Claude Code GitLab CI/CD

​

Warum Claude Code mit GitLab verwenden?

• Sofortige MR-Erstellung: Beschreiben Sie, was Sie benötigen, und Claude schlägt eine vollständige MR mit Änderungen und Erklärung vor
• Automatisierte Implementierung: Verwandeln Sie Issues in funktionierenden Code mit einem einzigen Befehl oder einer Erwähnung
• Projektbewusst: Claude folgt Ihren CLAUDE.md-Richtlinien und bestehenden Code-Mustern
• Einfache Einrichtung: Fügen Sie einen Job zu .gitlab-ci.yml hinzu und eine maskierte CI/CD-Variable
• Enterprise-ready: Wählen Sie Anthropic API, AWS Bedrock oder Google Vertex AI, um Datenresidenz- und Beschaffungsanforderungen zu erfüllen
• Standardmäßig sicher: Läuft in Ihren GitLab-Runnern mit Ihrem Branch-Schutz und Genehmigungen

​

Wie es funktioniert

Claude Code verwendet GitLab CI/CD, um KI-Aufgaben in isolierten Jobs auszuführen und Ergebnisse über MRs zurückzucommiten:

1. Ereignisgesteuerte Orchestrierung: GitLab lauscht auf Ihre gewählten Trigger (zum Beispiel ein Kommentar, der @claude in einem Issue, MR oder Review-Thread erwähnt). Der Job sammelt Kontext aus dem Thread und Repository, erstellt Prompts aus dieser Eingabe und führt Claude Code aus.

2. Provider-Abstraktion: Verwenden Sie den Provider, der zu Ihrer Umgebung passt:

   • Anthropic API (SaaS)
   • AWS Bedrock (IAM-basierter Zugriff, regionsübergreifende Optionen)
   • Google Vertex AI (GCP-nativ, Workload Identity Federation)

3. Sandboxed-Ausführung: Jede Interaktion läuft in einem Container mit strengen Netzwerk- und Dateisystem-Regeln. Claude Code erzwingt arbeitsbereichsbeschränkte Berechtigungen, um Schreibvorgänge zu begrenzen. Jede Änderung fließt durch eine MR, sodass Reviewer das Diff sehen und Genehmigungen weiterhin gelten.

Wählen Sie regionale Endpunkte, um Latenz zu reduzieren und Datensouveränitätsanforderungen zu erfüllen, während Sie bestehende Cloud-Vereinbarungen nutzen.

​

Was kann Claude tun?

Claude Code ermöglicht leistungsstarke CI/CD-Workflows, die die Art und Weise transformieren, wie Sie mit Code arbeiten:

• MRs aus Issue-Beschreibungen oder Kommentaren erstellen und aktualisieren
• Performance-Regressionen analysieren und Optimierungen vorschlagen
• Features direkt in einem Branch implementieren und dann eine MR öffnen
• Bugs und Regressionen beheben, die durch Tests oder Kommentare identifiziert wurden
• Auf Follow-up-Kommentare antworten, um auf angeforderte Änderungen zu iterieren

​

Einrichtung

​

Schnelle Einrichtung

Der schnellste Weg, um zu beginnen, ist das Hinzufügen eines minimalen Jobs zu Ihrer .gitlab-ci.yml und das Setzen Ihres API-Schlüssels als maskierte Variable.

1. Eine maskierte CI/CD-Variable hinzufügen

   • Gehen Sie zu Einstellungen → CI/CD → Variablen
   • Fügen Sie ANTHROPIC_API_KEY hinzu (maskiert, nach Bedarf geschützt)

2. Einen Claude-Job zu .gitlab-ci.yml hinzufügen

stages:
  - ai

