GitHub Actions Tutorial: CI/CD für deine Projekte automatisieren in 2026

Warum CI/CD-Automatisierung unverzichtbar ist

Stelle dir vor: Dein Team hat 10 Entwickler und committet täglich Dutzende Male. Wenn nach jedem Code-Merge manuell Tests ausgeführt, gebaut und deployed werden müsste, wäre das nicht nur ineffizient, sondern fehleranfällig. Genau hier setzt CI/CD (Continuous Integration/Continuous Deployment) an.

GitHub Actions ist GitHubs natives CI/CD-Tool – vollständig kostenlos für öffentliche Repositories (unbegrenzt), für private Repositories mit 2.000 Freiminuten pro Monat. Es ist tief in GitHub integriert, einfach zu konfigurieren und leistungsstark. Im Jahr 2026 hat es sich als Standardwerkzeug für Entwicklungsteams etabliert.

Kernkonzepte

Konzept	Erklärung
Workflow	Vollständige Definition eines Automatisierungsprozesses (YAML-Datei)
Event	Auslöser eines Workflows (push, PR, Timer usw.)
Job	Eine Ausführungseinheit im Workflow, läuft auf eigenem VM
Step	Einzelne Operation in einem Job – Befehl oder Action
Action	Wiederverwendbare Automatisierungseinheit, aus dem Marketplace abrufbar
Runner	VM, die den Workflow ausführt (GitHub-hosted oder selbst-gehostet)

Dein erster GitHub Actions Workflow

Workflow-Dateien müssen im Verzeichnis .github/workflows/ gespeichert sein:

# .github/workflows/hallo-welt.yml
name: Mein erster Workflow

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

jobs:
  begruessen:
    runs-on: ubuntu-latest
    steps:
      - name: Begrüßung ausgeben
        run: echo "Hallo, GitHub Actions!"

      - name: Laufzeitumgebung prüfen
        run: |
          echo "Betriebssystem: $(uname -a)"
          echo "Node.js-Version: $(node --version)"
          echo "Python-Version: $(python3 --version)"

Vollständiger CI/CD-Workflow für Node.js

# .github/workflows/node-ci.yml
name: Node.js CI/CD

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  test:
    name: Tests
    runs-on: ubuntu-latest

    strategy:
      matrix:
        node-version: [18.x, 20.x, 22.x]

    steps:
      - name: Code auschecken
        uses: actions/checkout@v4

      - name: Node.js ${{ matrix.node-version }} einrichten
        uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node-version }}
          cache: 'npm'

      - name: Abhängigkeiten installieren
        run: npm ci

      - name: Linting ausführen
        run: npm run lint

      - name: Unit-Tests ausführen
        run: npm test -- --coverage

      - name: Abdeckungsbericht hochladen
        uses: codecov/codecov-action@v4
        if: matrix.node-version == '20.x'
        with:
          token: ${{ secrets.CODECOV_TOKEN }}

  build:
    name: Build
    needs: test
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'

    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-node@v4
        with:
          node-version: '20.x'
          cache: 'npm'

      - run: npm ci
      - run: npm run build

      - name: Build-Artefakte hochladen
        uses: actions/upload-artifact@v4
        with:
          name: build-files
          path: dist/
          retention-days: 7

  deploy:
    name: Deployment auf Produktionsumgebung
    needs: build
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    environment: production

    steps:
      - uses: actions/checkout@v4

      - name: Build-Artefakte herunterladen
        uses: actions/download-artifact@v4
        with:
          name: build-files
          path: dist/

      - name: Auf Server deployen
        uses: appleboy/ssh-action@v1.0.0
        with:
          host: ${{ secrets.DEPLOY_HOST }}
          username: ${{ secrets.DEPLOY_USER }}
          key: ${{ secrets.DEPLOY_SSH_KEY }}
          script: |
            cd /var/www/myapp
            git pull origin main
            npm ci --production
            pm2 restart myapp

Python-Projekt CI-Workflow

# .github/workflows/python-ci.yml
name: Python CI

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

