DEV Community: Nabin Ale

SSH in Linux

Nabin Ale — Sat, 25 Jul 2026 10:44:06 +0000

What is SSH in Linux?

SSH means Secure Shell. It is a safe way to connect to another
computer over a network.

Why do we use SSH?

We use SSH to:

Logging into a remote Linux server
Run commands from far away
Send and receive files safely (using scp or sftp)
Managing cloud servers (AWS, Azure, DigitalOcean, etc.)
Setting up secure tunnels (port forwarding)

Does SSH Only Work on Linux?

No. SSH works on many operating systems.
✅ Linux
✅ Windows
✅ macOS

For example, you can use a Windows laptop to connect to a Linux server by opening PowerShell or Command Prompt and typing:

ssh alice@192.168.1.10

You can also connect from macOS to Linux. If Windows has an SSH server installed, you can even connect to a Windows computer using SSH.

This means SSH is a cross-platform tool that works on different operating systems.

Real-Life Example

One of the use case:

Imagine you are at home, but your office computer is turned on.
Without driving to the office, you can use SSH to connect to that
computer and do your work. It is like using a secure remote control for
your computer.

Installing SSH

To use SSH, you need to install the OpenSSH package. It provides both the SSH client and the SSH server.

On Ubuntu or Debian

sudo apt update
sudo apt install openssh-client openssh-server

To start the SSH service, use:

sudo systemctl start sshd

Note: If you see this error while starting the SSH service:
Failed to start sshd.service: Unit sshd.service not found.
To fix this issue, see this guide: click here

To make the SSH service start automatically every time the computer boots:

sudo systemctl enable sshd

Check the SSH Service Status

To check if the SSH service is running, use:

sudo systemctl status sshd

If the service is running, you should see active (running) in the output.

Basic SSH Command

ssh username@server_ip

Example:

ssh alice@192.168.1.10

After connecting, you'll usually be prompted for a password (unless you're using SSH keys).

Example session

$ ssh alice@192.168.1.10
alice@192.168.1.10's password:
Welcome to Ubuntu!
alice@server:~$

Now you can run commands on the remote machine as if you were sitting in front of it.

SSH key authentication (optional)

Instead of using a password every time, you can use an SSH key pair.

Generate a key:

ssh-keygen

Copy the public key to the remote server:

ssh-copy-id username@hostname

Then log in without entering a password:

ssh username@hostname

Some useful SSH options:

Connect using a specific port:

ssh -p 2222 username@hostname

Use a specific private key:

ssh -i ~/.ssh/my_key username@hostname

Run a single command remotely:

ssh username@hostname "ls -l /home"

Secure file transfer

Copy a file to a remote server:

scp file.txt username@hostname:/home/username/

Copy a file from a remote server:

scp username@hostname:/home/username/file.txt

How SSH works

The SSH client (your computer) connects to the SSH server (remote computer).
They authenticate each other using a password or SSH keys.
An encrypted connection is established.
All commands and data are securely transmitted.

Why is SSH Safe?

✅ Can transfer files securely
✅ Supports password and key-based authentication
✅ Widely used on Linux and cloud servers
✅ SSH encrypts your data and communication. This means other people cannot easily read your passwords or commands while they travel over the internet.

Summary

SSH is a simple and secure tool for connecting to another
computer. It helps you work from anywhere while keeping your data safe.

How to Make Your Linux Mint Faster

Nabin Ale — Mon, 20 Jul 2026 06:26:20 +0000

Linux Mint is one of the best Linux operating systems. It is easy to use, stable, and works well on both old and new computers. But after using it for some time, you may notice that it becomes slow.

The good news is that you can make Linux Mint faster with a few simple steps. This guide will show you how.

1. Keep Linux Mint Updated

Updates fix bugs, improve speed, and keep your computer safe.

Open the Terminal and run:

sudo apt update
sudo apt upgrade

Restart your computer after the updates are finished.

2. Check Your Disk Space

If your hard drive is almost full, Linux Mint can become very slow.

Check your disk space by running:

df -h

If your / (root) partition is over 90% full, delete files you don't need.

Good things to remove include:

Old downloads
Large videos
ISO files
Files in the Trash

