Day 13 of my 90-Devops project: Setting Up a CI/CD Pipeline with Docker and Kubernetes on GitLab

Prerequisites

1. Basic Knowledge of Docker and Kubernetes


2. GitLab Account


3. Git Installed on Local Machine


4. Docker Installed on Local Machine


5. Minikube Installed on Local Machine


6. kubectl Installed on Local Machine

Step 1: Setting Up the Project

1. 
   

   Create a Project Directory
   
   

   
   

   mkdir day13secureci
   
   cd day13secureci
   
   

   
   
   


2. 
   

   Initialize a Git Repository
   
   

   
   

   git init
   
   

   
   
   


3. 
   

   Create a Dockerfile
   
   

   
   

   touch Dockerfile
   
   

   
   
   
   

   Content of Dockerfile:
   
   

   
   

   # Use an official Node.js runtime as a parent 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 port 8080
   
   EXPOSE 8080
   
   
   
   # Run the application
   
   CMD ["node", "app.js"]
   
   

   
   
   


4. 
   

   Create Kubernetes Deployment and Service Files
   
   

   
   

   mkdir -p kubernetes
   
   touch kubernetes/deployment.yaml
   
   touch kubernetes/service.yaml
   
   

   
   
   
   

   Content of deployment.yaml:
   
   

   
   

   apiVersion: apps/v1
   
   kind: Deployment
   
   metadata:
   
     name: my-app-deployment
   
   spec:
   
     replicas: 1
   
     selector:
   
       matchLabels:
   
         app: my-app
   
     template:
   
       metadata:
   
         labels:
   
           app: my-app
   
       spec:
   
         containers:
   
         - name: my-app
   
           image: registry.gitlab.com/your-username/your-project-name:my-app:latest
   
           ports:
   
           - containerPort: 8080
   
   

   
   
   
   

   Content of service.yaml:
   
   

   
   

   apiVersion: v1
   
   kind: Service
   
   metadata:
   
     name: my-app-service
   
   spec:
   
     selector:
   
       app: my-app
   
     ports:
   
       - protocol: TCP
   
         port: 80
   
         targetPort: 8080
   
     type: LoadBalancer
   
   

   
   
   


5. 
   

   Create GitLab CI/CD Configuration File
   
   

   
   

   touch .gitlab-ci.yml
   
   

   
   
   
   

   Content of .gitlab-ci.yml:
   
   

   
   

   stages:
   
     - build
   
     - test
   
     - deploy
   
   
   
   variables:
   
     DOCKER_DRIVER: overlay2
   
   
   
   before_script:
   
     - docker info
   
   
   
   build:
   
     stage: build
   
     script:
   
       - docker build -t my-app .
   
       - docker tag my-app:latest registry.gitlab.com/your-username/your-project-name:my-app:latest
   
       - docker login -u gitlab-ci-token -p $CI_JOB_TOKEN registry.gitlab.com
   
       - docker push registry.gitlab.com/your-username/your-project-name:my-app:latest
   
   
   
   test:
   
     stage: test
   
     script:
   
       - docker run --rm my-app npm test
   
   
   
   deploy:
   
     stage: deploy
   
     script:
   
       - kubectl apply -f kubernetes/deployment.yaml
   
       - kubectl apply -f kubernetes/service.yaml
   
     environment:
   
       name: production
   
       url: http://your-app-url.com
   
   

   
   
   


6. 
   

   Create Your Application Code

   
   
   
   
   
   • Create a simple Node.js application:
     
   
   
   
   

   touch app.js
   
   

   
   
   
   

   Content of app.js:
   
   

   
   

   const express = require('express');
   
   const app = express();
   
   const port = 8080;
   
   
   
   app.get('/', (req, res) => {
   
     res.send('Hello, World!');
   
   });
   
   
   
   app.listen(port, () => {
   
     console.log(`App running on http://localhost:${port}`);
   
   });
   
   

   
   
   
   

   Create package.json:
   
   

   
   

   touch package.json
   
   

   
   
   
   

   Content of package.json:
   
   

   
   

   {
   
     "name": "my-app",
   
     "version": "1.0.0",
   
     "description": "A simple Node.js app",
   
     "main": "app.js",
   
     "scripts": {
   
       "test": "echo \"Error: no test specified\" && exit 1"
   
     },
   
     "dependencies": {
   
       "express": "^4.17.1"
   
     }
   
   }
   
   

   
   
   

