Jenkins CI/CD Pipeline auf dem VPS – Automatisierte Builds & Deployments 2026

Was ist Jenkins?

Jenkins ist ein in Java geschriebener Open-Source-Automatisierungsserver, der 2011 aus dem Hudson-Projekt hervorgegangen ist. Mit über 1.800 verfügbaren Plugins und einer riesigen Community zählt Jenkins seit über einem Jahrzehnt zu den am weitesten verbreiteten CI/CD-Tools weltweit. Das Herzstück von Jenkins sind sogenannte Pipelines: Workflows, die Build-, Test- und Deployment-Schritte in einer definierten Abfolge ausführen. Ob eine einfache Node.js-App, eine komplexe Microservices-Architektur oder ein eingebettetes System – Jenkins lässt sich dank seiner Plugin-Architektur für nahezu jede Technologie konfigurieren.

Der große Vorteil von Jenkins gegenüber Cloud-nativen CI/CD-Diensten: Du hostest Jenkins auf deiner eigenen Infrastruktur. Das bedeutet volle Kontrolle über die Ausführungsumgebung, keine Limits durch Minutenkontingente und keine Vendor-Lock-in-Effekte. Du entscheidest, welche Ressourcen deine Builds bekommen, wann sie laufen und wie lange sie archiviert werden.

Warum Jenkins auf dem VPS betreiben?

Ein VPS (Virtual Private Server) bietet die ideale Plattform für Jenkins. Im Vergleich zu Cloud-Managed-Services wie GitHub Actions oder GitLab CI hast du folgende Vorteile:

Für Teams und Einzelentwickler, die maximale Flexibilität benötigen und ohnehin einen VPS für ihre Projekte betreiben, ist Jenkins die kosteneffizienteste und mächtigste Lösung.

Installation von Jenkins auf Ubuntu/Debian VPS

Die Installation von Jenkins auf einem Ubuntu 22.04 LTS oder Debian 12 VPS ist dank offizieller Paket-Repositories unkompliziert. Voraussetzung ist eine Java Runtime Environment (JRE) ab Version 11 – Jenkins selbst ist eine Java-Anwendung.

# System aktualisieren
sudo apt update && sudo apt upgrade -y

# Java 17 (OpenJDK) installieren
sudo apt install openjdk-17-jdk -y

# Jenkins Repository hinzufügen
curl -fsSL https://pkg.jenkins.io/debian/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 binary/ \
  | sudo tee /etc/apt/sources.list.d/jenkins.list

# Jenkins installieren
sudo apt update
sudo apt install jenkins -y

# Jenkins starten und beim Booten automatisch starten
sudo systemctl enable --now jenkins

# Status prüfen
sudo systemctl status jenkins

Nach der Installation erreichst du Jenkins über http://DEINE_VPS_IP:8080. Das initiale Admin-Passwort findest du mit:

sudo cat /var/lib/jenkins/secrets/initialAdminPassword

Der Setup-Assistent führt dich durch die Installation der empfohlenen Plugins und die Erstellung des ersten Admin-Benutzers. Wähle unbedingt die „Empfohlene Plugins installieren“-Option – darunter sind essenzielle Plugins wie Git, Pipeline und Credentials Binding.

Erste Pipeline konfigurieren: Jenkinsfile

Das Herz jeder Jenkins-Pipeline ist das Jenkinsfile – eine Textdatei, die deinen gesamten CI/CD-Workflow als Code definiert (Pipeline as Code). Es gibt zwei Syntax-Varianten:

Für den Einstieg empfehle ich die deklarative Syntax. Hier ein minimales Jenkinsfile für ein Node.js-Projekt:

pipeline {
    agent any

    stages {
        stage('Checkout') {
            steps {
                git branch: 'main',
                    url: 'https://github.com/deinuser/dein-repo.git'
            }
        }
        stage('Install Dependencies') {
            steps {
                sh 'npm ci'
            }
        }
        stage('Test') {
            steps {
                sh 'npm test'
            }
        }
        stage('Build') {
            steps {
                sh 'npm run build'
            }
        }
        stage('Deploy') {
            steps {
                sh '''
                    scp -r dist/* deploy@server:/var/www/myapp/
                '''
            }
        }
    }
}

