Jenkins auf Ubuntu mit Docker Compose installieren

Jenkins ist eine beliebte Open-Source-Anwendung, die in Java entwickelt wurde und sich hervorragend zur Einrichtung von Continuous Integration und Continuous Deployment (CI/CD)-Pipelines eignet. Dadurch wird die Softwarebereitstellung deutlich beschleunigt. Jenkins spielt eine zentrale Rolle bei der Automatisierung des Softwareentwicklungsprozesses (SDLC). Diese Anleitung zeigt Schritt für Schritt, wie Jenkins auf einer Ubuntu-Instanz mithilfe von Docker Compose eingerichtet wird.

Systemvoraussetzungen

• Eine neu eingerichtete Cloud-Instanz mit Ubuntu 20.04 oder 18.04
• Docker und Docker Compose müssen auf dem Server installiert sein

Docker Compose-Datei für Jenkins erstellen

Erstelle zuerst ein Verzeichnis mit dem Namen jenkins-compose und darin eine Datei namens docker-compose.yml.

$ mkdir jenkins-compose

$ cd jenkins-compose

$ touch docker-compose.yml

Öffne nun die erstellte Datei mit einem Editor deiner Wahl:

$ nano docker-compose.yml

Füge folgendes Skript in die Datei docker-compose.yml ein:

version: '3.8'
services:
  jenkins:
    container_name: jenkins
    restart: always
    image: jenkins/jenkins:lts
    ports:
      - 8080:8080
    volumes:
      - jenkins-home:/var/jenkins_home

volumes:
  jenkins-home:

Aufbau der Compose-Datei verstehen

version: '3.8'

Diese Angabe definiert das Dateiformat der Docker Compose-Datei. Andere Versionen können zu Problemen mit dieser Konfiguration führen.

services:

In diesem Abschnitt werden alle Container aufgeführt, die durch Docker Compose gestartet werden. Jeder Container wird einzeln konfiguriert.

jenkins:
  container_name: jenkins
  restart: always
  image: jenkins/jenkins:lts
  ports:
    - 8080:8080
  volumes:
    - jenkins-home:/var/jenkins_home

Diese Konfiguration legt fest, wie der Jenkins-Container aufgebaut ist – einschließlich des Container-Namens, des Restart-Verhaltens, des verwendeten Images, der Portweiterleitungen und der Volumes.

Die Anweisung restart: always sorgt dafür, dass der Container nach einem Neustart des Systems automatisch wieder gestartet wird.

volumes:

Hier wird ein Volume namens jenkins-home definiert, das im Container verwendet wird, um dauerhaft Daten zu speichern.

Docker-Dienst starten

Nachdem die Docker-Compose-Datei erstellt wurde, solltest du den Docker-Dienst aktivieren und starten. Durch das Aktivieren wird sichergestellt, dass Docker beim Systemstart automatisch ausgeführt wird.

$ sudo systemctl enable docker.service

$ sudo systemctl start docker.service

Jenkins-Container starten

Mit der vorhandenen Docker-Compose-Datei kannst du Jenkins nun im Hintergrund starten, indem du folgenden Befehl ausführst:

$ docker-compose up -d

Dieser Befehl lädt das offizielle Jenkins-Image von Docker Hub herunter und startet den Container im Hintergrund.

Status des Containers prüfen

Um zu überprüfen, ob Jenkins erfolgreich läuft, verwende diesen Befehl:

$ docker-compose ps

SSL-Zertifikate für Jenkins mit Nginx aktivieren

Damit Jenkins über das HTTPS-Protokoll erreichbar ist, musst du den Nginx-Webserver einrichten, SSL-Zertifikate konfigurieren und den Datenverkehr an den Jenkins-Server weiterleiten.

Nginx-Webserver installieren

# apt install nginx -y

Nginx für Jenkins konfigurieren

Bearbeite die Standardkonfigurationsdatei von Nginx wie folgt:

# nano /etc/nginx/conf.d/default.conf

Füge folgenden Server-Block für deine Domain ein:

server {
  server_name example.com www.example.com
}

Um SSL zu aktivieren, folge einem passenden Let's Encrypt-Tutorial für Nginx. Dieses aktualisiert die Konfigurationsdatei automatisch mit den nötigen SSL-Einstellungen. Öffne sie anschließend erneut:

# nano /etc/nginx/conf.d/default.conf

Ergänze jetzt folgende Weiterleitungsregeln, um den Datenverkehr an Jenkins zu übergeben:

location / {
  proxy_pass http://127.0.0.1:8080;
  proxy_set_header Host $host;
  proxy_set_header X-Forwarded-For $remote_addr;
}

Beispielhafte Nginx-Endkonfiguration

Die finale Konfiguration deiner Nginx-Datei sieht wie folgt aus:

server {
  server_name example.com www.example.com;

    listen 443 ssl; # managed by Certbot
    ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem; # managed by Certbot
    ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem; # managed by Certbot
    include /etc/letsencrypt/options-ssl-nginx.conf; # managed by Certbot
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; # managed by Certbot

    location / {
      proxy_pass http://127.0.0.1:8080;
      proxy_set_header Host $host;
      proxy_set_header X-Forwarded-For $remote_addr;
    }
}

server {
    if ($host = www.example.com) {
        return 301 https://$host$request_uri;
    } # managed by Certbot

    if ($host = example.com) {
        return 301 https://$host$request_uri;
    } # managed by Certbot

  server_name example.com www.example.com;
    listen 80;
    return 404; # managed by Certbot
}

Firewall-Konfiguration für den Server

Um deinen Server besser zu schützen, solltest du die Firewall so konfigurieren, dass nur die wichtigsten Ports offen sind – also 22 (SSH), 80 (HTTP) und 443 (HTTPS).

Firewall (UFW) im Betriebssystem einrichten

Installiere zunächst die einfache Firewall „Uncomplicated Firewall“ (UFW):

# apt install ufw

Blockiere eingehenden Verkehr standardmäßig und erlaube ausgehende Verbindungen:

# ufw default deny incoming
# ufw default allow outgoing

Erlaube nun die benötigten Ports manuell:

# ufw allow ssh
# ufw allow http
# ufw allow https

Wichtig: Stelle sicher, dass der SSH-Port nicht gesperrt ist, bevor du die Firewall aktivierst – sonst verlierst du den Zugriff auf deinen Server.

Aktiviere anschließend die Firewall und prüfe den Status:

# ufw enable

# ufw status

Jenkins-Installation überprüfen

Sobald Jenkins läuft, rufe die URL https://www.example.com/ im Browser auf. Das System verlangt nach dem initialen Administrator-Passwort.

Mit folgendem Befehl kannst du das Passwort direkt aus dem Container auslesen:

$ docker exec -it jenkins cat /var/jenkins_home/secrets/initialAdminPassword

Jenkins fordert dich anschließend auf, empfohlene Plugins zu installieren. Danach kannst du die Zugangsdaten für einen Administrator festlegen. Nun ist Jenkins einsatzbereit zur Erstellung von CI/CD-Pipelines.

Fazit

Docker Compose ist ein hilfreiches Tool zur Verwaltung und Bereitstellung containerbasierter Anwendungen. In dieser Anleitung wurde gezeigt, wie man Jenkins auf einem Ubuntu-Server mithilfe von Docker Compose installiert, mit HTTPS über Nginx absichert und den Zugang über Firewalls schützt.