3. Remove Unused Packages

Linux keeps old packages that you may not need anymore.

Remove them with:

sudo apt autoremove

You can also clean the package cache:

sudo apt clean

4. Stop Apps from Starting Automatically

Some apps start every time you log in. This can slow down your computer.

Go to:

Menu → Startup Applications

Turn off apps that you do not need when your computer starts.

5. Check What Is Using Your Computer

Sometimes one program uses too much CPU or memory.

Install htop:

sudo apt install htop

Run it:

htop

If you see a program using a lot of CPU or RAM, close it if you do not need it.

6. Check Your RAM

To see how much memory is being used, run:

free -h

If your RAM is always full, try:

Closing unused programs
Opening fewer browser tabs
Upgrading your RAM if possible

7. Delete Large Files

Large files can quickly fill your drive.

Find files bigger than 1 GB:

find / -type f -size +1G 2>/dev/null

Delete or move files that you no longer need.

8. Use an SSD

If your computer still uses an HDD (Hard Disk Drive), changing to an SSD (Solid State Drive) can make a huge difference.

An SSD helps your computer:

Start faster
Open apps faster
Copy files faster
Feel smoother

This is one of the best upgrades you can make.

9. Install the Right Graphics Driver

If moving windows or watching videos feels slow, install the recommended graphics driver.

Open:

Menu → Driver Manager

Install the driver that Linux Mint recommends.

10. Turn Off Extra Effects

Desktop animations look nice, but they can slow down older computers.

Go to:

System Settings → Effects

Turn off or reduce animations.

11. Restart Your Computer

Restarting your computer can fix many small problems.

It clears temporary files and finishes installing updates.

12. Check Your Hard Drive Health

A damaged hard drive can make your computer slow.

Install SMART tools:

sudo apt install smartmontools

Check your drive:

sudo smartctl -H /dev/sda

If your drive has problems, back up your important files and consider replacing it.

Useful Commands

Check disk space

df -h

Check memory

free -h

Monitor CPU and RAM

htop

Clean package cache

sudo apt clean

Remove unused packages

sudo apt autoremove

Final Thoughts

Linux Mint is already fast, but a little maintenance helps keep it running smoothly.

Remember these simple tips:

Keep Linux Mint updated.
Keep enough free disk space.
Delete files you no longer need.
Remove unused packages.
Disable unnecessary startup apps.
Check your CPU and RAM usage.
Upgrade to an SSD if possible.

Following these steps will help your Linux Mint stay fast and reliable for a long time.

Try to keep at least 15–20 GB of free space.

Easy set up of PHP Xdebug on VS Code

Nabin Ale — Sat, 04 Jul 2026 09:01:52 +0000

If you want to debug your PHP code in VS Code, Xdebug is the best tool. This guide will help you set it up on Ubuntu in a few minutes.

Step 1: Check Your PHP Version

Open a terminal and run:

php -v

Example output:

PHP 8.2.12 (cli)

Remember your PHP version.

Step 2: Install Xdebug

Install Xdebug using:

sudo apt update
sudo apt install php-xdebug

Or install the version-specific package if needed:

sudo apt install php8.2-xdebug

Check that it is installed:

php -m | grep xdebug

If you see xdebug, it is installed successfully.

Step 3: Configure Xdebug

Open the Xdebug configuration file:

sudo nano /etc/php/<your-php-version>/mods-available/xdebug.ini

Replace <your-php-version> with your PHP version (for example, 8.2).

Add these settings:

zend_extension=xdebug.so

xdebug.mode=debug
xdebug.start_with_request=yes
xdebug.client_host=127.0.0.1
xdebug.client_port=9003

Save the file.

Step 4: Restart PHP

If you use Apache:

sudo systemctl restart apache2

If you use PHP-FPM:

sudo systemctl restart php<your-php-version>-fpm

Step 5: Install the VS Code Extension

In VS Code:

Open Extensions.
Search for PHP Debug.
Install the extension by Xdebug.

Step 6: Create `launch.json`

Create a .vscode/launch.json file with this content:

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Listen for Xdebug",
      "type": "php",
      "request": "launch",
      "port": 9003
    }
  ]
}

