Continuous Integration (CI) and Continuous Deployment (CD) are pivotal practices in modern software development that allow teams to deliver high-quality software at an unprecedented speed. Jenkins is one of the most widely used open-source automation servers that supports these practices. In this blog, we will delve into how to implement CI\/CD using Jenkins, ensuring you have a foundational understanding paired with practical steps.<\/p>\n
Jenkins is an open-source automation tool developed in Java that helps automate the parts of software development related to building, testing, and deploying. It enables the continuous integration and delivery of projects, thereby allowing developers to push changes to apps quickly and efficiently. With a rich ecosystem of plugins and integrations, Jenkins can connect with virtually any technology stack.<\/p>\n
CI\/CD practices promote early error detection, improve collaboration, and speed up the development process. Here are some reasons why these practices are crucial:<\/p>\n
To get started with Jenkins, you first need to install it on your machine or server. Here\u2019s how to do it:<\/p>\n
sudo apt update\nsudo apt install openjdk-11-jdk\nwget -q -O - https:\/\/pkg.jenkins.io\/debian\/jenkins.io.key | sudo apt-key add -\necho deb http:\/\/pkg.jenkins.io\/debian-stable binary\/ | sudo tee \/etc\/apt\/sources.list.d\/jenkins.list\nsudo apt update\nsudo apt install jenkins<\/code><\/pre>\nOnce Jenkins is installed, you can start it with:<\/p>\n
sudo systemctl start jenkins<\/code><\/pre>\nJenkins is typically accessible via http:\/\/localhost:8080<\/strong>. When you first access this URL, you will be prompted to unlock Jenkins using an initial administrative password, which you can find in:<\/p>\n\/var\/lib\/jenkins\/secrets\/initialAdminPassword<\/code><\/pre>\nBasic Configuration<\/h3>\n
After unlocking Jenkins, you can follow the setup wizard to configure the following:<\/p>\n
\n- Install Suggested Plugins:<\/strong> Jenkins offers many plugins that enhance functionality. It is typically a good idea to start with the suggested plugins.<\/li>\n
- Create Admin User:<\/strong> Set up an admin user for managing your Jenkins instance.<\/li>\n
- Configure Instance:<\/strong> Set the Jenkins URL so that it can be accessed correctly during builds and notifications.<\/li>\n<\/ul>\n
Creating Your First Job<\/h2>\nSetting Up a Simple Job<\/h3>\n
Now that Jenkins is configured, let\u2019s create your first CI\/CD job:<\/p>\n
\n- Click on \u201cNew Item\u201d in the Jenkins dashboard.<\/li>\n
- Name your job (e.g., My First CI\/CD Job<\/strong>). Select the Freestyle project<\/strong> option and click OK<\/strong>.<\/li>\n<\/ul>\n
Configuring Source Code Management<\/h3>\n
In the job configuration page, scroll down to Source Code Management<\/strong> and select Git<\/strong>. Here, provide the repository URL and credentials if needed:<\/p>\nhttps:\/\/github.com\/yourusername\/your-repo.git<\/code><\/pre>\nDon\u2019t forget to specify the branch you want to build (typically main<\/strong> or master<\/strong>).<\/p>\nBuilding Triggers<\/h3>\n
Next, configure how you want Jenkins to trigger builds. A common method is using webhooks from GitHub. Under the Build Triggers<\/strong> section:<\/p>\n\n- Check the GitHub hook trigger for GITScm polling<\/strong> option.<\/li>\n<\/ul>\n
Build Steps<\/h3>\n
Every CI\/CD pipeline needs build steps. In the Build<\/strong> section, choose Add build step<\/strong> and select Execute shell<\/strong>. Here, write the commands you wish to run:<\/p>\necho \"Building the project...\"\n# Add your build commands here, e.g., Maven, Gradle, NPM\nmvn clean install<\/code><\/pre>\nPost-build Actions<\/h3>\n
Post-build actions can include notifications, deploying artifacts, or triggering other jobs. For example, you can configure notifications via email when there\u2019s a build failure:<\/p>\n
\n- Select Add post-build action<\/strong>.<\/li>\n
- Choose Editable Email Notification<\/strong> and enter appropriate email settings.<\/li>\n<\/ul>\n
Implementing Continuous Deployment<\/h2>\nPreparing for Deployment<\/h3>\n
Now, let’s set up Jenkins to automatically deploy your built application. In this case, we’ll use a simple approach: copying built artifacts to a server.<\/p>\n
First, you need to install the Publish Over SSH<\/strong> plugin:<\/p>\n\n- Go to Manage Jenkins<\/strong>.<\/li>\n
- Select Manage Plugins<\/strong> and find Publish Over SSH<\/strong>.<\/li>\n
- Install the plugin and restart Jenkins if required.<\/li>\n<\/ul>\n
Configuring Deployment<\/h3>\n
Once the plugin is installed, go back to Manage Jenkins<\/strong> and select Configure System<\/strong>. Scroll down to the Publish over SSH<\/strong> section, then configure the SSH server details:<\/p>\n\n- Enter the remote server\u2019s information (host, username, remote directory, etc.).<\/li>\n
- Test the connection to ensure Jenkins can reach the server.<\/li>\n<\/ul>\n
In your job configuration, under Post-build Actions<\/strong>, select Send files or execute commands over SSH<\/strong>. Choose the server you configured and specify which files to transfer:<\/p>\ntarget\/*.jar<\/code><\/pre>\nIntegrating Automated Testing<\/h2>\n
Automated testing is crucial in a CI\/CD pipeline. Jenkins supports various testing frameworks and can run tests as part of the build process.<\/p>\n
Simple Test Integration<\/h3>\n
For example, if using JUnit tests, you can add the following commands in the Execute shell<\/strong> section:<\/p>\necho \"Running tests...\"\nmvn test<\/code><\/pre>\nConfigure Jenkins to report test results by adding the Publish JUnit test result report<\/strong> post-build action and point it to the test reports directory:<\/p>\ntarget\/surefire-reports\/*.xml<\/code><\/pre>\nAdvanced Pipeline Using Jenkinsfile<\/h3>\n
For more complex projects, consider using a Jenkinsfile, which is a text file that contains the definition of the CI\/CD pipeline. Here\u2019s a simple example:<\/p>\n
pipeline {\n agent any\n stages {\n stage('Build') {\n steps {\n script {\n sh 'mvn clean install'\n }\n }\n }\n stage('Test') {\n steps {\n script {\n sh 'mvn test'\n }\n }\n }\n stage('Deploy') {\n steps {\n script {\n sh 'scp target\/*.jar user@remote-server:\/path\/to\/deploy'\n }\n }\n }\n }\n}\n<\/code><\/pre>\nIn this Jenkinsfile, we defined three stages: Build, Test, and Deploy, making the process easy to visualize and manage.<\/p>\n
Common Practices for CI\/CD with Jenkins<\/h2>\nVersion Control Everything<\/h3>\n
Your Jenkins configurations, pipelines, and scripts should be version-controlled. Use Git to keep track of changes and share your Jenkinsfile with your team. <\/p>\n
Monitor and Optimize Performance<\/h3>\n
Regularly monitor your Jenkins jobs. Look for bottlenecks, failed builds, and slow tests to enhance overall performance. Jenkins provides various plugins for monitoring, helping ensure your CI\/CD pipeline remains efficient.<\/p>\n
Backup Your Configuration<\/h3>\n
Familiarize yourself with Jenkins backup plugins to avoid losing configuration. Regular backups can save critical time in case of failures.<\/p>\n
Conclusion<\/h2>\n
Implementing CI\/CD with Jenkins can seem daunting initially, but by breaking it down into manageable steps, you can simplify the process significantly. By setting up a basic Jenkins job, integrating testing, and automating your deployment process, you can enhance your development workflow and improve product quality. As you continue to experiment and explore, the flexibility and power of Jenkins will enable you to support even the most complex CI\/CD scenarios.<\/p>\n
Start today and transform the way you develop, integrate, and deploy applications with Jenkins!<\/p>\n","protected":false},"excerpt":{"rendered":"
Implementing CI\/CD with Jenkins: A Comprehensive Guide Continuous Integration (CI) and Continuous Deployment (CD) are pivotal practices in modern software development that allow teams to deliver high-quality software at an unprecedented speed. Jenkins is one of the most widely used open-source automation servers that supports these practices. In this blog, we will delve into how<\/p>\n","protected":false},"author":77,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"footnotes":""},"categories":[289,247],"tags":[379,380],"class_list":{"0":"post-9457","1":"post","2":"type-post","3":"status-publish","4":"format-standard","6":"category-continuous-integration-continuous-deployment","7":"category-software-engineering-and-development-practices","8":"tag-continuous-integration-continuous-deployment-ci-cd","9":"tag-software-engineering-and-development-practices"},"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/namastedev.com\/blog\/wp-json\/wp\/v2\/posts\/9457","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/namastedev.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/namastedev.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/namastedev.com\/blog\/wp-json\/wp\/v2\/users\/77"}],"replies":[{"embeddable":true,"href":"https:\/\/namastedev.com\/blog\/wp-json\/wp\/v2\/comments?post=9457"}],"version-history":[{"count":1,"href":"https:\/\/namastedev.com\/blog\/wp-json\/wp\/v2\/posts\/9457\/revisions"}],"predecessor-version":[{"id":9458,"href":"https:\/\/namastedev.com\/blog\/wp-json\/wp\/v2\/posts\/9457\/revisions\/9458"}],"wp:attachment":[{"href":"https:\/\/namastedev.com\/blog\/wp-json\/wp\/v2\/media?parent=9457"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/namastedev.com\/blog\/wp-json\/wp\/v2\/categories?post=9457"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/namastedev.com\/blog\/wp-json\/wp\/v2\/tags?post=9457"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}