claude:
  stage: ai
  image: node:24-alpine3.21
  # Passen Sie Regeln an, um zu bestimmen, wie Sie den Job auslösen möchten:
  # - manuelle Ausführungen
  # - Merge-Request-Ereignisse
  # - Web/API-Trigger, wenn ein Kommentar '@claude' enthält
  rules:
    - if: '$CI_PIPELINE_SOURCE == "web"'
    - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
  variables:
    GIT_STRATEGY: fetch
  before_script:
    - apk update
    - apk add --no-cache git curl bash
    - npm install -g @anthropic-ai/claude-code
  script:
    # Optional: Starten Sie einen GitLab MCP-Server, falls Ihr Setup einen bereitstellt
    - /bin/gitlab-mcp-server || true
    # Verwenden Sie AI_FLOW_*-Variablen beim Aufrufen über Web/API-Trigger mit Kontext-Payloads
    - echo "$AI_FLOW_INPUT for $AI_FLOW_CONTEXT on $AI_FLOW_EVENT"
    - >
      claude
      -p "${AI_FLOW_INPUT:-'Review this MR and implement the requested changes'}"
      --permission-mode acceptEdits
      --allowedTools "Bash(*) Read(*) Edit(*) Write(*) mcp__gitlab"
      --debug

Nach dem Hinzufügen des Jobs und Ihrer ANTHROPIC_API_KEY-Variable testen Sie, indem Sie den Job manuell von CI/CD → Pipelines ausführen oder ihn von einer MR auslösen, um Claude Aktualisierungen in einem Branch vorschlagen und bei Bedarf eine MR öffnen zu lassen.

​

Manuelle Einrichtung (für Produktion empfohlen)

Wenn Sie eine kontrolliertere Einrichtung bevorzugen oder Enterprise-Provider benötigen:

1. Provider-Zugriff konfigurieren:

   • Anthropic API: Erstellen und speichern Sie ANTHROPIC_API_KEY als maskierte CI/CD-Variable
   • AWS Bedrock: GitLab → AWS OIDC konfigurieren und eine IAM-Rolle für Bedrock erstellen
   • Google Vertex AI: Workload Identity Federation für GitLab → GCP konfigurieren

2. Projekt-Anmeldedaten für GitLab API-Operationen hinzufügen:

   • Verwenden Sie standardmäßig CI_JOB_TOKEN oder erstellen Sie ein Project Access Token mit api-Bereich
   • Als GITLAB_ACCESS_TOKEN (maskiert) speichern, wenn Sie ein PAT verwenden

3. Den Claude-Job zu .gitlab-ci.yml hinzufügen (siehe Beispiele unten)

4. (Optional) Erwähnungsgesteuerte Trigger aktivieren:

   • Fügen Sie einen Projekt-Webhook für “Kommentare (Notizen)” zu Ihrem Event-Listener hinzu (falls Sie einen verwenden)
   • Lassen Sie den Listener die Pipeline-Trigger-API mit Variablen wie AI_FLOW_INPUT und AI_FLOW_CONTEXT aufrufen, wenn ein Kommentar @claude enthält

​

Beispiel-Anwendungsfälle

​

Issues in MRs verwandeln

In einem Issue-Kommentar:

@claude implement this feature based on the issue description

Claude analysiert das Issue und die Codebasis, schreibt Änderungen in einem Branch und öffnet eine MR zur Überprüfung.

​

Implementierungshilfe erhalten

In einer MR-Diskussion:

@claude suggest a concrete approach to cache the results of this API call

Claude schlägt Änderungen vor, fügt Code mit angemessenem Caching hinzu und aktualisiert die MR.

​

Bugs schnell beheben

In einem Issue- oder MR-Kommentar:

@claude fix the TypeError in the user dashboard component

Claude lokalisiert den Bug, implementiert eine Lösung und aktualisiert den Branch oder öffnet eine neue MR.

​

Verwendung mit AWS Bedrock & Google Vertex AI

Für Enterprise-Umgebungen können Sie Claude Code vollständig auf Ihrer Cloud-Infrastruktur mit derselben Entwicklererfahrung ausführen.

