Kurs · Schulung · Workshop
Modern Jenkins für CI/CD & Automation
Zwei Tage hands-on: Jenkinsfiles und Shared Libraries mit schnellem Feedback entwickeln und testen, und den Jenkins Controller, seine Plugins und Kubernetes Agents als Code verwalten.
Eine Jenkins-Installation besteht aus Pipelines, Shared Libraries, Plugins und der Konfiguration des Controllers und seiner Agents. Mit Pipeline as Code und Jenkins Configuration as Code liegen alle diese Teile in Git: Das Jenkinsfile beschreibt den Build, Shared Libraries enthalten die wiederverwendbare Automatisierung, eine YAML-Datei definiert die Einstellungen des Controllers und ein Dockerfile das Jenkins Image mit seinen Plugins. Änderungen werden wie Anwendungscode reviewt, getestet und ausgerollt. Am ersten Tag entwickelst Du Jenkinsfiles und lagerst wiederverwendbare Steps in eine Shared Pipeline Library aus, die Du strukturierst und versionierst. Den Feedback Loop verkürzt Du mit lokalem Editieren und Validieren: mit dem Declarative Pipeline Linter, mit Replay und mit einem lokalen Jenkins im Container. Du schreibst Unit Tests für Pipeline-Code mit gemockten Jenkins Steps und Integrationstests, die Deine Pipelines mit Testcontainers gegen eine containerisierte Jenkins-Instanz ausführen. Am zweiten Tag machst Du die Jenkins-Installation selbst reproduzierbar. Du startest die offiziellen Controller und Agent Images, baust ein eigenes Jenkins Image und verwaltest dessen Plugins in einer Plugin-Liste. Die Einstellungen des Controllers definierst Du mit Jenkins Configuration as Code (JCasC) in YAML, ergänzt Groovy Hooks, wo zusätzliche Flexibilität nötig ist, und führst Builds auf Kubernetes Agents aus. Sicherheitseinstellungen wie Authentifizierung und Autorisierung werden Teil derselben Konfiguration. Am Ende enthält Dein Repository die Pipeline, die Shared Library, ihre Tests und das Jenkins-Setup, und eine Änderung durchläuft die Tests, bevor sie den produktiven Controller erreicht.
Stimmen unserer Teilnehmer:innen






