Zum Inhalt springen

Von Jenkins zu GitHub Actions migrieren: Schritt für Schritt

Zuletzt aktualisiert am

Die Migration von Jenkins zu GitHub Actions bedeutet, ein Jenkinsfile in Workflow-YAML zu übersetzen: Stages werden zu Jobs oder Steps, agent wird zu runs-on, Credentials werden zu Secrets und Shared Libraries werden zu Composite Actions oder wiederverwendbaren Workflows. Deklarative Pipelines lassen sich gut übertragen. Scripted Pipelines mit umfangreicher Groovy-Logik kosten dagegen die meiste Zeit. Dieser Leitfaden zeigt die Zuordnung, eine durchgerechnete Übersetzung, den Umgang mit Agents und Plugins sowie einen Umstellungsplan.

Verwandte Seiten: Jenkins vs. GitHub Actions und Jenkins-Alternativen.

Zuordnung der Konzepte

JenkinsGitHub Actions
Jenkinsfile.github/workflows/*.yml
Multibranch-PipelineWorkflow on: push / pull_request (läuft automatisch pro Branch)
agent { label 'x' }runs-on: [label]
agent { docker { image 'x' } }container: x am Job
stages / stagejobs (standardmäßig parallel) oder sequenzielle steps
parallel { }Eigene Jobs oder eine matrix
steps { sh '...' }steps: - run: ...
environment { }env: auf Workflow-, Job- oder Step-Ebene
credentials('id')${{ secrets.NAME }}
when { branch 'main' }if: github.ref == 'refs/heads/main'
post { always { } }Step mit if: always()
stash / unstash, archiveArtifactsactions/upload-artifact / download-artifact
input (manuelle Freigabe)Environment mit erforderlichen Reviewern
triggers { cron() }on.schedule
parameters { }workflow_dispatch.inputs
Shared LibrariesComposite Actions, wiederverwendbare Workflows
PluginsActions aus dem Marketplace oder einfache Skripte
Jenkins-Controller + AgentsGitHub-gehostete Runner oder selbst gehostete Runner
Workspace bleibt auf dem Agent erhaltenFrische VM pro Job, sofern Sie nicht cachen oder einen persistenten Runner nutzen

Die letzte Zeile überrascht viele. Ein Jenkins-Agent behält oft seinen Workspace, das Maven-Repository und Docker-Layer zwischen den Builds. Ein gehosteter GitHub-Runner startet jeden Job leer. Deshalb brauchen Sie explizites Caching, um die Geschwindigkeit zurückzugewinnen.

Eine realistische Pipeline im direkten Vergleich

Ein deklaratives Jenkinsfile für einen Java-Service:

pipeline {
  agent { label 'linux' }
  options { timeout(time: 30, unit: 'MINUTES') }
  environment {
    REGISTRY = 'registry.example.com'
    DEPLOY_KEY = credentials('deploy-key')
  }
  stages {
    stage('Build') {
      steps { sh './gradlew assemble' }
    }
    stage('Test') {
      parallel {
        stage('Unit') { steps { sh './gradlew test' } }
        stage('Integration') { steps { sh './gradlew integrationTest' } }
      }
      post { always { junit '**/build/test-results/**/*.xml' } }
    }
    stage('Deploy') {
      when { branch 'main' }
      steps { sh './scripts/deploy.sh' }
    }
  }
  post { failure { mail to: 'team@example.com', subject: 'Build failed' } }
}

Die Version für GitHub Actions:

name: CI
on:
  push:
    branches: [main]
  pull_request:

env:
  REGISTRY: registry.example.com

