Jenkins: Grundlagen und Jenkinsfile

Jenkins ist der Veteran unter den CI/CD-Tools. Seit 2005 (damals als „Hudson" bei Sun Microsystems) prägt es die Automatisierungs-Welt und ist bis heute in tausenden Unternehmen das zentrale Build-Werkzeug. Während GitHub Actions und GitLab CI moderne SaaS-Lösungen sind, ist Jenkins selbst-gehostet, extrem flexibel und hat eine enorme Plugin-Bibliothek mit über 1.800 Add-ons.

Diese Lektion zeigt dir die Grundlagen: was ist Jenkins, wie ist es aufgebaut (Master/Agent), wie schreibst du Jenkinsfiles in declarative oder scripted Pipeline-Syntax, welche Plugins braucht man, und wann ist Jenkins die richtige Wahl. Wer in einem mittleren bis großen Unternehmen arbeitet, wird Jenkins früher oder später begegnen.

1) Was ist Jenkins?

Jenkins ist ein selbst-gehosteter Automation-Server. Du installierst ihn auf einem Server (oder als Docker-Container) und konfigurierst dort Builds, Tests, Deployments. Im Gegensatz zu GitHub Actions oder GitLab CI ist Jenkins nicht an ein Git-Repository-Hosting gebunden – es kann mit jeder Git-Variante arbeiten (GitHub, GitLab, Bitbucket, on-prem).

Die Stärken:

Volle Kontrolle: läuft auf deinen Servern, keine Daten gehen nach außen
Plugin-Ökosystem: über 1.800 Plugins für alles Mögliche
Beliebige Tools integriert: Slack-Benachrichtigungen, JIRA-Updates, AWS-Deploy, …
Reife: 20 Jahre Erfahrung, sehr stabil
Kostenlos: Open Source unter MIT-Lizenz

Die Schwächen:

Wartungsaufwand: musst du selbst hosten, updaten, sichern
UI fühlt sich altbacken an – funktional, aber nicht modern
Plugin-Pflege: viele Plugins werden nicht mehr aktiv entwickelt, Kompatibilitäts-Probleme
Komplexität: für simple Projekte oft Overkill

2) Master-Agent-Architektur

Jenkins folgt einem klassischen Master-Agent-Modell (früher „Master/Slave" genannt, heute auch „Controller/Agent"):

Jenkins-Architektur

🎯 Jenkins Controller (Master)

Web-UI, Job-Management, Scheduling, Konfiguration

↓ verteilt Jobs ↓

Agent Linux

Ubuntu, Docker, Java-Builds

Agent Windows

Windows, .NET-Builds

Agent macOS

macOS, iOS-Builds

Der Controller verwaltet die Konfiguration und das UI. Die eigentliche Arbeit (Builds, Tests) machen Agents. Du kannst beliebig viele Agents anschließen, auch verschiedene Betriebssysteme. Das skaliert gut: hundert Agents arbeiten parallel an verschiedenen Jobs. Bei kleinen Setups kann auch der Controller selbst Jobs ausführen (Built-in Node), bei Produktion sollte man das aber trennen aus Sicherheits- und Performance-Gründen.

3) Pipeline as Code: das Jenkinsfile

Früher wurden Jenkins-Jobs in der Web-UI angeklickt. Heute ist Pipeline as Code Standard: die Pipeline wird als Jenkinsfile direkt im Git-Repository abgelegt. Das hat Vorteile: versionierbar, reviewbar, reproduzierbar.

Jenkins UI mit laufender Pipeline

J Jenkins

main-app › #142

Build #142 - main-app

Started: 2 min ago · Triggered by: git push (alice@example.com)

Stage View

Checkout
5s

Build
42s

Test
2m 5s

Deploy
running

Die Stage-View zeigt sofort den Status jeder Stage. Klick auf eine Box öffnet das Console-Log. Der Blue Ocean-Plugin macht's nochmal hübscher – modernere Optik mit besserer Visualisierung von Branches.

4) Declarative vs. Scripted Pipeline

Jenkins hat zwei Syntax-Varianten für Pipelines. Beide sind Groovy-basiert, aber unterschiedlich strukturiert:

Zwei Syntax-Varianten

Declarative (empfohlen)

Scripted (klassisch)

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                sh 'mvn clean package'
            }
        }
        stage('Test') {
            steps {
                sh 'mvn test'
            }
        }
    }
}

