
- Docker - Home
- Docker - Overview
- Docker - Installing on Linux
- Docker - Installation
- Docker - Hub
- Docker - Images
- Docker - Containers
- Docker - Registries
- Docker - Compose
- Docker - Working With Containers
- Docker - Architecture
- Docker - Layers
- Docker - Container & Hosts
- Docker - Configuration
- Docker - Containers & Shells
- Docker - Dockerfile
- Docker - Building Files
- Docker - Public Repositories
- Docker - Managing Ports
- Docker - Web Server
- Docker - Commands
- Docker - Container Linking
- Docker - Data Storage
- Docker - Volumes
- Docker - Networking
- Docker - Security
- Docker - Toolbox
- Docker - Cloud
- Docker - Build Cloud
- Docker - Logging
- Docker - Continuous Integration
- Docker - Kubernetes Architecture
- Docker - Working of Kubernetes
- Docker - Generative AI
- Docker - Hosting
- Docker - Best Practices
- Docker - Setting Node.js
- Docker - Setting MongoDB
- Docker - Setting NGINX
- Docker - Setting ASP.Net
- Docker - Setting MySQL
- Docker - Setting Go
- Docker - Setting Rust
- Docker - Setting Apache
- Docker - Setting MariaDB
- Docker - Setting Jupyter
- Docker - Setting Portainer
- Docker - Setting Rstudio
- Docker - Setting Plex
- Docker Setting - Flame
- Docker Setting - PostgreSql
- Docker Setting - Mosquitto
- Docker Setting - Grafana
- Docker Setting - Nextcloud
- Docker Setting - Pawns
- Docker Setting - Ubuntu
- Docker Setting - RabbitMQ
- Docker - Setting Python
- Docker - Setting Java
- Docker - Setting Redis
- Docker - Setting Alpine
- Docker - Setting BusyBox
- Docker Setting - Traefik
- Docker Setting - WordPress
- Docker Useful Resources
- Docker - Quick Guide
- Docker - Useful Resources
- Docker - Discussion
Docker - Continuous Integration
Continuous Integration with Docker is the process of automating the creation, testing, and deployment of Docker containers in a Development Workflow. It means that changes committed into a version control system like Git will automatically build Docker images from updated code in a CI pipeline. The image is then sent through a series of automated tests that check if the application works as expected.
Assuming the tests pass, the image can be pushed to a container registry and deployed in staging or production environments. Docker with CI/CD provides consistency across all development and deployment stages by ensuring exactly the same environment from development to production. This helps in minimizing environment-related issues.
In this chapter, lets understand how to build a basic CI/CD pipeline with Docker integrated into it.
How to build a CI/CD pipeline with Docker?
In this section, we will understand how to create an end-to-end CI/CD pipeline using Docker, and Jenkins, and build, test, and run a Java application through it.
Step 1: Install Docker
The first step is to install Docker on your machine. You can refer to one of our previous chapters and follow the installation instructions for your operating system by downloading Docker from the Docker website.
Step 2: Run Jenkins in a Docker Container
Next, You can run the following command to start Jenkins in a Docker container −
$ docker run -d --name jenkins -p 8080:8080 -p 50000:50000 -v jenkins_home:/var/jenkins_home jenkins/jenkins:lts

The above command will pull the latest Jenkins LTS image and run it. You can access the Jenkins dashboard at http://localhost:8080.
Step 3: Initial Jenkins Setup
1. Access Jenkins − Open your browser and navigate to http://localhost:8080.
2. Unlock Jenkins − Follow the instructions to get the initial admin password.

Run the following command to get the password −
$ docker exec jenkins cat /var/jenkins_home/secrets/initialAdminPassword

3. Install Suggested Plugins − After entering the password, choose "Install suggested plugins."


4. Create Admin User − Create your admin user to manage Jenkins.

Step 4: Configure Docker in Jenkins
Install Docker Pipeline Plugin
- Go to Jenkins Dashboard -> Manage Jenkins -> Manage Plugins -> Available.
- Search for "Docker Pipeline" and install it.

Add Docker Hub Credentials
- Go to Jenkins Dashboard -> Manage Jenkins -> Manage Credentials.
- Add a new set of credentials with your Docker Hub username and password.

