How to Set Up a CI/CD Pipeline with Docker and Kubernetes

In today’s fast-paced software development landscape, Continuous Integration (CI) and Continuous Deployment (CD) have become essential practices for delivering high-quality applications. By automating the integration and deployment processes, teams can enhance collaboration and accelerate delivery cycles. When combined with powerful containerization technologies like Docker and orchestration platforms like Kubernetes, setting up a CI/CD pipeline becomes both efficient and scalable. This guide will walk you through the process, providing actionable insights, code examples, and troubleshooting tips.

What is CI/CD?

Continuous Integration (CI) is a practice where developers frequently integrate their code changes into a shared repository, ensuring that these changes are automatically tested. This helps identify issues early in the development cycle.

Continuous Deployment (CD) goes a step further by automatically deploying code changes to a production environment after passing predefined tests. This automation eliminates the manual steps typically involved in deployment, reducing the risk of human error.

Why Use Docker and Kubernetes in CI/CD?

Docker allows developers to package applications and their dependencies into containers, ensuring consistency across environments. Kubernetes, on the other hand, is a container orchestration platform that automates the deployment, scaling, and management of containerized applications. Together, they provide a robust solution for CI/CD pipelines with the following benefits:

• Environment Consistency: Containers ensure that your application runs the same way in development, testing, and production.
• Scalability: Kubernetes can automatically scale applications based on demand, making it easier to handle varying loads.
• Resilience: Kubernetes manages container failures and can restart them automatically, ensuring high availability.

Setting Up a CI/CD Pipeline: Step-by-Step

Prerequisites

Before diving into the setup, ensure you have the following:

• Docker: Installed and running on your machine.
• Kubernetes Cluster: You can use a local cluster (like Minikube) or a cloud provider (like Google Kubernetes Engine).
• CI/CD Tool: We’ll use GitHub Actions for this example, but the principles can be applied to other tools like Jenkins or GitLab CI.

Step 1: Create a Sample Application

Let’s create a simple Node.js application. First, create a new directory and initialize a Node.js project:

mkdir my-app
cd my-app
npm init -y

Install Express:

npm install express

Create an app.js file with the following content:

const express = require('express');
const app = express();
const PORT = process.env.PORT || 3000;

app.get('/', (req, res) => {
    res.send('Hello, CI/CD with Docker and Kubernetes!');
});

app.listen(PORT, () => {
    console.log(`Server is running on port ${PORT}`);
});

Step 2: Dockerize Your Application

Create a Dockerfile in your project directory:

# Use the official Node.js image
FROM node:14

# Set the working directory
WORKDIR /usr/src/app

# Copy package.json and package-lock.json
COPY package*.json ./

# Install dependencies
RUN npm install

# Copy the rest of the application code
COPY . .

# Expose the port
EXPOSE 3000

# Command to run the application
CMD ["node", "app.js"]

Step 3: Build and Test Your Docker Image

Build your Docker image with the following command:

docker build -t my-app .

Run the Docker container:

docker run -p 3000:3000 my-app

Visit http://localhost:3000 in your browser to verify that your application is running.

Step 4: Create a Kubernetes Deployment

Create a Kubernetes deployment YAML file named deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app
        image: my-app:latest
        ports:
        - containerPort: 3000

Apply the deployment:

kubectl apply -f deployment.yaml

Step 5: Set Up GitHub Actions for CI/CD

Create a .github/workflows/ci-cd.yml file in your project directory:

name: CI/CD Pipeline

on:
  push:
    branches:
      - main

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v1

      - name: Login to Docker Hub
        uses: docker/login-action@v1
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}

      - name: Build and push Docker image
        uses: docker/build-push-action@v2
        with:
          context: .
          push: true
          tags: my-app:latest

      - name: Deploy to Kubernetes
        uses: azure/setup-kubectl@v1
        with:
          version: 'latest'

      - name: Set Kubeconfig
        run: echo "${{ secrets.KUBECONFIG }}" > $HOME/.kube/config

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

Step 6: Troubleshooting Common Issues

• Docker Build Failures: Check for syntax errors in your Dockerfile and ensure your application dependencies are correctly defined in package.json.
• Kubernetes Deployment Errors: Use kubectl logs <pod-name> to check logs for any issues with your application.
• CI/CD Pipeline Failures: Review the GitHub Actions logs for detailed error messages and steps to troubleshoot.

Conclusion

Setting up a CI/CD pipeline with Docker and Kubernetes enables teams to automate the integration and deployment of their applications effectively. By following the steps outlined in this guide, you can create a robust environment that accelerates your development cycle, enhances collaboration, and ensures high-quality software delivery.

As you refine your CI/CD practices, continue exploring advanced topics such as monitoring, testing strategies, and security considerations to further enhance your pipeline. Happy coding!