[{"data":1,"prerenderedAt":780},["ShallowReactive",2],{"/de-de/blog/from-code-to-production-a-guide-to-continuous-deployment-with-gitlab":3,"navigation-de-de":44,"banner-de-de":447,"footer-de-de":457,"blog-post-authors-de-de-Benjamin Skierlak|James Wormwell":662,"blog-related-posts-de-de-from-code-to-production-a-guide-to-continuous-deployment-with-gitlab":688,"assessment-promotions-de-de":730,"next-steps-de-de":770},{"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":437},{"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&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/compare/gitlab-vs-github/","get started",{"freeTrial":428,"mobileIcon":433,"desktopIcon":435},{"text":429,"config":430},"Erfahre mehr über GitLab Duo",{"href":431,"dataGaName":432,"dataGaLocation":414},"/de-de/gitlab-duo/","gitlab duo",{"altText":416,"config":434},{"src":418,"dataGaName":419,"dataGaLocation":414},{"altText":416,"config":436},{"src":422,"dataGaName":419,"dataGaLocation":414},{"freeTrial":438,"mobileIcon":443,"desktopIcon":445},{"text":439,"config":440},"Zurück zur Preisübersicht",{"href":192,"dataGaName":441,"dataGaLocation":414,"icon":442},"back to pricing","GoBack",{"altText":416,"config":444},{"src":418,"dataGaName":419,"dataGaLocation":414},{"altText":416,"config":446},{"src":422,"dataGaName":419,"dataGaLocation":414},{"title":448,"button":449,"config":454},"Sieh dir an, wie agentische KI die Softwarebereitstellung transformiert",{"text":450,"config":451},"GitLab Transcend jetzt ansehen",{"href":452,"dataGaName":453,"dataGaLocation":50},"/de-de/events/transcend/virtual/","transcend event",{"layout":455,"icon":456},"release","AiStar",{"data":458},{"text":459,"source":460,"edit":466,"contribute":471,"config":476,"items":481,"minimal":654},"Git ist eine Marke von Software Freedom Conservancy und unsere Verwendung von „GitLab“ erfolgt unter Lizenz.",{"text":461,"config":462},"Quelltext der Seite anzeigen",{"href":463,"dataGaName":464,"dataGaLocation":465},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/","page source","footer",{"text":467,"config":468},"Diese Seite bearbeiten",{"href":469,"dataGaName":470,"dataGaLocation":465},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/content/","web ide",{"text":472,"config":473},"Beteilige dich",{"href":474,"dataGaName":475,"dataGaLocation":465},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/CONTRIBUTING.md/","please contribute",{"twitter":477,"facebook":478,"youtube":479,"linkedin":480},"https://x.com/gitlab","https://www.facebook.com/gitlab","https://www.youtube.com/channel/UCnMGQ8QHMAnVIsI3xJrihhg","https://www.linkedin.com/company/gitlab-com",[482,505,560,587,621],{"title":68,"links":483,"subMenu":488},[484],{"text":485,"config":486},"DevSecOps-Plattform",{"href":77,"dataGaName":487,"dataGaLocation":465},"devsecops platform",[489],{"title":190,"links":490},[491,495,500],{"text":492,"config":493},"Tarife anzeigen",{"href":192,"dataGaName":494,"dataGaLocation":465},"view plans",{"text":496,"config":497},"Vorteile von Premium",{"href":498,"dataGaName":499,"dataGaLocation":465},"/de-de/pricing/premium/","why premium",{"text":501,"config":502},"Vorteile von Ultimate",{"href":503,"dataGaName":504,"dataGaLocation":465},"/de-de/pricing/ultimate/","why ultimate",{"title":506,"links":507},"Lösungen",[508,513,516,518,523,528,532,535,538,543,545,547,550,555],{"text":509,"config":510},"Digitale Transformation",{"href":511,"dataGaName":512,"dataGaLocation":465},"/de-de/topics/digital-transformation/","digital transformation",{"text":514,"config":515},"Sicherheit und Compliance",{"href":132,"dataGaName":139,"dataGaLocation":465},{"text":124,"config":517},{"href":109,"dataGaName":110,"dataGaLocation":465},{"text":519,"config":520},"Agile Entwicklung",{"href":521,"dataGaName":522,"dataGaLocation":465},"/de-de/solutions/agile-delivery/","agile delivery",{"text":524,"config":525},"Cloud-Transformation",{"href":526,"dataGaName":527,"dataGaLocation":465},"/de-de/topics/cloud-native/","cloud transformation",{"text":529,"config":530},"SCM",{"href":121,"dataGaName":531,"dataGaLocation":465},"source code management",{"text":26,"config":533},{"href":114,"dataGaName":534,"dataGaLocation":465},"continuous integration & delivery",{"text":162,"config":536},{"href":164,"dataGaName":537,"dataGaLocation":465},"value stream management",{"text":539,"config":540},"GitOps",{"href":541,"dataGaName":542,"dataGaLocation":465},"/de-de/solutions/gitops/","gitops",{"text":175,"config":544},{"href":177,"dataGaName":178,"dataGaLocation":465},{"text":180,"config":546},{"href":182,"dataGaName":183,"dataGaLocation":465},{"text":548,"config":549},"Öffentlicher Sektor",{"href":187,"dataGaName":188,"dataGaLocation":465},{"text":551,"config":552},"Bildungswesen",{"href":553,"dataGaName":554,"dataGaLocation":465},"/de-de/solutions/education/","education",{"text":556,"config":557},"Finanzdienstleistungen",{"href":558,"dataGaName":559,"dataGaLocation":465},"/de-de/solutions/finance/","financial services",{"title":195,"links":561},[562,564,566,568,571,573,575,577,579,581,583,585],{"text":207,"config":563},{"href":209,"dataGaName":210,"dataGaLocation":465},{"text":212,"config":565},{"href":214,"dataGaName":215,"dataGaLocation":465},{"text":217,"config":567},{"href":219,"dataGaName":220,"dataGaLocation":465},{"text":222,"config":569},{"href":224,"dataGaName":570,"dataGaLocation":465},"docs",{"text":245,"config":572},{"href":247,"dataGaName":248,"dataGaLocation":465},{"text":240,"config":574},{"href":242,"dataGaName":243,"dataGaLocation":465},{"text":250,"config":576},{"href":252,"dataGaName":253,"dataGaLocation":465},{"text":258,"config":578},{"href":260,"dataGaName":261,"dataGaLocation":465},{"text":263,"config":580},{"href":265,"dataGaName":266,"dataGaLocation":465},{"text":268,"config":582},{"href":270,"dataGaName":271,"dataGaLocation":465},{"text":273,"config":584},{"href":275,"dataGaName":276,"dataGaLocation":465},{"text":278,"config":586},{"href":280,"dataGaName":281,"dataGaLocation":465},{"title":296,"links":588},[589,591,593,595,597,599,601,605,610,612,614,616],{"text":303,"config":590},{"href":305,"dataGaName":298,"dataGaLocation":465},{"text":308,"config":592},{"href":310,"dataGaName":311,"dataGaLocation":465},{"text":316,"config":594},{"href":318,"dataGaName":319,"dataGaLocation":465},{"text":321,"config":596},{"href":323,"dataGaName":324,"dataGaLocation":465},{"text":326,"config":598},{"href":328,"dataGaName":329,"dataGaLocation":465},{"text":331,"config":600},{"href":333,"dataGaName":334,"dataGaLocation":465},{"text":602,"config":603},"Sustainability",{"href":604,"dataGaName":602,"dataGaLocation":465},"/sustainability/",{"text":606,"config":607},"Vielfalt, Inklusion und Zugehörigkeit",{"href":608,"dataGaName":609,"dataGaLocation":465},"/de-de/diversity-inclusion-belonging/","Diversity, inclusion and belonging",{"text":336,"config":611},{"href":338,"dataGaName":339,"dataGaLocation":465},{"text":346,"config":613},{"href":348,"dataGaName":349,"dataGaLocation":465},{"text":351,"config":615},{"href":353,"dataGaName":354,"dataGaLocation":465},{"text":617,"config":618},"Transparenzerklärung zu moderner Sklaverei",{"href":619,"dataGaName":620,"dataGaLocation":465},"https://handbook.gitlab.com/handbook/legal/modern-slavery-act-transparency-statement/","modern slavery transparency statement",{"title":622,"links":623},"Nimm Kontakt auf",[624,627,632,634,639,644,649],{"text":625,"config":626},"Sprich mit einem Experten/einer Expertin",{"href":59,"dataGaName":60,"dataGaLocation":465},{"text":628,"config":629},"Support",{"href":630,"dataGaName":631,"dataGaLocation":465},"/support/","get help",{"text":370,"config":633},{"href":372,"dataGaName":373,"dataGaLocation":465},{"text":635,"config":636},"Status",{"href":637,"dataGaName":638,"dataGaLocation":465},"https://status.gitlab.com/","status",{"text":640,"config":641},"Nutzungsbedingungen",{"href":642,"dataGaName":643,"dataGaLocation":465},"/terms/","terms of use",{"text":645,"config":646},"Datenschutzerklärung",{"href":647,"dataGaName":648,"dataGaLocation":465},"/de-de/privacy/","privacy statement",{"text":650,"config":651},"Cookie-Einstellungen",{"dataGaName":652,"dataGaLocation":465,"id":653,"isOneTrustButton":32},"cookie preferences","ot-sdk-btn",{"items":655},[656,658,660],{"text":640,"config":657},{"href":642,"dataGaName":643,"dataGaLocation":465},{"text":645,"config":659},{"href":647,"dataGaName":648,"dataGaLocation":465},{"text":650,"config":661},{"dataGaName":652,"dataGaLocation":465,"id":653,"isOneTrustButton":32},[663,676],{"id":664,"title":19,"body":9,"config":665,"content":667,"description":9,"extension":30,"meta":671,"navigation":32,"path":672,"seo":673,"stem":674,"__hash__":675},"blogAuthors/en-us/blog/authors/benjamin-skierlak.yml",{"template":666},"BlogAuthor",{"name":19,"config":668},{"headshot":669,"ctfId":670},"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":677,"title":20,"body":9,"config":678,"content":679,"description":9,"extension":30,"meta":683,"navigation":32,"path":684,"seo":685,"stem":686,"__hash__":687},"blogAuthors/en-us/blog/authors/james-wormwell.yml",{"template":666},{"name":20,"config":680},{"headshot":681,"ctfId":682},"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",[689,701,716],{"content":690,"config":699},{"title":691,"description":692,"authors":693,"heroImage":695,"body":696,"date":697,"category":10,"tags":698},"Neue GitLab-Metriken und Registry-Funktionen reduzieren CI/CD-Engpässe","CI/CD Job Performance Metrics und Container Virtual Registry, derzeit in der Beta, helfen Plattform-Teams dabei, langsame Jobs zu identifizieren und Multi-Registry-Container-Pulls zu vereinfachen.",[694],"Talia Armato-Helle","https://res.cloudinary.com/about-gitlab-com/image/upload/v1771438388/t6sts5qw4z8561gtlxiq.png","Plattform- und DevOps-Ingenieure verbringen zu viel Zeit damit, Transparenz über fragmentierte Tools hinweg herzustellen und Infrastruktur zu verwalten, die einfach funktionieren sollte.\n\nZwei neue GitLab-Funktionen, derzeit in der Beta, gehen dieses Problem aus unterschiedlichen Richtungen an – mit demselben Ziel: Praktikern direkte Kontrolle über die CI/CD-Infrastruktur zu geben, auf die sie angewiesen sind, ohne ein weiteres Drittanbieter-Tool einzuführen. Die eine Funktion liefert Job-Performance-Daten direkt dort, wo Pipelines überwacht werden. Die andere vereinfacht das Abrufen von Container-Images aus mehreren Registries mit integriertem Caching.\n\nBeide Funktionen sind jetzt für Feedback offen. Rückmeldungen helfen dabei, die nächsten Entwicklungsschritte zu gestalten.\n\n## CI/CD Job Performance Metrics\n\n* **Verfügbare Tiers:** GitLab Premium, GitLab Ultimate\n* **Status:** Beta mit eingeschränkter Verfügbarkeit auf GitLab.com; verfügbar auf GitLab Self-Managed und GitLab Dedicated bei konfiguriertem ClickHouse\n\nBislang gibt es keine einfache Möglichkeit zu erkennen, wenn die Laufzeit eines bestimmten Jobs zunimmt oder welche Jobs die Pipeline-Laufzeiten im Hintergrund verlangsamen. Die meisten Teams erstellen entweder eigene Dashboards oder durchsuchen manuell Logs, um grundlegende Fragen zu beantworten:\n\n* Welche Jobs sind am langsamsten?\n* Wo steigen die Fehlerquoten?\n* Welche Stage ist der eigentliche Engpass?\n\nCI/CD Job Performance Metrics löst das durch ein neues job-fokussiertes Panel auf der CI/CD-Analytics-Seite auf Projektebene.\n\nFür jeden Job in den Pipelines sind folgende Informationen einsehbar:\n\n* Typische (P50, Median) und ungünstigste (P95) Job-Laufzeit für einen schnellen Vergleich zwischen normalem und langsamstem Lauf\n* Fehlerquote zur Erkennung instabiler oder unzuverlässiger Jobs\n* Job-Name und Stage, standardmäßig für die letzten 30 Tage\n\nDie Tabelle ist sortierbar, nach Job-Name durchsuchbar und paginiert – Plattform-Teams erhalten so eine einheitliche Ansicht für Fragen, die bisher separate Tools oder eigene Berichte erforderten.\n\n**Jetzt ausprobieren**\n\n* Im Projekt **Analysieren > CI/CD-Analyse** aufrufen.\n* Das CI/CD Job Performance Metrics-Panel suchen und nach Laufzeit oder Fehlerquote sortieren, um die langsamsten oder unzuverlässigsten Jobs zu finden.\n\n**Dokumentation**\n\n* [CI/CD-Analyse – CI/CD Job Performance Metrics](https://docs.gitlab.com/user/analytics/ci_cd_analytics/#cicd-job-performance-metrics)\n\n**Was als Nächstes kommt**\n\nAktuell wird an einer Stage-Level-Gruppierung gearbeitet, mit der aggregierte Metriken über Build-, Test- und Deploy-Stages hinweg einsehbar sein werden – für ein schnelles Verständnis davon, wo Optimierungsbedarf besteht.\n\n**Feedback geben:**\n\n* [CI/CD Job Performance Metrics Epic](https://gitlab.com/groups/gitlab-org/-/work_items/18548)\n\n## Container Virtual Registry\n\n**Tier:** GitLab Premium\n**Status:** Beta, API-ready in 18.9\n\nDie meisten Unternehmen, die Container-Images in CI/CD-Pipelines abrufen, sind auf mehrere Registries angewiesen: Docker Hub, Harbor, Quay und interne Registries, um nur einige zu nennen. Authentifizierung, Verfügbarkeit und Caching für all diese Registries zu verwalten, ist operativer Aufwand, der Pipelines verlangsamt und Fehleranfälligkeit erhöht.\n\nDie Container Virtual Registry ermöglicht die Erstellung eines einzigen GitLab-Endpunkts, der Images aus mehreren vorgelagerten Container-Quellen mit integriertem Caching abruft.\n\nStatt Zugangsdaten und Verfügbarkeit für jede Registry einzeln in der Pipeline-Konfiguration einzurichten, lässt sich:\n\n* Eine einzelne virtuelle GitLab-Registry als Endpunkt für alle Pipelines konfigurieren\n* Mehrere vorgelagerte Registries einbinden (Docker Hub, Harbor, Quay und andere mit Long-Lived-Token-Authentifizierung)\n* GitLab Image-Pulls automatisch auflösen lassen, mit Pull-Through-Caching zur Reduzierung von Bandbreitenkosten und verbesserter Zuverlässigkeit\n\nFür Teams, die GitLab als Container-Registry-Ersatz evaluieren, schließt dies eine wesentliche Funktionslücke. Für Teams, die bereits Multi-Registry-Container-Workflows verwalten, zentralisiert es das Image-Management in GitLab und reduziert wiederholte Pulls.\n\n**Was die Beta heute unterstützt**\n\n* Vorgelagerte Registries mit Long-Lived-Token-Authentifizierung: Docker Hub, Harbor, Quay und andere kompatible Registries\n* Pull-Through-Caching, sodass häufig verwendete Images nach dem ersten Abruf von GitLab bereitgestellt werden\n* API-first-Konfiguration, UI-Verwaltung in Entwicklung\n\nCloud-Provider-Registries mit IAM-Authentifizierung (wie Amazon Elastic Container Registry, Google Artifact Registry und Azure Container Registry) werden für zukünftige Iterationen berücksichtigt.\n\n**Heute testen**\n\n* Die Container Virtual Registry ist in 18.9 API-ready.\n* SaaS (GitLab.com): Zugang über den CSM anfragen oder im unten verlinkten Feedback-Issue kommentieren, um das Feature-Flag für die eigene Gruppe zu aktivieren.\n* Self-managed: Feature-Flag aktivieren und die virtuelle Registry über die API konfigurieren.\n\n**Dokumentation**\n\n* [Container Virtual Registry API](https://docs.gitlab.com/api/container_virtual_registries/)\n* [Container-Images aus der virtuellen Registry abrufen](https://docs.gitlab.com/user/packages/virtual_registry/container/#pull-container-images-from-the-virtual-registry)\n\nWalkthrough der Container Virtual Registry Beta:\n\n\u003Ciframe src=\"https://player.vimeo.com/video/1167512082?title=0&byline=0&portrait=0&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=\"20260223_Container Virtual Registry Beta_V1\">\u003C/iframe>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\u003Cbr>\u003C/br>\n\n**Feedback geben:**\n\n* [Feedback-Issue zur Container Virtual Registry](https://gitlab.com/gitlab-org/gitlab/-/issues/589630)\n\n## Mitgestalten\n\nAlle in der GitLab-Community sind Mitwirkende. Diese Betas wurden auf Basis von Community-Anfragen entwickelt.\n\n* **CI/CD Job Performance Metrics** entstand aus dem Bedarf von Teams, die keine einfache Möglichkeit hatten zu erkennen, wenn Build-Zeiten in die falsche Richtung tendierten oder welche Jobs die Pipeline-Zuverlässigkeit beeinträchtigten.\n* **Container Virtual Registry** entstand aus Anfragen von Enterprise-Kunden, die mehrere Registries verwalteten und Tool-Sprawl sowie Bandbreitenkosten reduzieren wollten, während sie GitLab als zentrale Registry evaluierten.\n\nRückmeldungen gestalten, was als nächstes entwickelt wird. Eine oder beide Betas ausprobieren und Erfahrungen in den verlinkten Feedback-Issues teilen.\n\nDies ist der erste Beitrag in einer Reihe von Core-DevOps-Betas, die im Laufe des Jahres vorgestellt werden.\n","2026-02-25",[26,10,27],{"featured":32,"template":14,"slug":700},"new-gitlab-metrics-and-registry-features-help-reduce-ci-cd-bottlenecks",{"content":702,"config":714},{"title":703,"description":704,"authors":705,"date":708,"body":709,"heroImage":710,"category":10,"tags":711},"GitLab sichert 99,9 % Verfügbarkeit mit Service Credits für Ultimate-Kund(inn)en ab","Ultimate-Kund(inn)en erhalten Service Credits, wenn die Plattformverfügbarkeit unter 99,9 % fällt – für zuverlässige DevSecOps-Workflows.",[706,707],"Aathira Nair","Lyle Kozloff","2026-02-18","GitLab sichert die Verfügbarkeitszusage von 99,9 % ab sofort mit Service Credits für Ultimate-Kund(inn)en auf GitLab.com und GitLab Dedicated ab. Wenn die monatliche Verfügbarkeit unter diesen Schwellenwert fällt, erhalten berechtigte Kund(inn)en Gutschriften für zukünftige Rechnungen. Diese Zusage stellt sicher, dass DevSecOps-Workflows die nötige Zuverlässigkeit haben.\n\n## Vertrauen durch Verbindlichkeit\n\nModerne Softwarebereitstellung arbeitet in einem Tempo, in dem Teams kontinuierlich Code pushen, Merge Requests öffnen und Issues verfolgen. Git-Operationen – Push, Pull, Clone – finden tausende Male pro Stunde über verteilte Teams hinweg statt. Wenn einer dieser zentralen Dienste nicht verfügbar ist, steht der gesamte Software-Delivery-Workflow still.\n\nDas 99,9-%-Verfügbarkeits-SLA (Service-Level-Agreement) stellt sicher, dass ein hohes Entwicklungstempo nicht an Infrastruktur-Grenzen scheitert. Service Credits unterstreichen die Verantwortlichkeit – GitLabs Erfolg wird an die Plattformzuverlässigkeit gekoppelt. GitLab misst sich an den Geschäftsergebnissen der Kund(inn)en, nicht nur an Verfügbarkeitszielen.\n\nDas SLA von GitLab deckt die zentralen Plattformdienste ab, die für DevSecOps-Workflows wesentlich sind.\n\n**Zum Start sind folgende Dienste abgedeckt:**\n\n\\* Issues und Merge Requests\n\n\n\\* Git-Operationen (Push, Pull, Clone via HTTPS und SSH)\n\n\n\\* Container-Registry-Operationen\n\n\n\\* Package-Registry-Operationen\n\n\n\\* API-Requests (beschränkt auf die oben genannten Dienste)\n\n\nDie aktuelle Liste der abgedeckten und ausgeschlossenen Dienste ist im [GitLab-Handbuch](https://handbook.gitlab.com/handbook/engineering/infrastructure-platforms/service-level-agreement/#covered-experiences) verfügbar.\n\nDie Dienstverfügbarkeit wird durch automatisiertes Monitoring an mehreren geografischen Standorten gemessen und bildet die tatsächlich von Kund(inn)en erlebte Verfügbarkeit ab. Wenn die Verfügbarkeit unter 99,9 % fällt, können Kund(inn)en je nach Schwere des Ausfalls Credits beanspruchen.\n\n## Downtime Minutes verstehen\n\nWenn der GitLab-Dienst eine Verfügbarkeitseinschränkung von 5 % oder mehr der validen Kundenanfragen für abgedeckte Dienste innerhalb einer Minute aufweist und dies zu Server-Fehlern führt, wird dies als [Downtime Minute](https://handbook.gitlab.com/handbook/engineering/infrastructure-platforms/service-level-agreement/#downtime-minute-definition) bezeichnet. Server-Fehler sind definiert als HTTP-5xx-Statuscodes oder Verbindungs-Timeouts von mehr als 30 Sekunden, gemessen durch GitLabs interne und externe Monitoring-Systeme.\n\nDas SLA erfasst serverseitige Fehler, aber bestimmte Probleme lösen keine 5xx-Fehler aus – beispielsweise Anwendungsfehler, die Features unbenutzbar machen, Sidekiq-Job-Processing-Ausfälle oder Infrastrukturprobleme, die die Performance beeinträchtigen, ohne dass Requests fehlschlagen.\n\nSo lassen sich Service Credits bei Bedarf beanspruchen:\n\n1. Einen Support-Request auf support.gitlab.com innerhalb von dreißig (30) Tagen nach Ende des betroffenen Monats einreichen.\n\n2. Das GitLab-Team prüft den Anspruch, validiert die Downtime und verarbeitet die Gutschrift, falls zutreffend.\n\n3. Service Credits werden mit der nächsten Rechnung verrechnet.\n\nIm [Handbuch](https://handbook.gitlab.com/handbook/engineering/infrastructure-platforms/service-level-agreement/#calculating-monthly-uptime-percentage) finden sich weitere Details zur Berechnung der monatlichen Verfügbarkeit, den angebotenen Service Credits und dem Anspruchsverfahren.\n\nDas Monitoring ist darauf ausgelegt, die große Mehrheit der Dienstunterbrechungen zu erfassen. Falls die eigene Erfahrung nicht mit der gemeldeten Verfügbarkeit übereinstimmt, empfiehlt es sich, einen Service-Credit-Anspruch einzureichen. GitLab prüft den Anspruch ganzheitlich, einschließlich der Untersuchung von Problemen, die möglicherweise nicht im automatisierten Monitoring erfasst wurden.\n\n## Zuverlässigkeit mit Verbindlichkeit\n\nDas 99,9-%-Verfügbarkeits-SLA mit Service Credits steht für GitLabs Anspruch, eine zuverlässige Grundlage für Software-Delivery-Workflows zu bieten. Teams verlassen sich auf GitLab – und GitLab steht dafür ein.\n\nFragen zum SLA? Das GitLab-Account-Team kontaktieren oder einen Request über [GitLab Support](http://support.GitLab.com) einreichen.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1758812952/yxhgljkwljld0lyizmaz.png",[712,10,713],"performance","DevSecOps",{"featured":32,"template":14,"slug":715},"gitlab-backs-99-9-availability-with-service-credits-for-ultimate-customers",{"content":717,"config":728},{"title":718,"description":719,"authors":720,"heroImage":722,"date":723,"body":724,"category":10,"tags":725},"GitLab Credits – nutzungsbasierte Preise für GitLab Duo Agent Platform","Erfahre, wie GitLab Credits Kosten reduziert und Flexibilität für KI-Agenten im Enterprise-Software-Entwicklungszyklus bietet.\n",[721],"Manav Khurana","https://res.cloudinary.com/about-gitlab-com/image/upload/v1768314648/gvy4pfqjaeahkoagsjmr.png","2026-01-15","Wir haben GitLab Credits entwickelt, weil Seat-basierte Preise für KI-Agenten keinen Sinn ergaben.\nSeat-basierte Preise schaffen KI-„Besitzende\" und „Nicht-Besitzende\" in Engineering-Teams – eine grundlegende Fehlausrichtung mit der Art, wie moderne KI-Agenten im gesamten Software-Entwicklungszyklus genutzt werden sollten. Heute musst du für jede Person einen Seat kaufen, bevor sie KI nutzen kann. Während dies für die wenigen Heavy-User funktioniert, kann es für die Mehrheit des Teams mit leichter oder unregelmäßiger Nutzung zu teuer und unfair sein. Deshalb erhält in vielen Organisationen nur ein Teil des Teams einen „KI-Seat\".\n\nHinzu kommt, dass [GitLab Duo Agent Platform](https://about.gitlab.com/de-de/blog/gitlab-duo-agent-platform-is-generally-available/) sich von Duo Pro, Duo Enterprise und anderen KI-Entwicklertools auf dem Markt unterscheidet. Agenten und Agenten-Workflows können von deinem Team aufgerufen werden, wenn sie KI-Unterstützung benötigen, und durch SDLC-Events im Hintergrund ausgelöst werden. Mit Duo Agent Platform ist KI mit Agenten nicht mehr nur an Nutzer-Seats gebunden.\n\nGitLab Credits löst diese Probleme als unsere neue virtuelle Währung für nutzungsbasierte Preise, beginnend mit GitLab Duo Agent Platform. Das bedeutet, dass jedes Mitglied deiner Organisation mit einem GitLab-Konto (Premium oder Ultimate) jetzt KI-Agenten-Fähigkeiten nutzen kann, ohne dass du für einen KI-Seat bezahlst – egal ob von ihnen aufgerufen oder als Hintergrund-Agenten eingerichtet.\n\n## Wie GitLab Credits funktionieren\n\nGitLab Credits werden über deine gesamte Organisation gepoolt. Deine GitLab Duo Agent Platform-Nutzung wird von GitLab Credits abgezogen. Das umfasst sowohl synchrone als auch asynchrone Nutzung von Agenten und Agenten-Flows. Dazu gehören:\n* [Grundlegende Agenten](https://docs.gitlab.com/user/duo_agent_platform/agents/foundational_agents/) wie Security Analyst, Planner und Data Analyst\n\n* [Grundlegende Flows](https://docs.gitlab.com/user/duo_agent_platform/flows/foundational_flows/) wie Code Review, Developer und Fix CI/CD Pipeline\n\n* [Externe Agenten](https://docs.gitlab.com/user/duo_agent_platform/agents/external/) wie Anthropic Claude Code und OpenAI Codex\n\n* Benutzerdefinierte Agenten und Flows, die du in deinem [GitLab AI Catalog](https://docs.gitlab.com/user/duo_agent_platform/ai_catalog/) erstellst und veröffentlichst\n\n* [Agentic Chat](https://docs.gitlab.com/user/gitlab_duo_chat/agentic_chat/) in der GitLab-UI und in der IDE, die von deinen Entwicklungsteams genutzt wird\n\n**Hinweis:** Externe Agenten können in 18.8 kostenlos getestet werden und verbrauchen keine GitLab Credits. Wir werden nächsten Monat mit unserem 18.9 Release Preise einführen. Benutzerdefinierte Flows befinden sich derzeit in der Beta-Phase und verbrauchen keine GitLab Credits.\n\nDie Anzahl der abgezogenen Credits basiert auf der Anzahl der Agenten-Anfragen an große Sprachmodelle ([weitere Details hier](https://docs.gitlab.com/subscriptions/gitlab_credits/#models)). Wenn weitere LLMs verfügbar werden, werden wir sie für die Nutzung mit GitLab Duo Agent Platform zertifizieren und zu dieser Liste hinzufügen, um Kunden einen transparenten Überblick über deren Verbrauch zu geben.\n\nDie Gesamtzahl der GitLab Credits wird am Ende des Monats basierend auf der tatsächlichen Nutzung berechnet. Dieses Modell gleicht auch automatisch die Nutzung von Power-Usern mit der von leichteren Nutzern aus, wodurch deine Gesamtkosten für KI für jede Person effektiv gesenkt werden (im Vergleich zur Zahlung pro Seat für jede Person).\n\nDer Einfachheit halber hat jeder GitLab Credit einen **On-Demand**-Listenpreis von $1. Du kannst GitLab Duo Agent Platform ohne Verpflichtungen nutzen und die Nutzung wird monatlich abgerechnet (am Ende jedes Monats). Für Unternehmenskunden, die sich für **Jahresverpflichtungen** anmelden, bieten wir Mengenrabatte für monatliche Credits.\n\nAls zeitlich begrenzte Aktion[*](#notes) erhalten alle GitLab-Kunden mit aktiven Premium- und Ultimate-Abonnements automatisch $12 bzw. $24 an **inkludierten Credits pro Nutzer(in)**. Diese Credits werden jeden Monat bis zum Ende des Aktionszeitraums erneuert und geben deinem Team kostenlos Zugang zu allen GitLab Duo Agent Platform Features. Wenn du unsere Abrechnungsbedingungen akzeptierst, wird jede Nutzung über diese inkludierten Credits hinaus über zugesagte monatliche Credits oder On-Demand-Credits abgerechnet.\n\n## Kostenkontrolle mit GitLab Credits\n\n**GitLab Credits dimensionieren:** Dein Account-Team hat einen Dimensionierungsrechner als Teil der GA von GitLab Duo Agent Platform, um die Anzahl der GitLab Credits zu schätzen, die du jeden Monat benötigst. Dieser Rechner wurde mit Nutzungsmustern erstellt, die wir während der Beta-Phase beobachtet haben. Zusätzlich kannst du als Bestands- oder Neukunde eine kostenlose Testversion anfordern, um deine geschätzte tatsächliche Nutzung zu bestätigen.\n\n**Nutzungssichtbarkeit:** Mit dem 18.8 Release hast du detaillierte Nutzungsinformationen über zwei sich ergänzende Dashboards – eines im GitLab Customers Portal für Abrechnungsmanager mit Fokus auf finanzielle Übersicht und eines im Produkt für Administrator(inn)en mit Fokus auf operative Überwachung. Beide bieten Zuordnung der Nutzung, Kostenaufschlüsselung und historische Trends, sodass du immer genau weißt, wie deine Credits verbraucht werden. Wenn du intern eine Querverrechnung praktizierst, kannst du Projekt- und Gruppenebenen-Rollups für Kostenzuordnungen verwenden.\n\n**Nutzungskontrollen:** Du kannst den Zugriff auf GitLab Duo Agent Platform für bestimmte Teams oder Projekte aktivieren oder deaktivieren und sicherstellen, dass nur genehmigte Nutzung zu deinen Credits gezählt wird. Wir planen auch, kurz nach GA Kontrollen auf Nutzerebene hinzuzufügen, um dir zu helfen zu verwalten, wer GitLab Duo Agent Platform-Fähigkeiten nutzen und Credits verbrauchen kann.\n\n**Automatisierte Nutzungsbenachrichtigungen:** Wir halten dich proaktiv über deine GitLab Credit-Nutzung per E-Mail-Benachrichtigungen auf dem Laufenden, wenn du 50 %, 80 % und 100 % deiner zugesagten monatlichen Credits erreichst, was dir Zeit gibt, die Nutzung anzupassen, zusätzliche Verpflichtungen zu kaufen oder für On-Demand-Abrechnung zu planen.\n\n## Upgrade von Seat-basierten GitLab Duo Pro/Enterprise zu GitLab Credits für Duo Agent Platform\n\nWenn du GitLab Duo Pro und Duo Enterprise gekauft hast und nutzt, kannst du diese Funktionen als unterstützte Optionen weiterhin verwenden. Du kannst jederzeit auf GitLab Duo Agent Platform upgraden und das tun, was du mit „klassischem\" Duo kannst, und auf neue Funktionen wie Agentic Chat, zusätzliche grundlegende Agenten, benutzerdefinierte Agenten und Flows, externe Agenten und mehr zugreifen.\n\nZum Zeitpunkt des Upgrades übertragen wir deine Investition in Seats für GitLab Duo Pro und Duo Enterprise auf GitLab Credits für Duo Agent Platform. Der verbleibende Dollar-Betrag der Seat-Verpflichtungen wird gegen monatliche GitLab Credits mit volumenbasierten Rabatten getauscht. Die monatlichen GitLab Credits können dann von jedem Teammitglied in deiner Organisation geteilt werden, das du zulässt, nicht nur von den Nutzern, die vorher zugewiesene Duo Seats hatten.\n\n## Wettbewerbsvergleich: GitLab Credits vs. Seat-basierte Preise\n\n| Vorteil | GitLab Credits | Seat-basierte Preise |\n| ----- | ----- | ----- |\n| **KI für alle** | Jedes genehmigte Teammitglied erhält KI-Zugriff vom ersten Tag an | Schafft KI-„Besitzende\" und „Nicht-Besitzende\" – erzwingt Seat-Rationierung |\n| **Keine Vorabinvestition** | Starte klein mit inkludierten Credits, erhöhe Verpflichtung, wenn ROI klar wird | Muss Seats im Voraus kaufen, bevor der Wert bewiesen ist |\n| **Zahle nur was du nutzt** | Nur die tatsächlich durchgeführte KI-Arbeit über der inkludierten Stufe wird abgerechnet | Zahle pro Seat unabhängig von der tatsächlichen Nutzung |\n| **Optimierte Ausgaben** | Gemeinsamer Credit-Pool ermöglicht dir, Power-User mit leichten Nutzern auszugleichen | Muss für leichte Nutzer zahlen, Überziehungen für Premium-Anfragen von Power-Usern |\n| **Detaillierte Sichtbarkeit** | Nutzungs-Dashboards mit detaillierter Zuordnung und historischen Trends | Begrenzte Einblicke, welche Nutzer Wert schaffen |\n| **Granulare Kostenkontrolle** | Wähle wer Zugriff hat, proaktive Benachrichtigungen und kommende Budgetkontrollen zur Begrenzung | Begrenze wer einen Seat erhält, um Kosten zu kontrollieren |\n| **Flexibilität bei der Dimensionierung** | Rechner zur Schätzung monatlicher Credits, mit mehr Einheitenrabatten bei Volumen | Zähle wer einen Seat erhält multipliziert mit Preis pro Seat |\n| **Vereinfachte Verträge und Abrechnung** | Einzelne SKU und Rechnung deckt alle Agenten-Fähigkeiten über den DevSecOps-Lebenszyklus ab | Mehrere KI-Lizenzen über verschiedene Drittanbieter-Tools erforderlich |\n\n## Erste Schritte\n\n1. **Für bestehende Premium/Ultimate-Kunden**: Mit GA wird GitLab Duo Agent Platform für Kunden mit aktiven Premium- und Ultimate-Lizenzen verfügbar sein[**](#notes). GitLab.com SaaS-Kunden erhalten automatisch Zugriff. GitLab Self-Managed-Kunden erhalten Zugriff, wenn sie auf GitLab 18.8 Release upgraden (mit der geplanten allgemeinen Verfügbarkeit von Duo Agent Platform). GitLab Dedicated-Kunden werden während ihres geplanten Wartungsfensters im Februar auf GitLab 18.8 aktualisiert und können Duo Agent Platform ab diesem Zeitpunkt nutzen.\n\n2. **GitLab Duo aktivieren**: Stelle sicher, dass GitLab Duo Agent Platform in deinen Namespace-Einstellungen aktiviert ist.\n\n3. **Mit der Erkundung beginnen**: Nutze deine inkludierten monatlichen GitLab Credits, um GitLab Duo Agent Platform-Funktionen auszuprobieren.\n\n4. **Über inkludierte Credits hinausgehen:** Du kannst dich für GitLab Credits für erweiterte Nutzung über inkludierte Credits hinaus zum On-Demand-Listenpreis anmelden. Für Mengenrabatte mit Verpflichtung [kontaktiere uns](https://about.gitlab.com/de-de/sales/), um ein Angebot für dein spezifisches Nutzungsniveau zu erhalten.\n\nBesuche unsere [GitLab Duo Agent Platform Dokumentation](https://docs.gitlab.com/user/duo_agent_platform/), um mehr über die ersten Schritte zu erfahren.\n## Hinweise\n\n\\* Diese inkludierten Aktions-Credits sind für begrenzte Zeit bei GA verfügbar und können nach GitLabs Ermessen geändert werden.\n\n\\** Ausgenommen sind GitLab Duo mit Amazon Q und GitLab Dedicated für Regierungskunden.\n> Um mehr über GitLab Duo Agent Platform zu erfahren und alle Möglichkeiten, wie KI-Agenten die Arbeitsweise deines Teams transformieren können, [besuche unsere GitLab Duo Agent Platform Seite](https://about.gitlab.com/de-de/gitlab-duo-agent-platform/). Wenn du bestehender GitLab-Kunde bist, wende dich an deinen GitLab Account Manager oder Partner, um eine Live-Demonstration unserer Plattform-Funktionen zu vereinbaren.\n## GitLab Credits FAQ\n**1\\. Was sind GitLab Credits und warum hat GitLab sie eingeführt?**\n\nGitLab Credits ist eine neue virtuelle Währung für nutzungsbasierte GitLab-Funktionen, beginnend mit GitLab Duo Agent Platform. GitLab hat dieses Modell eingeführt, weil Seat-basierte Preise Organisationen zwangen, KI-Zugriff innerhalb von Engineering-Teams zu rationieren, und die Nutzung von Duo Agent Platform nicht nur an Seats gebunden ist. Credits werden über deine gesamte Organisation gepoolt, sodass du jedem Teammitglied Zugriff auf KI-Funktionen geben oder Hintergrund-Agenten-Workflows einrichten kannst, ohne individuelle Seat-Käufe im Voraus zu benötigen.\n\n**2\\. Wie funktioniert der Credit-Verbrauch?**\n\nCredits werden basierend auf der Anzahl der gestellten Agenten-Anfragen abgezogen, mit unterschiedlichen Raten je nachdem, welches LLM verwendet wird. Zum Beispiel erhältst du zwei Modell-Anfragen pro Credit für Claude-sonnet-4.5 (der Standard für die meisten Features) und 20 Anfragen pro Credit für Modelle wie gpt-5-mini oder claude-3-haiku.\n\n**3\\. Was ist für bestehende Premium- und Ultimate-Kunden enthalten?**\n\nAls zeitlich begrenzte Aktion erhalten Kunden mit aktiven Premium- und Ultimate-Abonnements automatisch inkludierte Credits kostenlos zusammen mit der GA-Veröffentlichung von Duo Agent Platform in GitLab 18.8:\n\n* $12 an Credits pro Nutzer/in pro Monat für Premium * $24 an Credits pro Nutzer/in pro Monat für Ultimate\n\nInkludierte Credits sind auf Pro-Nutzer-Ebene, werden monatlich erneuert und ermöglichen Zugriff auf alle GitLab Duo Agent Platform Features ohne zusätzliche Kosten. Die Nutzung über diese inkludierten Credits hinaus wird separat abgerechnet. Diese inkludierten Aktions-Credits sind für begrenzte Zeit nach GA verfügbar und können nach GitLabs Ermessen geändert werden.\n\n**4\\. Wie kann ich den Credit-Verbrauch kontrollieren und überwachen?**\n\nGitLab bietet mehrere Governance-Tools: detaillierte Nutzungs-Dashboards sowohl im Customers Portal als auch im Produkt, die Möglichkeit, den Zugriff für bestimmte Teams oder Projekte zu aktivieren/deaktivieren, kommende Kontrollen auf Nutzerebene und automatisierte E-Mail-Benachrichtigungen bei 50%, 80% und 100% der zugesagten monatlichen Credits. Wir erwarten auch, einen Dimensionierungsrechner anzubieten, um deinen monatlichen Credit-Bedarf zu schätzen.\n\n**5\\. Wie beginne ich mit GitLab Duo Agent Platform?**\n\nSobald GA, ist der Zugriff für bestehende Premium/Ultimate-Kunden automatisch auf GitLab.com SaaS. Self-Managed-Kunden erhalten Zugriff beim Upgrade auf GitLab 18.8 mit der geplanten allgemeinen Verfügbarkeit von Duo Agent Platform. Aktiviere einfach GitLab Duo Agent Platform in deinen Namespace-Einstellungen und beginne mit der Erkundung unter Verwendung deiner inkludierten monatlichen Credits. Für die Nutzung über inkludierte Credits hinaus kannst du dich für On-Demand-Abrechnung anmelden oder GitLab für Mengenrabatte mit jährlichen Verpflichtungen kontaktieren.\n\n*Dieser Blogbeitrag enthält „zukunftsgerichtete Aussagen\" im Sinne von Section 27A des Securities Act von 1933 in der geänderten Fassung und Section 21E des Securities Exchange Act von 1934. Obwohl wir glauben, dass die in diesen Aussagen widergespiegelten Erwartungen angemessen sind, unterliegen sie bekannten und unbekannten Risiken, Unsicherheiten, Annahmen und anderen Faktoren, die dazu führen können, dass die tatsächlichen Ergebnisse oder Resultate wesentlich abweichen. Weitere Informationen zu diesen Risiken und anderen Faktoren finden sich unter der Überschrift „Risikofaktoren\" in unseren Einreichungen bei der SEC. Wir verpflichten uns nicht, diese Aussagen nach dem Datum dieses Blogbeitrags zu aktualisieren oder zu überarbeiten, es sei denn, dies ist gesetzlich vorgeschrieben.*",[726,10,727],"AI/ML","news",{"featured":13,"template":14,"slug":729},"introducing-gitlab-credits",{"promotions":731},[732,746,758],{"id":733,"categories":734,"header":736,"text":737,"button":738,"image":743},"ai-modernization",[735],"ai-ml","Is AI achieving its promise at scale?","Quiz will take 5 minutes or less",{"text":739,"config":740},"Get your AI maturity score",{"href":741,"dataGaName":742,"dataGaLocation":248},"/assessments/ai-modernization-assessment/","modernization assessment",{"config":744},{"src":745},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1772138786/qix0m7kwnd8x2fh1zq49.png",{"id":747,"categories":748,"header":750,"text":737,"button":751,"image":755},"devops-modernization",[10,749],"devsecops","Are you just managing tools or shipping innovation?",{"text":752,"config":753},"Get your DevOps maturity score",{"href":754,"dataGaName":742,"dataGaLocation":248},"/assessments/devops-modernization-assessment/",{"config":756},{"src":757},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1772138785/eg818fmakweyuznttgid.png",{"id":759,"categories":760,"header":762,"text":737,"button":763,"image":767},"security-modernization",[761],"security","Are you trading speed for security?",{"text":764,"config":765},"Get your security maturity score",{"href":766,"dataGaName":742,"dataGaLocation":248},"/assessments/security-modernization-assessment/",{"config":768},{"src":769},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1772138786/p4pbqd9nnjejg5ds6mdk.png",{"header":771,"blurb":772,"button":773,"secondaryButton":778},"Beginne noch heute, schneller zu entwickeln","Entdecke, was dein Team mit der intelligenten Orchestrierungsplattform für DevSecOps erreichen kann.\n",{"text":774,"config":775},"Kostenlosen Test starten",{"href":776,"dataGaName":55,"dataGaLocation":777},"https://gitlab.com/-/trial_registrations/new?glm_content=default-saas-trial&glm_source=about.gitlab.com/","feature",{"text":57,"config":779},{"href":59,"dataGaName":60,"dataGaLocation":777},1772652053596]