Speichere dieses Jenkinsfile im Root deines Git-Repositories. Jenkins erkennt es automatisch, wenn du eine Pipeline mit der Quelle „Pipeline script from SCM“ anlegst. So ist der Workflow versioniert und liegt direkt neben dem Quellcode.

post {
    success {
        emailext to: '[email protected]',
                 subject: "Build erfolgreich: ${env.BUILD_NUMBER}",
                 body: "Der Build war erfolgreich."
    }
    failure {
        slackSend channel: '#ci-cd',
                  color: 'danger',
                  message: "Build ${env.BUILD_NUMBER} fehlgeschlagen!"
    }
}

Integration mit Git: GitHub/GitLab Webhooks

Eine CI/CD-Pipeline lebt von der automatischen Auslösung bei Code-Änderungen. Jenkins integriert sich über Webhooks mit Git-Hosting-Diensten. Die Einrichtung erfolgt in drei Schritten:

1. Jenkins-Job konfigurieren: Aktiviere im Pipeline-Job „GitHub hook trigger for GITScm polling“ (für GitHub) oder „Build when a change is pushed to GitLab“ (für GitLab).
2. Webhook im Git-Dienst anlegen: Gehe in deinem GitHub/GitLab-Repository zu Settings → Webhooks und füge die Jenkins-URL ein: http://DEINE_VPS_IP:8080/github-webhook/ (GitHub) oder http://DEINE_VPS_IP:8080/project/DEIN-PROJEKT (GitLab). Wähle als Auslöser „Push events“ und optional „Pull requests“.
3. Testen: Push einen Commit auf den getrackten Branch – Jenkins sollte automatisch einen neuen Build starten.

Wichtig: Für Produktivumgebungen solltest du Jenkins hinter einem Nginx-Reverse-Proxy mit SSL betreiben und den Webhook-Zugriff per API-Token absichern. Das verhindert, dass Unbefugte Builds auslösen können.

Build, Test, Deploy: Eine vollständige CI/CD-Pipeline

Schauen wir uns eine vollständige CI/CD-Pipeline für eine Webanwendung an, die in Docker-Container verpackt und auf dem VPS deployed wird. Wir nutzen das Docker Pipeline Plugin, um Build-Images zu erstellen und zu pushen.

pipeline {
    agent any

    environment {
        DOCKER_REGISTRY = 'ghcr.io/deinuser'
        IMAGE_NAME = 'meine-app'
        IMAGE_TAG = "${BUILD_NUMBER}"
    }

    stages {
        stage('Checkout') {
            steps { checkout scm }
        }
        stage('Unit Tests') {
            steps { sh 'npm test' }
        }
        stage('Integration Tests') {
            steps { sh 'npm run test:integration' }
        }
        stage('Build Docker Image') {
            steps {
                script {
                    docker.build("${DOCKER_REGISTRY}/${IMAGE_NAME}:${IMAGE_TAG}")
                    docker.build("${DOCKER_REGISTRY}/${IMAGE_NAME}:latest")
                }
            }
        }
        stage('Push to Registry') {
            steps {
                script {
                    docker.withRegistry('', 'ghcr-credentials') {
                        docker.image("${DOCKER_REGISTRY}/${IMAGE_NAME}:${IMAGE_TAG}").push()
                        docker.image("${DOCKER_REGISTRY}/${IMAGE_NAME}:latest").push()
                    }
                }
            }
        }
        stage('Deploy to VPS') {
            steps {
                sh '''
                    ssh deploy@vps-host "cd /opt/myapp && \
                    docker-compose pull && \
                    docker-compose up -d"
                '''
            }
        }
    }
}

Diese Pipeline demonstriert den kompletten Weg von Code-Commit bis Live-Deployment:

• Nach jedem Push checkt Jenkins den aktuellen Code aus.
• Unit- und Integrationstests laufen automatisch – schlägt ein Test fehl, wird die Pipeline abgebrochen.
• Bei Erfolg wird ein Docker-Image gebaut und in die GitHub Container Registry gepusht.
• Der Deployment-Step verbindet sich per SSH mit dem VPS und führt docker-compose pull && up -d aus – die neue Version ist live.

