Jenkins auf Rocky Linux 9 installieren für automatisierte CI/CD-Prozesse
Jenkins ist eine weit verbreitete Open-Source-Plattform zur Automatisierung, die speziell für kontinuierliche Integration (CI) und kontinuierliche Bereitstellung (CD) entwickelt wurde. Das in Java geschriebene Tool unterstützt Entwickler beim automatisierten Erstellen, Testen und Ausliefern von Software. Durch eine Vielzahl an Plugins lassen sich Testabläufe und Codeänderungen effizient verwalten.
Diese Anleitung beschreibt Schritt für Schritt die Installation von Jenkins auf Rocky Linux 9. Zudem lernst du, wie du die Einrichtung über das Webinterface und die Kommandozeile testest und Jenkins für maximale Leistung optimierst.
Voraussetzungen
Bevor du beginnst, stelle sicher, dass folgende Voraussetzungen erfüllt sind:
- Du hast Zugriff auf einen Rocky Linux 9 Server mit einem Benutzerkonto, das über
sudo-Rechte verfügt. - Ein DNS-A-Eintrag verweist auf die IP-Adresse deines Servers, z. B.
example.com.
Java installieren
Da Jenkins auf dem Java Development Kit (JDK) basiert, muss dieses mit allen notwendigen Abhängigkeiten installiert werden. So geht’s auf Rocky Linux 9:
Schritt 1: System aktualisieren
Aktualisiere die Paketinformationen deines Systems:
$ sudo dnf update -y
Schritt 2: OpenJDK 21 installieren
Installiere OpenJDK in Version 21 oder ersetze sie durch eine aktuellere Version von der offiziellen OpenJDK-Webseite:
$ sudo dnf install -y java-21-openjdk
Schritt 3: Falls nötig, auf OpenJDK 21 umstellen
Falls dein System standardmäßig eine ältere Java-Version nutzt, kannst du mit folgendem Befehl auf Version 21 wechseln:
$ sudo alternatives --config java
Die Ausgabe sieht beispielsweise so aus:
Es sind zwei Programme verfügbar, die 'java' bereitstellen. Auswahl Befehl ----------------------------------------------- *+ 1 java-1.8.0-openjdk.x86_64 (/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.442.b06-2.el9.x86_64/jre/bin/java) 2 java-21-openjdk.x86_64 (/usr/lib/jvm/java-21-openjdk-21.0.6.0.7-1.el9.x86_64/bin/java) Drücke Enter, um die aktuelle Auswahl beizubehalten, oder gib die Nummer der gewünschten Version ein:
Wähle 2, um OpenJDK 21 zu aktivieren.
Schritt 4: Java-Installation überprüfen
Mit folgendem Befehl prüfst du, ob Java korrekt installiert wurde:
$ java -version
Die erwartete Ausgabe:
openjdk 21.0.6 2025-01-21 LTS OpenJDK Runtime Environment (Red_Hat-21.0.6.0.7-1) (build 21.0.6+7-LTS) OpenJDK 64-Bit Server VM (Red_Hat-21.0.6.0.7-1) (build 21.0.6+7-LTS, mixed mode, sharing)
Jenkins installieren
Verwende den DNF-Paketmanager, um Jenkins auf deinem Rocky Linux 9 System zu installieren:
Schritt 1: Jenkins-Repository hinzufügen
Füge die aktuellste stabile Jenkins-Repositorydatei hinzu:
$ sudo wget https://pkg.jenkins.io/redhat-stable/jenkins.repo -O /etc/yum.repos.d/jenkins.repo
Schritt 2: GPG-Schlüssel importieren
Importiere den GPG-Schlüssel, der zu deiner Jenkins-Version passt:
$ sudo rpm --import https://pkg.jenkins.io/redhat-stable/jenkins.io-2023.key
Schritt 3: Jenkins installieren
Installiere Jenkins über DNF:
$ sudo dnf install -y jenkins
Schritt 4: Jenkins starten
Starte den Jenkins-Dienst:
$ sudo systemctl start jenkins
Schritt 5: Jenkins beim Booten aktivieren
Stelle sicher, dass Jenkins beim Systemstart automatisch ausgeführt wird:
$ sudo systemctl enable jenkins
Schritt 6: Jenkins-Status prüfen
Mit folgendem Befehl überprüfst du, ob Jenkins aktiv ist:
$ sudo systemctl status jenkins
Beispielausgabe:
● jenkins.service - Jenkins Continuous Integration Server
Loaded: loaded (/usr/lib/systemd/system/jenkins.service; enabled; preset: disabled)
Active: active (running) since Sun 2025-02-23 10:45:53 UTC; 21s ago
Main PID: 5166 (java)
Tasks: 44 (limit: 11059)
Memory: 407.4M
CPU: 12.385s
CGroup: /system.slice/jenkins.service
└─5166 /usr/bin/java -Djava.awt.headless=true -jar /usr/share/java/jenkins.war --webroot=/var/cache/jenkins/war --httpPort=8080
Feb 23 10:45:47 test-server jenkins[5166]: 69638179145e4a3fa6826e5fe6c427da
Feb 23 10:45:47 test-server jenkins[5166]: This may also be found at: /var/lib/jenkins/secrets/initialAdminPassword
Feb 23 10:45:47 test-server jenkins[5166]: *************************************************************
Feb 23 10:45:47 test-server jenkins[5166]: *************************************************************
Feb 23 10:45:47 test-server jenkins[5166]: *************************************************************
Feb 23 10:45:53 test-server jenkins[5166]: 2025-02-23 10:45:53.349+0000 [id=32] INFO jenkins.InitReactorRunner$1#onAttained: Completed initiali>
Feb 23 10:45:53 test-server jenkins[5166]: 2025-02-23 10:45:53.367+0000 [id=24] INFO hudson.lifecycle.Lifecycle#onReady: Jenkins is fully up an>
Feb 23 10:45:53 test-server systemd[1]: Started Jenkins Continuous Integration Server.
Feb 23 10:45:55 test-server jenkins[5166]: 2025-02-23 10:45:55.036+0000 [id=47] INFO h.m.DownloadService$Downloadable#load: Obtained the update>
Feb 23 10:45:55 test-server jenkins[5166]: 2025-02-23 10:45:55.038+0000 [id=47] INFO hudson.util.Retrier#start: Performed the action check upda>
Zugriff auf die Jenkins-Weboberfläche und erste Einrichtung abschließen
Bevor du Jenkins nutzen kannst, musst du die Weboberfläche freischalten und die grundlegende Konfiguration durchführen.
Schritt 1: Port 8080 in der Firewall freigeben
Standardmäßig nutzt Jenkins den Port 8080. Mit folgendem Befehl erlaubst du den Zugriff durch die Firewall:
$ sudo firewall-cmd --permanent --zone=public --add-port=8080/tcp
Aktualisiere die Firewall-Regeln anschließend mit:
$ sudo firewall-cmd --reload
Schritt 2: Administratives Startpasswort abrufen
Um Jenkins freizuschalten, brauchst du ein temporäres Passwort, das lokal gespeichert wurde. Mit diesem Befehl liest du es aus:
$ sudo cat /var/lib/jenkins/secrets/initialAdminPassword
Kopiere den ausgegebenen Wert. Dieser dient als einmaliges Administrator-Passwort.
Schritt 3: Jenkins im Browser aufrufen
Öffne http://example.com:8080 im Browser. Füge das kopierte Passwort in das Passwortfeld ein und klicke auf Continue.
Schritt 4: Vorgeschlagene Plugins installieren
Wähle Install suggested plugins, um empfohlene Erweiterungen automatisch installieren zu lassen.
Schritt 5: Administrator-Benutzer anlegen
Trage im Formular deine Benutzerdaten ein, um ein Administratorkonto zu erstellen. Klicke danach auf Save and Continue.
Schritt 6: Domain für Jenkins bestätigen
Bestätige die Adresse deiner Jenkins-Installation, z. B. example.com, und schließe den Vorgang mit Save and Finish ab.
Schritt 7: Dashboard aufrufen
Klicke auf Start using Jenkins, um zum Haupt-Dashboard zu gelangen und Jenkins vollständig zu nutzen.
Jenkins mit HTTPS absichern über Let’s Encrypt und Nginx
Mit den folgenden Schritten richtest du Nginx als Reverse Proxy ein und schützt Jenkins mit einem SSL-Zertifikat von Let’s Encrypt.
Schritt 1: Nginx installieren
Installiere zuerst den Webserver Nginx:
$ sudo dnf install nginx -y
Schritt 2: Certbot und Nginx-Plugin installieren
Installiere Certbot sowie das zugehörige Plugin für Nginx:
$ sudo dnf install -y certbot python3-certbot-nginx
Schritt 3: Webzugriff in der Firewall freigeben
Erlaube Datenverkehr über HTTP (Port 80) und HTTPS (Port 443):
$ sudo firewall-cmd --permanent --add-service=http
$ sudo firewall-cmd --permanent --add-service=https
$ sudo firewall-cmd --reload
Schritt 4: SSL-Zertifikat anfordern
Fordere mit Certbot ein SSL-Zertifikat für deine Domain an:
$ sudo certbot certonly --standalone -d example.com
Während der Zertifikatsanfrage wirst du von Certbot folgendes gefragt:
- Eine gültige E-Mail-Adresse zur Kontaktaufnahme
- Ob du den Nutzungsbedingungen zustimmst
- Optional, ob deine Adresse mit der Electronic Frontier Foundation geteilt werden darf
Nach dem Durchlauf erstellt Certbot ein gültiges TLS-Zertifikat für deine Domain.
Schritt 5: Nginx aktivieren und starten
Aktiviere Nginx beim Systemstart und starte den Dienst sofort:
$ sudo systemctl enable --now nginx
Schritt 6: Jenkins Netzwerkzugriff erlauben
Erlaube Jenkins Netzwerkverbindungen – erforderlich für die Kommunikation mit dem Proxy:
$ sudo setsebool -P httpd_can_network_connect 1
Schritt 7: Nginx für Jenkins konfigurieren
Öffne die Konfigurationsdatei von Nginx für Jenkins:
$ sudo nano /etc/nginx/conf.d/jenkins.conf
Füge die folgende Konfiguration ein, um Jenkins als Reverse Proxy bereitzustellen:
server {
listen 80;
server_name example.com;
return 301 https://$host$request_uri;
}
server {
listen 443 ssl;
server_name example.com;
ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
location / {
proxy_pass http://127.0.0.1:8080;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_set_header X-Forwarded-Host $host;
proxy_set_header X-Forwarded-Port $server_port;
# WebSocket-Unterstützung für Jenkins
proxy_http_version 1.1;
proxy_request_buffering off;
proxy_buffering off;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "Upgrade";
}
}
Hinweis: In der Direktive server_name nur den Domainnamen angeben – ohne https:// oder Slash am Ende.
Schritt 8: Nginx-Konfiguration testen und neu laden
Überprüfe die Konfiguration auf Syntaxfehler:
$ sudo nginx -t
Erwartete Ausgabe:
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok nginx: configuration file /etc/nginx/nginx.conf test is successful
Starte Nginx neu, um die Änderungen zu übernehmen:
$ sudo systemctl restart nginx
Schritt 9: Jenkins-URL aktualisieren und Dienst neu starten
Rufe https://example.com im Browser auf, um die Jenkins-Oberfläche sicher über HTTPS zu erreichen. Um Proxy-Fehler zu vermeiden, ändere die interne URL wie folgt:
- Gehe zu Manage Jenkins > System
- Scrolle zum Abschnitt Jenkins Location
- Ändere die URL von
http://example.com:8080aufhttps://example.com/ - Klicke auf Save, um die Änderungen zu speichern
Starte Jenkins neu, damit die neue URL übernommen wird:
$ sudo systemctl restart jenkins
Jenkins für mehr Leistung und Stabilität optimieren
Systemressourcen für Jenkins anpassen
Erhöhe die Anzahl gleichzeitig geöffneter Dateien, damit Jenkins mehr Prozesse effizient verarbeiten kann. Ändere dafür die Systemlimits wie folgt:
Öffne die Konfigurationsdatei für Ressourcenbeschränkungen:
$ sudo nano /etc/security/limits.conf
Füge direkt vor #End of file diese Zeilen ein, um die Datei-Limits für Jenkins zu erhöhen:
jenkins soft nofile 65536
jenkins hard nofile 65536
Speichere die Datei und starte Jenkins neu:
$ sudo systemctl restart jenkins
Überprüfe, ob die neuen Limits aktiv sind:
$ cat /proc/$(pgrep -u jenkins java)/limits | grep "open files"
Beispielausgabe:
Max open files 524288 524288 files
Jenkins-Backups automatisieren
Schütze deine Jenkins-Daten vor Verlust durch regelmäßige Sicherungen. Folge diesen Schritten, um tägliche Backups einzurichten:
Erstelle ein Verzeichnis für die Backup-Dateien:
$ mkdir ~/jenkins_backup
Kopiere die Jenkins-Daten manuell in das neue Verzeichnis:
$ sudo cp -r /var/lib/jenkins ~/jenkins_backup/
Öffne die Crontab-Konfiguration, um tägliche Backups um Mitternacht zu planen:
$ crontab -e
Füge folgende Zeile am Ende der Datei ein:
0 0 * * * sudo cp -r /var/lib/jenkins ~/jenkins_backup/
Überprüfe, ob der Cronjob erfolgreich gespeichert wurde:
$ crontab -l
Stelle sicher, dass der Cron-Dienst aktiv ist:
$ sudo systemctl status crond
Erwartete Statusausgabe:
● crond.service - Command Scheduler
Loaded: loaded (/usr/lib/systemd/system/crond.service; enabled; preset: enabled)
Active: active (running) since Sun 2025-02-23 10:43:02 UTC; 1h 18min ago
Main PID: 1348 (crond)
Tasks: 1 (limit: 11059)
Memory: 1.2M
CPU: 66ms
CGroup: /system.slice/crond.service
└─1348 /usr/sbin/crond -n
...
Jenkins über die Weboberfläche testen
Öffne Jenkins im Browser und melde dich im Dashboard an. Klicke auf Neues Item, gib z. B. TestJob als Namen ein, wähle den Typ Freestyle-Projekt aus und klicke auf OK.
Wechsle zum Abschnitt Build und klicke auf Build-Schritt hinzufügen > Shell ausführen.
Trage folgenden Befehl ein:
$ echo "Hello, Jenkins!"
Speichere den Job mit Speichern und starte ihn mit Jetzt bauen.
Nach dem Build klickst du auf den Build-Nummer-Link, z. B. #1, und anschließend auf Konsole-Ausgabe, um die Protokolle einzusehen. Wenn dort die Ausgabe erscheint, war die Einrichtung erfolgreich.
Jenkins über die Kommandozeile testen
Jenkins lässt sich auch über die CLI und die REST API bedienen. Öffne dazu das Dashboard, klicke auf deinen Benutzernamen oben rechts, navigiere zum Reiter Sicherheit und erstelle dort unter API-Token ein neues Token.
Lade anschließend die CLI-JAR-Datei herunter:
$ wget https://example.com/jnlpJars/jenkins-cli.jar
Verschiebe sie in ein passendes Verzeichnis deiner Wahl:
$ mv jenkins-cli.jar ~/jenkins-cli.jar
Teste die Verbindung zu Jenkins mit folgendem Befehl:
$ java -jar ~/jenkins-cli.jar -s https://example.com/ -auth your_username:your_api_token version
Erwartete Ausgabe:
2.492.1
Starte den TestJob per CLI:
$ java -jar ~/jenkins-cli.jar -s https://example.com/ -auth your_username:your_api_token build TestJob
Zeige die Konsolenausgabe des Jobs an:
$ java -jar ~/jenkins-cli.jar -s https://example.com/ -auth your_username:your_api_token console TestJob
Beispielausgabe:
Running as SYSTEM Building in workspace /var/lib/jenkins/workspace/TestJob [TestJob] $ /bin/sh -xe /tmp/jenkins132166175190200986.sh + echo 'Hello, Jenkins!' Hello, Jenkins! Finished: SUCCESS
Fazit
Du hast Jenkins erfolgreich auf Rocky Linux 9 installiert, die Umgebung abgesichert, Performance-Optimierungen umgesetzt und ein tägliches Backup eingerichtet. Über das Webinterface und die Kommandozeile konntest du die Funktionalität bestätigen. Jetzt kannst du Jenkins mit Git-Repositories verknüpfen, automatisierte Deployments erstellen und dein CI/CD-Setup beliebig erweitern. Weitere Details findest du in der offiziellen Jenkins-Dokumentation.
