[{"data":1,"prerenderedAt":786},["ShallowReactive",2],{"/de-de/blog/from-code-to-production-a-guide-to-continuous-deployment-with-gitlab":3,"navigation-de-de":44,"banner-de-de":446,"footer-de-de":456,"blog-post-authors-de-de-Benjamin Skierlak|James Wormwell":661,"blog-related-posts-de-de-from-code-to-production-a-guide-to-continuous-deployment-with-gitlab":687,"blog-promotions-de-de":723,"next-steps-de-de":776},{"id":4,"title":5,"authorSlugs":6,"body":9,"categorySlug":10,"config":11,"content":15,"description":9,"extension":30,"isFeatured":13,"meta":31,"navigation":32,"path":33,"publishedDate":22,"seo":34,"stem":39,"tagSlugs":40,"__hash__":43},"blogPosts/de-de/blog/from-code-to-production-a-guide-to-continuous-deployment-with-gitlab.yml","From Code To Production A Guide To Continuous Deployment With Gitlab",[7,8],"benjamin-skierlak","james-wormwell",null,"product",{"slug":12,"featured":13,"template":14},"from-code-to-production-a-guide-to-continuous-deployment-with-gitlab",false,"BlogPost",{"heroImage":16,"body":17,"authors":18,"updatedDate":21,"date":22,"title":23,"tags":24,"description":29,"category":10},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1749659478/Blog/Hero%20Images/REFERENCE_-_Use_this_page_as_a_reference_for_thumbnail_sizes.png","Die kontinuierliche Bereitstellung ist eine bahnbrechende Praxis, die es Teams ermöglicht, schneller und mit höherem Vertrauen Werte zu schaffen. Das Eintauchen in erweiterte Bereitstellungs-Workflows – wie GitOps, Container-Orchestrierung mit Kubernetes oder dynamische Umgebungen – kann jedoch für Teams, die gerade erst anfangen, einschüchternd sein.\n\nGitLab setzt sich dafür ein, die Bereitstellung nahtlos und skalierbar zu gestalten. Indem wir es den Teams ermöglichen, sich auf die Grundlagen zu konzentrieren, befähigen wir sie, eine starke Basis zu schaffen, die das Wachstum komplexerer Strategien im Laufe der Zeit unterstützt. Dieser Leitfaden enthält wichtige Schritte, um mit der Implementierung der kontinuierlichen Bereitstellung mit GitLab zu beginnen und die Grundlage für deinen langfristigen Erfolg zu schaffen.\n\n## Inhaltsverzeichnis\n\n* [Beginne mit einem Workflow-Plan](#beginne-mit-einem-workflow-plan)\n\n  * [Artefakt-Management-Strategie](#artefakt-management-strategie)\n\n    * [Artefakte und Versionsstrategien](#artefakte-und-versionsstrategien)\n    * [Artefaktaufbewahrung erstellen](#artefaktaufbewahrung-erstellen)\n    * [Registrierungszugriff und Authentifizierung](#registrierungszugriff-und-authentifizierung)\n  * [Umgebungsstrategie](#umgebungsstrategie)\n  * [Bereitstellungsziele](#bereitstellungsziele)\n* [Deine CD-Pipeline implementieren](#deine-cd-pipeline-implementieren)\n\n  * [Ein Schritt-für-Schritt-Beispiel](#ein-schritt-für-schritt-beispiel)\n\n    * [Voraussetzungen](#voraussetzungen)\n  * [Best Practices](#best-practices)\n* [Skaliere deine Bereitstellungsstrategie](#skaliere-deine-bereitstellungsstrategie)\n\n  * [Erweiterte Sicherheitsmaßnahmen](#erweiterte-sicherheitsmaßnahmen)\n  * [Progressive Bereitstellungsstrategien](#progressive-bereitstellungsstrategien)\n  * [Überwachung und Optimierung](#überwachung-und-optimierung)\n* [Warum GitLab](#warum-gitlab)\n* [Noch heute starten](#noch-heute-starten)\n\n## Beginne mit einem Workflow-Plan\n\nBevor du dich mit der technischen Implementierung befasst, nimm dir Zeit, um deinen Bereitstellungs-Workflow zu planen. Der Erfolg liegt in der sorgfältigen Planung und dem methodischen Vorgehen.\n\n### Artefakt-Management-Strategie\n\nIm Zusammenhang mit der kontinuierlichen Bereitstellung sind Artefakte die Paket-Ausgaben deines Build-Prozesses, die gespeichert, als Versionen verwaltet und bereitgestellt werden müssen. Darunter fallen:\n\n* Container-Images für deine Anwendungen\n* Pakete\n* kompilierte Binärdateien oder ausführbare Dateien\n* Bibliotheken\n* Konfigurationsdateien\n* Dokumentationspakete\n* andere Artefakte\n\nJede Art von Artefakt spielt eine bestimmte Rolle in deinem Bereitstellungsprozess. Zum Beispiel könnte eine typische Webanwendung Folgendes generieren:\n\n* ein Container-Image für den Backend-Service\n* ein ZIP-Archiv mit kompilierten Frontend-Assets\n* SQL-Dateien für Datenbankänderungen\n* umweltspezifische Konfigurationsdateien\n\nDie effektive Verwaltung dieser Artefakte ist für erfolgreiche Bereitstellungen von entscheidender Bedeutung. Hier erfährst du, wie du das Artefakt-Management angehen kannst.\n\n#### Artefakte und Versionsstrategien\n\nEine Best Practice, um mit einer sauberen Struktur zu beginnen, besteht darin, eine klare Versionsstrategie für deine Artefakte festzulegen. Bei der Erstellung von Releases gilt:\n\n* Verwende eine semantische Versionsverwaltung (major.minor.patch) für Release-Tags\n\n  * Beispiel: `myapp:1.2.3` für ein stabiles Release\n  * Wichtige Versionsänderungen (2.0.0) für Breaking Changes\n  * Geringfügige Versionsänderungen (1.3.0) für neue Funktionen\n  * Patch-Versionsänderungen (1.2.4) für Fehlerbehebungen\n* Pflege einen „neuesten“ Tag für die neueste stabile Version\n\n  * Beispiel: `myapp:latest` für automatisierte Bereitstellungen\n* Beziehe Commit-SHA für präzises Versions-Tracking ein\n\n  * Beispiel: `myapp:1.2.3-abc123f` zum Debuggen\n* Berücksichtige Branch-basierte Tags für Entwicklungsumgebungen\n\n  * Beispiel: `myapp: feature-user-auth` für Funktionstests\n\n#### Artefaktaufbewahrung erstellen\n\nImplementiere definierte Aufbewahrungsregeln:\n\n* Lege explizite Ablaufzeitrahmen für temporäre Artefakte fest\n* Definiere, welche Artefakte dauerhaft aufbewahrt werden müssen\n* Konfiguriere Bereinigungsrichtlinien zur Verwaltung des Speichers\n\n#### Registrierungszugriff und Authentifizierung\n\nSchütze deine Artefakte mit den richtigen Zugangskontrollen:\n\n* Implementiere persönliche Zugriffstoken für den Entwicklerzugriff\n* Konfiguriere CI/CD-Variablen für die Pipeline-Authentifizierung\n* Richte ordnungsgemäße Zugangsumfänge ein\n\n### Umgebungsstrategie\n\nBetrachte deine Umgebungen frühzeitig, da sie deine gesamte Bereitstellungspipeline prägen:\n\n* Konfigurationen der Entwicklungs-, Staging- und Produktionsumgebung\n* Umgebungsspezifische Variablen und Geheimnisse\n* Zugangskontrollen und Schutzregeln\n* Ansatz zur Nachverfolgung und Überwachung der Bereitstellung\n\n### Bereitstellungsziele\n\nSei dir bewusst, wo und wie du bereitstellen wirst. Diese Entscheidungen sind wichtig und die jeweiligen Vor- und Nachteile sollten berücksichtigt werden:\n\n* Infrastrukturanforderungen (VMs, Container, Cloud-Services)\n* Netzwerkzugriff und Sicherheitskonfigurationen\n* Authentifizierungsmechanismen (SSH-Schlüssel, Zugriffstoken)\n* Überlegungen zur Ressourcenzuweisung und Skalierung\n\nNachdem wir unsere Strategie definiert und grundlegende Entscheidungen getroffen haben, können wir diese Pläne jetzt in eine funktionierende Pipeline umsetzen. Wir werden ein praktisches Beispiel erstellen, das diese Konzepte demonstriert, beginnend mit einer einfachen Anwendung und dem schrittweisen Hinzufügen von Bereitstellungsfunktionen.\n\n## Deine CD-Pipeline implementieren\n\n### Ein Schritt-für-Schritt-Beispiel\n\nSehen wir uns nun die Implementierung einer grundlegenden Pipeline für die kontinuierliche Bereitstellung für eine Webanwendung an. Wir werden eine einfache HTML-Anwendung als Beispiel verwenden, aber diese Prinzipien gelten für jede Art von Anwendung. Wir werden unsere Anwendung auch als Docker Image auf einer einfachen virtuellen Maschine bereitstellen. Somit können wir uns auf ein kuratiertes Bild mit minimalen Abhängigkeiten stützen und sicherstellen, dass keine umgebungsspezifischen Anforderungen unbeabsichtigt eingeführt werden. Wenn wir an einer virtuellen Maschine arbeiten, werden wir die nativen Integrationen von GitLab nicht nutzen, sodass wir zunächst an einem einfacheren, aber weniger skalierbaren Setup arbeiten können.\n\n#### Voraussetzungen\n\nIn diesem Beispiel zielen wir darauf ab, eine Anwendung zu containerisieren, die wir auf einer virtuellen Maschine ausführen, die auf einem Cloud-Anbieter gehostet wird. Wir werden diese Anwendung auch lokal auf unserem Computer testen. Diese Liste der Voraussetzungen wird nur für dieses Szenario benötigt.\n\n##### Einrichtung der virtuellen Maschine\n\n* Stelle eine VM in deinem bevorzugten Cloud-Provider (z. B. GCP, AWS, Azure) bereit\n* Konfiguriere die Netzwerkregeln, um den Zugriff auf die Ports 22, 80 und 443 zu ermöglichen\n* Zeichne die öffentliche IP-Adresse des Computers für die Bereitstellung auf\n\n##### SSH-Authentifizierung einrichten:\n\n* Generiere ein öffentliches/privates Schlüsselpaar für die Maschine\n* Gehe in GitLab zu **Einstellungen > CI/CD > Variablen**\n* Erstelle eine Variable mit dem Namen `GITLAB_KEY`\n* Wähle als Typ „Datei“ (für SSH-Authentifizierung erforderlich)\n* Füge den privaten Schlüssel in das Feld „Wert“ ein\n* Definiere eine BENUTZERVARIABLE; dies ist der Benutzer, der sich anmeldet und die Skripte auf deiner VM ausführt\n\n##### Bereitstellungsvariablen konfigurieren\n\n* Erstelle Variablen für deine Bereitstellungsziele:\n\n  * `STAGING_TARGET`: deine Staging-Server-IP/-Domäne\n  * `PRODUCTION_TARGET`: deine Produktionsserver-IP/-Domäne\n\n##### Lokales Entwicklungs-Setup\n\n* Installiere Docker auf deinem lokalen Computer, um Bereitstellungen zu testen\n\n##### GitLab-Container-Registry-Zugriff\n\n* Finde deinen Registry-Pfad:\n\n  * Navigiere zu **Bereitstellen > Container-Registry**\n  * Kopiere den Registry-Pfad (z. B. registry.gitlab.com/group/project)\n* Authentifizierung einrichten:\n\n  * Gehe zu **Einstellungen > Zugriffstoken**\n  * Erstelle ein neues Token mit Registry-Zugriff\n  * Token-Ablauf: max. 1 Jahr\n  * Speichere das Token sicher\n* Lokalen Registry-Zugriff konfigurieren:\n\n```shell\ndocker login registry.gitlab.com\n# Der Benutzername, wenn du einen PAT verwendest, ist gitlab-ci-token\n# Passwort: your-access-token\n```\n\n#### 1. Erstelle deine Anwendung\n\nBeginne mit einer grundlegenden Webanwendung. In unserem Beispiel verwenden wir eine einfache HTML-Seite:\n\n```xml\n\u003C!|||UNTRANSLATED_CONTENT_START|||-- index.html -->\n\u003Chtml>\n  \u003Chead>\n    \u003Cstyle>\n      body {\n        background-color: #171321; /* GitLab dark */\n      }\n    \u003C/style>\n  \u003C/head>\n  \u003Cbody>\n    \u003C!|||UNTRANSLATED_CONTENT_END|||-- Dein Inhalt hier -->\n  \u003C/body>\n\u003C/html>\n```\n\n#### 2. Containerisiere deine Anwendung\n\nErstelle ein Dockerfile, um deine Anwendung zu paketieren:\n\n```text\nFROM nginx:1.26.2\nCOPY index.html /usr/share/nginx/html/index.html\n```\n\nDieses Dockerfile:\n\n* Verwendet nginx als Basis-Image für die Bereitstellung von Webinhalten\n* Kopiert deine HTML-Datei an die richtige Stelle in der nginx-Verzeichnisstruktur\n\n#### 3. Richte deine CI/CD-Pipeline ein\n\nErstelle eine `.gitlab-ci.yml`-Datei, um deine Pipeline-Phasen zu definieren:\n\n```yaml\nvariables:\n  TAG_LATEST: $CI_REGISTRY_IMAGE/$CI_COMMIT_REF_NAME:latest\n  TAG_COMMIT: $CI_REGISTRY_IMAGE/$CI_COMMIT_REF_NAME:$CI_COMMIT_SHA\n\nstages:\n  - publish\n  - deploy\n```\n\nSehen wir uns das genauer an:\n\n`TAG_LATEST` besteht aus drei Teilen:\n\n* `$CI_REGISTRY_IMAGE` ist der Pfad zum Container-Registry deines Projekts in GitLab\n\nZum Beispiel: `registry.gitlab.com/your-group/your-project`\n\n* `$CI_COMMIT_REF_NAME` ist der Name deiner Branch oder deines Tags\n\nZum Beispiel, wenn du dich im Haupt-Branch befindest: `/main`, und wenn du dich in einem Feature-Branch befindest: `/feature-login`\n\n* `:latest` ist ein festes Suffix\n\nWenn du dich also im Main-Branch befindest, wird `TAG_LATEST` zu: `registry.gitlab.com/your-group/your-project/main:latest`.\n\n`TAG_COMMIT` ist fast identisch, aber anstelle von `:latest` verwendet es: `$CI_COMMIT_SHA`, was die Commit-Kennung ist, zum Beispiel: `:abc123def456`.\n\nFür denselben Commit im Haupt-Branch wird `TAG_COMMIT` zu: `registry.gitlab.com/your-group/your-project/main:abc123def456`.\n\nDer Grund für beides ist, dass `TAG_LATEST` dir eine einfache Möglichkeit bietet, immer die neueste Version zu erhalten, und `TAG_COMMIT` gibt dir eine bestimmte Version, zu der du bei Bedarf zurückkehren kannst.\n\n#### 4. Im Container-Registry veröffentlichen\n\nFüge den Veröffentlichungsauftrag zu deiner Pipeline hinzu:\n\n```yaml\npublish:\n  stage: publish\n  image: docker:latest\n  services:\n    - docker:dind\n  script:\n    - docker build -t $TAG_LATEST -t $TAG_COMMIT .\n    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY\n    - docker push $TAG_LATEST\n    - docker push $TAG_COMMIT\n```\n\nDieser Job:\n\n* verwendet Docker-in-Docker, um Bilder zu entwickeln\n* erstellt zwei getaggte Versionen deines Bildes\n* authentifiziert sich bei der GitLab-Registrierung\n* pusht beide Versionen in das Registry \n\nJetzt, da unsere Bilder sicher im Registry gespeichert sind, können wir uns darauf konzentrieren, sie in unseren Zielumgebungen bereitzustellen. Beginnen wir mit lokalen Tests, um unser Setup zu validieren, bevor wir zu Produktionsbereitstellungen übergehen.\n\n#### 5. In deiner Umgebung bereitstellen\n\nVor der Bereitstellung in der Produktion kannst du einen lokalen Test durchführen. Wir haben unser Image gerade im GitLab-Repository veröffentlicht, das wir lokal abrufen werden. Wenn du dir über den genauen Pfad nicht sicher bist, navigiere zu **Bereitstellen > Container-Registry**. Du solltest ein Symbol sehen, um den Pfad deines Bildes am Ende der Zeile für das Container-Image zu kopieren, das du testen möchtest.\n\n```shell\ndocker login registry.gitlab.com \ndocker run -p 80:80 registry.gitlab.com/your-project-path/main:latest\n```\n\nAuf diese Weise solltest du über deinen Webbrowser lokal über deine lokale Host-Adresse auf deine Anwendung zugreifen können.\n\nDu kannst jetzt einen Bereitstellungsjob zu deiner Pipeline hinzufügen:\n\n```yaml\ndeploy:\n  stage: deploy\n  image: alpine:latest\n  script:\n    - chmod 400 $GITLAB_KEY\n    - apk add openssh-client\n    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY\n    - ssh -i $GITLAB_KEY -o StrictHostKeyChecking=no $USER@$TARGET_SERVER \n      docker pull $TAG_COMMIT &&\n      docker rm -f myapp || true &&\n      docker run -d -p 80:80 --name myapp $TAG_COMMIT\n```\n\nDieser Job:\n\n* richtet einen SSH-Zugriff auf dein Bereitstellungsziel ein\n* ruft das neueste Image auf\n* entfernt alle vorhandenen Container\n* stellt die neue Version bereit\n\n#### 6. Bereitstellungen nachverfolgen\n\nAktiviere die Nachverfolgung von Bereitstellungen, indem du die Umgebungskonfiguration hinzufügst:\n\n```yaml\ndeploy:\n  environment:\n    name: production\nurl: https://deine-anwendung-url.com\n```\n\nDadurch wird ein Umgebungsobjekt im Abschnitt **Betreiben > Umgebungen** von GitLab erstellt, das Folgendes bietet:\n\n* Bereitstellungsverlauf\n* aktueller Bereitstellungsstatus\n* schneller Zugriff auf deine Anwendung\n\nWährend eine einzelne Umgebungspipeline ein guter Ausgangspunkt ist, müssen die meisten Teams mehrere Umgebungen verwalten, um ordnungsgemäß zu testen und die Staging-Phase durchzuführen. Lass uns unsere Pipeline erweitern, um dieses realistischere Szenario zu bewältigen.\n\n#### 7. Mehrere Umgebungen einrichten\n\nFür eine robustere Pipeline, konfiguriere Staging- und Produktionsbereitstellungen:\n\n```yaml\nstages:\n  - publish\n  - staging\n  - release\n  - version\n  - production\n\nstaging:\n  stage: staging\n  rules:\n    - if: $CI_COMMIT_BRANCH == \"main\" && $CI_COMMIT_TAG == null\n  environment:\n    name: staging\n    url: https://staging.your-app.com\n  # deployment script here\n\nproduction:\n  stage: production\n  rules:\n    - if: $CI_COMMIT_TAG\n  environment:\n    name: production\n    url: https://your-app.com\n  # deployment script here\n```\n\nDieses Setup:\n\n* stellt die Staging-Phase deines Main-Branch bereit\n* verwendet GitLab-Tags, um Produktionsbereitstellungen auszulösen\n* bietet separate Nachverfolgung für jede Umgebung\n\nHier und in unserem nächsten Schritt nutzen wir eine sehr nützliche GitLab-Funktion: Tags. Durch manuelles Erstellen eines Tags im Abschnitt **Code > Tags** wird das `$CI_COMMIT_TAG` erstellt, wodurch wir Jobs entsprechend auslösen können.\n\n#### 8. Automatisierte Versionshinweise erstellen\n\nWir werden die Release-Funktionen von GitLab über unsere CI/CD-Pipeline nutzen. Aktualisiere zuerst deine Phasen in `.gitlab-ci.yml`:\n\n```yaml\nstages:\n\n- publish\n- staging\n- release # New stage for releases\n- version\n- production\n```\n\nAls Nächstes fügst du den Release-Job hinzu:\n\n```yaml\nrelease_job:\n  stage: release\n  image: registry.gitlab.com/gitlab-org/release-cli:latest\n  rules:\n    - if: $CI_COMMIT_TAG                  # Only run when a tag is created\n  script:\n    - echo \"Creating release for $CI_COMMIT_TAG\"\n  release:                                # Release configuration\n    name: 'Release $CI_COMMIT_TAG'\n    description: 'Release created from $CI_COMMIT_TAG'\n    tag_name: '$CI_COMMIT_TAG'           # The tag to create\n    ref: '$CI_COMMIT_TAG'                # The tag to base release on\n```\n\nDu kannst dies verbessern, indem du Links zu deinen Container-Bildern hinzufügst:\n\n```yaml\nrelease:\n  name: 'Release $CI_COMMIT_TAG'\n  description: 'Release created from $CI_COMMIT_TAG'\n  tag_name: '$CI_COMMIT_TAG'\n  ref: '$CI_COMMIT_TAG'\n  assets:\n    links:\n      - name: 'Container Image'\n        url: '$CI_REGISTRY_IMAGE/main:$CI_COMMIT_TAG'\n        link_type: 'image'\n```\n\nFür die automatische Erzeugung von Versionshinweisen basierend auf Commit-Nachrichten:\n\n```yaml\nrelease:\n  name: 'Release $CI_COMMIT_TAG'\n  description: 'Release notes for version $CI_COMMIT_TAG'\n  tag_name: '$CI_COMMIT_TAG'\n  ref: '$CI_COMMIT_TAG'\n  auto_generate_release_notes: true    # Enables automatic notes\n```\n\nFür aussagekräftige automatisierte Versionshinweise:\n\n* herkömmliche Commits verwenden (feat:, fix:, etc.)\n* Issue-Nummern einschließen (#123)\n* Betreff mit leerer Zeile vom Text trennen\n\nWenn du benutzerdefinierte Versionshinweise mit Bereitstellungsinformationen möchtest:\n\n```text\nrelease_job:\n  script:\n    - |\n      DEPLOY_TIME=$(date '+%Y-%m-%d %H:%M:%S')\n      CHANGES=$(git log $(git describe --tags --abbrev=0 @^)..@ --pretty=format:\"- %s\")\n      cat > release_notes.md \u003C\u003C EOF\n      ## Deployment Info\n      - Deployed on: $DEPLOY_TIME\n      - Environment: Production\n      - Version: $CI_COMMIT_TAG\n\n      ## Changes\n      $CHANGES\n\n      ## Artifacts\n      - Container Image: \\`$CI_REGISTRY_IMAGE/main:$CI_COMMIT_TAG\\`\n      EOF\n  release:\n    description: './release_notes.md'\n```\n\nNach der Konfiguration werden Releases automatisch erstellt, wenn du ein Git-Tag erstellst. Du kannst sie in GitLab unter **Bereitstellen > Releases** anzeigen.\n\n#### 9. Alles zusammensetzen\n\nSo sieht unsere finale YAML-Datei aus:\n\n```text\nvariables:\n  TAG_LATEST: $CI_REGISTRY_IMAGE/$CI_COMMIT_REF_NAME:latest\n  TAG_COMMIT: $CI_REGISTRY_IMAGE/$CI_COMMIT_REF_NAME:$CI_COMMIT_SHA\n  STAGING_TARGET: $STAGING_TARGET    # Set in CI/CD Variables\n  PRODUCTION_TARGET: $PRODUCTION_TARGET  # Set in CI/CD Variables\n\nstages:\n  - publish\n  - staging\n  - release\n  - version\n  - production\n\n# Build and publish to registry\npublish:\n  stage: publish\n  image: docker:latest\n  services:\n    - docker:dind\n  rules:\n    - if: $CI_COMMIT_BRANCH == \"main\" && $CI_COMMIT_TAG == null\n  script:\n    - docker build -t $TAG_LATEST -t $TAG_COMMIT .\n    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY\n    - docker push $TAG_LATEST\n    - docker push $TAG_COMMIT\n\n# Deploy to staging\nstaging:\n  stage: staging\n  image: alpine:latest\n  rules:\n    - if: $CI_COMMIT_BRANCH == \"main\" && $CI_COMMIT_TAG == null\n  script:\n    - chmod 400 $GITLAB_KEY\n    - apk add openssh-client\n    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY\n    - ssh -i $GITLAB_KEY -o StrictHostKeyChecking=no $USER@$STAGING_TARGET \"\n        docker pull $TAG_COMMIT &&\n        docker rm -f myapp || true &&\n        docker run -d -p 80:80 --name myapp $TAG_COMMIT\"\n  environment:\n    name: staging\n    url: http://$STAGING_TARGET\n\n# Create release\nrelease_job:\n  stage: release\n  image: registry.gitlab.com/gitlab-org/release-cli:latest\n  rules:\n    - if: $CI_COMMIT_TAG\n  script:\n    - |\n      DEPLOY_TIME=$(date '+%Y-%m-%d %H:%M:%S')\n      CHANGES=$(git log $(git describe --tags --abbrev=0 @^)..@ --pretty=format:\"- %s\")\n      cat > release_notes.md \u003C\u003C EOF\n      ## Deployment Info\n      - Deployed on: $DEPLOY_TIME\n      - Environment: Production\n      - Version: $CI_COMMIT_TAG\n\n      ## Changes\n      $CHANGES\n\n      ## Artifacts\n       - Container Image: \\`$CI_REGISTRY_IMAGE/main:$CI_COMMIT_TAG\\`\n      EOF\n  release:\n    name: 'Release $CI_COMMIT_TAG'\n    description: './release_notes.md'\n    tag_name: '$CI_COMMIT_TAG'\n    ref: '$CI_COMMIT_TAG'\n    assets:\n      links:\n        - name: 'Container Image'\n          url: '$CI_REGISTRY_IMAGE/main:$CI_COMMIT_TAG'\n          link_type: 'image'\n\n# Version the image with release tag\nversion_job:\n  stage: version\n  image: docker:latest\n  services:\n    - docker:dind\n  rules:\n    - if: $CI_COMMIT_TAG\n  script:\n    - docker pull $TAG_COMMIT\n    - docker tag $TAG_COMMIT $CI_REGISTRY_IMAGE/main:$CI_COMMIT_TAG\n    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY\n    - docker push $CI_REGISTRY_IMAGE/main:$CI_COMMIT_TAG\n\n# Deploy to production\nproduction:\n  stage: production\n  image: alpine:latest\n  rules:\n    - if: $CI_COMMIT_TAG\n  script:\n    - chmod 400 $GITLAB_KEY\n    - apk add openssh-client\n    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY\n    - ssh -i $GITLAB_KEY -o StrictHostKeyChecking=no $USER@$PRODUCTION_TARGET \"\n        docker pull $CI_REGISTRY_IMAGE/main:$CI_COMMIT_TAG &&\n        docker rm -f myapp || true &&\n        docker run -d -p 80:80 --name myapp $CI_REGISTRY_IMAGE/main:$CI_COMMIT_TAG\"\n  environment:\n    name: production\n    url: http://$PRODUCTION_TARGET\n```\n\nDiese komplette Pipeline:\n\n* veröffentlicht Images im Registry (Main-Branch)\n* stellt das Staging bereit (Main-Branch)\n* erstellt Releases (mit Tags)\n* bietet die Versionsverwaltung von Images mit Release-Tags \n* Stellt die Produktion bereit (für Tags)\n\nHauptvorteile:\n\n* Saubere, reproduzierbare, lokale Entwicklungs- und Testumgebung\n* Klarer Pfad zu Produktionsumgebungen mit Struktur, um Vertrauen in die Bereitstellung aufzubauen\n* Muster zur Wiederherstellung nach unerwarteten Fehlern usw.\n* Bereit, komplexere Bereitstellungsstrategien zu skalieren/zu übernehmen\n\n### Best Practices\n\nWährend der gesamten Implementierung solltest du diese Grundsätze einhalten:\n\n* Dokumentiere alles, von der variablen Nutzung bis hin zu Bereitstellungsverfahren\n* Nutze die integrierten Funktionen von GitLab (Umgebungen, Releases, Registry)\n* Implementiere ordnungsgemäße Zugriffskontrollen und Sicherheitsmaßnahmen\n* Sorge für Ausfälle mit robusten Rollback-Verfahren vor\n* Halte deine Pipeline-Konfigurationen SAUBER (wiederhole dich nicht)\n\n> **12x kürzere Bereitstellungszeit: Dank GitLabs vollständiger Integration lebt Hilti Effizienz**. GitLab bringt vollständige Transparenz, eine umfassende Codeverwaltung und umfangreiche Sicherheitsscans mit, um Hilti neue Softwarefähigkeiten zu ermöglichen. Erfahre, wie Hilti seine Softwareentwicklung revolutioniert hat. **[Erfolgsstory lesen](https://about.gitlab.com/de-de/customers/hilti/)**\n\n## Skaliere deine Bereitstellungsstrategie\n\nWie geht es weiter? Hier sind einige Aspekte, die du berücksichtigen solltest, wenn deine kontinuierliche Bereitstellungsstrategie ausgereift ist.\n\n### Erweiterte Sicherheitsmaßnahmen\n\nErhöhe die Sicherheit durch:\n\n* Geschützte Umgebungen mit eingeschränktem Zugang\n* Erforderliche Genehmigungen für Produktionseinsätze\n* Integriertes Sicherheitsscannen\n* Automatisierte Schwachstellenbewertungen\n* Branch-Schutzregeln für einsatzbedingte Änderungen\n\n### Progressive Bereitstellungsstrategien\n\nImplementiere erweiterte Bereitstellungsstrategien:\n\n* Feature-Flags für kontrollierte Rollouts\n* Canary-Bereitstellungen zur Risikominderung\n* Blaugrüne Bereitstellungsstrategien\n* A/B-Testfähigkeiten\n* Dynamisches Umgebungsmanagement\n\n### Überwachung und Optimierung\n\nEtabliere robuste Überwachungspraktiken:\n\n* Verfolge Bereitstellungsmetriken nach\n* Richte eine Leistungsüberwachung ein\n* Konfiguriere Bereitstellungswarnungen\n* Richte Bereitstellungs-SLOs ein\n* Regelmäßige Pipeline-Optimierung\n\n## Warum GitLab\n\nDurch die kontinuierlichen Bereitstellungsfunktionen ist GitLab eine herausragende Wahl für moderne Bereitstellungsworkflows. Die Plattform zeichnet sich dadurch aus, dass sie den Weg vom Code bis zur Produktion optimiert und eine integrierte Container-Registrierung, ein Umgebungsmanagement und eine Nachverfolgung der Bereitstellung innerhalb einer einzigen Benutzeroberfläche bietet. Die umgebungsspezifischen Variablen von GitLab, die Approval-Gates für die Bereitstellung und die Rollback-Funktionen bieten die Sicherheit und Kontrolle, die für Produktionsbereitstellungen erforderlich sind, während Funktionen wie Review-Apps und Feature-Flags progressive Bereitstellungsansätze ermöglichen. Als Teil der kompletten DevSecOps-Plattform von GitLab lassen sich diese CD-Funktionen nahtlos in deinen gesamten Software-Lebenszyklus integrieren.\n\n## Noch heute starten\n\nDer Weg zur kontinuierlichen Bereitstellung ist eine Evolution, keine Revolution. Beginne mit den Grundlagen, baue eine solide Grundlage auf und integriere nach und nach erweiterte Funktionen, wenn die Anforderungen deines Teams wachsen. GitLab bietet die Tools und die Flexibilität, um dich in jeder Phase dieser Reise zu unterstützen, von deiner ersten automatisierten Bereitstellung bis hin zu komplexen Bereitstellungspipelines für mehrere Umgebungen.\n\n> Melde dich für eine [kostenlose Testversion von GitLab Ultimate](https://about.gitlab.com/free-trial/devsecops/) an, um noch heute mit der kontinuierlichen Bereitstellung zu beginnen.",[19,20],"Benjamin Skierlak","James Wormwell","2025-05-14","2025-01-28","Vom Code bis zur Produktion: Ein Leitfaden für die kontinuierliche Bereitstellung mit GitLab",[25,26,27,10,28],"CD","CI/CD","features","tutorial","Erfahre, wie du mit dem Aufbau einer robusten Pipeline für die kontinuierliche Bereitstellung in GitLab beginnen kannst. In diesem Artikel findest du Schritt-für-Schritt-Anleitungen, praktische Beispiele und Best Practices.","yml",{},true,"/de-de/blog/from-code-to-production-a-guide-to-continuous-deployment-with-gitlab",{"ogTitle":35,"ogImage":16,"ogDescription":29,"ogSiteName":36,"noIndex":13,"ogType":37,"ogUrl":38,"title":35,"canonicalUrls":38,"description":29},"Leitfaden: Kontinuierliche Bereitstellung mit GitLab","https://about.gitlab.com","article","https://about.gitlab.com/blog/from-code-to-production-a-guide-to-continuous-deployment-with-gitlab","de-de/blog/from-code-to-production-a-guide-to-continuous-deployment-with-gitlab",[41,42,27,10,28],"cd","cicd","B8_Efp8_WUwcmVhSO7-udI-JhTylW1uAs3mFNQV9Bfs",{"data":45},{"logo":46,"freeTrial":51,"sales":56,"login":61,"items":66,"search":374,"minimal":409,"duo":427,"pricingDeployment":436},{"config":47},{"href":48,"dataGaName":49,"dataGaLocation":50},"/de-de/","gitlab logo","header",{"text":52,"config":53},"Kostenlose Testversion anfordern",{"href":54,"dataGaName":55,"dataGaLocation":50},"https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com/de-de&glm_content=default-saas-trial/","free trial",{"text":57,"config":58},"Vertrieb kontaktieren",{"href":59,"dataGaName":60,"dataGaLocation":50},"/de-de/sales/","sales",{"text":62,"config":63},"Anmelden",{"href":64,"dataGaName":65,"dataGaLocation":50},"https://gitlab.com/users/sign_in/","sign in",[67,94,189,194,295,355],{"text":68,"config":69,"cards":71},"Plattform",{"dataNavLevelOne":70},"platform",[72,78,86],{"title":68,"description":73,"link":74},"Die intelligente Orchestrierungsplattform für DevSecOps",{"text":75,"config":76},"Erkunde unsere Plattform",{"href":77,"dataGaName":70,"dataGaLocation":50},"/de-de/platform/",{"title":79,"description":80,"link":81},"GitLab Duo Agent Platform","Agentische KI für den gesamten Softwareentwicklungszyklus",{"text":82,"config":83},"Lerne GitLab Duo kennen",{"href":84,"dataGaName":85,"dataGaLocation":50},"/de-de/gitlab-duo-agent-platform/","gitlab duo agent platform",{"title":87,"description":88,"link":89},"Gründe, die für GitLab sprechen","Erfahre, warum Unternehmen auf GitLab setzen",{"text":90,"config":91},"Mehr erfahren",{"href":92,"dataGaName":93,"dataGaLocation":50},"/de-de/why-gitlab/","why gitlab",{"text":95,"left":32,"config":96,"link":98,"lists":102,"footer":171},"Produkt",{"dataNavLevelOne":97},"solutions",{"text":99,"config":100},"Alle Lösungen anzeigen",{"href":101,"dataGaName":97,"dataGaLocation":50},"/de-de/solutions/",[103,127,149],{"title":104,"description":105,"link":106,"items":111},"Automatisierung","CI/CD und Automatisierung zur Beschleunigung der Bereitstellung",{"config":107},{"icon":108,"href":109,"dataGaName":110,"dataGaLocation":50},"AutomatedCodeAlt","/de-de/solutions/delivery-automation/","automated software delivery",[112,115,118,123],{"text":26,"config":113},{"href":114,"dataGaLocation":50,"dataGaName":26},"/de-de/solutions/continuous-integration/",{"text":79,"config":116},{"href":84,"dataGaLocation":50,"dataGaName":117},"gitlab duo agent platform - product menu",{"text":119,"config":120},"Quellcodeverwaltung",{"href":121,"dataGaLocation":50,"dataGaName":122},"/de-de/solutions/source-code-management/","Source Code Management",{"text":124,"config":125},"Automatisierte Softwarebereitstellung",{"href":109,"dataGaLocation":50,"dataGaName":126},"Automated software delivery",{"title":128,"description":129,"link":130,"items":135},"Sicherheit","Entwickle schneller, ohne die Sicherheit zu gefährden",{"config":131},{"href":132,"dataGaName":133,"dataGaLocation":50,"icon":134},"/de-de/solutions/application-security-testing/","security and compliance","ShieldCheckLight",[136,140,145],{"text":137,"config":138},"Application Security Testing",{"href":132,"dataGaName":139,"dataGaLocation":50},"Application security testing",{"text":141,"config":142},"Schutz der Software-Lieferkette",{"href":143,"dataGaLocation":50,"dataGaName":144},"/de-de/solutions/supply-chain/","Software supply chain security",{"text":146,"config":147},"Software Compliance",{"href":148,"dataGaName":146,"dataGaLocation":50},"/de-de/solutions/software-compliance/",{"title":150,"link":151,"items":156},"Bewertung",{"config":152},{"icon":153,"href":154,"dataGaName":155,"dataGaLocation":50},"DigitalTransformation","/de-de/solutions/visibility-measurement/","visibility and measurement",[157,161,166],{"text":158,"config":159},"Sichtbarkeit und Bewertung",{"href":154,"dataGaLocation":50,"dataGaName":160},"Visibility and Measurement",{"text":162,"config":163},"Wertstrommanagement",{"href":164,"dataGaLocation":50,"dataGaName":165},"/de-de/solutions/value-stream-management/","Value Stream Management",{"text":167,"config":168},"Analysen und Einblicke",{"href":169,"dataGaLocation":50,"dataGaName":170},"/de-de/solutions/analytics-and-insights/","Analytics and insights",{"title":172,"items":173},"GitLab für",[174,179,184],{"text":175,"config":176},"Enterprise",{"href":177,"dataGaLocation":50,"dataGaName":178},"/de-de/enterprise/","enterprise",{"text":180,"config":181},"Kleinunternehmen",{"href":182,"dataGaLocation":50,"dataGaName":183},"/de-de/small-business/","small business",{"text":185,"config":186},"den öffentlichen Sektor",{"href":187,"dataGaLocation":50,"dataGaName":188},"/de-de/solutions/public-sector/","public sector",{"text":190,"config":191},"Preise",{"href":192,"dataGaName":193,"dataGaLocation":50,"dataNavLevelOne":193},"/de-de/pricing/","pricing",{"text":195,"config":196,"link":198,"lists":202,"feature":282},"Ressourcen",{"dataNavLevelOne":197},"resources",{"text":199,"config":200},"Alle Ressourcen anzeigen",{"href":201,"dataGaName":197,"dataGaLocation":50},"/de-de/resources/",[203,236,254],{"title":204,"items":205},"Erste Schritte",[206,211,216,221,226,231],{"text":207,"config":208},"Installieren",{"href":209,"dataGaName":210,"dataGaLocation":50},"/de-de/install/","install",{"text":212,"config":213},"Kurzanleitungen",{"href":214,"dataGaName":215,"dataGaLocation":50},"/de-de/get-started/","quick setup checklists",{"text":217,"config":218},"Lernen",{"href":219,"dataGaLocation":50,"dataGaName":220},"https://university.gitlab.com/","learn",{"text":222,"config":223},"Produktdokumentation",{"href":224,"dataGaName":225,"dataGaLocation":50},"https://docs.gitlab.com/","product documentation",{"text":227,"config":228},"Best-Practice-Videos",{"href":229,"dataGaName":230,"dataGaLocation":50},"/de-de/getting-started-videos/","best practice videos",{"text":232,"config":233},"Integrationen",{"href":234,"dataGaName":235,"dataGaLocation":50},"/de-de/integrations/","integrations",{"title":237,"items":238},"Entdecken",[239,244,249],{"text":240,"config":241},"Kundenerfolge",{"href":242,"dataGaName":243,"dataGaLocation":50},"/de-de/customers/","customer success stories",{"text":245,"config":246},"Blog",{"href":247,"dataGaName":248,"dataGaLocation":50},"/de-de/blog/","blog",{"text":250,"config":251},"Remote",{"href":252,"dataGaName":253,"dataGaLocation":50},"https://handbook.gitlab.com/handbook/company/culture/all-remote/","remote",{"title":255,"items":256},"Vernetzen",[257,262,267,272,277],{"text":258,"config":259},"GitLab-Services",{"href":260,"dataGaName":261,"dataGaLocation":50},"/de-de/services/","services",{"text":263,"config":264},"Community",{"href":265,"dataGaName":266,"dataGaLocation":50},"/community/","community",{"text":268,"config":269},"Forum",{"href":270,"dataGaName":271,"dataGaLocation":50},"https://forum.gitlab.com/","forum",{"text":273,"config":274},"Veranstaltungen",{"href":275,"dataGaName":276,"dataGaLocation":50},"/events/","events",{"text":278,"config":279},"Partner",{"href":280,"dataGaName":281,"dataGaLocation":50},"/de-de/partners/","partners",{"backgroundColor":283,"textColor":284,"text":285,"image":286,"link":290},"#2f2a6b","#fff","Perspektiven für die Softwareentwicklung der Zukunft",{"altText":287,"config":288},"the source promo card",{"src":289},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758208064/dzl0dbift9xdizyelkk4.svg",{"text":291,"config":292},"Lies die News",{"href":293,"dataGaName":294,"dataGaLocation":50},"/de-de/the-source/","the source",{"text":296,"config":297,"lists":299},"Unternehmen",{"dataNavLevelOne":298},"company",[300],{"items":301},[302,307,313,315,320,325,330,335,340,345,350],{"text":303,"config":304},"Über",{"href":305,"dataGaName":306,"dataGaLocation":50},"/de-de/company/","about",{"text":308,"config":309,"footerGa":312},"Karriere",{"href":310,"dataGaName":311,"dataGaLocation":50},"/jobs/","jobs",{"dataGaName":311},{"text":273,"config":314},{"href":275,"dataGaName":276,"dataGaLocation":50},{"text":316,"config":317},"Geschäftsführung",{"href":318,"dataGaName":319,"dataGaLocation":50},"/company/team/e-group/","leadership",{"text":321,"config":322},"Team",{"href":323,"dataGaName":324,"dataGaLocation":50},"/company/team/","team",{"text":326,"config":327},"Handbuch",{"href":328,"dataGaName":329,"dataGaLocation":50},"https://handbook.gitlab.com/","handbook",{"text":331,"config":332},"Investor Relations",{"href":333,"dataGaName":334,"dataGaLocation":50},"https://ir.gitlab.com/","investor relations",{"text":336,"config":337},"Trust Center",{"href":338,"dataGaName":339,"dataGaLocation":50},"/de-de/security/","trust center",{"text":341,"config":342},"AI Transparency Center",{"href":343,"dataGaName":344,"dataGaLocation":50},"/de-de/ai-transparency-center/","ai transparency center",{"text":346,"config":347},"Newsletter",{"href":348,"dataGaName":349,"dataGaLocation":50},"/company/contact/#contact-forms","newsletter",{"text":351,"config":352},"Presse",{"href":353,"dataGaName":354,"dataGaLocation":50},"/press/","press",{"text":356,"config":357,"lists":358},"Kontakt",{"dataNavLevelOne":298},[359],{"items":360},[361,364,369],{"text":57,"config":362},{"href":59,"dataGaName":363,"dataGaLocation":50},"talk to sales",{"text":365,"config":366},"Support-Portal",{"href":367,"dataGaName":368,"dataGaLocation":50},"https://support.gitlab.com","support portal",{"text":370,"config":371},"Kundenportal",{"href":372,"dataGaName":373,"dataGaLocation":50},"https://customers.gitlab.com/customers/sign_in/","customer portal",{"close":375,"login":376,"suggestions":383},"Schließen",{"text":377,"link":378},"Um Repositories und Projekte zu durchsuchen, melde dich an bei",{"text":379,"config":380},"gitlab.com",{"href":64,"dataGaName":381,"dataGaLocation":382},"search login","search",{"text":384,"default":385},"Vorschläge",[386,388,393,395,400,405],{"text":79,"config":387},{"href":84,"dataGaName":79,"dataGaLocation":382},{"text":389,"config":390},"Code Suggestions (KI)",{"href":391,"dataGaName":392,"dataGaLocation":382},"/de-de/solutions/code-suggestions/","Code Suggestions (AI)",{"text":26,"config":394},{"href":114,"dataGaName":26,"dataGaLocation":382},{"text":396,"config":397},"GitLab auf AWS",{"href":398,"dataGaName":399,"dataGaLocation":382},"/de-de/partners/technology-partners/aws/","GitLab on AWS",{"text":401,"config":402},"GitLab auf Google Cloud",{"href":403,"dataGaName":404,"dataGaLocation":382},"/de-de/partners/technology-partners/google-cloud-platform/","GitLab on Google Cloud",{"text":406,"config":407},"Warum GitLab?",{"href":92,"dataGaName":408,"dataGaLocation":382},"Why GitLab?",{"freeTrial":410,"mobileIcon":415,"desktopIcon":420,"secondaryButton":423},{"text":411,"config":412},"Kostenlos testen",{"href":413,"dataGaName":55,"dataGaLocation":414},"https://gitlab.com/-/trials/new/","nav",{"altText":416,"config":417},"GitLab-Symbol",{"src":418,"dataGaName":419,"dataGaLocation":414},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758203874/jypbw1jx72aexsoohd7x.svg","gitlab icon",{"altText":416,"config":421},{"src":422,"dataGaName":419,"dataGaLocation":414},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758203875/gs4c8p8opsgvflgkswz9.svg",{"text":204,"config":424},{"href":425,"dataGaName":426,"dataGaLocation":414},"https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com/de-de/get-started/","get started",{"freeTrial":428,"mobileIcon":432,"desktopIcon":434},{"text":429,"config":430},"Erfahre mehr über GitLab Duo",{"href":84,"dataGaName":431,"dataGaLocation":414},"gitlab duo",{"altText":416,"config":433},{"src":418,"dataGaName":419,"dataGaLocation":414},{"altText":416,"config":435},{"src":422,"dataGaName":419,"dataGaLocation":414},{"freeTrial":437,"mobileIcon":442,"desktopIcon":444},{"text":438,"config":439},"Zurück zur Preisübersicht",{"href":192,"dataGaName":440,"dataGaLocation":414,"icon":441},"back to pricing","GoBack",{"altText":416,"config":443},{"src":418,"dataGaName":419,"dataGaLocation":414},{"altText":416,"config":445},{"src":422,"dataGaName":419,"dataGaLocation":414},{"title":447,"button":448,"config":453},"Sieh dir an, wie agentische KI die Softwarebereitstellung transformiert",{"text":449,"config":450},"GitLab Transcend jetzt ansehen",{"href":451,"dataGaName":452,"dataGaLocation":50},"/de-de/events/transcend/virtual/","transcend event",{"layout":454,"icon":455,"disabled":32},"release","AiStar",{"data":457},{"text":458,"source":459,"edit":465,"contribute":470,"config":475,"items":480,"minimal":653},"Git ist eine Marke von Software Freedom Conservancy und unsere Verwendung von „GitLab“ erfolgt unter Lizenz.",{"text":460,"config":461},"Quelltext der Seite anzeigen",{"href":462,"dataGaName":463,"dataGaLocation":464},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/","page source","footer",{"text":466,"config":467},"Diese Seite bearbeiten",{"href":468,"dataGaName":469,"dataGaLocation":464},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/content/","web ide",{"text":471,"config":472},"Beteilige dich",{"href":473,"dataGaName":474,"dataGaLocation":464},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/CONTRIBUTING.md/","please contribute",{"twitter":476,"facebook":477,"youtube":478,"linkedin":479},"https://x.com/gitlab","https://www.facebook.com/gitlab","https://www.youtube.com/channel/UCnMGQ8QHMAnVIsI3xJrihhg","https://www.linkedin.com/company/gitlab-com",[481,504,559,586,620],{"title":68,"links":482,"subMenu":487},[483],{"text":484,"config":485},"DevSecOps-Plattform",{"href":77,"dataGaName":486,"dataGaLocation":464},"devsecops platform",[488],{"title":190,"links":489},[490,494,499],{"text":491,"config":492},"Tarife anzeigen",{"href":192,"dataGaName":493,"dataGaLocation":464},"view plans",{"text":495,"config":496},"Vorteile von Premium",{"href":497,"dataGaName":498,"dataGaLocation":464},"/de-de/pricing/premium/","why premium",{"text":500,"config":501},"Vorteile von Ultimate",{"href":502,"dataGaName":503,"dataGaLocation":464},"/de-de/pricing/ultimate/","why ultimate",{"title":505,"links":506},"Lösungen",[507,512,515,517,522,527,531,534,537,542,544,546,549,554],{"text":508,"config":509},"Digitale Transformation",{"href":510,"dataGaName":511,"dataGaLocation":464},"/de-de/topics/digital-transformation/","digital transformation",{"text":513,"config":514},"Sicherheit und Compliance",{"href":132,"dataGaName":139,"dataGaLocation":464},{"text":124,"config":516},{"href":109,"dataGaName":110,"dataGaLocation":464},{"text":518,"config":519},"Agile Entwicklung",{"href":520,"dataGaName":521,"dataGaLocation":464},"/de-de/solutions/agile-delivery/","agile delivery",{"text":523,"config":524},"Cloud-Transformation",{"href":525,"dataGaName":526,"dataGaLocation":464},"/de-de/topics/cloud-native/","cloud transformation",{"text":528,"config":529},"SCM",{"href":121,"dataGaName":530,"dataGaLocation":464},"source code management",{"text":26,"config":532},{"href":114,"dataGaName":533,"dataGaLocation":464},"continuous integration & delivery",{"text":162,"config":535},{"href":164,"dataGaName":536,"dataGaLocation":464},"value stream management",{"text":538,"config":539},"GitOps",{"href":540,"dataGaName":541,"dataGaLocation":464},"/de-de/solutions/gitops/","gitops",{"text":175,"config":543},{"href":177,"dataGaName":178,"dataGaLocation":464},{"text":180,"config":545},{"href":182,"dataGaName":183,"dataGaLocation":464},{"text":547,"config":548},"Öffentlicher Sektor",{"href":187,"dataGaName":188,"dataGaLocation":464},{"text":550,"config":551},"Bildungswesen",{"href":552,"dataGaName":553,"dataGaLocation":464},"/de-de/solutions/education/","education",{"text":555,"config":556},"Finanzdienstleistungen",{"href":557,"dataGaName":558,"dataGaLocation":464},"/de-de/solutions/finance/","financial services",{"title":195,"links":560},[561,563,565,567,570,572,574,576,578,580,582,584],{"text":207,"config":562},{"href":209,"dataGaName":210,"dataGaLocation":464},{"text":212,"config":564},{"href":214,"dataGaName":215,"dataGaLocation":464},{"text":217,"config":566},{"href":219,"dataGaName":220,"dataGaLocation":464},{"text":222,"config":568},{"href":224,"dataGaName":569,"dataGaLocation":464},"docs",{"text":245,"config":571},{"href":247,"dataGaName":248,"dataGaLocation":464},{"text":240,"config":573},{"href":242,"dataGaName":243,"dataGaLocation":464},{"text":250,"config":575},{"href":252,"dataGaName":253,"dataGaLocation":464},{"text":258,"config":577},{"href":260,"dataGaName":261,"dataGaLocation":464},{"text":263,"config":579},{"href":265,"dataGaName":266,"dataGaLocation":464},{"text":268,"config":581},{"href":270,"dataGaName":271,"dataGaLocation":464},{"text":273,"config":583},{"href":275,"dataGaName":276,"dataGaLocation":464},{"text":278,"config":585},{"href":280,"dataGaName":281,"dataGaLocation":464},{"title":296,"links":587},[588,590,592,594,596,598,600,604,609,611,613,615],{"text":303,"config":589},{"href":305,"dataGaName":298,"dataGaLocation":464},{"text":308,"config":591},{"href":310,"dataGaName":311,"dataGaLocation":464},{"text":316,"config":593},{"href":318,"dataGaName":319,"dataGaLocation":464},{"text":321,"config":595},{"href":323,"dataGaName":324,"dataGaLocation":464},{"text":326,"config":597},{"href":328,"dataGaName":329,"dataGaLocation":464},{"text":331,"config":599},{"href":333,"dataGaName":334,"dataGaLocation":464},{"text":601,"config":602},"Sustainability",{"href":603,"dataGaName":601,"dataGaLocation":464},"/sustainability/",{"text":605,"config":606},"Vielfalt, Inklusion und Zugehörigkeit",{"href":607,"dataGaName":608,"dataGaLocation":464},"/de-de/diversity-inclusion-belonging/","Diversity, inclusion and belonging",{"text":336,"config":610},{"href":338,"dataGaName":339,"dataGaLocation":464},{"text":346,"config":612},{"href":348,"dataGaName":349,"dataGaLocation":464},{"text":351,"config":614},{"href":353,"dataGaName":354,"dataGaLocation":464},{"text":616,"config":617},"Transparenzerklärung zu moderner Sklaverei",{"href":618,"dataGaName":619,"dataGaLocation":464},"https://handbook.gitlab.com/handbook/legal/modern-slavery-act-transparency-statement/","modern slavery transparency statement",{"title":621,"links":622},"Nimm Kontakt auf",[623,626,631,633,638,643,648],{"text":624,"config":625},"Sprich mit einem Experten/einer Expertin",{"href":59,"dataGaName":60,"dataGaLocation":464},{"text":627,"config":628},"Support",{"href":629,"dataGaName":630,"dataGaLocation":464},"https://support.gitlab.com/hc/en-us/articles/11626483177756-GitLab-Support","get help",{"text":370,"config":632},{"href":372,"dataGaName":373,"dataGaLocation":464},{"text":634,"config":635},"Status",{"href":636,"dataGaName":637,"dataGaLocation":464},"https://status.gitlab.com/","status",{"text":639,"config":640},"Nutzungsbedingungen",{"href":641,"dataGaName":642,"dataGaLocation":464},"/terms/","terms of use",{"text":644,"config":645},"Datenschutzerklärung",{"href":646,"dataGaName":647,"dataGaLocation":464},"/de-de/privacy/","privacy statement",{"text":649,"config":650},"Cookie-Einstellungen",{"dataGaName":651,"dataGaLocation":464,"id":652,"isOneTrustButton":32},"cookie preferences","ot-sdk-btn",{"items":654},[655,657,659],{"text":639,"config":656},{"href":641,"dataGaName":642,"dataGaLocation":464},{"text":644,"config":658},{"href":646,"dataGaName":647,"dataGaLocation":464},{"text":649,"config":660},{"dataGaName":651,"dataGaLocation":464,"id":652,"isOneTrustButton":32},[662,675],{"id":663,"title":19,"body":9,"config":664,"content":666,"description":9,"extension":30,"meta":670,"navigation":32,"path":671,"seo":672,"stem":673,"__hash__":674},"blogAuthors/en-us/blog/authors/benjamin-skierlak.yml",{"template":665},"BlogAuthor",{"name":19,"config":667},{"headshot":668,"ctfId":669},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1749659471/Blog/Author%20Headshots/Benjamin_Skierlak_headshot.png","Kzp6pkUjPORYYMoeLFPRf",{},"/en-us/blog/authors/benjamin-skierlak",{},"en-us/blog/authors/benjamin-skierlak","RbLU9KGFtah9Juo58JyxfHHYNIU4fyzzOUb5p7-fubo",{"id":676,"title":20,"body":9,"config":677,"content":678,"description":9,"extension":30,"meta":682,"navigation":32,"path":683,"seo":684,"stem":685,"__hash__":686},"blogAuthors/en-us/blog/authors/james-wormwell.yml",{"template":665},{"name":20,"config":679},{"headshot":680,"ctfId":681},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1749659474/Blog/Author%20Headshots/james_wormwell_headshot.png","CPPijHb0Op5C5aVcvsOEf",{},"/en-us/blog/authors/james-wormwell",{},"en-us/blog/authors/james-wormwell","n6G4XENUWxgqOdCgfG0ECu0Uqj7qOS9zr3Rl8ouF49M",[688,702,712],{"content":689,"config":700},{"title":690,"description":691,"authors":692,"heroImage":694,"date":695,"body":696,"category":10,"tags":697},"GitLab 18.11: Budgetkontrolle für GitLab Credits – Ausgabelimits und Nutzergrenzen","GitLab 18.11 führt Ausgabelimits und Nutzergrenzen für GitLab Credits ein – für planbare KI-Kosten und reibungslose Budgetgenehmigungen.",[693],"Bryan Rothwell","https://res.cloudinary.com/about-gitlab-com/image/upload/v1776259080/cakqnwo5ecp255lo8lzo.png","2026-04-17","Teams, die GitLab Duo Agent Platform mit On-Demand GitLab Credits nutzen, profitieren von automatisierten Workflows, die früher ganze Sprints beansprucht haben. Mit wachsender Nutzung steigt jedoch der Bedarf an Kostentransparenz – seitens Finance, Procurement und Platform-Teams, die belegen müssen, dass KI-Ausgaben begrenzt, planbar und steuerbar sind.\n\nEine wesentliche Hürde bei der breiteren KI-Einführung ist nicht Skepsis gegenüber der Technologie. Es ist die Unsicherheit bei der Kostenkontrolle. Ohne Ausgabeobergrenzen kann ein arbeitsintensiver Monat zu unerwarteten Kosten führen. Ohne Nutzerlimits können wenige Intensivnutzende das Credit-Kontingent des gesamten Teams aufbrauchen, bevor der Monat endet. Und ohne beides müssen Engineering-Verantwortliche, die Agentic AI weiter ausrollen wollen, aufwändigere Budgetgenehmigungsprozesse durchlaufen.\n\nSeit der [allgemeinen Verfügbarkeit](https://about.gitlab.com/blog/gitlab-duo-agent-platform-is-generally-available/) bietet GitLab Duo Agent Platform bereits Nutzungs-Governance und Transparenz. Mit GitLab 18.11 kommen Verbrauchssteuerung für [GitLab Credits](https://about.gitlab.com/blog/introducing-gitlab-credits/) hinzu: Ausgabeobergrenzen und Budgetlimits, die Organisationen noch mehr Kontrolle und Transparenz über den Credit-Verbrauch geben.\n\n\n## GitLab Credits steuern\n\nGitLab 18.11 führt drei Steuerungsebenen für den GitLab-Credits-Verbrauch ein: eine Ausgabenobergrenze auf Abonnementebene, Nutzerlimits auf individueller Ebene sowie Einblick in den Status und die Durchsetzung beider Limits.\n\n\n### Ausgabenobergrenze auf Abonnementebene\n\nBilling Account Manager können ab sofort eine monatliche Höchstgrenze für den Verbrauch von On-Demand GitLab Credits des gesamten Abonnements festlegen.\n\nFunktionsweise:\n\n* **Limit festlegen** im `Customers Portal` unter den GitLab-Credits-Einstellungen des Abonnements.\n* **Ausgaben automatisch begrenzen.** Erreicht der On-Demand-Verbrauch die Obergrenze, wird der DAP-Zugriff für alle Nutzenden des Abonnements pausiert – bis die nächste monatliche Periode beginnt.\n* **Anpassungen jederzeit möglich.** Das Limit lässt sich innerhalb des Monats anheben oder deaktivieren, um den Zugriff wiederherzustellen.\n\nDas Limit wird monatlich zurückgesetzt; die konfigurierte Grenze gilt so lange, bis sie geändert wird. Da Nutzungsdaten in Intervallen synchronisiert werden – nicht in Echtzeit –, kann nach Erreichen der Obergrenze eine geringe Mehrmenge anfallen, bevor die Durchsetzung greift. Details dazu finden sich in der [GitLab-Credits-Dokumentation](https://docs.gitlab.com/subscriptions/gitlab_credits/).\n\n\n### Nutzerlimits auf individueller Ebene\n\nNicht alle Nutzenden verbrauchen Credits im gleichen Tempo – das ist erwartbar. Problematisch wird es, wenn ein oder zwei Intensivnutzende einen unverhältnismäßig großen Anteil des Kontingents beanspruchen und der Rest des Teams vor Monatsende keinen Zugriff mehr hat.\n\nIndividuelle Nutzerlimits verhindern, dass einzelne Nutzende mehr als ihren fairen Anteil verbrauchen:\n\n* **Einheitliches Nutzerlimit.** Ein gleiches Credit-Limit für alle Nutzenden des Abonnements lässt sich über die GitLab GraphQL API setzen. Anders als die Abonnementobergrenze gilt dieses Limit für den Gesamtverbrauch einer Person über alle Credit-Quellen hinweg.\n* **Individuelle Ausnahmen.** Für differenzierte Limits können über die GraphQL API individuelle Credit-Obergrenzen für bestimmte Nutzende gesetzt werden. So lässt sich beispielsweise Staff Engineers ein höheres Kontingent einräumen, während für das breitere Team ein Standardlimit gilt.\n* **Individuelle Durchsetzung.** Erreicht eine Person ihr Limit, behält sie vollen Zugriff auf GitLab. Lediglich die Duo-Agent-Platform-Nutzung via Credits wird bis zum nächsten Abrechnungszeitraum pausiert. Alle anderen arbeiten unterbrechungsfrei weiter – bis sie ihr eigenes Limit oder die Abonnementobergrenze erreichen, je nachdem, was zuerst eintritt.\n\n\n### Sichtbarkeit und Benachrichtigungen\n\nWird die Abonnementobergrenze erreicht, sendet GitLab eine E-Mail-Benachrichtigung an Billing Account Manager, damit diese reagieren können: das Limit anheben, die nächste Periode abwarten oder Credits umverteilen.\n\nInnerhalb von GitLab können Group Owner (GitLab.com) und Instanz-Administratoren (Self-Managed) einsehen, welche Nutzenden aufgrund ihres individuellen Limits gesperrt wurden, und den Zugriff durch Anpassung der Grenze über die GraphQL API wiederherstellen.\n\n\n## Warum Budgetlimits die KI-Skalierung ermöglichen\n\nKlare Steuerungsmechanismen sind entscheidend, wenn Organisationen ihre KI-Nutzung ausweiten. Drei Gründe:\n\n\n### Planbare KI-Budgets\n\nVerbrauchssteuerung für GitLab Duo Agent Platform macht KI-Ausgaben zu einer planbaren, begrenzten Budgetposition auf Basis von On-Demand GitLab Credits. Das erleichtert sowohl die Budgetfreigabe durch Finance als auch die Planung der quartalsweisen Ausgaben.\n\n\n### Governance und interne Kostenverrechnung\n\nGroße Organisationen müssen KI-Ausgaben häufig internen Budgets, Kostenstellen oder Abteilungsrichtlinien zuordnen. Individuelle Nutzerlimits geben Platform-Teams einen unkomplizierten Mechanismus, Credits fair zuzuweisen und den Verbrauch auf Personenebene nachzuverfolgen. Die API-Konfiguration macht dies auch im Enterprise-Maßstab handhabbar. In Kombination mit den personenbezogenen Verbrauchsdaten aus dem GitLab-Credits-Dashboard lassen sich Verbrauchsmuster nachverfolgen – als Grundlage für interne Kostenverrechnungs- oder Budgetzuweisungsprozesse.\n\n\n### Sicherheit beim Skalieren\n\nViele Kunden starten GitLab Duo Agent Platform zunächst mit einer kleinen Pilotgruppe. Verbrauchssteuerung beseitigt die Risiken, die mit einer Ausweitung auf die gesamte Organisation verbunden sind. Duo Agent Platform lässt sich auf Hunderte oder Tausende von Entwicklungsteams ausrollen – mit der Gewissheit, dass eine harte Ausgabenobergrenze das Budget schützt. Wächst die Nutzung schneller als erwartet, greift das Limit – nicht eine unerwartete Rechnung.\n\n\n## Sitzplatzbasiert vs. verbrauchsbasiert\n\nViele KI-Coding-Tools setzen auf ein sitzplatzbasiertes Preismodell. Eine feste Anzahl von Lizenzen wird zu einem einheitlichen Preis pro Nutzenden erworben. Einfach, aber unflexibel: Der Preis ist derselbe, unabhängig davon, ob jemand das Tool zehnmal täglich nutzt oder gar nicht. Wenn Anbieter zudem Premium-Modelle und verbrauchsabhängige Zusatzkosten auf die Lizenzgebühr aufschlagen, erodiert die Kostentransparenz, die das Lizenzmodell ursprünglich versprochen hat.\n\nGitLab verfolgt einen anderen Ansatz: verbrauchsbasierte Abrechnung mit harten Limits und einem zentralen Governance-Dashboard. Das verbindet die Flexibilität, nur für tatsächliche Nutzung zu zahlen, mit der Budgetplanbarkeit durchgesetzter Ausgabengrenzen.\n\n\n## Anwendungsbeispiele\n\n\n**Beispiel 1: Mittelgroßes SaaS-Unternehmen mit 200 Entwicklungspersonen.** Die Organisation setzt eine Abonnementobergrenze in Höhe des erwarteten On-Demand-Verbrauchs. Die VP of Engineering kann Finance gegenüber zuverlässig zusichern, dass die Duo-Agent-Platform-Ausgaben den genehmigten Betrag nicht überschreiten werden – auch während des Onboardings neuer Teams. Nähert sich die Grenze in der Monatsmitte, erhält der Billing Account Manager eine Benachrichtigung und kann entscheiden: Limit anheben oder die nächste Periode abwarten.\n\n**Beispiel 2: Globales Finanzdienstleistungsunternehmen mit 2.000 Entwicklungspersonen.** Das Unternehmen setzt individuelle Nutzerlimits, um einen fairen Zugang sicherzustellen. Staff Engineers, die an komplexen Refactoring-Projekten arbeiten, erhalten über die API ein höheres individuelles Kontingent; die meisten Entwicklungsteams erhalten ein Standard-Pauschalimit. Einzelne Nutzende können das Gesamtkontingent nicht erschöpfen. Das Platform-Team nutzt die personenbezogenen Verbrauchsdaten im GitLab-Credits-Dashboard für die Nachverfolgung von Verbrauchsmustern und die quartalsweise Budgetplanung.\n\n\n## Erste Schritte\n\nVerbrauchssteuerung ist für GitLab.com- und Self-Managed-Kunden ab GitLab 18.11 verfügbar. Die Konfiguration erfolgt je nach Geltungsbereich und Rolle an unterschiedlichen Stellen.\n\n**Abonnementobergrenze**\n\nBilling Account Manager setzen die Abonnementobergrenze im Customers Portal:\n\n1. Im `Customers Portal` anmelden.\n2. Auf der Abonnementkarte zu den **GitLab Credits**-Einstellungen navigieren.\n3. Die monatliche On-Demand-Credits-Obergrenze aktivieren und den gewünschten Wert eingeben.\n\n**Einheitliches Nutzerlimit**\n\nDas einheitliche Nutzerlimit wird über die GitLab GraphQL API durch Namespace Owner (GitLab.com) oder Instanz-Administratoren (Self-Managed) gesetzt. Details zu verfügbaren Konfigurationsoberflächen finden sich in der [GitLab-Credits-Dokumentation](https://docs.gitlab.com/subscriptions/gitlab_credits/).\n\n**Individuelle Ausnahmen**\n\nFür differenzierte Limits können Namespace Owner (GitLab.com) und Instanz-Administratoren (Self-Managed) individuelle Obergrenzen programmatisch setzen – geeignet für Automatisierungs- und Infrastructure-as-Code-Workflows.\n\n**Verbrauch und Status überwachen**\n\n* **Customers Portal:** Detaillierter Verbrauch und Limitstatus einsehbar.\n* **GitLab.com:** Group Owner können gesperrte Nutzende unter **Einstellungen > GitLab Credits** einsehen.\n* **Self-Managed:** Instanz-Administratoren können Limitstatus und gesperrte Nutzende unter **Admin > GitLab Credits** einsehen.\n\n\n## GitLab Duo Agent Platform – bereit für die Skalierung\n\nVerbrauchssteuerung ist ab sofort in GitLab 18.11 verfügbar. Ausgabelimits setzen, Duo Agent Platform auf weitere Teams ausrollen – und die KI-Ausgaben dabei vollständig im Griff behalten.\n\n> [Mehr über GitLab Credits und Verbrauchssteuerung erfahren](https://docs.gitlab.com/subscriptions/gitlab_credits/).\n",[10,698,699],"AI/ML","news",{"featured":13,"template":14,"slug":701},"gitlab-18-11-budget-guardrails-for-gitlab-credits",{"content":703,"config":710},{"title":704,"description":705,"authors":706,"heroImage":694,"date":695,"body":708,"category":10,"tags":709},"GitLab 18.11: KI-Agenten CI Expert und Data Analyst schließen Entwicklungslücken","Mit GitLab 18.11 stehen zwei neue Agenten bereit – CI Expert für automatisiertes Pipeline-Setup und Data Analyst für direkte SDLC-Datenabfragen.",[707],"Corinne Dent","KI generiert Code schneller, als die Systeme drum herum mithalten können. Mehr Code bedeutet mehr Merge Requests in der Warteschlange, mehr Pipelines, die konfiguriert werden müssen, mehr Fragen zur Delivery, für die niemand Zeit hat – und die meisten Tools, auf die Teams sich stützen, wurden nicht für dieses Tempo entwickelt.\n\nIn GitLab 18.11 adressieren zwei neue Foundational Agents der Duo Agent Platform konkrete Lücken im Entwicklungszyklus, die KI bislang weitgehend unberührt gelassen hat:\n\n* **CI Expert Agent (jetzt in Beta)** schließt die Lücke zwischen dem Schreiben von Code und einer laufenden Pipeline\n* **Data Analyst Agent (jetzt allgemein verfügbar)** schließt die Lücke zwischen dem Ausliefern von Code und der Fähigkeit, grundlegende Fragen zur tatsächlichen Delivery zu beantworten\n\nDiese Problembereiche lassen sich nicht mit einem allgemeinen Assistenten lösen. Ein Tool außerhalb von GitLab kann eine YAML-Datei generieren oder eine Frage beantworten – es hat jedoch keine Kenntnis davon, wie Pipelines historisch performt haben, wo Fehler gehäuft auftreten oder wie die tatsächlichen MR-Durchlaufzeiten aussehen. Dieser Kontext liegt in GitLab. Diese Agenten auch.\n\n\n## Schnelles CI-Setup mit CI Expert Agent\n\nKI beschleunigt das Schreiben von Code erheblich. Den Code in eine laufende Pipeline zu bringen ist etwas, das die meisten Teams Tage oder Wochen später erledigen – wenn überhaupt. Das Blank-Page-Problem liegt nicht mehr im Editor. Es liegt jetzt in der `.gitlab-ci.yml`.\n\nEntwicklungsteams, die CI noch nie konfiguriert haben, wissen nicht, wie Language Detection in YAML aussieht, welche Test-Befehle verwendet werden sollten oder wie das Ergebnis vor dem Push validiert wird. Teams kopieren entweder eine Konfiguration aus einem früheren Projekt, die möglicherweise nicht passt, fügen Beispiele aus der Dokumentation zusammen oder warten auf die eine Person, die es schon einmal gemacht hat. Ist diese Person nicht verfügbar, wird CI zu etwas, das man \"später erledigt\". Aus \"später\" wird \"nie\".\n\nWenn CI dauerhaft ausbleibt, zeigen sich die Folgen im gesamten Entwicklungsprozess: Änderungen werden ohne automatisierte Absicherung ausgeliefert, Regressionen tauchen in der Produktion statt in der Pipeline auf, und Arbeit häuft sich in größeren, riskanteren Batches an. Teams gewöhnen sich mit der Zeit daran, ohne strukturierte Rückkopplung zu arbeiten – auf undokumentiertes Erfahrungswissen angewiesen statt auf einen reproduzierbaren Feedback-Mechanismus, der in jeden Commit integriert ist.\n\nCI Expert Agent, jetzt in Beta verfügbar, beseitigt diese Hürde systematisch. Der Agent analysiert das Repository, erkennt Sprache und Framework und schlägt eine funktionsfähige Build- und Test-Pipeline vor, die auf dem tatsächlichen Repository-Inhalt basiert – mit einer Erklärung jeder Entscheidung in verständlicher Sprache. Das Ziel: eine laufende Pipeline, ohne YAML manuell schreiben zu müssen.\n\nFunktionsumfang von CI Expert Agent:\n\n* Repository-bewusste Pipeline-Generierung erkennt Sprache, Framework und Test-Setup\n* Generiert valide, ausführbare Build- und Test-Konfigurationen\n* Geführter Erstkonfigurations-Ablauf mit verständlicher Erklärung jedes Schritts im Agentic Chat\n* Native GitLab-CI-Semantik ohne Konfigurations-Übersetzung\n\nDa der Agent innerhalb von GitLab läuft und das tatsächliche Pipeline-Verhalten über Zeit beobachtet, kann jede Verbesserung auf der Arbeitsweise der Teams aufbauen – nicht nur auf statischen Beispielen.\n\n\u003Ciframe src=\"https://player.vimeo.com/video/1183458036?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"CI/CD Expert Agent\">\u003C/iframe>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n\u003Cbr>\u003C/br>\n\nCI Expert Agent ist verfügbar auf GitLab.com, Self-Managed und Dedicated in den Editionen Free, Premium und Ultimate – mit aktivierter Duo Agent Platform.\n\n\n## SDLC-Daten in natürlicher Sprache abfragen mit Data Analyst Agent\n\nKI hat das Tempo der Code-Auslieferung erhöht. Grundlegende Fragen dazu, wie diese Arbeit verläuft, sind dadurch nicht einfacher zu beantworten – im Gegenteil.\n\nWie lange liegen MRs im Review? Welche Pipelines bremsen Teams aus? Werden Deployment-Ziele tatsächlich erreicht? Diese Fragen ließen sich früher mit einem Blick auf ein Dashboard beantworten. Mit mehr Code, mehr Teams und mehr Komplexität sind die Daten zwar vorhanden – sie liegen in GitLab – der Zugriff erfordert jedoch nach wie vor das Warten auf ein Analytics-Team, eine Dashboard-Anfrage oder die Einarbeitung in GLQL.\n\nData Analyst Agent schließt diese Lücke. Eine Frage in natürlicher Sprache stellen – und eine sofortige Visualisierung im Agentic Chat erhalten. Keine Abfragesprache, keine Dashboard-Anfrage, kein Warten.\n\nDer Agent beantwortet beispielsweise folgende Fragen – je nach Rolle:\n\n* **Engineering Manager:** MR-Durchlaufzeiten, Durchsatz nach Projekt, wo Reviews stocken\n* **Entwicklungsteams:** Beitragsmuster, instabile Tests, die MRs blockieren, Pipeline-Geschwindigkeit\n* **DevOps- und Plattform-Teams:** Pipeline-Erfolgs- und Fehlerquoten, Runner-Auslastung, Deployment-Frequenz\n* **Engineering Leadership:** Deployment-Frequenz über Portfolios hinweg, Projektgesundheitsmetriken, Lead-Time-Vergleiche\n\nMit der allgemeinen Verfügbarkeit in GitLab 18.11 deckt der Agent MRs, Issues, Projekte, Pipelines und Jobs ab – vollständige SDLC-Abdeckung, erweitert gegenüber dem Beta-Umfang. Da Data Analyst Agent direkt auf vorhandene GitLab-Daten zugreift, ist der Kontext stets aktuell – ohne eine separate Datenpipeline pflegen oder ein Drittanbieter-Tool synchron halten zu müssen. Generierte GitLab Query Language-Abfragen lassen sich überall dort kopieren und verwenden, wo GitLab Flavored Markdown unterstützt wird; ein direkter Export zu Work Items und Dashboards ist in Planung.\n\n\u003Ciframe src=\"https://player.vimeo.com/video/1183094817?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"Data Analyst agent demo\">\u003C/iframe>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n\u003Cbr>\u003C/br>\n\nData Analyst Agent ist verfügbar auf GitLab.com, Self-Managed und Dedicated in den Editionen Free, Premium und Ultimate – mit aktivierter Duo Agent Platform.\n\n\n## Eine Plattform, verbundener Kontext\n\nBeide Agenten laufen innerhalb von GitLab und haben Zugriff auf den Code, die Pipelines, Issues und Merge Requests, die dort bereits vorhanden sind. Das unterscheidet plattformnative KI von einem externen Assistenten: Der Kontext ist stets aktuell und wächst mit der Nutzung. CI Expert Agent und Data Analyst Agent sind zwei konkrete Erweiterungen einer Plattform, auf der KI den gesamten Entwicklungszyklus unterstützt – von der Pipeline-Konfiguration über die Auslieferung bis zur Nachverfolgung.\n\n> [GitLab Duo Agent Platform kostenlos testen](https://about.gitlab.com/gitlab-duo/) und diese KI-Agenten direkt im Entwicklungs-Workflow einsetzen.\n",[698,27,10],{"featured":32,"template":14,"slug":711},"ci-expert-and-data-analyst-ai-agents-target-development-gaps",{"content":713,"config":721},{"title":714,"description":715,"authors":716,"heroImage":694,"date":695,"body":718,"category":10,"tags":719},"GitLab 18.11: KI behebt SAST-Schwachstellen – automatisch und 'ready-to-merge'","GitLab 18.11 macht Agentic SAST Vulnerability Resolution allgemein verfügbar und behebt SAST-Schwachstellen per KI-Code-Fix automatisch.",[717],"Alisa Ho","KI generiert Code schneller, als Security-Teams ihn prüfen können. Was früher ein überschaubarer Rückstand an SAST-Befunden (Static Application Security Testing) war, wächst heute mit jedem KI-assistierten Commit weiter an. Laut [GitLab DevSecOps Report 2025](https://about.gitlab.com/resources/developer-survey/) verbringen Entwicklungsteams bereits 11 Stunden pro Monat damit, Schwachstellen nach dem Release zu beheben – also Probleme zu korrigieren, die bereits in der Produktion ausnutzbar sind, statt neue Funktionen zu liefern. Mehr manuelle Remediierung löst dieses Problem grundsätzlich nicht. [Agentic SAST Vulnerability Resolution](https://docs.gitlab.com/user/application_security/vulnerabilities/agentic_vulnerability_resolution/) innerhalb der GitLab Duo Agent Platform ist für genau dieses Problem entwickelt worden.\n\nMit der allgemeinen Verfügbarkeit in GitLab 18.11 generiert Agentic SAST Vulnerability Resolution automatisch zusammenführungsbereite Code-Fixes zur Behebung von SAST-Schwachstellen:\n\n* Entwicklungsteams bleiben im Arbeitsfluss\n* Schwachstellen werden behoben, bevor sie die Produktion erreichen\n* AppSec-Teams verbringen weniger Zeit mit Triage und der Nachverfolgung offener Findings\n\nGitLab 18.11 liefert darüber hinaus schnelleres SAST-Scanning, evidenzbasierte Priorisierung und klar abgegrenzte Governance-Kontrollen.\n\n\n## Auto-Remediierung ohne Unterbrechung des Arbeitsflusses\n\nWenn KI Code in großem Umfang generiert, verändert sich die Ausgangslage grundlegend. Ein Security-Rückstand, der früher linear wuchs, nimmt heute mit jedem modellgestützten Commit weiter zu. Mehr manuelle Kontextwechsel von Entwicklungsteams zu fordern löst dieses Problem nicht – die Mengen sind schlicht zu groß.\n\nAgentic SAST Vulnerability Resolution verändert die Dynamik dieses Zyklus. Sobald ein SAST-Scan abgeschlossen ist, starten die Findings automatisch den [Erkennungsfluss für Fehlalarme (SAST False Positive Detection)](https://docs.gitlab.com/user/application_security/vulnerabilities/false_positive_detection/). Bestätigte True Positives werden direkt in den Agentic SAST Vulnerability Resolution Flow übergeben, wo GitLab Duo Agent Platform:\n\n* die Schwachstelle im Kontext analysiert\n* einen Fix erstellt, der die Grundursache behebt\n* den Fix durch automatisierte Tests validiert\n\nEntwicklungsteams erhalten einen zusammenführungsbereiten MR mit einem Confidence-Score, auf dessen Basis eine fundierte Entscheidung zur Behebung getroffen werden kann. Der Sprint bleibt auf Kurs, Schwachstellen werden behoben, bevor sie die Produktion erreichen.\n\nZum Thema Scan-Geschwindigkeit: GitLab 18.11 führt [inkrementelles Scanning für Advanced SAST](https://docs.gitlab.com/user/application_security/sast/gitlab_advanced_sast/#incremental-scanning) ein. Entwicklungsteams erhalten Schwachstellenergebnisse, ohne auf den Abschluss eines vollständigen Scans warten zu müssen – Pipelines bleiben durchgehend in Bewegung.\n\n\u003Ciframe src=\"https://player.vimeo.com/video/1183195999?badge=0&autopause=0&player_id=0&app_id=58479%2Fembed\" allow=\"autoplay; fullscreen; picture-in-picture\" allowfullscreen=\"\" frameborder=\"0\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\">\u003C/iframe>\n\n\n## Remediierung nach Geschäftsrisiko – nicht nach Score\n\nEine automatisierte Remediierungspipeline funktioniert nur so gut wie das Signal, das sie antreibt. Wenn Schwachstellenscores die tatsächliche Ausnutzbarkeit nicht widerspiegeln, verlieren Entwicklungsteams das Vertrauen in das Signal – und beginnen, es zu ignorieren.\n\nGitLab 18.11 adressiert dieses Problem auf vier Ebenen. Erstens sind [Schwachstellenscores](https://docs.gitlab.com/user/application_security/vulnerabilities/severities/#critical-severity) jetzt im Common Vulnerability Scoring System (CVSS) 4.0 verankert – dem aktuellen Industriestandard mit differenzierteren Metriken zur Erfassung realer Ausnutzbarkeit. Der Score, den Entwicklungsteams in GitLab sehen, entspricht damit dem Stand der Technik für die Bewertung realer Risiken.\n\nDarüber hinaus können AppSec-Teams [richtlinienbasierte Regeln](https://docs.gitlab.com/user/application_security/policies/vulnerability_management_policy/#severity-override-policies) definieren, die Schwachstellenscores automatisch anpassen – basierend auf Signalen wie Common Vulnerabilities and Exposures (CVE), Common Weakness Enumeration (CWE) sowie Dateipfad oder Verzeichnis. Einmal konfiguriert, greifen die Schweregrad-Anpassungen sofort, sodass Entwicklungsteams an einem Rückstand arbeiten, der das tatsächliche Geschäftsrisiko widerspiegelt und nicht den unbereinigten Scanner-Output.\n\nDie risikobasierte Steuerung endet nicht beim Rückstand. AppSec-Teams können jetzt [Freigaberichtlinien konfigurieren](https://docs.gitlab.com/user/application_security/policies/merge_request_approval_policies/#vulnerability_attributes-object), die Merges blockieren oder warnen – basierend auf dem Known Exploited Vulnerabilities (KEV)-Status oder dem Exploit Prediction Scoring System (EPSS)-Score. Wird ein Merge blockiert, wissen Entwicklungsteams, dass dies auf realen Ausnutzbarkeitsdaten beruht.\n\nDas [neue Top-CWEs-Diagramm im Security-Dashboard](https://docs.gitlab.com/user/application_security/security_dashboard/#top-10-cwes) gibt Teams abschließend Einblick, welche Schwachstellenklassen in ihren Projekten am häufigsten auftreten. Statt einzelnen Findings nachzujagen, lassen sich Muster erkennen, Grundursachen priorisieren und systemische Risiken adressieren, bevor sie sich auswachsen.\n\n\n## Stärkere Security-Kontrollen bei geringerem operativem Aufwand\n\nEine automatisierte Remediierungspipeline ist nur so gut wie die darunterliegende Scanner-Abdeckung. Inkonsistente Scanner-Konfigurationen führen zu unvollständigen Findings – und damit zu unvollständigen Fixes.\n\nGitLab 18.11 führt den [Security Manager](https://docs.gitlab.com/user/permissions/#default-roles) ein – eine neue Standardrolle, die speziell für Security-Professionals entwickelt wurde. Mit dieser Rolle lassen sich Security-Scanner durchsetzen, Security-Richtlinien definieren und konfigurieren, Triage- und Remediierungs-Workflows für Schwachstellen verwalten sowie Compliance-Frameworks und Audit-Streams pflegen – ohne Code-Änderungs- oder Deployment-Berechtigungen zu benötigen. Security-Teams erhalten genau die Zugriffsrechte, die ihre Aufgaben erfordern, und keine weiteren.\n\nFür AppSec-Teams vereinfachen [SAST-Konfigurationsprofile](https://docs.gitlab.com/user/application_security/configuration/security_configuration_profiles/) die konsistente Scanner-Abdeckung über mehrere Projekte und Gruppen hinweg erheblich. Das Scanning wird einmalig definiert und mit einer Aktion auf alle Projekte einer Gruppe angewendet. Das manuelle Pflegen von YAML-Policy-Dateien, die Abhängigkeit von Entwicklungsteams bei der Scanner-Konfiguration und das Prüfen einzelner Projekte auf Abdeckungslücken entfällt damit.\n\n\n## Automatisierte Vulnerability-Remediierung – jetzt starten\n\nGitLab 18.11 liefert den vollständigen Vulnerability-Workflow auf einer Plattform: KI, die Schwachstellen automatisch behebt, CVSS-4.0-basierte Priorisierung, die Vulnerability-Rauschen reduziert, und Governance-Kontrollen, die Security-Teams den erforderlichen Zugriff und vollständige Abdeckung ermöglichen.\n\n> [GitLab Ultimate kostenlos testen](https://about.gitlab.com/free-trial/?utm_medium=blog&utm_source=blog&utm_campaign=eg_global_x_inbound-request_security_en_) und erleben, wie GitLab Duo Agent Platform die automatisierte Remediierung direkt in den Entwicklungs-Workflow integriert.\n\n\nFür konkrete Compliance-Anforderungen empfiehlt sich die Rücksprache mit entsprechender Fachberatung.\n",[720,698,10,27],"security",{"featured":13,"template":14,"slug":722},"automate-remediation-with-ready-to-merge-ai-code-fixes",{"promotions":724},[725,739,751,762],{"id":726,"categories":727,"header":729,"text":730,"button":731,"image":736},"ai-modernization",[728],"ai-ml","Is AI achieving its promise at scale?","Quiz will take 5 minutes or less",{"text":732,"config":733},"Get your AI maturity score",{"href":734,"dataGaName":735,"dataGaLocation":248},"/assessments/ai-modernization-assessment/","modernization assessment",{"config":737},{"src":738},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1772138786/qix0m7kwnd8x2fh1zq49.png",{"id":740,"categories":741,"header":743,"text":730,"button":744,"image":748},"devops-modernization",[10,742],"devsecops","Are you just managing tools or shipping innovation?",{"text":745,"config":746},"Get your DevOps maturity score",{"href":747,"dataGaName":735,"dataGaLocation":248},"/assessments/devops-modernization-assessment/",{"config":749},{"src":750},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1772138785/eg818fmakweyuznttgid.png",{"id":752,"categories":753,"header":754,"text":730,"button":755,"image":759},"security-modernization",[720],"Are you trading speed for security?",{"text":756,"config":757},"Get your security maturity score",{"href":758,"dataGaName":735,"dataGaLocation":248},"/assessments/security-modernization-assessment/",{"config":760},{"src":761},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1772138786/p4pbqd9nnjejg5ds6mdk.png",{"id":763,"paths":764,"header":767,"text":768,"button":769,"image":774},"github-azure-migration",[765,766],"migration-from-azure-devops-to-gitlab","integrating-azure-devops-scm-and-gitlab","Is your team ready for GitHub's Azure move?","GitHub is already rebuilding around Azure. Find out what it means for you.",{"text":770,"config":771},"See how GitLab compares to GitHub",{"href":772,"dataGaName":773,"dataGaLocation":248},"/compare/gitlab-vs-github/github-azure-migration/","github azure migration",{"config":775},{"src":750},{"header":777,"blurb":778,"button":779,"secondaryButton":784},"Beginne noch heute, schneller zu entwickeln","Entdecke, was dein Team mit der intelligenten Orchestrierungsplattform für DevSecOps erreichen kann.\n",{"text":780,"config":781},"Kostenlosen Test starten",{"href":782,"dataGaName":55,"dataGaLocation":783},"https://gitlab.com/-/trial_registrations/new?glm_content=default-saas-trial&glm_source=about.gitlab.com/de-de/","feature",{"text":57,"config":785},{"href":59,"dataGaName":60,"dataGaLocation":783},1776707163956]