Latest Posts

Implement a CI/CD pipeline for a sample app

Posted on by Zubair Shaik

Loading

Implementing a CI/CD Pipeline for a Sample App: A Detailed Guide

Introduction to CI/CD and Its Importance

Continuous Integration (CI) and Continuous Delivery (CD) are essential practices in modern software development. They allow development teams to release code frequently and reliably by automating the processes of building, testing, and deploying applications. In simple terms, CI involves automatically merging code changes from multiple developers into a shared codebase, while CD ensures that these changes can be automatically deployed to production or staging environments.

The main goals of a CI/CD pipeline are:

  • Automate repetitive tasks such as building, testing, and deploying.
  • Improve collaboration between development and operations teams (DevOps).
  • Reduce errors by ensuring that new code passes automated tests before it’s integrated.
  • Increase speed by enabling faster feedback and continuous deployment.

In this tutorial, we’ll walk through setting up a CI/CD pipeline for a sample application. We will use GitHub Actions for CI/CD automation, but the concepts can be easily applied to other CI/CD tools like Jenkins, GitLab CI, CircleCI, or Travis CI.

Prerequisites

Before starting, ensure that you have the following:

  1. A GitHub repository for your app.
  2. A sample app (we’ll use a simple Node.js app for demonstration).
  3. A basic understanding of Git and version control.
  4. An account on Docker Hub (optional for containerization).
  5. Basic knowledge of CI/CD concepts.

1. Overview of the CI/CD Pipeline

A typical CI/CD pipeline consists of several stages. Below is an outline of a basic pipeline for a sample app:

  1. Code Commit (CI):
    • Developers push code changes to a version control repository (e.g., GitHub).
    • A trigger is set up to automatically start the pipeline on code changes.
  2. Build:
    • The pipeline automatically builds the app from the latest code base.
  3. Test:
    • Automated tests (unit tests, integration tests) are executed to validate the changes.
  4. Containerization (optional):
    • Docker can be used to package the app and its dependencies into a container, making it portable and consistent across environments.
  5. Deploy:
    • The pipeline automatically deploys the app to a staging or production environment (e.g., AWS, Azure, Google Cloud, or on-prem servers).
  6. Monitor:
    • After deployment, monitoring tools ensure that the app works as expected in the production environment.

2. Setting Up the Sample App

For this tutorial, we’ll use a Node.js app as our sample project. Let’s first set up a simple app. You can clone this GitHub repository or create your own from scratch.

Step 1: Create a Node.js Application

  1. Initialize a Node.js project:
    • Open your terminal and create a new directory.
    mkdir sample-app cd sample-app npm init -y
    • This command initializes a new package.json file.
  2. Install dependencies:
    • For this tutorial, we’ll install express to create a simple web server.
    npm install express
  3. Create the app:
    • Create a file called index.js in the root of the project folder with the following content:
    const express = require('express'); const app = express(); const port = 3000; app.get('/', (req, res) => { res.send('Hello, CI/CD!'); }); app.listen(port, () => { console.log(`App listening at http://localhost:${port}`); });
    • This code creates a simple Express app that listens on port 3000.
  4. Run the app locally:
    • Run the app to ensure everything works as expected.
    node index.js
  5. Test the app:
    • Open your browser and go to http://localhost:3000. You should see “Hello, CI/CD!” displayed on the page.

Step 2: Push the App to GitHub

  1. Initialize a Git repository: git init
  2. Add the files to the repository: git add . git commit -m "Initial commit of sample app"
  3. Create a GitHub repository:
    • Go to GitHub and create a new repository (e.g., sample-app).
  4. Push the app to GitHub:
    • Push the code to your newly created GitHub repository:
    git remote add origin https://github.com/your-username/sample-app.git git push -u origin master

3. Creating a CI/CD Pipeline with GitHub Actions

Now that we have a Node.js app in a GitHub repository, let’s create a CI/CD pipeline using GitHub Actions. GitHub Actions provides a powerful, flexible, and free CI/CD platform built right into GitHub.

