CI/CD Pipelines (GitHub Actions)

In modern software development, delivering applications quickly and reliably is important. CI/CD pipelines help automate the process of building, testing, and deploying applications.

A well-designed CI/CD pipeline ensures that every code change is automatically tested and ready for deployment, reducing errors and saving time.

With GitHub Actions, you can create automated workflows that run whenever you push code, making development faster and more consistent.

? In simple terms, CI/CD using GitHub Actions helps you automate your development process, improve code quality, and deliver updates faster.

What is CI/CD ?

CI/CD stands for Continuous Integration and Continuous Delivery/Deployment. It is a modern DevOps practice used to automate software development and release processes.

Continuous Integration (CI): In CI, developers frequently push code to a shared repository. Every change is automatically:

Built
Tested

? This helps detect bugs early and ensures code stability.

Continuous Deployment/Delivery (CD): After successful CI:

Application is automatically prepared and deployed to staging or production environments
Releases become faster, safer, and more consistent

? CD ensures your application is always ready for production deployment.

Simple Real-World CI/CD Flow

Developer pushes code to GitHub
GitHub Actions triggers workflow automatically
Application is built using tools like Maven
Automated tests are executed
Docker image is created
Application is deployed to Kubernetes

Example (GitHub Actions Steps)

- name: Build Application
  run: mvn clean package

- name: Run Tests
  run: mvn test

- name: Build Docker Image
  run: docker build -t myapp:latest .

? This pipeline runs automatically every time new code is pushed.

Why Automation is Important

Automation is a core part of modern DevOps because it improves speed, accuracy, and consistency in software delivery.

Reduces human errors in deployment
Speeds up release cycles
Ensures consistent builds across all environments
Detects bugs early in development
Improves developer productivity
Enables fast and reliable software delivery

? In simple words, automation makes the software delivery process faster, safer, and more scalable.

Difference Between CI vs CD

Feature	Continuous Integration (CI)	Continuous Delivery / Deployment (CD)
Purpose	Integrates code changes and runs automated tests	Automates application release and deployment
Stage in Pipeline	Early stage (development phase)	Final stage (release and production)
Main Focus	Code quality, build stability, and testing	Fast, safe, and reliable delivery to users
Key Activities	Code build, unit testing, integration testing	Packaging, deployment, infrastructure updates
Common Tools	GitHub Actions, Jenkins, Maven, JUnit	Docker, Kubernetes, ArgoCD, Helm
Output	Verified and tested build artifact	Running application in staging or production

GitHub Actions Overview

GitHub Actions is a powerful built-in CI/CD automation tool provided by GitHub. It allows developers to automate their software workflows directly inside a GitHub repository without needing external tools.

With GitHub Actions, you can automate tasks like building code, running tests, and deploying applications whenever specific events occur.

GitHub Actions is widely used for:

Build automation (compiling and packaging code)
Testing automation (unit & integration tests)
Deployment automation (deploying to cloud or Kubernetes)

Trigger Events in GitHub Actions : Workflows are automatically triggered based on events such as:

push → When code is pushed to repository
pull_request → When a pull request is created or updated
release → When a new release is published

? These triggers help automate CI/CD pipelines without manual intervention.

Workflow File (.github/workflows)

GitHub Actions workflows are defined using YAML files stored inside the repository.

Path :

.github/workflows/ci-cd.yml

Key Components of a Workflow

name → Name of the workflow
on → Events that trigger the workflow
jobs → Set of tasks to run
steps → Individual actions or commands

? This structure defines how your CI/CD pipeline executes automatically.

Example Workflow Structure

Below is a simple and real-world CI pipeline example:

name: CI Pipeline

on:
  push:
    branches: ["main"]

jobs:
  build:
    runs-on: ubuntu-latest

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

      - name: Set up Java
        uses: actions/setup-java@v3
        with:
          java-version: '17'

      - name: Build Project
        run: mvn clean package

      - name: Run Tests
        run: mvn test

Build Pipeline (Code → Image)

The build pipeline is the first stage in a CI/CD workflow. It converts source code into a runnable and deployable application.

This step ensures that the application compiles successfully and is ready for testing and deployment.

What Build Pipeline Does

Checks out source code from the repository
Compiles the application code
Resolves dependencies
Packages the application into build artifacts like JAR, WAR, or executable files

? The main goal is to produce a stable and deployable build.

Example (Java Build with Maven)

- name: Build Application
  run: mvn clean package

Test Pipeline (Quality Assurance Stage)

The test pipeline runs automatically after the build stage to ensure that the application is working correctly.

It validates the application before deployment and helps catch issues early in the development cycle.