Diese Kunden haben Kurse im gleichen Themen-Cluster bei uns gebucht.Mehr Kunden →
Inhalt
Dieses Training richtet sich an Teams, die Jenkins produktiv betreiben und Pipelines und eine Jenkins-Installation wollen, die wartbar, testbar und reproduzierbar sind. Du arbeitest an einem Beispielprojekt mit einer Shared Library und einem Jenkins-Setup in Containern und erweiterst beides Schritt für Schritt.
Der Kurs besteht aus den folgenden Themen und kann je nach Publikum angepasst werden. Der erste Tag behandelt Entwicklung und Tests von Pipelines, der zweite Tag die Jenkins-Installation als Code. Für Inhouse-Kurse vereinbaren wir die Schwerpunkte und die Tiefe der Kapitel.
Pipeline-Grundlagen und Praktiken
- Pipeline as Code: das Jenkinsfile im Quellcode-Repository, Declarative und Scripted Syntax
- Pipeline Job, Multibranch Pipeline und Organization Folder
- Lesbarkeit, Wartbarkeit und typische Stolpersteine in Jenkinsfiles
- Hands-On: Umgebung einrichten und das Jenkinsfile des Beispielprojekts erweitern
Pipeline Developer Tools
- Eine Declarative Pipeline mit dem Command-Line Linter über SSH oder HTTP validieren
- Linter-Integrationen für den Editor und als Pre-Commit Hook
- Replay: einen Pipeline-Lauf ohne Commit anpassen und erneut ausführen
- Ein lokaler Jenkins im Container, mit Deinen Libraries und Jenkinsfiles aus dem Dateisystem eingebunden
- Hands-On: Pipeline-Änderungen vor dem Commit lokal validieren und ausprobieren
Shared Pipeline Libraries
- Aufbau einer Library: eigene Steps in vars, Groovy-Klassen in src, Dateien in resources
- Globale und Folder-Level Libraries, Trusted Libraries und die Groovy Sandbox
- Libraries mit der @Library Annotation und dem library Step laden
- Versionierung mit Branches, Tags und Commits, und eine Library-Änderung aus einem Pull Request ausprobieren
- Hands-On: Wiederverwendbare Steps aus dem Jenkinsfile in eine Shared Library auslagern und projektübergreifend nutzen
Unit Tests für Pipelines
- Test-Frameworks für Pipeline-Code, am Beispiel von JenkinsPipelineUnit
- Pipeline-Code in einer Mock-Ausführung ohne Jenkins Server ausführen
- Jenkins Steps und die Ergebnisse von Shell-Befehlen mocken
- Das Verhalten von Shared Library Steps testen und den Call Stack mit einer Referenz vergleichen
- Hands-On: Unit Tests für das Jenkinsfile und die Shared Library schreiben
Integrationstests für Pipelines
- Eine containerisierte Jenkins-Instanz mit Testcontainers aus dem Test starten
- Mit dem eigenen Plugin-Set und eigenen Initialisierungsskripten testen
- Unit Tests und Integrationstests vergleichen und für jede Prüfung die Ebene wählen
- Einordnung: Jenkinsfile Runner als Single-Shot Pipeline Runner
- Hands-On: Eine Pipeline mit der Shared Library gegen Jenkins im Container ausführen
Jenkins-Konfiguration als Code
- Bestandteile einer Jenkins-Installation: Controller, Agents, Plugins, Jobs und Systemkonfiguration
- Job-Konfiguration und Systemkonfiguration, die neben dem Code abgelegt sind
- Eine Jenkins-Installation, die sich aus dem Repository neu aufbauen lässt
Jenkins mit Docker
- Das offizielle Controller Image jenkins/jenkins mit Weekly und LTS Releases und die offiziellen Agent Images starten
- Ein eigenes Jenkins Image mit einem Dockerfile bauen
- Plugins mit einer Plugin-Liste und jenkins-plugin-cli verwalten, Versionen pinnen und verfügbare Updates prüfen
- Hands-On: Ein eigenes Jenkins Image mit Deinem Plugin-Set bauen
Jenkins Configuration as Code (JCasC)
- Die Einstellungen des Controllers in YAML definieren: die Abschnitte jenkins, tool, unclassified und credentials
- Die bestehende Konfiguration eines Controllers als Ausgangspunkt exportieren
- Secrets über Variablen und Secret Sources wie Docker Secrets, Kubernetes Secrets und HashiCorp Vault übergeben
- Konfigurationsänderungen mit einem Reload über die Benutzeroberfläche, das CLI oder HTTP anwenden
- Hands-On: Den Controller des Beispiel-Setups inklusive Shared Library in YAML konfigurieren
Groovy Hooks
- Die Initialisierung von Jenkins mit Groovy Hook Scripts in init.groovy.d anpassen
- Hooks mit JCasC kombinieren, wo zusätzliche Flexibilität nötig ist
- Hands-On: Dem eigenen Image einen Groovy Hook hinzufügen
Jenkins auf Kubernetes
- Containerisierte Jenkins Deployments: Helm Chart, YAML Manifeste und Jenkins Operator
- Kubernetes Plugin: ein Pod pro Agent, der nach dem Build entfernt wird
- Pod Templates in der Konfiguration, mit dem podTemplate Step und als YAML in einer Declarative Pipeline
- Hands-On: Die Pipeline des Beispielprojekts auf einem Kubernetes Agent ausführen
Security als Code
- Authentifizierung und Autorisierung in der Konfiguration als Code definieren
- Builds auf Agents ausführen und die Executors des Controllers auf null setzen
- Die Berechtigungen von Builds mit dem Authorize Project Plugin steuern
- Das Jenkins-Home-Verzeichnis und Backups schützen, Plugins und Container Images prüfen
- Den Jenkins Security Advisories folgen und auf der aktuellen LTS-Linie bleiben
Von der Änderung in die Produktion
- Ein Repository-Workflow für Jenkinsfile, Shared Library und JCasC YAML
- Unit Tests und Integrationstests laufen, bevor eine Änderung den produktiven Controller erreicht
- Hands-On: Eine Änderung an der Shared Library und an der Konfiguration durch die Tests ins Jenkins-Setup bringen
Am Ende der zwei Tage hast Du ein Beispiel-Setup mit getesteten Pipelines, einer versionierten Shared Library und einer als Code definierten Jenkins-Installation mit eigenem Image, JCasC und Kubernetes Agents. Du weisst, wie Du diese Praktiken Schritt für Schritt in Eure bestehende Jenkins-Umgebung bringst.
Der effektive Kursinhalt kann, abhängig von Trainer, Durchführung, Dauer und Konstellation der Teilnehmer:innen, von obigen Angaben abweichen.
In-House Kurs anfragen
Öffentlichen Termin anfragen
Kein passender öffentlicher Termin dabei? Trag dich unverbindlich ein – sobald genug Interesse besteht, planen wir einen neuen öffentlichen Termin und informieren dich zuerst.
Mehr über Jenkins Pipelines und Configuration as Code
Jenkins Pipeline beschreibt einen Build-, Test- und Delivery-Ablauf als Code in einem Jenkinsfile, das im Quellcode-Repository des Projekts liegt. Pipelines werden in Declarative oder Scripted Syntax geschrieben. Shared Libraries enthalten Pipeline-Code, den mehrere Projekte nutzen: Eine Library ist ein Repository mit den Verzeichnissen vars für eigene Steps, src für Groovy-Klassen und resources für weitere Dateien, und sie wird in einer definierten Version von einem Branch, einem Tag oder einem Commit geladen.
Jenkins Configuration as Code (JCasC) definiert die Einstellungen eines Jenkins Controllers in einer YAML-Datei. Das offizielle Container Image jenkins/jenkins ist darauf ausgelegt, erweitert zu werden: Ein Dockerfile ergänzt die Plugins aus einer Plugin-Liste mit jenkins-plugin-cli, und Groovy Hook Scripts passen die Initialisierung an. Mit dem Kubernetes Plugin betreibt Jenkins dynamische Agents in einem Kubernetes Cluster. Zusammen beschreiben diese Teile eine vollständige Jenkins-Installation, die sich aus dem Repository neu aufbauen lässt.
Weitere Ressourcen:
Passende Vertiefungen
- Integrationstests mit Testcontainers & WireMock: Testcontainers vertieft für die Anwendungen, die Deine Pipelines bauen.
- Dev Containers: Reproduzierbare Entwicklungsumgebungen: dieselbe Umgebung auf dem Laptop, in der Cloud IDE und in CI.
- Container & Kubernetes DevOps: Container-Grundlagen, Images und Kubernetes.
