Installation Overview

There are three ways to install Jenkins — and picking the wrong one for your situation will cause you headaches for months. This lesson walks through all three so you know exactly which one to choose before you run a single command.

Installing Jenkins isn't hard. But teams often install it the fastest way rather than the right way — and then six months later they're dealing with Java version conflicts, manual upgrade pain, or a Jenkins instance that can't be moved to a new server without hours of work. A few minutes of planning here saves a lot of pain later.

The Three Installation Methods

Think of these three methods like three ways to set up a workspace. You could rent a desk in a co-working space (Docker — quick, self-contained, easy to pack up). You could lease a dedicated office in a building managed by someone else (cloud — someone else handles the building, you manage your space). Or you could own and build your own office from scratch on your own land (native install — total control, total responsibility).

Each approach has a time and a place. Here's the full picture:

What You Need Before Any Install

Regardless of which method you choose, there is one hard requirement: Java. Jenkins is a Java application. No Java, no Jenkins. Full stop.

Jenkins requires Java 17 or Java 21 as of the current LTS release. Java 11 was previously supported but is now end-of-life for Jenkins. This trips up a lot of people who have an older Java version already on their system and wonder why Jenkins won't start.

Method 1 — Native Install on Linux (Ubuntu)

This is the most common production install method. Jenkins gets installed directly onto a Linux server — just like installing any other software package. Once it's running, it starts automatically on boot and behaves like any other system service.

The scenario:

You're a DevOps engineer at a logistics company. Your team has been given a fresh Ubuntu 22.04 server to run Jenkins on. No Docker, no Kubernetes — just a clean Linux box. Your job is to get Jenkins installed and running as a system service before end of day. These are the exact commands you'd run.

Tools used in these commands:

• apt — Ubuntu's package manager. Think of it as the App Store for Linux. It downloads and installs software from trusted sources called repositories.
• wget — a command-line tool that downloads files from the internet. We use it to download the Jenkins repository signing key.
• systemctl — a Linux tool for managing system services. It lets you start, stop, restart, and check the status of background programs like Jenkins.
• curl — another download tool, similar to wget. Used here to get the Jenkins repository configuration file.

# Step 1: Install Java 21 — Jenkins will not start without this
sudo apt update
sudo apt install -y fontconfig openjdk-21-jre

# Confirm Java installed correctly — you should see "openjdk version 21..."
java -version

# Step 2: Add the Jenkins package repository so apt knows where to find Jenkins
# Download the Jenkins repo signing key — this proves the packages are genuine
sudo wget -O /usr/share/keyrings/jenkins-keyring.asc \
  https://pkg.jenkins.io/debian-stable/jenkins.io-2023.key

# Add the Jenkins repo to apt's list of sources
echo "deb [signed-by=/usr/share/keyrings/jenkins-keyring.asc]" \
  https://pkg.jenkins.io/debian-stable binary/ | \
  sudo tee /etc/apt/sources.list.d/jenkins.list > /dev/null

# Step 3: Install Jenkins now that apt knows where to find it
sudo apt update
sudo apt install -y jenkins

# Step 4: Start Jenkins and enable it to start automatically on every reboot
sudo systemctl start jenkins
sudo systemctl enable jenkins

# Step 5: Check Jenkins is actually running — look for "active (running)"
sudo systemctl status jenkins

● jenkins.service - Jenkins Continuous Integration Server
     Loaded: loaded (/lib/systemd/system/jenkins.service; enabled; vendor preset: enabled)
     Active: active (running) since Wed 2024-03-13 09:14:22 UTC; 5s ago
   Main PID: 3821 (java)
      Tasks: 38 (limit: 4915)
     Memory: 312.4M
        CPU: 18.432s
     CGroup: /system.slice/jenkins.service
             └─3821 /usr/bin/java -Djava.awt.headless=true -jar /usr/share/jenkins/jenkins.war

Mar 13 09:14:22 jenkins-master-01 systemd[1]: Started Jenkins Continuous Integration Server.
Mar 13 09:14:26 jenkins-master-01 jenkins[3821]: Jenkins initial setup is required.
Mar 13 09:14:26 jenkins-master-01 jenkins[3821]: Please use the following password to proceed:
Mar 13 09:14:26 jenkins-master-01 jenkins[3821]: a3f2b1c9d4e5f6a7b8c9d0e1f2a3b4c5
Mar 13 09:14:26 jenkins-master-01 jenkins[3821]: This may also be found at:
Mar 13 09:14:26 jenkins-master-01 jenkins[3821]: /var/lib/jenkins/secrets/initialAdminPassword

Method 2 — Docker Install

Docker is a tool that packages software into isolated containers — self-contained boxes with everything the software needs to run, bundled together. For Jenkins, this means you don't need to install Java, worry about OS compatibility, or manage dependencies manually. You pull the Jenkins Docker image and it comes with everything pre-installed.

The scenario:

You're a backend developer who wants to learn Jenkins on your own laptop without touching your system's Java install or setting up a full server. Docker lets you spin up a complete Jenkins instance in one command and throw it away just as easily when you're done.

Tools used in this command:

• Docker — a platform that runs software in containers. A container is like a lightweight virtual machine — isolated from the rest of your system. Install Docker from docs.docker.com/get-docker before running this command.
• docker run — the command that starts a new container from an image. An image is a pre-built snapshot of software — like a template. Jenkins publishes official images to Docker Hub.
• -v (volume) — connects a folder on your machine to a folder inside the container so Jenkins data isn't lost when the container stops.

# Pull and run the official Jenkins LTS image
# LTS = Long Term Support — the stable release recommended for most users
docker run \
  --name jenkins-local \          # give the container a friendly name
  --detach \                      # run in background so your terminal stays free
  --publish 8080:8080 \           # map port 8080 on your machine to port 8080 in the container
  --publish 50000:50000 \         # port 50000 is used for agent connections
  --volume jenkins-data:/var/jenkins_home \  # save Jenkins data to a named volume
  jenkins/jenkins:lts-jdk21       # the official Jenkins image with Java 21 included

# Check the container started successfully
docker ps

# Read the initial admin password from inside the container
docker exec jenkins-local \
  cat /var/jenkins_home/secrets/initialAdminPassword

Unable to find image 'jenkins/jenkins:lts-jdk21' locally
lts-jdk21: Pulling from jenkins/jenkins
a378f10b3218: Pull complete
3a9bc1f49b47: Pull complete
Digest: sha256:4a2b...f1c9
Status: Downloaded newer image for jenkins/jenkins:lts-jdk21
e7d3a1b2c4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c0d1e2f3

CONTAINER ID   IMAGE                    COMMAND                  STATUS          PORTS
e7d3a1b2c4f5   jenkins/jenkins:lts-jdk21   "/usr/bin/tini -- /u…"   Up 12 seconds   0.0.0.0:8080->8080/tcp

a3f2b1c9d4e5f6a7b8c9d0e1f2a3b4c5

Which Method Should You Use?

Practice Questions

Quiz