jobs:
  test:
    runs-on: ubuntu-latest

    strategy:
      matrix:
        python-version: ["3.11", "3.12", "3.13"]

    steps:
      - uses: actions/checkout@v4

      - name: Python ${{ matrix.python-version }} einrichten
        uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}
          cache: 'pip'

      - name: Abhängigkeiten installieren
        run: |
          python -m pip install --upgrade pip
          pip install -r requirements.txt
          pip install pytest pytest-cov black flake8 mypy

      - name: Code-Formatierung prüfen (black)
        run: black --check .

      - name: Code-Qualität prüfen (flake8)
        run: flake8 . --max-line-length=100

      - name: Typprüfung (mypy)
        run: mypy src/

      - name: Tests ausführen
        run: pytest tests/ -v --cov=src --cov-report=xml

      - name: Abdeckung hochladen
        uses: codecov/codecov-action@v4
        if: matrix.python-version == '3.12'

  docker:
    needs: test
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'

    steps:
      - uses: actions/checkout@v4

      - name: Bei Docker Hub anmelden
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}

      - name: Metadaten extrahieren
        id: meta
        uses: docker/metadata-action@v5
        with:
          images: meinname/meine-app
          tags: |
            type=ref,event=branch
            type=sha,prefix=sha-
            type=raw,value=latest,enable=${{ github.ref == 'refs/heads/main' }}

      - name: Docker-Image bauen und pushen
        uses: docker/build-push-action@v5
        with:
          context: .
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          cache-from: type=gha
          cache-to: type=gha,mode=max

Secrets verwalten

Sensible Daten (API-Keys, Passwörter, SSH-Schlüssel) gehören niemals in den Code. GitHub Actions bietet sicheres Secret-Management.

Secrets hinzufügen

Repository öffnen → Settings → Secrets and variables → Actions
"New repository secret" klicken
Name (z.B. DEPLOY_SSH_KEY) und Wert eingeben

Im Workflow verwenden

steps:
  - name: Secrets verwenden
    env:
      API_KEY: ${{ secrets.API_KEY }}
      DB_PASSWORD: ${{ secrets.DB_PASSWORD }}
    run: |
      echo "API_KEY=$API_KEY" >> .env
      # Wichtig: Secrets niemals in Logs ausgeben!

Cache-Optimierung: Workflows beschleunigen

# npm-Abhängigkeiten cachen
- uses: actions/setup-node@v4
  with:
    node-version: '20'
    cache: 'npm'   # Eingebaute Cache-Unterstützung

# Oder manuell konfigurieren
- name: node_modules cachen
  uses: actions/cache@v4
  with:
    path: ~/.npm
    key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
    restore-keys: |
      ${{ runner.os }}-node-

# Python pip-Cache
- uses: actions/setup-python@v5
  with:
    python-version: '3.12'
    cache: 'pip'

Guter Einsatz von Caches kann Workflow-Laufzeiten von Minuten auf Sekunden reduzieren.

Matrix-Builds: Multi-Umgebungs-Tests

strategy:
  matrix:
    os: [ubuntu-latest, windows-latest, macos-latest]
    node: [18, 20, 22]
    exclude:
      - os: windows-latest
        node: 18
  fail-fast: false  # Failure einer Kombination stoppt nicht andere

runs-on: ${{ matrix.os }}

Geplante Aufgaben

on:
  schedule:
    # Täglich um 01:00 Uhr UTC (02:00 MEZ)
    - cron: '0 1 * * *'
    # Jeden Montag um 09:00 Uhr UTC
    - cron: '0 9 * * 1'

Typische Anwendungsfälle für geplante Aufgaben:

Sicherheitslücken-Scans bei Abhängigkeiten
Datensicherungen
Performance-Benchmarks
Regelmäßige Datensynchronisation

Umgebungsschutz

Für Produktions-Deployments können Genehmigungsregeln konfiguriert werden:

deploy:
  environment:
    name: production
    url: https://meine-app.de
  # Genehmiger müssen in den Repository-Einstellungen konfiguriert sein

Empfehlenswerte Actions

Action	Verwendungszweck
actions/checkout	Code auschecken (immer nötig)
actions/setup-node	Node.js-Umgebung konfigurieren
actions/setup-python	Python-Umgebung konfigurieren
actions/cache	Abhängigkeiten cachen
actions/upload-artifact	Build-Artefakte hochladen
docker/build-push-action	Docker-Images bauen und pushen
appleboy/ssh-action	SSH-Remote-Deployment
codecov/codecov-action	Code-Coverage hochladen

Fazit

GitHub Actions ist eine zentrale Infrastrukturkomponente moderner Software-Entwicklung. Mit diesem Tutorial hast du gelernt:

Workflow-Grundstruktur und Kernkonzepte
Vollständige CI/CD-Pipelines für Node.js und Python
Secret-Management und Sicherheitspraktiken
Cache-Optimierung und Matrix-Builds
Geplante Aufgaben und Umgebungsschutz

Konfiguriere noch heute CI/CD für deine Projekte. Selbst die einfachste automatisierte Testsuite verbessert die Code-Qualität und Teamzusammenarbeit erheblich. Mit wachsender Erfahrung kannst du deine Automatisierungs-Pipeline kontinuierlich ausbauen und GitHub Actions zu deinem zuverlässigsten Automatisierungshelfer machen.