Continuous Integration/Continuous Deployment (CI/CD) with Git and GitHub

Introduction

Continuous Integration (CI) and Continuous Deployment (CD) are essential practices for modern software development. CI automates the integration of code changes from multiple contributors into a shared repository, while CD automates the deployment of those changes to production environments. This tutorial will guide you through setting up a CI/CD pipeline using Git and GitHub Actions.

Prerequisites

Before you begin, ensure you have the following:

• A GitHub account
• Basic knowledge of Git and version control
• A sample repository with some code (e.g., a simple Node.js application)

Setting Up Your Repository

1. Create a New Repository:

   • Go to GitHub and create a new repository.
   • Name your repository, e.g., ci-cd-demo.
   • Initialize the repository with a README file.

2. Clone the Repository Locally:

   git clone https://github.com/your-username/ci-cd-demo.git
   cd ci-cd-demo
   

3. Add Sample Code:

   • Create a simple Node.js application or any other language you prefer.
   • Commit your changes:

     git add .
     git commit -m "Initial commit"
     git push origin main
     

Configuring GitHub Actions

GitHub Actions is a powerful CI/CD platform that allows you to automate workflows directly in your repository.

1. Create a Workflow File

1. Navigate to the Actions Tab:

   • Go to your repository on GitHub.
   • Click on the "Actions" tab.

2. Set Up a New Workflow:

   • Click on "New workflow."
   • Choose "Node.js application" or select "set up a workflow yourself" for custom configuration.

3. Configure the Workflow:

   Create a file named .github/workflows/nodejs.yml with the following content:

   name: Node.js CI/CD
   
   on:
     push:
       branches: [ main ]
     pull_request:
       branches: [ main ]
   
   jobs:
     build:
       runs-on: ubuntu-latest
   
       strategy:
         matrix:
           node-version: [14.x, 16.x]
   
       steps:
       - uses: actions/checkout@v2
       - name: Use Node.js ${{ matrix.node-version }}
         uses: actions/setup-node@v2
         with:
           node-version: ${{ matrix.node-version }}
       - run: npm install
       - run: npm test
   
     deploy:
       needs: build
       runs-on: ubuntu-latest
       if: github.ref == 'refs/heads/main'
   
       steps:
       - uses: actions/checkout@v2
       - name: Use Node.js ${{ matrix.node-version }}
         uses: actions/setup-node@v2
         with:
           node-version: 14.x
       - run: npm install
       - run: npm run build
       - name: Deploy to Vercel
         uses: vercel/vercel-action@v2
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
           vercel_token: ${{ secrets.VERCEL_TOKEN }}
           app_id: your-vercel-app-id
   

2. Explanation of the Workflow

• Trigger Events: The workflow is triggered on push and pull_request events to the main branch.
• Jobs:
  • Build: This job runs tests using different Node.js versions.
  • Deploy: This job deploys the application to Vercel after successful builds.

3. Secrets Management

To securely manage secrets like API tokens, use GitHub Secrets:

1. Add Vercel Token:
   • Go to your repository settings.
   • Click on "Secrets" and then "Actions."
   • Add a new secret named VERCEL_TOKEN with your Vercel deployment token.

Best Practices

• Automate Testing: Ensure that all code changes pass tests before deployment.
• Use Environment Variables: Store sensitive information in environment variables instead of hardcoding them.
• Monitor Workflows: Regularly check the Actions tab for workflow status and logs.
• Keep Workflows Simple: Start with a basic workflow and gradually add complexity as needed.

Conclusion

By following this tutorial, you have set up a CI/CD pipeline using GitHub Actions. This setup automates testing and deployment, helping you deliver code changes more efficiently and reliably. As your project grows, consider adding more complex workflows to handle different environments (e.g., staging, production) and additional tasks like code linting or security checks.

Feel free to explore more advanced features of GitHub Actions and customize the workflow to fit your specific development needs.