Strukturiert mit Schlüsselwörtern wie pipeline, stages, steps. Einfacher zu lesen, von Jenkins-Linter prüfbar, bessere IDE-Unterstützung. Heute Standard.

5) Vollständiges Jenkinsfile-Beispiel

Realistisches Beispiel mit allen wichtigen Konzepten – Stages, Variablen, Parallel, Post-Aktionen:

JenkinsfileGroovy

1pipeline {
  agent { docker { image 'node:20-alpine' } }
3
  environment {
      // Globale Variablen
      NODE_ENV = 'production'
      DEPLOY_KEY = credentials('deploy-key-id')
  }
9
  stages {
      stage('Checkout') {
          steps {
              checkout scm
          }
      }
16
      stage('Install & Build') {
          steps {
              sh 'npm ci'
              sh 'npm run build'
          }
      }
23
      // Parallel-Stage: zwei Test-Suites gleichzeitig
      stage('Test') {
          parallel {
              stage('Unit Tests') {
                  steps { sh 'npm test' }
              }
              stage('Lint') {
                  steps { sh 'npm run lint' }
              }
          }
      }
35
      stage('Deploy') {
          when { branch 'main' }   // nur auf main
          steps {
              sh './deploy.sh'
          }
      }
  }
43
  // Post-Aktionen: laufen am Ende, immer
  post {
      success { slackSend color: 'good', message: "Build OK" }
      failure { slackSend color: 'danger', message: "Build FAILED" }
      always { archiveArtifacts 'dist/**' }
  }
50}

Wichtige Konzepte hier: environment mit credentials() für Secret-Variablen, parallel für gleichzeitige Stages, when für Conditional Execution, post für Aktionen nach dem Build (Erfolg, Fehler oder immer).

6) Plugins: das Geheimnis von Jenkins' Macht

Jenkins' eigentliche Stärke ist das Plugin-Ökosystem. Über 1.800 Plugins decken praktisch jeden Use-Case ab. Die unverzichtbaren:

Top-Plugins für die meisten Setups

Git Plugin

Git-Integration. Eigentlich immer vorinstalliert.

Pipeline

Das Plugin für Jenkinsfile-basierte Pipelines.

Blue Ocean

Moderne, schönere UI für Pipelines mit Stage-Visualisierung.

Docker Pipeline

Jobs in Docker-Containern laufen lassen.

Credentials Binding

Secret-Management für API-Keys, Passwörter.

Slack Notification

Build-Status in Slack-Channel posten.

JUnit

Test-Reports im UI anzeigen, Trends tracken.

SonarQube Scanner

Code-Quality-Analysen integrieren.

Kubernetes

Jobs als Pods im Kubernetes-Cluster ausführen.

Plugins werden im Jenkins-UI unter Manage Jenkins → Plugins installiert. Vorsicht: nicht alle Plugins sind gleich gut gepflegt. Manche sind seit Jahren nicht mehr aktualisiert. Vor Installation immer prüfen: letztes Update? Anzahl Downloads? Issue-Tracker aktiv?

7) Multibranch Pipelines

Ein besonders mächtiges Feature: Multibranch Pipelines. Jenkins durchsucht automatisch alle Branches eines Git-Repos nach Jenkinsfiles und baut für jeden Branch eine eigene Pipeline. Das passiert ohne manuelle Konfiguration pro Branch.

Use-Case: du hast ein Repo mit Branches main, develop, feature/login. Mit Multibranch-Pipeline bekommt jeder Branch automatisch eine eigene Build-History. Wenn du feature/login löschst, verschwindet auch die Pipeline-History. Sehr praktisch für moderne Git-Workflows.

8) Credentials-Management

Ein wichtiges Sicherheits-Thema: Credentials – Passwörter, API-Keys, SSH-Schlüssel. Jenkins hat ein eingebautes Credentials-Management mit verschiedenen Typen:

Username + Password: für klassisches Login
SSH Username with private key: für SSH-basierte Auth
Secret text: für API-Tokens
Secret file: für ganze Schlüssel-Dateien
Certificate: für TLS-Client-Certs
Docker Host Certificate Authentication: für Docker-Daemons

JenkinsfileGroovy

