Mastering Continuous Integration: How to Use Docker Images with Jenkins

4 min readSep 10, 2024

Jenkins, a popular open-source automation server, combined with Docker, a containerization platform, offers a powerful solution for managing and scaling CI/CD pipelines.

In the ever-evolving world of DevOps and continuous integration/continuous deployment (CI/CD), the need for efficient, scalable, and reliable build environments is paramount.

Jenkins, a popular open-source automation server, combined with Docker, a containerization platform, offers a powerful solution for managing and scaling CI/CD pipelines.

This blog post will explore how to leverage Docker images within Jenkins to enhance your build processes, offering a step-by-step guide and practical examples.

Understanding Jenkins and Docker

Jenkins

Jenkins is a widely-used tool for automating parts of software development related to building, testing, and deploying, facilitating continuous integration and continuous delivery.

It supports various plugins that enable building, deploying, and automating projects.

Docker

Docker is a platform that enables developers to automate the deployment of applications inside lightweight, portable containers.

Containers encapsulate an application and its dependencies, ensuring that it runs consistently across different environments.

Combining Jenkins with Docker allows you to create isolated build environments and ensure consistency across development, testing, and production stages.

Benefits of Using Docker with Jenkins

1. Isolation

Docker containers ensure that each build runs in its own isolated environment, eliminating conflicts between dependencies and configurations.

2. Consistency

Using Docker images ensures that builds are consistent across different environments, reducing the “it works on my machine” problem.

3. Scalability

Docker makes it easy to scale Jenkins builds by spinning up additional containers as needed.

4. Efficiency

Docker images can be reused across multiple Jenkins jobs, speeding up the build process by avoiding redundant setups.

Setting Up Jenkins with Docker

To use Docker images with Jenkins, follow these steps:

1. Install Docker

Ensure Docker is installed on your Jenkins server. You can download Docker from Docker’s official website.

2. Configure Jenkins to Use Docker

2.1 Install Docker Plugin

In Jenkins, go to ‘Manage Jenkins’ > ‘Manage Plugins’. Search for and install the “Docker Plugin”.

2.2 Set Up Docker Host

Configure the Docker host in Jenkins. Go to ‘Manage Jenkins’ > ‘Configure System’ and add a new Docker host.

3. Create a Docker Image for Your Build

Write a ‘Dockerfile’ that specifies the environment needed for your build.

Here’s a simple example for a Node.js application:

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

# Set the working directory in the container.
 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 port and define the command to run the app.
 EXPOSE 8080
 CMD [ "node", "app.js" ]

Build the Docker image:

docker build -t my-node-app .

4. Integrate Docker Image with Jenkins Pipeline

Create a Jenkins pipeline job and use a ‘Jenkinsfile’ to define your build steps.

Here’s an example ‘Jenkinsfile’ using the Docker image:

pipeline {
 agent {
   docker {
             image 'my-node-app'
             label 'docker-agent'
   }
 }
 stages {
   stage('Build') {
     steps {
     script {
             // Example command: Run tests inside the Docker container
             sh 'npm test'
     }
   }
 }
 stage('Deploy') {
   steps {
     script {
             // Example command: Deploy your application
             sh 'npm run deploy'
       }
     }
   }
 }
}

5. Run and Monitor Your Jenkins Pipeline

Trigger your pipeline job in Jenkins. Monitor the build process through the Jenkins interface to ensure that it runs smoothly within the Docker container.

Practical Example: Building and Testing a Python Application

Let’s go through a practical example of using Docker with Jenkins to build and test a Python application.

1. Create a Docker Image:

Write a ‘Dockerfile’ for a Python application:

# Use the official Python image from the Docker Hub.
 FROM python:3.9-slim

# Set the working directory.
 WORKDIR /app

# Copy the dependencies file.
 COPY requirements.txt .

# Install the dependencies.
 RUN pip install - no-cache-dir -r requirements.txt

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

# Define the command to run the application.
 CMD [ "python", "./app.py" ]

Build the Docker image:

docker build -t my-python-app .

2. Set Up Jenkins Pipeline

Create a ‘Jenkinsfile’ for your Python application:

pipeline {
 agent {
   docker {
             image 'my-python-app'
             label 'python-agent'
     }
   }
   stages {
     stage('Test') {
       steps {
         script {
                 // Run tests inside the Docker container
                 sh 'pytest'
         }
       }
   }
   stage('Deploy') {
     steps {
       script {
                 // Example deploy command
                 sh 'python deploy.py'
        }
     }
   }
 }
}

3. Run and Verify

Trigger the Jenkins pipeline and verify that the tests run successfully within the Docker container and the deployment proceeds as expected.

Conclusion

Integrating Docker with Jenkins offers numerous benefits, including isolation, consistency, and scalability.

By following the steps outlined in this blog post, you can set up Jenkins to use Docker images effectively, enhancing your CI/CD workflows and improving overall efficiency.

Docker images ensure that your builds are consistent across different environments, and Jenkins pipelines allow for seamless automation of your build, test, and deployment processes.

By leveraging these tools together, you can streamline your development process and focus more on building great software.

CodeX