CI/CD with Docker: Integrating Docker into Your Build Pipelines

In today’s fast-paced development world, Continuous Integration and Continuous Deployment (CI/CD) are essential practices for delivering quality software quickly and efficiently. Docker, the popular containerization platform, has become a foundational element in modern DevOps toolchains. It provides a consistent environment for building, testing, and deploying applications across different stages of the pipeline.

In this blog, we’ll explore how to integrate Docker into your CI/CD pipelines using popular CI tools like Jenkins and GitLab CI. Whether you’re automating builds, running tests in containers, or deploying Docker images, this guide will help you implement containerized CI/CD pipelines effectively.

🚀 Why Use Docker in CI/CD?

Using Docker in CI/CD pipelines offers several benefits:

• Environment Consistency: Eliminate “it works on my machine” issues by packaging dependencies with the application.

• Isolation: Run tests, builds, or other processes in isolated containers.

• Reusability: Use pre-built Docker images for testing or build environments.

• Scalability: Containers can be spun up or down as needed, supporting parallel jobs and microservices.

🏗️ CI/CD Workflow with Docker – An Overview

A typical Docker-powered CI/CD workflow looks like this:

1. Code Commit: Developer pushes code to a Git repository.

2. CI Tool Trigger: The CI tool (Jenkins, GitLab CI, etc.) is triggered via a webhook or polling.

3. Build Container: The application is built inside a Docker container.

4. Run Tests: Tests (unit/integration) are run in Docker containers.

5. Build Image: A Docker image is created and tagged (e.g., with a commit SHA or version).

6. Push to Registry: Image is pushed to Docker Hub or a private registry.

7. Deploy: The new image is deployed to a staging/production environment via Docker or Kubernetes.

⚙️ Using Docker in Jenkins

Jenkins is one of the most widely used CI tools. Here's how you can integrate Docker with Jenkins.

1. Install Docker on Jenkins Host

Ensure Docker is installed on the machine where Jenkins is running. Jenkins should have permission to run Docker commands. You can add the Jenkins user to the Docker group:

sudo usermod -aG docker jenkins

2. Use Docker in Jenkins Pipelines

You can use Docker inside Jenkins pipelines via the Docker Pipeline plugin.

Example: Jenkins Declarative Pipeline with Docker

pipeline {
    agent {
        docker {
            image 'node:18' // or your build environment
            label 'docker-node'
        }
    }
    stages {
        stage('Install Dependencies') {
            steps {
                sh 'npm install'
            }
        }
        stage('Run Tests') {
            steps {
                sh 'npm test'
            }
        }
        stage('Build Docker Image') {
            steps {
                script {
                    dockerImage = docker.build("my-app:${env.BUILD_NUMBER}")
                }
            }
        }
        stage('Push Image') {
            steps {
                withCredentials([usernamePassword(credentialsId: 'dockerhub-creds', usernameVariable: 'DOCKER_USER', passwordVariable: 'DOCKER_PASS')]) {
                    sh "echo $DOCKER_PASS | docker login -u $DOCKER_USER --password-stdin"
                    sh "docker push my-app:${env.BUILD_NUMBER}"
                }
            }
        }
    }
}

Notes:

• Replace dockerhub-creds with your Jenkins credential ID.

• Ensure Docker is installed and accessible from Jenkins agents.

🔧 Using Docker in GitLab CI/CD

GitLab has built-in CI/CD with first-class Docker support. You can use Docker in two main ways:

1. Using Docker Executor

If your GitLab Runner uses the Docker executor, you can build and run containers directly in your .gitlab-ci.yml.

Example .gitlab-ci.yml

image: docker:latest

services:
  - docker:dind # Docker-in-Docker

variables:
  DOCKER_DRIVER: overlay2

stages:
  - build
  - test
  - deploy

before_script:
  - docker info

build:
  stage: build
  script:
    - docker build -t my-app:$CI_COMMIT_SHORT_SHA .

test:
  stage: test
  script:
    - docker run --rm my-app:$CI_COMMIT_SHORT_SHA npm test

deploy:
  stage: deploy
  script:
    - echo "$DOCKER_PASSWORD" | docker login -u "$DOCKER_USERNAME" --password-stdin
    - docker push my-app:$CI_COMMIT_SHORT_SHA

Notes:

• docker:dind enables Docker commands inside the container.

• Use GitLab CI/CD variables to store credentials securely.

🛠️ Best Practices for Docker in CI/CD

1. Use Multi-stage Builds: Optimize Dockerfiles by separating build and runtime environments.

2. Tag Images Clearly: Use meaningful tags like v1.2.3, latest, or Git commit SHAs.

3. Clean Up After Builds: Avoid leftover containers or dangling images.

4. Security: Scan images using tools like Trivy, Clair, or GitLab’s built-in scanners.

5. Immutable Builds: Avoid changing base images or dependencies without changing tags.

6. Monitor Your Registry: Regularly audit and prune unused images from your registry.

📦 Popular CI/CD Tools That Work with Docker

🧪 Bonus: Testing Docker Images in CI

Automated tests are a critical part of CI. You can test Docker containers by:

• Running unit tests inside the Docker container.

• Spinning up services with docker-compose and testing APIs.

• Using health checks to validate container readiness.

Example Docker Compose Test Setup

version: '3.8'
services:
  web:
    build: .
    ports:
      - "8080:8080"
    depends_on:
      - db
  db:
    image: postgres:15
    environment:
      POSTGRES_PASSWORD: example

Run integration tests once both services are up.

🧭 Conclusion

Integrating Docker into your CI/CD pipelines enhances portability, reproducibility, and scalability of your software delivery process. Whether you're using Jenkins, GitLab CI, or another tool, Docker provides a robust and flexible foundation for modern DevOps practices.

By containerizing build and deployment steps, you can ensure consistent results across development, testing, and production environments. Start small, automate everything, and iterate toward a more reliable and faster release process.