[{"data":1,"prerenderedAt":764},["ShallowReactive",2],{"/de-de/blog/ultimate-guide-to-ci-cd-fundamentals-to-advanced-implementation":3,"navigation-de-de":43,"banner-de-de":446,"footer-de-de":456,"blog-post-authors-de-de-Sandra Gittlen":661,"blog-related-posts-de-de-ultimate-guide-to-ci-cd-fundamentals-to-advanced-implementation":677,"assessment-promotions-de-de":716,"next-steps-de-de":754},{"id":4,"title":5,"authorSlugs":6,"body":8,"categorySlug":9,"config":10,"content":14,"description":8,"extension":30,"isFeatured":12,"meta":31,"navigation":12,"path":32,"publishedDate":20,"seo":33,"stem":38,"tagSlugs":39,"__hash__":42},"blogPosts/de-de/blog/ultimate-guide-to-ci-cd-fundamentals-to-advanced-implementation.yml","Ultimate Guide To Ci Cd Fundamentals To Advanced Implementation",[7],"sandra-gittlen",null,"devsecops",{"slug":11,"featured":12,"template":13},"ultimate-guide-to-ci-cd-fundamentals-to-advanced-implementation",true,"BlogPost",{"title":15,"description":16,"authors":17,"heroImage":19,"date":20,"body":21,"category":9,"tags":22,"updatedDate":29},"Der ultimative CI/CD-Leitfaden: Grundlagen für die erweiterte Implementierung","Erfahre, wie du die kontinuierliche Integration/kontinuierliche Bereitstellung modernisierst und die Entwicklung, Lieferung und Sicherheit von Pipelines automatisierst.",[18],"Sandra Gittlen","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749660151/Blog/Hero%20Images/blog-image-template-1800x945__26_.png","2025-01-06","Die kontinuierliche Integration/kontinuierliche Lieferung ([CI/CD](https://about.gitlab.com/de-de/topics/ci-cd/)) hat die Art und Weise revolutioniert, wie Softwareteams Werte für ihre Benutzer(innen) schaffen. Vorbei sind die Zeiten manueller Bereitstellungen und komplizierter Integrationen – moderne Entwicklung erfordert Automatisierung, Zuverlässigkeit und Geschwindigkeit.\n\nIm Grunde geht es bei CI/CD darum, eine nahtlose Pipeline zu erstellen, die Code von der Umgebung der Entwickler(innen) bis hin zur Produktion überführt und Feedback in Echtzeit einbezieht. [CI](https://about.gitlab.com/de-de/topics/ci-cd/benefits-continuous-integration/) hilft Teams, Mängel frühzeitig zu erkennen – bevor sie zu kostspieligen Problemen werden –, indem sichergestellt wird, dass Codeänderungen häufig in einem gemeinsamen Repository zusammengeführt, automatisch getestet und validiert werden. [CD](https://about.gitlab.com/de-de/topics/ci-cd/#what-is-continuous-delivery-cd) führt diesen Ansatz fort, indem es den Bereitstellungsprozess automatisiert und die Releases vorhersehbar und stressfrei macht.\n\nAnstatt sich auf manuelle Prozesse und komplexe Toolchains für die Softwareentwicklung zu verlassen, können Teams eine robuste CI/CD-Pipeline verwenden, um Software zu erstellen, zu testen und bereitzustellen. Die KI kann diesen Prozess noch weiter optimieren und automatisch CI/CD-Pipelines erstellen, die konsistente Qualität, Compliance und Sicherheitsüberprüfungen ermöglichen.\n\nIn diesem Leitfaden werden moderne CI/CD-Pipelines von den Grundprinzipien über Best Practices bis hin zu fortschrittlichen Strategien erklärt. Du erfährst außerdem, wie führende Unternehmen CI/CD nutzen, um wirkungsvolle Ergebnisse zu erzielen. Mit den Erkenntnissen dieses Leitfadens kannst du deine DevSecOps-Umgebung skalieren und Software [agil](https://about.gitlab.com/de-de/topics/ci-cd/continuous-integration-agile/), automatisiert und effizient entwickeln und bereitstellen.\n\n## Inhalt: Das erwartet dich\n\n- [Was ist kontinuierliche Integration?](#was-ist-kontinuierliche-integration%3F)\n- [Was ist kontinuierliche Lieferung?](#was-ist-kontinuierliche-lieferung%3F)\n- [Wie hängt die Quellcodeverwaltung mit CI/CD zusammen?](#wie-hängt-die-quellcodeverwaltung-mit-cicd-zusammen%3F)\n- [Die Vorteile von CI/CD in der modernen Softwareentwicklung](#die-vorteile-von-cicd-in-der-modernen-softwareentwicklung)\n - [Hauptunterschiede zwischen CI/CD und traditioneller Entwicklung](#hauptunterschiede-zwischen-cicd-und-traditioneller-entwicklung)\n- [Grundlagen von CI/CD verstehen](#grundlagen-von-cicd-verstehen)\n - [Was ist eine CI/CD-Pipeline?](#was-ist-eine-cicd-pipeline%3F)\n- [Best Practices für CI/CD-Implementierung und -Management](#best-practices-für-cicd-implementierung-und--management)\n - [Best Practices für CI](#best-practices-für-ci)\n - [Best Practices für CD](#best-practices-für-cd)\n- [Erste Schritte mit CI/CD](#erste-schritte-mit-cicd)\n- [Sicherheit, Compliance und CI/CD](#sicherheit-compliance-und-cicd)\n- [CI/CD und die Cloud](#cicd-und-die-cloud)\n- [Erweitertes CI/CD](#erweitertes-cicd)\n - [Wiederverwendung und Automatisierung in CI/CD](#wiederverwendung-und-automatisierung-in-cicd)\n - [Problembehebung für Pipelines mithilfe von KI](#problembehebung-für-pipelines-mithilfe-von-ki)\n- [So migrierst du zu GitLab CI/CD](#so-migrierst-du-zu-gitlab-cicd)\n- [Erfahrungsberichte von führenden Unternehmen](#erfahrungsberichte-von-führenden-unternehmen)\n- [CI/CD-Tutorials](#cicd-tutorials)\n\n## Was ist kontinuierliche Integration?\n\nUnter [kontinuierlicher Integration](https://about.gitlab.com/de-de/topics/ci-cd/benefits-continuous-integration/) (CI) versteht man das Vorgehen, alle Codeänderungen frühzeitig und häufig in den main-Branch eines gemeinsamen Quellcode-Repositorys zu integrieren, Änderungen automatisch zu testen, wenn sie committet oder zusammengeführt werden, und automatisch einen Build zu starten. Mit kontinuierlicher Integration können Teams Fehler und Sicherheitsprobleme leichter und viel früher im Entwicklungsprozess erkennen und beheben.\n\n## Was ist kontinuierliche Lieferung?\n[Kontinuierliche Lieferung](https://about.gitlab.com/de-de/topics/ci-cd/#what-is-continuous-delivery-cd) (CD) – manchmal auch _kontinuierliche Bereitstellung_ genannt – ermöglicht es Unternehmen, ihre Anwendungen automatisch bereitzustellen, sodass Entwickler(innen) mehr Zeit haben, sich auf die Überwachung des Bereitstellungsstatus zu konzentrieren und den Erfolg sicherzustellen. Bei der kontinuierlichen Lieferung legen DevOps-Teams die Kriterien für die Codefreigabe im Voraus fest. Wenn diese Kriterien erfüllt und validiert sind, wird der Code in der Produktivumgebung bereitgestellt. So können Unternehmen flexibler sein und neue Funktionen den Benutzer(inne)n schneller zur Verfügung stellen.\n\n## Wie hängt die Quellcodeverwaltung mit CI/CD zusammen?\n\nQuellcodeverwaltung ([Source Code Management, SCM](https://about.gitlab.com/de-de/solutions/source-code-management/)) und CI/CD bilden die Grundlage moderner Softwareentwicklungsverfahren. SCM-Systeme wie [Git](https://about.gitlab.com/de-de/blog/what-is-git-the-ultimate-guide-to-gits-role-and-functionality/) bieten eine zentrale Möglichkeit, Änderungen zu verfolgen, verschiedene Codeversionen zu verwalten und die Zusammenarbeit zwischen den Teammitgliedern zu erleichtern. Wenn Entwickler(innen) an neuen Funktionen oder Fehlerbehebungen arbeiten, erstellen sie Branches aus der main-Codebase, nehmen ihre Änderungen vor und [führen sie dann über Merge Requests zusammen](https://docs.gitlab.com/ee/user/project/merge_requests/) (Artikel nur in englischer Sprache verfügbar). Diese Branching-Strategie macht es möglich, dass mehrere Entwickler(innen) gleichzeitig arbeiten können, ohne sich gegenseitig in die Quere zu kommen, und gleichzeitig einen stabilen main-Branch zu bewahren, der immer produktionsreifen Code enthält.\n\n> **Nahezu 100 % Uptime: NVIDIA skaliert mit GitLab global – ohne Ausfallzeiten** Verteilte Teams bei NVIDIA profitieren mit GitLab Geo von schneller verfügbaren Repositories, häufigeren Upgrades ohne Ausfallzeiten und global-synchronen sowie -sicheren Projekten. Erfahre, wie GitLab Premium hilft, Stabilität, Transparenz und Effizienz zu verbessern. **[Erfolgsstory lesen](https://about.gitlab.com/de-de/customers/nvidia/)**\n\nCI/CD übernimmt den von SCM-Systemen verwalteten Code und erstellt, testet und validiert ihn automatisch, wenn Änderungen gepusht werden. Wenn Entwickler(innen) Codeänderungen einreichen, ruft das CI/CD-System automatisch den neuesten Code ab, kombiniert ihn mit der vorhandenen Codebase und führt eine Reihe automatisierter Überprüfungen durch. Dazu gehören in der Regel das Kompilieren des Codes, das Ausführen von Unit-Tests, das Durchführen einer statischen Codeanalyse und das Überprüfen der Testabdeckung. Wenn einer dieser Schritte fehlschlägt, wird das Team sofort benachrichtigt, sodass es Probleme beheben kann, bevor sie sich auf andere Entwickler(innen) auswirken oder in die Produktivumgebung überführt werden. Durch diese enge Integration zwischen Versionskontrolle und kontinuierlicher Integration entsteht eine Feedbackschleife, die dazu beiträgt, die Codequalität aufrechtzuerhalten, und verhindert, dass sich Integrationsprobleme ansammeln.\n\n## Die Vorteile von CI/CD in der modernen Softwareentwicklung\n\n[CI/CD bringt transformative Vorteile für die moderne Softwareentwicklung](https://about.gitlab.com/blog/ten-reasons-why-your-business-needs-ci-cd/) (Blogbeitrag nur in englischer Sprache verfügbar), indem die Zeit und das Risiko drastisch reduziert werden, die neue Funktionen und Fixes mit sich bringen. Durch die kontinuierliche Feedbackschleife können DevSecOps-Teams sicher sein, dass ihre Änderungen automatisch für die gesamte Codebase validiert werden. Das Ergebnis sind hochwertigere Software, kürzere Lieferzeiten und häufigere Veröffentlichungen, mit denen man schneller auf Benutzer- und Marktanforderungen reagieren kann.\n\nEiner der wichtigsten Aspekte ist jedoch, dass CI/CD eine Kultur der Zusammenarbeit und Transparenz innerhalb von Softwareentwicklungsteams fördert. Wenn jeder den Status von Builds, Tests und Bereitstellungen in Echtzeit sehen kann, wird es einfacher, Engpässe im Bereitstellungsprozess zu identifizieren und zu beheben. Die von CI/CD ermöglichte Automatisierung reduziert auch die kognitive Belastung für Entwickler(innen) und gibt ihnen die Möglichkeit, sich auf das Schreiben von Code zu konzentrieren, anstatt manuelle Bereitstellungsprozesse zu verwalten. Dies führt zu einer höheren Zufriedenheit und Produktivität der Entwickler(innen) und reduziert gleichzeitig das Risiko, das traditionell mit dem gesamten Softwareveröffentlichungsprozess verbunden ist. Teams können freier experimentieren, wenn sie wissen, dass schnelle Code Reviews Teil des Prozesses sind, und sie können Änderungen bei Bedarf schnell zurücknehmen, was Innovationen und kontinuierliche Verbesserungen fördert.\n\n### Hauptunterschiede zwischen CI/CD und traditioneller Entwicklung\n\nCI/CD unterscheidet sich in vielerlei Hinsicht von der traditionellen Softwareentwicklung:\n\n**Häufige Code-Commits**\nEntwickler(innen) arbeiten oft unabhängig und laden ihren Code selten in eine main-Codebase hoch, was zu Merge-Konflikten und anderen zeitaufwändigen Problemen führt. Mit CI/CD pushen Entwickler(innen) Commits den ganzen Tag über, um sicherzustellen, dass Konflikte frühzeitig erkannt werden und die Codebase auf dem neuesten Stand bleibt.\n\n**Reduziertes Risiko**\n\nLangwierige Testzyklen und eine umfassende Vorabplanung kennzeichnen die traditionelle Softwareentwicklung. Dadurch sollen Risiken minimiert werden, jedoch wird die Möglichkeit eingeschränkt, Probleme zu finden und zu beheben. Das Risikomanagement in CI/CD basiert darauf, dass kleine, inkrementelle Änderungen vorgenommen werden, die genau überwacht und leicht rückgängig gemacht werden können.\n\n**Automatisierte und kontinuierliche Tests**\n\nIn der traditionellen Softwareentwicklung werden Tests durchgeführt, sobald die Entwicklung abgeschlossen ist. Dies führt jedoch zu Problemen wie verspäteter Lieferung und kostspieliger Fehlerbehebungen. CI/CD unterstützt automatisierte Tests, die während der gesamten Entwicklung kontinuierlich durchgeführt und durch jeden Code-Commit ausgelöst werden. Entwickler(innen) erhalten außerdem Feedback, auf das sie schnell reagieren können.\n\n**Automatisierte, wiederholbare und häufige Bereitstellungen**\n\nMit CI/CD sind Bereitstellungen automatisierte Prozesse, die den typischen Stress und Aufwand für große Software-Rollouts reduzieren. Der gleiche Bereitstellungsprozess kann in allen Umgebungen wiederholt werden, was Zeit spart und Fehler und Inkonsistenzen reduziert.\n\n## Grundlagen von CI/CD verstehen\n\nCI/CD dient als Framework für den Aufbau skalierbarer, wartbarer Bereitstellungsprozesse. Daher ist es für DevSecOps-Teams wichtig, die Kernkonzepte wirklich zu verstehen. Durch ein solides Verständnis der CI/CD-Prinzipien können Teams, Strategien und Praktiken an die Entwicklung der Technologie anpassen, anstatt an alte Ansätze gebunden zu sein. Hier sind einige der Grundlagen.\n\n### Was ist eine CI/CD-Pipeline?\n\nEine [CI/CD-Pipeline](https://about.gitlab.com/de-de/topics/ci-cd/cicd-pipeline/) ist eine Reihe von Schritten wie Erstellen, Testen und Bereitstellen, durch die der Softwarebereitstellungsprozess automatisiert und optimiert wird. [Jede Phase dient als Qualitätsüberprüfung](https://about.gitlab.com/blog/guide-to-ci-cd-pipelines/) (Blogbeitrag nur in englischer Sprache verfügbar) und stellt sicher, dass nur validierter Code weiterentwickelt wird. In den frühen Phasen werden in der Regel grundlegende Überprüfungen wie Kompilierung und Unit-Tests durchgeführt, während spätere Phasen Integrationstests, Leistungstests, Konformitätstests und gestaffelte Bereitstellungen in verschiedenen Umgebungen umfassen können.\n\nDie Pipeline kann so konfiguriert werden, dass manuelle Genehmigungen an kritischen Punkten erforderlich sind, z. B. vor der Bereitstellung für die Produktion, während gleichzeitig Routineaufgaben automatisiert werden und Entwickler(innen) schnelles Feedback über den Zustand ihrer Änderungen erhalten. Dieser strukturierte Ansatz sorgt für Konsistenz, reduziert menschliche Fehler und bietet einen klaren Audit-Trail, wie Codeänderungen sich von der Entwicklung bis in die Produktion bewegen. Moderne Pipelines werden oft als Code implementiert, so dass sie wie Anwendungscode versioniert, getestet und gepflegt werden können.\n\nAuch die folgenden Begriffe sind für CI/CD wichtig:\n- **Commit:** eine Codeänderung\n- **Job:** Anweisungen, die ein Runner ausführen muss\n- **Runner:** ein Agent oder Server, der jeden Job einzeln ausführt und nach Bedarf hoch- oder herunterfahren kann\n- **Phase:** ein Schlüsselwort, das bestimmte Jobphasen definiert, z. B. „Erstellen“ und „Bereitstellen“. Jobs der gleichen Phase werden parallel ausgeführt. Pipelines werden mithilfe der versionierten YAML-Datei `.gitlab-ci.yml` auf der Root-Ebene eines Projekts konfiguriert.\n\n![CI/CD-Pipeline-Schema](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749673928/Blog/Content%20Images/1690824533476.png)\n\n## Best Practices für die Implementierung und das Management von CI/CD\n\nWie erfolgreich du mit CI/CD bist, hängt stark von den [Best Practices](https://about.gitlab.com/de-de/blog/how-to-keep-up-with-ci-cd-best-practices/) ab, die du implementierst.\n#### Best Practices für CI\n\n* Committe früh und oft.\n* Optimiere die Pipeline-Phasen.\n* Erstelle Builds schnell und einfach.\n* Nutze Fehlschläge, um Prozesse zu verbessern.\n* Stelle sicher, dass die Testumgebung die Produktion widerspiegelt.\n\n#### Best Practices für CD\n\n* Beginne dort, wo du gerade bist – du kannst jederzeit iterieren.\n* Die beste kontinuierliche Lieferung erfolgt mit minimalen Mitteln.\n* Verfolge, was passiert, damit Probleme und Merge Requests nicht außer Kontrolle geraten.\n* Optimiere Benutzerakzeptanztests und Staging mit Automatisierung.\n* Verwalte die Release-Pipeline durch Automatisierung.\n* Implementiere Überwachung für Transparenz und Effizienz.\n> ### Setz dir ein Lesezeichen!\n>\n>Sieh dir unser englischsprachiges [Webinar „Intro to CI/CD“](https://www.youtube.com/watch?v=sQ7Nw3o0izc) (Einführung in CI/CD) an!\n>\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n\u003Ciframe src=\"https://www.youtube.com/embed/sQ7Nw3o0izc?si=3HpNqIClrc2ncr7Y\" title=\"Intro to CI/CD webinar\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n## Erste Schritte mit CI/CD\n\nDer Einstieg in CI/CD beginnt mit einem einfachen, aber repräsentativen Projekt, das als Pilotprojekt dienen soll. Wähle eine einfache Anwendung mit simplen Testanforderungen aus, damit du dich auf das Erlernen der Pipeline-Mechanismen konzentrieren kannst, anstatt dich mit komplexen Bereitstellungsszenarien zu befassen. Stelle zunächst sicher, dass dein Code [versioniert](https://about.gitlab.com/de-de/topics/version-control/) ist und einige [grundlegende automatisierte Tests](https://about.gitlab.com/blog/develop-c-unit-testing-with-catch2-junit-and-gitlab-ci/) (Blogbeitrag nur in englischer Sprache verfügbar) enthält – dabei reichen schon ein paar Unit-Tests aus. Das Ziel besteht darin, [eine minimale Pipeline zu erstellen](https://about.gitlab.com/blog/how-to-learn-ci-cd-fast/) (Blogbeitrag nur in englischer Sprache verfügbar), die du mit zunehmendem Verständnis nach und nach ausbauen kannst.\n\nIm Fall von GitLab beginnt der Prozess mit dem Erstellen der Datei `.gitlab-ci.yml` im Stammverzeichnis deines Projekts. Diese YAML-Datei definiert deine Pipeline-Phasen (grundlegende Phasen wie Erstellen, Testen und Bereitstellen) und Jobs. Eine einfache Pipeline könnte so aussehen: In der Phase „Erstellen“ wird deine Code kompiliert und es werden Artefakte erstellt, die Testphase führt deine Unit-Tests aus und die Phase „Bereitstellen“ pusht deine Anwendung in eine Staging-Umgebung. GitLab erkennt diese Datei automatisch und beginnt, deine Pipeline auszuführen, wenn Änderungen in dein Repository gepusht werden. Die Plattform bietet [integrierte Runner](https://docs.gitlab.com/runner/) (Artikel nur in englischer Sprache verfügbar), um deine Pipeline-Jobs auszuführen, aber du kannst auch eigene Runner einrichten, wenn du mehr Kontrolle haben willst.\n\nWenn du mit den Grundlagen vertraut bist, kannst du nach und nach anspruchsvollere Elemente zu deiner Pipeline hinzufügen. Du kannst zum Beispiel Code-Qualitätsprüfungen, [Sicherheitsscans](https://docs.gitlab.com/ee/user/application_security/#security-scanning) (Artikel nur in englischer Sprache verfügbar) oder die automatisierte Bereitstellung für die Produktion hinzufügen. Die DevSecOps-Plattform von GitLab bietet Funktionen wie [Compliance-Management](https://about.gitlab.com/blog/meet-regulatory-standards-with-gitlab/), [Bereitstellungsvariablen](https://about.gitlab.com/blog/demystifying-ci-cd-variables/) (Blogbeiträge nur in englischer Sprache verfügbar) und manuelle Genehmigungsprüfungen, die du integrieren kannst, wenn deine Pipeline ausgereift ist. Achte auf die Ausführungszeit der Pipeline und suche nach Möglichkeiten, Jobs parallel auszuführen. Denke daran, die richtige Fehlerbehandlung und Benachrichtigungen hinzuzufügen, damit deine Teammitglieder umgehend über alle Pipeline-Ausfälle informiert werden. Beginne damit, häufige Probleme und Lösungen zu dokumentieren, wenn sie auftauchen – dies wird von unschätzbarem Wert sein, wenn dein Team wächst.\n\n> ### Möchtest du mehr über die ersten Schritte mit CI/CD erfahren? Registriere dich für einen [kostenlosen, englischsprachigen CI/CD-Kurs auf GitLab University](https://university.gitlab.com/courses/continuous-integration-and-delivery-ci-cd-with-gitlab).\n\n## Sicherheit, Compliance und CI/CD\n\nEiner der größten Vorteile von CI/CD ist die Möglichkeit, Sicherheits- und Compliance-Prüfungen frühzeitig und häufig in den Software-Entwicklungsprozess einzubetten. In GitLab können Teams die Konfiguration `.gitlab-ci.yml` verwenden, um automatisch Sicherheitsscans in mehreren Phasen auszulösen, vom ersten Code Commit bis zur Bereitstellung in der Produktivumgebung. Container-Scanning, Abhängigkeitsuche und Sicherheitsscans auf der Plattform ([Dynamische Anwendungssicherheitstests](https://docs.gitlab.com/ee/user/application_security/dast/) und [Erweitertes SAST](https://about.gitlab.com/blog/gitlab-advanced-sast-is-now-generally-available/); beide nur in englischer Sprache verfügbar) können so konfiguriert werden, dass sie bei jeder Codeänderung automatisch ausgeführt werden, um auf Sicherheitslücken, Compliance-Verstöße und Sicherheitsfehlkonfigurationen zu prüfen. Die API der Plattform ermöglicht die Integration mit [externen Sicherheitstools](https://about.gitlab.com/blog/integrate-external-security-scanners-into-your-devsecops-workflow/) (Blogbeitrag nur in englischer Sprache verfügbar) und die Testabdeckungsfunktionen stellen sicher, dass die Sicherheitstests die erforderlichen Anforderungen erfüllen.\n\nDie Sicherheitstestberichte von GitLab enthalten detaillierte Informationen zu den Ergebnissen und sollen sicherstellen, dass Sicherheitsprobleme schnell behoben werden können, bevor sie in die Produktion kommen. Das Sicherheitsdashboard bietet eine zentrale Ansicht von Sicherheitslücken in allen Projekten, während [Sicherheitsrichtlinien](https://about.gitlab.com/blog/how-gitlab-supports-the-nsa-and-cisa-cicd-security-guidance/) (Blogbeitrag nur in englischer Sprache verfügbar) durch Merge-Request-Genehmigungen und Pipeline-Gates durchgesetzt werden können. Darüber hinaus bietet GitLab mehrere Sicherheitsebenen, um vertrauliche Daten während des gesamten CI/CD-Prozesses zu schützen, Audit-Protokolle, um den Zugriff auf Geheimnisse zu verfolgen, und rollenbasierte Zugriffskontrolle (RBAC), um sicherzustellen, dass nur autorisierte Benutzer(innen) vertrauliche Konfigurationsdaten anzeigen oder ändern können.\n\nGitLab unterstützt auch die Erstellung einer Software-Stückliste ([SBOM](https://about.gitlab.com/de-de/blog/the-ultimate-guide-to-sboms/)), die eine umfassende Bestandsaufnahme aller Softwarekomponenten, Abhängigkeiten und Lizenzen in einer Anwendung bietet und es den Teams ermöglicht, Sicherheitslücken schnell zu identifizieren, darauf zu reagieren und behördliche Auflagen zu erfüllen.\n\n## CI/CD und die Cloud\n\nDie CI/CD-Plattform von GitLab bietet eine robuste Integration mit großen Cloud-Anbietern wie [Amazon Web Services](https://about.gitlab.com/de-de/partners/technology-partners/aws/), [Google Cloud Platform](https://about.gitlab.com/blog/provision-group-runners-with-google-cloud-platform-and-gitlab-ci/) (Blogbeitrag nur in englischer Sprache verfügbar) und [Microsoft Azure](https://docs.gitlab.com/ee/install/azure/) (Artikel nur in englischer Sprache verfügbar), sodass Teams ihre Cloud-Bereitstellungen direkt aus ihren Pipelines heraus automatisieren können. Durch die Cloud-Integrationen von GitLab können Teams Cloud-Ressourcen verwalten, Anwendungen bereitstellen und Cloud-Dienste innerhalb der GitLab-Oberfläche überwachen. Die integrierten Cloud-Bereitstellungsvorlagen und [Auto-DevOps-Funktionen](https://docs.gitlab.com/ee/topics/autodevops/) (Artikel nur in englischer Sprache verfügbar) der Plattform reduzieren die Komplexität von Cloud-Bereitstellungen erheblich, sodass sich die Teams auf die Anwendungsentwicklung konzentrieren können und sich nicht mit dem Infrastrukturmanagement befassen müssen. Für Unternehmen, die ihre IT-Infrastruktur mit GitOps automatisieren möchten, bietet GitLab eine [Flux-CD-Integration](https://about.gitlab.com/blog/why-did-we-choose-to-integrate-fluxcd-with-gitlab/) (Blogbeitrag nur in englischer Sprache verfügbar).\n\nDie Cloud-Funktionen von GitLab gehen weit über die einfache Automatisierung der Bereitstellung hinaus. Die [Kubernetes-Integration](https://about.gitlab.com/blog/kubernetes-overview-operate-cluster-data-on-the-frontend/) (Blogbeitrag nur in englischer Sprache verfügbar) der Plattform ermöglicht es den Teams, die Container-Orchestrierung über mehrere Cloud-Anbieter hinweg zu verwalten, während die [Cloud-nativen Installationsoptionen von GitLab](https://about.gitlab.com/de-de/topics/ci-cd/cloud-native-continuous-integration/) den Betrieb der Plattform selbst in Cloud-Umgebungen ermöglichen. Durch die Cloud-nativen Funktionen von GitLab können Teams Runner mit automatischer Skalierung implementieren, die dynamisch Cloud-Ressourcen für die Pipeline-Ausführung bereitstellen und so Kosten und Leistung optimieren. Die Integration der Plattform mit den Sicherheitsdiensten von Cloud-Anbietern macht es möglich, dass die Sicherheits- und Konformitätsanforderungen während des gesamten Bereitstellungsprozesses erfüllt werden.\n\nFür Multi-Cloud-Umgebungen stellt GitLab konsistente Workflows und Tools zur Verfügung, unabhängig vom zugrunde liegenden Cloud-Anbieter. Teams können die Umgebungsverwaltung von GitLab verwenden, um verschiedene Cloud-Konfigurationen in Entwicklungs-, Staging- und Produktivumgebungen zu verwalten. Da die Plattform [Infrastructure as Code](https://docs.gitlab.com/ee/user/infrastructure/iac/) (Artikel nur in englischer Sprache verfügbar) unterstützt – insbesondere die native Integration mit Terraform – können Teams ihre Cloud-Infrastruktur-Bereitstellung steuern und automatisieren. Die Überwachungs- und Beobachtungsfunktionen von GitLab lassen sich in die Metriken von Cloud-Anbietern integrieren und bieten einen umfassenden Überblick über den Zustand von Anwendungen und Infrastruktur in allen Cloud-Umgebungen.\n\n## Erweitertes CI/CD CI/CD hat sich weit über das einfache Erstellen und Bereitstellen von Pipelines hinaus entwickelt. In umfassenderen Implementierungen bietet CI/CD eine ausgefeilte Orchestrierung von automatisierten Tests, Sicherheitsscans, Infrastrukturbereitstellung, KI und mehr. Hier findest du einige Strategien für Erweitertes CI/CD, die Entwicklungsteams dabei helfen können, ihre Pipelines zu skalieren und Probleme zu beheben, auch wenn die architektonische Komplexität zunimmt.\n\n### Wiederverwendung und Automatisierung in CI/CD\n\nGitLab verändert die Art und Weise, wie Entwicklungsteams CI/CD-Pipelines erstellen und verwalten. Dazu tragen vor allem zwei wichtige Innovationen bei: der [CI/CD-Katalog](https://about.gitlab.com/blog/ci-cd-catalog-goes-ga-no-more-building-pipelines-from-scratch/) und [CI/CD Steps](https://about.gitlab.com/blog/introducing-ci-cd-steps-a-programming-language-for-devsecops-automation/) (Blogbeiträge nur in englischer Sprache verfügbar), eine neue Programmiersprache für DevSecOps-Automatisierung, die derzeit getestet wird. Der CI/CD-Katalog ist eine zentralisierte Plattform, auf der Entwickler(innen) CI/CD-Komponenten entdecken, wiederverwenden und beitragen können. Komponenten fungieren als wiederverwendbare Bausteine mit einem einzigen Zweck und sollen die Pipeline-Konfiguration vereinfachen – du kannst sie dir wie Legosteine für CI/CD-Workflows vorstellen. CI/CD Steps unterstützt komplexe Workflows, indem es Entwickler(inne)n ermöglicht, Eingaben und Ausgaben für einen CI/CD-Job zu erstellen. Mit dem CI/CD-Katalog und CI/CD Steps können DevSecOps-Teams CI/CD und seine Komponenten einfach standardisieren und so die Entwicklung und Pflege von CI/CD-Pipelines vereinfachen.\n\n> Weitere Informationen findest du in unseren [CI/CD-Katalog-FAQ](https://about.gitlab.com/blog/faq-gitlab-ci-cd-catalog/) und der [Dokumentation für CI/CD Steps](https://docs.gitlab.com/ee/ci/steps/) (beide nur in englischer Sprache verfügbar).\n\n### Problembehebung für Pipelines mithilfe von KI\n\nCI/CD-Pipelines können zwar ab und zu ausfallen, aber eine schnelle Problembehebung kann die Auswirkungen minimieren. GitLab Duo Root Cause Analysis, schafft als Teil eines Programmpakets KI-basierter Funktionen Klarheit, indem es [die Grundursache für eine defekte CI/CD-Pipeline ermittelt](https://about.gitlab.com/blog/quickly-resolve-broken-ci-cd-pipelines-with-ai/) (Blogbeitrag nur in englischer Sprache verfügbar). Wenn eine Pipeline fehlschlägt, stellt GitLab detaillierte Job-Protokolle, Fehlermeldungen und Ausführungsverläufe bereit, die genau zeigen, wo und warum der Fehler aufgetreten ist. Root Cause Analysis schlägt dann mithilfe von KI eine Lösung vor.\nSieh dir GitLab Duo Root Cause Analysisin Aktion an:\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n\u003Ciframe src=\"https://www.youtube.com/embed/sTpSLwX5DIs?si=J6-0Bf6PtYjrHX1K\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n## So migrierst zu GitLab CI/CD\n\nFür die Migration auf die DevSecOps-Plattform und ihr integriertes CI/CD ist ein systematischer Ansatz nötig, um deine vorhandene Pipeline-Konfigurationen, Abhängigkeiten und Bereitstellungsprozesse zu analysieren und dann den entsprechenden Funktionen und der Syntax von GitLab zuzuordnen. Die folgenden englischsprachigen Anleitungen sollen dir den Einstieg erleichtern.\n\n* [So migrierst du von Bamboo zu GitLab CI/CD](https://about.gitlab.com/blog/migrating-from-bamboo-to-gitlab-cicd/)\n* [Von Jenkins zu GitLab: der ultimative Leitfaden zur Modernisierung deiner CI/CD-Umgebung](https://about.gitlab.com/blog/jenkins-gitlab-ultimate-guide-to-modernizing-cicd-environment/)\n* [Einfache Migration von GitHub zu GitLab](https://about.gitlab.com/blog/github-to-gitlab-migration-made-easy/)\n\n## Erfahrungsberichte von führenden Unternehmen\n\nDiese führenden Unternehmen sind zu GitLab migriert und profitieren von den unzähligen Vorteilen von CI/CD. Lies ihre Stories.\n\n- [Lockheed Martin](https://about.gitlab.com/de-de/customers/lockheed-martin/)\n- [Indeed](https://about.gitlab.com/de-de/blog/how-indeed-transformed-its-ci-platform-with-gitlab/)\n- [CARFAX](https://about.gitlab.com/de-de/customers/carfax/)\n- [HackerOne](https://about.gitlab.com/de-de/customers/hackerone/)\n- [Betstudios](https://about.gitlab.com/blog/betstudios-cto-on-improving-ci-cd-capabilities-with-gitlab-premium/) (nur in englischer Sprache verfügbar)\n- [Thales und Carrefour](https://about.gitlab.com/blog/how-carrefour-and-thales-are-evolving-their-ci-cd-platforms/) (nur in englischer Sprache verfügbar)\n\n## CI/CD-Tutorials\n\nWerde mit diesen einfach verständlichen Tutorials zum CI/CD-Profi. (Die Tutorials sind im Moment nur in englischer Sprache verfügbar.)\n\n* [Grundlagen von CI: So führst du Jobs sequenziell, parallel oder unregelmäßig aus](https://about.gitlab.com/blog/basics-of-gitlab-ci-updated/)\n* [So richtest du deine erste CI/CD-Komponente mit GitLab ein](https://about.gitlab.com/blog/tutorial-how-to-set-up-your-first-gitlab-ci-cd-component/)\n* [Einfacher Aufbau einer CI/CD-Pipeline mit GitLab für ein Monorepo](https://about.gitlab.com/blog/building-a-gitlab-ci-cd-pipeline-for-a-monorepo-the-easy-way/)\n* [Verwendung von untergeordneten Pipelines für die kontinuierliche Bereitstellung in fünf Umgebungen](https://about.gitlab.com/blog/using-child-pipelines-to-continuously-deploy-to-five-environments/)\n* [CI/CD-Automatisierung: Maximiere die Auswirkungen eines Bereitstellungsstopps auf GitLab-Gruppen](https://about.gitlab.com/blog/ci-cd-automation-maximize-deploy-freeze-impact-across-gitlab-groups/)\n* [Refaktorisierung einer CI/CD-Vorlage zu einer CI/CD-Komponente](https://about.gitlab.com/blog/refactoring-a-ci-cd-template-to-a-ci-cd-component/)\n* [Kommentiere Container-Images mit Build-Provenienz mithilfe von Cosign in GitLab CI/CD](https://about.gitlab.com/blog/annotate-container-images-with-build-provenance-using-cosign-in-gitlab-ci-cd/)\n\n> #### Erste Schritte mit GitLab CI/CD. [Registriere dich für GitLab Ultimate](https://gitlab.com/-/trials/new) und teste die KI-basierte DevSecOps-Plattform kostenlos.",[23,24,25,26,27,28],"CI/CD","DevSecOps","DevSecOps platform","tutorial","security","product","2025-05-08","yml",{},"/de-de/blog/ultimate-guide-to-ci-cd-fundamentals-to-advanced-implementation",{"title":15,"description":16,"ogTitle":15,"ogDescription":16,"noIndex":34,"ogImage":19,"ogUrl":35,"ogSiteName":36,"ogType":37,"canonicalUrls":35},false,"https://about.gitlab.com/blog/ultimate-guide-to-ci-cd-fundamentals-to-advanced-implementation","https://about.gitlab.com","article","de-de/blog/ultimate-guide-to-ci-cd-fundamentals-to-advanced-implementation",[40,9,41,26,27,28],"cicd","devsecops-platform","vQdVqfP5EBycBG7WWOc2NYg9nNqqokT4XwGRRzCV4yg",{"data":44},{"logo":45,"freeTrial":50,"sales":55,"login":60,"items":65,"search":373,"minimal":408,"duo":426,"pricingDeployment":436},{"config":46},{"href":47,"dataGaName":48,"dataGaLocation":49},"/de-de/","gitlab logo","header",{"text":51,"config":52},"Kostenlose Testversion anfordern",{"href":53,"dataGaName":54,"dataGaLocation":49},"https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com&glm_content=default-saas-trial/","free trial",{"text":56,"config":57},"Vertrieb kontaktieren",{"href":58,"dataGaName":59,"dataGaLocation":49},"/de-de/sales/","sales",{"text":61,"config":62},"Anmelden",{"href":63,"dataGaName":64,"dataGaLocation":49},"https://gitlab.com/users/sign_in/","sign in",[66,93,188,193,294,354],{"text":67,"config":68,"cards":70},"Plattform",{"dataNavLevelOne":69},"platform",[71,77,85],{"title":67,"description":72,"link":73},"Die intelligente Orchestrierungsplattform für DevSecOps",{"text":74,"config":75},"Erkunde unsere Plattform",{"href":76,"dataGaName":69,"dataGaLocation":49},"/de-de/platform/",{"title":78,"description":79,"link":80},"GitLab Duo Agent Platform","Agentische KI für den gesamten Softwareentwicklungszyklus",{"text":81,"config":82},"Lerne GitLab Duo kennen",{"href":83,"dataGaName":84,"dataGaLocation":49},"/de-de/gitlab-duo-agent-platform/","gitlab duo agent platform",{"title":86,"description":87,"link":88},"Gründe, die für GitLab sprechen","Erfahre, warum Unternehmen auf GitLab setzen",{"text":89,"config":90},"Mehr erfahren",{"href":91,"dataGaName":92,"dataGaLocation":49},"/de-de/why-gitlab/","why gitlab",{"text":94,"left":12,"config":95,"link":97,"lists":101,"footer":170},"Produkt",{"dataNavLevelOne":96},"solutions",{"text":98,"config":99},"Alle Lösungen anzeigen",{"href":100,"dataGaName":96,"dataGaLocation":49},"/de-de/solutions/",[102,126,148],{"title":103,"description":104,"link":105,"items":110},"Automatisierung","CI/CD und Automatisierung zur Beschleunigung der Bereitstellung",{"config":106},{"icon":107,"href":108,"dataGaName":109,"dataGaLocation":49},"AutomatedCodeAlt","/de-de/solutions/delivery-automation/","automated software delivery",[111,114,117,122],{"text":23,"config":112},{"href":113,"dataGaLocation":49,"dataGaName":23},"/de-de/solutions/continuous-integration/",{"text":78,"config":115},{"href":83,"dataGaLocation":49,"dataGaName":116},"gitlab duo agent platform - product menu",{"text":118,"config":119},"Quellcodeverwaltung",{"href":120,"dataGaLocation":49,"dataGaName":121},"/de-de/solutions/source-code-management/","Source Code Management",{"text":123,"config":124},"Automatisierte Softwarebereitstellung",{"href":108,"dataGaLocation":49,"dataGaName":125},"Automated software delivery",{"title":127,"description":128,"link":129,"items":134},"Sicherheit","Entwickle schneller, ohne die Sicherheit zu gefährden",{"config":130},{"href":131,"dataGaName":132,"dataGaLocation":49,"icon":133},"/de-de/solutions/application-security-testing/","security and compliance","ShieldCheckLight",[135,139,144],{"text":136,"config":137},"Application Security Testing",{"href":131,"dataGaName":138,"dataGaLocation":49},"Application security testing",{"text":140,"config":141},"Schutz der Software-Lieferkette",{"href":142,"dataGaLocation":49,"dataGaName":143},"/de-de/solutions/supply-chain/","Software supply chain security",{"text":145,"config":146},"Software Compliance",{"href":147,"dataGaName":145,"dataGaLocation":49},"/de-de/solutions/software-compliance/",{"title":149,"link":150,"items":155},"Bewertung",{"config":151},{"icon":152,"href":153,"dataGaName":154,"dataGaLocation":49},"DigitalTransformation","/de-de/solutions/visibility-measurement/","visibility and measurement",[156,160,165],{"text":157,"config":158},"Sichtbarkeit und Bewertung",{"href":153,"dataGaLocation":49,"dataGaName":159},"Visibility and Measurement",{"text":161,"config":162},"Wertstrommanagement",{"href":163,"dataGaLocation":49,"dataGaName":164},"/de-de/solutions/value-stream-management/","Value Stream Management",{"text":166,"config":167},"Analysen und Einblicke",{"href":168,"dataGaLocation":49,"dataGaName":169},"/de-de/solutions/analytics-and-insights/","Analytics and insights",{"title":171,"items":172},"GitLab für",[173,178,183],{"text":174,"config":175},"Enterprise",{"href":176,"dataGaLocation":49,"dataGaName":177},"/de-de/enterprise/","enterprise",{"text":179,"config":180},"Kleinunternehmen",{"href":181,"dataGaLocation":49,"dataGaName":182},"/de-de/small-business/","small business",{"text":184,"config":185},"den öffentlichen Sektor",{"href":186,"dataGaLocation":49,"dataGaName":187},"/de-de/solutions/public-sector/","public sector",{"text":189,"config":190},"Preise",{"href":191,"dataGaName":192,"dataGaLocation":49,"dataNavLevelOne":192},"/de-de/pricing/","pricing",{"text":194,"config":195,"link":197,"lists":201,"feature":281},"Ressourcen",{"dataNavLevelOne":196},"resources",{"text":198,"config":199},"Alle Ressourcen anzeigen",{"href":200,"dataGaName":196,"dataGaLocation":49},"/de-de/resources/",[202,235,253],{"title":203,"items":204},"Erste Schritte",[205,210,215,220,225,230],{"text":206,"config":207},"Installieren",{"href":208,"dataGaName":209,"dataGaLocation":49},"/de-de/install/","install",{"text":211,"config":212},"Kurzanleitungen",{"href":213,"dataGaName":214,"dataGaLocation":49},"/de-de/get-started/","quick setup checklists",{"text":216,"config":217},"Lernen",{"href":218,"dataGaLocation":49,"dataGaName":219},"https://university.gitlab.com/","learn",{"text":221,"config":222},"Produktdokumentation",{"href":223,"dataGaName":224,"dataGaLocation":49},"https://docs.gitlab.com/","product documentation",{"text":226,"config":227},"Best-Practice-Videos",{"href":228,"dataGaName":229,"dataGaLocation":49},"/de-de/getting-started-videos/","best practice videos",{"text":231,"config":232},"Integrationen",{"href":233,"dataGaName":234,"dataGaLocation":49},"/de-de/integrations/","integrations",{"title":236,"items":237},"Entdecken",[238,243,248],{"text":239,"config":240},"Kundenerfolge",{"href":241,"dataGaName":242,"dataGaLocation":49},"/de-de/customers/","customer success stories",{"text":244,"config":245},"Blog",{"href":246,"dataGaName":247,"dataGaLocation":49},"/de-de/blog/","blog",{"text":249,"config":250},"Remote",{"href":251,"dataGaName":252,"dataGaLocation":49},"https://handbook.gitlab.com/handbook/company/culture/all-remote/","remote",{"title":254,"items":255},"Vernetzen",[256,261,266,271,276],{"text":257,"config":258},"GitLab-Services",{"href":259,"dataGaName":260,"dataGaLocation":49},"/de-de/services/","services",{"text":262,"config":263},"Community",{"href":264,"dataGaName":265,"dataGaLocation":49},"/community/","community",{"text":267,"config":268},"Forum",{"href":269,"dataGaName":270,"dataGaLocation":49},"https://forum.gitlab.com/","forum",{"text":272,"config":273},"Veranstaltungen",{"href":274,"dataGaName":275,"dataGaLocation":49},"/events/","events",{"text":277,"config":278},"Partner",{"href":279,"dataGaName":280,"dataGaLocation":49},"/de-de/partners/","partners",{"backgroundColor":282,"textColor":283,"text":284,"image":285,"link":289},"#2f2a6b","#fff","Perspektiven für die Softwareentwicklung der Zukunft",{"altText":286,"config":287},"the source promo card",{"src":288},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758208064/dzl0dbift9xdizyelkk4.svg",{"text":290,"config":291},"Lies die News",{"href":292,"dataGaName":293,"dataGaLocation":49},"/de-de/the-source/","the source",{"text":295,"config":296,"lists":298},"Unternehmen",{"dataNavLevelOne":297},"company",[299],{"items":300},[301,306,312,314,319,324,329,334,339,344,349],{"text":302,"config":303},"Über",{"href":304,"dataGaName":305,"dataGaLocation":49},"/de-de/company/","about",{"text":307,"config":308,"footerGa":311},"Karriere",{"href":309,"dataGaName":310,"dataGaLocation":49},"/jobs/","jobs",{"dataGaName":310},{"text":272,"config":313},{"href":274,"dataGaName":275,"dataGaLocation":49},{"text":315,"config":316},"Geschäftsführung",{"href":317,"dataGaName":318,"dataGaLocation":49},"/company/team/e-group/","leadership",{"text":320,"config":321},"Team",{"href":322,"dataGaName":323,"dataGaLocation":49},"/company/team/","team",{"text":325,"config":326},"Handbuch",{"href":327,"dataGaName":328,"dataGaLocation":49},"https://handbook.gitlab.com/","handbook",{"text":330,"config":331},"Investor Relations",{"href":332,"dataGaName":333,"dataGaLocation":49},"https://ir.gitlab.com/","investor relations",{"text":335,"config":336},"Trust Center",{"href":337,"dataGaName":338,"dataGaLocation":49},"/de-de/security/","trust center",{"text":340,"config":341},"AI Transparency Center",{"href":342,"dataGaName":343,"dataGaLocation":49},"/de-de/ai-transparency-center/","ai transparency center",{"text":345,"config":346},"Newsletter",{"href":347,"dataGaName":348,"dataGaLocation":49},"/company/contact/#contact-forms","newsletter",{"text":350,"config":351},"Presse",{"href":352,"dataGaName":353,"dataGaLocation":49},"/press/","press",{"text":355,"config":356,"lists":357},"Kontakt",{"dataNavLevelOne":297},[358],{"items":359},[360,363,368],{"text":56,"config":361},{"href":58,"dataGaName":362,"dataGaLocation":49},"talk to sales",{"text":364,"config":365},"Support-Portal",{"href":366,"dataGaName":367,"dataGaLocation":49},"https://support.gitlab.com","support portal",{"text":369,"config":370},"Kundenportal",{"href":371,"dataGaName":372,"dataGaLocation":49},"https://customers.gitlab.com/customers/sign_in/","customer portal",{"close":374,"login":375,"suggestions":382},"Schließen",{"text":376,"link":377},"Um Repositories und Projekte zu durchsuchen, melde dich an bei",{"text":378,"config":379},"gitlab.com",{"href":63,"dataGaName":380,"dataGaLocation":381},"search login","search",{"text":383,"default":384},"Vorschläge",[385,387,392,394,399,404],{"text":78,"config":386},{"href":83,"dataGaName":78,"dataGaLocation":381},{"text":388,"config":389},"Code Suggestions (KI)",{"href":390,"dataGaName":391,"dataGaLocation":381},"/de-de/solutions/code-suggestions/","Code Suggestions (AI)",{"text":23,"config":393},{"href":113,"dataGaName":23,"dataGaLocation":381},{"text":395,"config":396},"GitLab auf AWS",{"href":397,"dataGaName":398,"dataGaLocation":381},"/de-de/partners/technology-partners/aws/","GitLab on AWS",{"text":400,"config":401},"GitLab auf Google Cloud",{"href":402,"dataGaName":403,"dataGaLocation":381},"/de-de/partners/technology-partners/google-cloud-platform/","GitLab on Google Cloud",{"text":405,"config":406},"Warum GitLab?",{"href":91,"dataGaName":407,"dataGaLocation":381},"Why GitLab?",{"freeTrial":409,"mobileIcon":414,"desktopIcon":419,"secondaryButton":422},{"text":410,"config":411},"Kostenlos testen",{"href":412,"dataGaName":54,"dataGaLocation":413},"https://gitlab.com/-/trials/new/","nav",{"altText":415,"config":416},"GitLab-Symbol",{"src":417,"dataGaName":418,"dataGaLocation":413},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758203874/jypbw1jx72aexsoohd7x.svg","gitlab icon",{"altText":415,"config":420},{"src":421,"dataGaName":418,"dataGaLocation":413},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758203875/gs4c8p8opsgvflgkswz9.svg",{"text":203,"config":423},{"href":424,"dataGaName":425,"dataGaLocation":413},"https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com/de-de/compare/gitlab-vs-github/","get started",{"freeTrial":427,"mobileIcon":432,"desktopIcon":434},{"text":428,"config":429},"Erfahre mehr über GitLab Duo",{"href":430,"dataGaName":431,"dataGaLocation":413},"/de-de/gitlab-duo/","gitlab duo",{"altText":415,"config":433},{"src":417,"dataGaName":418,"dataGaLocation":413},{"altText":415,"config":435},{"src":421,"dataGaName":418,"dataGaLocation":413},{"freeTrial":437,"mobileIcon":442,"desktopIcon":444},{"text":438,"config":439},"Zurück zur Preisübersicht",{"href":191,"dataGaName":440,"dataGaLocation":413,"icon":441},"back to pricing","GoBack",{"altText":415,"config":443},{"src":417,"dataGaName":418,"dataGaLocation":413},{"altText":415,"config":445},{"src":421,"dataGaName":418,"dataGaLocation":413},{"title":447,"button":448,"config":453},"Sieh dir an, wie agentische KI die Softwarebereitstellung transformiert",{"text":449,"config":450},"GitLab Transcend jetzt ansehen",{"href":451,"dataGaName":452,"dataGaLocation":49},"/de-de/events/transcend/virtual/","transcend event",{"layout":454,"icon":455},"release","AiStar",{"data":457},{"text":458,"source":459,"edit":465,"contribute":470,"config":475,"items":480,"minimal":653},"Git ist eine Marke von Software Freedom Conservancy und unsere Verwendung von „GitLab“ erfolgt unter Lizenz.",{"text":460,"config":461},"Quelltext der Seite anzeigen",{"href":462,"dataGaName":463,"dataGaLocation":464},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/","page source","footer",{"text":466,"config":467},"Diese Seite bearbeiten",{"href":468,"dataGaName":469,"dataGaLocation":464},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/content/","web ide",{"text":471,"config":472},"Beteilige dich",{"href":473,"dataGaName":474,"dataGaLocation":464},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/CONTRIBUTING.md/","please contribute",{"twitter":476,"facebook":477,"youtube":478,"linkedin":479},"https://x.com/gitlab","https://www.facebook.com/gitlab","https://www.youtube.com/channel/UCnMGQ8QHMAnVIsI3xJrihhg","https://www.linkedin.com/company/gitlab-com",[481,504,559,586,620],{"title":67,"links":482,"subMenu":487},[483],{"text":484,"config":485},"DevSecOps-Plattform",{"href":76,"dataGaName":486,"dataGaLocation":464},"devsecops platform",[488],{"title":189,"links":489},[490,494,499],{"text":491,"config":492},"Tarife anzeigen",{"href":191,"dataGaName":493,"dataGaLocation":464},"view plans",{"text":495,"config":496},"Vorteile von Premium",{"href":497,"dataGaName":498,"dataGaLocation":464},"/de-de/pricing/premium/","why premium",{"text":500,"config":501},"Vorteile von Ultimate",{"href":502,"dataGaName":503,"dataGaLocation":464},"/de-de/pricing/ultimate/","why ultimate",{"title":505,"links":506},"Lösungen",[507,512,515,517,522,527,531,534,537,542,544,546,549,554],{"text":508,"config":509},"Digitale Transformation",{"href":510,"dataGaName":511,"dataGaLocation":464},"/de-de/topics/digital-transformation/","digital transformation",{"text":513,"config":514},"Sicherheit und Compliance",{"href":131,"dataGaName":138,"dataGaLocation":464},{"text":123,"config":516},{"href":108,"dataGaName":109,"dataGaLocation":464},{"text":518,"config":519},"Agile Entwicklung",{"href":520,"dataGaName":521,"dataGaLocation":464},"/de-de/solutions/agile-delivery/","agile delivery",{"text":523,"config":524},"Cloud-Transformation",{"href":525,"dataGaName":526,"dataGaLocation":464},"/de-de/topics/cloud-native/","cloud transformation",{"text":528,"config":529},"SCM",{"href":120,"dataGaName":530,"dataGaLocation":464},"source code management",{"text":23,"config":532},{"href":113,"dataGaName":533,"dataGaLocation":464},"continuous integration & delivery",{"text":161,"config":535},{"href":163,"dataGaName":536,"dataGaLocation":464},"value stream management",{"text":538,"config":539},"GitOps",{"href":540,"dataGaName":541,"dataGaLocation":464},"/de-de/solutions/gitops/","gitops",{"text":174,"config":543},{"href":176,"dataGaName":177,"dataGaLocation":464},{"text":179,"config":545},{"href":181,"dataGaName":182,"dataGaLocation":464},{"text":547,"config":548},"Öffentlicher Sektor",{"href":186,"dataGaName":187,"dataGaLocation":464},{"text":550,"config":551},"Bildungswesen",{"href":552,"dataGaName":553,"dataGaLocation":464},"/de-de/solutions/education/","education",{"text":555,"config":556},"Finanzdienstleistungen",{"href":557,"dataGaName":558,"dataGaLocation":464},"/de-de/solutions/finance/","financial services",{"title":194,"links":560},[561,563,565,567,570,572,574,576,578,580,582,584],{"text":206,"config":562},{"href":208,"dataGaName":209,"dataGaLocation":464},{"text":211,"config":564},{"href":213,"dataGaName":214,"dataGaLocation":464},{"text":216,"config":566},{"href":218,"dataGaName":219,"dataGaLocation":464},{"text":221,"config":568},{"href":223,"dataGaName":569,"dataGaLocation":464},"docs",{"text":244,"config":571},{"href":246,"dataGaName":247,"dataGaLocation":464},{"text":239,"config":573},{"href":241,"dataGaName":242,"dataGaLocation":464},{"text":249,"config":575},{"href":251,"dataGaName":252,"dataGaLocation":464},{"text":257,"config":577},{"href":259,"dataGaName":260,"dataGaLocation":464},{"text":262,"config":579},{"href":264,"dataGaName":265,"dataGaLocation":464},{"text":267,"config":581},{"href":269,"dataGaName":270,"dataGaLocation":464},{"text":272,"config":583},{"href":274,"dataGaName":275,"dataGaLocation":464},{"text":277,"config":585},{"href":279,"dataGaName":280,"dataGaLocation":464},{"title":295,"links":587},[588,590,592,594,596,598,600,604,609,611,613,615],{"text":302,"config":589},{"href":304,"dataGaName":297,"dataGaLocation":464},{"text":307,"config":591},{"href":309,"dataGaName":310,"dataGaLocation":464},{"text":315,"config":593},{"href":317,"dataGaName":318,"dataGaLocation":464},{"text":320,"config":595},{"href":322,"dataGaName":323,"dataGaLocation":464},{"text":325,"config":597},{"href":327,"dataGaName":328,"dataGaLocation":464},{"text":330,"config":599},{"href":332,"dataGaName":333,"dataGaLocation":464},{"text":601,"config":602},"Sustainability",{"href":603,"dataGaName":601,"dataGaLocation":464},"/sustainability/",{"text":605,"config":606},"Vielfalt, Inklusion und Zugehörigkeit",{"href":607,"dataGaName":608,"dataGaLocation":464},"/de-de/diversity-inclusion-belonging/","Diversity, inclusion and belonging",{"text":335,"config":610},{"href":337,"dataGaName":338,"dataGaLocation":464},{"text":345,"config":612},{"href":347,"dataGaName":348,"dataGaLocation":464},{"text":350,"config":614},{"href":352,"dataGaName":353,"dataGaLocation":464},{"text":616,"config":617},"Transparenzerklärung zu moderner Sklaverei",{"href":618,"dataGaName":619,"dataGaLocation":464},"https://handbook.gitlab.com/handbook/legal/modern-slavery-act-transparency-statement/","modern slavery transparency statement",{"title":621,"links":622},"Nimm Kontakt auf",[623,626,631,633,638,643,648],{"text":624,"config":625},"Sprich mit einem Experten/einer Expertin",{"href":58,"dataGaName":59,"dataGaLocation":464},{"text":627,"config":628},"Support",{"href":629,"dataGaName":630,"dataGaLocation":464},"/support/","get help",{"text":369,"config":632},{"href":371,"dataGaName":372,"dataGaLocation":464},{"text":634,"config":635},"Status",{"href":636,"dataGaName":637,"dataGaLocation":464},"https://status.gitlab.com/","status",{"text":639,"config":640},"Nutzungsbedingungen",{"href":641,"dataGaName":642,"dataGaLocation":464},"/terms/","terms of use",{"text":644,"config":645},"Datenschutzerklärung",{"href":646,"dataGaName":647,"dataGaLocation":464},"/de-de/privacy/","privacy statement",{"text":649,"config":650},"Cookie-Einstellungen",{"dataGaName":651,"dataGaLocation":464,"id":652,"isOneTrustButton":12},"cookie preferences","ot-sdk-btn",{"items":654},[655,657,659],{"text":639,"config":656},{"href":641,"dataGaName":642,"dataGaLocation":464},{"text":644,"config":658},{"href":646,"dataGaName":647,"dataGaLocation":464},{"text":649,"config":660},{"dataGaName":651,"dataGaLocation":464,"id":652,"isOneTrustButton":12},[662],{"id":663,"title":18,"body":8,"config":664,"content":666,"description":8,"extension":30,"meta":672,"navigation":12,"path":673,"seo":674,"stem":675,"__hash__":676},"blogAuthors/en-us/blog/authors/sandra-gittlen.yml",{"template":665},"BlogAuthor",{"role":667,"name":18,"config":668},"Managing Editor, GitLab Blog",{"headshot":669,"linkedin":670,"ctfId":671},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1749659648/Blog/Author%20Headshots/Sgittlen-headshot.jpg","https://www.linkedin.com/in/sandra-gittlen-48557a294/","sgittlen",{},"/en-us/blog/authors/sandra-gittlen",{},"en-us/blog/authors/sandra-gittlen","Y1hpWIa-4iLRjGVQU7Rsuo7D3zGggeSoWHEaLRZQ104",[678,692,704],{"content":679,"config":690},{"description":680,"authors":681,"heroImage":683,"date":684,"title":685,"body":686,"category":9,"tags":687},"Komm am 10. Februar 2026 auf die GitLab Transcend in München oder sei online live dabei. Finde heraus, wie du Produktivitätsgewinne mit Qualität, Zuverlässigkeit und Sicherheit in Einklang bringst.",[682],"Manav Khurana","https://res.cloudinary.com/about-gitlab-com/image/upload/v1767982271/e9ogyosmuummq7j65zqg.png","2026-01-12","KI verändert DevSecOps: Triff GitLab und erfahre, was als Nächstes kommt","**KI verspricht einen Quantensprung bei der Innovationsgeschwindigkeit, doch die meisten Software-Teams stoßen an ihre Grenzen.**\n\nLaut unserem brandneuen [Global DevSecOps Report mit Zahlen für Deutschland](https://learn.gitlab.com/de-developer-survey/report-de-de-de-devsecops-report-practitioner) macht KI-generierter Code mittlerweile 32 Prozent aller Entwicklungsarbeit aus. Dennoch berichten 75 Prozent der deutschen DevSecOps-Expert(inn)en, dass KI das Compliance-Management erschwert, und 78 Prozent sagen, dass agentische KI beispiellose Sicherheitsherausforderungen schaffen wird.\n\nDas ist das **KI-Paradoxon:** KI beschleunigt das Programmieren, aber die Software-Auslieferung verlangsamt sich, weil Teams damit kämpfen, den Code zu testen, abzusichern und zu deployen.\n\n> **[Lade dir unseren DevSecOps Report für Deutschland *kostenlos* herunter!](https://learn.gitlab.com/de-developer-survey/report-de-de-de-devsecops-report-practitioner)**\n\n## Produktivitätsgewinne treffen auf Workflow-Engpässe\n\nDas Problem ist nicht die KI selbst. Es liegt daran, wie Software heute entwickelt wird. Der traditionelle DevSecOps-Lebenszyklus enthält Hunderte kleiner Aufgaben, die Entwickler(innen) manuell bewältigen müssen: Tickets aktualisieren, Tests ausführen, Reviews anfordern, auf Freigaben warten, Merge-Konflikte beheben, Sicherheitsprobleme angehen. Diese Aufgaben kosten laut unserer Forschung jedes Teammitglied durchschnittlich sieben Stunden pro Woche.\n\nEntwicklungsteams produzieren Code schneller als je zuvor, aber dieser Code kriecht immer noch durch fragmentierte Toolchains, manuelle Übergaben und unverbundene Prozesse. Tatsächlich verwenden nahezu 60 Prozent der deutschen DevSecOps-Teams mehr als fünf Tools für die Softwareentwicklung insgesamt, und 45 Prozent nutzen mehr als fünf KI-Tools. Diese Fragmentierung schafft Kollaborationsbarrieren – 97 Prozent der deutschen DevSecOps-Fachleute erleben Faktoren, die die Zusammenarbeit im Software-Entwicklungszyklus einschränken.\n\nDie Antwort sind nicht noch mehr Tools. Es ist intelligente Orchestrierung, die Software-Teams und ihre KI-Agenten über Projekte und Release-Zyklen hinweg zusammenbringt – mit eingebauter Sicherheit, Governance und Compliance auf Enterprise-Niveau.\n\n## Auf der Suche nach tieferen Mensch-KI-Partnerschaften\n\nDevSecOps-Profis wollen nicht, dass KI übernimmt – sie wollen verlässliche Partnerschaften. Die große Mehrheit (81 Prozent) sagt, dass die Nutzung agentischer KI ihre Arbeitszufriedenheit erhöhen würde, und 38 Prozent stellen sich eine ideale Zukunft mit einer 50/50-Aufteilung zwischen menschlichen und KI-Beiträgen vor. Sie sind bereit, KI rund ein Drittel ihrer täglichen Aufgaben ohne menschliche Überprüfung anzuvertrauen, besonders bei Dokumentation, Test-Erstellung und Code-Reviews.\n\nWas wir deutlich von deutschen DevSecOps-Expert(inn)en gehört haben, ist, dass KI sie nicht ersetzen wird; vielmehr wird sie ihre Rollen grundlegend verändern. 80 Prozent der DevSecOps-Fachleute glauben, dass KI ihre Arbeit innerhalb von fünf Jahren erheblich verändern wird, und bemerkenswert ist, dass drei Viertel denken, dies wird mehr Engineering-Jobs schaffen, nicht weniger. Da das Programmieren mit KI einfacher wird, werden Ingenieur(inn)en, die Systeme entwerfen, Qualität sicherstellen und geschäftlichen Kontext anwenden können, sehr gefragt sein.\n\nEntscheidend ist, dass 84 Prozent zustimmen, dass es wesentliche menschliche Qualitäten gibt, die KI niemals vollständig ersetzen wird, einschließlich Kreativität, Innovation, Zusammenarbeit und strategische Vision.\n\nWie können Organisationen also die Lücke zwischen dem Versprechen der KI und der Realität fragmentierter Workflows überbrücken?\n\n## Komm zur GitLab Transcend: Erfahre, wie du mit agentischer KI echten Wert schaffst\n\nAm 10. Februar 2026 veranstaltet GitLab Transcend, wo wir zeigen werden, wie intelligente Orchestrierung die KI-gestützte Softwareentwicklung transformiert. Du erhältst einen ersten Blick auf GitLabs kommende Produkt-Roadmap und erfährst, wie Teams reale Herausforderungen lösen, indem sie Entwicklungs-Workflows mit KI modernisieren.\n\nOrganisationen, die in dieser neuen Ära gewinnen, balancieren KI-Einführung mit Sicherheit, Compliance und Plattform-Konsolidierung. KI bietet echte Produktivitätsgewinne, wenn sie durchdacht implementiert wird – nicht indem sie menschliche Entwickler(innen) ersetzt, sondern indem sie DevSecOps-Profis befreit, sich auf strategisches Denken und kreative Innovation zu konzentrieren.\n\n> ## **Registriere dich jetzt für unser Event in München oder die Online-Konferenz**\n>\n> [Hier geht's zur digitalen Transcend](https://about.gitlab.com/events/transcend/virtual/) und [hier zum Live-Event in München](https://about.gitlab.com/events/transcend/munich/). Sichere dir deinen Platz und erfahre, wie intelligente Orchestrierung deinen Software-Teams helfen kann, im Flow zu bleiben.\n> *Die Transcend in München wird auf Englisch stattfinden.*",[688,689,27],"AI/ML","DevOps platform",{"featured":12,"template":13,"slug":691},"ai-is-reshaping-devsecops-attend-gitlab-transcend-to-see-whats-next",{"content":693,"config":702},{"title":694,"category":9,"tags":695,"authors":696,"heroImage":698,"body":699,"description":700,"date":701},"Shift Left Security: DevSecOps richtig umsetzen – ein Praxisleitfaden",[689],[697],"GitLab Germany Team","https://res.cloudinary.com/about-gitlab-com/image/upload/v1765222301/czfqu7ajwcwyyn4beg6k.jpg","Traditionelle Sicherheitsmodelle geraten in modernen [DevOps-Umgebungen](https://about.gitlab.com/de-de/topics/devops/) schnell an ihre Grenzen. Sicherheitsprüfungen, die erst spät im Entwicklungsprozess erfolgen, verursachen hohe Kosten, lange Reaktionszeiten und unterbrechen agile Workflows. Der Shift Left Security-Ansatz begegnet diesen Herausforderungen, indem er Sicherheitsmaßnahmen frühzeitig integriert. Statt reaktiv auf Sicherheitslücken zu reagieren, werden Risiken bereits in der Entwicklungsphase erkannt und adressiert. Wir zeigen dir, wie dieser Ansatz funktioniert, welche Vorteile er bietet und wie du Shift Left Security umsetzt.\n\n## **Was ist Shift Left Security?**\n\nShift Left Security bezeichnet einen Ansatz in der Softwareentwicklung, bei dem Sicherheitsmaßnahmen möglichst früh im Entwicklungsprozess integriert werden.\n\nTraditionell wurden Sicherheitstests erst am Ende des Softwareentwicklungszyklus (SDLC) durchgeführt, zum Beispiel in der Test- oder Produktionsphase. Dieses Vorgehen führt oft zu höheren Kosten und längeren Entwicklungszeiten, wenn kritische Sicherheitslücken spät entdeckt werden.\n\nMit dem Shift Left Ansatz wird das Thema Sicherheit nun auf der Zeitachse der Anwendungsentwicklung nach links verschoben, sodass anfälliger Code früh entdeckt werden kann. Ziel ist es, Schwachstellen schon in den frühen Phasen wie Planung, Design oder Codierung zu erkennen und zu beheben, statt sie erst im späteren Verlauf oder nach dem Deployment zu adressieren.\n\n![Infografik So funktioniert Shift Left](https://res.cloudinary.com/about-gitlab-com/image/upload/v1765222295/lx0qqnnyse2ginovcnxb.jpg \"Schaubild: Shift Left Security, Sicherheitsmaßnahmen werden möglichst früh im Entwicklungsprozess integriert.\")\n\n## **Der Shift Left Ansatz**\n\nShift Left Security ist eine strategische Herangehensweise, bei der Sicherheit möglichst früh in den Entwicklungsprozess integriert wird – nicht durch ein einzelnes Tool, sondern durch eine Kombination verschiedener Maßnahmen.\n\nTypischerweise werden dafür Sicherheitstools entlang des Entwicklungszyklus eingesetzt, darunter:\n\n* **SCA (Software Composition Analysis)**: SCA erkennt Schwachstellen und Lizenzrisiken in Open-Source-Komponenten, indem es Paketverwaltung, Manifestdateien, Binärdateien und Container-Images analysiert. Die Ergebnisse werden in einer Software-Stückliste (sog.[ Software Bill of Materials](https://about.gitlab.com/de-de/blog/the-ultimate-guide-to-sboms/)) zusammengeführt und mit Schwachstellen- und Lizenzdatenbanken abgeglichen. So lassen sich Sicherheits- und Compliance-Probleme systematisch aufspüren und schnell adressieren.\n* **SAST (Static Application Security Testing)**: SAST ist ein White-Box-Verfahren, das den Quellcode analysiert, ohne die Anwendung auszuführen. Es spiegelt die Sichtweise von Entwickler(innen) wider und erkennt Schwachstellen früh im Softwareentwicklungszyklus, z. B. fehlende Eingabevalidierung oder unsichere Codemuster. Dadurch ist es besonders kosteneffizient. Laufzeit- oder umgebungsbezogene Probleme kann SAST allerdings nicht erfassen.\n* **DAST (Dynamic Application Security Testing)**: DAST ist ein Black-Box-Verfahren, das laufende Web-Anwendungen testet und sich an der Methodik potenzieller Angreifer(innen) orientiert. Es erkennt Schwachstellen wie XSS, fehlerhafte Authentifizierung oder Konfigurationsfehler zur Laufzeit – ohne Kenntnis des zugrundeliegenden Codes. DAST wird typischerweise in späten Phasen der Entwicklung oder in Testumgebungen eingesetzt und eignet sich ausschließlich für Web-Anwendungen und -Services.\n* **Secret Scanning:** Shift Left Security umfasst auch das Scannen von Container-Images und serverlosen Funktionen, da moderne Anwendungen zunehmend in Containern ausgeführt oder über serverlose Architekturen bereitgestellt werden. Beim Scannen eines [Container-Images](https://about.gitlab.com/de-de/topics/devsecops/beginners-guide-to-container-security/) wird der Inhalt auf Sicherheitslücken, Schwachstellen im Build-Prozess und fehlerhafte Konfigurationen geprüft. Ziel ist es, Probleme zu erkennen, bevor das Image in der Produktion verwendet wird. Das Scannen serverloser Funktionen erfordert spezielle Überwachungslösungen, die cloud-native Umgebungen abdecken und auch ohne klassische Serverinfrastruktur funktionieren.\n\nDiese Tools können einzeln oder kombiniert verwendet werden. Effektiver ist jedoch eine [automatisierte Sicherheitsplattform](https://about.gitlab.com/de-de/blog/why-are-organizations-moving-to-a-unified-devsecops-platform/), die Risiken in allen Phasen des Entwicklungszyklus erkennt – von der Codierung bis zur Bereitstellung. So können DevOps-Teams Schwachstellen frühzeitig und systematisch beheben.\n\n**Lesetipp:** [SAST vs. DAST - Die Unterschiede erklärt](https://about.gitlab.com/de-de/topics/devsecops/sast-vs-dast/)\n\n## **Vorteile der Shift Left Security**\n\nDie Linksverschiebung sicherheitsrelevanter Maßnahmen führt zu einer Reihe von Vorteilen für Unternehmen und Entwickler(innen).\n\n* **Frühzeitiges Erkennen von Sicherheitsrisiken:** Durch Sicherheitsanalysen direkt im Code oder bei der Integration von Abhängigkeiten lassen sich Schwachstellen erkennen, bevor sie in produktive Systeme gelangen. Dies verschafft Entwickler(innen) mehr Zeit für die Reaktion und reduziert die potenzielle Bedrohung (beispielsweise durch Exploits oder Datenlecks) erheblich.\n* **Geringere Kosten für Fehlerbehebung:** Je später ein Sicherheitsfehler entdeckt wird, desto teurer ist seine Behebung. Wird eine Schwachstelle bereits vor dem Build entdeckt, reicht oft eine einfache Codeänderung – ohne zusätzlichen Aufwand für Tests oder Deployments. Wird das Problem erst in der Produktion bemerkt, ist der Aufwand deutlich höher und der gesamte Prozess kann Wochen dauern. Frühes Eingreifen spart Zeit, senkt die Kosten und ermöglicht es Entwickler(innen), sich stärker auf neue Funktionen statt auf Notfallpatches zu konzentrieren.\n* **Schnellere Entwicklungszyklen:** Sicherheitsprobleme lassen sich schneller beheben, solange sie nur im Quellcode bestehen. Wird ein Problem erst kurz vor dem Release oder in der Produktion entdeckt, verlängert sich der Behebungsprozess deutlich – mit der Gefahr, gesetzte Fristen zu verpassen und die Time-to-Market zu verlangsamen.\n* **Bessere Codequalität:** Sicherheitsüberprüfungen fördern eine saubere Code-Architektur, konsistente Implementierung und verständlichen Code. So entstehen robuste und wartbare Anwendungen.\n* **Bessere Zusammenarbeit:** Shift Left Security fördert die Zusammenarbeitzwischen Entwickler(innen) und Security-Teams. Wird ein Sicherheitsproblem früh im Quellcode erkannt, können beide Seiten gemeinsam daran arbeiten, ohne Schuldzuweisungen oder Zeitdruck. Das verbessert die Kommunikation und stärkt das gegenseitige Verständnis.\n* **Reduziertes Risiko im Live-Betrieb:** Wird eine Schwachstelle erst im laufenden Betrieb entdeckt, sind schnelle und oft drastische Maßnahmen nötig – etwa das Abschalten der App. Wird die Schwachstelle hingegen bereits während der Entwicklung identifiziert, lässt sie sich mit geringem Aufwand und ohne größere Auswirkungen auf Nutzer(innen) beheben.\n\n***[Wie Dunelm, der britische Marktführer für Haushaltswaren, die Sicherheit \"nach links\" geschoben hat, steht in dieser ausführlichen Case Study.](https://about.gitlab.com/de-de/customers/dunelm/)***\n\n## **Best Practices für deinen Shift Left Security Ansatz**\n\nShift Left Security erfordert die frühzeitige und umfassende Integration von Sicherheitsmaßnahmen in den Entwicklungsprozess – idealerweise ab dem ersten Moment, in dem Entwickler(innen) mit dem Programmieren beginnen. Die Sicherheitsprüfung soll nicht nachgelagert, sondern integraler Bestandteil der täglichen Entwicklungsarbeit sein. Damit das gelingt, solltest du auf Best Practices zurückgreifen.\n\n### **\\#1 Integration von Sicherheitsmaßnahmen in die CI/CD-Pipeline**\n\nSicherheits-Scans sind ein zentrales Element des Shift-Left-Ansatzes. Ihre volle Wirkung entfalten sie aber nur, wenn die Ergebnisse unmittelbar in die[ DevOps-Toolkette](https://about.gitlab.com/de-de/topics/ci-cd/shift-left-devops/) eingebunden sind. Reports sollten direkt im CI/CD-Pipeline-Bericht angezeigt werden, sodass Entwickler(innen) sie ohne Umwege nutzen können. Zusätzlich sollte die Erstellung einer Software Bill of Materials (SBOM) automatisiert werden, um alle verwendeten Abhängigkeiten, Container-Images und serverlosen Funktionen transparent zu erfassen und systematisch auf bekannte Schwachstellen zu prüfen.\n\n### **\\#2 Anwendung von Security-Tools in der Entwicklungsumgebung**\n\nSicherheitsfunktionen sollten direkt in die Entwicklungsumgebung eingebunden werden, damit Schwachstellen bereits vor Übertragung in den Main Branch erkannt werden. Durch die Integration in die vertrauten Toolsets der Entwickler(innen) wird eine kontinuierliche Zusammenarbeit mit dem Security-Team ermöglicht und der Aufwand für nachträgliche Korrekturen deutlich reduziert.\n\n### **\\#3 Schulung von Entwickler(innen)**\n\nDamit Entwickler(innen) die Anwendungssicherheit bereits frühzeitig im Prozess berücksichtigen, ist eine intensive Schulung notwendig. Entwicklerteams müssen verstehen, warum sie Sicherheitsprüfungen frühzeitig durchführen – und welchen Beitrag das zur Gesamtqualität und Stabilität der Anwendung leistet. Dazu eignen sich praxisnahe und rollenbezogene Schulungsformate wie z. B. Code Labs, Code Guidelines oder Hands-on-Training.\n\n### **\\#4 Integration von Security Reviews in Code Reviews und Pull Requests**\n\nSicherheit sollte auch Teil von [Code Reviews](https://about.gitlab.com/de-de/topics/version-control/what-is-code-review/) sein. Teams können z. B. Checklisten mit sicherheitsrelevanten Aspekten verwenden. Pair Programming bietet zusätzlich die Möglichkeit, Sicherheit direkt beim Schreiben des Codes mitzudenken – vor allem in frühen Projektphasen.\n\n## **HackerOne + GitLab: Setze Shift Left Security einfach und kostengünstig um**\n\nEine der größten Herausforderungen für die Umsetzung der Shift Left Sicherheit für Entwicklerteams ist eine aufgeblähte Toolchain. Der Wechsel zwischen Tools und unklare Rollenverteilungen können die frühzeitige Integration von Sicherheitsüberprüfungen behindern.\n\nGitLab bietet mit HackerOne eine integrierte Lösung, die Security-Teams und Entwickler(innen) effektiv verbindet. Sicherheitslücken, die über HackerOne gemeldet und validiert werden, werden automatisch in GitLab als Tickets angelegt. Diese enthalten unter anderem:\n\n* Synchronisation von Kommentaren\n* Statusänderungen\n* Zuständigkeiten\n* Belohnungen\n* Fälligkeitsdaten\n\nDie Kommunikation erfolgt dabei bidirektional zwischen beiden Plattformen. Die Integration ermöglicht es somit Entwickler(innen), im gewohnten Workflow zu bleiben und Sicherheitslücken direkt zu bearbeiten.\n\n### **Auswirkungen der automatisierten Sicherheitsintegration**\n\nDie Integration von HackerOne und GitLab führt in der Praxis zu:\n\n* Bis zu 70 Prozent Zeitersparnis von der Entdeckung bis zur Behebung von Schwachstellen\n* Erhöhte Transparenz über den Sicherheitsstatus im gesamten Unternehmen\n* Effektivere Nutzung der Ressourcen im Security-Team\n* Gesteigerte Zufriedenheit der Entwickler(innen), da sie im bevorzugten Workflow bleiben können\n\n## **Keine Kompromisse bei der Shift Left Security**\n\nShift Left Security verschiebt das Thema Sicherheit weg von der Endkontrolle hin zur kontinuierlichen Begleitung des Entwicklungsprozesses. Durch Tools wie SAST, DAST, SCA und Container-Scanning lassen sich Schwachstellen frühzeitig identifizieren – noch bevor sie produktiv wirksam werden. Das senkt Kosten, reduziert Risiken und beschleunigt Entwicklungszyklen.\n\nErfolgreich ist dieser Ansatz jedoch nur, wenn Sicherheitsprüfungen eng in die[ CI/CD-Pipeline](https://about.gitlab.com/de-de/topics/ci-cd/cicd-pipeline/) und Entwicklungsumgebungen integriert werden und Entwickler(innen) durch gezielte Schulungen und klare Prozesse unterstützt werden. Die Fallstudie zu GitLab und HackerOne zeigt zudem, dass integrierte Plattformen Kontextwechsel vermeiden und die Effizienz deutlich steigern können. Entscheidend für eine nachhaltige Umsetzung ist eine Sicherheitskultur, in der Entwicklung und Security partnerschaftlich und auf Augenhöhe zusammenarbeiten.","Erkenne und behebe Sicherheitslücken früh mit Shift-Left-Security. Lerne aus HackerOnes GitLab-Story und erhalte praxisnahe DevSecOps-Tipps.","2025-12-08",{"featured":34,"template":13,"slug":703},"devsecops-shift-left-guide",{"content":705,"config":714},{"title":706,"description":707,"authors":708,"date":709,"body":710,"category":9,"tags":711,"heroImage":713},"Cloud-Kosten systematisch steuern – mit FinOps","FinOps verbindet Finance und IT, macht Cloud-Kosten transparent und wandelt reaktive Rechnungszahlung in proaktive Wert-Optimierung um.",[697],"2025-11-19","**FinOps** ist die Disziplin, die Cloud-Kosten-Management transformiert – von reaktiver Rechnungszahlung zu proaktiver Wert-Optimierung. Sie vereint Finance-, Technical- und Business-Teams um eine gemeinsame Sprache.\n\nWährend Cloud-Nutzung intensiviert wird, kämpfen Organisationen mit Ausgaben-Kontrolle. Ein Gartner-Report zeigt: **[69% der Organisationen überschritten 2023 ihr Cloud-Budget](https://www.gartner.com/peer-community/oneminuteinsights/omi-keeping-cloud-costs-check-it-leader-perspectives-rfz)**.\n\nDiese Unvorhersagbarkeit schwächt Finance-Vertrauen und erhöht Druck auf IT-Teams. FinOps bietet strukturierte Antwort: Kosten in Echtzeit sichtbar machen, Kultur gemeinsamer Verantwortung etablieren und jede Ausgabe an generiertem Business-Wert ausrichten.\n\nMehr als reine Kostenreduktions-Strategie ist FinOps ein operativer und kultureller Rahmen. Er ermöglicht Organisationen, Kontrolle über Cloud-Budgets zurückzugewinnen ohne Agilität oder Innovation zu opfern. Dieser Ansatz wird besonders relevant, wenn er direkt in [DevOps](https://about.gitlab.com/de-de/topics/devops/)- und [CI/CD](https://about.gitlab.com/de-de/topics/ci-cd/)-Praktiken integriert wird, die auf der [GitLab-Plattform](https://about.gitlab.com/de-de/why-gitlab/) verfügbar sind.\n\n> **[→ GitLab Ultimate und GitLab Duo Enterprise kostenlos testen.](https://about.gitlab.com/de-de/free-trial/devsecops/?utm_medium=blog&utm_source=blog&utm_campaign=eg_emea_x_trial_x_de_blog_de)**\n\n## FinOps: Definition\n\nDer Begriff **FinOps**, Kurzform von *Financial Operations*, bezeichnet eine Disziplin, geboren aus einfacher Erkenntnis: explodierende Cloud-Nutzung erfordert neue finanzielle Governance. Klassische Budget-Methoden reichen nicht mehr, da sie Cloud-spezifische Schwankungen und Komplexität nicht berücksichtigen.\n\nFinOps geht weit über **Kostenreduktion** hinaus. Es geht nicht nur darum, Verschwendung zu tracken oder Rabatte mit Providern zu verhandeln. Es ist ein **kultureller und organisatorischer Ansatz**, der Finance-, Technology- und Business-Teams vereint. Sein Ziel: Innovation kanalisieren ohne zu bremsen, indem allen klare Sicht auf finanzielle Impacts ihrer **Infrastruktur**- und **Operations**-Entscheidungen gegeben wird.\n\nEine FinOps-Organisation sucht nicht, weniger auszugeben, sondern **besser auszugeben**: in die richtigen Ressourcen investieren, zum richtigen Zeitpunkt, mit messbarem Business-Return.\n\n## Warum wurde FinOps unverzichtbar?\n\nMulticloud setzt sich in den meisten Organisationen durch. AWS, Azure, Google Cloud und Private-Lösungen koexistieren, jeder mit eigenen Pricing-Modellen und Rabatten. Diese Diversität macht Budget-Tracking fragmentiert und verstärkt Governance-Komplexität.\n\nZu dieser Diversität kommen **Kosten-Schwankungen**. In selbst-gehosteten (On-Premise) Systemen war Budget im Voraus fixiert. In der Cloud kann jeder Load-Spike, Test-Projekt oder beschleunigtes Deployment die Rechnung über Nacht erhöhen. Diese Unvorhersagbarkeit unterminiert klassische Finance-Methoden und schafft dringenden Bedarf nach neuen Management-Praktiken.\n\nFinance-Services verlangen inzwischen mehr als unverständliche monatliche Cloud-Rechnungen. Sie erwarten verlässliche Prognosen, klare Ausgaben-Aufschlüsselung und Management-Logik vergleichbar mit anderen Unternehmens-Investitionen.\n\nDaher wurde Abstimmung zwischen Kosten und Business-Wert zentral. Jede Ausgabe muss mit einem Produkt oder Customer-Experience verknüpfbar sein. FinOps bringt diese gemeinsame Sprache, die technische Rechnung in Business-Dashboard transformiert.\n\nIn diesem Kontext entstand FinOps als strukturierter Rahmen zur Komplexitäts-Beherrschung.\n\n## Fundamentale FinOps-Prinzipien\n\nFinOps basiert auf geteilter Kultur, strukturiert um mehrere Schlüsselprinzipien:\n\n* **Team-übergreifende Kollaboration**: Kein Akteur kann allein steuern. Finance bringt Budget-Kontrolle, Engineering technische Realität, und Business-Teams Wert-Perspektive. Gemeinsam bauen sie eine **Organisation** fähig zu ausgewogenen Entscheidungen, aber diese Sharing-Logik allein reicht nicht.\n* **Verteilte Verantwortung und Governance**: Jedes Team übernimmt Kosten seiner technischen Entscheidungen (*you build it, you run it, you pay it*), aber zentrale Funktion definiert Standards, setzt KPIs und liefert Tools zur globalen Konsistenz-Aufrechterhaltung. Diese Governance beschränkt sich nicht auf Kosten – sie betrifft auch **Management** von Umgebungen und Ressourcen.\n* **Business-Wert als Kompass**: Cloud-Ausgabe macht nur Sinn, wenn sie zu Produkt, Service oder Customer-Experience beiträgt. FinOps misst diese direkte Verknüpfung zwischen Kosten und ROI.\n* **Transparenz und Reaktivität durch Daten**: Kosten müssen in Echtzeit sichtbar sein mit klarem, actionable Reporting – idealerweise in Workflows, wo Teams bereits arbeiten. Dies ist Bedingung für schnelle Korrektur und Vertrauensaufbau.\n* **Dezentralisierte Entscheidungsfindung mit zentraler Governance**: Teams treffen Echtzeit-Entscheidungen über ihre Ressourcen im Rahmen etablierter Leitplanken statt auf Approval-Chains zu warten.\n* **Variables Cloud-Modell**: Statt Schwankungen zu erleiden, macht FinOps sie zum Asset. Ressourcen an Bedarf anpassen, Skalierung automatisieren und via Reservierungen antizipieren transformiert Flexibilität in strategischen Hebel.\n* **Kontinuierliche Optimierungs-Kultur**: FinOps ist permanente Praxis, kein punktuelles Projekt. Teams identifizieren kontinuierlich Verschwendung, optimieren Ressourcen und verfeinern Prozesse während Cloud-Nutzung evolviert.\n\nDiese Prinzipien bilden das kulturelle Fundament. Für Umsetzung braucht es klaren Rahmen und definierten Lifecycle, fähig Organisationen über Zeit zu begleiten.\n\n## FinOps-Framework und Lifecycle\n\nZur Transformation dieser Prinzipien in nachhaltige Praktiken bietet die FinOps Foundation ein anerkanntes **Framework**. Es beschreibt Action-Domänen, involvierte Rollen und Reife-Stufen.\n\n### Die drei Framework-Domänen\n\nDas FinOps Foundation Framework basiert auf drei permanenten Domänen:\n\n* **Informieren**: Kosten sichtbar und verständlich machen durch Echtzeit-Finance-Daten-Sharing.\n* **Optimieren**: Ineffizienzen identifizieren, Ressourcen anpassen und kontinuierliche Optimierungs-Logik einführen.\n* **Operieren**: Nachhaltige Governance installieren und langfristig steuern.\n\nDiese Domänen sind nicht sequenziell – sie bilden kontinuierlichen Zyklus. Je besser informiert wird, desto besser optimiert wird, und desto mehr verankert sich Governance in der Organisation.\n\n### Rollen und Organisations-Reife\n\nJede Domäne mobilisiert spezifische Akteure: Finance für Budget-Kontrolle, Engineering für technische Übersetzung, Business-Teams für Business-Wert und Governance für gemeinsame Standards.\n\nFinOps-Einführung misst sich auch an Reife-Stufen (*crawl, walk, run*), die schrittweisen Weg einer Organisation zu vollständig beherrschtem Cloud-Management abbilden.\n\n### Die \"Crawl, Walk, Run\"-Stufen\n\nDas **Crawl-Walk-Run**-Modell beschreibt Organisations-Reife:\n\n* **Crawl**: Erste Schritte, Basic-Reporting, wenige nachverfolgte KPIs.\n* **Walk**: Praktiken-Integration, regelmäßige Optimierung, erste Rituale und Automatisierungen.\n* **Run**: Fortgeschrittene Reife, komplette Automatisierung, robuste Governance, FinOps in Unternehmensstrategie integriert.\n\nDieser Rahmen gibt Organisationen einen Kompass: er ermöglicht zu wissen, wo sie stehen und wie sie zu nachhaltiger Cloud-Ausgaben-Beherrschung fortschreiten.\n\n## Warum und wie FinOps-Modell einführen?\n\nFinOps-Ansatz umzusetzen bedeutet, diese Herausforderungen zu adressieren: Kosten-Schwankungen, Budget-Druck, Transparenz-Bedarf und Effizienz-Suche. Für Erfolg muss Deployment schrittweise sein und in realen Use Cases verankert.\n\n### Cloud-Kosten-Schwankungen und -Unvorhersagbarkeit beherrschen\n\nCloud funktioniert nach Nutzung, was Kosten natürlich schwanken lässt. Um zu vermeiden, dass diese Instabilität zu Budget-Risiko wird, erfordert FinOps: Consumption-Spikes zu kartieren, Budget-Steuerungs-Regeln zu setzen und Infrastruktur-Szenarien zu modellieren. Ziel: unvorhersagbare Ausgabe in kontrollierte Ausgabe transformieren.\n\n### Kosten und Business-Wert abstimmen\n\nSobald Transparenz erreicht ist, wird die Frage: *Schafft jede Ausgabe wirklich Wert?* FinOps verknüpft Kosten mit Produkten und Services und misst sie via Unit-Indikatoren wie Kosten pro User oder pro Transaktion. Dieser Ansatz ermöglicht Investment-Priorisierung nach Business-ROI und gibt Cloud-Kosten Bedeutung.\n\n### Governance und geteilte Regeln etablieren\n\nDamit diese Logik über Zeit hält, ist klare Governance notwendig. Tagging-Standards, Ressourcen-Owner-Definition und Budget-Attribution pro Team garantieren Nachvollziehbarkeit. Arbitrage-Prozesse ergänzen diesen Rahmen, validiert auf höchster Unternehmensebene. Governance wird dann Rückgrat des Modells.\n\n### Auf dedizierte Tools und Metriken setzen\n\nGovernance funktioniert nicht ohne verlässliche Daten. Cloud-Provider bieten eigene Tracking-Tools, aber diese bleiben oft fragmentiert und schwer vergleichbar. Die Herausforderung: Information zentralisieren und in derselben Umgebung umsetzbar machen. Einfache KPIs wie Kosten pro Workload, pro User oder Effizienz pro Team zeigen bereits die Verknüpfung zwischen Nutzung und Wert. Direkt in existierende Workflows integriert werden sie konkrete tägliche Steuerungs-Hebel.\n\n### Schrittweisen Ansatz verfolgen\n\nFinOps erfordert keine Komplettumstellung. Erfolg kommt durch schrittweise Einführung: FinOps-MVP starten wie ein [DevOps-Projekt](https://about.gitlab.com/de-de/solutions/devops-platform/), schnelle Gewinne einfahren und Umfang schrittweise erweitern. Ziel ist nicht sofortige Perfektion, sondern Aufbau nachhaltiger Dynamik, die sich in Kultur verankert.\n\n### Beispiele schneller Aktionen für FinOps-Strategie-Entwicklung\n\nEine FinOps-Strategie muss Wert schnell demonstrieren. Drei einfache Aktionen reichen oft, sichtbare Einsparungen zu generieren und den Ansatz zu validieren:\n\n* **Orphan-Ressourcen eliminieren**: Vergessene Storage-Volumes, ungenutzte IPs oder inaktive Test-Umgebungen. Diese diskreten Leaks repräsentieren oft mehrere Prozent der monatlichen Rechnung.\n* **Überbereitgestellte Instances rightsizen**: Viele Ressourcen laufen auf Bruchteil ihrer Kapazität. Größen-Anpassung reduziert Kosten sofort ohne Infrastruktur-Performance-Verlust.\n* **Nicht-kritische Umgebungen automatisch stoppen**: Nachts und Wochenenden abschalten, was nicht kontinuierlich laufen muss, generiert wiederkehrende, einfache, nachhaltige Einsparungen.\n\nDiese schnellen Gesten geben klares Signal: FinOps produziert sofortige Ergebnisse und bereitet Boden für nachhaltige Einführung.\n\n> **Die FinOps Foundation**: Gegründet 2019 und an Linux Foundation angegliedert, definiert die FinOps Foundation Disziplin-Standards und föderiert globale Community. Sie verbreitet anerkanntes Framework (Inform, Optimize, Operate), bietet Trainings und Zertifizierungen und organisiert Practitioner-Austausch. Sie ist heute die Referenz zur Strukturierung und Weiterentwicklung von FinOps-Praktiken.\n\n## FinOps-Herausforderungen und -Limitationen\n\nFinOps-Ansatz zu übernehmen ist kein ruhiger Fluss. Während die Disziplin durch Transparenz- und Kontroll-Versprechen überzeugt, konfrontiert Implementierung Organisationen mit mehreren wiederkehrenden Hindernissen.\n\n### Schwieriger Kultur-Wandel\n\nDie erste Herausforderung ist kulturell. FinOps reduziert sich nicht auf Tool- oder Dashboard-Deployment – es ist primär eine **neue Art zusammenzuarbeiten**. Finance-, Technology- und Business-Teams müssen Verantwortungen teilen, was Gewohnheiten durcheinanderbringt. Wie bei jeder Transformation ist **Widerstands gegen Veränderung** oft das erste Hindernis.\n\nDiese kulturelle Schwierigkeit führt zu einer weiteren.\n\n### Organisatorische Silos bremsen Kollaboration\n\nIn vielen Organisationen bleiben Teams in Silos eingeschlossen: Finance auf einer Seite, IT auf der anderen, Business-Teams separat. Ohne reibungslose Kommunikation ist Abstimmung zwischen Kosten und Business-Wert unmöglich. FinOps-Governance zielt präzise darauf ab, diese Trennwände zu durchbrechen, aber dies erfordert **starken Management-Support** zur Änderung organisatorischer Reflexe.\n\nUnd selbst wenn Teams kooperieren, tritt ein weiteres Hindernis auf: die Daten selbst.\n\n### Partielle Sichtbarkeit und komplexe Daten-Nutzung\n\nCloud-Kosten sind notorisch schwer zu lesen, besonders in Multicloud-Umgebungen. Daten existieren, bleiben aber oft **verstreut, roh und schwer zu interpretieren**. Teams haben nicht immer die richtigen Tools zur Zentralisierung und Umsetzbarkeit. FinOps-versprochene Transparenz kann daher auf technische und analytische Grenzen stoßen.\n\nDieser Klarheits-Mangel paart sich mit Kompetenz-Mangel.\n\n### Mangel an Kompetenzen und passenden Tools\n\nFinOps ist noch junge Disziplin, und erfahrene Profile sind rar. Viele Organisationen müssen Teams intern schulen, was Einführung schrittweise aber manchmal langsam macht. Diese Kompetenz-Entwicklung ist essenziell, da Erfolg gleichermaßen auf Kultur und Technik basiert.\n\nTools repräsentieren eine weitere Herausforderung. Organisationen haben zahlreiche Tools zur Cloud-Kosten-Analyse, aber diese Lösungen sind oft verstreut und schwer in einheitliche Vision zu integrieren. Das Ergebnis ist paradox: mehr Daten, aber nicht notwendigerweise mehr Klarheit.\n\nDie wahre Herausforderung ist daher, einen Tool-Ansatz zu bauen, der einfach bleibt und auf Organisations-Reife abgestimmt ist. Schrittweise vorgehen, Lesbarkeit und Effizienz priorisieren, verhindert Transformation eines Governance-Problems in Tool-Problem.\n\n### Inhärent instabiles Cloud-Budget\n\nSelbst mit solider Governance und performanten Tools bleiben Cloud-Kosten naturgemäß instabil. Load-Spikes, Hybrid-Umgebungen oder KI-Workloads schaffen schwer vorhersagbare Schwankungen. Budget-Prognosen müssen daher permanent revidiert werden, da unerwarteter Verbrauch selbst strengste Schätzungen entgleisen lassen kann.\n\nDiese Hindernisse machen FinOps nicht ungültig – sie zeigen, warum die Disziplin weiter evolvieren muss.\n\n## FinOps-Trends und Perspektiven\n\nDer FinOps-Ansatz steht erst am Anfang seiner Geschichte. Die Disziplin evolviert kontinuierlich zur Adressierung neuer Herausforderungen, die weit über reine Kosten-Fragen hinausgehen.\n\nDer erste Trend ist **Nachhaltigkeit**. Mehr und mehr Organisationen wollen Cloud-Ausgaben optimieren und gleichzeitig Carbon-Footprint reduzieren. FinOps öffnet sich zu **GreenOps**, wo ökonomische Performance und Umwelt-Verantwortung Hand in Hand gehen.\n\nDie zweite Evolution ist **Automatisierung**. Wachsende Cloud-Komplexität macht manuelle Steuerung unmöglich. FinOps-as-Code-Praktiken und KI-Nutzung zur Verbrauchs-Analyse oder automatischen Ressourcen-Anpassung werden zur Norm.\n\nDritte Transformation: Impact von **KI-Workloads**. Diese massiven, unvorhersagbaren Loads redefinieren Cloud-Finance-Governance. Sie erzwingen neue Prognose-Methoden, neue Indikatoren und noch engere Kollaboration zwischen Finance und Engineering.\n\nDie vierte Änderung ist **Konvergenz mit Platform Engineering**. Während Organisationen interne Development-Plattformen zur Standardisierung und Beschleunigung von Software-Delivery bauen, findet FinOps seinen effizientesten Umsetzungs-Kanal. Platform-Teams integrieren Kosten-Intelligence direkt in die Struktur, wie Software gebaut und deployed wird. Durch Self-Service-Portale, \"Golden Paths\" und Infrastruktur-Templates machen sie Kosten-Optimierung zu Standard-Verhalten statt Nachgedanke. Teams erhalten Echtzeit-Kosten-Feedback in Workflows, Ressourcen-Limits werden via Policy as Code durchgesetzt, und finanzielle Guardrails werden unsichtbare Plattform-Features. Es geht nicht nur darum, Kosten-Dashboards hinzuzufügen – es geht darum, fundamental zu überdenken, wie FinOps in großem Maßstab funktioniert.\n\nSchließlich bleibt Reife noch niedrig. Viele Organisationen machen erste Schritte, oft im \"Crawl\"-Stadium. Die Herausforderung kommender Jahre: **gemeinsam Reife steigern**, damit FinOps nicht punktuelle Initiative, sondern integrierte organisatorische Kompetenz wird.\n\nFinOps ist daher kein Selbstzweck, sondern schrittweiser Ansatz. Er ermöglicht, Cloud von unvorhersagbarem Kosten-Center in strategischen Hebel zu transformieren. Direkt in DevSecOps- und CI/CD-Praktiken integriert, bringt er Finance-, Technology- und Business-Teams noch enger um gemeinsame Ziele zusammen.\n\nDieser Weg beginnt mit Integration von FinOps-Praktiken direkt in existierende Development-Workflows. Hier kommen Plattformen wie GitLab ins Spiel.\n\n## GitLab und FinOps-Ansatz\n\nGitLab trägt zum FinOps-Ansatz bei durch Sichtbarkeit auf Development-Ressourcen-Nutzung. Die Plattform ermöglicht Tracking von Compute-Minuten-Verbrauch pro Projekt und Namespace, erleichtert damit Kosten-Zuordnung zu Teams. Zudem können Admins Nutzungs-Quotas konfigurieren und Verbrauchs-Trends via Usage-Dashboards überwachen. Dieser Ansatz hilft Organisationen, ihre [CI/CD-Pipeline](https://about.gitlab.com/de-de/topics/ci-cd/cicd-pipeline/)-bezogenen Ausgaben besser zu verstehen und Runner-Nutzung zu optimieren. Durch Integration dieser Metriken in Development-Workflows sensibilisiert GitLab Technical-Teams für Impact ihrer Praktiken auf operative Kosten.\n\n> **[→ GitLab Ultimate und GitLab Duo Enterprise kostenlos testen.](https://about.gitlab.com/de-de/free-trial/devsecops/?utm_medium=blog&utm_source=blog&utm_campaign=eg_emea_x_trial_x_de_blog_de)**",[712,23],"DevOps","https://res.cloudinary.com/about-gitlab-com/image/upload/v1760520341/suhp5cpbgzqikafvl7p1.jpg",{"featured":34,"template":13,"slug":715},"what-is-finops",{"promotions":717},[718,732,743],{"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":247},"/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":735,"text":723,"button":736,"image":740},"devops-modernization",[28,9],"Are you just managing tools or shipping innovation?",{"text":737,"config":738},"Get your DevOps maturity score",{"href":739,"dataGaName":728,"dataGaLocation":247},"/assessments/devops-modernization-assessment/",{"config":741},{"src":742},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1772138785/eg818fmakweyuznttgid.png",{"id":744,"categories":745,"header":746,"text":723,"button":747,"image":751},"security-modernization",[27],"Are you trading speed for security?",{"text":748,"config":749},"Get your security maturity score",{"href":750,"dataGaName":728,"dataGaLocation":247},"/assessments/security-modernization-assessment/",{"config":752},{"src":753},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1772138786/p4pbqd9nnjejg5ds6mdk.png",{"header":755,"blurb":756,"button":757,"secondaryButton":762},"Beginne noch heute, schneller zu entwickeln","Entdecke, was dein Team mit der intelligenten Orchestrierungsplattform für DevSecOps erreichen kann.\n",{"text":758,"config":759},"Kostenlosen Test starten",{"href":760,"dataGaName":54,"dataGaLocation":761},"https://gitlab.com/-/trial_registrations/new?glm_content=default-saas-trial&glm_source=about.gitlab.com/","feature",{"text":56,"config":763},{"href":58,"dataGaName":59,"dataGaLocation":761},1772652052587]