Docker Integration with Jenkins

# CHAPTER 11

Docker Integration with Jenkins #

1. Introduction #

2. Learning Objectives #

• Understand the benefits of using Docker containers as Jenkins Build Agents.

• Configure a declarative pipeline to execute steps inside a specific Docker container.

• Use Jenkins to build a custom Docker image from a Dockerfile.

• Understand how to push built images to a Docker Registry (like Docker Hub).

3. Beginner-Friendly Explanation #

• The Old Way: The chef installs a pizza oven, a sushi rolling station, and a taco press all in the same tiny kitchen. It's crowded, messy, and the flavors mix.

• The Docker Way: The chef has a magical button. When they need to make sushi, they press the button, and a spotless, perfectly equipped "Sushi Kitchen" (A Docker Container) appears. The chef makes the sushi, and when they are done, the kitchen vanishes into thin air. Tomorrow, they press the button for a "Pizza Kitchen."

Docker allows Jenkins to conjure up perfectly clean, temporary environments to run your code, keeping the main Jenkins server perfectly clean.

4. Running Pipelines Inside Docker (Agents) #

pipeline {
    // Instead of 'any', we specify a Docker image!
    agent {
        docker { image 'node:18-alpine' }
    }
    stages {
        stage('Test') {
            steps {
                // This command runs INSIDE the Node.js container!
                sh 'npm install'
                sh 'npm test'
            }
        }
    }
}

*When the pipeline finishes, Jenkins automatically deletes the Node.js container. Your Jenkins server never needed to have Node.js installed!*

5. Building and Pushing Docker Images #

To do this, you use standard Docker commands in your sh steps, assuming your Jenkins server has Docker installed on the host.

6. Mini Project: Build a Docker Image Automatically #

Step-by-Step Pipeline Concept:

pipeline {
    agent any
    environment {
        // Define the name of our final image
        IMAGE_NAME = 'my-company/my-php-app'
        IMAGE_TAG = "v${env.BUILD_NUMBER}" // Uses the Jenkins build number (e.g., v42)
    }
    stages {
        stage('Build Docker Image') {
            steps {
                echo 'Building the Docker Image...'
                // Jenkins runs the docker build command, reading the Dockerfile in your repo
                sh "docker build -t ${IMAGE_NAME}:${IMAGE_TAG} ."
            }
        }
        stage('Push to Registry') {
            steps {
                echo 'Pushing image to Docker Hub...'
                // We will learn how to handle the password securely in Chapter 14!
                // sh 'docker login -u myuser -p mypassword'
                sh "docker push ${IMAGE_NAME}:${IMAGE_TAG}"
            }
        }
    }
    post {
        always {
            // Clean up the heavy image from the Jenkins hard drive
            sh "docker rmi ${IMAGE_NAME}:${IMAGE_TAG} || true"
        }
    }
}

7. Real-World Scenarios #

8. Best Practices #

• Use Specific Tags, Not 'latest': When defining a Docker agent (e.g., node:latest), your build might pass today, but fail tomorrow if the Node.js team releases a new version that breaks your code. Always lock your agent to a specific, immutable version tag (e.g., node:18.16.0-alpine).

9. Security Recommendations #

• Docker Socket Security: To allow Jenkins to run docker build commands, administrators often map the host's /var/run/docker.sock file into the Jenkins container. This is highly dangerous. Anyone who can execute a shell script in Jenkins has root access to the host server. In enterprise environments, prefer secure alternatives like "Kaniko" or "Podman" for rootless image building.

10. Troubleshooting Tips #

• "Docker command not found": If your pipeline fails on sh 'docker build ...', it means the Jenkins agent you are currently running on does not have the Docker executable installed. You must install Docker CLI on your Jenkins worker nodes.

11. Exercises #

1. 1. Explain the architectural benefit of using agent { docker { image 'php:8.1' } } instead of installing PHP 8.1 directly onto the Jenkins host server.

1. 2. What is the purpose of the Jenkins ${env.BUILD_NUMBER} variable when tagging a Docker image?

12. FAQs #

13. Interview Questions #

• Q: Describe the "Docker out of Docker" (DooD) pattern commonly used in Jenkins. What are the security implications of binding the host's Docker socket to the Jenkins container?

• Q: A pipeline successfully builds a 1GB Docker image, pushes it to a registry, and completes. However, the Jenkins server runs out of disk space after 50 builds. Identify the missing architectural step in the Jenkinsfile and how to fix it.

14. Summary #

15. Next Chapter Recommendation #