Learn Jenkins - Pre-Requisites Skill & Environment Setup

#Introduction

Welcome to the Learn Jenkins series! Jenkins is the world's most popular self-hosted automation server, and mastering it is one of the gateways into the DevOps Engineer, Release Engineer, and even SRE roles. But before touching Jenkins, there are three foundations you need to hold onto firmly: Linux CLI navigation, basic Git concepts, and shell scripting fundamentals. Without these three, you will struggle to follow the upcoming episodes — because almost all Jenkins work ultimately comes down to running commands on a server, using commit results, and writing automation scripts.

Episode 0 is the foundation layer. We will dig into these three skills, set up Jenkins in your environment through two paths — Docker as the primary recommendation and a native Ubuntu/Debian installation as an alternative — then complete the Initial Setup Wizard until Jenkins is ready to accept its first build. By the end of this episode, you will have Jenkins running on localhost:8080 and enough understanding to move on to episode 1 about history and architecture.

#Main Discussion

#Foundational Skill 1: Linux CLI Navigation

Both the Jenkins controller and its agents almost always run on Linux servers without a GUI. You will spend a lot of time in the terminal, so navigation should feel natural. Here is a quick exercise:

pwd
cd /home
mkdir project
cd project
touch hello.txt
ls -la

The essential commands you must master: pwd to view the current directory, ls -la to list files including hidden ones, cd to change directories, mkdir to create directories, cp/mv/rm to copy, move, and delete files, and cat to read file contents. Note this basic pattern: every command takes the form command [options] [arguments] — for example ls -la /var/lib.

#Foundational Skill 2: Basic Git Concepts

Jenkins needs access to Git because the Pipeline as Code concept (which we will learn in episode 2) stores the build definition inside the repository. Three concepts are non-negotiable:

git init
git add .
git commit -m "first commit"
git branch feature/login
git checkout feature/login
git log --oneline

The important mental model: a commit is a checkpoint you can restore at any time, and a branch is a way to develop a feature without breaking the main line. Jenkins will leverage both to trigger builds per commit and per branch. If you have never run git add and git commit, make time to read the learn-git series before episode 2.

#Foundational Skill 3: Shell Scripting Basics

Jenkins runs builds by invoking a shell. The ability to write bash scripts is what separates those who merely "run Jenkins" from those who "build great pipelines". Here is the most basic example representing a day-to-day pattern:

#!/bin/bash
PROJECT="my-app"
BUILD_DIR="./build"
mkdir -p "$BUILD_DIR"
echo "Building $PROJECT"
if [ -d "$BUILD_DIR" ]; then
    echo "Build directory is ready"
fi

Three things you must understand: variables (values are assigned without $, and used with $), conditionals with if, and exit codes — a successful command returns 0, and Jenkins uses this exit code to determine whether a build succeeded or failed. The learn-bash-scripting series on this blog is a highly recommended companion read.

#Setting Up Jenkins via Docker (Primary Recommendation)

The fastest, cleanest, and most consistent way across machines is to run Jenkins inside a container. The official Long Term Support image for 2026 is jenkins/jenkins:lts-jdk17 (the lts-jdk21 variant is also available if you need a newer JDK). Make sure Docker is installed, then run:

docker run -d --name jenkins --restart unless-stopped \
  -p 8080:8080 -p 50000:50000 \
  -v jenkins_home:/var/jenkins_home \
  jenkins/jenkins:lts-jdk17

Let's break down the options:

Two important decisions here: we reserve port 50000 from the start because the Jenkins agent architecture needs it, and the jenkins_home volume is the lifeline of Jenkins — all configuration, credentials, and build history live there. Once the container is running, verify:

docker ps
docker logs jenkins

#Native Installation on Ubuntu/Debian (Alternative)

If you prefer not to depend on Docker, Jenkins can also be installed directly as a systemd service. Run the following steps on Ubuntu/Debian:

sudo curl -fsSL https://pkg.jenkins.io/debian-stable/jenkins.io-2023.key | sudo tee /usr/share/keyrings/jenkins-keyring.asc > /dev/null
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
sudo apt-get update
sudo apt-get install -y fontconfig openjdk-17-jre jenkins
sudo systemctl enable --now jenkins
sudo systemctl status jenkins

In a native installation, Jenkins data lives in /var/lib/jenkins (known as JENKINS_HOME), and the service is managed with sudo systemctl status jenkins as well as sudo journalctl -u jenkins -f to view real-time logs. The advantage: full control over the service and systemd; the downside: the environment is less isolated than Docker.

#Initial Setup Wizard

Regardless of the installation method, the next steps are the same. Open http://localhost:8080 in your browser, and Jenkins will display the first-time setup wizard.

Step 1 — Unlock Jenkins. Jenkins provides a random password stored in the container data. Fetch it with the command matching your installation method:

docker exec jenkins cat /var/jenkins_home/secrets/initialAdminPassword
sudo cat /var/lib/jenkins/secrets/initialAdminPassword

Paste the password into the Administrator password form, then continue.

Step 2 — Install Suggested Plugins. Jenkins offers two options: install the suggested plugins or choose your own. For the beginning, select Install suggested plugins — Jenkins will automatically download the Git, Pipeline, and dozens of other basic plugins. This can take a few minutes.

Step 3 — Create the first Admin User. Fill in the name, username, password, and email. This user is the administrator who will manage Jenkins; store the credentials in a password manager, because from this point on initialAdminPassword will no longer work.

Step 4 — Instance Configuration. Jenkins shows the instance URL — leave the default http://localhost:8080, then click Save and Finish.

#Common Setup Mistakes

1. Port 8080 is already in use. The error port is already allocated appears. The solution is to change the host port, e.g. -p 8081:8080.
2. Bind mount volume issues. If you use a bind mount (-v /data/jenkins:/var/jenkins_home), the host directory must be owned by a user with UID 1000 (the jenkins user inside the image). A named volume (jenkins_home) avoids this problem entirely.
3. Ignoring updates. Jenkins LTS regularly releases security fixes. On a native installation, schedule sudo apt-get update && sudo apt-get upgrade jenkins periodically.

#Conclusion

In episode 0 you have set up a complete foundation for learning Jenkins:

• Three prerequisite skills: Linux CLI navigation (cd, ls, cat), basic Git (add, commit, branch), and shell scripting basics (#!/bin/bash, variables, if, exit codes).
• Jenkins installation via Docker with the jenkins/jenkins:lts-jdk17 image, a jenkins_home volume, and ports 8080/50000.
• Native Ubuntu/Debian installation as an alternative, complete with systemctl and JENKINS_HOME at /var/lib/jenkins.
• Completing the Initial Setup Wizard: unlocking with initialAdminPassword, installing suggested plugins, and creating the first admin user.

Your Jenkins is now alive and ready to accept jobs. In episode 1 we will take a pause from typing and understand Jenkins history, concepts, and core architecture — from the Hudson project in 2004, why Jenkins remains dominant in enterprises, how the controller and agents work together, to the difference between a Freestyle Project and a Jenkins Pipeline. See you in episode 1!