What Test Pipeline Includes

Unit testing (testing individual components)
Integration testing (testing combined modules)
Automated test execution
Failure detection before deployment

? This ensures that only stable and tested code moves forward in the pipeline.

Example (Run Tests)

- name: Run Tests
  run: mvn test

Docker Image Build & Push

After the application is successfully built and tested, the next step in the CI/CD pipeline is to containerize the application using Docker.

This step ensures that the application runs consistently across all environments like development, staging, and production.

What This Step Does

Builds a Docker image using a Dockerfile
Tags the image for version control (e.g., v1, latest)
Pushes the image to a container registry

? This makes the application portable and deployment-ready.

Popular Container Registries

Docker Hub
AWS Elastic Container Registry (ECR)
Google Container Registry (GCR)

Example (Build & Push Docker Image)

- name: Build Docker Image
  run: docker build -t username/myapp:v1 .

- name: Login to Docker Hub
  run: echo "${{ secrets.DOCKER_PASSWORD }}" | docker login -u "${{ secrets.DOCKER_USERNAME }}" --password-stdin

- name: Push Docker Image
  run: docker push username/myapp:v1

Deployment Pipeline to Kubernetes

The final stage of a CI/CD pipeline is deploying the application to a Kubernetes cluster, which provides a scalable and production-ready environment.

This step ensures that your application runs reliably across different environments with minimal manual effort.

What This Step Does

Deploys application using Kubernetes YAML configuration files
Performs rolling updates for zero downtime deployments
Manages scaling automatically based on load
Supports deployment to staging or production environments

? This ensures high availability, scalability, and production stability.

Example (GitHub Actions)

- name: Set up Kubeconfig
  run: |
    mkdir -p $HOME/.kube
    echo "${{ secrets.KUBE_CONFIG }}" > $HOME/.kube/config

- name: Deploy to Kubernetes
  run: kubectl apply -f deployment.yaml

Environment Variables & Secrets in CI/CD

CI/CD pipelines often require sensitive information such as API keys, database credentials, and authentication tokens.

Instead of hardcoding them in the codebase, GitHub Actions provides Secrets Management to securely store and access them.

Examples of Secrets

DATABASE_URL
DOCKER_USERNAME
DOCKER_PASSWORD
API_KEYS

Common Environments

Development (dev)
Staging
Production

? This helps manage configurations safely across different environments.

Example (Environment Variables)

env:
  APP_ENV: production

Using Secrets

- name: Login to Docker Hub
  run: echo "${{ secrets.DOCKER_PASSWORD }}" | docker login -u "${{ secrets.DOCKER_USERNAME }}" --password-stdin

Complete CI/CD Pipeline Overview

The CI/CD pipeline represents the end-to-end automation process that takes code from development to production deployment using GitHub Actions.

Developer Push → GitHub Actions → Build → Test → Docker Image → Push → Kubernetes Deployment

Developer Push : Developer pushes code to GitHub repository.
GitHub Actions Trigger : Workflow automatically starts after code push.
Build Stage : Code is compiled and packaged into a deployable file (JAR/WAR).
Test Stage : Automated tests run to check code quality and bugs.
Docker Image Creation : Application is containerized into a Docker image.
Push to Registry : Docker image is pushed to registry (Docker Hub / AWS ECR / GCR).
Kubernetes Deployment : Final image is deployed to Kubernetes for production use.

Complete GitHub Actions Workflow Example

This shows how a real-world CI/CD pipeline works from code to deployment.

name: CI/CD Pipeline

on:
  push:
    branches: ["main"]

jobs:
  build-test-deploy:
    runs-on: ubuntu-latest

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

      - name: Set up JDK
        uses: actions/setup-java@v3
        with:
          java-version: '17'

      - name: Build Application
        run: mvn clean package

      - name: Run Tests
        run: mvn test

      - name: Build Docker Image
        run: docker build -t username/myapp:latest .

      - name: Login to Docker Hub
        run: echo "${{ secrets.DOCKER_PASSWORD }}" | docker login -u "${{ secrets.DOCKER_USERNAME }}" --password-stdin

      - name: Push Docker Image
        run: docker push username/myapp:latest

      - name: Deploy to Kubernetes
        run: kubectl apply -f deployment.yaml

Conclusion

CI/CD pipelines using GitHub Actions automate the entire software delivery lifecycle — from code commit to production deployment.

They ensure:

Faster development cycles
Reliable and consistent deployments
Reduced manual errors
Improved scalability and software quality

? In modern DevOps, CI/CD is essential for building and deploying applications efficiently at scale.