jobs:
  build:
    runs-on: ubuntu-latest        # or [self-hosted, Linux, compiler-ci]
    timeout-minutes: 30
    steps:
      - uses: actions/checkout@v6
      - uses: actions/setup-java@v5
        with:
          distribution: temurin
          java-version: 21
      - uses: gradle/actions/setup-gradle@v6
      - run: ./gradlew assemble

  test:
    needs: build
    runs-on: ubuntu-latest
    timeout-minutes: 30
    strategy:
      fail-fast: false
      matrix:
        task: [test, integrationTest]
    steps:
      - uses: actions/checkout@v6
      - uses: actions/setup-java@v5
        with:
          distribution: temurin
          java-version: 21
      - uses: gradle/actions/setup-gradle@v6
      - run: ./gradlew ${{ matrix.task }}
      - uses: actions/upload-artifact@v4
        if: always()
        with:
          name: results-${{ matrix.task }}
          path: "**/build/test-results/**/*.xml"

  deploy:
    needs: test
    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
    runs-on: ubuntu-latest
    environment: production
    steps:
      - uses: actions/checkout@v6
      - run: ./scripts/deploy.sh
        env:
          DEPLOY_KEY: ${{ secrets.DEPLOY_KEY }}

Hinweise zur Übersetzung:

  • Jeder GitHub-Job läuft auf einer frischen Maschine, daher teilen sich build und test keinen Workspace. Entweder bauen Sie in jedem Job neu (mit dem Gradle-Cache günstig) oder übergeben Ergebnisse über Artifacts. Oft ist es einfacher, build in die Test-Jobs zu integrieren.
  • parallel-Stages werden zu einer Matrix oder zu separaten Jobs. Siehe Matrix-Builds.
  • post { failure { mail } } wird zu einem Benachrichtigungsschritt mit if: failure(), alternativ verlassen Sie sich auf die integrierten Benachrichtigungen von GitHub bei fehlgeschlagenen Workflows.
  • credentials('deploy-key') wird zu einem Secret. Legen Sie es im Repository, in der Organisation oder in einer Environment an.
  • when { branch 'main' } wird zu einer if:-Bedingung. Für eine manuelle Freigabe fügen Sie der Environment production erforderliche Reviewer hinzu.
  • Testergebnisse werden als Artefakte hochgeladen. Für eine Zusammenfassung im Pull Request verwenden Sie eine JUnit-Reporter-Action.

Agents, Labels und Self-Hosting

Viele Jenkins-Teams betreiben eigene Agents aus gutem Grund: Zugriff auf private Netzwerke, spezielle Hardware oder Kosten. GitHub Actions unterstützt Self-Hosted Runner mit Labels, die sich auf Jenkins-Labels abbilden lassen. Gehostete Runner erreichen private Netzwerke ohne Tunnel oder einen Ansatz wie OIDC mit einem öffentlichen Endpunkt nicht. Wenn Sie privaten Zugriff benötigen, planen Sie Self-Hosted Runner ein und lesen Sie die Sicherheitshinweise: Führen Sie auf langlebigen Runnern niemals nicht vertrauenswürdigen Code aus Forks aus.

Wenn Sie auf GitHub-gehostete Runner umgestiegen sind und Builds langsamer als auf Ihren Jenkins-Agents laufen, liegt das meist an den Standard-2-vCPU und einem kalten Cache. compiler.dev führt dieselben Jobs auf Maschinen mit 8 vCPU / 16 GB aus, mit bereitstehenden Abhängigkeits- und Docker-Layer-Caches, für $0.008 pro Minute, über runs-on: [self-hosted, Linux, compiler-ci], mit automatischem Fallback auf Ihre bisherigen Runner. Siehe Preise und schnellere Runner.

Plugins

Prüfen Sie Ihre installierten Plugins und ordnen Sie sie dann in drei Gruppen ein:

  1. Durch eine integrierte oder Marketplace-Action ersetzt (SCM, JUnit, Slack-Benachrichtigung, Credentials, Artefakt-Archivierung).
  2. Durch ein Skript ersetzt (alles, was eine CLI gekapselt hat).
  3. Ohne Entsprechung (seltene Plugins, die die Jenkins-Oberfläche erweitern). Entscheiden Sie, ob Sie sie weiterhin benötigen.

