[{"data":1,"prerenderedAt":766},["ShallowReactive",2],{"/de-de/blog/basics-of-gitlab-ci-updated":3,"navigation-de-de":38,"banner-de-de":442,"footer-de-de":452,"blog-post-authors-de-de-Itzik Gan Baruch":657,"blog-related-posts-de-de-basics-of-gitlab-ci-updated":671,"assessment-promotions-de-de":716,"next-steps-de-de":756},{"id":4,"title":5,"authorSlugs":6,"body":8,"categorySlug":9,"config":10,"content":14,"description":8,"extension":26,"isFeatured":12,"meta":27,"navigation":28,"path":29,"publishedDate":20,"seo":30,"stem":34,"tagSlugs":35,"__hash__":37},"blogPosts/de-de/blog/basics-of-gitlab-ci-updated.yml","Basics Of Gitlab Ci Updated",[7],"itzik-gan-baruch",null,"engineering",{"slug":11,"featured":12,"template":13},"basics-of-gitlab-ci-updated",false,"BlogPost",{"title":15,"description":16,"authors":17,"heroImage":19,"date":20,"body":21,"category":9,"tags":22,"updatedDate":25},"Grundlagen der GitLab-CI-Pipeline: Aufgaben sequenziell parallel oder ohne Reihenfolge ausführen","Neu in der Continuous Integration? Erfahre, wie du deine erste CI-Pipeline mit GitLab erstellst.",[18],"Itzik Gan Baruch","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749662061/Blog/Hero%20Images/cicdcover.png","2020-12-10","Nehmen wir an, dass du nichts über [kontinuierliche Integration (CI)](/topics/ci-cd/) and [why it's needed](/blog/how-to-keep-up-with-ci-cd-best-practices/) weißt und darüber, warum sie im Lebenszyklus der Softwareentwicklung benötigt wird.\n## Inhaltsverzeichnis\n- [Der erste Test in CI](#der-erste-test-in-ci)\n- [Ergebnisse von Builds zum Herunterladen bereitstellen](#ergebnisse-von-builds-zum-herunterladen-bereitstellen)\n- [Aufträge der Reihe nach ausführen](#aufträge-der-reihe-nach-ausführen)\n- [Welches Docker Image muss verwendet werden?](#welches-docker-image-muss-verwendet-werden%3F)\n- [Umgang mit komplexen Szenarien](#umgang-mit-komplexen-szenarien)\n- [Umgang mit fehlender Software/Paketen](#umgang-mit-fehlender-softwarepaketen)\n- [Directed Acyclic Graphs: Schnellere und flexiblere Pipelines](#directed-acyclic-graphs-schnellere-und-flexiblere-pipelines)\n- [Wie wertest du deine Pipeline auf?](#wie-wertest-du-deine-pipeline-auf%3F)\n  - [Automatisierte Tests in CI-Pipelines einbinden](#automatisierte-tests-in-ci-pipelines-einbinden)\n  - [Matrix-Builds](#matrix-builds)\n- [Unit-Tests](#unit-tests)\n  - [Was sind Unit-Tests?](#was-sind-unit-tests%3F)\n  - [Best Practices für Unit-Tests](#best-practices-für-unit-tests)\n    - [JUnit Test-Report](#junit-test-report)\n- [Strategien für Integrations- und End-to-End-Tests](#strategien-für-integrations--und-end-to-end-tests)\n- [Testumgebung](#testumgebung)\n- [Implementierung von Sicherheitsscans in CI-Pipelines](#implementierung-von-sicherheitsscans-in-ci-pipelines)\n  - [SAST und DAST-Integration](#sast-und-dast-integration)\n- [Zusammenfassung](#zusammenfassung)\n- [Beschreibungen der Keywords](#beschreibungen-der-keywords)\nStell dir vor, du arbeitest an einem Projekt, bei dem der gesamte Code aus zwei Textdateien besteht. Dabei ist es sehr wichtig, dass die Verkettung dieser beiden Dateien die Phrase „Hello world\" enthält.\nWenn das nicht der Fall ist, wird das gesamte Development-Team in diesem Monat nicht bezahlt. Ja, so ernst ist es!\nDer oder die verantwortliche Softwareentwickler(in) hat ein kleines Skript geschrieben, das jedes Mal ausgeführt wird, wenn wir unseren Code an die Kunden senden wollen.\nDer Code ist ziemlich komplex:\n```bash\ncat file1.txt file2.txt | grep -q \"Hello world\"\n```\nDas Problem ist, dass das Team aus 10 Entwickler(inne)n besteht. Da bleiben menschliche Fehler nicht aus.\nVor einer Woche vergaß einer der Mitarbeiter(innen), das Skript auszuführen, und drei Kund(inn)en erhielten fehlerhafte Builds. Also hast du beschlossen, dieses Problem endgültig zu lösen. Glücklicherweise befindet sich der Code bereits auf GitLab, und du erinnerst dich, dass es eine [integrierte CI](/de-de/solutions/continuous-integration/) gibt. Zudem hast du auf einer Konferenz gehört, dass viele Entwickler(innen) eine CI verwenden, um Tests durchzuführen...\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## Der erste Test in CI\nNach ein paar Minuten Suche und Lesen der Dokumentation scheint es, dass wir nur diese zwei Codezeilen benötigen, die wir in einer Datei namens .gitlab-ci.yml finden:\n```yaml\ntest:\n  script: cat file1.txt file2.txt | grep -q 'Hello world'\n```\nWir übertragen die Zeilen, und siehe da– unser Build ist erfolgreich:\n![build succeeded](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674096/Blog/Content%20Images/build_succeeded.png)\nNun ändern wir in der zweiten Datei \"World\" zu \"Africa\" und prüfen, was passiert:\n![build failed](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674096/Blog/Content%20Images/build_failed.png)\nDer Build schlägt wie erwartet fehl!\nNun haben wir hier automatisierte Tests! GitLab CI führt unser Testskript jedes Mal aus, wenn wir neuen Code in das Quellcode-Repository in der DevOps-Umgebung übertragen.\n**Hinweis:** Im obigen Beispiel gehen wir davon aus, dass file1.txt und file2.txt auf dem Runner-Host vorhanden sind.\nUm dieses Beispiel in GitLab auszuführen, verwende den folgenden Code, der zunächst die Dateien erstellt und dann das Skript ausführt.\n```yaml\ntest:\nbefore_script:\n      - echo \"Hello \" > | tr -d \"\\n\" | > file1.txt\n      - echo \"world\" > file2.txt\nscript: cat file1.txt file2.txt | grep -q 'Hello world'\n```\nAus Gründen der Übersichtlichkeit gehen wir davon aus, dass diese Dateien auf dem Host vorhanden sind und werden sie in den folgenden Beispielen nicht erstellen.\n## Ergebnisse von Builds zum Herunterladen bereitstellen\nDie nächste Anforderung besteht darin, den Code zu paketieren, bevor wir ihn an unsere Kunden senden. Lass uns auch diesen Teil des Softwareentwicklungsprozesses automatisieren!\nAlles, was wir machen müssen, ist, einen weiteren Job für CI zu definieren. Nennen wir den Auftrag mal „Package\":\n```yaml\ntest:\n  script: cat file1.txt file2.txt | grep -q 'Hello world'\n\npackage:\n  script: cat file1.txt file2.txt | gzip > package.gz\n```\nNun haben wir zwei Tabs:\n![Two tabs - generated from two jobs](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674096/Blog/Content%20Images/two_tabs.png)\nWir haben jedoch vergessen anzugeben, dass die neue Datei ein Build-Artefakt ist, damit sie heruntergeladen werden kann. Wir können dies beheben, indem wir einen Abschnitt für Artifacts hinzufügen:\n```yaml\ntest:\n  script: cat file1.txt file2.txt | grep -q 'Hello world'\n\npackage:\n  script: cat file1.txt file2.txt | gzip > packaged.gz\n  artifacts:\n    paths:\n    - packaged.gz\n```\nChecking... it is there:\n![Checking the download button](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674096/Blog/Content%20Images/artifacts.png)\nSo klappt's. Wir haben jedoch noch ein Problem zu lösen: Die Aufträge laufen parallel, aber wir wollen unsere Anwendung nicht paketieren, wenn unsere Tests fehlschlagen.\n## Aufträge der Reihe nach ausführen\nDer Auftrag „Paket\" soll nur ausgeführt werden, wenn die Tests erfolgreich sind. Definieren wir die Reihenfolge, indem wir stages angeben:\n```yaml\nstages:\n  - test\n  - package\n\ntest:\n  stage: test\n  script: cat file1.txt file2.txt | grep -q 'Hello world'\n\npackage:\n  stage: package\n  script: cat file1.txt file2.txt | gzip > packaged.gz\n  artifacts:\n    paths:\n    - packaged.gz\n```\nDas sollte funktionieren!\nAußerdem haben wir vergessen zu erwähnen, dass die Zusammenstellung (die in unserem Fall durch Verkettung dargestellt wird) eine Weile dauert, sodass wir sie nicht zweimal ausführen wollen. Definieren wir also einen separaten Schritt dafür:\n```yaml\nstages:\n  - compile\n  - test\n  - package\n\ncompile:\n  stage: compile\n  script: cat file1.txt file2.txt > compiled.txt\n  artifacts:\n    paths:\n    - compiled.txt\n\ntest:\n  stage: test\n  script: cat compiled.txt | grep -q 'Hello world'\n\npackage:\n  stage: package\n  script: cat compiled.txt | gzip > packaged.gz\n  artifacts:\n    paths:\n    - packaged.gz\n```\nLass uns jetzt auf unsere Artifacts an:\n![Unnecessary artifact](https://about.gitlab.com/images/blogimages/the-basics-of-gitlab-ci/clean-artifacts.png)\nWir brauchen diese „Kompilierungsdatei\" nicht zum Herunterladen. Deshalb lassen wir unsere temporären Artefakte ablaufen, indem wir expire_in auf „20 Minuten\" setzen:\n```yaml\ncompile:\n  stage: compile\n  script: cat file1.txt file2.txt > compiled.txt\n  artifacts:\n    paths:\n    - compiled.txt\n    expire_in: 20 minutes\n```\nJetzt sieht unsere Konfiguration ziemlich beeindruckend aus:\n- Wir haben drei aufeinanderfolgende Phasen zum Kompilieren, Testen und Paketieren unserer Anwendung.\n- Wir übergeben die kompilierte Anwendung an die nächsten Stufen, damit die Kompilierung nicht zweimal ausgeführt werden muss (und somit schneller läuft).\n- Wir speichern eine paketierte Version unserer Anwendung in Build-Artefakten für die weitere Verwendung.\n## Welches Docker Image muss verwendet werden?\nEs scheint, dass unsere Builds immer noch langsam sind. Werfen wir einen Blick auf die Protokolle.\n![ruby3.1](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674096/Blog/Content%20Images/ruby-31.png)\nWas ist Ruby 3.1?\nGitLab.com verwendet Docker-Images, um unsere [Builds](/blog/shared-runners/) auszuführen, und [standardmäßig](https://docs.gitlab.com/ee/user/gitlab_com/#shared-runners) wird das [`ruby:3.1`](https://hub.docker.com/_/ruby/)-Image verwendet. Dieses Image enthält natürlich viele Pakete, die wir nicht brauchen. Nach einer Minute des Googlens finden wir heraus, dass es ein Image namens [`alpine`](https://hub.docker.com/_/alpine/) gibt, das ein fast leeres Linux-Image ist.\nWir geben also explizit an, dass wir dieses Image verwenden wollen, indem wir image: alpine` to `.gitlab-ci.yml`.\nWir haben so drei Minuten gespart:\n![Build speed improved](https://about.gitlab.com/images/blogimages/the-basics-of-gitlab-ci/speed.png)\nEs sieht so aus, als gäbe es viele öffentliche Images:\n- [mysql](https://hub.docker.com/_/mysql/)\n- [Python](https://hub.docker.com/_/python/)\n- [Java](https://hub.docker.com/_/java/)\n- [php](https://hub.docker.com/_/php/)\nWir können also einfach eines für unseren Technologie-Stack nehmen. Es ist sinnvoll, ein Image anzugeben, das keine zusätzliche Software enthält, da dies die Downloadzeit verringert.\n## Umgang mit komplexen Szenarien\nNehmen wir nun aber an, wir haben neue Kund(inn)en, die möchten, dass wir unsere Anwendung in ein .iso-Image statt in ein .gz-Image packen. ISO-Images können mit dem Befehl [mkisofs](http://www.w3big.com/linux/linux-comm-mkisofs.html) erstellt werden. Da CI die ganze Arbeit erledigt, können wir einfach einen weiteren Job hinzufügen. Darauf basierend sollte unsere Konfiguration so aussehen:\n```yaml\nimage: alpine\n\nstages:\n  - compile\n  - test\n  - package\n\n# ... \"compile\" and \"test\" jobs are skipped here for the sake of compactness\n\npack-gz:\n  stage: package\n  script: cat compiled.txt | gzip > packaged.gz\n  artifacts:\n    paths:\n    - packaged.gz\n\npack-iso:\n  stage: package\n  script:\n  - mkisofs -o ./packaged.iso ./compiled.txt\n  artifacts:\n    paths:\n    - packaged.iso\n```\nBeachte, dass die Auftragsnamen nicht unbedingt gleich sein sollten. Wären sie identisch, wäre es nicht möglich, die Aufträge innerhalb derselben Phase des Softwareentwicklungsprozesses parallel laufen zu lassen. Sollte es daher doch mal vorkommen, kannst du das getrost als Zufall betrachten.\nWie dem auch sei, zurück zu unserem Job, da läuft es nicht recht rund – der Build schlägt fehl:\n![Failed build because of missing mkisofs](https://about.gitlab.com/images/blogimages/the-basics-of-gitlab-ci/mkisofs.png)\n`mkisofs` ist nicht im `alpine` Image mit dabei, also müssenw ir es erstmal installieren.\n## Umgang mit fehlender Software/Paketen\nLaut der [Alpine Linux website](https://pkgs.alpinelinux.org/contents?file=mkisofs&path=&name=&branch=edge&repo=&arch=) ist mkisofs Teil der Pakete xorriso und cdrkit. Dies sind die Befehle, die wir ausführen müssen, um ein Paket zu installieren:\n```bash\necho \"ipv6\" >> /etc/modules  # enable networking\napk update                   # update packages list\napk add xorriso              # install package\n```\nFür CI sind dies die gleichen Befehle wie für alle anderen. Die vollständige Liste der Befehle, die wir dem Skriptabschnitt übergeben müssen, sollte wie folgt aussehen:\n```yml\nscript:\n- echo \"ipv6\" >> /etc/modules\n- apk update\n- apk add xorriso\n- mkisofs -o ./packaged.iso ./compiled.txt\n```\nUm es jedoch semantisch korrekt zu machen, sollten wir die Befehle, die sich auf die Paketinstallation beziehen, in before_script unterbringen. Beachte, dass, wenn du before_script auf der obersten Ebene einer Konfiguration verwendest, die Befehle vor allen Aufträgen ausgeführt werden. In unserem Fall wollen wir nur, dass sie vor einem bestimmten Auftrag ausgeführt werden.\n## Directed Acyclic Graphs: Schnellere und flexiblere Pipelines\nWir haben die Stufen so definiert, dass die Paketaufgaben nur ausgeführt werden, wenn die Tests bestanden wurden. Was aber, wenn wir die Phasenabfolge ein wenig aufbrechen und einige Aufträge früher ausführen wollen, auch wenn sie in einer späteren Phase definiert sind? In einigen Fällen kann die herkömmliche Phasenabfolge die Gesamtausführungszeit der Pipeline verlangsamen.\nStell dir vor, dass unsere Testphase einige umfangreichere Tests enthält, deren Ausführung viel Zeit in Anspruch nimmt und diese Tests nicht unbedingt mit den Paketaufgaben zusammenhängen. In diesem Fall wäre es effizienter, wenn die Paketaufgaben nicht auf den Abschluss dieser Tests warten müssten, bevor sie beginnen können. An dieser Stelle kommen Directed Acyclic Graphs (DAG) ins Spiel: Um die Phasenreihenfolge für bestimmte Aufträge zu unterbrechen, kannst du Abhängigkeiten von Aufgaben definieren, die die reguläre Phasenreihenfolge übergehen.\nGitLab verfügt über ein spezielles Keyword „needs\", das Abhängigkeiten zwischen Aufträgen schafft und es ermöglicht, Aufträge früher auszuführen, sobald ihre abhängigen Aufträge abgeschlossen sind.\nIm folgenden Beispiel werden die Paketaufgaben ausgeführt, sobald der Testjob abgeschlossen ist. Wenn also in Zukunft jemand weitere Tests in der Testphase hinzufügt, beginnen die Paketjobs zu laufen, bevor die neuen Testjobs abgeschlossen sind\n```yaml\npack-gz:\n  stage: package\n  script: cat compiled.txt | gzip > packaged.gz\n  needs: [\"test\"]\n  artifacts:\n    paths:\n    - packaged.gz\n\npack-iso:\n  stage: package\n  before_script:\n  - echo \"ipv6\" >> /etc/modules\n  - apk update\n  - apk add xorriso\n  script:\n  - mkisofs -o ./packaged.iso ./compiled.txt\n  needs: [\"test\"]\n  artifacts:\n    paths:\n    - packaged.iso\n```\nUnsere finale Version von: `.gitlab-ci.yml`:\n```yaml\nimage: alpine\n\nstages:\n  - compile\n  - test\n  - package\n\ncompile:\n  stage: compile\n  before_script:\n      - echo \"Hello  \" | tr -d \"\\n\" > file1.txt\n      - echo \"world\" > file2.txt\n  script: cat file1.txt file2.txt > compiled.txt\n  artifacts:\n    paths:\n    - compiled.txt\n    expire_in: 20 minutes\n\ntest:\n  stage: test\n  script: cat compiled.txt | grep -q 'Hello world'\n\npack-gz:\n  stage: package\n  script: cat compiled.txt | gzip > packaged.gz\n  needs: [\"test\"]\n  artifacts:\n    paths:\n    - packaged.gz\n\npack-iso:\n  stage: package\n  before_script:\n  - echo \"ipv6\" >> /etc/modules\n  - apk update\n  - apk add xorriso\n  script:\n  - mkisofs -o ./packaged.iso ./compiled.txt\n  needs: [\"test\"]\n  artifacts:\n    paths:\n    - packaged.iso\n```\nWir haben gerade eine Pipeline erstellt! Wir haben drei sequenzielle Stufen, die Aufträge `pack-gz` und `pack-iso` innerhalb der package-Stufe laufen parallel:\n![Pipelines illustration](https://about.gitlab.com/images/blogimages/the-basics-of-gitlab-ci/pipeline.png)\n## Wie wertest du deine Pipeline auf?\nSo kannst du deine Pipeline aufwerten.\n### Automatisierte Tests in CI-Pipelines einbinden\nEine wichtige Regel der DevOps-Strategie für die Softwareentwicklung besteht darin, wirklich großartige Anwendungen mit erstaunlicher Benutzererfahrung zu entwickeln. Fügen wir also einige Tests in unsere CI-Pipeline ein, um Fehler frühzeitig im gesamten Prozess zu erkennen. Auf diese Weise können wir Probleme beheben, bevor sie zu groß werden und bevor wir an einem neuen Projekt weiterarbeiten.\nGitLab macht uns das Leben leichter, indem es fertige Vorlagen für verschiedene [Tests](https://docs.gitlab.com/ee/ci/testing/) anbietet. Alles, was wir tun müssen, ist, diese Vorlagen in unsere CI-Konfiguration aufzunehmen.\nIn diesem Beispiel schließen wir auch [Accessibility-Tests](https://docs.gitlab.com/ee/ci/testing/accessibility_testing.html) ein:\n```yaml\nstages:\n  - accessibility\n\nvariables:\n  a11y_urls: \"https://about.gitlab.com https://www.example.com\"\n\ninclude:\n  - template: \"Verify/Accessibility.gitlab-ci.yml\"\n```\nPasse die Variable a11y_urls an, um die URLs der Webseiten aufzulisten, die mit [Pa11y](https://pa11y.org/) und der [Codequalität](https://docs.gitlab.com/ee/ci/testing/code_quality.html) getestet werden sollen.\n```yaml\n   include:\n   - template: Jobs/Code-Quality.gitlab-ci.yml\n```\nMit GitLab kannst du den Testbericht direkt im Widget-Bereich der Zusammenführungsanforderung sehen. Wenn du die Codeüberprüfung, den Pipelinestatus und die Testergebnisse an einem Ort hast, wird alles reibungsloser und effizienter.\n![Accessibility report](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674096/Blog/Content%20Images/Screenshot_2024-04-02_at_10.56.41.png)\n\u003Ccenter>\u003Ci>Widget für die Zusammenführung von Accessibility-Anfragen\u003C/i>\u003C/center>\u003Cp>\u003C/p>\n![Code quality widget in MR](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674096/Blog/Content%20Images/Screenshot_2024-04-02_at_11.00.25.png)\n\u003Ccenter>\u003Ci>Widget für Zusammenführungsanfragen in Codequalität\u003C/i>\u003C/center>\n### Matrix-Builds\nIn einigen Fällen müssen wir unsere Anwendung in verschiedenen Konfigurationen, Betriebssystemversionen, Programmiersprachenversionen usw. testen. In diesen Fällen verwenden wir den [parallel:matrix](https://docs.gitlab.com/ee/ci/yaml/#parallelmatrix)-Build, um unsere Anwendung in verschiedenen Kombinationen parallel mit einer Job-Konfiguration zu testen. In diesem Artikel werden wir unseren Code mit verschiedenen Python-Versionen unter Verwendung des Schlüsselworts matrix testen.\n```yaml\npython-req:\n  image: python:$VERSION\n  stage: lint\n  script:\n    - pip install -r requirements_dev.txt\n    - chmod +x ./build_cpp.sh\n    - ./build_cpp.sh\n  parallel:\n    matrix:\n      - VERSION: ['3.8', '3.9', '3.10', '3.11']   # https://hub.docker.com/_/python\n```\nWährend der Pipeline-Ausführung wird dieser Auftrag viermal parallel ausgeführt, wobei jedes Mal ein anderes Python-Image verwendet wird (siehe unten):\n![Matrix job running](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674096/Blog/Content%20Images/Screenshot_2024-04-02_at_11.12.48.png)\n### Unit-Tests\n#### Was sind Unit-Tests?\nUnit-Tests sind kleine, gezielte Tests, die einzelne Komponenten oder Funktionen von Software prüfen, um sicherzustellen, dass sie wie erwartet funktionieren. Sie sind wichtig, um Fehler in einem frühen Stadium des Softwareentwicklungsprozesses aufzuspüren und zu überprüfen, ob jeder Teil des Codes für sich genommen korrekt funktioniert.\nBeispiel: Stell dir vor, du entwickelst eine Taschenrechner-App. Ein Unit-Test für die Additionsfunktion würde prüfen, ob 2 + 2 gleich 4 ist. Wenn dieser Test erfolgreich ist, bestätigt er, dass die Additionsfunktion korrekt funktioniert.\n#### Best Practices für Unit-Tests\nWenn die Tests fehlschlagen, schlägt die Pipeline fehl und die Benutzer werden benachrichtigt. Entwickler(innen) müssen die Auftragsprotokolle, die in der Regel Tausende von Zeilen enthalten, überprüfen und feststellen, wo die Tests fehlgeschlagen sind, um sie zu korrigieren. Diese Prüfung ist zeitaufwendig und ineffizient.\nDu kannst deinen Auftrag so konfigurieren, dass er [Unit-Test-Berichte](https://docs.gitlab.com/ee/ci/testing/unit_test_reports.html) verwendet. GitLab zeigt die Berichte in der Zusammenführungsanforderung und auf der Detailseite der Pipeline an, sodass du den Fehler einfacher und schneller identifizieren kannst, ohne das gesamte Protokoll überprüfen zu müssen.\n##### JUnit Test-Report\nDies ist ein beispielhafter JUnit Test-Report:\n![pipelines JUnit test report v13 10](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674097/Blog/Content%20Images/pipelines_junit_test_report_v13_10.png){: .shadow.center}\n### Strategien für Integrations- und End-to-End-Tests\nZusätzlich zu unserer regulären Entwicklungsroutine ist es sehr wichtig, eine spezielle Pipeline nur für Integrations- und End-to-End-Tests einzurichten. Damit wird überprüft, ob alle verschiedenen Teile unseres Codes reibungslos zusammenarbeiten, einschließlich der [Microservices](https://about.gitlab.com/topics/microservices/), der UI-Tests und aller anderen Komponenten.\nWir führen diese Tests jede [Nacht](https://docs.gitlab.com/ee/ci/pipelines/schedules.html) durch. Wir können es so einrichten, dass die Ergebnisse automatisch an einen speziellen [Slack](https://docs.gitlab.com/ee/user/project/integrations/gitlab_slack_application.html#notification-events)-Kanal gesendet werden. Auf diese Weise können die Entwickler(innen), wenn sie am nächsten Tag kommen, schnell alle Probleme erkennen. Es geht darum, Probleme frühzeitig zu erkennen und zu beheben!\n### Testumgebung\nFür einige der Tests benötigen wir möglicherweise eine Testumgebung, um unsere Anwendungen ordnungsgemäß zu testen. Mit GitLab CI/CD können wir die Bereitstellung von Testumgebungen automatisieren und so eine Menge Zeit sparen. Da es in diesem Blog hauptsächlich um CI geht, werde ich nicht näher darauf eingehen, aber du kannst diesen Abschnitt in der [GitLab-Dokumentation](https://docs.gitlab.com/ee/topics/release_your_application.html) nachlesen.\n## Implementierung von Sicherheitsscans in CI-Pipelines\nFolgend siehst du die Möglichkeiten zur Implementierung von Sicherheitsscans in CI-Pipelines.\n### SAST und DAST-Integration\nWir legen großen Wert darauf, dass unser Code sicher ist. Wenn unsere letzten Änderungen Schwachstellen aufweisen, wollen wir das so schnell wie möglich wissen. Sicherheitsscans sind hier eine sinnvolle Lösung und wir empfehlen dir, sie auch in deine Pipeline aufzunehmen. Sie überprüfen den Code bei jeder Übertragung und warnen dich vor möglichen Risiken. Wir haben eine Produktübersicht zusammengestellt, die dich durch das Hinzufügen von Scans, einschließlich statischer Anwendungssicherheitstests ([SAST](https://docs.gitlab.com/ee/user/application_security/sast/)) und dynamischer Anwendungssicherheitstests ([DAST](https://docs.gitlab.com/ee/user/application_security/dast/)), zu deiner CI-Pipeline führt.\n__Klicke__ auf das Bild unten, um zur Übersicht zu gelangen.\n[![Scans product tour](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674096/Blog/Content%20Images/Screenshot_2024-04-14_at_13.44.42.png)](https://gitlab.navattic.com/gitlab-scans)\nAußerdem können wir mithilfe von KI noch tiefer in Schwachstellen eindringen und Vorschläge zu ihrer Behebung erhalten.\nWeitere Informationen findest du in dieser Demo.\n[![product tour explain vulnerability ](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674096/Blog/Content%20Images/Screenshot_2024-04-14_at_13.50.24.png)](https://tech-marketing.gitlab.io/static-demos/pt-explain-vulnerability.html)\n## Zusammenfassung\nEs gibt noch viel mehr zu erläutern, aber lass uns hier erst einmal aufhören.\nAlle Beispiele sind bewusst einfach gehalten, um das Konzept GitLab CI vorzustellen, ohne die Dinge zu verkomplizieren. Fassen wir zusammen, was wir gelernt haben:\n1. Um Arbeit an GitLab CI zu delegieren, solltest du einen oder mehrere [Jobs](https://docs.gitlab.com/ee/ci/jobs/) in.gitlab-ci.yml. definieren.\n2. Jobs sollten Namen haben – also denk dir was Gutes aus! Jeder Auftrag enthält eine Reihe von Regeln und Anweisungen für GitLab CI, die durch spezielle Schlüsselwörter definiert sind.\n3. Aufträge können nacheinander, parallel oder ungeordnet über [DAG](https://docs.gitlab.com/ee/ci/directed_acyclic_graph/index.html) ausgeführt werden.\n4. Du kannst Dateien zwischen Aufträgen weitergeben und sie in Build-Artefakten speichern, sodass sie über die Schnittstelle heruntergeladen werden können.\n5. Du kannst Dateien zwischen Aufträgen weitergeben und sie in Build-Artefakten speichern, sodass sie über die Schnittstelle heruntergeladen werden können.\nNachstehend findest du eine genauere Beschreibung der von uns verwendeten Begriffe und Schlüsselwörter sowie Links zu den entsprechenden Dokumenten.\n### Beschreibungen der Keywords\n{: #keywords}\n| Keyword/term       | Beschreibung | |---------------|--------------------|\n| [.gitlab-ci.yml](https://docs.gitlab.com/ee/ci/yaml/) | Datei mit allen Definitionen dazu, wie dein Projekt aufgebaut sein sollte |\n| [script](https://docs.gitlab.com/ee/ci/yaml/#script)        | Definiert ein Shell-Script, das ausgeführt werden soll |\n| [before_script](https://docs.gitlab.com/ee/ci/yaml/#before_script) | Wird verwendet, um den Befehl zu definieren, der vor (allen) Aufträgen ausgeführt werden soll |\n| [image](https://docs.gitlab.com/ee/ci/docker/using_docker_images.html#what-is-image) | Definiert das zu verwendende Docker-Image |\n| [stages](https://docs.gitlab.com/ee/ci/yaml/#stages)         | Legt eine Pipelinestufe fest (Standard: test) |\n| [artifacts](https://docs.gitlab.com/ee/ci/yaml/#artifacts)     | Definiert eine Liste von Build-Artifacts |\n| [artifacts:expire_in](https://docs.gitlab.com/ee/ci/yaml/#artifactsexpire_in) | Wird verwendet, um hochgeladene Artifacts nach der angegebenen Zeit zu löschen |\n| [needs](https://docs.gitlab.com/ee/ci/yaml/#needs) | Dient zur Definition von Abhängigkeiten zwischen Aufträgen und ermöglicht die Ausführung von Aufträgen außerhalb der Reihenfolge |\n| [pipelines](https://about.gitlab.com/topics/ci-cd/cicd-pipeline/) | Eine Pipeline ist eine Gruppe von Builds, die stufenweise (Batches) ausgeführt werden |\n",[23,24],"CI","tutorial","2025-05-16","yml",{},true,"/de-de/blog/basics-of-gitlab-ci-updated",{"title":15,"description":16,"ogTitle":15,"ogDescription":16,"noIndex":12,"ogImage":19,"ogUrl":31,"ogSiteName":32,"ogType":33,"canonicalUrls":31},"https://about.gitlab.com/blog/basics-of-gitlab-ci-updated","https://about.gitlab.com","article","de-de/blog/basics-of-gitlab-ci-updated",[36,24],"ci","c5Ig6hOEXyNv7TzyvVOo9aR4e6Ae4o_PJcSpKcvyzJ0",{"data":39},{"logo":40,"freeTrial":45,"sales":50,"login":55,"items":60,"search":369,"minimal":404,"duo":422,"pricingDeployment":432},{"config":41},{"href":42,"dataGaName":43,"dataGaLocation":44},"/de-de/","gitlab logo","header",{"text":46,"config":47},"Kostenlose Testversion anfordern",{"href":48,"dataGaName":49,"dataGaLocation":44},"https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com&glm_content=default-saas-trial/","free trial",{"text":51,"config":52},"Vertrieb kontaktieren",{"href":53,"dataGaName":54,"dataGaLocation":44},"/de-de/sales/","sales",{"text":56,"config":57},"Anmelden",{"href":58,"dataGaName":59,"dataGaLocation":44},"https://gitlab.com/users/sign_in/","sign in",[61,88,184,189,290,350],{"text":62,"config":63,"cards":65},"Plattform",{"dataNavLevelOne":64},"platform",[66,72,80],{"title":62,"description":67,"link":68},"Die intelligente Orchestrierungsplattform für DevSecOps",{"text":69,"config":70},"Erkunde unsere Plattform",{"href":71,"dataGaName":64,"dataGaLocation":44},"/de-de/platform/",{"title":73,"description":74,"link":75},"GitLab Duo Agent Platform","Agentische KI für den gesamten Softwareentwicklungszyklus",{"text":76,"config":77},"Lerne GitLab Duo kennen",{"href":78,"dataGaName":79,"dataGaLocation":44},"/de-de/gitlab-duo-agent-platform/","gitlab duo agent platform",{"title":81,"description":82,"link":83},"Gründe, die für GitLab sprechen","Erfahre, warum Unternehmen auf GitLab setzen",{"text":84,"config":85},"Mehr erfahren",{"href":86,"dataGaName":87,"dataGaLocation":44},"/de-de/why-gitlab/","why gitlab",{"text":89,"left":28,"config":90,"link":92,"lists":96,"footer":166},"Produkt",{"dataNavLevelOne":91},"solutions",{"text":93,"config":94},"Alle Lösungen anzeigen",{"href":95,"dataGaName":91,"dataGaLocation":44},"/de-de/solutions/",[97,122,144],{"title":98,"description":99,"link":100,"items":105},"Automatisierung","CI/CD und Automatisierung zur Beschleunigung der Bereitstellung",{"config":101},{"icon":102,"href":103,"dataGaName":104,"dataGaLocation":44},"AutomatedCodeAlt","/de-de/solutions/delivery-automation/","automated software delivery",[106,110,113,118],{"text":107,"config":108},"CI/CD",{"href":109,"dataGaLocation":44,"dataGaName":107},"/de-de/solutions/continuous-integration/",{"text":73,"config":111},{"href":78,"dataGaLocation":44,"dataGaName":112},"gitlab duo agent platform - product menu",{"text":114,"config":115},"Quellcodeverwaltung",{"href":116,"dataGaLocation":44,"dataGaName":117},"/de-de/solutions/source-code-management/","Source Code Management",{"text":119,"config":120},"Automatisierte Softwarebereitstellung",{"href":103,"dataGaLocation":44,"dataGaName":121},"Automated software delivery",{"title":123,"description":124,"link":125,"items":130},"Sicherheit","Entwickle schneller, ohne die Sicherheit zu gefährden",{"config":126},{"href":127,"dataGaName":128,"dataGaLocation":44,"icon":129},"/de-de/solutions/application-security-testing/","security and compliance","ShieldCheckLight",[131,135,140],{"text":132,"config":133},"Application Security Testing",{"href":127,"dataGaName":134,"dataGaLocation":44},"Application security testing",{"text":136,"config":137},"Schutz der Software-Lieferkette",{"href":138,"dataGaLocation":44,"dataGaName":139},"/de-de/solutions/supply-chain/","Software supply chain security",{"text":141,"config":142},"Software Compliance",{"href":143,"dataGaName":141,"dataGaLocation":44},"/de-de/solutions/software-compliance/",{"title":145,"link":146,"items":151},"Bewertung",{"config":147},{"icon":148,"href":149,"dataGaName":150,"dataGaLocation":44},"DigitalTransformation","/de-de/solutions/visibility-measurement/","visibility and measurement",[152,156,161],{"text":153,"config":154},"Sichtbarkeit und Bewertung",{"href":149,"dataGaLocation":44,"dataGaName":155},"Visibility and Measurement",{"text":157,"config":158},"Wertstrommanagement",{"href":159,"dataGaLocation":44,"dataGaName":160},"/de-de/solutions/value-stream-management/","Value Stream Management",{"text":162,"config":163},"Analysen und Einblicke",{"href":164,"dataGaLocation":44,"dataGaName":165},"/de-de/solutions/analytics-and-insights/","Analytics and insights",{"title":167,"items":168},"GitLab für",[169,174,179],{"text":170,"config":171},"Enterprise",{"href":172,"dataGaLocation":44,"dataGaName":173},"/de-de/enterprise/","enterprise",{"text":175,"config":176},"Kleinunternehmen",{"href":177,"dataGaLocation":44,"dataGaName":178},"/de-de/small-business/","small business",{"text":180,"config":181},"den öffentlichen Sektor",{"href":182,"dataGaLocation":44,"dataGaName":183},"/de-de/solutions/public-sector/","public sector",{"text":185,"config":186},"Preise",{"href":187,"dataGaName":188,"dataGaLocation":44,"dataNavLevelOne":188},"/de-de/pricing/","pricing",{"text":190,"config":191,"link":193,"lists":197,"feature":277},"Ressourcen",{"dataNavLevelOne":192},"resources",{"text":194,"config":195},"Alle Ressourcen anzeigen",{"href":196,"dataGaName":192,"dataGaLocation":44},"/de-de/resources/",[198,231,249],{"title":199,"items":200},"Erste Schritte",[201,206,211,216,221,226],{"text":202,"config":203},"Installieren",{"href":204,"dataGaName":205,"dataGaLocation":44},"/de-de/install/","install",{"text":207,"config":208},"Kurzanleitungen",{"href":209,"dataGaName":210,"dataGaLocation":44},"/de-de/get-started/","quick setup checklists",{"text":212,"config":213},"Lernen",{"href":214,"dataGaLocation":44,"dataGaName":215},"https://university.gitlab.com/","learn",{"text":217,"config":218},"Produktdokumentation",{"href":219,"dataGaName":220,"dataGaLocation":44},"https://docs.gitlab.com/","product documentation",{"text":222,"config":223},"Best-Practice-Videos",{"href":224,"dataGaName":225,"dataGaLocation":44},"/de-de/getting-started-videos/","best practice videos",{"text":227,"config":228},"Integrationen",{"href":229,"dataGaName":230,"dataGaLocation":44},"/de-de/integrations/","integrations",{"title":232,"items":233},"Entdecken",[234,239,244],{"text":235,"config":236},"Kundenerfolge",{"href":237,"dataGaName":238,"dataGaLocation":44},"/de-de/customers/","customer success stories",{"text":240,"config":241},"Blog",{"href":242,"dataGaName":243,"dataGaLocation":44},"/de-de/blog/","blog",{"text":245,"config":246},"Remote",{"href":247,"dataGaName":248,"dataGaLocation":44},"https://handbook.gitlab.com/handbook/company/culture/all-remote/","remote",{"title":250,"items":251},"Vernetzen",[252,257,262,267,272],{"text":253,"config":254},"GitLab-Services",{"href":255,"dataGaName":256,"dataGaLocation":44},"/de-de/services/","services",{"text":258,"config":259},"Community",{"href":260,"dataGaName":261,"dataGaLocation":44},"/community/","community",{"text":263,"config":264},"Forum",{"href":265,"dataGaName":266,"dataGaLocation":44},"https://forum.gitlab.com/","forum",{"text":268,"config":269},"Veranstaltungen",{"href":270,"dataGaName":271,"dataGaLocation":44},"/events/","events",{"text":273,"config":274},"Partner",{"href":275,"dataGaName":276,"dataGaLocation":44},"/de-de/partners/","partners",{"backgroundColor":278,"textColor":279,"text":280,"image":281,"link":285},"#2f2a6b","#fff","Perspektiven für die Softwareentwicklung der Zukunft",{"altText":282,"config":283},"the source promo card",{"src":284},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758208064/dzl0dbift9xdizyelkk4.svg",{"text":286,"config":287},"Lies die News",{"href":288,"dataGaName":289,"dataGaLocation":44},"/de-de/the-source/","the source",{"text":291,"config":292,"lists":294},"Unternehmen",{"dataNavLevelOne":293},"company",[295],{"items":296},[297,302,308,310,315,320,325,330,335,340,345],{"text":298,"config":299},"Über",{"href":300,"dataGaName":301,"dataGaLocation":44},"/de-de/company/","about",{"text":303,"config":304,"footerGa":307},"Karriere",{"href":305,"dataGaName":306,"dataGaLocation":44},"/jobs/","jobs",{"dataGaName":306},{"text":268,"config":309},{"href":270,"dataGaName":271,"dataGaLocation":44},{"text":311,"config":312},"Geschäftsführung",{"href":313,"dataGaName":314,"dataGaLocation":44},"/company/team/e-group/","leadership",{"text":316,"config":317},"Team",{"href":318,"dataGaName":319,"dataGaLocation":44},"/company/team/","team",{"text":321,"config":322},"Handbuch",{"href":323,"dataGaName":324,"dataGaLocation":44},"https://handbook.gitlab.com/","handbook",{"text":326,"config":327},"Investor Relations",{"href":328,"dataGaName":329,"dataGaLocation":44},"https://ir.gitlab.com/","investor relations",{"text":331,"config":332},"Trust Center",{"href":333,"dataGaName":334,"dataGaLocation":44},"/de-de/security/","trust center",{"text":336,"config":337},"AI Transparency Center",{"href":338,"dataGaName":339,"dataGaLocation":44},"/de-de/ai-transparency-center/","ai transparency center",{"text":341,"config":342},"Newsletter",{"href":343,"dataGaName":344,"dataGaLocation":44},"/company/contact/#contact-forms","newsletter",{"text":346,"config":347},"Presse",{"href":348,"dataGaName":349,"dataGaLocation":44},"/press/","press",{"text":351,"config":352,"lists":353},"Kontakt",{"dataNavLevelOne":293},[354],{"items":355},[356,359,364],{"text":51,"config":357},{"href":53,"dataGaName":358,"dataGaLocation":44},"talk to sales",{"text":360,"config":361},"Support-Portal",{"href":362,"dataGaName":363,"dataGaLocation":44},"https://support.gitlab.com","support portal",{"text":365,"config":366},"Kundenportal",{"href":367,"dataGaName":368,"dataGaLocation":44},"https://customers.gitlab.com/customers/sign_in/","customer portal",{"close":370,"login":371,"suggestions":378},"Schließen",{"text":372,"link":373},"Um Repositories und Projekte zu durchsuchen, melde dich an bei",{"text":374,"config":375},"gitlab.com",{"href":58,"dataGaName":376,"dataGaLocation":377},"search login","search",{"text":379,"default":380},"Vorschläge",[381,383,388,390,395,400],{"text":73,"config":382},{"href":78,"dataGaName":73,"dataGaLocation":377},{"text":384,"config":385},"Code Suggestions (KI)",{"href":386,"dataGaName":387,"dataGaLocation":377},"/de-de/solutions/code-suggestions/","Code Suggestions (AI)",{"text":107,"config":389},{"href":109,"dataGaName":107,"dataGaLocation":377},{"text":391,"config":392},"GitLab auf AWS",{"href":393,"dataGaName":394,"dataGaLocation":377},"/de-de/partners/technology-partners/aws/","GitLab on AWS",{"text":396,"config":397},"GitLab auf Google Cloud",{"href":398,"dataGaName":399,"dataGaLocation":377},"/de-de/partners/technology-partners/google-cloud-platform/","GitLab on Google Cloud",{"text":401,"config":402},"Warum GitLab?",{"href":86,"dataGaName":403,"dataGaLocation":377},"Why GitLab?",{"freeTrial":405,"mobileIcon":410,"desktopIcon":415,"secondaryButton":418},{"text":406,"config":407},"Kostenlos testen",{"href":408,"dataGaName":49,"dataGaLocation":409},"https://gitlab.com/-/trials/new/","nav",{"altText":411,"config":412},"GitLab-Symbol",{"src":413,"dataGaName":414,"dataGaLocation":409},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758203874/jypbw1jx72aexsoohd7x.svg","gitlab icon",{"altText":411,"config":416},{"src":417,"dataGaName":414,"dataGaLocation":409},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758203875/gs4c8p8opsgvflgkswz9.svg",{"text":199,"config":419},{"href":420,"dataGaName":421,"dataGaLocation":409},"https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com/de-de/compare/gitlab-vs-github/","get started",{"freeTrial":423,"mobileIcon":428,"desktopIcon":430},{"text":424,"config":425},"Erfahre mehr über GitLab Duo",{"href":426,"dataGaName":427,"dataGaLocation":409},"/de-de/gitlab-duo/","gitlab duo",{"altText":411,"config":429},{"src":413,"dataGaName":414,"dataGaLocation":409},{"altText":411,"config":431},{"src":417,"dataGaName":414,"dataGaLocation":409},{"freeTrial":433,"mobileIcon":438,"desktopIcon":440},{"text":434,"config":435},"Zurück zur Preisübersicht",{"href":187,"dataGaName":436,"dataGaLocation":409,"icon":437},"back to pricing","GoBack",{"altText":411,"config":439},{"src":413,"dataGaName":414,"dataGaLocation":409},{"altText":411,"config":441},{"src":417,"dataGaName":414,"dataGaLocation":409},{"title":443,"button":444,"config":449},"Sieh dir an, wie agentische KI die Softwarebereitstellung transformiert",{"text":445,"config":446},"GitLab Transcend jetzt ansehen",{"href":447,"dataGaName":448,"dataGaLocation":44},"/de-de/events/transcend/virtual/","transcend event",{"layout":450,"icon":451},"release","AiStar",{"data":453},{"text":454,"source":455,"edit":461,"contribute":466,"config":471,"items":476,"minimal":649},"Git ist eine Marke von Software Freedom Conservancy und unsere Verwendung von „GitLab“ erfolgt unter Lizenz.",{"text":456,"config":457},"Quelltext der Seite anzeigen",{"href":458,"dataGaName":459,"dataGaLocation":460},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/","page source","footer",{"text":462,"config":463},"Diese Seite bearbeiten",{"href":464,"dataGaName":465,"dataGaLocation":460},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/content/","web ide",{"text":467,"config":468},"Beteilige dich",{"href":469,"dataGaName":470,"dataGaLocation":460},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/CONTRIBUTING.md/","please contribute",{"twitter":472,"facebook":473,"youtube":474,"linkedin":475},"https://x.com/gitlab","https://www.facebook.com/gitlab","https://www.youtube.com/channel/UCnMGQ8QHMAnVIsI3xJrihhg","https://www.linkedin.com/company/gitlab-com",[477,500,555,582,616],{"title":62,"links":478,"subMenu":483},[479],{"text":480,"config":481},"DevSecOps-Plattform",{"href":71,"dataGaName":482,"dataGaLocation":460},"devsecops platform",[484],{"title":185,"links":485},[486,490,495],{"text":487,"config":488},"Tarife anzeigen",{"href":187,"dataGaName":489,"dataGaLocation":460},"view plans",{"text":491,"config":492},"Vorteile von Premium",{"href":493,"dataGaName":494,"dataGaLocation":460},"/de-de/pricing/premium/","why premium",{"text":496,"config":497},"Vorteile von Ultimate",{"href":498,"dataGaName":499,"dataGaLocation":460},"/de-de/pricing/ultimate/","why ultimate",{"title":501,"links":502},"Lösungen",[503,508,511,513,518,523,527,530,533,538,540,542,545,550],{"text":504,"config":505},"Digitale Transformation",{"href":506,"dataGaName":507,"dataGaLocation":460},"/de-de/topics/digital-transformation/","digital transformation",{"text":509,"config":510},"Sicherheit und Compliance",{"href":127,"dataGaName":134,"dataGaLocation":460},{"text":119,"config":512},{"href":103,"dataGaName":104,"dataGaLocation":460},{"text":514,"config":515},"Agile Entwicklung",{"href":516,"dataGaName":517,"dataGaLocation":460},"/de-de/solutions/agile-delivery/","agile delivery",{"text":519,"config":520},"Cloud-Transformation",{"href":521,"dataGaName":522,"dataGaLocation":460},"/de-de/topics/cloud-native/","cloud transformation",{"text":524,"config":525},"SCM",{"href":116,"dataGaName":526,"dataGaLocation":460},"source code management",{"text":107,"config":528},{"href":109,"dataGaName":529,"dataGaLocation":460},"continuous integration & delivery",{"text":157,"config":531},{"href":159,"dataGaName":532,"dataGaLocation":460},"value stream management",{"text":534,"config":535},"GitOps",{"href":536,"dataGaName":537,"dataGaLocation":460},"/de-de/solutions/gitops/","gitops",{"text":170,"config":539},{"href":172,"dataGaName":173,"dataGaLocation":460},{"text":175,"config":541},{"href":177,"dataGaName":178,"dataGaLocation":460},{"text":543,"config":544},"Öffentlicher Sektor",{"href":182,"dataGaName":183,"dataGaLocation":460},{"text":546,"config":547},"Bildungswesen",{"href":548,"dataGaName":549,"dataGaLocation":460},"/de-de/solutions/education/","education",{"text":551,"config":552},"Finanzdienstleistungen",{"href":553,"dataGaName":554,"dataGaLocation":460},"/de-de/solutions/finance/","financial services",{"title":190,"links":556},[557,559,561,563,566,568,570,572,574,576,578,580],{"text":202,"config":558},{"href":204,"dataGaName":205,"dataGaLocation":460},{"text":207,"config":560},{"href":209,"dataGaName":210,"dataGaLocation":460},{"text":212,"config":562},{"href":214,"dataGaName":215,"dataGaLocation":460},{"text":217,"config":564},{"href":219,"dataGaName":565,"dataGaLocation":460},"docs",{"text":240,"config":567},{"href":242,"dataGaName":243,"dataGaLocation":460},{"text":235,"config":569},{"href":237,"dataGaName":238,"dataGaLocation":460},{"text":245,"config":571},{"href":247,"dataGaName":248,"dataGaLocation":460},{"text":253,"config":573},{"href":255,"dataGaName":256,"dataGaLocation":460},{"text":258,"config":575},{"href":260,"dataGaName":261,"dataGaLocation":460},{"text":263,"config":577},{"href":265,"dataGaName":266,"dataGaLocation":460},{"text":268,"config":579},{"href":270,"dataGaName":271,"dataGaLocation":460},{"text":273,"config":581},{"href":275,"dataGaName":276,"dataGaLocation":460},{"title":291,"links":583},[584,586,588,590,592,594,596,600,605,607,609,611],{"text":298,"config":585},{"href":300,"dataGaName":293,"dataGaLocation":460},{"text":303,"config":587},{"href":305,"dataGaName":306,"dataGaLocation":460},{"text":311,"config":589},{"href":313,"dataGaName":314,"dataGaLocation":460},{"text":316,"config":591},{"href":318,"dataGaName":319,"dataGaLocation":460},{"text":321,"config":593},{"href":323,"dataGaName":324,"dataGaLocation":460},{"text":326,"config":595},{"href":328,"dataGaName":329,"dataGaLocation":460},{"text":597,"config":598},"Sustainability",{"href":599,"dataGaName":597,"dataGaLocation":460},"/sustainability/",{"text":601,"config":602},"Vielfalt, Inklusion und Zugehörigkeit",{"href":603,"dataGaName":604,"dataGaLocation":460},"/de-de/diversity-inclusion-belonging/","Diversity, inclusion and belonging",{"text":331,"config":606},{"href":333,"dataGaName":334,"dataGaLocation":460},{"text":341,"config":608},{"href":343,"dataGaName":344,"dataGaLocation":460},{"text":346,"config":610},{"href":348,"dataGaName":349,"dataGaLocation":460},{"text":612,"config":613},"Transparenzerklärung zu moderner Sklaverei",{"href":614,"dataGaName":615,"dataGaLocation":460},"https://handbook.gitlab.com/handbook/legal/modern-slavery-act-transparency-statement/","modern slavery transparency statement",{"title":617,"links":618},"Nimm Kontakt auf",[619,622,627,629,634,639,644],{"text":620,"config":621},"Sprich mit einem Experten/einer Expertin",{"href":53,"dataGaName":54,"dataGaLocation":460},{"text":623,"config":624},"Support",{"href":625,"dataGaName":626,"dataGaLocation":460},"/support/","get help",{"text":365,"config":628},{"href":367,"dataGaName":368,"dataGaLocation":460},{"text":630,"config":631},"Status",{"href":632,"dataGaName":633,"dataGaLocation":460},"https://status.gitlab.com/","status",{"text":635,"config":636},"Nutzungsbedingungen",{"href":637,"dataGaName":638,"dataGaLocation":460},"/terms/","terms of use",{"text":640,"config":641},"Datenschutzerklärung",{"href":642,"dataGaName":643,"dataGaLocation":460},"/de-de/privacy/","privacy statement",{"text":645,"config":646},"Cookie-Einstellungen",{"dataGaName":647,"dataGaLocation":460,"id":648,"isOneTrustButton":28},"cookie preferences","ot-sdk-btn",{"items":650},[651,653,655],{"text":635,"config":652},{"href":637,"dataGaName":638,"dataGaLocation":460},{"text":640,"config":654},{"href":642,"dataGaName":643,"dataGaLocation":460},{"text":645,"config":656},{"dataGaName":647,"dataGaLocation":460,"id":648,"isOneTrustButton":28},[658],{"id":659,"title":18,"body":8,"config":660,"content":662,"description":8,"extension":26,"meta":666,"navigation":28,"path":667,"seo":668,"stem":669,"__hash__":670},"blogAuthors/en-us/blog/authors/itzik-gan-baruch.yml",{"template":661},"BlogAuthor",{"name":18,"config":663},{"headshot":664,"ctfId":665},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1749658921/Blog/Author%20Headshots/iganbaruch-headshot.jpg","iganbaruch",{},"/en-us/blog/authors/itzik-gan-baruch",{},"en-us/blog/authors/itzik-gan-baruch","bz9VMiTQ1ixvnoxUFk0jiUcnLG3oQsymgXNCqyRqfsk",[672,686,700],{"content":673,"config":684},{"category":9,"tags":674,"body":676,"date":677,"heroImage":678,"authors":679,"title":682,"description":683},[24,675,107],"git","Enterprise-Migrationen in regulierten Branchen wie Finanzwesen und Automobilindustrie erfordern systematisches Risikomanagement gemäß NIS2-Richtlinie Artikel 21. Die mehrstufige Migrationsstruktur mit Testläufen vor Produktions-Wellen und kontrollierten Change-Freezes demonstriert Business-Continuity-Management in der Praxis. GitLab Professional Services organisiert Migrationen in Wellen von 200-300 Projekten, um Komplexität zu managen und API-Rate-Limits zu respektieren.\n\n## Überblick\n\nGitLab bietet [Congregate](https://gitlab.com/gitlab-org/professional-services-automation/tools/migration/congregate/) (maintained by GitLab Professional Services) und [eingebauten Git-Repository-Import](https://docs.gitlab.com/user/project/import/repo_by_url/) für Migrationen von Azure DevOps (ADO). Beide Optionen unterstützen Repository-basierte oder Bulk-Migration und erhalten Git-Commit-History, Branches und Tags. Mit Congregate werden zusätzliche Assets wie Wikis, Work Items, CI/CD-Variablen, Container-Images, Packages und Pipelines migriert (siehe [Feature-Matrix](https://gitlab.com/gitlab-org/professional-services-automation/tools/migration/congregate/-/blob/master/customer/ado-migration-features-matrix.md)).\n\nEnterprises folgen typischerweise einem mehrstufigen Ansatz:\n\n- Repositories von ADO zu GitLab migrieren (Congregate oder eingebauter Import)\n- Pipelines von Azure Pipelines zu GitLab CI/CD migrieren\n- Verbleibende Assets wie Boards, Work Items und Artifacts zu GitLab Issues, Epics und Package/Container Registries migrieren\n\nMehrstufige Migrationsphasen (siehe [Diagramm](https://about.gitlab.com/blog/migration-from-azure-devops-to-gitlab/#overview)):\n\n- Prerequisites (IdP, Runners, Change Management)\n- Migration Phase (Source Code, History, Work Items)\n- Post-Migration (Pipelines, Assets, Security)\n\n## Migration planen\n\n**Zentrale Planungsfragen:**\n\n- Wie schnell muss die Migration abgeschlossen werden?\n- Was genau wird migriert?\n- Wer führt die Migration durch?\n- Welche Organisationsstruktur wird in GitLab benötigt?\n- Welche Einschränkungen, Limitierungen oder Fallstricke müssen berücksichtigt werden?\n\nDie Timeline bestimmt weitgehend den Migrationsansatz. Identifizierung von Champions oder Teams mit ADO- und GitLab-Erfahrung unterstützt Adoption und Guidance.\n\n**Inventar erstellen:**\n\nDas GitLab Professional Services [Evaluate](https://gitlab.com/gitlab-org/professional-services-automation/tools/utilities/evaluate#beta-azure-devops)-Tool produziert ein vollständiges Inventar der Azure DevOps Organisation: Repositories, PR-Counts, Contributors, Pipelines, Work Items, CI/CD-Variablen. Bei Professional Services Engagements wird dieser Report mit Engagement Manager oder Technical Architect geteilt für Migrationsplanung.\n\nMigrations-Timing wird primär bestimmt durch Pull-Request-Count, Repository-Größe und Contribution-Menge. Beispiel: 1.000 kleine Repositories mit wenigen PRs migrieren schneller als wenige Repositories mit Zehntausenden PRs. Inventar-Daten ermöglichen Aufwands-Schätzung und Test-Run-Planung.\n\nIn Professional Services Engagements werden Migrationen in Wellen von 200-300 Projekten organisiert, um Komplexität zu managen und API-Rate-Limits zu respektieren (sowohl [GitLab](https://docs.gitlab.com/security/rate_limits/) als auch [ADO](https://learn.microsoft.com/en-us/azure/devops/integrate/concepts/rate-limits?view=azure-devops)).\n\n**Tool-Auswahl:**\n\nGitLabs [eingebauter Repository-Importer](https://docs.gitlab.com/user/project/import/repo_by_url/) migriert Git-Repositories (Commits, Branches, Tags) einzeln. Congregate erhält Pull Requests (in GitLab: Merge Requests), Kommentare und Metadata; der eingebaute Import fokussiert auf Git-Daten (History, Branches, Tags).\n\nAssets die typischerweise separate Migration oder manuelle Neuerstellung erfordern:\n\n- Azure Pipelines → GitLab CI/CD Pipelines (siehe [CI/CD YAML](https://docs.gitlab.com/ci/yaml/) oder [CI/CD Components](https://docs.gitlab.com/ci/components/)). Alternativ: AI-basierte Pipeline-Konvertierung in Congregate.\n- Work Items und Boards → GitLab Issues, Epics, Issue Boards\n- Artifacts, Container-Images (ACR) → GitLab Package/Container Registry\n- Service Hooks, externe Integrationen → in GitLab neu erstellen\n\n[Permissions-Modelle](https://docs.gitlab.com/user/permissions/) unterscheiden sich zwischen ADO und GitLab. Permissions-Mapping planen statt exakter Preservation zu erwarten.\n\n**Organisationsstruktur in GitLab:**\n\nEmpfohlener Ansatz: ADO-Organisationen auf GitLab-Groups mappen (nicht viele kleine Groups). Migration als Gelegenheit nutzen, GitLab-Struktur zu rationalisieren (siehe [Struktur-Diagramm](https://about.gitlab.com/blog/migration-from-azure-devops-to-gitlab/#planning-your-migration)):\n\n- **ADO Organization** → GitLab Top-level Group\n- **ADO Project** → GitLab Subgroup (optional)\n- **ADO Repository** → GitLab Project\n\nWeitere Empfehlungen:\n\n- Subgroups und Project-Level-Permissions für verwandte Repositories nutzen\n- Zugriff über GitLab Groups und Group-Membership managen\n- GitLab [Permissions](https://docs.gitlab.com/ee/user/permissions.html) und [SAML Group Links](https://docs.gitlab.com/user/group/saml_sso/group_sync/) für Enterprise-RBAC-Modell evaluieren\n\n**ADO Work Items Migration:**\n\nADO Boards und Work Items mappen zu GitLab Issues, Epics und Issue Boards. ADO Epics und Features werden GitLab Epics. Andere Work-Item-Typen (User Stories, Tasks, Bugs) werden project-scoped Issues. Standard-Felder bleiben erhalten; ausgewählte Custom Fields können migriert werden. Parent-Child-Relationships bleiben erhalten. Links zu Pull Requests werden zu Merge-Request-Links konvertiert.\n\n![Migration eines Work Items zu GitLab Issue](https://res.cloudinary.com/about-gitlab-com/image/upload/v1764769188/ztesjnxxfbwmfmtckyga.png)\n\n**Pipelines-Migration:**\n\nCongregate bietet [AI-basierte Konvertierung](https://gitlab.com/gitlab-org/professional-services-automation/tools/migration/congregate/-/merge_requests/1298) für multi-stage YAML-Pipelines von Azure DevOps zu GitLab CI/CD. Die automatisierte Konvertierung funktioniert optimal für einfache Single-File-Pipelines und liefert einen funktionalen Ausgangspunkt, nicht ein produktionsreifes `.gitlab-ci.yml`-File. Das Tool generiert funktional äquivalente GitLab-Pipelines zur weiteren Optimierung.\n\n- Konvertiert Azure Pipelines YAML zu `.gitlab-ci.yml` automatisch\n- Geeignet für straightforward Single-File-Pipeline-Konfigurationen\n- Liefert Boilerplate zur Migrations-Beschleunigung, nicht finales Production-Artifact\n- Erfordert Review und Anpassung für komplexe Szenarien, Custom Tasks oder Enterprise-Requirements\n- Unterstützt keine Azure DevOps Classic Release Pipelines\n\nRepository-Owner sollten [GitLab CI/CD Dokumentation](https://docs.gitlab.com/ci/) konsultieren für weitere Pipeline-Optimierung nach initialer Konvertierung.\n\n## Migrationen durchführen\n\nNach der Planung werden Migrationen in Stages durchgeführt, beginnend mit Trial Runs. Trial Migrations identifizieren organisations-spezifische Issues frühzeitig und ermöglichen Duration-Messung, Outcome-Validierung und Approach-Finetuning vor Production.\n\n**Was Trial Migrations validieren:**\n\n- Ob Repository und Assets erfolgreich migrieren (History, Branches, Tags; plus MRs/Comments bei Congregate)\n- Ob Destination sofort nutzbar ist (Permissions, Runners, CI/CD-Variablen, Integrationen)\n- Wie lange jeder Batch benötigt für Schedule- und Stakeholder-Expectations\n\n**Downtime-Guidance:**\n\nGitLabs eingebauter Git-Import und Congregate erfordern inhärent keine Downtime. Für Production-Wellen: Changes in ADO freezen (Branch-Protections oder Read-only), um verpasste Commits, PR-Updates oder mid-migration Work Items zu vermeiden. Trial Runs erfordern keine Freezes.\n\n**Batching-Guidance:**\n\nTrial-Batches back-to-back durchführen für kürzere elapsed Time. Teams validieren Results asynchron. Geplante Group/Subgroup-Struktur für Batch-Definition nutzen und API-Rate-Limits respektieren.\n\n**Empfohlene Schritte:**\n\n1. Test-Destination in GitLab erstellen (GitLab.com: dedicated Group/Namespace; Self-managed: Top-level Group)\n2. Authentication vorbereiten (Azure DevOps PAT, GitLab Personal Access Token mit api und read_repository Scopes)\n3. Trial Migrations durchführen (Repos only: eingebauter Import; Repos + PRs/MRs: Congregate)\n4. Post-Trial Follow-up (Repo-History, Branches, Tags, Merge Requests, Issues/Epics, Labels, Relationships verifizieren)\n5. Permissions/Roles, Protected Branches, Runners/Tags, Variables/Secrets, Integrations/Webhooks prüfen\n6. Pipelines (`.gitlab-ci.yml`) oder konvertierte Pipelines validieren\n7. User-Validierung für Functionality und Data-Fidelity\n8. Production-Migrationen in Waves durchführen (Change-Freezes in ADO erzwingen, Progress und Logs monitoren)\n\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/ibIXGfrVbi4?si=ZxOVnXjCF-h4Ne0N\" frameborder=\"0\" allowfullscreen=\"true\">\u003C/iframe>\n\u003C/figure>\n\n## Zentrale ADO-zu-GitLab-Mappings\n\nWichtigste Struktur-Mappings für Migrationsplanung:\n\n- **ADO Organization** → GitLab Group (Top-level Namespace)\n- **ADO Project** → GitLab Group oder Subgroup (Permissions-Boundary)\n- **ADO Repository** → GitLab Project (Git-Repo plus Issues, CI/CD, Wiki)\n- **Pull Request** → Merge Request (Code Review, Approvals)\n- **Azure Pipelines** → GitLab CI/CD (`.gitlab-ci.yml`)\n- **Agent Pools** → GitLab Runners (Job-Execution)\n- **Work Items** → GitLab Issues/Epics (Planning-Funktionalität)\n- **Variable Groups** → CI/CD Variables (Project/Group/Instance Level)\n\nFür vollständige Terminologie-Referenztabelle mit allen Mappings siehe [englische Originalversion](https://about.gitlab.com/blog/migration-from-azure-devops-to-gitlab/).\n\n## Professional Services Migrationsmuster\n\nGitLab Professional Services nutzt bewährte Muster für Enterprise-Migrationen:\n\n**Systematische Planung:** Evaluate-Tool liefert vollständiges Inventar (Repositories, PRs, Contributors, Pipelines, Work Items). Klassifikation nach Komplexität (Work Items = Planning-Team-Involvement; Pipelines = Conversion-Requirements) ermöglicht Timeline-Schätzung und Batch-Definition.\n\n**Controlled Execution:** Wellen von 200-300 Projekten managen Komplexität und respektieren API-Rate-Limits. Trial-Migrationen vor Production-Waves identifizieren Issues frühzeitig. Change-Freezes in ADO während Production-Wellen vermeiden mid-migration Updates.\n\n**Risikominimierung:** Multi-Phase-Ansatz (Prerequisites → Migration → Post-migration) mit Validierungs-Checkpoints an jeder Phase. Trial-Runs ermöglichen asynchrone Team-Validierung ohne Production-Impact.\n\n## Praktische Implementierung\n\nFür vollständige Implementierungsdetails, Konfigurationsbeispiele, Pipeline-Konvertierungs-Patterns und detaillierte Post-Migration-Checklisten siehe [englische Originalversion](https://about.gitlab.com/blog/migration-from-azure-devops-to-gitlab/).\n\nWeitere Professional Services Ressourcen:\n\n- [Professional Services Full Catalog](https://about.gitlab.com/professional-services/catalog/)\n- [Congregate Migration Tool](https://gitlab.com/gitlab-org/professional-services-automation/tools/migration/congregate/)\n- [Evaluate Inventory Tool](https://gitlab.com/gitlab-org/professional-services-automation/tools/utilities/evaluate)\n","2025-12-03","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749658924/Blog/Hero%20Images/securitylifecycle-light.png",[680,681],"Evgeny Rudinsky","Michael Leopard","Migration von Azure DevOps zu GitLab systematisch planen","Professional Services Migrationsansatz mit mehrstufiger Struktur, 200-300 Projekt-Wellen und systematischem Risikomanagement für Enterprise-Migrationen.",{"featured":28,"template":13,"slug":685},"migration-from-azure-devops-to-gitlab",{"content":687,"config":698},{"heroImage":688,"title":689,"description":690,"authors":691,"date":693,"category":9,"tags":694,"body":697},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1764108112/tyntnsy3xotlmehtnfkb.png","Wie wir die größte GitLab-Instanz 12-mal täglich bereitstellen","Systematische Deployment-Pipeline mit mehrstufigen Rollouts, Canary-Strategie (5% Traffic) und Datenbank-Migrationen für Millionen Entwickler(innen) weltweit.",[692],"John Skarbek","2025-12-01",[695,696],"product","inside GitLab","GitLab führt täglich bis zu 12 Code-Bereitstellungen auf der weltweit größten GitLab-Instanz – GitLab.com – ohne Ausfallzeiten durch. Diese Bereitstellungen nutzen GitLabs eigene CI/CD-Plattform und betreffen Millionen Entwickler(innen) weltweit. Die hohe Bereitstellungsfrequenz dient als primäres Qualitätstor und Belastungstest. Organisationen, die auf GitLab für ihre DevOps-Workflows setzen, nutzen eine auf der eigenen Infrastruktur im Enterprise-Maßstab bewährte Plattform.\n\nIn regulierten Branchen wie dem Finanzwesen und der Automobilproduktion sind Zero-Downtime-Bereitstellungen keine Option, sondern Voraussetzung. Die NIS2-Richtlinie fordert in Artikel 21 systematische Risikoanalyse und Business-Continuity-Management – genau das, was GitLab.coms progressive Rollout-Strategie in der Praxis demonstriert. Durch mehrstufige Validierung mit isoliertem Canary-Traffic (5% aller Anfragen) werden potenzielle Probleme erkannt, bevor Millionen Nutzer(innen) betroffen sind.\n\n## Die Herausforderung: Frequenz trifft Skalierung\n\n**Für GitLab:** Bereitstellungsfrequenz ist geschäftskritisch. Schnelle Deployment-Zyklen ermöglichen Reaktion auf Kundenfeedback innerhalb von Stunden, sofortige Security-Patches und Validierung neuer Features in Production vor Skalierung.\n\n**Für Kund(inn)en:** Jede Bereitstellung auf GitLab.com validiert die Deployment-Praktiken, die GitLab seinen Nutzer(inne)n empfiehlt. Features werden auf der weltweit größten GitLab-Instanz getestet, bevor sie Kundenumgebungen erreichen. Dies liefert:\n\n* Neueste Features sofort verfügbar (Stunden statt Wochen)\n* Bewährte Zuverlässigkeit im Maßstab\n* Zero-Downtime-Bereitstellungen garantieren durchgängigen Zugriff\n* Dokumentation basiert auf tatsächlichen Production-Praktiken\n\n## Code-to-Production-Architektur\n\nDie Deployment-Pipeline durchläuft strukturierte Phasen, wobei jede Phase als Checkpoint auf dem Weg zur Production-Bereitstellung fungiert:\n\n```mermaid\n    graph TD\n        A[Code Proposed] --> B[Merge Request Created]\n        B --> C[Pipeline Triggered]\n        C --> D[Build & Test]\n        D --> E{Spec/Integration/QA Tests Pass?}\n        E -->|No| F[Feedback Loop]\n        F --> B\n        E -->|Yes| G[Merge to default branch]\n        G -->|Periodically| H[Auto-Deploy Branch]\n\n        subgraph \"Deployment Pipeline\"\n            H --> I[Package Creation]\n            I --> K[Canary Environment]\n            K --> L[QA Validation]\n            L --> M[Main Environment]\n\n        end\n```\n\n## Progressive Rollout-Strategie\n\n### Build und Paket-Erstellung\n\nGitLab erstellt sowohl Omnibus-Pakete als auch Cloud Native GitLab (CNG) Images. Omnibus-Pakete werden auf der Gitaly-Flotte bereitgestellt (Git-Storage-Layer), während CNG-Images alle anderen Komponenten als containerisierte Workloads ausführen. Eine geplante Pipeline sucht regelmäßig nach dem jüngsten Commit mit erfolgreicher Pipeline und erstellt daraus einen Auto-Deploy-Branch.\n\n```mermaid\n    graph LR\n        A[Create branch] --> B[Build]\n        B --> C[Choose Built package]\n        C --> D[Start Deploy Pipeline]\n```\n\n### Canary-Strategie und mehrstufige Validierung\n\nGitLabs QA-Prozess arbeitet Hand in Hand mit der Canary-Strategie durch umgebungsbasierte Validierung. [Etwa 5% des gesamten Traffics durchlaufen die Canary-Stage](https://handbook.gitlab.com/handbook/engineering/infrastructure/environments/canary-stage/#environments-canary-stage). Dieser Ansatz erhöht die Komplexität von Datenbankmigrationen, gewährleistet aber nahtlose Bereitstellung eines zuverlässigen Produkts.\n\n**Progressive Rollout-Phasen:**\n\n1. **Staging Canary:** Initiale Validierungsumgebung\n2. **Production Canary:** Limitierter Production-Traffic\n3. **Staging Main:** Vollständige Staging-Umgebung\n4. **Production Main:** Vollständiger Production-Rollout\n\n```mermaid\n    graph TD\n        C[Staging Canary Deploy]\n        C --> D[QA Smoke Main Stage Tests]\n        C --> E[QA Smoke Canary Stage Tests]\n        D --> F\n        E --> F{Tests Pass?}\n        F -->|Yes| G[Production Canary Deploy]\n        G --> S[QA Smoke Main Stage Tests]\n        G --> T[QA Smoke Canary Stage Tests]\n        F -->|No| H[Issue Creation]\n        H --> K[Fix & Backport]\n        K --> C\n\n        S --> M[Canary Traffic Monitoring]\n        T --> M[Canary Traffic Monitoring baking period]\n        M --> U[Production Safety Checks]\n        U --> N[Staging Main]\n        N --> V[Production Main]\n```\n\nQA-Validierung erfolgt an mehreren Checkpoints: nach jeder Canary-Bereitstellung und nach Post-Deploy-Migrationen. Weitere Details zur [GitLab-Teststrategie](https://handbook.gitlab.com/handbook/engineering/testing/) finden sich im Handbook.\n\n## Deployment-Pipeline-Stages\n\nGitLab.com repräsentiert reale Deployment-Komplexität im Maßstab. Als größte bekannte GitLab-Instanz nutzen Bereitstellungen denselben offiziellen GitLab Helm Chart und dasselbe Linux-Paket wie Kund(inn)en. Mehr zur [GitLab.com-Architektur](https://handbook.gitlab.com/handbook/engineering/infrastructure/production/architecture/#gitlab-com-architecture) im Handbook.\n\n**Dogfooding im Maßstab:** GitLab nutzt dieselben Verfahren, die für [Zero-Downtime-Upgrades](https://docs.gitlab.com/update/zero_downtime/) dokumentiert sind. Was bei GitLab nicht reibungslos funktioniert, wird Kund(inn)en nicht empfohlen.\n\nFolgende Stages laufen für alle Environment- und Stage-Upgrades:\n\n```mermaid\n    graph LR\n        a[prep] --> c[Regular Migrations - Canary stage only]\n        a --> f[Assets - Canary stage only]\n        c --> d[Gitaly]\n        d --> k8s\n\n        subgraph subGraph0[\"VM workloads\"]\n          d[\"Gitaly\"]\n        end\n\n        subgraph subGraph1[\"Kubernetes workloads\"]\n          k8s[\"k8s\"]\n        end\n\n        subgraph fleet[\"fleet\"]\n          subGraph0\n          subGraph1\n        end\n```\n\n**Stage-Details:**\n\n* **Prep:** Validiert Deployment-Bereitschaft und führt Pre-Deployment-Checks durch\n* **Migrations:** Führt reguläre Datenbankmigrationen aus (nur Canary-Stage)\n* **Assets:** Lädt statische Assets in GCS-Bucket hoch (nur Canary-Stage)\n* **Gitaly:** Aktualisiert Gitaly-VM-Storage-Layer via Omnibus-Paket\n* **Kubernetes:** Deployed containerisierte GitLab-Komponenten via Helm Chart\n\n### Multi-Version-Kompatibilität: Die versteckte Herausforderung\n\nWährend der Bereitstellung existiert eine Zeitspanne, in der das Datenbankschema dem Code voraus ist, den die Main-Stage kennt. Dies geschieht, weil die Canary-Stage bereits neuen Code deployed und reguläre Datenbankmigrationen ausführt, während die Main-Stage noch die vorherige Code-Version ausführt.\n\n**Beispiel:** Bei Hinzufügen eines neuen `merge_readiness`-Felds zu Merge Requests laufen manche Server mit Code, der dieses Feld erwartet, während andere nichts davon wissen. Schlechte Handhabung würde GitLab.com für Millionen Nutzer(innen) unterbrechen. Gute Handhabung bleibt unbemerkt.\n\nMit wenigen Ausnahmen läuft die Mehrheit der Services für eine gewisse Zeit in leicht neuerer Version in Canary. Diese Szenarien sind transiente Zustände, können aber mehrere Stunden oder Tage in Live-Production-Umgebung persistieren. Daher müssen sie mit derselben Sorgfalt wie permanente Zustände behandelt werden.\n\n## Datenbank-Operationen\n\nDatenbankmigrationen stellen eine besondere Herausforderung im Canary-Deployment-Modell dar. Schemaänderungen müssen neue Features unterstützen und gleichzeitig Rollback-Fähigkeit bewahren:\n\n* **Regular Migrations:** Laufen während Canary-Stage, rückwärtskompatibel, nur reversible Änderungen\n* **Post-Deploy-Migrations:** \"Point of no Return\"-Migrationen, die erst nach mehreren erfolgreichen Bereitstellungen laufen\n\n```mermaid\n    graph LR\n        A[Regular Migrations] --> B[Canary Stage Deploy]\n        B --> C[Main Stage Deploy]\n        C --> D[Post Deploy Migrations]\n```\n\nPost-Deploy-Migrationen enthalten oft Änderungen, die nicht einfach rückgängig gemacht werden können – Datentransformationen, Column-Drops oder strukturelle Änderungen, die ältere Code-Versionen unterbrechen würden. Durch Ausführung nach Erlangung von Vertrauen durch mehrere erfolgreiche Bereitstellungen wird sichergestellt:\n\n1. Neuer Code ist stabil, Rollback unwahrscheinlich\n2. Performance-Charakteristiken in Production verstanden\n3. Edge Cases erkannt und adressiert\n4. Blast Radius minimiert, falls etwas schiefgeht\n\nDieser Ansatz bietet optimale Balance: schnelle Feature-Bereitstellung durch Canary-Releases bei gleichzeitiger Rollback-Fähigkeit bis Vertrauen in Deployment-Stabilität besteht.\n\n**Expand-Migrate-Contract-Pattern:** Datenbank-, Frontend- und Anwendungskompatibilitäts-Änderungen folgen einem sorgfältig orchestrierten dreiphasigen Ansatz:\n\n1. **Expand:** Neue Strukturen hinzufügen, alte funktional belassen\n2. **Migrate:** Neuen Application-Code deployen, der neue Strukturen nutzt\n3. **Contract:** Alte Strukturen in Post-Deploy-Migrationen entfernen\n\n**Beispiel für `merge_readiness`-Column:**\n\n1. **Expand:** Neue Column mit Default-Value hinzufügen; bestehender Code ignoriert sie\n2. **Migrate:** Code deployen, der neue Column liest und schreibt, alten Ansatz weiter unterstützt\n3. **Contract:** Nach mehreren erfolgreichen Bereitstellungen alte Column in Post-Deploy-Migration entfernen\n\nAlle Datenbank-Operationen, Application-Code und Frontend-Code unterliegen Guidelines, dokumentiert in der [Multi-Version-Compatibility-Dokumentation](https://docs.gitlab.com/development/multi_version_compatibility/).\n\n## Ergebnisse und Auswirkungen\n\n**Für GitLab:**\n\n* Bis zu 12 Bereitstellungen täglich auf GitLab.com\n* Zero-Downtime-Bereitstellungen für Millionen Entwickler(innen)\n* Security-Patches erreichen Production innerhalb von Stunden\n* Neue Features in Production im Maßstab validiert vor General Availability\n\n**Für Kunden:**\n\n* Bewährte Deployment-Patterns für eigene Anwendungen\n* Features auf weltweit größter GitLab-Instanz getestet vor Erreichen der Kundenumgebung\n* Dokumentation reflektiert tatsächliche Production-Praktiken\n* Vertrauen, dass GitLabs empfohlene Upgrade-Prozeduren in jedem Maßstab funktionieren\n\n## Erkenntnisse für Engineering-Teams\n\nDie hier beschriebenen Muster – von Expand-Migrate-Contract für Datenbankmigrationen bis zur Multi-Version-Kompatibilität – sind auf kleinere Deployments übertragbar. Nicht jede Organisation benötigt 12 Bereitstellungen täglich, aber die systematische Herangehensweise an Rollback-Fähigkeit und Validierungspunkte gilt unabhängig von der Skalierung.\n\nGitLabs Deployment-Pipeline repräsentiert ein ausgereiftes System, das Deployment-Geschwindigkeit mit operationaler Zuverlässigkeit ausbalanciert. Das progressive Deployment-Modell, umfassende Testing-Integration und robuste Rollback-Fähigkeiten bieten Grundlage für zuverlässige Software-Auslieferung im Maßstab.\n\n**Zentrale Überlegungen für Engineering-Teams:**\n\n* **Automatisiertes Testing:** Umfassende Test-Coverage durch Deployment-Pipeline\n* **Progressive Rollouts:** Gestufte Bereitstellungen zur Risikominimierung und schnellen Wiederherstellung\n* **Monitoring-Integration:** Umfassende Observability über alle Deployment-Stages\n* **Incident Response:** Schnelle Erkennungs- und Lösungsfähigkeiten für Deployment-Probleme\n\nGitLabs Architektur demonstriert, wie moderne CI/CD-Systeme Komplexität großskaliger Bereitstellungen managen und gleichzeitig Geschwindigkeit für wettbewerbsfähige Software-Entwicklung bewahren.\n\n## Vollständige technische Dokumentation\n\nDieser Artikel beschreibt die Deployment-Patterns und systematische Herangehensweise für GitLab.com. Für vollständige Implementierungsdetails, spezifische Konfigurationsbeispiele und tiefergehende technische Architekturbeschreibungen siehe die [englische Originalversion](https://about.gitlab.com/blog/continuously-deploying-the-largest-gitlab-instance/).\n\nWeitere Dokumentation zu Auto-Deploy und Verfahren:\n\n* [Engineering Deployments](https://handbook.gitlab.com/handbook/engineering/deployments-and-releases/deployments/)\n* [Release Procedural Documentation](https://gitlab-org.gitlab.io/release/docs/)\n* [GitLab Environment Toolkit](https://gitlab.com/gitlab-org/gitlab-environment-toolkit)\n\n## Weitere Ressourcen\n\n* [How we decreased GitLab repo backup times from 48 hours to 41 minutes](https://about.gitlab.com/blog/how-we-decreased-gitlab-repo-backup-times-from-48-hours-to-41-minutes/)\n* [How we supercharged GitLab CI statuses with WebSockets](https://about.gitlab.com/blog/how-we-supercharged-gitlab-ci-statuses-with-websockets/)\n* [How we reduced MR review time with Value Stream Management](https://about.gitlab.com/blog/how-we-reduced-mr-review-time-with-value-stream-management/)",{"featured":28,"template":13,"slug":699},"continuously-deploying-the-largest-gitlab-instance",{"content":701,"config":714},{"title":702,"description":703,"authors":704,"heroImage":706,"date":707,"category":9,"tags":708,"body":713},"MR-Review-Zeit mit Value Stream Management reduzieren","GitLab Engineering nutzt VSM zur Identifikation von Engpässen im MR-Review-Prozess. Systematische Analyse mit Custom Stages.",[705],"Haim Snir","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097876/Blog/Hero%20Images/Blog/Hero%20Images/REFERENCE%20-%20display%20preview%20for%20blog%20images%20%282%29_2pKf8RsKzAaThmQfqHIaa7_1750097875817.png","2025-10-30",[695,709,710,711,712],"features","DevSecOps platform","workflow","solutions architecture","Das GitLab Engineering-Team nutzt die eigenen Produkte intern – eine Praxis, die im Englischen als \"Dogfooding\" bezeichnet wird. Diese Selbstnutzung hat zu Verbesserungen bei der Beschleunigung der Software-Delivery-Zyklen für Kunden geführt. Dieser Artikel beleuchtet einen spezifischen Anwendungsfall, bei dem [GitLab Value Stream Management (VSM)](https://about.gitlab.com/solutions/value-stream-management/) Verbesserungen für unser Engineering-Team ermöglicht hat. Es wird gezeigt, wie VSM dabei half, zwei zentrale Herausforderungen anzugehen: die Messung des Wegs von der Idee bis zur Fertigstellung eines Merge Requests und die Optimierung der Deployment-Workflows.\n\nValue Stream Management ist in der deutschen Industrie als Wertstromanalyse etabliert – insbesondere in der Fertigung und Automobilbranche wird diese Lean-Methode zur Identifikation von Verschwendung eingesetzt. GitLabs VSM-Funktionen übertragen diesen systematischen Ansatz auf Software-Entwicklungsprozesse und ermöglichen die Unterscheidung zwischen wertschöpfenden und nicht-wertschöpfenden Aktivitäten im Entwicklungsworkflow.\n\n## Die Herausforderung: Engpässe in MR-Reviews identifizieren\n\nTrotz gut definierter Workflows stellte ein Team fest, dass Merge Requests länger als erwartet brauchten, um geprüft und gemerged zu werden. Die Herausforderung bestand nicht nur in den Verzögerungen selbst, sondern darin zu verstehen, wo im Review-Prozess diese Verzögerungen auftraten und warum.\n\nDas Ziel des Teams war klar:\n\n- Identifizieren, wo Zeit vom initialen Konzept bis zum finalen Merge eines MR verbracht wurde\n- Spezifische Engpässe im Review-Prozess lokalisieren\n- Verstehen, wie MR-Größe, Komplexität oder Dokumentationsqualität die Review-Zeit beeinflussen\n\n## Der Ansatz: MR-Review-Zeit in GitLab Value Stream Analytics messen\n\nValue Stream Analytics (VSA) ermöglicht es Organisationen, ihren gesamten Workflow von der Idee bis zur Auslieferung abzubilden und dabei zwischen wertschöpfenden Aktivitäten (VA) und nicht-wertschöpfenden Aktivitäten (NVA) im Prozessfluss zu unterscheiden. Durch die Berechnung des Verhältnisses von wertschöpfender Zeit zur gesamten Lead Time kann das Team verschwenderische Aktivitäten identifizieren, die zu Verzögerungen bei MR-Reviews führen.\n\nUm die notwendigen Metriken zu erhalten, passte das Team GitLab VSA an, um bessere Sichtbarkeit in den MR-Review-Prozess zu erhalten.\n\n### 1. Custom Stage für MR-Review einrichten\n\nDas Team fügte eine [neue Custom Stage](https://docs.gitlab.com/ee/user/group/value_stream_analytics/#value-stream-stage-events) in VSA mit dem Namen **Review Time to Merge** hinzu, um spezifisch die Zeit vom ersten Zuweisen eines Reviewers bis zum Merge des MR zu tracken.\n\n- Start-Event: MR first reviewer assigned\n- End-Event: MR merged\n\nDurch die Definition dieser Stage begann VSA, die Dauer des MR-Review-Prozesses zu messen und lieferte präzise Daten darüber, wo Zeit verbracht wurde.\n\n![Defining stage of VSA](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097884/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097883929.png)\n\n### 2. Total Time Chart für Klarheit nutzen\n\nMit der Custom Stage eingerichtet, nutzte das Team das [**Total Time Chart** auf der VSA Overview-Seite](https://about.gitlab.com/blog/value-stream-total-time-chart/) (**Analyze > Value Stream**), um zu visualisieren, wie viel Zeit während der neuen MR-Review-Stage verbracht wurde. Durch den Vergleich der Werte, die durch jeden Bereich im Chart dargestellt wurden, konnte das Team schnell identifizieren, wie diese Stage zur gesamten Software-Delivery-Lifecycle-Zeit (SDLC) beitrug.\n\n![total time chart for VSA](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097884/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097883930.png)\n\n### 3. Für tiefere Erkenntnisse detailliert analysieren\n\nUm spezifische Verzögerungen zu untersuchen, nutzte das Team die **Stage Navigation Bar**, um tiefer in die MR-Review-Stage einzutauchen. Diese Ansicht ermöglichte:\n\n- MRs nach Review-Zeit sortieren: Die Stage-Tabelle zeigte alle zugehörigen MRs sortiert nach Review-Dauer, sodass langsame MRs leicht erkennbar waren\n- Individuelle MRs analysieren: Für jeden MR konnte das Team Faktoren wie Verzögerungen bei der Reviewer-Zuweisung, mehrere Feedback-Runden, Leerlaufzeit nach Approval und MR-Größe/Komplexität untersuchen\n\n## Das Ergebnis: Umsetzbare Erkenntnisse und Verbesserungen\n\nDurch die Anpassung von VSA zur Verfolgung der [MR-Review-Zeit](https://docs.gitlab.com/user/project/merge_requests/reviews/) deckte das Team mehrere zentrale Erkenntnisse auf:\n\n- **Verzögerungen bei Reviewer-Zuweisung:** Einige MRs erfuhren Verzögerungen, weil Reviewer spät zugewiesen wurden oder Reviewer zu viele MRs in ihrer Queue hatten\n- **Langsame Review-Start-Zeiten:** Selbst nach Zuweisung lagen bestimmte MRs untätig, bevor Reviews begannen – oft aufgrund von Kontextwechseln oder konkurrierenden Prioritäten\n- **Mehrere Feedback-Schleifen:** Größere MRs erforderten oft mehrere Feedback-Runden, was die Review-Zeit erheblich verlängerte\n- **Leerlaufzeit nach Approval:** Einige MRs wurden approved, aber nicht zeitnah gemerged – oft aufgrund von Deployment-Koordinationsproblemen\n\nFür den Engineering Manager im Team erwies sich VSA als wertvoll für die Verwaltung des Team-Workflows: \"Ich habe VSA genutzt, um zu begründen, wo wir Zeit bei der MR-Fertigstellung verbrachten. Wir haben VSA auf unsere Bedürfnisse angepasst, und es war sehr hilfreich für unsere Untersuchungen nach Verbesserungsmöglichkeiten.\"\n\nAus dieser Dogfooding-Erfahrung entwickeln wir nun eine wichtige Erweiterung zur Verbesserung der Sichtbarkeit in den Review-Prozess. Wir fügen ein neues Event zu VSA hinzu – [Merge request last approved at](https://gitlab.com/gitlab-org/gitlab/-/issues/503754) – das eine Stage erzeugt, die MR-Review-Schritte noch granularer aufschlüsselt.\n\n## Die Kraft datengestützter Entscheidungen\n\nDurch die Nutzung von GitLabs VSA haben wir nicht nur Engpässe identifiziert – wir erhielten umsetzbare Erkenntnisse, die zu Verbesserungen bei der MR-Review-Zeit und der allgemeinen Entwickler-Produktivität führten. Wir optimierten Merge-Request-Review-Zyklen und erhöhten den Entwickler-Durchsatz, was unser Commitment zu kontinuierlicher Verbesserung durch Messung bestätigt.\n\n> Möchtest du erfahren, wie VSA deinem Team helfen kann? [Starte eine kostenlose GitLab Ultimate-Testversion](https://about.gitlab.com/free-trial/), passe deine Value Streams an und sieh, wie du Verbesserungen im gesamten SDLC für deine Teams erreichen kannst. [Teile dann dein Feedback und deine Erfahrungen in diesem Issue](https://gitlab.com/gitlab-org/gitlab/-/issues/520962).\n\n## Weiterführende Informationen\n\n- [Optimize value stream efficiency to do more with less, faster](https://about.gitlab.com/the-source/platform/optimize-value-stream-efficiency-to-do-more-with-less-faster/)\n- [New Scheduled Reports Generation tool simplifies value stream management](https://about.gitlab.com/blog/new-scheduled-reports-generation-tool-simplifies-value-stream-management/)\n- [Value stream analytics documentation](https://docs.gitlab.com/user/group/value_stream_analytics/)\n- [Value stream management: Total Time Chart simplifies top-down optimization flow](https://about.gitlab.com/blog/value-stream-total-time-chart/)\n",{"slug":715,"featured":12,"template":13},"how-we-reduced-mr-review-time-with-value-stream-management",{"promotions":717},[718,732,744],{"id":719,"categories":720,"header":722,"text":723,"button":724,"image":729},"ai-modernization",[721],"ai-ml","Is AI achieving its promise at scale?","Quiz will take 5 minutes or less",{"text":725,"config":726},"Get your AI maturity score",{"href":727,"dataGaName":728,"dataGaLocation":243},"/assessments/ai-modernization-assessment/","modernization assessment",{"config":730},{"src":731},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1772138786/qix0m7kwnd8x2fh1zq49.png",{"id":733,"categories":734,"header":736,"text":723,"button":737,"image":741},"devops-modernization",[695,735],"devsecops","Are you just managing tools or shipping innovation?",{"text":738,"config":739},"Get your DevOps maturity score",{"href":740,"dataGaName":728,"dataGaLocation":243},"/assessments/devops-modernization-assessment/",{"config":742},{"src":743},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1772138785/eg818fmakweyuznttgid.png",{"id":745,"categories":746,"header":748,"text":723,"button":749,"image":753},"security-modernization",[747],"security","Are you trading speed for security?",{"text":750,"config":751},"Get your security maturity score",{"href":752,"dataGaName":728,"dataGaLocation":243},"/assessments/security-modernization-assessment/",{"config":754},{"src":755},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1772138786/p4pbqd9nnjejg5ds6mdk.png",{"header":757,"blurb":758,"button":759,"secondaryButton":764},"Beginne noch heute, schneller zu entwickeln","Entdecke, was dein Team mit der intelligenten Orchestrierungsplattform für DevSecOps erreichen kann.\n",{"text":760,"config":761},"Kostenlosen Test starten",{"href":762,"dataGaName":49,"dataGaLocation":763},"https://gitlab.com/-/trial_registrations/new?glm_content=default-saas-trial&glm_source=about.gitlab.com/","feature",{"text":51,"config":765},{"href":53,"dataGaName":54,"dataGaLocation":763},1772652049945]