DEV Community

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

Posted on

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.

Top comments (0)