# Für AWS Bedrock:
- AWS_ROLE_TO_ASSUME
- AWS_REGION

# Für AWS Bedrock:
- AWS_ROLE_TO_ASSUME
- AWS_REGION

# Für Google Vertex AI:
- GCP_WORKLOAD_IDENTITY_PROVIDER
- GCP_SERVICE_ACCOUNT
- CLOUD_ML_REGION (zum Beispiel us-east5)

​

Konfigurationsbeispiele

Unten sind gebrauchsfertige Snippets, die Sie an Ihre Pipeline anpassen können.

​

Basis .gitlab-ci.yml (Anthropic API)

stages:
  - ai

claude:
  stage: ai
  image: node:24-alpine3.21
  rules:
    - if: '$CI_PIPELINE_SOURCE == "web"'
    - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
  variables:
    GIT_STRATEGY: fetch
  before_script:
    - apk update
    - apk add --no-cache git curl bash
    - npm install -g @anthropic-ai/claude-code
  script:
    - /bin/gitlab-mcp-server || true
    - >
      claude
      -p "${AI_FLOW_INPUT:-'Summarize recent changes and suggest improvements'}"
      --permission-mode acceptEdits
      --allowedTools "Bash(*) Read(*) Edit(*) Write(*) mcp__gitlab"
      --debug
  # Claude Code wird ANTHROPIC_API_KEY aus CI/CD-Variablen verwenden

​

AWS Bedrock Job-Beispiel (OIDC)

Voraussetzungen:

• Amazon Bedrock aktiviert mit Zugriff auf Ihre gewählten Claude-Modelle
• GitLab OIDC in AWS mit einer Rolle konfiguriert, die Ihrem GitLab-Projekt und Refs vertraut
• IAM-Rolle mit Bedrock-Berechtigungen (Least Privilege empfohlen)

Erforderliche CI/CD-Variablen:

• AWS_ROLE_TO_ASSUME: ARN der IAM-Rolle für Bedrock-Zugriff
• AWS_REGION: Bedrock-Region (zum Beispiel us-west-2)

claude-bedrock:
  stage: ai
  image: node:24-alpine3.21
  rules:
    - if: '$CI_PIPELINE_SOURCE == "web"'
  before_script:
    - apk add --no-cache bash curl jq git python3 py3-pip
    - pip install --no-cache-dir awscli
    - npm install -g @anthropic-ai/claude-code
    # GitLab OIDC-Token gegen AWS-Anmeldedaten tauschen
    - export AWS_WEB_IDENTITY_TOKEN_FILE="${CI_JOB_JWT_FILE:-/tmp/oidc_token}"
    - if [ -n "${CI_JOB_JWT_V2}" ]; then printf "%s" "$CI_JOB_JWT_V2" > "$AWS_WEB_IDENTITY_TOKEN_FILE"; fi
    - >
      aws sts assume-role-with-web-identity
      --role-arn "$AWS_ROLE_TO_ASSUME"
      --role-session-name "gitlab-claude-$(date +%s)"
      --web-identity-token "file://$AWS_WEB_IDENTITY_TOKEN_FILE"
      --duration-seconds 3600 > /tmp/aws_creds.json
    - export AWS_ACCESS_KEY_ID="$(jq -r .Credentials.AccessKeyId /tmp/aws_creds.json)"
    - export AWS_SECRET_ACCESS_KEY="$(jq -r .Credentials.SecretAccessKey /tmp/aws_creds.json)"
    - export AWS_SESSION_TOKEN="$(jq -r .Credentials.SessionToken /tmp/aws_creds.json)"
  script:
    - /bin/gitlab-mcp-server || true
    - >
      claude
      -p "${AI_FLOW_INPUT:-'Implement the requested changes and open an MR'}"
      --permission-mode acceptEdits
      --allowedTools "Bash(*) Read(*) Edit(*) Write(*) mcp__gitlab"
      --debug
  variables:
    AWS_REGION: "us-west-2"