Step 7: Start Debugging

Open your PHP project in VS Code.
Add a breakpoint.
Press F5 to start listening.
Run your PHP script or open your website.

VS Code will stop at your breakpoint.

Check That Xdebug Is Working

Run:

php -v

If you see something like with Xdebug v3.x.x, everything is ready.

Conclusion

That's it! You have successfully set up PHP Xdebug on Ubuntu with VS Code. You can now debug your PHP applications more easily and find issues faster.

Playwright and GitHub Actions - Run tests in CI

Nabin Ale — Mon, 16 Mar 2026 08:49:26 +0000

This blog post explains how to run Playwright UI tests in CI (Continuous Integration) using GitHub Actions.
Before you start, you need to have a basic knowledge of GitHub Actions, Playwright, and the Playwright Trace Viewer to better understand this blog. If you are not familiar with any of these topics, below are links to our blogs that explain each one:

By the end of this blog, you will be able to set up a CI workflow that automatically runs your Playwright UI tests whenever you push code to your repository. You will also learn how to get Playwright trace reports when tests fail, making it easier to debug and fix errors.

🤔 Why run tests on CI?

Tests are run on CI to ensure the code works properly in a clean and isolated environment every time a change is made. Here are some reasons:

1. Early bug detection:
CI runs tests automatically on every push or PR, so you find problems right when they're introduced, not days or weeks later when the context is gone and fixes are harder.

2. No more "Works on my machine":
CI runs your tests in a clean environment every time. If tests pass there, it means your code works in a standard setup, not just on your own computer.

3. Protect the main branch:
Tests on CI act like a gatekeeper. If something breaks, it doesn't get merged. This keeps the main (or master) branch deployable and stable.

4. Confidence to refactor and move fast:
When tests run automatically, you can refactor aggressively. If CI is green, you didn't break existing behavior. That confidence significantly speeds things up.

5. Better collaboration:
CI gives everyone on the team the same test results. This helps avoid confusion and makes it clear whether the code is working or not.

6. Automated process:
CI systems enable developers to save time and effort on testing.

📘 About the Project

In this blog, I have taken a simple application with a frontend built using Vue.js and a backend built using json-server(a fake REST API). The GitHub repository is available at: https://github.com/nabim777/momo-restro-list.git

This is a basic application that includes login and logout functionality. E2E tests are written using Playwright to verify the login feature. You can find the test scenarios here

🛠️ Running App Locally

Before setting up CI, let's run the application and tests locally.

1. Install dependencies

npm ci

2. Start the frontend and backend servers

npm run serve              # Start frontend
npm run backend            # Start backend

🧪 Running UI Tests Locally

NOTE: Make sure both the frontend and backend are running before running the tests.

To run the UI tests locally, use the following command:

npx playwright install chromium
npm run test:e2e tests

⚙️ Setting Up CI in GitHub Actions

After verifying the app locally, the next step is to set up CI using GitHub Actions. First, create a file named ci.yml in your project using the following folder structure:

📦momo-restro-list
┗ 📂.github
┃ ┣ 📂workflows
┃ ┃ ┗ 📜ci.yml

Then, add the following code to the ci.yml file.

name: CI

on:
  push:
    branches:
      - master
  pull_request:
    branches:
      - master
  workflow_dispatch:

