{"id":7677,"date":"2024-07-03T19:34:35","date_gmt":"2024-07-04T02:34:35","guid":{"rendered":"https:\/\/ioflood.com\/blog\/?p=7677"},"modified":"2024-07-03T19:34:35","modified_gmt":"2024-07-04T02:34:35","slug":"jenkins-installation-on-linux","status":"publish","type":"post","link":"https:\/\/ioflood.com\/blog\/jenkins-installation-on-linux\/","title":{"rendered":"Jenkins Installation on Linux | Develop Software Efficiently"},"content":{"rendered":"
\n
\"Tech<\/figure>\n<\/div>\n

Our software development processes at IOFLOOD<\/a> are greatly assisted with a properly configured Jenkins installation on Linux. This automated pipelines offers robust CI\/CD automation features that we believe could also be of use to our bare metal hosting<\/a> customers. This article delves into different installation methods for Jenkins on Linux, offering practical examples and techniques.<\/p>\n

In this guide, we will navigate the process of install Jenkins on Ubuntu and other Linux distros.<\/strong> We will provide you with installation instructions for both APT and YUM. We will also delve into more advanced topics like compiling Jenkins from source and installing a specific version. Finally, we will guide you on how to use Jenkins and verify that the correct version is installed.<\/p>\n

So, let’s dive in and begin installing Jenkins on your Linux system!<\/p>\n

TL;DR: How Do I Install Jenkins on Linux?<\/h2>\n

\n You can install Jenkins on Ubuntu by first adding the Jenkins repository and its key, then using sudo apt-get install jenkins<\/code>. For RPM-based systems like CentOS, run sudo yum install jenkins<\/code>.\n<\/p><\/blockquote>\n

For example:<\/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 -\nsudo sh -c 'echo deb http:\/\/pkg.jenkins.io\/debian-stable binary\/ > \/etc\/apt\/sources.list.d\/jenkins.list'\nsudo apt update\nsudo apt install jenkins\n<\/code><\/pre>\n
This will install Jenkins on your Ubuntu system. However, this is just the basic way to install Jenkins on Linux. There’s much more to learn about installing Jenkins, including advanced installation methods, configurations, and troubleshooting common issues. Continue reading for a more detailed guide on how to install Jenkins on Linux.<\/p>\n
Intro to Jenkins Installation on Linux<\/h2>\n
Jenkins is an open-source automation server that helps automate the parts of software development related to building, testing, and deploying, facilitating continuous integration and continuous delivery. It’s a server-based system that runs in servlet containers such as Apache Tomcat.<\/p>\n
Jenkins supports version control tools, including AccuRev, CVS, Subversion, Git, Mercurial, Perforce, ClearCase, and RTC, and can execute Apache Ant, Apache Maven, and sbt based projects as well as arbitrary shell scripts and Windows batch commands.<\/p>\n
Let’s get started with the installation process. We’ll cover the installation using two popular package managers: apt<\/code> and yum<\/code>.<\/p>\n
Install Jenkins on Ubuntu with APT<\/h3>\n
APT is the package manager for Ubuntu and similar systems. Here’s how you can install Jenkins using APT:<\/p>\n
# Update the system\nsudo apt update\n\n# Install Java\nsudo apt install openjdk-11-jdk\n\n# Add the Jenkins Debian repository\nwget -q -O - https:\/\/pkg.jenkins.io\/debian\/jenkins.io.key | sudo apt-key add -\nsudo sh -c 'echo deb http:\/\/pkg.jenkins.io\/debian-stable binary\/ > \/etc\/apt\/sources.list.d\/jenkins.list'\n\n# Update the system again\nsudo apt update\n\n# Install Jenkins\nsudo apt install jenkins\n\n# Check Jenkins status\nsystemctl status jenkins\n\n# Output:\n# \u25cf jenkins.service - LSB: Start Jenkins at boot time\n#    Loaded: loaded (\/etc\/init.d\/jenkins; generated)\n#    Active: active (exited) since Tue 2022-03-01 10:33:37 PST; 2min 15s ago\n<\/code><\/pre>\n
This will install Jenkins and start it automatically. The systemctl status<\/code> command is used to check the status of the Jenkins service. If it’s active, it means Jenkins is running successfully.<\/p>\n
Install Jenkins on Linux with YUM<\/h3>\n
YUM is the package manager for Red Hat-based systems. Here’s how you can install Jenkins using YUM:<\/p>\n
# Update the system\nsudo yum update\n\n# Install Java\nsudo yum install java-1.8.0-openjdk-devel\n\n# Add the Jenkins repository\nsudo wget -O \/etc\/yum.repos.d\/jenkins.repo http:\/\/pkg.jenkins-ci.org\/redhat\/jenkins.repo\nsudo rpm --import https:\/\/jenkins-ci.org\/redhat\/jenkins-ci.org.key\n\n# Install Jenkins\nsudo yum install jenkins\n\n# Start Jenkins\nsudo systemctl start jenkins\n\n# Enable Jenkins to start at boot\nsudo systemctl enable jenkins\n\n# Check Jenkins status\nsudo systemctl status jenkins\n\n# Output:\n# \u25cf jenkins.service - LSB: Jenkins Automation Server\n#    Loaded: loaded (\/etc\/rc.d\/init.d\/jenkins; bad; vendor preset: disabled)\n#    Active: active (running) since Tue 2022-03-01 10:33:37 PST; 2min 15s ago\n<\/code><\/pre>\n
This will install Jenkins and start it automatically. The systemctl status<\/code> command is used to check the status of the Jenkins service. If it’s active, it means Jenkins is running successfully.<\/p>\n
Install Jenkins from Source Code<\/h2>\n
For those who prefer to compile from source code, Jenkins provides that option. This method allows you to access the latest features and bug fixes immediately after they are committed to the repository.<\/p>\n
# Clone the Jenkins repository\n\ngit clone https:\/\/github.com\/jenkinsci\/jenkins.git\n\n# Switch to the directory\n\ncd jenkins\n\n# Compile the source code using Maven\n\nmvn -B -DskipTests clean package\n\n# Output:\n# [INFO] BUILD SUCCESS\n<\/code><\/pre>\n
This will compile Jenkins and create a .war<\/code> file in the target<\/code> directory, which you can run using Java.<\/p>\n
Installing Different Jenkins Versions<\/h2>\n
Different versions of Jenkins come with different features and bug fixes. Depending on your requirements, you might want to install a specific version of Jenkins.<\/p>\n
Installing Specific Versions from Source<\/h3>\n
You can check out a specific version in the Jenkins repository and compile it.<\/p>\n
# Check out a specific version\n\ngit checkout jenkins-2.263.4\n\n# Compile the source code\n\nmvn -B -DskipTests clean package\n\n# Output:\n# [INFO] BUILD SUCCESS\n<\/code><\/pre>\n
This will compile the specific version of Jenkins and create a .war<\/code> file in the target<\/code> directory.<\/p>\n
Installing Specific Versions with APT and YUM<\/h3>\n
You can also install a specific version of Jenkins using APT or YUM.<\/p>\n
# APT\n\nsudo apt install jenkins=2.263.4\n\n# YUM\n\nsudo yum install jenkins-2.263.4\n<\/code><\/pre>\n
Jenkins Version Comparison<\/h3>\n\n\n\n\n\n\n\n
Version<\/th>\nKey Changes<\/th>\nCompatibility<\/th>\n<\/tr>\n<\/thead>\n
2.263.4<\/td>\nSecurity fixes<\/td>\nJava 8, Java 11<\/td>\n<\/tr>\n
2.277.1<\/td>\nNew password encryption<\/td>\nJava 11<\/td>\n<\/tr>\n
2.289.1<\/td>\nUpdate Center improvements<\/td>\nJava 11<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Using Jenkins Installation on Linux<\/h2>\n
After installing Jenkins, you can access it at http:\/\/localhost:8080<\/code>. The first time you access it, you’ll be asked to unlock Jenkins using the initial admin password.<\/p>\n
# Display the initial admin password\n\nsudo cat \/var\/lib\/jenkins\/secrets\/initialAdminPassword\n\n# Output:\n# 7d33ff5c543f4c4aae0891a7055e5b1e\n<\/code><\/pre>\n
You can then enter this password in the Jenkins setup wizard in your browser to unlock Jenkins and complete the setup.<\/p>\n
To check the version of Jenkins you have installed, you can use the --version<\/code> option.<\/p>\n
# Check Jenkins version\n\njava -jar \/usr\/share\/jenkins\/jenkins.war --version\n\n# Output:\n# Jenkins ver. 2.263.4\n<\/code><\/pre>\n
This will display the version of Jenkins that is currently installed.<\/p>\n
Install Jenkins on Linux with Docker<\/h2>\n
Docker is a platform that simplifies software deployment using containerization. It allows you to package an application with all of its dependencies into a standardized unit for software development. Jenkins provides official Docker images that you can use.<\/p>\n
# Pull the latest Jenkins Docker image\n\ndocker pull jenkins\/jenkins:lts\n\n# Run Jenkins in a Docker container\n\ndocker run -d -p 8080:8080 -p 50000:50000 jenkins\/jenkins:lts\n\n# Output:\n# 2d526e791a3a9f0a8006e5179bb77c3a3791f2b448fea6b7c288a6a8e3e4a211\n<\/code><\/pre>\n
This will download the latest Jenkins LTS Docker image and run it in a new Docker container. You can then access Jenkins at http:\/\/localhost:8080<\/code>.<\/p>\n
Install Jenkins on Linux with Kubernetes<\/h3>\n
Kubernetes is an open-source platform designed to automate deploying, scaling, and operating application containers. Jenkins provides a Helm chart that you can use to deploy Jenkins on Kubernetes.<\/p>\n
# Add the Jenkins Helm repository\n\nhelm repo add jenkins https:\/\/charts.jenkins.io\nhelm repo update\n\n# Install Jenkins\n\nhelm install my-jenkins jenkins\/jenkins\n\n# Output:\n# NAME: my-jenkins\n# LAST DEPLOYED: Tue Mar  1 15:37:31 2022\n# NAMESPACE: default\n# STATUS: deployed\n# REVISION: 1\n# NOTES:\n# 1. Get your 'admin' user password by running:\n#   printf $(kubectl get secret --namespace default my-jenkins -o jsonpath=\"{.data.jenkins-admin-password}\" | base64 --decode);echo\n# 2. Get the Jenkins URL to visit by running these commands in the same shell:\n#   NOTE: It may take a few minutes for the LoadBalancer IP to be available.\n#         You can watch the status of by running 'kubectl get svc --namespace default -w my-jenkins'\n#   export SERVICE_IP=$(kubectl get svc --namespace default my-jenkins --template \"{{ range (index .status.loadBalancer.ingress 0) }}{{.}}{{ end }}\")\n#   echo http:\/\/$SERVICE_IP:8080\/login\n<\/code><\/pre>\n
This will deploy Jenkins on your Kubernetes cluster. You can then access Jenkins at the URL provided in the output.<\/p>\n
Jenkins Installation Comparison<\/h3>\n\n\n\n\n\n\n\n\n
Method<\/th>\nComplexity<\/th>\nFlexibility<\/th>\nUpdates<\/th>\n<\/tr>\n<\/thead>\n
Package Manager<\/td>\nLow<\/td>\nLow<\/td>\nDepends on repository<\/td>\n<\/tr>\n
Source Code<\/td>\nHigh<\/td>\nHigh<\/td>\nImmediate<\/td>\n<\/tr>\n
Docker<\/td>\nMedium<\/td>\nMedium<\/td>\nDepends on image<\/td>\n<\/tr>\n
Kubernetes<\/td>\nHigh<\/td>\nHigh<\/td>\nDepends on chart<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Each installation method has its advantages and disadvantages. While installing from a package manager or Docker might be easier, compiling from source or deploying on Kubernetes offers more flexibility. The best method depends on your specific needs and environment.<\/p>\n
Solving Issues: Jenkins Install<\/h2>\n
Even with the best of guides, you might encounter issues when installing Jenkins on Linux. Let’s discuss some common problems and their solutions.<\/p>\n
Jenkins Service Fails to Start<\/h3>\n
After installation, you might find that the Jenkins service fails to start. This is often due to insufficient memory. Jenkins requires at least 256 MB of memory to run.<\/p>\n
# Check system memory\nfree -m\n\n# Output:\n#               total        used        free      shared  buff\/cache   available\n# Mem:           1990         380         130          19        1479        1440\n# Swap:          2047           0        2047\n<\/code><\/pre>\n
The free -m<\/code> command displays the total, used, and free memory in MB. If you have less than 256 MB of free memory, you might need to increase your system’s memory.<\/p>\n
Jenkins Web Interface is Unavailable<\/h3>\n
After starting the Jenkins service, you might find that the web interface is not available at http:\/\/localhost:8080<\/code>. This could be due to a firewall blocking the port.<\/p>\n
# Check if port 8080 is open\nsudo ufw status\n\n# Output:\n# Status: active\n#\n# To                         Action      From\n# --                         ------      ----\n# 8080                       ALLOW       Anywhere\n# 8080 (v6)                  ALLOW       Anywhere (v6)\n<\/code><\/pre>\n
The sudo ufw status<\/code> command displays the status of the firewall. If port 8080 is not allowed, you can open it using the sudo ufw allow 8080<\/code> command.<\/p>\n
Jenkins is Slow or Unresponsive<\/h3>\n
If Jenkins is slow or unresponsive, it could be due to a large number of builds or jobs. You can manage this by setting up job retention policies in the Jenkins settings.<\/p>\n
# Display number of builds\nls \/var\/lib\/jenkins\/jobs\/*\/builds | wc -l\n\n# Output:\n# 500\n<\/code><\/pre>\n
The ls \/var\/lib\/jenkins\/jobs\/*\/builds | wc -l<\/code> command displays the number of builds. If this number is large, consider setting up job retention policies.<\/p>\n
Remember, troubleshooting is a normal part of any software installation process. Don’t be discouraged if you encounter issues. With persistence and the right resources, you’ll have Jenkins up and running on your Linux system in no time.<\/p>\n
Core Concepts of CI\/CD<\/h2>\n
Jenkins, an open-source automation server, has revolutionized the software development landscape. It’s not just a tool; it’s a complete ecosystem for Continuous Integration (CI)<\/strong> and Continuous Delivery (CD)<\/strong>. But what does that mean?<\/p>\n
Understanding Continuous Integration (CI)<\/h3>\n
Continuous Integration is a development practice that requires developers to integrate code into a shared repository several times a day. Each check-in is then verified by an automated build, allowing teams to detect problems early.<\/p>\n
# Example of a developer pushing changes to a shared repository\n\ngit add .\ngit commit -m \"Integrate new feature\"\ngit push origin main\n\n# Output:\n# [main 9a377c6] Integrate new feature\n#  1 file changed, 1 insertion(+), 1 deletion(-)\n# Counting objects: 3, done.\n# Delta compression using up to 8 threads.\n# Compressing objects: 100% (3\/3), done.\n# Writing objects: 100% (3\/3), 352 bytes | 352.00 KiB\/s, done.\n# Total 3 (delta 2), reused 0 (delta 0)\n# remote: Resolving deltas: 100% (2\/2), completed with 2 local objects.\n# To github.com:username\/repo.git\n#    1a2b3c4..5d6e7f8  main -> main\n<\/code><\/pre>\n
In the above example, a developer makes changes to the code, commits those changes, and pushes them to a shared repository. Jenkins can then pull this code and build it, ensuring the changes integrate correctly with the existing codebase.<\/p>\n
Grasping Continuous Delivery (CD)<\/h3>\n
Continuous Delivery is an extension of continuous integration to make sure that you can release new changes to your customers quickly in a sustainable way. This means that on top of having automated your testing, you also have automated your release process and you can deploy your application at any point of time by clicking on a button.<\/p>\n
# Example of Jenkins automating the deployment process\n\necho \"Deploying application...\"\n\n# Output:\n# Deploying application...\n<\/code><\/pre>\n
In this simplified example, Jenkins automates the deployment process, allowing you to deploy your application at any time.<\/p>\n
What is Jenkins Used For?<\/h2>\n
Jenkins is more than just a tool; it’s a critical player in the DevOps landscape. It can automate various stages of your delivery pipeline and is used in conjunction with other tools to form a complete CI\/CD pipeline, facilitating DevOps practices.<\/p>\n
Jenkins Pipelines: Streamlining CI\/CD<\/h3>\n
Jenkins Pipelines are a suite of plugins that support implementing and integrating continuous delivery pipelines into Jenkins. A pipeline has an extensible automation server for creating simple or complex delivery pipelines “as code” via pipeline DSL (Domain-specific Language).<\/p>\n
# Example of a Jenkins Pipeline script\n\npipeline {\n    agent any\n\n    stages {\n        stage('Build') {\n            steps {\n                echo 'Building..'\n            }\n        }\n        stage('Test') {\n            steps {\n                echo 'Testing..'\n            }\n        }\n        stage('Deploy') {\n            steps {\n                echo 'Deploying....'\n            }\n        }\n    }\n}\n\n# Output:\n# [Pipeline] echo\n# Building..\n# [Pipeline] echo\n# Testing..\n# [Pipeline] echo\n# Deploying....\n<\/code><\/pre>\n
In this example, a Jenkins Pipeline script defines three stages: Build, Test, and Deploy. Jenkins will execute these stages in order, providing a streamlined CI\/CD pipeline.<\/p>\n
Jenkins Plugins: Enhancing Functionality<\/h3>\n
Jenkins’ functionality can be extended with plugins. There are over a thousand plugins available for Jenkins to integrate with various platforms and tools.<\/p>\n
# Example of installing a Jenkins plugin\n\necho \"Installing Git plugin...\"\n\n# Output:\n# Installing Git plugin...\n<\/code><\/pre>\n
In this simplified example, a Jenkins plugin (Git plugin in this case) is installed, allowing Jenkins to integrate with Git.<\/p>\n
Further Resources for Jenkins Mastery<\/h3>\n
Want to dive deeper into Jenkins? Here are some resources to help you on your journey:<\/p>\n
    \n
  1. Official Jenkins Documentation<\/a>: The official documentation provides comprehensive information on various topics, from how to install jenkins on ubuntu to plugins and pipelines.<\/p>\n<\/li>\n
  2. \n
    Definitive Jenkins Installation on Linux Guide<\/a>: Provides a detailed guide on what is Jenkins used for continuous integration on a project.<\/p>\n<\/li>\n
  3. \n
    How to Install Jenkins in Linux Interactive Course<\/a>: Covers the basics of Jenkins and how to install Jenkins in Linux.<\/p>\n<\/li>\n<\/ol>\n
    Recap: Jenkins Installation on Linux<\/h2>\n
    In this comprehensive guide, we’ve delved into the process of installing Jenkins on Linux, an essential step in setting up a robust CI\/CD pipeline. Jenkins, as we’ve seen, is a powerful automation server that orchestrates your software build, test, and deployment tasks, making it an invaluable tool in the DevOps landscape.<\/p>\n
    We started with the basics, guiding you through a step-by-step process of installing Jenkins on Linux for beginners. We then moved on to more advanced topics, discussing how to compile Jenkins from source, install specific versions, and verify the installed version. We also explored alternative approaches to installing Jenkins, such as using Docker or Kubernetes, each with its own advantages and disadvantages.<\/p>\n
    We addressed common issues you might encounter during installation and provided solutions to help you troubleshoot effectively. Throughout the guide, we provided practical examples to help you understand the concepts better and get hands-on experience.<\/p>\n
    Here’s a quick comparison of the methods we’ve discussed:<\/p>\n\n\n\n\n\n\n\n\n
    Method<\/th>\nComplexity<\/th>\nFlexibility<\/th>\nUpdates<\/th>\n<\/tr>\n<\/thead>\n
    Package Manager<\/td>\nLow<\/td>\nLow<\/td>\nDepends on repository<\/td>\n<\/tr>\n
    Source Code<\/td>\nHigh<\/td>\nHigh<\/td>\nImmediate<\/td>\n<\/tr>\n
    Docker<\/td>\nMedium<\/td>\nMedium<\/td>\nDepends on image<\/td>\n<\/tr>\n
    Kubernetes<\/td>\nHigh<\/td>\nHigh<\/td>\nDepends on chart<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
    Whether you’re a beginner just starting out with Jenkins or an experienced developer looking to brush up your skills, we hope this guide has provided you with a deeper understanding of the installation process and its nuances.<\/p>\n
    The ability to install and configure Jenkins effectively is a crucial skill in today’s DevOps-oriented industry. With this guide, you’re now equipped to take on this task confidently. Happy coding!<\/p>\n","protected":false},"excerpt":{"rendered":"
    Our software development processes at IOFLOOD are greatly assisted with a properly configured Jenkins installation on Linux. This automated pipelines offers robust CI\/CD automation features that we believe could also be of use to our bare metal hosting customers. This article delves into different installation methods for Jenkins on Linux, offering practical examples and techniques. […]<\/p>\n","protected":false},"author":1,"featured_media":21739,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[3],"tags":[],"class_list":["post-7677","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-linux","cat-3-id","has_thumb"],"_links":{"self":[{"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/posts\/7677","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/comments?post=7677"}],"version-history":[{"count":19,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/posts\/7677\/revisions"}],"predecessor-version":[{"id":21799,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/posts\/7677\/revisions\/21799"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/media\/21739"}],"wp:attachment":[{"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/media?parent=7677"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/categories?post=7677"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/ioflood.com\/blog\/wp-json\/wp\/v2\/tags?post=7677"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}