How To Build Docker Images in Docker Hub Using Jenkins Pipeline
Learn how to set up your environment, create your first Jenkins Pipeline, define said pipeline, and run your pipeline and build images.
Jenkins Pipeline is a powerful tool to automate your deployments. Flexible and customized actions split between stages are a good reason to try this feature.
Building your own Docker Image and uploading it to Docker Hub to keep your repository updated is a good example of understanding how Jenkins Pipeline can improve your way of work.
Let's walk through the steps for building Docker images inside the Docker Hub using Jenkins Pipeline and see the benefits of using Docker Hub.
Prerequisites
- A server with Jenkins and Docker running on it (Jenkins user should be allowed to run Docker)
- GitHub account
- Docker Hub account
Why Use Docker Hub?
Building Docker images within Docker Hub offers several benefits. It is especially beneficial for implementing Continuous Integration (CI) and Continuous Deployment (CD) systems for software development. The following are some of the advantages of using Docker Hub for deploying Docker images.
- Collaboration: Custom Docker images can be shared among different developers working on the same project, thus it helps in better collaboration within a team.
- Automation: Docker Hub simplifies the process of development pipelines and workflows and ensures continuous Docker image updates.
- Security: Docker Hub provides an essential security to help protect your docker image against known vulnerabilities.
- Portability: Docker images can be run on any environment or platform that supports Docker.
How To Build Docker Images in Docker Hub Using Jenkins Pipeline
1. Setting Up Your Environment
Install the Docker Pipelines plugin on Jenkins:
Manage Jenkins → Manage Plugins.
Search Docker Pipelines, click on Install without restart, and wait until is done.
Upload your Dockerfile definition to your GitHub repository. Click on the green button, "Clone or Download," and copy the URL because you will need it later.
On Jenkins, you need to create a new credential with your Docker Hub account
details. Go to Credentials → Global → Add credentials, and
fill out the form with your username and password. Fill in ID and Descriptions.
Note that if you set the ID, you will need this specific ID to refer this credential
from your scripts. Here we are just using dockerhub_id.
2. Creating Your First Jenkins Pipeline
Now, we are ready to create our first pipeline. On Jenkins go to New Item → Pipeline, type the name you want for this Pipeline project, and then click OK.
Following that, you can skip all General and Build Trigger options and go straight to the Pipeline section. Here, you can include a Pipeline definition (usually named Jenkinsfile), or you can refer to an external location like Git or Subversion.
3. Defining a Jenkins Pipeline
Consider the below code snippet where we are declaring Jenkins pipeline to build a Docker image from GitHub repository:
pipeline {
environment {
registry = "YourDockerhubAccount/YourRepository"
registryCredential = 'dockerhub_id'
dockerImage = ''
}
agent any
stages {
stage('Cloning our Git') {
steps {
git 'https://github.com/YourGithubAccount/YourGithubRepository.git'
}
}
stage('Building our image') {
steps {
script {
dockerImage = docker.build registry + ":$BUILD_NUMBER"
}
}
}
stage('Deploy our image') {
steps {
script {
docker.withRegistry( '', registryCredential ) {
dockerImage.push()
}
}
}
}
stage('Cleaning up') {
steps {
sh "docker rmi $registry:$BUILD_NUMBER"
}
}
}
}
Please note that you need to modify the above code with your specific Docker Hub and GitHub details: Here, the pipeline we are defining has four stages:
- The first one is to get the Dockerfile from our GitHub repository.
- The second one will build the image using $BUILD_NUMBER to tag the version.
- The third one is pushing the built image to your Docker Hub registry.
- Finally, we will cleanup the previously built image on the local server.
4. Run Your Pipeline and Build Images
Now, we are
ready to run the Pipeline and check the output if an error is present on any
stage during the run.
Go to your Pipeline project on Jenkins and click on Build Now to
run manually. You should get a sequential output of the different stages
similar to this one:
If everything is fine, you can check your Docker Hub repository for a new image
tagged with the Jenkins build version matching with your Docker Hub registry:
This was a basic example of how to work with Pipelines and integrate different
components of your deployments.
Final Thoughts
In this article, we illustrated a simple procedure for building up Docker images using Jenkins within Docker Hub. There are possibilities for creating numerous complex integrations through pipelines as you go ahead.
Some ideas to go further with Jenkins:
- Define a webhook to run the pipeline when a commit is submitted to your GitHub repository.
- Include several containers in the same pipeline to keep different stages (like backend and frontend) or different environments (dev/prod)
- Set a notification by Email/Telegram/Slack with the status and/or output of your pipeline.
As you can see, a lot of options are easily achievable. Just keep experimenting, and you will gain a deeper understanding of Jenkins Pipeline orchestration. Thanks for reading!
We Provide consulting, implementation, and management services on DevOps, DevSecOps, DataOps, Cloud, Automated Ops, Microservices, Infrastructure, and Security
Services offered by us: https://www.zippyops.com/services
Our Products: https://www.zippyops.com/products
Our Solutions: https://www.zippyops.com/solutions
For Demo, videos check out YouTube Playlist: https://www.youtube.com/watch?v=4FYvPooN_Tg&list=PLCJ3JpanNyCfXlHahZhYgJH9-rV6ouPro
If this seems interesting, please email us at [email protected] for a call.
Recent Comments
No comments
Leave a Comment
We will be happy to hear what you think about this post