jobs:
  e2e-UI-tests:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repo code
        uses: actions/checkout@v6

      - name: Set up node
        uses: actions/setup-node@v6
        with:
          node-version: 24.x

      - name: Install dependencies
        run: |
          npm ci
          npx playwright install chromium

      - name: JS lint
        run: |
          npm run lint || (echo "Linting failed! Please run 'npm run lint:fix' to fix the errors." && exit 1)

      - name: Run the project
        run: |
          npm run serve &
          npm run backend &

      - name: Wait for services
        run: |
          sudo apt-get install wait-for-it -y
          wait-for-it -h localhost -p 8080 -t 10
          wait-for-it -h localhost -p 3000 -t 10

      - name: Run UI tests
        id: test-ui
        run: npm run test:e2e tests

      - name: Upload trace results
        if: ${{ failure() && steps.test-ui.conclusion == 'failure' }}
        uses: actions/upload-artifact@v6
        with:
          path: |
            trace-results/*.zip
            retention-days: 30

🔍 What does this workflow do?

This GitHub Actions file runs when you push to the master branch or create a pull request to master.

It has one job called e2e-UI-tests with these steps:

Checkout repo code - Gets the project code from GitHub.
Set up node - Installs Node.js version 24.
Install dependencies - Installs the project dependencies and Playwright browsers.
JS lint - Runs the linter to check for code quality issues. If linting fails, it will print a custom error message and exit with a failure status.
Run the project - Starts the Vue app and the backend using json-server.
Wait for services - Waits for the frontend (port 8080) and backend (port 3000) to be ready.
Run UI tests - Runs the UI tests using Playwright.
Upload trace results - If the UI tests fail, it uploads the Playwright trace results as an artifact that can be downloaded from the GitHub Actions interface. The trace files will be retained for 30 days.

📥 How to Download and View Trace Files?

If your tests fail in CI, you can download the trace files to see what went wrong:

Go to your GitHub repository
Click on the Actions tab
Select the failed workflow run
Scroll down to the Artifacts section at the bottom of the page
Click on the artifact name to download the trace files (they will be in a .zip file)
Extract the downloaded .zip file
Open the trace file using one of these methods:
- Drag and drop the trace file into trace.playwright.dev
- Or run this command locally: npx playwright show-trace path/to/trace.zip

The trace viewer will show you step-by-step what happened during the test, including screenshots, network requests, and console logs.

📝 Conclusion

Using GitHub Actions to run your Playwright tests means your app is tested automatically in a clean environment every time you make changes. It helps find bugs early, makes teamwork easier, and keeps your project stable.

CI tests turn "hope it works" into "we know it works."

Helpful for keycloak script

Nabin Ale — Fri, 23 Aug 2024 06:49:08 +0000

Altogether I have found three method to set up keycloak can be used as the bash script. methods are:

1. Using Admin CLI bash command
2. By importing the json file
3. Using API (recommended)

1. Using Admin CLI command

NOTE: following command is for docker if keycloak is locally run then you can run command inside ''

a. Login

docker exec keycloak-keycloak-1 /bin/bash -c 'cd opt/keycloak/bin && bash kcadm.sh config credentials --server <keycloak-host> --realm master --user admin --password admin'

b. Create realm

docker exec keycloak-keycloak-1 /bin/bash -c 'cd opt/keycloak/bin && bash kcadm.sh create realms -s realm=<realm-name> -s enabled=true -o'

c. Create clients( here we get client-id )

docker exec keycloak-keycloak-1 /bin/bash -c "cd opt/keycloak/bin && bash kcadm.sh create clients -r opendesk -s clientId=nextcloud -s enabled=true -s 'redirectUris=[\"<nextcloud-host>/apps/user_oidc/code\"]' -s rootUrl=<nextcloud-host> -s 'attributes.\"backchannel.logout.url\"=<nextcloud-host>/apps/user_oidc/backchannel-logout/Keycloak' -s 'attributes.\"post.logout.redirect.uris\"=<nextcloud-host>/*' -s 'webOrigins=[\"<nextcloud-host>\"]' -s adminUrl=<nextcloud-host>"

d. Get secretId

docker exec keycloak-keycloak-1 /bin/bash -c 'cd opt/keycloak/bin && bash kcadm.sh get clients/<Client-ID> -r <realm-name> --fields secret'

e. OIDC configure (this is for user_oidc on nextcloud)

docker exec --user www-data nextcloud php ./occ user_oidc:provider Keycloak --clientid="nextcloud" \
--clientsecret="<secret-id>" --discoveryuri="<keycloak-host>/realms/<realm-name>/.well-known/openid-configuration" --scope="openid email profile"

2. By importing the json file

It simply by importing the json file in a realm with the help of import admin bash cli command

bash kc.sh export --dir <path-to-json-file> --realm <realm-name>

3. Using API

a. getting the acess token using api

following curlcommand will store the acess_token in variable MASTER_TOKEN

MASTER_TOKEN=$(curl --location --request POST <keycloak-host>/realms/master/protocol/openid-connect/token \
--header 'Content-Type: application/x-www-form-urlencoded' \
--data-urlencode 'client_id=admin-cli' \
--data-urlencode 'username=admin' \
--data-urlencode 'password=admin' \
--data-urlencode 'grant_type=password' | jq -r '.access_token')

b. Creating the realm using API

curl --silent --show-error -L -X POST "<keycloak-host>/admin/realms" \
--header "Content-Type: application/json" \
--header "Authorization: Bearer ""$MASTER_TOKEN" \
--data '{"realm":"opendesk","enabled":true}'

c. Creating the clients using API

curl -X POST \
  "https://keycloak.local/admin/realms/opendesk/clients" \
  --header "Authorization: Bearer ""$MASTER_TOKEN" \
  --header "Content-Type: application/json" \
  --data '{
    "clientId": "nextcloud",
    "enabled": true, 
    "redirectUris" : ["<nextcloud-host>/apps/user_oidc/code"],
    "rootUrl": "<nextcloud-host>",
    "attributes": {
     "backUsing Admin CLI bash commandchannel.logout.url": "<nextcloud-host>/apps/user_oidc/backchannel-logout/Keycloak"
    }
  }'

d. Get the secret id using API

SECRET=$(curl -X GET \
  "<keycloak-host>/admin/realms/opendesk/clients" \
  --header "Authorization: Bearer ""$MASTER_TOKEN" | jq -r '.[] | select(.clientId == "nextcloud") | .secret')

Factory Design Pattern

Nabin Ale — Mon, 20 May 2024 01:23:39 +0000

The Factory Design Pattern is a way to create objects without specifying the exact class of the object that will be created. It provides a method to create objects that can be overridden by subclasses to change the type of objects that will be created.

Understanding through Example

Let's use the Factory Design Pattern with an example involving a waiter, a cook, and the client in a restaurant setting. Here’s how the pattern works in this context:

a. Waiter: Acts as the Factory.
b. Cook: Represents the different types of objects that can be created.
c. Client: Requests a dish through the waiter.

Scenario

A client goes to a restaurant and asks the waiter for a specific dish (e.g., Momo or Pizza). The waiter takes the order and instructs the cook to prepare the dish. The client doesn't know the details of how the dish is prepared; they just get the dish.

Step-by-Step Example in TypeScript

Step 1: Define the Dish Interface

interface Dish {
    prepare(): void;
}

This interface defines a method prepare() that every dish must implement.

Step 2: Create Concrete Classes for Dishes

class Momo implements Dish {
    prepare(): void {
        console.log("Preparing Momo");
    }
}

class Pizza implements Dish {
    prepare(): void {
        console.log("Preparing Pizza");
    }
}

These classes implement the Dish interface and provide their own version of the prepare method.

Step 3: Create the Waiter (Factory)

class Waiter {
    static orderDish(dishType: string): Dish | null {
        switch (dishType) {
            case 'Momo':
                return new Momo();
            case 'Pizza':
                return new Pizza();
            default:
                return null;
        }
    }
}

The Waiter class has a static method orderDish that takes a string parameter dishType and returns an instance of the corresponding dish.

Step 4: Client Request a Dish

const dish1: Dish | null = Waiter.orderDish('Momo');
if (dish1) {
    dish1.prepare();  // Output: Preparing Momo
}

const dish2: Dish | null = Waiter.orderDish('Pizza');
if (dish2) {
    dish2.prepare();  // Output: Preparing Pizza
}

The client uses the Waiter to order dishes by specifying the dish type. The Waiter (factory) handles the creation of the dish, and the client receives a dish ready to be prepared.

Explanation

- Dish Interface: This defines a common interface that all dishes must follow.
- Concrete Classes (Momo, Pizza): Implement the Dish interface and provide specific implementations for the prepare method.
- Waiter (Factory): Contains the orderDish method, which decides which dish to create based on the given type.
- Client: Requests dishes from the Waiter without needing to know the details of how the dishes are created.

Full given Example in TypeScript look like this

// Dish Interface
interface Dish {
    prepare(): void;
}

// Concrete Momo Class
class Momo implements Dish {
    prepare(): void {
        console.log("Preparing Momo");
    }
}

// Concrete Pizza Class
class Pizza implements Dish {
    prepare(): void {
        console.log("Preparing Pizza");
    }
}

// Waiter (Factory) Class
class Waiter {
    static orderDish(dishType: string): Dish | null {
        switch (dishType) {
            case 'Momo':
                return new Momo();
            case 'Pizza':
                return new Pizza();
            default:
                return null;
        }
    }
}

// Client Code
const dish1: Dish | null = Waiter.orderDish('Momo');
if (dish1) {
    dish1.prepare();  // Output: Preparing Momo
}

const dish2: Dish | null = Waiter.orderDish('Pizza');
if (dish2) {
    dish2.prepare();  // Output: Preparing Pizza
}

To execute the code within a web browser click here

Why use the Factory Design Pattern?

1. Decoupling: It decouples the client code from the object creation process. It separates the part of the code that asks for an object from the part that makes the object. This way, the code that needs the object doesn't have to know exactly how the object is made
2. Flexibility: It allows the code to be more flexible and easier to extend. New classes can be added without changing the existing client code.
3. Single Responsibility: The Factory Design Pattern follows the Single Responsibility Principle by making sure that each class has only one job

Summary

In this example, the client interacts only with the Waiter (factory), asking for specific dishes. The Waiter then decides which type of dish to create and returns it to the client. This pattern decouples the client from the creation logic, making the system more modular and easier to maintain.

Introduction to GitHub Actions - CI & CD

Nabin Ale — Thu, 25 Apr 2024 05:06:24 +0000

GitHub Actions is an automation and CI/CD (Continuous Integration/Continuous Delivery or Deployment) service provided by GitHub, allowing us to automate our software development processes or workflows, from building and testing code to deploying it to different environments. It's an effective tool that can enhance software quality and save our time.

Some features of GitHub Actions:

It allows you to automate various stages of SDLC (Software Development Life Cycle), such as building, testing, deploying, and releasing software.
It simplifies CI/CD integration, facilitating seamless DevOps practices.

Components of GitHub Actions:

Workflows
Events
Jobs
Steps
Actions
Runners

1. Workflows

Workflows are automated procedures that you add to your repository. They will run when triggered by an event in your repository, or they can be triggered manually, or at a defined schedule. They can be used to build, test, package, release, or deploy a project on GitHub.

2. Events

Events are specific activities such as code push, pull request creation, issue creation, comments on pull requests or issues, etc., that trigger a workflow.

3. Jobs

Jobs are sets of steps that are executed in the same runner. A workflow with multiple jobs will run in parallel by default, but it can be configured so that jobs run sequentially.

4. Steps

A step is an individual task that can run the commands in a job. These can be actions or commands.

5. Actions

Actions are the standalone commands for the GitHub Actions platform that perform complex but frequently repeated tasks. Actions help to reduce repetitive code in workflows.

6. Runner

A runner is a GitHub Actions server where our workflows run. It listens for available jobs, runs multiple jobs at a time, and reports the progress, logs, and results back to GitHub. GitHub hosted runners are based on Ubuntu, Linux, Microsoft Windows, and Mac OS.

Note:
One event can trigger many workflows, a workflow can contain many jobs, and a job can contain many steps.

Process in GitHub Actions:

Getting started:

Before we dive into an example, make sure you have a repository where you want to set up your CI/CD workflow. If you don't have one, create a new repository, for example, named action-hero.

Step 1: Clone your repository into your system

git clone <your_github_repo_url>

Step 2: Go to path action-hero and create a folder named .github

cd action-hero
mkdir .github

Step 3: Go to path .github and create a folder named workflows

cd .github
mkdir workflows

Step 4: Inside the folder workflows, create a file named hello_world.yml

cd workflows
touch hello_world.yml

Our file structure should look like this:

📦action-hero
┗ 📂.github
┃ ┣ 📂workflows
┃ ┃ ┗ 📜hello_world.yml

Step 5: Add the following code snippet to your hello_world.yml file:

name: Hello world workflow

on:
  push:
    branches:
      - main
  pull_request:

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout repository
      uses: actions/checkout@v2

    - name: Print a message
      run: echo "Hello, GitHub Actions!"

In this example:

The workflow is triggered by a push event on the main branch and on pull requests.
The job named "build" runs on the latest version of Ubuntu.
The first step checks out the repository using the actions/checkout action.
The second step simply prints a message using the echo command.

Step 6: Create a branch, push your changes, and open a pull request to the main branch.

GitHub Actions activity:

The image above is the output from our GitHub Actions workflow run. It shows that the workflow was successful and completed the Hello world workflow job, which consisted of two steps: Checkout repository and Print a message.

The step Print a message executed the command echo "Hello, GitHub Actions!", resulting in the output Hello, GitHub Actions! being displayed in the workflow log.

Conclusion

In this blog, we've explored GitHub Actions, an automation and CI/CD service provided by GitHub. We've learned about its key components and how they work together to automate software development workflows.

GitHub Actions enables us to automate tasks like building, testing, and deploying code, leading to improved software quality and time savings.

With a practical example, we've seen how easy it is to set up a basic workflow.

In summary, GitHub Actions is a powerful tool for speedy development processes, making it easier to deliver high-quality software efficiently.

Set SSH keys for Github in ubuntu or linux mint

Nabin Ale — Sat, 14 Oct 2023 01:50:52 +0000

Github Installation

sudo apt install ppa-purge
sudo ppa-purge ppa:git-core/ppa
sudo apt purge git

Configuring the git

git config --global user.name "<your_github_username>"
git config --global user.email <your_email@example.com>

NOTE: To check the user.name and user.email set or not
git config -l

Keys generation

Step 1: Generate new ssh keys

ssh-keygen -t ed25519 -C "your_email@example.com"

Step 2: Add a new ssh keys

cat ~/.ssh/id_ed25519.pub

Output will be something like this

ssh-ed25519
NAAAC3Nza*********jPRyyNVIdgj
your_email@example.com

Step 3: Copy output and paste in setting > SSH and GPG keys > new SSH key

DEV Community: Nabin Ale

SSH in Linux

What is SSH in Linux?

Why do we use SSH?

Does SSH Only Work on Linux?

Real-Life Example

Installing SSH

Basic SSH Command

SSH key authentication (optional)

Some useful SSH options:

Secure file transfer

How SSH works

Why is SSH Safe?

Summary

How to Make Your Linux Mint Faster

1. Keep Linux Mint Updated

2. Check Your Disk Space

3. Remove Unused Packages

4. Stop Apps from Starting Automatically

5. Check What Is Using Your Computer

6. Check Your RAM

7. Delete Large Files

8. Use an SSD

9. Install the Right Graphics Driver

10. Turn Off Extra Effects

11. Restart Your Computer

12. Check Your Hard Drive Health

Useful Commands

Check disk space

Check memory

Monitor CPU and RAM

Clean package cache

Remove unused packages

Final Thoughts

Easy set up of PHP Xdebug on VS Code

Step 1: Check Your PHP Version

Step 2: Install Xdebug

Step 3: Configure Xdebug

Step 4: Restart PHP

Step 5: Install the VS Code Extension

Step 6: Create launch.json

Step 7: Start Debugging

Check That Xdebug Is Working

Conclusion

Playwright and GitHub Actions - Run tests in CI

🤔 Why run tests on CI?

📘 About the Project

🛠️ Running App Locally

🧪 Running UI Tests Locally

⚙️ Setting Up CI in GitHub Actions

🔍 What does this workflow do?

📥 How to Download and View Trace Files?

📝 Conclusion

Helpful for keycloak script

1. Using Admin CLI command

2. By importing the json file

3. Using API

Factory Design Pattern

Understanding through Example

Scenario

Step-by-Step Example in TypeScript

Explanation

Why use the Factory Design Pattern?

Summary

Introduction to GitHub Actions - CI & CD

Some features of GitHub Actions:

Components of GitHub Actions:

1. Workflows

2. Events

3. Jobs

4. Steps

5. Actions

6. Runner

Process in GitHub Actions:

Getting started:

GitHub Actions activity:

Conclusion

Set SSH keys for Github in ubuntu or linux mint

Github Installation

Configuring the git

Step 6: Create `launch.json`