How to Set Up a CI/CD Pipeline for Dockerized Applications on Google Cloud

In the rapidly evolving world of software development, Continuous Integration (CI) and Continuous Deployment (CD) have become essential practices for delivering high-quality applications swiftly and efficiently. When combined with Docker, these practices can streamline your development workflow and enhance your team's productivity. In this article, we'll explore how to set up a CI/CD pipeline for Dockerized applications on Google Cloud, providing you with actionable insights, clear code examples, and step-by-step instructions.

What is CI/CD?

Continuous Integration (CI) is the practice of automatically integrating code changes from multiple contributors into a shared repository several times a day. CI helps detect problems early, improving the quality of software and reducing the time it takes to deliver new features.

Continuous Deployment (CD) goes a step further by automating the release of software changes to production after passing predefined tests. This ensures that your code is always in a deployable state.

Why Use Docker with CI/CD?

Docker allows developers to package applications and their dependencies into containers, providing a consistent environment from development through production. This eliminates the classic "it works on my machine" problem and allows for:

• Portability: Run anywhere that supports Docker.
• Scalability: Easily scale applications based on demand.
• Isolation: Keep applications and their dependencies separate.

Use Case: Building a CI/CD Pipeline with Google Cloud

In this tutorial, we'll build a CI/CD pipeline for a Dockerized Node.js application deployed on Google Cloud, utilizing Google Cloud Build for CI and Google Kubernetes Engine (GKE) for CD.

Prerequisites

Before we start, ensure you have:

• A Google Cloud account with billing enabled.
• The Google Cloud SDK installed locally.
• Basic knowledge of Docker and Kubernetes.
• A sample Node.js application ready for Dockerization.

Step 1: Dockerize Your Application

First, let's create a Dockerfile for your Node.js application. A basic Dockerfile looks like this:

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

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

# Copy package.json and install dependencies.
COPY package*.json ./
RUN npm install

# Copy the rest of the application code.
COPY . .

# Expose the application port.
EXPOSE 8080

# Start the application.
CMD ["node", "app.js"]

Build and Test Your Docker Image Locally

To build and test your Docker image, run the following commands:

# Build the Docker image.
docker build -t my-node-app .

# Run the container.
docker run -p 8080:8080 my-node-app

Visit http://localhost:8080 to see your application in action!

Step 2: Push Your Docker Image to Google Container Registry

Next, we need to push your Docker image to Google Container Registry (GCR). First, authenticate your Docker client to your Google Cloud account:

gcloud auth configure-docker

Now, tag and push your Docker image:

# Tag the image.
docker tag my-node-app gcr.io/[YOUR_PROJECT_ID]/my-node-app

# Push the image to GCR.
docker push gcr.io/[YOUR_PROJECT_ID]/my-node-app

Step 3: Set Up Google Cloud Build

Now we’ll set up Google Cloud Build to automate the CI process. Create a file named cloudbuild.yaml in your project root:

steps:
  - name: 'gcr.io/cloud-builders/docker'
    args: ['build', '-t', 'gcr.io/$PROJECT_ID/my-node-app', '.']
  - name: 'gcr.io/cloud-builders/docker'
    args: ['push', 'gcr.io/$PROJECT_ID/my-node-app']
images:
  - 'gcr.io/$PROJECT_ID/my-node-app'

Configure Triggers

1. Go to the Google Cloud Console.
2. Navigate to Cloud Build > Triggers.
3. Create a new trigger linked to your source code repository (e.g., GitHub).
4. Set it to trigger on pushes to the main branch.

Step 4: Deploy to Google Kubernetes Engine (GKE)

Create a GKE Cluster

To deploy your application, you need a GKE cluster. Run the following command:

gcloud container clusters create my-cluster --num-nodes=1

Deploy Your Docker Application

Create a Kubernetes deployment file named deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-node-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: my-node-app
  template:
    metadata:
      labels:
        app: my-node-app
    spec:
      containers:
      - name: my-node-app
        image: gcr.io/[YOUR_PROJECT_ID]/my-node-app
        ports:
        - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: my-node-app-service
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 8080
  selector:
    app: my-node-app

Apply the deployment:

kubectl apply -f deployment.yaml

Access Your Application

To get the external IP of your service, run:

kubectl get services

Visit the external IP in your browser to see your application running live!

Step 5: Automate Deployment with Cloud Build

To automate the deployment process, extend your cloudbuild.yaml:

steps:
  - name: 'gcr.io/cloud-builders/docker'
    args: ['build', '-t', 'gcr.io/$PROJECT_ID/my-node-app', '.']
  - name: 'gcr.io/cloud-builders/docker'
    args: ['push', 'gcr.io/$PROJECT_ID/my-node-app']
  - name: 'gcr.io/cloud-builders/kubectl'
    args: ['set', 'image', 'deployment/my-node-app', 'my-node-app=gcr.io/$PROJECT_ID/my-node-app']
    env:
      - 'CLOUDSDK_COMPUTE_ZONE=us-central1-a'
      - 'CLOUDSDK_CONTAINER_CLUSTER=my-cluster'

Now, every time you push code to the main branch, your application will be built, tested, and deployed automatically!

Conclusion

Setting up a CI/CD pipeline for Dockerized applications on Google Cloud can significantly enhance your development workflow. By automating the building, testing, and deployment processes, you can ensure that your applications are delivered faster and with higher quality. With the steps outlined in this article, you're now equipped to implement this powerful workflow in your projects. Embrace CI/CD and Docker to elevate your development practices and stay ahead in the competitive software landscape!