Step 2: Setting Up GitLab

1. 
   

   Create a New Project on GitLab

   
   
   
   
   
   • Log in to your GitLab account and create a new project.
   
   
   
   


2. 
   

   Connect Your Local Repository to GitLab
   
   

   
   

   git remote add origin https://gitlab.com/your-username/your-project-name.git
   
   git add .
   
   git commit -m "Initial commit"
   
   git push -u origin master
   
   

   
   
   

Step 3: Running the Pipeline Locally

Since GitLab CI/CD runs in a CI environment and cannot directly interact with your local Minikube cluster, you’ll need to simulate the pipeline locally or adjust your setup for local testing.

1. 
   

   Create a Script to Run the CI/CD Steps Locally
   
   

   
   

   touch run_pipeline.sh
   
   

   
   
   
   

   Content of run_pipeline.sh:
   
   

   
   

   #!/bin/bash
   
   
   
   # Set variables
   
   IMAGE_NAME="my-app"
   
   REGISTRY="registry.gitlab.com"
   
   USERNAME="your-username"
   
   PROJECT_NAME="your-project-name"
   
   IMAGE_TAG="${REGISTRY}/${USERNAME}/${PROJECT_NAME}:${IMAGE_NAME}"
   
   
   
   # Build Docker image
   
   echo "Building Docker image..."
   
   docker build -t ${IMAGE_NAME} .
   
   
   
   # Tag the Docker image
   
   echo "Tagging Docker image..."
   
   docker tag ${IMAGE_NAME}:latest ${IMAGE_TAG}:latest
   
   
   
   # Log in to GitLab container registry
   
   echo "Logging in to GitLab container registry..."
   
   docker login -u your-gitlab-username -p your-gitlab-password ${REGISTRY}
   
   
   
   # Push the Docker image to the registry
   
   echo "Pushing Docker image to registry..."
   
   docker push ${IMAGE_TAG}:latest
   
   
   
   # Run tests (assuming you have a test script)
   
   echo "Running tests..."
   
   docker run --rm ${IMAGE_TAG}:latest npm test
   
   
   
   # Deploy to Minikube
   
   echo "Deploying to Minikube..."
   
   kubectl apply -f kubernetes/deployment.yaml
   
   kubectl apply -f kubernetes/service.yaml
   
   
   
   echo "Pipeline execution completed."
   
   

   
   
   


2. 
   

   Make the Script Executable
   
   

   
   

   chmod +x run_pipeline.sh
   
   

   
   
   


3. 
   

   Run the Script
   
   

   
   

   ./run_pipeline.sh
   
   

   
   
   

Step 4: Verify Deployment on Minikube

1. 
   

   Start Minikube
   
   

   
   

   minikube start
   
   

   
   
   


2. 
   

   Check the Deployment and Service
   
   

   
   

   kubectl get deployments
   
   kubectl get services
   
   

   
   
   

Common Issues and Troubleshooting

1. 
   

   Dockerfile Not Found

   
   
   
   
   
   • Ensure the Dockerfile is in the project root directory and named correctly.
   
   
   
   


2. 
   

   Invalid Repository/Tag Format

   
   
   
   
   
   • Ensure you have replaced placeholder values with actual GitLab username and project name.
   
   
   
   


3. 
   

   Missing Kubernetes Files

   
   
   
   
   
   • Verify that kubernetes/deployment.yaml and kubernetes/service.yaml exist and have the correct content.
   
   
   
   

Final Notes

• Ensure all paths and filenames are correct.


• Replace all placeholder values with your actual values.


• Follow the steps sequentially to avoid errors.