​

Google Vertex AI Job-Beispiel (Workload Identity Federation)

Voraussetzungen:

• Vertex AI API in Ihrem GCP-Projekt aktiviert
• Workload Identity Federation konfiguriert, um GitLab OIDC zu vertrauen
• Ein Service-Konto mit Vertex AI-Berechtigungen

Erforderliche CI/CD-Variablen:

• GCP_WORKLOAD_IDENTITY_PROVIDER: Vollständiger Provider-Ressourcenname
• GCP_SERVICE_ACCOUNT: Service-Konto-E-Mail
• CLOUD_ML_REGION: Vertex-Region (zum Beispiel us-east5)

claude-vertex:
  stage: ai
  image: gcr.io/google.com/cloudsdktool/google-cloud-cli:slim
  rules:
    - if: '$CI_PIPELINE_SOURCE == "web"'
  before_script:
    - apt-get update && apt-get install -y git nodejs npm && apt-get clean
    - npm install -g @anthropic-ai/claude-code
    # Bei Google Cloud über WIF authentifizieren (keine heruntergeladenen Schlüssel)
    - >
      gcloud auth login --cred-file=<(cat <<EOF
      {
        "type": "external_account",
        "audience": "${GCP_WORKLOAD_IDENTITY_PROVIDER}",
        "subject_token_type": "urn:ietf:params:oauth:token-type:jwt",
        "service_account_impersonation_url": "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/${GCP_SERVICE_ACCOUNT}:generateAccessToken",
        "token_url": "https://sts.googleapis.com/v1/token"
      }
      EOF
      )
    - gcloud config set project "$(gcloud projects list --format='value(projectId)' --filter="name:${CI_PROJECT_NAMESPACE}" | head -n1)" || true
  script:
    - /bin/gitlab-mcp-server || true
    - >
      CLOUD_ML_REGION="${CLOUD_ML_REGION:-us-east5}"
      claude
      -p "${AI_FLOW_INPUT:-'Review and update code as requested'}"
      --permission-mode acceptEdits
      --allowedTools "Bash(*) Read(*) Edit(*) Write(*) mcp__gitlab"
      --debug
  variables:
    CLOUD_ML_REGION: "us-east5"

​

Best Practices

​

CLAUDE.md-Konfiguration

Erstellen Sie eine CLAUDE.md-Datei im Repository-Root, um Coding-Standards, Review-Kriterien und projektspezifische Regeln zu definieren. Claude liest diese Datei während der Ausführung und folgt Ihren Konventionen beim Vorschlagen von Änderungen.

​

Sicherheitsüberlegungen

Committen Sie niemals API-Schlüssel oder Cloud-Anmeldedaten in Ihr Repository! Verwenden Sie immer GitLab CI/CD-Variablen:

• Fügen Sie ANTHROPIC_API_KEY als maskierte Variable hinzu (und schützen Sie sie bei Bedarf)
• Verwenden Sie provider-spezifisches OIDC wo möglich (keine langlebigen Schlüssel)
• Begrenzen Sie Job-Berechtigungen und Netzwerk-Egress
• Überprüfen Sie Claudes MRs wie jeden anderen Beitragenden

​

Performance-Optimierung

• Halten Sie CLAUDE.md fokussiert und prägnant
• Stellen Sie klare Issue/MR-Beschreibungen bereit, um Iterationen zu reduzieren
• Konfigurieren Sie sinnvolle Job-Timeouts, um Runaway-Runs zu vermeiden
• Cachen Sie npm- und Paket-Installationen in Runnern wo möglich

​

CI-Kosten

Bei der Verwendung von Claude Code mit GitLab CI/CD sollten Sie sich der damit verbundenen Kosten bewusst sein:

• GitLab Runner-Zeit:

  • Claude läuft auf Ihren GitLab-Runnern und verbraucht Compute-Minuten
  • Siehe die Runner-Abrechnung Ihres GitLab-Plans für Details

• API-Kosten:

  • Jede Claude-Interaktion verbraucht Token basierend auf Prompt- und Antwortgröße
  • Token-Verbrauch variiert je nach Aufgabenkomplexität und Codebasis-Größe
  • Siehe Anthropic-Preisefür Details

• Kostenoptimierungs-Tipps:

  • Verwenden Sie spezifische @claude-Befehle, um unnötige Turns zu reduzieren
  • Setzen Sie angemessene max_turns- und Job-Timeout-Werte
  • Begrenzen Sie die Parallelität, um parallele Runs zu kontrollieren

​

Sicherheit und Governance

• Jeder Job läuft in einem isolierten Container mit eingeschränktem Netzwerkzugriff
• Claudes Änderungen fließen durch MRs, sodass Reviewer jedes Diff sehen
• Branch-Schutz und Genehmigungsregeln gelten für KI-generierten Code
• Claude Code verwendet arbeitsbereichsbeschränkte Berechtigungen, um Schreibvorgänge zu begrenzen
• Kosten bleiben unter Ihrer Kontrolle, da Sie Ihre eigenen Provider-Anmeldedaten mitbringen

​

Fehlerbehebung

​

Claude antwortet nicht auf @claude-Befehle

• Überprüfen Sie, dass Ihre Pipeline ausgelöst wird (manuell, MR-Ereignis oder über einen Note-Event-Listener/Webhook)
• Stellen Sie sicher, dass CI/CD-Variablen (ANTHROPIC_API_KEY oder Cloud-Provider-Einstellungen) vorhanden und nicht maskiert sind
• Überprüfen Sie, dass der Kommentar @claude (nicht /claude) enthält und dass Ihr Erwähnungs-Trigger konfiguriert ist

​

Job kann keine Kommentare schreiben oder MRs öffnen

• Stellen Sie sicher, dass CI_JOB_TOKEN ausreichende Berechtigungen für das Projekt hat, oder verwenden Sie ein Project Access Token mit api-Bereich
• Überprüfen Sie, dass das mcp__gitlab-Tool in --allowedTools aktiviert ist
• Bestätigen Sie, dass der Job im Kontext der MR läuft oder genügend Kontext über AI_FLOW_*-Variablen hat

​

Authentifizierungsfehler

• Für Anthropic API: Bestätigen Sie, dass ANTHROPIC_API_KEY gültig und nicht abgelaufen ist
• Für Bedrock/Vertex: Überprüfen Sie OIDC/WIF-Konfiguration, Rollenimitation und Secret-Namen; bestätigen Sie Region und Modellverfügbarkeit

​

Erweiterte Konfiguration

​

Häufige Parameter und Variablen

Claude Code unterstützt diese häufig verwendeten Eingaben:

• prompt / prompt_file: Anweisungen inline (-p) oder über eine Datei bereitstellen
• max_turns: Anzahl der Hin-und-Her-Iterationen begrenzen
• timeout_minutes: Gesamtausführungszeit begrenzen
• ANTHROPIC_API_KEY: Erforderlich für die Anthropic API (nicht für Bedrock/Vertex verwendet)
• Provider-spezifische Umgebung: AWS_REGION, Projekt/Region-Vars für Vertex

​

Claudes Verhalten anpassen

Sie können Claude auf zwei primäre Weise leiten:

1. CLAUDE.md: Definieren Sie Coding-Standards, Sicherheitsanforderungen und Projektkonventionen. Claude liest dies während der Ausführung und folgt Ihren Regeln.
2. Benutzerdefinierte Prompts: Übergeben Sie aufgabenspezifische Anweisungen über prompt/prompt_file im Job. Verwenden Sie verschiedene Prompts für verschiedene Jobs (zum Beispiel Review, Implementierung, Refactoring).