Wichtige Plugins für Jenkins 2026

Jenkins' Stärke liegt im Plugin-Ökosystem. Hier die wichtigsten Plugins, die du für eine moderne CI/CD-Pipeline benötigst:

Die Installation erfolgt direkt über die Jenkins-Oberfläche unter „Jenkins verwalten“ → „Plugins verwalten“. Blue Ocean installierst du am besten gleich zu Beginn – es ersetzt die klassische Jenkins-Oberfläche durch ein modernes, farbcodiertes Dashboard, das den Pipeline-Flow visualisiert.

Sicherheit: Jenkins absichern (Benutzer, SSL, Backup)

Ein Jenkins-Server, der im Internet erreichbar ist, ist ein potenzielles Einfallstor. Mit diesen Maßnahmen schützt du deine CI/CD-Umgebung:

1. Benutzerverwaltung & Berechtigungen

• Erstelle nach der Installation sofort einen Admin-Benutzer und deaktiviere die anonyme Benutzergruppe unter „Jenkins verwalten“ → „Global Security konfigurieren“.
• Aktiviere die Matrix-basierte Sicherheit und weise nur die minimal notwendigen Rechte zu.
• Nutze das Role-Based Strategy Plugin, um verschiedene Berechtigungsstufen für Developer, QA und Admins zu definieren.

2. SSL/TLS mit Let's Encrypt

Setze Jenkins hinter einen Nginx-Reverse-Proxy mit kostenlosem SSL-Zertifikat von Let's Encrypt:

# Nginx-Konfiguration für Jenkins
server {
    listen 443 ssl;
    server_name ci.deine-domain.de;

    ssl_certificate /etc/letsencrypt/live/ci.deine-domain.de/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/ci.deine-domain.de/privkey.pem;

    location / {
        proxy_pass http://localhost: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;
    }
}

3. Regelmäßige Backups

Das Jenkins-Home-Verzeichnis /var/lib/jenkins enthält alle Konfigurationen, Jobs und Build-Artefakte. Ein Backup ist essenziell:

# Einfaches Tarball-Backup
sudo tar -czf jenkins-backup-$(date +%F).tar.gz /var/lib/jenkins

# Mit dem ThinBackup Plugin automatisieren
# Oder als Cron-Job einrichten:
0 3 * * * tar -czf /backup/jenkins-$(date +\%F).tar.gz /var/lib/jenkins

Vor- und Nachteile: Jenkins vs. GitHub Actions / GitLab CI

Zum Abschluss ein ehrlicher Vergleich, der dir bei der Entscheidung hilft:

Fazit des Vergleichs: Jenkins ist die erste Wahl, wenn du maximale Kontrolle, ein riesiges Plugin-Ökosystem und keine Abhängigkeit von Cloud-Anbietern möchtest. GitHub Actions und GitLab CI punkten mit geringerem Setup-Aufwand und sind ideal, wenn du ohnehin in deren Ökosystem arbeitest und keine besonderen Anforderungen an die Build-Umgebung hast.

Fazit

Jenkins ist und bleibt 2026 eine der leistungsfähigsten CI/CD-Plattformen – besonders dann, wenn du die volle Kontrolle über deine Build-Infrastruktur haben möchtest. Die Installation auf einem VPS ist dank des offiziellen Paket-Repositories unkompliziert, und mit der deklarativen Pipeline-Syntax und Plugins wie Blue Ocean, Docker Pipeline und Credentials Binding baust du in kürzester Zeit eine professionelle CI/CD-Pipeline.

Die Einrichtung erfordert zwar etwas mehr initialen Aufwand als Cloud-Alternativen, aber du erhältst dafür:

• Unbegrenzte Build-Minuten – keine Limits, keine versteckten Kosten
• Volle Datenhoheit – dein Code verlässt nie deinen Server
• Maximale Flexibilität – über 1.800 Plugins für jeden Use Case
• Lernkurve – Jenkins-Kenntnisse sind in jedem DevOps-Team gefragt

Starte noch heute mit deiner eigenen Jenkins-Instanz auf dem VPS und automatisiere deine Builds, Tests und Deployments. Dein zukünftiges Ich – und dein Team – werden es dir danken.