Step 5: Create a Java Application
Create a simple Java application with the following structure −
my-java-app/ src/ main/ java/ org/ example/ Main.java test/ java/ org/ example/ MainTest.java Dockerfile Jenkinsfile pom.xml
App.java
package org.example; public class Main { public static void main(String[] args) { System.out.println("Hello, Docker CI/CD with Jenkins!"); } }
AppTest.java
package org.example; import static org.junit.Assert.assertTrue; import org.junit.Test; public class MainTest { @Test public void shouldAnswerWithTrue() { assertTrue(true); } }
pom.xml
<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>org.example</groupId> <artifactId>my-java-app</artifactId> <version>1.0-SNAPSHOT</version> <properties> <maven.compiler.source>8</maven.compiler.source> <maven.compiler.target>8</maven.compiler.target> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> </properties> <dependencies> <!-- JUnit 4 dependency --> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.13.2</version> <scope>test</scope> </dependency> </dependencies> </project>
Step 6: Update the Dockerfile
Create a Dockerfile in the root of your project −
FROM maven:3.6.3-jdk-8 AS build WORKDIR /app COPY pom.xml . COPY src /app/src RUN mvn clean package FROM openjdk:8-jre-alpine WORKDIR /app COPY --from=build /app/target/my-java-app-1.0-SNAPSHOT.jar app.jar ENTRYPOINT ["java", "-jar", "app.jar"]
Step 7: Update the Jenkinsfile
Create a Jenkinsfile in the root of your project to define your CI/CD pipeline −
pipeline { agent any tools { maven 'Maven 3.6.3' // Define the Maven version installed on your Jenkins server } stages { stage('Build') { steps { script { // Build the Docker image docker.build("my-java-app:${env.BUILD_ID}") } } } stage('Test') { steps { script { // Run tests inside the Docker container docker.image("my-java-app:${env.BUILD_ID}").inside { sh 'mvn test' } } } } stage('Push') { steps { script { // Push the Docker image to Docker Hub docker.withRegistry('https://index.docker.io/v1/', 'dockerhub-credentials') { docker.image("my-java-app:${env.BUILD_ID}").push('latest') } } } } stage('Deploy') { steps { script { // Deploy the Docker image to the production environment sh 'docker run -d -p 8080:8080 my-java-app:latest' } } } } post { always { cleanWs() } } }
Step 8: Configure Jenkins Job
1. Create a New Job − Go to Jenkins Dashboard -> New Item.
- Select "Pipeline" and name it my-java-app-pipeline.
- In the pipeline configuration, select "Pipeline script" and copy the Jenkinsfile content here.
- Alternatively, you can also Pipeline script from SCM and choose "Git" and provide the repository URL where your Java application is hosted.
- Specify the branch to build (e.g., main or master).
- Specify the Jenkinsfile path.


2. Build the Job − Save the configuration and click "Build Now" to start the pipeline.
Step 9: Monitor the Pipeline
- Build Stage − The Docker image is built using the Dockerfile.
- Test Stage − The application tests are run inside the Docker container using the mvn test command. The MainTest.java file is executed, and the results are reported.
- Push Stage − The Docker image is pushed to Docker Hub.
- Deploy Stage − The Docker image is deployed to a server.
By following these steps, you now have a fully functional CI/CD pipeline that includes a test stage for your Java application using Docker and Jenkins.
Conclusion
In this chapter, we have discussed how to create a fully functional CI/CD pipeline using Docker, and Jenkins, and build, test, and run a Java application. Docker's containerization ensures consistency across development, testing, and deployment environments for improved reliability and reproducibility. Jenkins automates this pipeline from building the Docker image and running tests to deploying the application, hence rapid feedback for continuous improvement.
Testing methodologies in such a setup using Maven and JUnit facilitates strong methods of testing for quality and reliability. Equipped with these best practices, teams can drive efficient, scalable, resilient software delivery that continues to work congruently with the demands of agile development and modern-day deployment cycles.
FAQs on Docker Continuous Integration
1. How do I integrate Docker with Jenkins for CI/CD?
The first step to integrate Docker with Jenkins is to install a Docker plugin on your Jenkins server, allowing interaction of Jenkins with Docker and enabling it to build images, run containers, and push them to registries. After that, you have the option to define your CI/CD pipeline in Jenkins with Docker commands for building and deploying applications.
2. How can I use Docker Compose with Jenkins?
Docker Compose is used to define and manage multi-container applications. You can use the Docker Compose plugin in Jenkins for complex deployments like spinning up several containers in the right order, configuration, and so on; this is particularly useful when having multiple services within an application.
3. How do I set up a Jenkins pipeline for building Docker images?
You can create a Jenkins pipeline with Jenkinsfile defining all your steps for building and deployment of your Docker image. This pipeline extracts the source code from source control, creates a Docker image, runs tests, pushes the image to some registry, and deploys it to the target environment.