Prüfen Sie Marketplace-Actions vor der Übernahme: Fixieren Sie Drittanbieter-Actions per Commit-SHA, wie unter GitHub Actions absichern beschrieben.

Credentials und Secrets

Jenkins speichert Credentials im Controller, und Sie können geheime Werte nicht über die Oberfläche exportieren. Beziehen Sie sie aus Ihrem Passwort-Manager oder Vault und legen Sie sie dann als GitHub-Secrets an. Ersetzen Sie langlebige Cloud-Schlüssel nach Möglichkeit durch OIDC: GitHub Actions OIDC mit AWS. Secrets im globalen Scope des Controllers werden zu Organisations-Secrets, Credentials pro Ordner zu Repository- oder Environment-Secrets.

Caching

Jenkins-Agents haben oft durch ihre Langlebigkeit gecacht. In Actions richten Sie das Caching explizit ein:

Automatisierte Konvertierung: GitHub Actions Importer

Der Importer von GitHub ist eine gh-Erweiterung. Laut der Dokumentation von GitHub (Stand Oktober 2026) unterstützt er Jenkins, CircleCI, GitLab CI, Azure DevOps, Bamboo, Bitbucket Pipelines und Travis CI, und er setzt Docker sowie die GitHub CLI voraus.

gh extension install github/gh-actions-importer
gh actions-importer configure
gh actions-importer audit jenkins --output-dir audit --source-url https://jenkins.example.com

Die dokumentierten Befehle sind audit, forecast, dry-run und migrate. Beginnen Sie mit audit gegen Ihren Jenkins-Server, um einen Bericht darüber zu erhalten, was sich konvertieren lässt und was nicht. Danach erzeugt dry-run die Workflows lokal. Rechnen Sie damit, Shared Libraries, eigenen Groovy-Code und plugin-spezifische Schritte von Hand zu konvertieren. Prüfen Sie die aktuelle Importer-Dokumentation von GitHub auf die genauen Flags für Jenkins, da Credentials und URLs anders übergeben werden als bei anderen Plattformen.

Umstellungsplan

  1. Inventarisieren Sie Jobs, Plugins, Credentials, Trigger und wer von welchem abhängt.
  2. Auditieren Sie mit dem Importer und wählen Sie zuerst die einfachste Pipeline.
  3. Portieren und parallel betreiben Sie zusammen mit Jenkins für ein bis zwei Wochen.
  4. Credentials übertragen Sie und die Deployment-Stages.
  5. Erforderliche Checks umstellen Sie im Branch-Schutz.
  6. Jenkins-Jobs einfrieren (nur lesend), den Controller für einen Release-Zyklus als Verlauf behalten und ihn danach außer Betrieb nehmen.

FAQ

Kann GitHub Actions Jenkins vollständig ersetzen?

Für die meisten Build-, Test- und Deployment-Pipelines ja. Behalten Sie Jenkins dort, wo Sie von einem Plugin ohne Entsprechung abhängen oder Funktionen auf Controller-Ebene benötigen.

Wie ersetze ich Jenkins Shared Libraries?

Composite Actions für wiederverwendbare Schritte, wiederverwendbare Workflows für ganze Pipelines. Konvertieren Sie die Groovy-Logik in Shell oder ein kleines Skript.

Was ist mit Jenkins-Agents in privaten Netzwerken?

Verwenden Sie Self-Hosted Runner in diesem Netzwerk mit passenden Labels.

Ist die Persistenz des Jenkins-Workspaces ein Problem?

Das kann es sein. Richten Sie Caching ein oder nutzen Sie Runner, die Caches warm halten, statt sich auf übrig gebliebene Dateien zu verlassen.

Wie lange dauert das?

Eine einfache deklarative Pipeline: Stunden. Dutzende skriptbasierte Pipelines und Plugins: planen Sie Wochen ein, vor allem für die Validierung.

Diesen Workflow auf compiler.dev ausführen Keine Karte nötig · 200 kostenlose Minuten

Kostenlos testen