Continuous Integration and Continuous Deployment (CI/CD) are essential practices in modern DevOps. They help teams automate code building, testing, and deployment so that software can be delivered faster and more reliably.

In this blog, we will learn how to build a complete CI/CD pipeline using GitHub Actions to automatically test and deploy an application whenever code is pushed to a repository.

What is CI/CD?

Continuous Integration (CI) ensures that every code change is automatically tested and validated before merging.

Continuous Deployment (CD) automatically deploys the tested code to a server or cloud platform.

A typical CI/CD pipeline performs these steps:

Code push to repository
Install dependencies
Run tests
Build application
Deploy to server or cloud

GitHub Actions helps automate all these steps.

What is GitHub Actions?

GitHub Actions is a CI/CD automation tool built directly into GitHub. It allows developers to create workflows that automatically run when events occur in a repository.

For example:

When code is pushed
When a pull request is created
When a release is published

These workflows are defined in YAML files inside the repository.

Project Structure

A GitHub Actions workflow is stored in the following directory:

.github/workflows/

Example:

my-project
│
├── src
├── package.json
├── tests
└── .github
    └── workflows
        └── ci-cd.yml

Step 1: Create a Workflow File

Create a workflow file:

.github/workflows/ci-cd.yml

This file will define the entire CI/CD pipeline.

Example workflow:

name: CI/CD Pipeline

on:
  push:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout Code
        uses: actions/checkout@v3

      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'

      - name: Install Dependencies
        run: npm install

      - name: Run Tests
        run: npm test

      - name: Build Application
        run: npm run build

Whenever code is pushed to the main branch, the workflow will automatically run.

Step 2: Add Deployment Step

Now we extend the pipeline to deploy the application automatically.

Example deployment to a Linux server using SSH:

      - name: Deploy to Server
        uses: appleboy/ssh-action@master
        with:
          host: ${{ secrets.SERVER_IP }}
          username: ${{ secrets.SERVER_USER }}
          key: ${{ secrets.SERVER_SSH_KEY }}
          script: |
            cd /var/www/app
            git pull origin main
            npm install
            pm2 restart app

This step connects to the server and updates the application.

Step 3: Configure GitHub Secrets

Sensitive information like SSH keys should never be stored directly in code.

Instead, use GitHub Secrets.

Go to:

Repository → Settings → Secrets → Actions

Add secrets like:

SERVER_IP
SERVER_USER
SERVER_SSH_KEY

These secrets are securely used in the workflow.

Step 4: Pipeline Execution

Once everything is configured:

Push code to GitHub
GitHub Actions triggers the workflow
The pipeline runs automatically
Code gets tested, built, and deployed

You can monitor the pipeline in:

Repository → Actions tab

Each workflow run shows logs for debugging and monitoring.

Best Practices for CI/CD Pipelines

To make your pipelines reliable and secure, follow these best practices:

Run automated tests

Always ensure tests pass before deployment.

Use secrets for credentials

Never hardcode passwords or keys.

Keep pipelines fast

Cache dependencies to reduce build time.

Use separate environments

Deploy to staging before production.

Add notifications

Notify teams when builds fail.

Benefits of Using GitHub Actions

Using GitHub Actions for CI/CD offers several advantages:

Built directly into GitHub
Easy YAML-based configuration
Supports thousands of integrations
Scales automatically
Free tier available for many projects

It enables teams to focus more on development and less on manual deployment tasks.

Conclusion

CI/CD pipelines are the backbone of modern DevOps workflows. By using GitHub Actions, developers can automate testing, building, and deployment directly from their repositories.

With just a few lines of configuration, you can build a fully automated CI/CD pipeline that ensures faster releases, fewer errors, and more reliable deployments.

As your projects grow, you can extend the pipeline with additional stages such as security scanning, container builds, and Kubernetes deployments.

Devopstick Blog

How to Build a Complete CI/CD Pipeline using GitHub Actions

How to Build a Complete CI/CD Pipeline using GitHub Actions