Step 1: Create a Workflow File

  1. Create a .github directory in the root of your project: mkdir -p .github/workflows
  2. Create a new workflow YAML file:
    • Create a file called ci.yml under .github/workflows/.
    • This file will define the steps of your CI/CD pipeline.

Step 2: Define the Pipeline Stages

Edit the ci.yml file with the following content:

name: CI/CD Pipeline

on:
  push:
    branches:
      - master

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    # Step 1: Checkout the code from GitHub
    - name: Checkout code
      uses: actions/checkout@v2

    # Step 2: Set up Node.js
    - name: Set up Node.js
      uses: actions/setup-node@v2
      with:
        node-version: '14'

    # Step 3: Install dependencies
    - name: Install dependencies
      run: npm install

    # Step 4: Run unit tests
    - name: Run tests
      run: npm test

    # Step 5: Build the app
    - name: Build the app
      run: npm run build

    # Step 6: Deploy to production (can be modified based on your environment)
    - name: Deploy to Production
      run: |
        echo "Deploying to production..."
        # Here you would add your deployment script, such as uploading to AWS, GCP, etc.

Explanation of the CI Workflow:

  • Trigger (on): The pipeline runs on any push to the master branch.
  • Jobs: In this case, we have a single build job that will run on the latest version of Ubuntu.
  • Steps:
    • Checkout code: The actions/checkout action checks out your code from the GitHub repository.
    • Set up Node.js: The actions/setup-node action sets up the required version of Node.js (version 14 in this case).
    • Install dependencies: This step runs npm install to install the app’s dependencies.
    • Run tests: This step will run any defined tests (ensure you have a test setup in your project).
    • Build the app: If applicable, this step runs the build process.
    • Deploy to Production: In this step, you can modify the script to deploy the app. For example, you could add a script to deploy the app to AWS Elastic Beanstalk, Heroku, or another hosting service.

4. Add Automated Tests

To fully utilize the CI pipeline, you should add automated tests to ensure that the code works correctly before deployment. For this, you can use a testing framework like Jest.

Step 1: Install Jest

npm install --save-dev jest

Step 2: Add a Test

Create a folder called __tests__ and add a test file called app.test.js:

const request = require('supertest');
const app = require('../index');

describe('GET /', () => {
  it('should return "Hello, CI/CD!"', async () => {
    const response = await request(app).get('/');
    expect(response.text).toBe('Hello, CI/CD!');
    expect(response.statusCode).toBe(200);
  });
});

Step 3: Run Tests Locally

To run tests locally, you can use the following command:

npx jest

5. Push Changes to GitHub and Run the Pipeline

Now that everything is set up, it’s time to push changes to GitHub and watch the CI/CD pipeline run.

  1. Commit changes: git add . git commit -m "Add CI/CD pipeline" git push origin master
  2. Check the pipeline:
    • Once you push to GitHub, the GitHub Actions pipeline will automatically trigger.
    • You can monitor the pipeline’s progress from the Actions tab in your GitHub repository.

6. Deploying to Production (Optional)

In this step, you would configure the Deploy to Production part of the pipeline. For example, if you wanted to deploy the app to AWS Elastic Beanstalk, you could use the AWS CLI to automate the deployment. Here’s an example deployment script:

aws configure set aws_access_key_id YOUR_ACCESS_KEY
aws configure set aws_secret_access_key YOUR_SECRET_KEY
aws configure set region us-west-2
eb init -p node.js --region us-west-2 sample-app
eb deploy

You would need to add your deployment credentials as GitHub Secrets for security.

7. Monitor and Scale the Application

Once the app is deployed, it’s essential to monitor the application for performance and errors. You can integrate monitoring tools like AWS CloudWatch, Datadog, or New Relic to keep track of your app’s health.

Additionally, as your app grows, you may want to scale the infrastructure automatically based on traffic. Services like AWS Elastic Beanstalk, Kubernetes, or Docker Swarm can help manage the scaling of your application.

Conclusion

Implementing a CI/CD pipeline for your sample app can drastically improve your development workflow by automating the build, test, and deployment process. With GitHub Actions, you can easily set up a pipeline that integrates with your GitHub repository and runs automatically every time you push new changes.

Leave a Reply

Your email address will not be published. Required fields are marked *