1pipeline {
  agent any
  environment {
      // credentials() lädt Username:Password als Tupel
      REGISTRY_CREDS = credentials('docker-registry')
  }
  stages {
      stage('Push') {
          steps {
              // Verfügbar als $REGISTRY_CREDS_USR und $REGISTRY_CREDS_PSW
              sh 'docker login -u $REGISTRY_CREDS_USR -p $REGISTRY_CREDS_PSW'
          }
      }
  }
15}

Wichtig: Credentials niemals in echo oder Console-Logs ausgeben! Jenkins versucht zwar Credentials in Logs zu maskieren, aber das ist nicht zu 100% zuverlässig.

9) Jenkins vs. moderne Alternativen

Wann lohnt sich Jenkins, wann nicht? Ehrliche Einschätzung:

Jenkins-Entscheidung

Jenkins lohnt sich wenn…

Unternehmen Self-Hosting verlangt (Compliance)
Existierende Jenkins-Infrastruktur und Know-How da ist
Sehr spezielle Plugins benötigt werden
Komplexe Multi-Tool-Integrationen nötig sind
Riesige Skalierung gebraucht wird (hunderte Agents)
On-Premise-Builds wichtig sind

Lieber GitHub Actions / GitLab CI wenn…

Neues Projekt von Grund auf
Cloud-First-Strategie
Kleines/mittleres Team
Moderne UX wichtig ist
Du dein Git-Hosting eh schon nutzt
Wenig Wartungsaufwand gewünscht

In Deutschland ist Jenkins immer noch weit verbreitet, besonders in Konzernen und im öffentlichen Sektor. In Startups und neuen Projekten dominieren GitHub Actions und GitLab CI. Wer Jenkins kann, hat aber definitiv Karriere-Vorteile – das Skill ist gefragt.

10) Installation und Setup

Jenkins installierst du am einfachsten via Docker:

install.shBash

1# Jenkins als Docker-Container starten
2docker run -d \
3    -p 8080:8080 \
4    -p 50000:50000 \
5    --name jenkins \
6    -v jenkins_home:/var/jenkins_home \
7    jenkins/jenkins:lts
8
9# Initial-Passwort abrufen (im Container)
10docker exec jenkins cat /var/jenkins_home/secrets/initialAdminPassword

Danach im Browser http://localhost:8080 öffnen, Initial-Passwort eingeben und der Wizard führt dich durch: empfohlene Plugins installieren, Admin-User anlegen, Jenkins-URL setzen. In 10 Minuten läuft dein lokales Jenkins.

11) Best Practices

Aus der Praxis – was du tun und lassen solltest:

Jenkinsfile in Git versionieren: niemals Pipelines nur in der UI konfigurieren – nicht versionierbar
Declarative Pipeline bevorzugen: Scripted nur wenn nötig
Builds in Containern: agent { docker { ... } } für reproduzierbare Builds
Credentials niemals hardcoden: immer über das Credentials-Plugin
Plugins minimieren: jedes Plugin = potenzielle Sicherheitslücke, Wartungsaufwand
Regelmäßig updaten: Jenkins-Sicherheitslücken werden ständig gefunden und gefixt
Backup des Jenkins-Home: enthält alle Konfigurationen, Plugins, Job-History
Agents trennen vom Controller: nicht direkt am Controller bauen, Sicherheit + Performance
Resource Limits setzen: ein durchgedrehter Build sollte nicht den ganzen Jenkins lahmlegen

Zusammenfassung

Jenkins ist der CI/CD-Veteran: Open-Source, selbst-gehostet, extrem flexibel, mit 1.800+ Plugins. Architektur: Controller (Master) verwaltet UI und Jobs, Agents führen Builds aus. Jenkinsfile als Pipeline-as-Code in zwei Varianten: Declarative (modern, strukturiert, empfohlen) und Scripted (klassisch, flexibler, Groovy-basiert). Key-Konzepte: stages, steps, parallel, when, post (Erfolg/Fehler/Always). Plugins erweitern alles – Git, Pipeline, Blue Ocean, Docker, Slack, Kubernetes. Multibranch Pipelines bauen automatisch jeden Git-Branch. Credentials-Management eingebaut für Secrets. Wann Jenkins: Enterprise, Self-Hosting, komplexe Integrationen. Wann Alternativen: neue Cloud-First-Projekte, kleinere Teams, weniger Wartung. In deutschen Konzernen weit verbreitet – Jenkins-Skills sind im Lebenslauf wertvoll.