<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
    <id>https://about.gitlab.com/blog</id>
    <title>GitLab</title>
    <updated>2025-07-03T13:17:59.541Z</updated>
    <generator>https://github.com/jpmonette/feed</generator>
    <author>
        <name>The GitLab Team</name>
    </author>
    <link rel="alternate" href="https://about.gitlab.com/blog"/>
    <link rel="self" href="https://about.gitlab.com/atom.xml"/>
    <subtitle>Gitlab Blog RSS feed</subtitle>
    <icon>https://about.gitlab.com/favicon.ico</icon>
    <rights>All rights reserved 2025,</rights>
    <entry>
        <title type="html"><![CDATA[GitLab Ultimate für IBM Z: Moderne DevSecOps für Mainframes]]></title>
        <id>https://about.gitlab.com/de-de/blog/gitlab-ultimate-for-ibm-z-modern-devsecops-for-mainframes/</id>
        <link href="https://about.gitlab.com/de-de/blog/gitlab-ultimate-for-ibm-z-modern-devsecops-for-mainframes/"/>
        <updated>2025-06-20T00:00:00.000Z</updated>
        <content type="html"><![CDATA[<p>GitLab und IBM haben sich zusammengeschlossen, um eine grundlegende Diskrepanz in der Unternehmensentwicklung zu lösen: Mainframe-Entwickler(innen) sollen mit denselben modernen Tools, Workflows und Kollaborationsfunktionen arbeiten können wie ihre Kolleg(inn)en in verteilten Umgebungen.</p>
<p>GitLab Ultimate für IBM Z, eine von GitLab zertifizierte, integrierte DevSecOps-Lösung, die speziell für die Mainframe-Umgebung entwickelt wurde, macht genau das möglich: Sie ermöglicht es Unternehmen, ihre Mainframe-Entwicklungsworkflows zu modernisieren, indem eine nahtlose Migration von veralteten Legacy-Bibliotheksmanagern erleichtert wird. Mit CI/CD-Pipelines, die nativ auf IBM z/OS laufen, erleben Kund(inn)en beschleunigte Innovation und reduzierte Betriebskosten.</p>
<h2>Herausforderungen der heutigen Mainframe-Entwicklung</h2>
<p>Unternehmen, die IBM Z-Systeme für geschäftskritische Workloads einsetzen, stehen vor Herausforderungen, für die herkömmliche DevSecOps-Tools nicht ausgestattet sind. Cloud-native Teams profitieren von modernen <a href="https://about.gitlab.com/topics/ci-cd/">CI/CD</a>-Pipelines, kollaborativer Entwicklung und automatisierten Tests. Im Gegensatz dazu werden Mainframe-Teams oft zurückgelassen – sie stecken mit veralteten Tools fest, die zu kostspieligen Ineffizienzen und operativen Silos führen.</p>
<p>Teams greifen oft auf Workarounds zurück, wie SSH-Verbindungen und manuelle Dateiübertragungen, die Sicherheitslücken schaffen und Audits erschweren. Wenn Compliance-Anforderungen streng sind, werden diese improvisierten Lösungen zu inakzeptablen Risiken. Gleichzeitig unterhalten Organisationen teure parallele Toolchains, wobei Legacy-Mainframe-Entwicklungstools Premium-Lizenzkosten verursachen, während sie im Vergleich zu modernen Alternativen nur eingeschränkte Funktionalität bieten.</p>
<p>Diese Fragmentierung schafft zwei Probleme: langsamere Bereitstellungszyklen und Schwierigkeiten bei der Rekrutierung von Entwickler(inne)n, die modernste Prozesse erwarten.</p>
<blockquote>
<p><strong>„GitLab Ultimate für IBM Z stellt einen wichtigen Schritt zur Bewältigung einer langjährigen Branchenherausforderung dar. IDC-Forschung zeigt, dass Mainframe-Entwickler(innen) oft mit Legacy-Tools arbeiten, die zu Bereitstellungsineffizienzen beitragen und es schwieriger machen, neue Talente anzuziehen. Mit diesem Angebot werden moderne DevSecOps-Fähigkeiten und einheitliche Workflows direkt auf den Mainframe gebracht. Dies befähigt Entwickler(innen), kollaborativer und effizienter zu arbeiten, während es Organisationen hilft, Innovation zu beschleunigen und Mainframe-Entwicklung in breitere digitale Transformationsstrategien zu integrieren.&quot;</strong> - Katie Norton, Research Manager, DevSecOps und Software Supply Chain Security bei IDC</p>
</blockquote>
<h2>Vereinheitlichte Entwicklungsumgebungen</h2>
<p>Wahre Modernisierung bedeutet mehr als nur die Aktualisierung der Mainframe-Entwicklung. Es bedeutet, eine einheitliche Plattform zu schaffen, auf der Mainframe-, Cloud-native-, Web- und Mobile-Entwicklungsteams nahtlos zusammenarbeiten.</p>
<p>GitLab Ultimate für IBM Z ermöglicht es Entwickler(inne)n, konsistente Workflows zu verwenden, unabhängig davon, ob sie auf z/OS, Cloud oder On-Premises-Infrastruktur bereitstellen – Wissen wird zwischen Teams übertragen, anstatt in Silos zu verbleiben. Organisationen können schrittweise modernisieren, ohne Geschäftsunterbrechungen, da Legacy-Systeme weiterhin funktionieren, während Teams moderne Praktiken in ihrem eigenen Tempo übernehmen.</p>
<p>Während Organisationen Hybrid-Cloud-Strategien verfolgen, bietet GitLab die Grundlage für Anwendungen, die sich über Mainframe- und Cloud-native-Umgebungen erstrecken.</p>
<h2>Was ist GitLab Ultimate für IBM Z?</h2>
<p>GitLab Ultimate für IBM Z bietet native z/OS-Runner-Unterstützung und ermöglicht eine nahtlose CI/CD-Pipeline-Ausführung direkt auf Ihrer Mainframe-Infrastruktur. Diese von GitLab zertifizierte Lösung hilft, die Notwendigkeit komplexer Workarounds zu eliminieren und gleichzeitig die Sicherheit und Zuverlässigkeit zu gewährleisten, die Ihre Unternehmensanwendungen erfordern.</p>
<p>Die Kombination aus GitLabs umfassender DevSecOps-Plattform und IBMs tiefgreifender Mainframe-Expertise schafft etwas Einzigartiges auf dem Markt: eine zertifizierte Lösung, die eine echte Brücke zwischen unternehmenskritischen Legacy-Systemen und Cloud-nativer Innovation bietet.</p>
<h2>GitLab Ultimate für IBM Z Funktionen</h2>
<p>GitLab Ultimate für IBM Z bietet Unternehmensteams die Tools, die sie benötigen, um die Mainframe-Entwicklung zu modernisieren und gleichzeitig kritische Geschäftssysteme zu erhalten.</p>
<p><strong>Native z/OS-Runner-Unterstützung</strong> hilft, Sicherheitsrisiken und Skalierbarkeitsengpässe im Zusammenhang mit Remote-Verbindungen zu eliminieren, während die Bereitstellung durch CI/CD-Pipelines beschleunigt wird, die direkt dort ausgeführt werden, wo sich Ihr Mainframe-Code befindet.</p>
<p><strong>Einheitliches Source Code Management</strong> modernisiert Toolchains, indem teure Legacy-Bibliotheksmanager durch GitLabs durchsuchbares, versionskontrolliertes Repository-System ersetzt werden, was zur Reduzierung von Lizenzkosten und Wartungsaufwand beiträgt.</p>
<p><strong>Nahtlose Integration</strong> mit IBM Developer for z/OS Enterprise Edition (IDzEE) liefert schnellere Software-Releases durch abhängigkeitsbasierte Builds, automatisiertes Code-Scanning und umfassende Debugging-Tools in vertrauten Entwicklerumgebungen, wodurch sowohl Qualität als auch Sicherheit verbessert werden.</p>
<p><strong>End-to-End-Transparenz</strong> über Mainframe- und verteilte Umgebungen hinweg bietet umfassendes Projektmanagement von der Planung bis zur Produktion und ermöglicht automatisierte DevOps-Workflows, die durch moderne Entwicklungstools der nächsten Generation zur Talentbindung beitragen.</p>
<h2>Modernisiere deine Mainframe-Entwicklungsumgebung noch heute</h2>
<p>GitLab Ultimate für IBM Z ist jetzt für Organisationen verfügbar, die bereit sind, ihre Mainframe-Entwicklungserfahrung zu transformieren. Weitere Informationen befinden sich auf der <a href="https://about.gitlab.com/de-de/partners/technology-partners/ibm/">GitLab und IBM Partnerseite</a>.</p>
]]></content>
        <author>
            <name>Mike Flouton</name>
            <uri>https://about.gitlab.com/blog/authors/mike-flouton</uri>
        </author>
        <author>
            <name>Andy Bradfield</name>
            <uri>https://about.gitlab.com/blog/authors/andy-bradfield</uri>
        </author>
        <published>2025-06-20T00:00:00.000Z</published>
    </entry>
    <entry>
        <title type="html"><![CDATA[GitLab ist ein Leader in der Forrester Wave™: DevOps Platforms, Q2 2025]]></title>
        <id>https://about.gitlab.com/de-de/blog/gitlab-named-a-leader-in-the-forrester-wave-devops-platforms-q2-2025/</id>
        <link href="https://about.gitlab.com/de-de/blog/gitlab-named-a-leader-in-the-forrester-wave-devops-platforms-q2-2025/"/>
        <updated>2025-06-02T00:00:00.000Z</updated>
        <content type="html"><![CDATA[<p>Die Wahl einer DevSecOps-Plattform ist eine der wichtigesten technologischen Entscheidungen, die ein Unternehmen zu treffen hat. Deshalb freuen wir uns sehr, dass wir als <a href="https://about.gitlab.com/forrester-wave-devops-platform/"><strong>führender Anbieter in The Forrester Wave™: DevOps Platforms, Q2 2025</strong> (nur in englischer Sprache verfügbar)</a> ausgezeichnet wurden.</p>
<p>Wir haben die höchstmöglichen Punktzahlen bei den Kriterien erhalten, die unseren Kund(inn)en laut ihren eigenen Angaben am wichtigsten sind, einschließlich der Benutzungserfahrung am ersten Tag, der Entwicklungstools, der Build-Automatisierung und CI, der automatisierten Bereitstellung, der Risikominderung im Zusammenhang mit KI, KI-Infusion, direkt integrierter Sicherheitstools und Plattformkohäsion.</p>
<p><em><strong>„GitLab ist die All-in-One-Lösung unter den All-in-One-Lösungen, die ihrem Namen am stärksten gerecht wird, und eignet sich damit für Unternehmen, die mit einem einzigen Kauf eine Standardisierung herbeiführen möchten.“ –</strong></em> Forrester Wave™: DevOps Platforms, Q2 2025</p>
<p>Diese Auszeichnung spiegelt das wider, was wir selbst von unseren Kund(inn)en gehört haben: Sie müssen sichere Software schneller bereitstellen, doch ihre bestehenden Lösungen zwingen sie, Kompromisse bei der Geschwindigkeit, Sicherheit oder Einfachheit einzugehen. GitLab wird jedoch allen drei Anforderungen gerecht. Und mit unserer <a href="https://about.gitlab.com/releases/2025/05/15/gitlab-18-0-released/">Veröffentlichung von GitLab 18.0 (nur in englischer Sprache verfügbar)</a> im Mai sind wir noch einen Schritt weiter gegangen, indem wir ohne zusätzliche Kosten <a href="https://about.gitlab.com/de-de/blog/gitlab-premium-with-duo/">die KI-nativen Funktionen von GitLab Duo</a> – wie Test Generation, Code Suggestions und Code Refactoring – direkt in GitLab Premium und GitLab Ultimate integriert haben.</p>
<blockquote>
<p><strong><a href="https://about.gitlab.com/forrester-wave-devops-platform/">Erhalte jetzt Zugang zum englischsprachigen Bericht.</a></strong></p>
</blockquote>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1749673518/Blog/Content%20Images/Image_DevOps-Platforms-Q2-2025.png" alt=" Forrester Wave™: DevOps-Plattformen, Grafik Q2 2025"></p>
<h2>Mit unternehmensweiter Kontrolle an der Spitze der KI-Transformation bleiben</h2>
<p>DevSecOps entwickelt sich rasant weiter, wobei die KI an der Spitze dieses Wandels steht. Leider zwingen viele KI-Tools die Anwender(innen) zu einer Wahl: entweder modernste Funktionen oder eine höchstmögliche Unternehmenssicherheit.</p>
<p>GitLab hat sowohl bei den Kriterien <strong>KI-Infusion</strong> als auch <strong>KI-Risikominderung</strong> 5 Punkte erhalten – die höchste mögliche Punktzahl. Wir freuen uns, dass unser klarer Fokus auf die Entwicklung innovativer KI-Funktionen, bei denen gleichermaßen eine umfassende Sicherheit gewährleistet bleibt, nicht nur von unseren Kund(inn)en wahrgenommen wird.</p>
<p>Diese doppelte Stärke zeigt sich in unseren KI-Angeboten von GitLab Duo, unter anderem:</p>
<ul>
<li>Duo Workflow (private Beta-Version): Autonome KI-Agenten, die komplexe Aufgaben bei der Entwicklung, Sicherheit und Betrieb bewältigen – mit Leitlinien und Audit-Trails auf Enterprise-Niveau.</li>
<li>Agentic Chat: Kontextbezogene, dialogorientierte KI-Unterstützung für alles von Codeerläuterungen bis hin zur Erstellung von Tests – mit integriertem Schutz des geistigen Eigentums und Datenschutzkontrollen.</li>
<li>Code Suggestions: KI-Unterstützung, die Codeblöcke vorausschauend vervollständigen, eine Funktionslogik definieren, Tests generieren und häufig verwendeten Code wie Regex-Muster vorschlagen kann.</li>
<li>KI-native Vulnerability Resolution: Findet und behebt Sicherheitslücken mit automatischen Erklärungen und automatisch erstellten Merge Requests, um so den Entwicklungsprozess zu optimieren.</li>
</ul>
<h2>Mit weniger mehr erreichen</h2>
<p>Wir haben deutlich vernommen, dass DevSecOps-Teams nicht noch mehr Tools und Integrationen benötigen, die sie bei einzelnen Abschnitten ihres Software-Entwicklungsprozesses unterstützen. Sie benötigen stattdessen eine nahtlose, integrierte Entwicklererfahrung, die den gesamten Lebenszyklus der Softwareentwicklung abdeckt.</p>
<p>Wir sind überzeugt, dass die Bewertungen von GitLab in den folgenden Kriterien unsere kundenorientierte Strategie bestätigen:</p>
<ul>
<li><strong>Nutzungserfahrung am ersten Tag:</strong> Forrester zitiert unsere „starke Nutzungserfahrung am ersten Tag“ und stellt fest, dass „alles sofort einsatzbereit ist“, unterstützt durch umfangreiche Migrationstools und Tutorials.</li>
<li><strong>Entwicklertools:</strong> Forrester verweist beispielhaft auf <a href="https://about.gitlab.com/de-de/blog/gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws/">GitLab Duo mit Amazon Q</a>, unser Angebot für agentische KI für AWS-Kund(inn)en, sowie auf unsere Entwicklungsumgebung in der Cloud, die integrierte Entwicklungsplattform und Wikis für die Dokumentation.</li>
<li><strong>Projektplanung und -abstimmung:</strong> Forrester hebt unser „starkes Compliance Center“ hervor und stellt fest, dass wir über Tools verfügen, um die Abstimmung in beide Richtungen voranzutreiben.</li>
<li><strong>Pipeline-Sicherheit:</strong> Forrester gibt uns die höchstmögliche Punktzahl beim Kriterium Pipeline-Sicherheit.</li>
<li><strong>Build-Automatisierung und CI:</strong> Forrester erwähnt unsere Build-Automatisierung und CI mit mehrstufigen Build-Pipelines und einer starken Unterstützung für selbst gehostete Installationen.</li>
</ul>
<h2>Bericht lesen</h2>
<p>Für uns spiegelt sich in unserer Auszeichnung als führender Anbieter in The Forrester Wave™: DevOps-Plattformen, Q2 2025 die Breite und Tiefe der Funktionen unserer Plattform wider, die als Single Source of Truth über den gesamten Lebenszyklus der Softwareentwicklung hinweg fungiert. Kein Jonglieren mit mehreren Tools und Integrationen mehr – GitLab bietet eine nahtlose, integrierte Erfahrung, die die Produktivität steigert und Reibungsverluste reduziert.</p>
<p>Wir sind überzeugt, dass sich in dieser hervorragenden Platzierung die harte Arbeit unseres Teams, die vielen Beiträge der Open-Source-Community von GitLab, das unschätzbare Feedback unserer Kund(inn)en und unser Engagement für die Gestaltung der Zukunft der Softwareentwicklung widerspiegeln.</p>
<blockquote>
<p><strong><a href="https://about.gitlab.com/forrester-wave-devops-platform/">Öffne den englischsprachigen Bericht.</a></strong></p>
</blockquote>
<p><em>Forrester spricht keine Empfehlung für Unternehmen, Produkte, Marken oder Dienstleistungen aus, die in seinen Forschungspublikationen vorkommen, und rät niemandem, sich auf der Grundlage der in diesen Publikationen aufgeführten Bewertungen für die Produkte oder Dienstleistungen eines Unternehmens oder einer Marke zu entscheiden. Die Informationen basieren auf den besten verfügbaren Ressourcen. Die Meinungen spiegeln die jeweils aktuelle Einschätzung wider und können sich ändern. Weitere Informationen zur Objektivität von Forrester (in englischer Sprache) findest du <a href="https://www.forrester.com/about-us/objectivity/">hier</a>.</em></p>
]]></content>
        <author>
            <name>Dave Steer</name>
            <uri>https://about.gitlab.com/blog/authors/dave-steer</uri>
        </author>
        <published>2025-06-02T00:00:00.000Z</published>
    </entry>
    <entry>
        <title type="html"><![CDATA[Warum steigen Unternehmen auf eine einheitliche DevSecOps-Plattform um?]]></title>
        <id>https://about.gitlab.com/de-de/blog/why-are-organizations-moving-to-a-unified-devsecops-platform/</id>
        <link href="https://about.gitlab.com/de-de/blog/why-are-organizations-moving-to-a-unified-devsecops-platform/"/>
        <updated>2025-06-02T00:00:00.000Z</updated>
        <content type="html"><![CDATA[<p>In der modernen Softwareentwicklung von heute migrieren viele Unternehmen in die Cloud und führen DevSecOps-Prozesse ein. Durch die Vielzahl von Tools und Legacy-Systemen, die nicht für die moderne Entwicklung ausgelegt sind, stellt diese Umstellung jedoch eine große Herausforderung dar.</p>
<p>Um diese Systeme an DevSecOps anzupassen, müssen Unternehmen mehrere Tools für Aufgabenmanagement, CI/CD, Sicherheit, Überwachung und vieles mehr miteinander verknüpfen. Das Ergebnis? Komplexe Betriebsabläufe, hohe Wartungskosten und eine erschwerte Zusammenarbeit zwischen Entwicklungs- und Betriebsteams. Darüber hinaus sind Entwickler(innen) frustriert, da sie ständig zwischen verschiedenen Tools wechseln müssen, um einen einzigen Flow – von der Planung bis zur Produktion – abzuschließen.</p>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097077/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097077287.jpg" alt="Die Komplexität und die Betriebskosten der Integration mehrerer Tools in einen DevSecOps-Prozess"></p>
<p>&lt;center&gt;&lt;i&gt;Wie komplex es sein kann, mehrere Tools in einen DevSecOps-Prozess zu integrieren&lt;/i&gt;&lt;/center&gt;</p>
<p>&lt;br&gt;&lt;/br&gt;</p>
<p>Die gute Nachricht ist, es gibt eine Lösung: Eine umfassende DevSecOps-Plattform, die einen einheitlichen Ansatz für die Softwareentwicklung bietet.</p>
<p>Diese Plattformen sind für Unternehmen konzipiert, die in cloudbasierten und DevSecOps-Umgebungen arbeiten. Sie konsolidieren alle Phasen der Softwareentwicklung – von der Codeverwaltung, über CI/CD-Prozesse, Aufgabenmanagement und Sicherheit bis hin zur KI-gestützten Automatisierung – auf einer einzigen Plattform. Die Zentralisierung aller Softwareentwicklungs-Workflows in einer einheitlichen Oberfläche ermöglicht es den Entwicklungs- und Betriebsteams, effizienter zu arbeiten, die Kommunikation zu vereinfachen und die Komplexität der Vorgänge und Störungen zu minimieren.</p>
<p>Darüber hinaus verbessert sich die Entwicklererfahrung erheblich – sie arbeiten viel lieber mit einem Produkt, das speziell für moderne Entwicklungsanforderungen konzipiert wurde.</p>
<p>In den folgenden Abschnitten erfahren wir, wie GitLab Teams bei der Bewältigung gängiger Herausforderungen hilft – sei es bei der Verwaltung von Projekten und Aufgaben, der Gewährleistung von Sicherheit und Compliance oder der Einführung von KI-basierten Entwicklungstools – und das alles auf einer einzigen, einheitlichen Plattform.</p>
<h2>Integriertes Agile-Projektmanagement</h2>
<p><a href="https://about.gitlab.com/de-de/">GitLab</a> bietet eine ganzheitliche Lösung, bei der das Projekt- und Aufgabenmanagement über alle Phasen des Softwareentwicklungszyklus hinweg vollständig integriert ist, wie z. B. CI/CD, wodurch der Entwicklungsfortschritt in Echtzeit verfolgt werden kann. Tickets und Epics sind direkt mit den Automatisierungsprozessen verknüpft und ermöglichen einen nahtlosen Flow von der Planung bis zur Bereitstellung in der Produktion. Dieser Ansatz erhöht die Transparenz zwischen den Teams, verringert Verzögerungen und stellt sicher, dass alle Beteiligten einen klaren Überblick über den Entwicklungsstatus in Echtzeit haben.</p>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097077/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097077288.jpg" alt="Tickets und Epics sind direkt mit Automatisierungsprozessen verknüpft und ermöglichen einen nahtlosen Übergang von der Planung bis zur Bereitstellung in der Produktion."></p>
<h2>Integrierte Sicherheit</h2>
<p>GitLab legt großen Wert auf die Integration von umfassenden Sicherheitsfunktionen („security first“). Die Plattform integriert eine breite Palette automatisierter Sicherheitsscanner, darunter (Dokumentation nur in englischer Sprache verfügbar):</p>
<ul>
<li><a href="https://docs.gitlab.com/user/application_security/dependency_scanning/">Abhängigkeitssuche</a></li>
<li><a href="https://docs.gitlab.com/user/application_security/sast/">Statische Anwendungssicherheitstests (SAST)</a></li>
<li><a href="https://docs.gitlab.com/user/application_security/dast/">Dynamische Anwendungssicherheitstests (DAST)</a></li>
<li><a href="https://docs.gitlab.com/user/application_security/secret_detection/">Erkennung von Geheimnissen</a></li>
<li><a href="https://docs.gitlab.com/user/application_security/container_scanning/">Container-Scanning</a></li>
</ul>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097077/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097077289.jpg" alt="Sicherheitsscanning-Funktionen, die in verschiedenen Entwicklungsphasen in den CI/CD-Prozess integriert sind"></p>
<p>&lt;center&gt;&lt;i&gt;Sicherheitsscanning-Funktionen, die in verschiedenen Entwicklungsphasen in den CI/CD-Prozess integriert sind&lt;/i&gt;&lt;/center&gt;</p>
<p>&lt;br&gt;&lt;/br&gt;</p>
<p>Diese Sicherheitsprüfungen werden direkt in jede Phase des Softwareentwicklungszyklus eingebaut, einschließlich der CI/CD-Pipeline, um den Entwickler(inne)n schon früh im Entwicklungszyklus ein unmittelbares Feedback zu potenziellen Sicherheitsproblemen zu geben.</p>
<h2>Compliance und regulatorische Anforderungen</h2>
<p>Neben Effizienz und Benutzerfreundlichkeit müssen viele Unternehmen – insbesondere in regulierten Branchen wie Finanzinstituten oder Großunternehmen – sicherstellen, dass ihre Prozesse strengen Sicherheits- und Compliance-Standards entsprechen. Sie müssen in der Lage sein, Richtlinien für verschiedene Projekte durchzusetzen, z. B. einen Sicherheitsscanner vorzuschreiben, wenn eine CI/CD-Pipeline auf bestimmten Code-Branches (Main- oder geschützte Branches) ausgeführt wird, oder bestimmte Genehmigungen zu verlangen, bevor Code in den Main-Branch zusammengeführt wird.</p>
<p>Mit GitLab wird dies durch <a href="https://about.gitlab.com/blog/introducing-custom-compliance-frameworks-in-gitlab/">Compliance-Frameworks (nur in englischer Sprache verfügbar)</a> erleichtert, eine Funktion, mit der Unternehmen strukturierte Richtlinien für ausgewählte Projekte definieren und durchsetzen können. So wird die Einhaltung automatischer gesetzlicher und sicherheitstechnischer Anforderungen gewährleistet und gleichzeitig ein nahtloser und effizienter Workflow für Entwickler(innen) sichergestellt.</p>
<h2>KI-basierte Entwicklung</h2>
<p><a href="https://about.gitlab.com/de-de/gitlab-duo/">GitLab Duo</a> unterstützt dich in allen Entwicklungsphasen mit KI, sodass du nicht mehr auf externe Tools zurückgreifen musst. Jede KI-unterstützte Anforderung wird im gesamten Kontext des Projekts und der Codebase bearbeitet, was eine intelligentere und effizientere Arbeit ermöglicht.</p>
<p>Die KI kann zum Beispiel folgende Aufgaben übernehmen:</p>
<ul>
<li>automatische Erstellung von Aufgabenbeschreibungen</li>
<li>intelligente Zusammenfassung von Diskussionen zu Tickets, was Entwickler(inne)n wertvolle Zeit spart</li>
<li>erweiterte Code-Review-Funktionen</li>
<li>Vorschläge zur Codeverbesserung und -optimierung</li>
<li>automatisierte Testgenerierung</li>
<li>Erkennung und Behebung von Sicherheitslücken</li>
<li>Fehlerbehebung bei der Grundursachenanalyse für CI-Pipeline-Fehler</li>
<li>Datenschutz und Datensicherheit</li>
</ul>
<p>GitLab kennt die Bedürfnisse von regulierten Unternehmen, insbesondere im öffentlichen und im Finanzsektor, und bietet eine einzigartige Lösung für den Einsatz von KI-Modellen in einer sicheren Umgebung. GitLab Duo Self-Hosted ermöglicht es Unternehmen, die volle Kontrolle über Datenschutz, Sicherheit und die Bereitstellung großer Sprachmodelle <a href="https://about.gitlab.com/blog/what-is-a-large-language-model-llm/">(LLMs; nur in englischer Sprache verfügbar)</a> in ihrer eigenen Infrastruktur zu behalten. Dabei wird Folgendes gewährleistet:</p>
<ul>
<li>Datenschutz</li>
<li>Einhaltung gesetzlicher Anforderungen</li>
<li>maximale Sicherheit</li>
<li>KI-Vorteile ohne externe Netzwerkabhängigkeiten oder -risiken</li>
</ul>
<h2>Zusammenfassung</h2>
<p>Unternehmen brauchen eine umfassende DevSecOps-Plattform, um Prozesse zu rationalisieren, die Sicherheit zu verbessern und Innovationen zu beschleunigen. GitLab bietet genau das – eine einzige Anwendung, die alle wichtigen Entwicklungs-, Sicherheits- und Betriebswerkzeuge mit integrierter Sicherheitsintegration und KI-basierter Automatisierung vereint.</p>
<p>Willst du GitLab in Aktion sehen? Entdecke interaktive (englischsprachige) Demos für:</p>
<ul>
<li><a href="https://gitlab.navattic.com/gitlab-premium-with-duo">GitLab Premium und Ultimate mit Duo</a>: Erlebe KI-Unterstützung bei der Entwicklung,</li>
<li><a href="https://gitlab.navattic.com/gitlab-scans">Sicherheit in der CI/CD-Pipeline</a>: Sieh dir an, wie integriertes Sicherheitsscanning deine Software schützt.</li>
<li><a href="https://gitlab.navattic.com/compliance">Compliance-Frameworks</a>: Erfahre, wie GitLab Richtlinien projektübergreifend durchsetzt, um eine bessere Governance zu gewährleisten.</li>
</ul>
<blockquote>
<p>Nimm am virtuellen Launch-Event von GitLab 18 teil, um mehr über die Zukunft der DevSecOps-Plattform zu erfahren, einschließlich der Rolle der agentischen KI. <a href="https://about.gitlab.com/de-de/eighteen/">Registriere dich noch heute!</a></p>
</blockquote>
]]></content>
        <author>
            <name>Itzik Gan Baruch</name>
            <uri>https://about.gitlab.com/blog/authors/itzik-gan baruch</uri>
        </author>
        <published>2025-06-02T00:00:00.000Z</published>
    </entry>
    <entry>
        <title type="html"><![CDATA[GitLab Duo Chat wird jetzt zum agentischen KI-Assistenten ]]></title>
        <id>https://about.gitlab.com/de-de/blog/gitlab-duo-chat-gets-agentic-ai-makeover/</id>
        <link href="https://about.gitlab.com/de-de/blog/gitlab-duo-chat-gets-agentic-ai-makeover/"/>
        <updated>2025-05-29T00:00:00.000Z</updated>
        <content type="html"><![CDATA[<p>Generative KI-Chat-Assistenten sind in kurzer Zeit zum Standard in der Softwareentwicklung geworden und helfen dabei, Code zu erstellen und zu verbessern. Stell dir nun vor, dein Chat-Assistent könnte die Artefakte deines gesamten Entwicklungsprozesses und nicht nur deinen Code verstehen.</p>
<p>Was wäre, wenn dieser Chat-Assistent dir hilft, Tickets und Projektdokumentationen zu bearbeiten, bevor er dich beim Programmieren unterstützt, und auf CI/CD-Pipelines und Merge Requests zugreifen könnte, um dich bei der ordnungsgemäßen Durchführung von Programmieraufgaben zu begleiten?</p>
<p><strong>Lerne die nächste Generation von GitLab Duo Chat kennen – GitLab Duo Agentic Chat, eine bedeutende Weiterentwicklung in der KI-nativen Entwicklungsunterstützung und die neueste Ergänzung unserer Plattform, die jetzt als <a href="https://docs.gitlab.com/policy/development_stages_support/#experiment">experimenteller Release (nur in englischer Sprache)</a> verfügbar ist.</strong></p>
<p>GitLab Duo Agentic Chat ist für alle GitLab.com-Benutzer(innen) mit der Workflow-Erweiterung von GitLab in VS Code verfügbar.</p>
<p>Mit Agentic Chat ist der Chat nicht mehr bloß eine herkömmliche dialogorientierte KI, sondern wird zum Chat-Assistenten, der in deinem Namen selbst handelt und komplexe Probleme in einzelne Aufgaben unterteilt, die er lösen kann. Anstatt einfach nur Fragen mit deinem angegebenen Kontext zu beantworten, kann Agentic Chat:</p>
<ul>
<li><strong>Autonom feststellen</strong>, welche Informationen er braucht, um deine Fragen zu beantworten</li>
<li><strong>Eine Reihe von Vorgängen ausführen</strong>, um diese Informationen aus verschiedenen Quellen zu sammeln</li>
<li><strong>Umfassende Antworten formulieren</strong>, indem er Einblicke aus deinem gesamten Projekt kombiniert</li>
<li><strong>Dateien erstellen und bearbeiten</strong>, um dir dabei zu helfen, Lösungen zu implementieren.</li>
</ul>
<p>Dabei bleibt stets der Mensch als Entwickler(in) involviert.</p>
<p>Agentic Chat basiert auf der Architektur von Duo Workflow, der derzeit in der <a href="https://about.gitlab.com/de-de/blog/gitlab-duo-workflow-enterprise-visibility-and-control-for-agentic-ai/">privaten Beta-Version verfügbar ist</a>. Die Architektur besteht aus Agenten und Tools, die bestimmte Aufgaben übernehmen, z. B. den richtigen Kontext für eine bestimmte Frage finden oder Dateien bearbeiten.</p>
<p><strong>Anwendungsfälle für GitLab Duo Agentic Chat</strong></p>
<p>Hier findest du einige praktische und häufige Anwendungsfälle für Agentic Chat:</p>
<ul>
<li>
<p>Arbeite dich schneller in neue Projekte ein, indem die KI dir hilft, mit einer neuen Codebase vertraut zu werden.</p>
</li>
<li>
<p>Lege sofort mit der zugewiesenen Arbeit los, auch wenn Ticketbeschreibungen unklar sind. Agentic Chat kann dir nämlich helfen, die Lücke zwischen Anforderungen und bestehenden Implementierungen zu überbrücken.</p>
</li>
<li>
<p>Wenn du Änderungen vornehmen möchtest, kann Agentic Chat die Implementierung übernehmen, indem er Dateien übergreifend über dein Projekt erstellt und bearbeitet.</p>
</li>
<li>
<p>Wenn ein Release ansteht, kann dir Agentic Chat helfen, zu überprüfen, ob deine Lösung die ursprünglichen Anforderungen auch tatsächlich erfüllt, indem er deinen Merge Request anhand des ursprünglichen Tickets oder der ursprünglichen Aufgabe überprüft.</p>
</li>
</ul>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099210/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750099210429.png" alt="Agentic Chat – Beispiel"></p>
<p>&lt;center&gt;&lt;i&gt;Agentic Chat bearbeitet Code&lt;/i&gt;&lt;/center&gt;</p>
<h2>Vom Lernen zum Bereitstellen: eine komplette Workflow-Demonstration in vier Schritten</h2>
<p>Um dir zu zeigen, wie Agentic Chat das Entwicklererlebnis transformiert, sehen wir uns ein echtes Szenario unserer Entwicklungsteams an. Stell dir vor, du bist ein neues Teammitglied und hast ein Ticket zugewiesen bekommen, weißt aber nichts über die Codebase. Sieh dir diese Videodemonstration an:</p>
<p>&lt;!-- blank line --&gt;
&lt;figure class=&quot;video_container&quot;&gt;
&lt;iframe src=&quot;https://www.youtube.com/embed/uG9-QLAJrrg?si=kaOhYylMIaWkIuG8j&quot; frameborder=&quot;0&quot; allowfullscreen=&quot;true&quot;&gt; &lt;/iframe&gt;
&lt;/figure&gt;
&lt;!-- blank line --&gt;</p>
<p><strong>Schritt 1: Das Projekt verstehen</strong></p>
<p>Anstatt manuell die Dateien und die Dokumentation zu durchforsten, kannst du einfach folgenden Prompt in Agentic Chat eingeben:</p>
<pre><code class="language-unset">I am new to this project. Could you read the project structure and explain it to me?
</code></pre>
<p>(Ich kenne dieses Projekt noch nicht. Lies dir bitte die Projektstruktur durch und erkläre sie mir.)</p>
<p>Agentic Chat bietet dir dann wir folgt einen umfassenden Projektüberblick:</p>
<ul>
<li>Er sieht sich die Verzeichnisstruktur an.</li>
<li>Er liest README-Dateien und die Dokumentation.</li>
<li>Er identifiziert wichtige Komponenten und Anwendungen.</li>
</ul>
<p><strong>Schritt 2: Deine zugewiesene Aufgabe verstehen</strong></p>
<p>Nun musst du deine jeweilige Aufgabe verstehen. Gib dazu den folgenden Prompt ein:</p>
<pre><code class="language-unset">I have been assigned Issue 1119. Could you help me understand this task, specifically where do I need to apply the refactoring?
</code></pre>
<p>(Mir wurde das Ticket 1119 zugewiesen. Hilf mir bitte, diese Aufgabe zu verstehen. Wo genau muss ich das Refactoring durchführen?)</p>
<p>Agentic Chat erklärt dir die Aufgabe und schlägt einen Refactoring-Ansatz vor, indem er wie folgt vorgeht:</p>
<ul>
<li>Er ruft die Details des Tickets vom GitLab-Remote-Server ab und analysiert sie.</li>
<li>Er untersucht relevante Projektdateien.</li>
<li>Er identifiziert die spezifischen Orte, für die Änderungen nötig sind.</li>
</ul>
<p><strong>Schritt 3: Die Lösung implementieren</strong></p>
<p>Anstatt die Arbeit manuell zu erledigen, kannst du folgende Frage stellen:</p>
<pre><code class="language-unset">Could you make the edits for me? Please start with steps one, two, three.
</code></pre>
<p>(Kannst du die Bearbeitungen für mich vornehmen? Bitte beginne mit den Schritten eins, zwei und drei.)</p>
<p>Agentic Chat geht dann so vor:</p>
<ul>
<li>Er erstellt, wenn nötig, neue Verzeichnisse und Dateien.</li>
<li>Er extrahiert und refaktorisiert Code an mehreren Stellen.</li>
<li>Er stellt die Konsistenz übergreifend über alle geänderten Dateien sicher.</li>
<li>Er erstelle eine Übersicht über alle vorgenommenen Änderungen.</li>
</ul>
<p><strong>Schritt 4: Vollständigkeit überprüfen</strong></p>
<p>Nachdem nun abschließend dein Merge Request erstellt wurde, kannst du deine Arbeit überprüfen:</p>
<pre><code class="language-unset">Does my MR fully address Issue 1119?
</code></pre>
<p>(Löst mein MR das Ticket 1119 vollständig?)</p>
<p>Agentic Chat bestätigt nun, dass alle Anforderungen erfüllt werden, indem er sowohl deinen Merge Request als auch das ursprüngliche Ticket analysiert.</p>
<h2>Probiere es jetzt aus und teile dein Feedback</h2>
<p>GitLab Duo Agentic Chat ist derzeit als experimentelle Funktion in VS Code für Benutzer(innen) von GitLab Duo Pro und GitLab Duo Enterprise verfügbar. In unserer <a href="https://docs.gitlab.com/user/gitlab_duo_chat/agentic_chat/">Einrichtungsdokumentation (nur in englischer Sprache verfügbar)</a> findest du die Voraussetzungen und Konfigurationsschritte.</p>
<p>Da Agentic Chat derzeit nur eine experimentelle Funktion ist, hat er einige bekannte Einschränkungen, an denen wir derzeit aktiv arbeiten. Dazu gehören langsamere Reaktionszeiten aufgrund mehrerer API-Aufrufe, eine eher schlüsselwortbasierte als semantische Suche und eine eingeschränkte Unterstützung für neue lokale Ordner oder Nicht-GitLab-Projekte. <strong>Dein Feedback ist wichtig, damit wir die Verbesserungen priorisieren und Agentic Chat bald allgemein verfügbar machen können. Teile daher bitte deine Erfahrungen in <a href="https://gitlab.com/gitlab-org/gitlab/-/issues/542198">diesem Ticket</a> mit uns.</strong></p>
<h2>Wie geht es weiter?</h2>
<p>Unser Hauptaugenmerk liegt darauf, Agentic Chat zu verbessern und allgemein verfügbar zu machen. In der Zwischenzeit arbeiten wir daran, die Reaktionszeiten zu verbessern und Funktionen hinzuzufügen, die GitLab Duo Chat derzeit bietet, wie z. B. die Verwendung von selbst gehosteten Modellen oder die Unterstützung von JetBrains und Visual Studio zusätzlich zu VS Code. Sobald wir Duo Chat auf diese neue Architektur umgestellt haben, planen wir außerdem, Agentic Chat in die Chat-Funktion der GitLab-Webanwendung zu integrieren. Zudem sind viele weitere Funktionen geplant, wie z. B. die Bearbeitung von GitLab-Artefakten, die Unterstützung von Kontexten aus benutzerdefinierten Model-Context-Protocol- oder MCP-Servern und Befehle, die im Terminal ausgeführt werden können.</p>
<blockquote>
<p>Möchtest du autonome Entwicklungsunterstützung erleben, bist aber noch kein(e) GitLab-Kund(in)? Probiere Agentic Chat jetzt im Rahmen <a href="https://about.gitlab.com/de-de/free-trial/">einer kostenlosen 60-tägigen Testversion von GitLab Ultimate mit Duo Enterprise</a> aus und gestalte die Zukunft der KI-basierten Entwicklung mit. Folge diesen <a href="https://docs.gitlab.com/user/gitlab_duo_chat/agentic_chat/#use-agentic-chat-in-vs-code">Einrichtungsschritten für VS Code (nur in englischer Sprache verfügbar)</a>.</p>
</blockquote>
<p><em><strong>Haftungsausschlussklausel: Dieser Blog enthält Informationen zu kommenden Produkten, Funktionen und Funktionalitäten. Bitte beachte, dass die Informationen in diesem Blogbeitrag nur zu Informationszwecken dienen. Bitte verlasse dich nicht auf diese Informationen, wenn du etwas kaufen oder planen möchtest. Wie bei allen Projekten können sich die in diesem Blog und auf den verlinkten Seiten genannten Punkte ändern oder verzögern. Die Entwicklung, Freigabe und der Zeitplan von Produkten, Funktionen oder Funktionalitäten liegen im alleinigen Ermessen von GitLab.</strong></em></p>
<h2>Mehr erfahren</h2>
<ul>
<li><a href="https://about.gitlab.com/de-de/blog/gitlab-duo-workflow-enterprise-visibility-and-control-for-agentic-ai/">GitLab Duo Workflow: Transparenz und Kontrolle für agentische KI auf Enterprise-Niveau</a></li>
<li><a href="https://about.gitlab.com/de-de/topics/agentic-ai/">Was ist agentische KI?</a></li>
<li><a href="https://about.gitlab.com/blog/agentic-ai-guides-and-resources/">Leitfäden und Ressourcen zu agentischer KI (nur in englischer Sprache verfügbar)</a></li>
</ul>
]]></content>
        <author>
            <name>Torsten Linz</name>
            <uri>https://about.gitlab.com/blog/authors/torsten-linz</uri>
        </author>
        <published>2025-05-29T00:00:00.000Z</published>
    </entry>
    <entry>
        <title type="html"><![CDATA[Erste Schritte mit GitLab: Arbeiten mit CI/CD-Variablen]]></title>
        <id>https://about.gitlab.com/de-de/blog/getting-started-with-gitlab-working-with-ci-cd-variables/</id>
        <link href="https://about.gitlab.com/de-de/blog/getting-started-with-gitlab-working-with-ci-cd-variables/"/>
        <updated>2025-05-27T00:00:00.000Z</updated>
        <content type="html"><![CDATA[<p><em>Willkommen zu unserer Serie „Erste Schritte mit GitLab“, in der wir Neueinsteiger(inne)n helfen, sich mit der DevSecOps-Plattform von GitLab vertraut zu machen.</em></p>
<p>In einem früheren Artikel haben wir uns mit <a href="https://about.gitlab.com/de-de/blog/getting-started-with-gitlab-understanding-ci-cd/">GitLab CI/CD</a> beschäftigt. Jetzt tauchen wir tiefer in die Welt der <strong>CI/CD-Variablen</strong> ein und erschließen ihr volles Potenzial.</p>
<h2>Inhaltsverzeichnis</h2>
<ul>
<li><a href="#was-sind-cicd-variablen%3F">Was sind CI/CD-Variablen?</a></li>
<li><a href="#warum-sind-cicd-variablen-wichtig%3F">Warum sind CI/CD-Variablen wichtig?</a></li>
<li><a href="#geltungsbereiche-von-cicd-variablen-projekt-gruppe-und-instanz">Geltungsbereiche von CI/CD-Variablen: Projekt, Gruppe und Instanz</a></li>
<li><a href="#definieren-von-cicd-variablen">Definieren von CI/CD-Variablen</a></li>
<li><a href="#verwenden-von-cicd-variablen">Verwenden von CI/CD-Variablen</a></li>
<li><a href="#vordefinierte-cicd-variablen">Vordefinierte CI/CD-Variablen</a></li>
<li><a href="#bew%C3%A4hrte-methoden">Bewährte Methoden</a></li>
<li><a href="#entdecke-die-leistungsf%C3%A4higkeit-von-variablen">Entdecke die Leistungsfähigkeit von Variablen</a></li>
<li><a href="#reihe-%E2%80%9Eerste-schritte-mit-gitlab%E2%80%9C">Reihe „Erste Schritte mit GitLab&quot;</a></li>
</ul>
<h3>Was sind CI/CD-Variablen?</h3>
<p>CI/CD-Variablen sind dynamische Schlüssel-Wert-Paare, die du auf verschiedenen Ebenen in deiner GitLab-Umgebung definieren kannst (z. B. Projekt, Gruppe oder Instanz). Diese Variablen fungieren als Platzhalter für Werte, die du in deiner <code>.gitlab-ci.yml</code>-Datei verwenden kannst, um deine Pipelines anzupassen, vertrauliche Informationen sicher zu speichern und deine CI/CD-Konfiguration besser zu pflegen.</p>
<h3>Warum sind CI/CD-Variablen wichtig?</h3>
<p>CI/CD-Variablen bieten zahlreiche Vorteile:</p>
<ul>
<li><strong>Flexibilität</strong> – Du kannst deine Pipelines leicht an verschiedene Umgebungen, Konfigurationen oder Bereitstellungsziele anpassen, ohne dein zentrales CI/CD-Skript zu ändern.</li>
<li><strong>Sicherheit</strong> – Speichere vertrauliche Informationen wie API-Schlüssel, Passwörter und Token sicher und verhindere so, dass sie in deinem Code offengelegt werden.</li>
<li><strong>Wartbarkeit</strong> – Verwalte deine CI/CD-Konfiguration sauber und übersichtlich, indem du Werte in Variablen zentralisierst, was Aktualisierungen und Änderungen erleichtert.</li>
<li><strong>Wiederverwendbarkeit</strong> – Definiere Variablen einmal und verwende sie in mehreren Projekten wieder, um die Konsistenz zu fördern und doppelte Arbeit zu vermeiden.</li>
</ul>
<h3>Geltungsbereiche von CI/CD-Variablen: Projekt, Gruppe und Instanz</h3>
<p>Mit GitLab kannst du CI/CD-Variablen mit unterschiedlichen Geltungsbereichen definieren und so ihre Sichtbarkeit und Zugänglichkeit steuern:</p>
<ul>
<li>
<p><strong>Variablen auf Projektebene</strong> – Diese Variablen sind spezifisch für ein einzelnes Projekt und eignen sich ideal zum Speichern von projektspezifischen Einstellungen, wie zum Beispiel:</p>
<ul>
<li>Bereitstellungs-URLs: Definiere unterschiedliche URLs für Staging- und Produktivumgebungen.</li>
<li>Datenbank-Zugangsdaten: Speichere Details zur Datenbankverbindung für Tests oder die Bereitstellung.</li>
<li>Feature-Flags: Aktiviere oder deaktiviere Funktionen in verschiedenen Phasen deiner Pipeline.</li>
<li>Beispiel: Du hast ein Projekt mit dem Namen „MyWebApp“ und möchtest die URL für die Bereitstellung speichern. Du erstellst eine Variable auf Projektebene mit dem Namen <code>DPROD_DEPLOY_URL</code> und dem Wert <code>https://mywebapp.com</code>.</li>
</ul>
</li>
<li>
<p><strong>Variablen auf Gruppenebene</strong> – Diese Variablen werden von allen Projekten innerhalb einer GitLab-Gruppe gemeinsam genutzt. Sie sind nützlich für Einstellungen, die für mehrere Projekte gleich sind, wie z. B.:</p>
<ul>
<li>API-Schlüssel für gemeinsam genutzte Dienste: Speichere API-Schlüssel für Dienste wie AWS, Google Cloud oder Docker Hub, die von mehreren Projekten innerhalb der Gruppe genutzt werden.</li>
<li>Globale Konfigurationseinstellungen: Lege gemeinsame Konfigurationsparameter fest, die für alle Projekte in der Gruppe gelten.</li>
<li>Beispiel: Du hast eine Gruppe mit dem Namen „Web-Apps“ und möchtest einen API-Schlüssel für Docker Hub speichern. Du erstellst eine Variable auf Gruppenebene mit dem Namen <code>DOCKER_HUB_API_KEY</code> und dem entsprechenden API-Schlüsselwert.</li>
</ul>
</li>
<li>
<p><strong>Variablen auf Instanzebene</strong> – Diese Variablen sind für alle Projekte auf einer GitLab-Instanz verfügbar. Sie werden in der Regel für globale Einstellungen verwendet, die für das gesamte Unternehmen gelten, wie z. B.:</p>
<ul>
<li>Standard-Token für die Registrierung von Runnern: Lege ein Standard-Token für die Registrierung neuer <a href="https://docs.gitlab.com/runner/">Runner (nur in englischer Sprache verfügbar)</a> fest.</li>
<li>Lizenzinformationen: Hier kannst du Lizenzschlüssel für GitLab-Funktionen oder Tools von Drittanbietern speichern.</li>
<li>Globale Umgebungseinstellungen: Lege Umgebungsvariablen fest, die für alle Projekte verfügbar sein sollen.</li>
<li>Beispiel: Du möchtest ein Standard-Docker-Image für alle Projekte in deiner GitLab-Instanz festlegen. Du erstellst eine Variable auf Instanzebene mit dem Namen <code>DEFAULT_DOCKER_IMAGE</code> und dem Wert <code>ubuntu:latest</code>.</li>
</ul>
</li>
</ul>
<h3>Definieren von CI/CD-Variablen</h3>
<p>So definierst du eine CI/CD-Variable:</p>
<ol>
<li>Klicke auf die Schaltflächen <strong>Einstellungen &gt; CI/CD</strong> für dein Projekt, deine Gruppe oder deine Instanz.</li>
<li>Gehe zum Abschnitt <strong>Variablen</strong>.</li>
<li>Klicke auf <strong>Variable hinzufügen</strong>.</li>
<li>Gib den <strong>Schlüssel</strong> (z. B. <code>API_KEY</code>) und den <strong>Wert</strong> ein.</li>
<li>Aktiviere optional das Kontrollkästchen <strong>Variable schützen</strong>, wenn es sich um vertrauliche Informationen handelt. Dadurch wird sichergestellt, dass die Variable nur für Pipelines verfügbar ist, die auf geschützten Branches oder Tags ausgeführt werden.</li>
<li>Aktiviere optional das Kontrollkästchen <strong>Variable maskieren</strong>, um den Wert der Variable in den Job-Protokollen auszublenden und eine versehentliche Offenlegung zu verhindern.</li>
<li>Klicke auf <strong>Variable speichern</strong>.</li>
</ol>
<h3>Verwenden von CI/CD-Variablen</h3>
<p>Um eine CI/CD-Variable in deiner <code>.gitlab-ci.yml</code>-Datei zu verwenden, stellst du dem Variablennamen einfach <code>$</code> voran:</p>
<pre><code class="language-yaml">deploy_job:
  script:
    - echo &quot;Deploying to production...&quot;
    - curl -H &quot;Authorization: Bearer $API_KEY&quot; https://api.example.com/deploy
</code></pre>
<h3>Vordefinierte CI/CD-Variablen</h3>
<p>GitLab stellt <a href="https://docs.gitlab.com/ci/variables/predefined_variables/">vordefinierte CI/CD-Variablen (nur in englischer Sprache verfügbar)</a> bereit, die du in deinen Pipelines verwenden kannst. Diese Variablen liefern Informationen über die aktuelle Pipeline, den Job, das Projekt und mehr.</p>
<p>Einige häufig verwendete vordefinierte Variablen sind:</p>
<ul>
<li><code>$CI_COMMIT_SHA</code>: Der Commit-SHA der aktuellen Pipeline.</li>
<li><code>$CI_PROJECT_DIR</code>: Das Verzeichnis, in dem das Projekt geklont wird.</li>
<li><code>$CI_PIPELINE_ID</code>: Die ID der aktuellen Pipeline.<br>
*<code>$CI_ENVIRONMENT_NAME</code>: Der Name der Umgebung, in der bereitgestellt wird (falls zutreffend).</li>
</ul>
<h3>Bewährte Methoden</h3>
<ul>
<li>Verwalte vertrauliche Variablen sicher: Verwende geschützte und maskierte Variablen für API-Schlüssel, Passwörter und andere vertrauliche Informationen.</li>
<li>Vermeide das Hardcoding von Werten: Verwende Variablen zum Speichern von Konfigurationswerten, um deine Pipelines flexibler und wartbarer zu machen.</li>
<li>Organisiere deine Variablen: Verwende aussagekräftige Namen und gruppiere verwandte Variablen, um sie besser zu organisieren.</li>
<li>Verwende den richtigen Geltungsbereich: Wähle den richtigen Geltungsbereich (Projekt, Gruppe oder Instanz) für deine Variablen aus, je nach Verwendungszweck und Sichtbarkeit.</li>
</ul>
<h3>Entdecke die Leistungsfähigkeit von Variablen</h3>
<p>CI/CD-Variablen sind ein leistungsstarkes Tool zur Anpassung und Sicherung deiner GitLab-Pipelines. Wenn du verstanden hast, wie Variablen funktionieren und ihre unterschiedlichen Geltungsbereiche kennst, kannst du flexiblere, wartbarere und effizientere Workflows erstellen.</p>
<p>Wir hoffen, dass diese Informationen für dich hilfreich waren und du jetzt gut gerüstet bist, um die Möglichkeiten von GitLab für deine Entwicklungsprojekte zu nutzen.</p>
<blockquote>
<p>Lege jetzt los mit CI/CD-Variablen mit einer <a href="https://about.gitlab.com/de-de/free-trial/">kostenlosen, 60-tägigen Testversion von GitLab Ultimate mit Duo Enterprise</a>.</p>
</blockquote>
<h2>Reihe „Erste Schritte mit GitLab“</h2>
<p>Lies weitere Artikel in unserer Serie „Erste Schritte mit GitLab“:</p>
<ul>
<li><a href="https://about.gitlab.com/de-de/blog/getting-started-with-gitlab-how-to-manage-users/">Benutzerverwaltung</a></li>
<li><a href="https://about.gitlab.com/blog/getting-started-with-gitlab-how-to-import-your-projects-to-gitlab/">Projekte in GitLab importieren (nur in englischer Sprache verfügbar)</a></li>
<li><a href="https://about.gitlab.com/de-de/blog/getting-started-with-gitlab-mastering-project-management/">Projektmanagement</a></li>
<li><a href="https://about.gitlab.com/de-de/blog/automating-agile-workflows-with-the-gitlab-triage-gem/">Automatisiere Agile-Workflows mit dem gem gitlab-triage</a></li>
<li><a href="https://about.gitlab.com/de-de/blog/getting-started-with-gitlab-understanding-ci-cd/">Grundlegendes zu CI/CD</a></li>
</ul>
]]></content>
        <author>
            <name>GitLab Team</name>
            <uri>https://about.gitlab.com/blog/authors/gitlab-team</uri>
        </author>
        <published>2025-05-27T00:00:00.000Z</published>
    </entry>
    <entry>
        <title type="html"><![CDATA[So schreibst du eine User Story in Scrum]]></title>
        <id>https://about.gitlab.com/de-de/blog/how-to-write-a-user-story-in-scrum/</id>
        <link href="https://about.gitlab.com/de-de/blog/how-to-write-a-user-story-in-scrum/"/>
        <updated>2025-05-20T00:00:00.000Z</updated>
        <content type="html"><![CDATA[<p>Die User Story ist ein sehr einfaches Konzept. Trotzdem hat sie die Projektplanung entscheidend verändert - und das, obwohl User Stories zum Beispiel in <a href="https://about.gitlab.com/de-de/blog/scrum-project-management-how-it-works/">Scrum</a> nicht einmal vorkommen.</p>
<p>Gerade weil User Storys für die Teamarbeit so wichtig sind, stellen sie eine Herausforderung dar. Diskussionen um die richtige Formulierung einer User Story in Scrum oder ihre korrekte Bearbeitung in <a href="https://about.gitlab.com/de-de/blog/what-is-kanban/">Kanban</a> können wertvolle Zeit verbrauchen. So empfinden viele das Konzept eher als undeutlich, aufwändig und belastend.</p>
<p>Wir glauben fest daran, dass eine tiefe Verinnerlichung von User Storys - gerade in der <a href="https://about.gitlab.com/de-de/solutions/agile-delivery/">agilen Methode</a> - dich wirklich voranbringen kann. In diesem Artikel werden wir deshalb so praxisnah wie möglich demonstrieren, wie du sie nutzen kannst, um zu besseren Entscheidungen, Prozessen und Produkten zu gelangen.</p>
<h2>Inhaltsverzeichnis</h2>
<ul>
<li><a href="#was-ist-eine-user-story%3F">Was ist eine User Story?</a></li>
<li><a href="#warum-sollte-ich-mit-user-stories-arbeiten%3F">Warum sollte ich mit User Stories arbeiten?</a></li>
<li><a href="#kann-ich-auch-ohne-user-stories-auskommen%3F">Kann ich auch ohne User Stories auskommen?</a></li>
<li><a href="#welche-rolle-spielen-user-stories-in-agile%3F">Welche Rolle spielen User Stories in Agile?</a></li>
<li><a href="#user-stories-in-scrum">User Stories in Scrum</a></li>
<li><a href="#wie-schreibe-ich-eine-gute-user-story%3F">Wie schreibe ich eine gute User Story?</a>
<ul>
<li><a href="#das-3c-modell">Das 3C-Modell</a></li>
<li><a href="#invest">INVEST</a></li>
</ul>
</li>
<li><a href="#scrum-user-story-aufbau-und-beispiel">Scrum User Story: Aufbau und Beispiel</a>
<ul>
<li><a href="#user-story-beispiel-schritt-1-5-whys">User-Story-Beispiel Schritt 1: 5 Whys</a></li>
<li><a href="#user-story-beispiel-schritt-2-connextra-template">User-Story-Beispiel Schritt 2: Connextra-Template</a></li>
<li><a href="#user-story-beispiel-schritt-3-akzeptanzkriterien">User-Story-Beispiel Schritt 3: Akzeptanzkriterien</a></li>
<li><a href="#das-gherkin-format">Das Gherkin-Format</a></li>
</ul>
</li>
<li><a href="#agile-schatzung">Agile Schätzung</a></li>
<li><a href="#story-points-aufwand-vs-arbeitszeit">Story Points: Aufwand vs. Arbeitszeit</a></li>
<li><a href="#story-points-in-der-schatzung">Story Points in der Schätzung</a>
<ul>
<li><a href="#planning-poker">Planning Poker</a></li>
<li><a href="#affinity-mapping">Affinity Mapping</a></li>
</ul>
</li>
<li><a href="#wer-schreibt-user-stories%3F">Wer schreibt User Stories?</a></li>
</ul>
<p>Wir werden dabei definieren, was User Stories sind, über das Schreiben und den Aufbau einer User Story informieren, Beispiele geben und dir zeigen, was eine gute User Story ausmacht. Doch fangen wir mit einer grundlegenden Frage an:</p>
<h2>Was ist eine User Story?</h2>
<p>Manche bezeichnen eine User Story schlicht als die kleinste Einheit (oder auch als ein „<a href="https://t2informatik.de/wissen-kompakt/user-story/">Werkzeug</a>”) der agilen Methode. Andere, darunter auch die <a href="https://scrumguide.de/user-story/">Agile Scrum Group</a>, als eine „Beschreibung dessen, was ein Benutzer (User) will.”</p>
<p>Aus diesen Definitionsversuchen wird deutlich: <strong>Eine User Story ist eigentlich gar keine „Geschichte”. Sie stellt vielmehr einen Ansatz dar, dein Produkt so zu verändern, dass es aus der Sicht der Kund(innen) ein neues, besseres Erlebnis bietet.</strong></p>
<p>Innerhalb einer User Story ist ein neues Feature somit nur dann eine Verbesserung, wenn es Anwender(innen) einen ganz bestimmten, erfahrbaren Nutzen bietet. Eine Software zu „optimieren”, ohne nach diesem Nutzen zu fragen, wird dabei als nicht zielführend betrachtet.</p>
<p>Gute User Stories zu schreiben, bedeutet, dich in der Entwicklung von Kund(innen) leiten zu lassen und auf ihre Bedürfnisse und Wünsche hinzuarbeiten. Es bedeutet, den Fokus auf Features hinter dir zu lassen und dich in Richtung einer Betrachtungweise zu bewegen, bei der echte Wertschöpfung in den Mittelpunkt gestellt wird.</p>
<p>Dennoch wurde der Begriff „Story”, wie Jeff Patton, einer der geistigen Väter der modernen User Story betont hat, mit Bedacht gewählt. Wir werden darauf später noch genauer eingehen.</p>
<h2>Warum sollte ich mit User Stories arbeiten?</h2>
<p>Diese Frage stellt sich in einigen Teams wohl so manche(r). Denn in der Praxis nimmt sich die Arbeit mit User Stories nicht immer einfach aus. Dennoch lohnt sich die investierte Mühe zweifelsohne. Denn das Konzept der User Story mag auf dem Papier fast schon banal anmuten. In Wahrheit steckt dahinter eine entscheidende Neuausrichtung der Entwicklungsarbeit:</p>
<ul>
<li>User Stories legen den Fokus voll und ganz auf die Anwender(innen) - also auf diejenigen, die das Produkt nutzen, bewerten und bezahlen.</li>
<li>Sie verlagern den Schwerpunkt von „objektiven” Features auf das „subjektive” Erlebnis, mit diesen Features zu arbeiten. Hier kommt der „Story-Gedanke” zum Tragen: Wie wertvoll dein Produkt aus Sicht der Kund(innen) ist, hängt von der Geschichte ab, die sich User(innen) darüber bilden.</li>
<li>Damit kombinieren diese Stories beide Sichten auf ein Produkt: Die technisch-funktionale sowie die narrativ-emotionale.</li>
<li>Weil User Stories die Betonung auf den Nutzen legen, der für Kund(innen) entsteht, sind sie in ihrer Umsetzung nicht starr festgelegt. Das Ziel ist nicht die Anwendung, sondern die Vorstellung von einer besseren Erfahrung. Der Weg zu dieser Erfahrung lässt sich auf viele verschiedene Weisen erreichen.</li>
<li>User Storys sind Teil eines kontinuierlichen Verbesserungsprozesses wie der <a href="https://about.gitlab.com/de-de/solutions/delivery-automation/">automatisierten Softwarebereitstellung</a>, mit vielen sofort testbaren Zwischenstufen (<em>minimal viable product</em>, das kleinste realisierbare Produkt). Dieser Prozess endet theoretisch mit einem Produkt, das aus Sicht der Kund(innen) nicht mehr optimiert werden kann (und welches somit in der Praxis niemals erreicht werden wird).</li>
</ul>
<p>In der Regel helfen User Stories auch dabei, sinnvolle Prioritäten zu setzen, die praxisnah und in einem angemessenen Zeitrahmen realisierbar sind.</p>
<h2>Kann ich auch ohne User Stories auskommen?</h2>
<p>User Stories haben sich fest etabliert. Dennoch kommen auch heute noch viele Teams ohne sie aus. Sogar Firmen, die sich eigentlich fest der agilen Methode verschrieben haben, nutzen sie nicht zwangsläufig.</p>
<p>Trotzdem kann man behaupten: Wer wirklich agil arbeiten will, wird zumindest mit Instrumenten und Konzepten arbeiten, die den User Stories sehr nahe kommen. Wie wir im nächsten Abschnitt zeigen werden, bauen beide auf demselben Ansatz auf und sind eng miteinander verflochten.</p>
<p>Andersherum gilt auch: Nicht jedes Team, das auf User Stories setzt, hat die Philosophie voll verinnerlicht. Nur allzu leicht wird eine User Story zu einem einfachen „Requirement” - einer Auflistung gewünschter Funktionalitäten, bei der oftmals der Nutzen für Kund(innen) vergessen wird.</p>
<h2>Welche Rolle spielen User Stories in Agile?</h2>
<p>Aus dem Gesagten wird ersichtlich, warum User Stories in der agilen Entwicklung auf einen fruchtbaren Nährboden gestoßen sind. Beide legen den Fokus auf ständige Verbesserungen, Teamarbeit einschließlich einer engen Zusammenarbeit mit Kund(innen), und die Orientierung der Ergebnisse an klaren Bewertungskriterien.</p>
<p>User Stories fügen sich nahtlos in eine agile Organisation ein:</p>
<ul>
<li>Idealerweise kann eine User Story innerhalb eines einzigen Sprints abgearbeitet werden.</li>
<li>User Stories werden im Team festgelegt, besprochen und umgesetzt.</li>
<li>Ein klar definiertes Bewertungssystem liefert die Daten, die benötigt werden, um ein Projekt abzuschließen.</li>
</ul>
<p>Willst du User Stories in deinem Team nutzen? Wenn du mit Kanban arbeitest, brauchst du für deine Projektarbeit nichts zu verändern. Du kannst weiterhin mit deinen To-do-Listen arbeiten, richtest die Ziele aber nunmehr auf die Perspektive von Kund(innen) aus.</p>
<h2>User Stories in Scrum</h2>
<p>Wie gezeigt, sind User Stories sehr eng mit der agilen Methode verbunden. Und Scrum ist eine der zentralen Konzepte zur Umsetzung der agilen Methode. So erscheint es als selbstverständlich, dass User Stories auch in Scrum Anwendung finden.</p>
<p>Interessanterweise aber werden sie im <a href="https://scrumguides.org/docs/scrumguide/v2020/2020-Scrum-Guide-German.pdf">Scrum User Guide</a> nicht erwähnt. Stattdessen thematisiert dieser lediglich den „Product Backlog”, also</p>
<p><em>„alle Features, Funktionalitäten, Verbesserungen und Fehlerbehebungen, die das Produkt in Zukunft verändern sollen. Ein Product Backlog Item enthält eine Beschreibung, eine Reihenfolge, Schätzung und Bewertung als Attribute.” [Übersetzung aus dem Englischen]</em></p>
<p>Aus dem gerade Erwähnten dürfen keine falschen Schlussfolgerungen gezogen werden.</p>
<p>User Stories sind nicht die einzige Möglichkeit, mit Scrum kundenorientiert zu arbeiten. Trotzdem haben sie in Scrum ganz gewiss ihren Platz! Vielmehr möchte sich der Scrum-Guide nur nicht eindeutig auf ihre Verwendung festlegen und Scrum-Mastern maximale Freiheit einräumen.</p>
<h2>Wie schreibe ich eine gute User Story?</h2>
<p>Diese Frage stellt sich zu Beginn nahezu jedes neuen Sprints. Wenn User Stories intuitiv erfassbar und ihre Vorteile offensichtlich sind und wenn das Konzept an sich einfach zu erklären ist - warum fällt es dann schwer, es in die Praxis umzusetzen?</p>
<p>Wenn du dich mit dieser Frage beschäftigst, mache dir deswegen keine Vorwürfe. User Storys gibt es als methodische Idee bereits seit fast 30 Jahren. Innerhalb dieser Zeit hat es immer wieder Bemühungen gegeben, die Umsetzung zu vereinfachen - ein eindeutiges Indiz, dass sie nicht einfach ist.</p>
<p>Eine gute User Story hat bestimmte Qualitätskriterien. Diese werden wir uns im nächsten Abschnitt ansehen. Trotzdem glauben wir, dass es möglich ist, auf einer etwas allgemeineren Ebene zu erklären, was eine gute User Story ausmacht:</p>
<p>Damit eine User Story wirklich Nutzen für Kund(innen) generiert, muss sie ihrer Erlebniswelt so nahe wie möglich kommen. Deshalb werden viele der besten User Storys de facto von den Anwender(innen) verfasst - sei es nach einem intensiven Gespräch oder weil der Kontakt so eng ist, dass du sehr genau abschätzen kannst, was diese sich wünschen.</p>
<p>Das zweite wichtige Kriterium ist, diesen Nutzen so lebendig wie möglich darzustellen. Wir haben zu Anfang erwähnt, dass eine User Story keine Geschichte ist. Wenn wir sie zu Papier bringen, dann solltest du sie dir sehr plastisch vorstellen können: <em>So dreidimensional wie ein kleiner Film, der vor dem geistigen Auge abläuft, so kurz gefasst wir ein Haiku.</em> Dabei kannst du die Zufriedenheit bei Anwender(innen) förmlich spüren.</p>
<p>Auf einer formalen Ebene können das 3C-Modell und die INVEST-Methode weitere Hinweise liefern. In den folgenden beiden Abschnitten gehen wir genauer auf sie ein.</p>
<h3>Das 3C-Modell</h3>
<p>Das 3C-Modell entstand bereits früh in der User-Story-Geschichte. Es stammt noch aus einer Zeit, in der die Stories noch wortwörtlich „zu Papier” gebracht wurden. Für eine gute Story sollten in diesem Rahmenwerk folgende drei Punkte erfüllt sein:</p>
<ol>
<li><strong>C</strong>ard: Die User Story sollte so knapp bemessen sein, dass sie auf eine Karteikarte passt, jedoch ausführlich genug, dass sie diese Karte komplett ausfüllt.</li>
<li><strong>C</strong>onversation: Die User Story definiert einen Wunsch und Nutzen der Kund(innen). Die Bewertung und Umsetzung dieser Story erfolgt in enger Zusammenarbeit zwischen allen Teammitgliedern und Kund(innen). Intensive Gespräche sind dabei ein zentraler Bestandteil.</li>
<li><strong>C</strong>onfirmation: Es muss eine objektivierbare Möglichkeit bestehen, festzustellen, wann das Ziel erreicht ist.</li>
</ol>
<p>Das 3C-Modell ist angenehm knapp und bringt zur Geltung, was eine gute Story von einer weniger überzeugenden unterscheidet. Gleichzeitig liefert es wenig praktische Hilfe dabei, eine solche User Story zu schreiben.</p>
<h3>INVEST</h3>
<p>Auch bei dem Akronym INVEST handelt es sich um einen Katalog von Anforderungen an gutes User-Story-Schreiben. Es gibt Überschneidungen mit 3C, aber auch eigenständige Punkte.</p>
<p>Sehen wir uns die sechs Anforderungen von INVEST einzeln an:</p>
<ol>
<li><strong>I</strong>ndependent: Jede User Story sollte einen eigenständigen Wunsch von Kund(innen) abbilden. Sie sollte nicht von der Umsetzung anderer Wünsche abhängen.</li>
<li><strong>N</strong>egotiable: Die Bedürfnisse der Kund(innen) stehen immer im Vordergrund. Aber eine User Story lebt auch vom regen Austausch zwischen verschiedenen Abteilungen und Teams. Wichtiger als ein starres Festhalten an einmal gewählten Formulierungen ist ein ständiges Aushandeln und Neuverhandeln der Ziele sowie der Methoden zu ihrer Umsetzung.</li>
<li><strong>V</strong>aluable: Eine gute User Story muss einen echten, spürbaren Nutzen für Kunden liefern.</li>
<li><strong>E</strong>stimate: Manche User Storys werden sich schnell und problemlos lösen lassen. Andere sind komplex. Damit für die praktische Arbeit ausreichend Mitarbeiter(innen) mit dem erforderlichen Wissen zur Verfügung gestellt werden, bedarf es einer möglichst genauen Aufwandseinschätzung.</li>
<li><strong>S</strong>mall: Eine User Story sollte in einem Sprint beendet werden können. Sobald du mit einem signifikant höheren Aufwand rechnest, solltest du die Story aufteilen oder von Anfang an als Epic planen.</li>
<li><strong>T</strong>estable: Zur Bewertung einer User Story solltest du Abnahmekriterien festlegen können. Diese erlauben es dir, später zu bestimmen, ob du das zu Anfang gesteckte Ziel erreicht hast. Mit diesen Akzeptanzkriterien beschäftigen wir uns gleich.</li>
</ol>
<p>Wie du aus dieser Übersicht erkennen kannst, beziehen sich die über das 3C-Modell hinausgehenden Punkte von INVEST vor allem auf die Arbeit in Scrum. Aus diesem Grund ergibt INVEST Sinn für alle Scrum-Master, die sich intensiver mit User Stories auseinandersetzen wollen.</p>
<h2>Scrum User Story: Aufbau und Beispiel</h2>
<p>Gehen wir nun zu dem Punkt über, der in nahezu allen Artikeln und Übersichten zum Thema fehlt: Einem praktischen Beispiel für eine User Story in Scrum und wie du sie so schreiben kannst, dass sie zu einem wünschenswerten Ergebnis führt. Wir werden in diesem Artikel nicht näher auf ein Epic-Beispiel (lange User Story) eingehen. Denn auch, wenn die Zyklen sich hier über mehrere Sprints erstrecken, bleibt das Grundprinzip identisch.</p>
<p>Nehmen wir an, du hast aus Gesprächen mit Kund(innen) ermittelt, dass diese nicht zufrieden mit der Updatefunktion deines Produkts sind. Immer wieder werden sie während der Arbeit von Update-Meldungen gestört und die Durchführung der Updates beeinträchtigt zudem die Rechenkapazität. Sie würden gerne komfortabel bestimmen können, wann Updates installiert werden sollen oder sich gegen bestimmte Updates entscheiden.</p>
<p>Wie verläuft nun der Weg von diesem ersten Wunsch der Kund(innen) hin zum neuen Feature, beziehungsweise zum Befriedigen des Wunsches der Kund(innen)?</p>
<h3>User-Story-Beispiel Schritt 1: 5 Whys</h3>
<p>Das Konzept der User Story fußt auf der Schöpfung von Nutzen. Deshalb sollte das genaue Definieren dieses Nutzens höchste Priorität genießen. Wenn du den Nutzen nicht richtig erfasst, wird es deinem Team auch nicht gelingen, die zentrale emotionale Komponente des Prozesses - die „Story” - zufriedenstellend umzusetzen.</p>
<p>Hilfe bietet hier die 5-Why-Technik.</p>
<p>Fange damit an, was du erreichen möchtest: ein Update-Prozess, der von Kund(innen) nicht mehr als Belästigung empfunden wird, sondern als Unterstützung und Optimierung. Anschließend stelle dir selbst die Aufgabe, fünf gute Gründe zu finden, warum diese Story einen Nutzen stiftet.</p>
<p>Für diese User Story wäre zum Beispiel aus der Sicht von Kund(innen) denkbar:</p>
<ul>
<li>Damit ich bei voller Rechenleistung weiterarbeiten kann.</li>
<li>Damit ich zunächst sicherstellen kann, dass genug Speicherplatz zur Verfügung steht.</li>
<li>Damit ich die Entscheidung über Updates dann treffe, wenn ich mich damit auch wirklich auseinandersetzen kann und möchte.</li>
<li>Damit ich gezielt nur die Updates auswählen kann, die ich brauche.</li>
<li>Damit ich weiß, welche neuen Updates installiert wurden und immer auf dem neuesten Stand bleibe.</li>
</ul>
<p>Je mehr Details du hier erarbeiten kannst, umso deutlicher wird es für das Team als Ganzes (und manchmal sogar für die Kund(innen) selbst), worin genau die „Story” besteht.</p>
<h3>User-Story-Beispiel Schritt 2: Connextra-Template</h3>
<p>Wir haben es bereits erwähnt: User Stories sind eher wie Haikus als Geschichten. Und genau wie Haikus hilft es, bei der Formulierung einer User Story einem mehr oder weniger strengen Format zu folgen.</p>
<p>Rachel Davis von der Firma Connextra stellte fest, dass viele Mitarbeiter(innen) mit dem Schreiben einer guten User Story überfordert waren. Die inhärente Freiheit des Konzepts erwies sich als ein Problem. Wie so oft bot eine gezielte Limitierung der Optionen eine passende Lösung.</p>
<p>Davis schlug den folgenden User-Story-Aufbau vor:</p>
<p><em>Als [Rolle] möchte ich [Story], damit ich [Grund]</em></p>
<p>Das bedeutet in unserem User-Story-Beispiel:</p>
<p><em>Als Kundin möchte ich in Ruhe mit der Software arbeiten können, ohne von Updates unterbrochen zu werden. Ich möchte aber auch immer darüber informiert sein, was für Updates genau neu installiert werden und mich gegebenenfalls gegen sie entscheiden. Der Grund ist, dass ich es vorziehe, immer die Kontrolle über die Software zu behalten und immer auf dem neuesten Stand zu sein.</em></p>
<p>Dies ist leider nicht, wie das Template in der Praxis üblicherweise benutzt wird. Oftmals setzen viele Teams statt einer emotional gelebten „Story” einfach eine rein technische Funktionalität ein.</p>
<p>Dabei geht genau der wichtigste Teil verloren. Bei User Stories geht es um eine alternative Möglichkeit, mit dem Produkt zu arbeiten - nicht um eine neue Methode, die Arbeit aufzuteilen. Wenn du so vorgehst, nutzt du zwar formal einen passenden User-Story-Aufbau, arbeitest aber mit alten Methoden.</p>
<p>Das Connextra-Template verführt dazu, zu Mustern zurückzukehren, die du hinter dir lassen solltest. Wer es aber in seiner ursprünglichen Form verwendet, kann sehr großen Nutzen daraus ziehen.</p>
<h3>User-Story-Beispiel Schritt 3: Akzeptanzkriterien</h3>
<p>Jede gute Geschichte hat einen Anfang und ein Ende. Ohne das letzte Kapitel und ein zufriedenstellendes Finale wird selbst ein spannender Anfang und ein packender Mittelteil mit einer Enttäuschung enden.</p>
<p>Aus diesem Grund solltest du unbedingt gleich zu Anfang Akzeptanzkriterien für deine User Story festlegen. Diese setzen einen Rahmen dafür, wann eine User Story als beendet („done”) betrachtet werden kann. Zusammen mit dem vierten Schritt, dem Abschätzen, verankern sie User Stories fest im agilen Framework.</p>
<p>Die Agile Scrum Group meint <a href="https://agilescrumgroup.de/akzeptanzkriterien/">zum Thema Akzeptanzkriterien</a>:</p>
<p><em>„Akzeptanzkriterien geben einer User Story Details, sodass Sie wissen, wann eine User Story fertig ist. Akzeptanzkriterien entstehen aus Gesprächen zwischen dem Product Owner, den Stakeholdern und den Entwicklern, wenn Sie nach dem Scrum Framework arbeiten.”</em></p>
<p>Es empfiehlt sich bei dem Festlegen der Akzeptanzkriterien folgendes zu beachten:</p>
<ul>
<li>4-8 Akzeptanzkriterien pro User Story erscheinen den meisten Experten als eine sinnvolle Menge.</li>
<li>Suche nach objektiven Kriterien, insofern dies innerhalb der subjektiven Grenzen einer User Story möglich ist. Umso präziser sich feststellen lässt, ob ein Kriterium erfüllt wurde, um so besser.</li>
<li>Entscheidend bei User Storys ist die „Story”, die sich Kund(innen) wünschen, nicht, wie diese umgesetzt wird oder welche Features sie beinhaltet. Lege deshalb genau fest, „was” du erreichen möchtest - und überlasse das „wie” der Teamarbeit.</li>
</ul>
<p>Wie sehen Akzeptanzkriterien in der Praxis aus? Es gibt hier verschiedene Ansätze. Das beste Beispiel ist das sogenannte Gherkin-Format.</p>
<h3>Das Gherkin-Format</h3>
<p>Ebenso wie das Connextra-Template für den User-Story-Aufbau packt das Gherkin-Format die Formulierung von Akzeptanzkriterien für diese User Stories in ein fixes Format. Das erleichtert die Arbeit ungemein.</p>
<p>Das Format sieht folgendermaßen aus:</p>
<p><em>Gegeben &lt;Voraussetzung&gt;</em><br>
<em>wenn &lt;Ereignis&gt;</em><br>
<em>dann &lt;Ergebnis&gt;</em></p>
<p>So kann für viele potenzielle Fälle ein Szenario entworfen werden. Ein hervorragendes User-Story-Beispiel findet sich in einem ausführlichen <a href="https://www.digitale-verwaltung.de/SharedDocs/downloads/Webs/DV/DE/servicehandbuch.pdf?__blob=publicationFile&amp;v=3">PDF-Leitfaden des Bundesinnenministeriums</a>: Hier möchten Anwender(innen) ein „Passbild hochladen&quot;, damit ihre „Antragsdaten vollständig sind”:</p>
<p><em>„Szenario: Bilddatei hochladen</em><br>
<em>Gegeben ist, dass der Nutzende angemeldet ist und sich auf dem entsprechenden Formular befindet,</em><br>
<em>Wenn der Nutzende eine ausgewählte Datei hochlädt und es sich um eine Bilddatei handelt,</em><br>
<em>dann wird sie übernommen und dem Nutzenden als hochgeladen angezeigt und die Biometrie-Prüfung</em><br>
<em>wird angestoßen.</em></p>
<p><em>Szenario: Falsches Format hochladen</em><br>
<em>Gegeben ist, dass der Nutzende angemeldet ist und sich auf dem entsprechenden Formular befindet,</em><br>
<em>Wenn der Nutzende eine ausgewählte Datei hochlädt und es keine Bilddatei ist,</em><br>
<em>dann wird sie nicht übernommen und es wird ein Fehler angezeigt.”</em></p>
<h2>Agile Schätzung</h2>
<p>Die Welt der Softwareentwicklung ist nicht linear. Aufgaben werden nicht bequem der Reihe nach abgearbeitet. In der Regel gilt es, mit einer limitierten Menge an Arbeitszeit die von dir und deinem Team definierten User Stories gleichzeitig oder zeitversetzt umzusetzen. Das stellt die Planung vor anspruchsvolle Aufgaben.</p>
<p>Das Ziel der User-Story-Organisation besteht darin, zu verstehen, wie viel Aufwand jede einzelne Story erfordert. Je genauer du dies weißt, desto genauer wirst du in der Lage sein, die zu erledigenden Aufgaben auf die bestehenden Kapazitäten zu verteilen. Je gröber dein Verständnis, umso höher das Risiko, dass User Stories gar nicht oder nicht in der erforderlichen Qualität erledigt werden.</p>
<p>Dieses Risiko kann das Überleben des Unternehmens gefährden. Aus diesem Grund nimmt die agile Schätzung - also die Schätzung des Aufwands deiner User Stories - eine zentrale Rolle ein.</p>
<p>Du könntest nun meinen, dass es dafür eine einfache Lösung gibt: Du weist schlicht jeder User Story eine geschätzte Bearbeitungsdauer zu und verteilst die Arbeit anschließend so, dass sie innerhalb der geplanten Sprints erledigt werden kann.</p>
<p>In der Praxis haben sich andere Ansätze als effektiver erwiesen.</p>
<h2>Story Points: Aufwand vs. Arbeitszeit</h2>
<p>Zeit ist relativ. Was für das Universum als Ganzes gilt, hat auch in der Softwareentwicklung Bestand. Arbeitszeit präziseeinzuschätzen hängt von einer Vielzahl von Faktoren ab und kann sich sogar für erfahrene Personalplaner als äußerst schwierig erweisen. Gerade bei schnellen und zugleich zeitintensiven Branchen können selbst kleine Abweichungen massive Folgewirkungen haben und den gesamten Zeitplan durcheinander bringen.</p>
<p>Aus unserer Sicht sind zwei Punkte verantwortlich dafür, dass Zeit in der Planung kein idealer Bewertungsmaßstab ist:</p>
<ul>
<li>Die Komplexitäten verschiedener User Stories können sehr weit auseinanderklaffen. Das bedeutet nicht unbedingt, dass komplexe Aufgaben mehr Zeit benötigen. Möglicherweise erfordern sie lediglich, dass sich erfahrene, hochqualifizierte oder auf dieses Thema geschulte Teammitglieder um ihre Bearbeitung kümmern müssen.</li>
<li>Der Aufwand einer Aufgabe hängt ebenfalls von sehr unterschiedlichen Faktoren ab. Manche User Stories müssen ausgiebig im Team diskutiert werden, andere erfordern viel Zeit, um realisiert zu werden, obwohl sie keineswegs „schwierig” sind. Andere können nur in ständiger Rücksprache mit Kund(innen) umgesetzt werden. All das beeinflusst die Arbeitszeit, teilweise auf eine Art und Weise, die nur schwer vorherzusehen ist.</li>
</ul>
<p>Aus diesem Grund hat sich eine andere Einheit zur Einschätzung herauskristallisiert: Story Points. Dabei handelt es sich um ein Maß, das den Aufwand einer User Story auf eine nicht direkt mit der erforderlichen Zeit verbundene Weise zu bestimmen versucht: Je mehr Story Points eine User Story erfordert, umso höher der Aufwand.</p>
<h2>Story Points in der Schätzung</h2>
<p>Story Points sind Aufwandspunkte. Sie können in erfahrenen Teams zu sehr genauen Schätzungen führen. Trotzdem stehen sie niemals für absolute Werte und sind im Gesamtkontext aller aktuell anstehenden User Storys zu sehen.</p>
<p>Die beliebtesten Konzepte basieren nahezu alle grob auf der Fibonacci-Folge. In dieser Sequenz entsteht die jeweils nächste Zahl aus der Summe der beiden vorangegangenen. Die ersten 13 Einträge dieser Folge sind demzufolge:</p>
<p>0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144</p>
<p>In der User-Story-Planung werden diese Zahlen ein wenig geglättet. So entsteht zum Beispiel die folgende Kette:</p>
<p>0, 1, 2, 3, 4, 5, 8, 13, 20, 30, 50, 100</p>
<p>Wir haben auch Konzepte gefunden, in der zwischen 0 und 1 noch ein 0,5 eingefügt und statt einer 50 eine 40 gewählt wurde. Das aber sind Feinheiten, die das Konzept als solches nicht wesentlich  tangieren.</p>
<p>Anschließend weist das Team den User Stories einen dieser Zahlenwerte zu. Daraus entsteht eine Reihenfolge der Stories nach Aufwand. Die folgenden Methoden zur Zuweisung von Story Points sind üblich:</p>
<h3>Planning Poker</h3>
<p>Beim Planning Poker weisen die Teammitglieder jeder User Story auf einer verdeckt gehaltenen Karte, je nach dem geschätzten Aufwand, Story Points zwischen 0 und 100 zu. Anschließend werden die Karten offen auf den Tisch gelegt und nach Zahl der Story Points auf Stapel verteilt.</p>
<p>Der Stapel mit den meisten Karten ist der „Sieger” und die User Story erhält die damit verbundene Zahl an Punkten, beispielsweise 20.</p>
<p>Das Planning Poker ist eine elegante Methode der Aufwandsschätzung, die letzten Endes aber natürlich einer simplen Abstimmung gleichkommt.</p>
<p>Das Konzept der Planung durch T-Shirtgrößen, was sich ebenfalls oft in einschlägigen Artikeln findet, ist aus unserer Sicht keine eigenständige Methode, sondern eine modifizierte Variante des Pokers. Gleiches gilt für das „Bucket System” (ein Eimer, in den die Karten geschmissen werden) oder das „Dot Voting” (mit kleinen Klebepunkten).</p>
<h3>Affinity Mapping</h3>
<p>Das Affinity Mapping ist eine der wenigen Alternativen zum Planning Poker. Es besteht aus zwei Phasen:</p>
<ol>
<li>Zunächst gruppieren alle Teammitglieder gemeinschaftlich die Aufgaben, die einen ähnlichen Komplexitätsgrad aufweisen. Die Einteilung erfolgt durch Diskussion innerhalb des Teams.</li>
<li>Anschließend werden den User Stories innerhalb der Gruppe, entweder durch weitere Gespräche oder Methoden wie Planning Poker, Story Points zugewiesen. So entsteht eine Reihenfolge, bei der die aufwandsintensiven Stories ganz oben, die vermutlich weniger anspruchsvollen weiter unten stehen.</li>
</ol>
<h2>Wer schreibt User Stories?</h2>
<p>In der Vergangenheit wurde die Planung und Aufgabenzuweisung üblicherweise von einer zentralen Instanz oder einer verantwortlichen Person vorgenommen. Bis heute hat sich diese Arbeitsverteilung in vielen Unternehmen gehalten. Sogar Scrum, ein teamorientiertes Konzept innerhalb der teamorientierten Agile-Management-Philosophie, arbeitet bis heute mit einem Scrum-Master.</p>
<p>Das Schreiben von User Stories unterscheidet sich hier deutlich. Zwar wird die erste Version der User Story oftmals noch von einem erfahrenen Teammitglied verfasst, beispielsweise nach einem ausführlichen Austausch mit Kund(innen). Hier schließt sich direkt die Phase der „Verhandlungen” an, also des Austauschs zwischen allen Beteiligten.</p>
<p>Somit werden User Stories zwar noch sehr oft von Einzelnen vorbereitet, geschrieben werden sie aber von der Gruppe.</p>
<p>Genau das macht sie auch zu einem so großartigen Tool. Denn wie jeder Autor weiß, ist eine Geschichte nur dann gut, wenn man sich mit ihr identifizieren kann.</p>
<p><em>Willst Du mehr dazu wissen, wie Deine persönliche User Story in Scrum zum Erfolg wird? Dann empfehlen wir Dir unseren Leitfaden zur <a href="https://docs.gitlab.com/ee/tutorials/scrum_events/">Verwendung von Scrum in GitLab</a>. Oder informiere Dich dazu, warum GitLab ganz allgemein die führende <a href="https://about.gitlab.com/de-de/platform/">DevSecOps-Plattform</a> ist.</em></p>
]]></content>
        <author>
            <name>GitLab Germany Team</name>
            <uri>https://about.gitlab.com/blog/authors/gitlab-germany team</uri>
        </author>
        <published>2025-05-20T00:00:00.000Z</published>
    </entry>
    <entry>
        <title type="html"><![CDATA[Was ist Kubernetes?]]></title>
        <id>https://about.gitlab.com/de-de/blog/definition-what-is-kubernetes/</id>
        <link href="https://about.gitlab.com/de-de/blog/definition-what-is-kubernetes/"/>
        <updated>2025-05-15T00:00:00.000Z</updated>
        <content type="html"><![CDATA[<h1>Kubernetes: Einfach erklärt</h1>
<p>Kubernetes hat sich weltweit als führende Technologie in der Container-Orchestrierung durchgesetzt. Die Vielfalt an Funktionalitäten, die Kubernetes bereitstellt, ist aber nicht immer leicht zu nutzen. Lukas Gentele schreibt auf entwickler.de, dass &quot;von vielen Entwicklern Kubernetes als zu komplex und kaum zu beherrschen wahrgenommen wird&quot;. Damit spricht er aus, was viele denken.</p>
<p>Ironischerweise besteht der Hauptnutzen von Kubernetes darin, viele Anwendungen überhaupt erst beherrschbar zu machen. Warum das kein Widerspruch ist, was Kubernetes ist und wie es funktioniert, erfährst du in diesem Artikel.</p>
<h2>Inhaltsverzeichnis</h2>
<ul>
<li><a href="#kubernetes-einfach-erkl%C3%A4rt">Kubernetes: Einfach erklärt</a>
<ul>
<li><a href="#kubernetes-container-kein-pod-kommt-ohne-aus">Kubernetes-Container: Kein Pod kommt ohne aus</a></li>
<li><a href="#container-%E2%80%93-%C3%BCbersichtlich-kollaborativ%2C-effizient">Container – übersichtlich, kollaborativ, effizient</a></li>
<li><a href="#pod-container-kombinationen">Pod: Container Kombinationen</a></li>
<li><a href="#orchestrierung-container-kontrollieren">Orchestrierung: Container kontrollieren</a></li>
<li><a href="#abstraktion-und-zustandsorientierung">Abstraktion und Zustandsorientierung</a></li>
<li><a href="#node-kubelet%2C-cluster-die-welt-von-kubernetes">Node, Kubelet, Cluster: Die Welt von Kubernetes</a></li>
<li><a href="#wie-funktioniert-kubernetes%3F">Wie funktioniert Kubernetes?</a></li>
<li><a href="#kubernetes-in-der-praxis">Kubernetes in der Praxis</a></li>
<li><a href="#die-vorteile-von-kubernetes">Die Vorteile von Kubernetes</a></li>
<li><a href="#wie-funktioniert-die-kubernetes-integration-unter-gitlab">Wie funktioniert die Kubernetes-Integration unter GitLab?</a></li>
<li><a href="#faqs-zu-kubernetes-(k8s)">FAQs zu Kubernetes (K8s)</a></li>
</ul>
</li>
</ul>
<h2>Kubernetes-Container: Kein Pod kommt ohne aus</h2>
<p>Wenn wir ein Verständnis über Kubernetes vermitteln wollen, kommen wir an einem Bestandteil nicht vorbei – dem Container.</p>
<p>Ähnlich wie Betriebssysteme wurden Anwendungen noch bis vor wenigen Jahre als Monolith entwickelt. Das bedeutet, Anwendungen bestanden aus einer einzigen unteilbaren Codebasis, welche alle Informationen enthält, die zum Betrieb notwendig sind.</p>
<p>Auch, wenn nur wenige Teile der Anwendung benötigt wurden, musste trotzdem das gesamte Programm geladen werden. Das verbrauchte offensichtlich viele Ressourcen, das System wurde langsam und fehleranfällig.</p>
<h2>Container – übersichtlich, kollaborativ, effizient</h2>
<p>Erste Versuche, die Nachteile einer monolithischen Architektur zu umgehen und Teile eines Programms gezielt zu isolieren, entstanden in den späten 70ern und frühen 80er-Jahren. Doch erst Docker, welches 2013 veröffentlicht wurde, verhalf dem Gedanken auf breiter Basis zum Durchbruch.</p>
<p>Die verschiedenen Funktionalitäten einer Anwendung werden mit einer Software wie Docker isoliert und in Pakete aufgeteilt. Diese Container enthalten sämtliche Daten, Software und Bibliotheken, die zum Betrieb genau dieser Funktionalitäten erforderlich sind.</p>
<p>Die Container können eigenständig genutzt oder getestet werden. Aber man kann sie auch zu einer größeren Architektur verknüpfen und &quot;aufeinanderstapeln&quot; wie Container (die Idee entstand <a href="https://www.computerwoche.de/a/der-niedergang-von-docker,3551769">laut dem ehemaligen Docker-CEO Ben Golub</a> &quot;als wir all die Containerschiffe im Hafen von Oakland einlaufen sahen&quot;).</p>
<p>Früher als monolithische Anwendungen entwickelt, werden Programme heute als Zusammensetzungen einzelner Container betrachtet. Anstatt den gesamten Code zu laden, werden nur die Container verwendet, die für die jeweils auszuführenden Aufgaben notwendig sind. Dadurch, dass die Container bereits alle Daten enthalten, die benötigt werden, um das Programm zu starten, wird es deutlich einfacher, einzelne Komponenten von einem Server mit Betriebssystem A auf einen anderen mit Betriebssystem B zu verschieben.</p>
<h2>Pod: Container Kombinationen</h2>
<p>Ausgehend von den einzelnen Docker-Containern bilden Anwender(innen) nun Gruppen aus Containern, die im Rahmen einer bestimmten Anwendung oder eines größeren Systems zusammenarbeiten. Jede dieser virtuellen Gruppen bezeichnet man als &quot;Pod&quot;.</p>
<p>Im Beispiel eines E-Commerces Unternehmen, kann nun ein Pod die Benutzeroberfläche enthalten, während andere Pods die Bezahlung, oder die Lieferung abwickeln. Die Vorteile sind klar: Dieser Ansatz ist schlanker und robuster als der monolithische und lässt sich konsistent auf verschiedenen Betriebssystemen verwenden. Gerade in der Softwareentwicklung bedeutete diese Zuverlässigkeit einen deutlichen Sprung nach vorne.</p>
<h2>Orchestrierung: Container kontrollieren</h2>
<p>Gleichzeitig erfordert eine Anwendung, die aus mehreren Containern zusammengesetzt ist, ein höheres Maß an Management.</p>
<p>Was passiert beispielsweise, wenn ein Pod ausfällt? Wie geht man mit Fehlern in einem Pod um? Wo sollen die Pods ausgeführt werden? Wie wirkt sich die Containerisierung auf die Entwicklung neuer Funktionalitäten aus? Wie funktioniert überhaupt die ständige Neuverteilung verschiedener Pods innerhalb derselben Anwendung während des laufenden Betriebs?</p>
<p>Diese Fragen werden dringlicher, je mehr Container eine Anwendung verwendet. Und sie werden geradezu kritisch in einer Umgebung, in der sehr viele Nutzer(innen) auf eine Vielzahl containerisierter Anwendungen zugreifen sollen.</p>
<p>Wenn es keinen monolithischen Code mehr gibt, welcher festlegt, in welchen Situationen bestimmte Kombinationen zur Anwendung kommen, werden neue Prinzipien zur Aktivierung benötigt. Darüber hinaus ergeben sich durch die Containerisierung eine Vielzahl spezifischer Herausforderungen.</p>
<p>Die Lösungsansätze, die sich mit dieser Herausforderung beschäftigen, werden unter dem Begriff Container-Orchestrierung zusammengefasst. Einfach erklärt ist Kubernetes das derzeit wohl leistungsfähigste und effizienteste Orchestrierungs-Tool.</p>
<h2>Abstraktion und Zustandsorientierung</h2>
<p>Vor der Einführung der Containerisierung, die mit Docker ihren Durchbruch fand, waren Programme im Wesentlichen Stories, die durch ihren Code zusammengehalten wurden. Mit Containern wird dieses Narrativ jedoch aufgebrochen und in seine einzelnen Bestandteile zerlegt. Damit aus diesen Teilen wieder eine sinnvolle Geschichte entsteht, benötigt man einen „roten Faden&quot;, der die einzelnen Komponenten zusammenführt.</p>
<p>Aus der Perspektive von Kubernetes werden Anwendungen schlicht als „Arbeitslasten&quot; (Workloads) betrachtet – also Dienste, die eine bestimmte Menge an Systemressourcen beanspruchen. Pods fungieren dabei als Abstraktionen, da der Zusammenhang zwischen den einzelnen Pods jederzeit aufgelöst und neu gestaltet werden kann.</p>
<p>Das bedeutet, dass du jederzeit eine bestehende Struktur aufbrechen und nach Belieben neu zusammensetzen kannst. Mit denselben Komponenten lässt sich so etwas völlig Neues erschaffen.</p>
<p>Wichtig bei der Wahl der geeigneten Abstraktion ist der Zustand (State), der durch die Kombination oder Aktivierung von Nutzlasten im System entsteht. Manche Zustände sind gewünscht, andere nicht.</p>
<p>Wenn man Kubernetes einfach definieren würde, würde man sagen Kubernetes stellt sicher, dass alle Komponenten im richtigen Zustand sind.</p>
<h2>Node, Kubelet, Cluster: Die Welt von Kubernetes</h2>
<p>In einem System werden Pods, also funktional zusammengehörige Kombinationen von Kubernetes-Containern auf sogenannte Knoten (englisch: Nodes) verteilt. Ein Knoten kann sowohl ein physischer Rechner (PC) als auch eine virtuelle Maschine (VM) sein.</p>
<p>Es gibt zwei Formen von Knoten:</p>
<ul>
<li>Die sogenannten Master-Nodes, welche die Steuerung und Kontrolle übernehmen sowie</li>
<li>die Work-Nodes, auf denen die Anwendungen liegen, welche die Funktionalität einer Anwendung übernehmen.</li>
</ul>
<p>Die Kommunikation zwischen diesen Ebenen wird von kleinen Managementagenten übernommen, den Kubelets.</p>
<p>Schließlich kann man mehrere Knoten zu Kubernetes-Clustern aufsetzen. Diese bilden dann die Umgebung ab, die Kubernetes verwaltet und auf welcher Kubernetes läuft.</p>
<h2>Wie funktioniert Kubernetes?</h2>
<p>Kubernetes automatisiert die Container-Orchestrierung, jedoch ist es als Administrator wichtig, stets die Kontrolle darüber zu behalten, welche Prioritäten dabei gesetzt und welche Aspekte berücksichtigt werden müssen.</p>
<p>Administrator(inn)en erarbeiten zusammen mit den Entwickler(innen)/Anwender(innen) eine Liste an gewünschten Zuständen. Dazu kann beispielsweise der Wunsch gehören, dass gewisse Pods stets aktiv sein sollten. Auch dann, wenn sie formal nicht ununterbrochen benötigt werden.</p>
<p>Das ist ein völlig neuer Ansatz, wie über die Kontrolle der Software nachgedacht werden muss. Statt ständig auf sich ändernde Anforderungen mit neuen Befehlen zu reagieren, definiert man stattdessen, welche Zustände erfüllt werden sollen und überlässt es dann Kubernetes diese zu erfüllen.</p>
<p><em>Man bezeichnet diese Form der Kontrolle auch als &quot;deklarativ&quot;, gegenüber dem traditionellen Modell der &quot;imperativen&quot; (befehlsgebenden) Kontrolle.</em></p>
<p>Ein weiteres Eingreifen seitens Administrator(inn)en ist im Idealfall nicht mehr erforderlich. Senior Solutions Manager Brendan O'Leary von GitLab hat das einmal folgendermaßen auf den Punkt gebracht: <em>&quot;Kubernetes sorgt dafür, dass das System so bleibt, wie wir es haben wollen.&quot;</em></p>
<h2>Kubernetes in der Praxis</h2>
<p>Wie funktioniert die Orchestrierung nun?</p>
<p>Kubernetes übernimmt eine Vielzahl von Funktionen, welche die Verwendung der Pods im Cluster optimieren:</p>
<ul>
<li>Der Kubernetes Scheduler sorgt dafür, dass Pods den für sie besten Knoten zugeordnet werden.</li>
<li>Kubernetes bringt die Nachfrage nach Nutzlasten mit dem Angebot in Einklang. Das bedeutet: Wenn besonders viele Nutzer(inn)en ein ganz bestimmtes Pod anfragen, droht eine Überlastung. Kubernetes kann hierauf mit zwei Antworten reagieren: Es kann für diesen Pod mehr Ressourcen bereitstellen, oder es kann den Pod duplizieren, also Kopien erstellen und die Anfragen auf diese neuen Pods verteilen. Dieser Prozess wird als load balancing bezeichnet.</li>
<li>Kubernetes aktualisiert sich stets selbst und bleibt somit immer auf dem neuesten Stand.</li>
<li>Entstehen in einem Pod Fehler, die zu einem Ausfall führen, kann Kubernetes im Rahmen seines Self-healings (Selbstheilung) entweder den Pod reparieren oder es auf einen funktionsfähigen früheren Zustand zurücksetzen.</li>
<li>Hast du einmal ein Kubernetes-Cluster aufgesetzt, werden Nutzlasten oft von einem Knoten auf einen anderen verschoben. Interne IP-Adressen können hier also nicht mehr verwendet werden, um den aktuellen Ort eines Pods zu bestimmen (weil er sich ständig ändert). Mit der Service-Discovery-Funktion übernimmt Kubernetes die Aufgabe, dass Anfragen auf dem richtigen Pod auch ankommen.</li>
</ul>
<h2>Die Vorteile von Kubernetes</h2>
<p>Gerade bei sehr großen Cloud-Umgebungen ist leicht ersichtlich, warum die oben beschriebene, automatisierte Gewährleistung eines optimalen Zustands einen großen Nutzen mit sich bringt.</p>
<p>Ein weiterer Vorteil von Kubernetes besteht in der Entwicklung neuer Funktionen. Es ermöglicht ein reibungsloses Testen, ohne dass es dabei zum Ausfall des Systems kommt. Neue Container und Pods können unkompliziert hinzugefügt werden. Teams können gezielt nur an den Diensten arbeiten, für die sie zuständig sind und so ganz gezielt und spezifisch das System optimieren.</p>
<p>Gerade Letzteres war der Grund, dass GitLab sich bereits 2017 für ein Container-zentriertes System mit Kubernetes entschieden hat.</p>
<p>Lukas Gentele schreibt dazu:</p>
<p><em>&quot;Dass das Kubernetes-Ökosystem so vielseitig ist, mag auf den ersten Blick abschrecken, doch es ist notwendig, da die Architektur von Kubernetes ein großes Maß an Flexibilität bietet.&quot;</em></p>
<h2>Wie funktioniert die Kubernetes-Integration unter GitLab?</h2>
<p>GitLab ist eine Platform die <a href="https://about.gitlab.com/de-de/solutions/continuous-integration/">Kontinuierlichen Integration und Auslieferung</a> ermöglicht. Somit kannst du als GitLab-Nutzer(in) die Vorteile von Kubernetes bezüglich der Container-Orchestrierung für dich nutzen.</p>
<p>Weil GitLab CE und Kubernetes so natürlich miteinander harmonieren, fällt die Integration recht unkompliziert aus. Wir haben für dich einen Artikel vorbereitet, der genau erklärt, wie du ein <a href="https://docs.gitlab.com/ee/user/clusters/agent/">Kubernetes Cluster mit GitLab verbindest</a>.</p>
<p>Kurz zusammengefasst erfordert die Integration folgende Punkte:</p>
<ul>
<li>Definiere das Cluster, welches über Kubernetes automatisiert werden soll.</li>
<li>Installiere einen Agenten, der die Kommunikation mit dem Cluster übernimmt.</li>
<li>Konfiguriere die GitLab-CI/CD Pipeline so, dass sie die Kubernetes-API verwendet.</li>
</ul>
<h2>FAQs zu Kubernetes (K8s)</h2>
<h3>Warum wird Kubernetes auch K8s genannt? Was bedeutet der Begriff?</h3>
<p>K8s ist eine smarte, leicht kryptische Abkürzung des Begriffs Kubernetes: &quot;K&quot; und &quot;s&quot; bezeichnen den ersten und letzten Buchstaben, die &quot;8&quot; schlicht die Anzahl der Buchstaben, die dazwischen liegen.</p>
<p>Das Wort Kubernetes stammt aus dem Griechischen und bedeutet Steuer- oder Fährmann. Der Begriff bezieht sich auf die zentrale Aufgabe von Kubernetes, ein System auch bei &quot;hohem Wellengang&quot; stets stabil zu halten und vor dem Kentern zu bewahren.</p>
<h3>Wer hat Kubernetes entwickelt?</h3>
<p>Die ersten Impulse für Kubernetes setzte Google mit seinen Vorläuferprojekten &quot;Borg&quot; und &quot;Project 7&quot;. Beide beschäftigten sich mit der Problemstellung, die Komplexität containierisierter Anwendungen beherrschbar zu machen.</p>
<p>Bewusst als Open-Source-Plattform entwickelt, entstand Kubernetes aus der Kollaboration verschiedener großer und kleiner Unternehmen, die sich in der Cloud Native Computing Foundation zusammenschlossen.</p>
<p>Darüber hinaus wurde es maßgeblich über die Git-Community ergänzt und weiterentwickelt.</p>
<h3>Was kostet die Nutzung von Kubernetes?</h3>
<p>Bei Kubernetes handelt es sich um ein Open-Source-System. Das bedeutet, dass das Programm kostenfrei heruntergeladen werden kann. Trotzdem entstehen bei der Nutzung von Kubernetes in deinem Unternehmen Kosten, potentiell sogar recht hohe.</p>
<p>Der Grund dafür ist, dass die nackte Basisversion der Anwendung letzten Endes für die meisten Anwender(innen) nicht nutzbar ist.</p>
<p>Neben den Kosten, die für das Hosten der Kubernetes-Cluster in der Cloud anfallen, solltest du folgende möglichen Kostenpunkte berücksichtigen:</p>
<ul>
<li>Die Nutzung von Kubernetes-Dienstleistungen, welche den Einsatz vereinfachen.</li>
<li>Experten, die das Kubernetes-System konfigurieren, es gegebenenfalls warten und es auf dem neuesten Stand halten. Gerade angesichts des hohen Spezialisierungsgrads des Anforderungsprofils sowie der Menge der anfallenden Arbeitsstunden können hierbei erhebliche Kosten entstehen.</li>
<li>Nach dem Aufsetzen eines Kubernetes-Clusters liegen Ressourcen auf verschiedenen Cloud-Speichern. Ein wichtiger Teil der Funktionalität von Kubernetes besteht darin, Nutzlasten dynamisch zwischen diesen Cloud-Speichern zu verschieben, so dass die Stabilität, Sicherheit und Geschwindigkeit des Systems optimiert wird. Allerdings wird dir das Verschieben von Datenpaketen von einem Speicher auf einen anderen sogar dann berechnet, wenn alle deine Daten bei demselben/derselben Provider(in) liegen. Diese Egress-Kosten werden gemäß des verschobenen Datenvolumens kalkuliert und können sich, abhängig von der Größe der Kubernetes-Cluster, am Ende des Jahres wahrhaft auftürmen.</li>
</ul>
<p>Immer mehr Anbieter(innen) haben inzwischen Kubernetes-Online-Rechner im Angebot, mit denen du einen besseren Eindruck über die möglichen Kosten erhältst. Allerdings bleibt es meistens bei einer <a href="https://www.heise.de/news/Kosten-der-Google-Kubernetes-Engine-vorab-berechnen-zumindest-grob-7120708.html">Schätzung</a>.</p>
]]></content>
        <author>
            <name>GitLab Germany Team</name>
            <uri>https://about.gitlab.com/blog/authors/gitlab-germany team</uri>
        </author>
        <published>2025-05-15T00:00:00.000Z</published>
    </entry>
    <entry>
        <title type="html"><![CDATA[Künstliche Intelligenz für alle Kund(inn)en von GitLab Premium und Ultimate]]></title>
        <id>https://about.gitlab.com/de-de/blog/gitlab-premium-with-duo/</id>
        <link href="https://about.gitlab.com/de-de/blog/gitlab-premium-with-duo/"/>
        <updated>2025-05-15T00:00:00.000Z</updated>
        <content type="html"><![CDATA[<p>Heute präsentieren wir GitLab 18.0, das unsere neuesten Innovationen und Pläne in den Bereichen DevSecOps-Workflows, Sicherheit und Compliance sowie KI in den Vordergrund stellt.</p>
<p><strong>Ab dieser Version enthalten GitLab Premium und Ultimate jetzt auch die grundlegenden KI-Funktionen von GitLab Duo – und das ohne zusätzliche Kosten.</strong></p>
<p>Alle Kund(inn)en mit Premium- und Ultimate-Lizenz erhalten sofort Zugang zu GitLab Duo Codevorschläge und Duo Chat direkt in ihren bevorzugten unterstützten Quellcode-Editoren und IDEs.</p>
<h2>KI für jedes Entwicklungsteam</h2>
<p>Künstliche Intelligenz steht jetzt im Mittelpunkt der Entwicklererfahrung. KI verbessert die Programmierung in vielerlei Hinsicht: Sie analysiert deine Codebase und liefert dir während der Eingabe Vorschläge in Echtzeit, erstellt Funktionen und Methoden basierend auf dem Kontext deines Projekts, reduziert sich wiederholende Aufgaben und automatisiert Code Reviews.</p>
<p>In den letzten Jahren haben wir <a href="https://about.gitlab.com/de-de/gitlab-duo/">GitLab Duo</a> entwickelt, um generative und agentische KI-Funktionen wie diese in unsere Plattform einzubauen. Da das Schreiben von Code nur der Anfang des Software-Lebenszyklus ist – unsere <a href="https://about.gitlab.com/de-de/developer-survey/">globale DevSecOps-Studie</a> hat ergeben, dass Entwickler(innen) 79 % ihrer Zeit mit anderen Aufgaben als der Code-Erstellung verbringen – haben wir eine Strategie entwickelt, um KI in den gesamten Lebenszyklus der Softwareentwicklung zu integrieren.</p>
<p>Jetzt freuen wir uns, den nächsten Schritt nach vorne zu machen, indem wir wesentliche Funktionen von GitLab Duo in unsere GitLab-Premium- und Ultimate-Tarife aufnehmen, damit Entwickler(innen) die Vorteile von KI <strong>ohne zusätzliche Kosten</strong> in Anspruch nehmen können.</p>
<p>Durch die Aufnahme von GitLab Duo Chat und Duo Codevorschläge in Premium und Ultimate können alle Softwareentwickler(innen) ihre Workflows innerhalb der IDE beschleunigen – ohne dass sie separate Tools, Lizenzen oder Governance benötigen. Alle bestehenden Kund(inn)en mit Premium- und Ultimate-Lizenz haben sofortigen Zugriff auf Duo Chat und Codevorschläge, sobald sie auf GitLab 18.0 upgraden, und diese Erweiterung wird zum Standard für alle Neukund(inn)en.</p>
<blockquote>
<p><strong>„GitLab hat bereits dazu beigetragen, dass wir nicht mehr auf eine fragmentierte Toolchain angewiesen sind, was die Kosten für unzusammenhängende Lösungen gesenkt und unseren Workflow optimiert hat. Die Erweiterung von GitLab Premium mit Duo wird unsere Effizienz und Kosteneinsparungen noch weiter steigern, da unsere Entwickler(innen) weniger Zeit für routinemäßige Programmieraufgaben aufwenden müssen und mehr Zeit für die Bewältigung komplexer Herausforderungen haben, die einen echten geschäftlichen Nutzen bringen.“</strong></p>
<ul>
<li>Andrei Nita, Chief Technology Officer bei McKenzie Intelligence Services</li>
</ul>
</blockquote>
<p>&lt;div style=&quot;padding:56.25% 0 0 0;position:relative;&quot;&gt;&lt;iframe src=&quot;https://player.vimeo.com/video/1083723619?badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479&quot; frameborder=&quot;0&quot; allow=&quot;autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media&quot; style=&quot;position:absolute;top:0;left:0;width:100%;height:100%;&quot; title=&quot;GitLab Premium with Duo Core&quot;&gt;&lt;/iframe&gt;&lt;/div&gt;&lt;script src=&quot;https://player.vimeo.com/api/player.js&quot;&gt;&lt;/script&gt;</p>
<p>&lt;br&gt;&lt;/br&gt;
Kund(inn)en mit Premium- und Ultimate-Lizenz haben jetzt Zugriff auf die folgenden KI-basierten Funktionen:</p>
<h4>GitLab Duo Codevorschläge</h4>
<ul>
<li>Generierung vollständiger Funktionen und Codeblöcke aus Kommentaren</li>
<li>Erhalten intelligenter Code-Vervollständigung während der Eingabe</li>
<li>Unterstützung für mehr als 20 Programmiersprachen</li>
<li>Verfügbar in den meisten gängigen IDEs</li>
</ul>
<p>In dieser interaktiven Tour erfährst du mehr über GitLab Duo Codevorschläge (klicke auf das Bild, um die Tour zu starten).</p>
<p>&lt;a href=&quot;https://gitlab.navattic.com/code-suggestions&quot;&gt;&lt;img src=&quot;//images.ctfassets.net/r9o86ar0p03f/4nclgZ2JUeQ0hR4wjOS30P/ba948ae1a0dce0cff4469ca06490efb1/Screenshot_2024-08-27_at_9.24.32_AM.png&quot; alt=&quot;GitLab Duo Code Suggestions cover image&quot;&gt;&lt;/a&gt;</p>
<p>Weitere Informationen findest du in unserer <a href="https://docs.gitlab.com/user/project/repository/code_suggestions/">Dokumentation zu Duo Codevorschläge (nur in englischer Sprache verfügbar)</a>.</p>
<h4>GitLab Duo Chat</h4>
<ul>
<li>Erklärung von unbekanntem Code, um komplexe Funktionen zu verstehen</li>
<li>Refaktorierung von vorhandenem Code, um Qualität und Wartbarkeit zu verbessern</li>
<li>Generierung umfassender Testfälle, um Bugs früher zu erkennen</li>
<li>Behebung von Codeproblemen direkt in deinem Workflow</li>
</ul>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1749673912/Blog/Content%20Images/Duo_Chat_-_gif_-_API_endpoint_explanation__3_.gif" alt="Duo Chat – Erklärung des API-Endpunkts"></p>
<p>Weitere Informationen findest du in unserer <a href="https://docs.gitlab.com/user/gitlab_duo_chat/">Dokumentation zu Duo Chat (nur in englischer Sprache vefügbar)</a>.</p>
<blockquote>
<p><strong>„Für uns als GitLab-Benutzer(innen) sind die intelligenten Codevorschläge von Duo zu einer täglichen Ressource für unsere Entwickler(innen) geworden. In Kombination mit der Chat-Funktion ermöglicht sie sofortiges Feedback und Iteration, was zu schnelleren Entwicklungszyklen und einer sichereren Codebase führt. Es ist eine nahtlose und leistungsstarke Ergänzung zu unseren Workflows.“</strong></p>
<ul>
<li>Felix Kortmann, Chief Technology Officer, Ignite by FORVIA HELLA</li>
</ul>
</blockquote>
<h2>Duo Enterprise jetzt für Kund(inn)en von GitLab Premium verfügbar</h2>
<p>Auf vielfachen Wunsch unserer Kund(inn)en könnt ihr jetzt auch mit <a href="https://about.gitlab.com/de-de/pricing/premium/">GitLab Premium</a> Duo Enterprise, unsere komplette KI-Suite, erwerben, ohne auf GitLab Ultimate upgraden zu müssen. Premium-Kund(inn)en kommen in den Genuss eines umfassenden KI-Erlebnisses, das nahtlos in den gesamten Lebenszyklus der Softwareentwicklung integriert ist. Dazu gehören spannende GitLab Duo-Funktionen wie:</p>
<ul>
<li><a href="https://docs.gitlab.com/user/gitlab_duo/use_cases/#root-cause-analysis-use-cases">Root Cause Analysis (nur in englischer Sprache verfügbar)</a> hilft bei der schnellen Behebung von CI/CD-Pipeline-Fehlern und sorgt dafür, dass deine CI/CD-Pipelines stabil bleiben.</li>
<li><a href="https://docs.gitlab.com/user/project/merge_requests/duo_in_merge_requests/#have-gitlab-duo-review-your-code">Code Review (nur in englischer Sprache verfügbar)</a> ermöglicht eine schnellere Merge-Request-Review, indem Duo als Code-Prüfer genutzt wird.</li>
<li><a href="https://docs.gitlab.com/user/gitlab_duo_chat/">Erweiterter Chat (nur in englischer Sprache verfügbar)</a> fasst Unterhaltungen zusammen, hilft beim Verständnis von Codeänderungen und bietet erweiterte Konfigurationsunterstützung.</li>
<li><a href="https://docs.gitlab.com/administration/gitlab_duo_self_hosted/">Self-Hosted (nur in englischer Sprache verfügbar)</a> ermöglicht den Einsatz von Duo in Air-Gapped- und Offline-Umgebungen, indem genehmigte KI-Modelle für Duo gehostet werden.</li>
</ul>
<p>Neben der Verfügbarkeit von Duo Enterprise investieren wir weiterhin in den Erfolg unserer GitLab-Premium-Kund(inn)en. Seit der Einführung von GitLab 17 <a href="https://gitlab.com/gitlab-org/gitlab/-/releases">haben wir mehr als hundert Funktionen und Verbesserungen bereitgestellt</a>, darunter:</p>
<ul>
<li>
<p>Der <a href="https://about.gitlab.com/blog/ci-cd-catalog-goes-ga-no-more-building-pipelines-from-scratch/"><strong>CI/CD-Katalog</strong> (nur in englischer Sprache verfügbar)</a> ermöglicht es Entwickler(inne)n, bereits vorhandene CI/CD-Komponenten und -Konfigurationen zu teilen, zu entdecken und wiederzuverwenden.</p>
</li>
<li>
<p>Die <a href="https://docs.gitlab.com/user/packages/virtual_registry/"><strong>Artefaktregistrierung</strong> (nur in englischer Sprache verfügbar)</a> bietet Entwickler(inne)n sicheren Zugriff auf Artefakte und eine nahtlose Integration in CI/CD-Pipelines.</p>
</li>
<li>
<p><a href="https://docs.gitlab.com/user/project/remote_development/"><strong>Remote-Entwicklung</strong> (nur in englischer Sprache verfügbar)</a> ermöglicht es Entwickler(inne)n, in bedarfsgerechten,<br>
Cloud-basierten Entwicklungsumgebungen zu arbeiten.</p>
</li>
</ul>
<blockquote>
<p><a href="https://about.gitlab.com/pricing/premium/#wp-premium-features">Erfahre mehr über die Funktionen von GitLab Premium (nur in englischer Sprache verfügbar).</a></p>
</blockquote>
<h2>GitLab Duo: KI, die Unternehmen dort unterstützt, wo sie arbeiten</h2>
<p>GitLab-Kund(inn)en haben Zugriff auf eine umfassende Auswahl an Duo-Angeboten, die in unseren Pro- und Enterprise-Lösungen enthalten sind. So können sie genau dort eingesetzt werden, wo du dich im KI-Einführungszyklus befindest. Je weiter deine Teams fortgeschritten sind, desto mehr Funktionen kannst du nutzen, um sichere Software schneller zu entwickeln, zu testen und bereitzustellen.</p>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1749673912/Blog/Content%20Images/Screenshot_2025-05-14_at_8.50.34_AM.png" alt="Hauptfunktionen in GitLab-Duo-Tarifen"></p>
<h2>Wie bestehende Kund(inn)en von GitLab Ultimate und Premium in GitLab Duo einsteigen können</h2>
<p>Ab GitLab 18.0 sind die Funktionen Duo Codevorschläge und Duo Chat für bestehende Kund(inn)en von GitLab Ultimate und Premium standardmäßig deaktiviert. Du kannst sie aber ganz einfach aktivieren – wie, erfährst du weiter unten.</p>
<p>So nutzt du GitLab Premium und Ultimate mit Duo:</p>
<ol>
<li>
<p>Stelle sicher, dass du GitLab Premium oder Ultimate hast. Wenn nicht, kannst du es 60 Tage lang kostenlos testen.</p>
</li>
<li>
<p>Aktiviere GitLab Duo in deinen Organisationseinstellungen.</p>
</li>
<li>
<p>Wenn du eine lokale IDE verwendest, installiere die entsprechende <a href="https://docs.gitlab.com/editor_extensions/#available-extensions">Editor-Erweiterung (nur in englischer Sprache verfügbar)</a> für GitLab.</p>
</li>
<li>
<p>Verwende Codevorschläge und Duo Chat in deiner bevorzugten unterstützten lokalen IDE oder der GitLab Web IDE.</p>
</li>
</ol>
<p><strong>Hinweis:</strong> Für Neukund(inn)en und Testversionen werden die KI-Funktionen von GitLab automatisch aktiviert.</p>
<h2>KI-native Entwicklung erfordert eine DevSecOps-Plattform</h2>
<p>KI verändert die Arbeit der Entwickler(innen) grundlegend. In Unternehmen wird es nicht nur mehr Mitarbeitende geben, die Software entwickeln. Es wird auch mehr produktionsreifen Code geben, der von KI generiert wird – <strong>was GitLab wichtiger denn je macht.</strong></p>
<p>Wir haben GitLab Premium und Ultimate mit Duo speziell für diese neue Realität entwickelt, damit Teams eine sichere Grundlage für ihren gesamten Code haben. Wenn KI in deinem Unternehmen Code generiert, wird GitLab zu deinem Kontrollzentrum: keine separaten Tools für Sicherheitsscans, Compliance-Checks oder die Verwaltung von Pipelines. Es reicht eine einzige, einheitliche Plattform, die mit deinem Unternehmen wächst und sicherstellt, dass der gesamte Code deinen Standards entspricht, bevor er in die Produktion gelangt. Während KI deine Entwicklung beschleunigt, kannst du mit GitLab die Kontrolle, Sicherheit und Qualität von Anfang bis Ende gewährleisten.</p>
<blockquote>
<p>Wenn du mehr über GitLab Duo und die Möglichkeiten erfahren möchtest, wie es die Arbeit deines Teams verändern kann, <a href="https://about.gitlab.com/de-de/pricing/premium/">besuche unsere GitLab-Premium-Seite</a>. Wenn du bereits Kund(in) von GitLab bist, wende dich an deine(n) Ansprechpartner(in) bei GitLab, um eine Demo zu planen. Komm am 24. Juni 2025 zu unserem <a href="https://about.gitlab.com/eighteen/">virtuellen Launch-Event für GitLab 18 (nur in englischer Sprache verfügbar)</a>, um mehr über die Zukunft der KI-nativen Softwareentwicklung zu erfahren.</p>
</blockquote>
]]></content>
        <author>
            <name>David DeSanto, Chief Product Officer, GitLab</name>
            <uri>https://about.gitlab.com/blog/authors/david-desanto, chief product officer, gitlab</uri>
        </author>
        <published>2025-05-15T00:00:00.000Z</published>
    </entry>
    <entry>
        <title type="html"><![CDATA[Leitfäden und Ressourcen zu agentischer KI]]></title>
        <id>https://about.gitlab.com/de-de/blog/undefined/</id>
        <link href="https://about.gitlab.com/de-de/blog/undefined/"/>
        <updated>2025-05-07T00:00:00.000Z</updated>
        <content type="html"><![CDATA[<h2>Inhaltsverzeichnis</h2>
<ul>
<li><a href="#definition-von-agentischer-ki">Definition von agentischer KI</a></li>
<li><a href="#einblicke-in-die-agentische-ki">Einblicke in die agentische KI</a></li>
<li><a href="#best-practices-f%C3%BCr-die-implementierung-von-agentischer-ki">Best Practices für die Implementierung von agentischer KI</a></li>
<li><a href="#das-bietet-gitlab-im-bereich-agentische-ki">Das bietet GitLab im Bereich agentische KI</a></li>
<li><a href="#gitlab-duo-mit-amazon-q">GitLab Duo mit Amazon Q</a></li>
<li><a href="#gitlab-duo-workflow">GitLab Duo Workflow</a></li>
<li><a href="#mehr-erfahren-mit-gitlab-university-(nur-in-englischer-sprache-verf%C3%BCgbar)">Mehr erfahren mit GitLab University (nur in englischer Sprache verfügbar)</a></li>
<li><a href="#weitere-ressourcen-zum-bereich-ki">Weitere Ressourcen zum Bereich KI</a></li>
</ul>
<h2>Definition von agentischer KI</h2>
<p>Agentische KI ist eine Form der künstlichen Intelligenz, die fortschrittliche Sprachmodelle und linguistische Datenverarbeitung nutzt, um eigenständig zu handeln. Im Gegensatz zu herkömmlichen generativen KI-Tools, bei denen ständige menschliche Anweisung nötig ist, können diese Systeme Anfragen verstehen, Entscheidungen treffen und mehrstufige Pläne ausführen, um Ziele zu erreichen. Sie bewältigen komplexe Aufgaben, indem sie sie in umsetzbare Schritte unterteilen, und setzen adaptives Lernen ein, um ihren Ansatz zu verändern, wenn sie auf Schwierigkeiten treffen.</p>
<p><a href="https://about.gitlab.com/de-de/topics/agentic-ai/">Erfahre mehr über agentische KI</a></p>
<h2>Einblicke in die agentische KI</h2>
<ul>
<li><a href="https://about.gitlab.com/the-source/ai/emerging-agentic-ai-trends-reshaping-software-development/">Neue Trends in der agentischen KI, die die Softwareentwicklung verändern (nur in englischer Sprache verfügbar)</a>: Erfahre, wie agentische KI die Entwicklung von isolierter Programmierung in intelligente Workflows verwandelt, die die Produktivität steigern und gleichzeitig die Sicherheit gewährleisten.</li>
<li><a href="https://about.gitlab.com/de-de/the-source/ai/agentic-ai-unlocking-developer-potential-at-scale/">Agentische KI: Entwicklungspotenzial im großen Stil</a>: Entdecke, wie agentische KI die Softwareentwicklung verändert und über die Code-Vervollständigung hinausgeht, um KI-Partner zu schaffen, die komplexe Aufgaben proaktiv angehen.</li>
<li><a href="https://about.gitlab.com/de-de/the-source/ai/ai-trends-for-2025-agentic-ai-self-hosted-models-and-more/">Agentische KI, Self-Hosted Models und mehr: KI-Trends im Jahr 2025</a>: Entdecke die wichtigsten KI-Trends im Bereich der Softwareentwicklung – von der lokalen Bereitstellung von Modellen bis hin zu intelligenten, adaptiven KI-Tools.</li>
<li><a href="https://about.gitlab.com/the-source/ai/how-agentic-ai-unlocks-platform-engineering-potential/">Wie agentische KI das Potenzial von Platform Engineering freisetzt (nur in englischer Sprache verfügbar)</a>: Erfahre, wie agentische KI Platform Engineering verbessert, indem sie komplexe Workflows automatisiert und die Standardisierung vorantreibt.</li>
</ul>
<h2>Best Practices für die Implementierung von agentischer KI</h2>
<ul>
<li><a href="https://about.gitlab.com/the-source/ai/implementing-effective-guardrails-for-ai-agents/">Implementierung effektiver Leitlinien für KI-Agenten (nur in englischer Sprache verfügbar)</a>: Entdecke die wichtigsten Sicherheitsleitlinien für KI-Tools in DevSecOps, von Compliance-Kontrollen über den Schutz der Infrastruktur bis hin zur Benutzerzugriffsverwaltung.</li>
</ul>
<h2>Das bietet GitLab im Bereich agentische KI</h2>
<h3>GitLab Duo mit Amazon Q</h3>
<ul>
<li><a href="https://about.gitlab.com/de-de/blog/gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws/">GitLab Duo mit Amazon Q: Die für AWS optimierte agentische KI ist jetzt allgemein verfügbar</a>: Die umfassende KI-basierte DevSecOps-Plattform mit den umfangreichsten Cloud-Computing-Funktionen beschleunigt Entwicklungszyklen, erhöht die Automatisierung und verbessert die Codequalität.</li>
<li><a href="https://about.gitlab.com/blog/devsecops-agentic-ai-now-on-gitlab-self-managed-ultimate-on-aws/">DevSecOps + agentische KI: Jetzt für GitLab Self-Managed Ultimate auf AWS (nur in englischer Sprache verfügbar)</a>: Verwende KI-basierte Agents, die für DevSecOps optimiert sind, in deiner Instanz von AWS GitLab Self-Managed Ultimate. Profitiere von den Vorteilen von GitLab Duo und Amazon Q in deinem Unternehmen.</li>
<li><a href="https://about.gitlab.com/de-de/partners/technology-partners/aws/">GitLab Duo mit Amazon Q – Partnerseite</a></li>
</ul>
<p>Sieh dir GitLab Duo mit Amazon Q in Aktion an:</p>
<p>&lt;div style=&quot;padding:56.25% 0 0 0;position:relative;&quot;&gt;&lt;iframe src=&quot;https://player.vimeo.com/video/1075753390?badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479&quot; frameborder=&quot;0&quot; allow=&quot;autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media&quot; style=&quot;position:absolute;top:0;left:0;width:100%;height:100%;&quot; title=&quot;Technical Demo: GitLab Duo with Amazon Q&quot;&gt;&lt;/iframe&gt;&lt;/div&gt;&lt;script src=&quot;https://player.vimeo.com/api/player.js&quot;&gt;&lt;/script&gt;</p>
<h4>Geführte Tour</h4>
<p>Klicke auf das Bild, um eine englischsprachige Tour durch GitLab Duo mit Amazon Q zu starten:</p>
<p><a href="https://gitlab.navattic.com/duo-with-q"><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1749673568/Blog/Content%20Images/Screenshot_2025-05-07_at_7.24.45_AM.png" alt="GitLab Duo mit Amazon Q – interaktive Tour"></a></p>
<h4>GitLab Duo mit Amazon Q – Tutorial</h4>
<ul>
<li><a href="https://about.gitlab.com/blog/gitlab-duo-amazon-q-transform-ideas-into-code-in-minutes/">GitLab Duo + Amazon Q: Ideen in wenigen Minuten in Code umwandeln (nur in englischer Sprache verfügbar)</a>: Die neue Integration „GitLab Duo mit Amazon Q“ analysiert deine Ticketbeschreibungen und generiert automatisch vollständige, funktionierende Code-Lösungen. So werden deine Entwicklungsworkflows beschleunigt.</li>
</ul>
<h3>GitLab Duo Workflow</h3>
<ul>
<li><a href="https://about.gitlab.com/de-de/gitlab-duo/workflow/">GitLab Duo Workflow</a>: Die Zukunft der sicheren Entwicklung von agentischer KI-Software</li>
<li><a href="https://about.gitlab.com/de-de/blog/gitlab-duo-workflow-enterprise-visibility-and-control-for-agentic-ai/">GitLab Duo Workflow: Transparenz und Kontrolle für agentische KI auf Enterprise-Niveau</a>: Sichere, autonome, kontextbewusste KI-Tools übernehmen komplexe Aufgaben und geben Entwickler(inne)n die Möglichkeit, innovative Software schneller zu entwickeln. Die private Beta-Warteliste ist jetzt geöffnet.</li>
<li><a href="https://about.gitlab.com/de-de/gitlab-duo/workflow/">GitLab Duo Workflow</a></li>
<li><a href="https://docs.gitlab.com/user/duo_workflow/">Dokumentation für GitLab Duo Workflow (nur in englischer Sprache verfügbar)</a></li>
</ul>
<p>Sieh dir GitLab Duo Workflow in Aktion an:</p>
<p>&lt;!-- blank line --&gt;
&lt;figure class=&quot;video_container&quot;&gt;
&lt;iframe src=&quot;https://www.youtube.com/embed/eN2Sd5UNc0g?si=C9HibBJ3QDDHADq2&quot; frameborder=&quot;0&quot; allowfullscreen=&quot;true&quot;&gt; &lt;/iframe&gt;
&lt;/figure&gt;
&lt;!-- blank line --&gt;</p>
<h3>Geführte Tour</h3>
<p>Klicke auf das Bild unten, um die englischsprachige Tour durch GitLab Duo Workflow zu starten:</p>
<p><a href="https://gitlab.navattic.com/duo-workflow"><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1749673569/Blog/Content%20Images/Screenshot_2025-05-07_at_7.29.57_AM.png" alt="GitLab Duo Workflow – geführte Tour"></a></p>
<h4>Tutorials und Anwendungsfälle für GitLab Duo Workflow</h4>
<ul>
<li>
<p><a href="https://about.gitlab.com/blog/refactoring-javascript-to-typescript-with-gitlab-duo-workflow/">Refactoring von JavaScript zu TypeScript mit GitLab Duo Workflow (nur in englischer Sprache verfügbar)</a></p>
</li>
<li>
<p><a href="https://about.gitlab.com/blog/automate-tedious-coding-tasks-with-gitlab-duo-workflow/">Automatisierung mühsamer Programmieraufgaben mit GitLab Duo Workflow (nur in englischer Sprache verfügbar)</a>: Erfahre, wie agentische KI den Zeitaufwand für sich wiederholende Aufgaben reduzieren kann, damit du dich auf die Entwicklung innovativer Lösungen und die Bereitstellung der nächsten großen Innovation konzentrieren kannst.</p>
</li>
<li>
<p><a href="https://about.gitlab.com/de-de/blog/use-gitlab-duo-workflow-to-improve-application-quality-assurance/">Verbesserte Qualitätssicherung von Anwendungen mit GitLab Duo Workflow</a>: Erfahre, wie du mithilfe von agentischer KI Unit-Tests zu einer Java-Anwendung hinzufügst (Video-Tutorial inklusive).</p>
</li>
<li>
<p><a href="https://about.gitlab.com/blog/solving-complex-challenges-with-gitlab-duo-workflow/">Komplexe Herausforderungen mit GitLab Duo Workflow lösen (nur in englischer Sprache verfügbar)</a>: Erfahre, wie ein Mitglied des GitLab-Management-Teams für Kundenerfolge agentische KI für die Lösung realer Probleme einsetzt, einschließlich der Bewältigung von Helm-Chart-Limits in der Paket-Registry.</p>
</li>
</ul>
<h2>Mehr erfahren mit GitLab University (nur in englischer Sprache verfügbar)</h2>
<ul>
<li><a href="https://university.gitlab.com/pages/ai">Kurs „Erste Schritte mit GitLab Duo“</a></li>
<li><a href="https://university.gitlab.com/learning-paths/gitlab-duo-enterprise-learning-path">GitLab Duo Enterprise Learning Path</a></li>
</ul>
<h2>Weitere Ressourcen zum Bereich KI</h2>
<ul>
<li><a href="https://about.gitlab.com/de-de/developer-survey/2024/ai/">Globaler DevSecOps-Bericht 2024: Navigation durch die KI-Entwicklung in DevSecOps</a></li>
<li><a href="https://about.gitlab.com/de-de/topics/devops/the-role-of-ai-in-devops/">Die Rolle der KI bei DevOps</a></li>
<li><a href="https://about.gitlab.com/de-de/blog/categories/ai-ml/">Die neuesten KI-/ML-Artikel von GitLab</a></li>
<li><a href="https://about.gitlab.com/de-de/gitlab-duo/">GitLab Duo</a></li>
</ul>
]]></content>
        <author>
            <name>GitLab</name>
            <uri>https://about.gitlab.com/blog/authors/gitlab</uri>
        </author>
        <published>2025-05-07T00:00:00.000Z</published>
    </entry>
    <entry>
        <title type="html"><![CDATA[So verwendest du die benutzerdefinierten Compliance Frameworks von GitLab in deiner DevSecOps-Umgebung]]></title>
        <id>https://about.gitlab.com/de-de/blog/how-to-use-gitlabs-custom-compliance-frameworks-in-your-devsecops/</id>
        <link href="https://about.gitlab.com/de-de/blog/how-to-use-gitlabs-custom-compliance-frameworks-in-your-devsecops/"/>
        <updated>2025-04-30T00:00:00.000Z</updated>
        <content type="html"><![CDATA[<p>Compliance ist mehr als nur ein Kontrollkästchen, sondern vielmehr eine wichtige Unternehmensfunktion, die sich von betrieblichen Risiken bis hin zum Kundenvertrauen auf jeden Bereich auswirkt. Für Entwicklungsteams kann es sich besonders schwierig gestalten, die Compliance-Anforderungen mit einer angemessenen Geschwindigkeit in Einklang zu bringen. Die <a href="https://about.gitlab.com/blog/introducing-custom-compliance-frameworks-in-gitlab/">benutzerdefinierten Compliance Frameworks (nur in englischer Sprache verfügbar)</a> von GitLab ermöglichen eine einfache und direkte Integration der Compliance-Verifizierung in deinen Entwicklungsworkflow. In diesem Artikel erfährst du, worum es sich dabei im Detail handelt und wie du sie so effizient wie möglich einsetzen kannst.</p>
<h2>Was sind die benutzerdefinierten Compliance Frameworks von GitLab?</h2>
<p>Mit den benutzerdefinierten Compliance Frameworks von GitLab können Unternehmen ihre Compliance-Standards direkt in ihrer GitLab-Instanz definieren, implementieren und durchsetzen. Diese Funktion erweitert die integrierten Compliance-Funktionen von GitLab und ermöglicht den Teams die Erstellung benutzerdefinierter Frameworks, die mit den konkreten gesetzlichen Anforderungen, internen Richtlinien oder Branchenstandards übereinstimmen.</p>
<p>Die benutzerdefinierten Compliance Frameworks bieten folgende Vorteile:</p>
<ul>
<li>Weniger manuelle Nachverfolgung</li>
<li>Schnellere Bereitschaft für Audits</li>
<li>Native Durchsetzung von Compliance-Kontrollen</li>
</ul>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097114254.png" alt="Screenshot des Compliance Centers mit einer Liste der Frameworks"></p>
<p>Im Rahmen dieser Veröffentlichung werden über 50 standardmäßig verfügbare Kontrollen bereitgestellt (weitere folgen in Kürze), die auf die individuellen Compliance-Anforderungen deines Unternehmens zugeschnitten werden können, einschließlich HIPAA im Gesundheitswesen, DSGVO für den Datenschutz, SOC 2 für Dienstleistungsunternehmen oder branchenspezifische Vorschriften. Einige Beispiele für standardmäßig verfügbare Kontrollen sind unter anderem:</p>
<ul>
<li>Aufgabentrennung (z. B. mindestens zwei genehmigende Personen und ein(e) Autor(in) für einen Merge Request)</li>
<li>Ausführung von Sicherheitsscannern (z. B. <a href="https://docs.gitlab.com/user/application_security/sast/">SAST (nur in englischer Sprache verfügbar)</a> und <a href="https://docs.gitlab.com/user/application_security/dependency_scanning/">Abhängigkeitssuche (nur in englischer Sprache verfügbar)</a></li>
<li>Authentifizierung/Genehmigung (z. B. keine öffentliche Projektsichtbarkeit und AuthSSO erforderlich)</li>
<li>Anwendungskonfiguration (z. B. Statusprüfungen und Terraform erforderlich)</li>
</ul>
<p>Darüber hinaus kannst du externe Umgebungskontrollen über die GitLab-API konfigurieren, um den Status und die Details einer externen Umgebung zu überprüfen.</p>
<h2>Entwickeln eines benutzerdefinierten Compliance Frameworks von Grund auf</h2>
<p>Nachdem wir nun den Wert verstanden haben, wollen wir uns im nächsten Schritt ansehen, wie du benutzerdefinierte Compliance Frameworks in deiner GitLab-Umgebung implementieren kannst. Wir verwenden dazu diese Demo-Anwendung. Du kannst den Details in diesem Video folgen.</p>
<p><strong>Hinweis:</strong> Dazu ist ein GitLab-Ultimate-Abonnement erforderlich.</p>
<p>&lt;!-- TODO: EMBED_YT_VIDEO --&gt;</p>
<p>&lt;!-- blank line --&gt;
&lt;figure class=&quot;video_container&quot;&gt;
&lt;iframe src=&quot;https://www.youtube.com/embed/bSwwv5XeMdQ?si=unDwCltF4vTHT4mB&quot; title=&quot;Adhering to compliance requirements with built-in compliance controls
&quot; frameborder=&quot;0&quot; allowfullscreen=&quot;true&quot;&gt; &lt;/iframe&gt;
&lt;/figure&gt;
&lt;!-- blank line --&gt;</p>
<p><strong>Schritt 1: Definiere deine Compliance-Anforderungen</strong></p>
<p>Bevor du dein benutzerdefiniertes Framework erstellst, musst du zunächst deine Compliance-Anforderungen klar definieren:</p>
<ol>
<li><strong>Identifiziere die geltenden Vorschriften:</strong> Bestimme, welche Vorschriften und Standards für dein Unternehmen gelten (z. B. DSGVO, PCI DSS und HIPAA).</li>
<li><strong>Ordne die Anforderungen den Kontrollen zu:</strong> Unterteile jede Vorschrift in konkrete umsetzbare Kontrollen.</li>
<li><strong>Priorisiere die Anforderungen:</strong> Konzentriere dich auf die Bereiche mit hohem Risiko sowie die Anforderungen mit der größten Wirkung.</li>
</ol>
<p><strong>Schritt 2: Entwickle dein benutzerdefiniertes Compliance Framework</strong></p>
<p>So entwickelst du ein benutzerdefiniertes Compliance Framework in GitLab:</p>
<ol>
<li>Navigiere in deiner GitLab-Gruppe zum Abschnitt <strong>Sichern &gt; Compliance Center</strong>.</li>
<li>Klicke auf die Schaltfläche <strong>Neues Framework</strong>.</li>
<li>Wähle <strong>Leeres Framework erstellen</strong> aus.</li>
</ol>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image7_aHR0cHM6_1750097114255.png" alt="Bildschirm zum Erstellen eines benutzerdefinierten Compliance Frameworks"></p>
<ol start="4">
<li>Gib einen Namen, eine Beschreibung und eine Farbe für dein Framework ein.</li>
</ol>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image6_aHR0cHM6_1750097114257.png" alt="Bildschirm „Neues Compliance Framework“"></p>
<ol start="5">
<li>
<p>Füge dem Framework eine Anforderung hinzu:<br>
a. Scrolle nach unten zum Tab <strong>Anforderungen</strong>.</p>
<p>b. Klicke auf die Schaltfläche <strong>Neue Anforderung</strong>.</p>
<p>c. Gib einen Namen und eine Beschreibung ein.
d. Wähle im Abschnitt <strong>Kontrollen</strong> <strong>GitLab-Kontrolle auswählen</strong> aus.<br>
e. Wähle eine Kontrolle aus der Liste aus (z. B. mindestens zwei Genehmigungen, SAST wird ausgeführt).<br>
f. Klicke auf die Schaltfläche <strong>Anforderung erstellen</strong>.</p>
</li>
</ol>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097114258.png" alt="Schaltfläche „Neue Anforderung erstellen“"></p>
<ol start="6">
<li>Klicke auf die Schaltfläche <strong>Framework erstellen</strong>.</li>
</ol>
<p>Das Framework wird wie angegeben erstellt und kann nun zu Projekten hinzugefügt werden. Darüber hinaus können Compliance Frameworks mit einem JSON mit dem entsprechenden Schema <a href="http://TODO">importiert</a> werden.</p>
<p><strong>Schritt 3: Wende das Framework auf Projekte an</strong></p>
<p>Sobald dein Framework erstellt wurde, gehst du wie folgt vor:</p>
<ol>
<li>Wähle im Compliance Center die Registerkarte <strong>Projekte</strong> aus.</li>
<li><strong>Suche</strong> mit dem Suchfeld oder <strong>filtere</strong> die Ergebnisse.</li>
<li>Wähle die Projekte aus, auf die du dein Framework anwenden möchtest.</li>
<li>Klicke auf die Schaltfläche <strong>Eine Massenaktion auswählen</strong>.</li>
<li>Wähle <strong>Frameworks auf ausgewählte Projekte anwenden</strong> aus.</li>
<li>Klicke auf die Schaltfläche <strong>Frameworks auswählen</strong>.</li>
<li>Wähle deine Frameworks aus der Liste aus.</li>
<li>Klicke auf die Schaltfläche <strong>Anwenden</strong>.</li>
</ol>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image5_aHR0cHM6_1750097114260.png" alt="Compliance-Center-Fenster mit Dropdown-Liste für das SOC-2-Framework"></p>
<p>Das Framework wird nun auf das Projekt angewendet, wodurch seine Anforderungen sichtbar und nachvollziehbar werden.</p>
<p><strong>Schritt 4: Überwache die Compliance und erstelle dazu entsprechende Berichte</strong></p>
<p>Sobald dein Framework eingerichtet ist, kannst du Folgendes tun:</p>
<ol>
<li>Im <strong>Compliance Center</strong> kannst du den Compliance-Status über alle Projekte hinweg verfolgen, einschließlich Details und vorgeschlagener Korrekturen für fehlgeschlagene Kontrollen.</li>
<li>Erstelle <strong>Compliance-Berichte</strong> für Audits und Stakeholder-Reviews.</li>
<li>Richte <strong>Compliance-Alarme</strong> ein, um die Stakeholder über mögliche Compliance-Probleme zu informieren.</li>
<li>Überprüfe <strong>Audit Events</strong>, um einen Überblick über die Maßnahmen zu erhalten, die im Zusammenhang mit den Compliance-Einstellungen ergriffen wurden.</li>
</ol>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750097114263.png" alt="Bildschirm des Compliance Centers mit SOC-2-Test-Framework"></p>
<h2>Praxisbeispiel: Implementierung eines SOC 2 Compliance Frameworks</h2>
<p>System and Organization Controls 2, besser bekannt als SOC 2, ist ein strenger Prüfungsstandard, der vom American Institute of Certified Public Accountants entwickelt wurde und die Kontrollen eines Dienstleistungsunternehmens in Bezug auf seine Sicherheit, Verfügbarkeit, Verarbeitungsintegrität, Vertraulichkeit und seinen Datenschutz evaluiert. Weitere Informationen findest du in meinem <a href="https://about.gitlab.com/blog/guide-to-fulfilling-soc-2-security-requirements-with-gitlab/">Leitfaden zur Erfüllung der SOC-2-Sicherheitsanforderungen mit GitLab (nur in englischer Sprache verfügbar)</a>.</p>
<p>Sehen wir uns nun ein praktisches Beispiel für die Verwendung eines benutzerdefinierten Compliance Frameworks zur Überprüfung der SOC-2-Sicherheits-Compliance an, wo folgende Anforderungen gelten:</p>
<ul>
<li>Implementierung von Kontrollen zum Schutz vor unbefugtem Zugriff</li>
<li>Einrichtung von Verfahren zur Identifizierung und Minderung von Risiken</li>
<li>Einrichtung von Systemen zur Erkennung von und zum Umgang mit sicherheitsrelevanten Vorfällen</li>
</ul>
<p><strong>Haftungsausschlussklausel:</strong> Dies ist nur ein Beispiel, in dem einige der möglichen Kontrollen zur Einhaltung von SOC 2 aufgezeigt werden. Konsultiere dein Sicherheits-/Compliance-Team, bevor du eine Implementierung in die Produktion überführst.</p>
<p>Ein benutzerdefiniertes Compliance Framework für SOC 2 sieht bei Verwendung einiger standardmäßiger Kontrollen von GitLab wie folgt aus:</p>
<ul>
<li><strong>Name:</strong> SOC-2-Sicherheitsanforderungen</li>
<li><strong>Beschreibung:</strong> Ergänzt die Sicherheitsanforderungen für die Einhaltung des SOC-2-Frameworks</li>
<li><strong>Anforderungen:</strong>
<ul>
<li><strong>Implementierung von Kontrollen zum Schutz vor unbefugtem Zugriff</strong>
<ul>
<li>Aktivierung von Auth SSO</li>
<li>Aktivierung des CI/CD-Job-Token-Bereichs</li>
<li>MFA auf Organisationsebene erforderlich</li>
</ul>
</li>
<li><strong>Richte Verfahren zur Identifizierung und Minderung von Risiken ein</strong></li>
<li>Mindestens zwei genehmigende Personen</li>
<li>Autor(in) hat den Merge Request genehmigt</li>
<li>Die Committer haben den Merge Request genehmigt</li>
<li>Standard-Branch ist geschützt</li>
<li><strong>Einrichtung von Systemen zur Erkennung von und zum Umgang mit sicherheitsrelevanten Vorfällen</strong>
<ul>
<li>Abhängigkeitssuche wird ausgeführt</li>
<li>SAST wird ausgeführt</li>
<li>DAST wird ausgeführt</li>
</ul>
</li>
</ul>
</li>
</ul>
<p>Wenn du dieses Framework auf dein(e) Projekt(e) anwendest, kannst du überwachen, ob und wann sie nicht mehr die Compliance-Kriterien erfüllen und was getan werden kann, damit die Erfüllung der Compliance-Kriterien wieder gewährleistet ist. Beachte, dass du mehrere Compliance Frameworks für Projekte erstellen und anwenden kannst. Du kannst zum Beispiel eines für die SOC-2-Anforderungen an die Prozessintegrität implementieren.</p>
<h2>Implementiere Sicherheitsrichtlinien, um sicherzustellen, dass die Compliance-Anforderungen erfüllt werden</h2>
<p>Obwohl dies nicht erforderlich ist, können Sicherheitsrichtlinien auf Projekte angewendet werden, die ein benutzerdefiniertes Compliance Framework enthalten. So kannst du sicherstellen, dass bestimmte Compliance-Kriterien über Sicherheitsrichtlinien durchgesetzt werden. Du kannst zum Beispiel erzwingen, dass Sicherheitsscanner für Projekte ausgeführt werden, die ein benutzerdefiniertes Compliance Framework enthalten, das einen solchen Sicherheitsscan erfordert.</p>
<p>GitLab bietet verschiedene Sicherheitsrichtlinien (Dokumentation nur in englischer Sprache verfügbar):</p>
<ul>
<li><a href="https://docs.gitlab.com/user/application_security/policies/scan_execution_policies/">Scan-Ausführungsrichtlinie</a>: Erzwingt Sicherheitsscans, entweder als Teil der Pipeline oder nach einem festgelegten Zeitplan.</li>
<li><a href="https://docs.gitlab.com/user/application_security/policies/merge_request_approval_policies/">Merge-Request-Approvalrichtlinie</a>: Erzwingt Einstellungen auf Projektebene und Approvalregeln auf Basis der Ergebnisse des Scans.</li>
<li><a href="https://docs.gitlab.com/user/application_security/policies/pipeline_execution_policies/">Pipeline-Ausführungsrichtlinie</a>: Erzwingt CI/CD-Jobs als Teil von Projekt-Pipelines.</li>
<li><a href="https://docs.gitlab.com/user/application_security/policies/vulnerability_management_policy/">Richtlinie zum Sicherheitslückenmanagement</a>: Behebt automatisch Sicherheitslücken, die im Standard-Branch nicht mehr erkannt werden.</li>
</ul>
<p>Wir wollen nun die Ausführung eines SAST-Scanners erzwingen, um automatisch alle Anforderungen zu erfüllen, die einen SAST-Scan erfordern. So erstellst du eine Sicherheitsrichtlinie und wendest sie auf ein Projekt mit einem bestimmten Framework an:</p>
<ol>
<li>Navigiere zu einem Projekt mit einem benutzerdefinierten Compliance Framework, das einen <strong>SAST-Scan</strong> erfordert.</li>
<li>Wähle in der Seitenleiste <strong>Sichern &gt; Richtlinien</strong> aus.</li>
<li>Klicke auf die Schaltfläche <strong>Neue Richtlinie</strong>.</li>
<li>Klicke unter <strong>Scan-Ausführungsrichtlinien</strong> auf die Schaltfläche <strong>Richtlinie auswählen</strong>.</li>
<li>Gib den <strong>Namen</strong> und die <strong>Beschreibung</strong> ein.</li>
<li>Wähle unter <strong>Aktionen</strong> <strong>SAST</strong> als auszuführenden Scan aus.</li>
</ol>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image8_aHR0cHM6_1750097114264.png" alt="Aktionsbildschirm"></p>
<ol start="7">
<li>Wähle unter <strong>Bedingungen</strong> die Pipeline aus, die ausgelöst werden soll, wenn eine Pipeline für alle Branches ausgeführt wird.</li>
</ol>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097114265.png" alt="Bildschirm „Bedingungen“"></p>
<ol start="8">
<li>Klicke auf die Schaltfläche <strong>Mit einem Merge Request konfigurieren</strong>.</li>
<li>In einem separaten Projekt wird nun ein MR erstellt, der alle Sicherheitsrichtlinien enthält, die für dieses Projekt gelten.</li>
<li>Klicke auf die Schaltfläche <strong>Zusammenführen</strong>.</li>
</ol>
<p>Jetzt wird SAST für jeden Branch ausgeführt, um sicherzustellen, dass du im jeweiligen Bereich die Compliance-Anforderungen erfüllst. Überprüfe unbedingt die verschiedenen Sicherheitsrichtlinien, um im Detail zu erfahren, wie sie zu deinen Anforderungen passen.</p>
<h2>5 Best Practices, die du beachten solltest</h2>
<p>So maximierst du den Wert benutzerdefinierter Compliance Frameworks:</p>
<ol>
<li><strong>Fang klein an:</strong> Beginne mit einer kritischen Vorschrift oder einem Standard, bevor du sukzessive erweiterst.</li>
<li><strong>Beteilige die wichtigsten Stakeholder:</strong> Beziehe die Compliance-, Sicherheits- und Entwicklungsteams in die Erstellung des Frameworks ein.</li>
<li><strong>Automatisiere, wo möglich:</strong> Verwende GitLab CI/CD, um Compliance-Überprüfungen zu automatisieren.</li>
<li><strong>Sorge für eine gründliche Dokumentation:</strong> Pflege eine klare Dokumentation darüber, wie dein Framework den gesetzlichen Anforderungen entspricht.</li>
<li><strong>Regelmäßige Überprüfungen:</strong> Aktualisiere deine Frameworks, wenn sich die Vorschriften ändern oder neue Anforderungen entstehen.</li>
</ol>
<h2>Leg noch heute los</h2>
<p>Die benutzerdefinierten Compliance Frameworks von GitLab sind ein bedeutender Fortschritt im DevSecOps-Bereich, da mit ihnen die Compliance direkt in den Entwicklungsworkflow integriert wird. Durch die Implementierung benutzerdefinierter Frameworks können Unternehmen ihren Compliance-Aufwand reduzieren, ihr Risikomanagement verbessern und die Entwicklungszyklen beschleunigen, während sie gleichzeitig beständig die gesetzlichen Anforderungen erfüllen.</p>
<p>Durch die Möglichkeit, benutzerdefinierte Compliance Frameworks zu definieren und durchzusetzen, erhalten die Teams die Flexibilität, die sie benötigen, um die Anforderungen ihrer konkreten regulatorischen Landschaft zu erfüllen. Gleichzeitig erhalten sie so die notwendige Struktur, um einheitliche Compliance-Praktiken im gesamten Unternehmen sicherzustellen.</p>
<p>Da die regulatorischen Anforderungen immer komplexer werden, werden Tools wie die benutzerdefinierten Compliance Frameworks von GitLab für Unternehmen, mit denen die umfassenden Compliance-Anforderungen und eine zielführende Entwicklungsgeschwindigkeit auf nachhaltige Weise in Einklang gebracht werden sollen, immer wichtiger.</p>
<blockquote>
<p>Melde dich für deine <a href="https://about.gitlab.com/de-de/free-trial/">kostenlose 60-tägige Testversion von GitLab Ultimate</a> an, um die benutzerdefinierten Compliance Frameworks noch heute auszuprobieren.</p>
</blockquote>
<h2>Mehr erfahren</h2>
<p>In diesen Ressourcen erfährst du mehr über benutzerdefinierte Compliance Frameworks und ihre Vorteile für dein Unternehmen:</p>
<ul>
<li><a href="https://docs.gitlab.com/user/compliance/compliance_center/compliance_status_report/">Dokumentation zu benutzerdefinierten Compliance Frameworks (nur in englischer Sprache verfügbar)</a></li>
<li><a href="https://gitlab.com/groups/gitlab-org/-/epics/13295">Epic zu benutzerdefinierten Compliance Frameworks</a></li>
<li><a href="https://docs.gitlab.com/user/application_security/policies/">Dokumentation der Sicherheitsrichtlinien (nur in englischer Sprache verfügbar)</a></li>
<li><a href="https://about.gitlab.com/de-de/solutions/security-compliance/">Sicherheits- und Compliance-Lösungen von GitLab</a></li>
</ul>
]]></content>
        <author>
            <name>Fernando Diaz</name>
            <uri>https://about.gitlab.com/blog/authors/fernando-diaz</uri>
        </author>
        <published>2025-04-30T00:00:00.000Z</published>
    </entry>
    <entry>
        <title type="html"><![CDATA[GitLab Duo mit Amazon Q: In wenigen Minuten wird aus einer Idee der passende Code]]></title>
        <id>https://about.gitlab.com/de-de/blog/gitlab-duo-amazon-q-transform-ideas-into-code-in-minutes/</id>
        <link href="https://about.gitlab.com/de-de/blog/gitlab-duo-amazon-q-transform-ideas-into-code-in-minutes/"/>
        <updated>2025-04-28T00:00:00.000Z</updated>
        <content type="html"><![CDATA[<p>Hast du schon einmal Tage oder sogar Wochen damit verbracht, aus einem komplexen Problem einen funktionierenden Code zu machen? Wer hat das nicht? Man beginnt mit einer vernünftigen Idee und klaren Anforderungen, aber der Weg vom anfänglichen Konzept hin zu bereitstellbarem Code kann frustrierend lang sein. Deine Produktivität wird durch Implementierungsdetails gebremst und Projekte, die schnell vorankommen sollten, ziehen sich in die Länge.</p>
<p>Hier kommt die <a href="https://about.gitlab.com/de-de/topics/agentic-ai/">agentische KI</a> mit all ihrer Power ins Spiel. <a href="https://about.gitlab.com/de-de/blog/gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws/">GitLab Duo mit Amazon Q</a> kombiniert die umfassende KI-basierte DevSecOps-Plattform mit den umfangreichsten Cloud-Computing-Funktionen, um deinen Anwendungsentwicklungsprozess innerhalb deines vertrauten GitLab-Workflows drastisch zu beschleunigen. Indem sie deinen Weg von der Idee bis zur Bereitstellung optimiert, kann diese leistungsstarke Integration Implementierungslösungen ausschließlich anhand deiner Ticketbeschreibungen vorschlagen – so wird ein Vorgang, der früher Tage dauerte, in wenigen Minuten erledigt.</p>
<h2>So funktioniert’s: vom Ticket zum funktionierenden Code</h2>
<p>Sehen wir uns an, wie die agentische KI-Funktion in der Praxis funktioniert. Stell dir vor, du bist Entwickler(in) und sollst eine Anwendung für einen Hypothekenrechner erstellen. So hilft dir GitLab Duo mit Amazon Q dabei:</p>
<ol>
<li>
<p><strong>Erstelle ein Ticket mit detaillierten Anforderungen:</strong> Erstelle zunächst ein Standard-<a href="https://docs.gitlab.com/user/project/issues/">GitLab-Ticket</a>. In der Beschreibung gibst du eine umfassende Liste der Anforderungen an, die deine Anwendung erfüllen muss. Dies bildet die Grundlage für deine Lösung.</p>
</li>
<li>
<p><strong>Rufe Amazon Q mit einem Schnellzugriff auf:</strong> Sobald dein Ticket erstellt ist, fügst du einfach einen Kommentar mit dem Schnellzugriff „/q dev“ hinzu, um Amazon Q aufzurufen. Jetzt wird es magisch.</p>
</li>
<li>
<p><strong>Lass die KI deine Implementierung generieren:</strong> GitLab Duo mit Amazon Q analysiert deine Ticketbeschreibung und den Kontext deines Quellcodes und generiert dann autonom Code, der alle angegebenen Anforderungen erfüllt. Und das ist noch nicht alles – es überträgt diese Änderungen sogar in einen Merge Request, der dann von dir überprüft werden kann.</p>
</li>
</ol>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097156/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097156018.png" alt="Screenshot des Aktivitäts-Pop-ups von GitLab Duo mit Amazon Q"></p>
<ol start="4">
<li>
<p><strong>Überprüfe die generierte Anwendung</strong>: Gehe nun zum Merge Request, um den generierten Code zu überprüfen. Sieh dir hier an, ob alle deine Anforderungen erfüllt wurden, und nimm bei Bedarf Anpassungen vor.</p>
</li>
<li>
<p><strong>Teste die vorgeschlagene Anwendung</strong>: Überprüfe abschließend, ob die Anwendung erfolgreich ausgeführt wird. Mit minimalem Aufwand hast du jetzt einen funktionierenden Code, der deine festgelegten Anforderungen erfüllt.</p>
</li>
</ol>
<h2>Transformiere deinen Entwicklungsprozess</h2>
<p>GitLab Duo mit Amazon Q transformiert diesen Prozess vollständig, indem es durch intelligente Automatisierung die Zeit, die für komplexe Entwicklungsaufgaben aufgewendet werden muss, signifikant senkt. Durch den Einsatz von agentischer KI kannst du deinen Weg von der Idee bis zur Bereitstellung verkürzen und gibst Entwicklungsteams so die Möglichkeit, sich auf strategischere Aufgaben zu konzentrieren.</p>
<p>Mit GitLab Duo und Amazon Q entwickelst du Software schneller, effizienter und mit geringerem manuellem Programmieraufwand. Diese Integration hilft dir:</p>
<ul>
<li><strong>Wertvolle Entwicklungszeit zu sparen</strong>, indem Implementierungen automatisiert werden und die jeweiligen Anforderungen berücksichtigt werden</li>
<li><strong>Konsistent zu bleiben</strong>, wenn du Code übergreifend über Projekte generierst</li>
<li><strong>Die kognitive Belastung zu reduzieren</strong>, die auftritt, wenn Anforderungen in funktionierenden Code umgewandelt werden sollen</li>
<li><strong>Deine Bereitstellungszyklen zu beschleunigen</strong>, indem Engstellen bei der Implementierung eliminiert werden</li>
<li><strong>Dich auf deine Expertise zu konzentrieren</strong> und Code zu überprüfen und zu optimieren, anstatt dich mit Boilerplate-Code herumschlagen zu müssen.</li>
</ul>
<p>Bist du bereit, GitLab Duo mit Amazon Q in Aktion zu erleben? In unserem Demo-Video erfährst du, wie du deinen Entwicklungsworkflow jetzt transformieren kannst.</p>
<p>&lt;!-- blank line --&gt;
&lt;figure class=&quot;video_container&quot;&gt;
&lt;iframe src=&quot;https://www.youtube.com/embed/jxxzNst3jpo?si=j_LQdZhUnwqoQEst&quot; title=&quot;GitLab Duo with Amazon Q demo video for dev workflow&quot; frameborder=&quot;0&quot; allowfullscreen=&quot;true&quot;&gt; &lt;/iframe&gt;
&lt;/figure&gt;
&lt;!-- blank line --&gt;</p>
<blockquote>
<p>Besuche uns auf einem der bevorstehenden <a href="https://about.gitlab.com/de-de/events/aws-summits/">AWS Summits in einer Stadt in deiner Nähe</a> oder <a href="https://about.gitlab.com/de-de/partners/technology-partners/aws/#form">wende dich an deine(n) GitLab-Vertreter(in)</a>, um mehr über GitLab Duo mit Amazon Q zu erfahren.</p>
</blockquote>
<h2>Ressourcen zu GitLab Duo mit Amazon Q</h2>
<ul>
<li><a href="https://about.gitlab.com/de-de/blog/gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws/">GitLab Duo mit Amazon Q: Die für AWS optimierte agentische KI ist jetzt allgemein verfügbar</a></li>
<li><a href="https://about.gitlab.com/de-de/partners/technology-partners/aws/">GitLab und AWS – Partnerseite</a></li>
<li><a href="https://docs.gitlab.com/user/duo_amazon_q/">Dokumentation zu GitLab Duo mit Amazon Q (nur in englischer Sprache verfügbar)</a></li>
</ul>
]]></content>
        <author>
            <name>Cesar Saavedra</name>
            <uri>https://about.gitlab.com/blog/authors/cesar-saavedra</uri>
        </author>
        <published>2025-04-28T00:00:00.000Z</published>
    </entry>
    <entry>
        <title type="html"><![CDATA[Erste Schritte mit GitLab: Grundlegendes zu CI/CD]]></title>
        <id>https://about.gitlab.com/de-de/blog/getting-started-with-gitlab-understanding-ci-cd/</id>
        <link href="https://about.gitlab.com/de-de/blog/getting-started-with-gitlab-understanding-ci-cd/"/>
        <updated>2025-04-25T00:00:00.000Z</updated>
        <content type="html"><![CDATA[<p>Stell dir einen Workflow vor, bei dem jede Codeänderung automatisch erstellt, getestet und für deine Benutzer(innen) bereitgestellt wird. Genau das macht <a href="https://about.gitlab.com/de-de/topics/ci-cd/">CI/CD (Kontinuierliche Integration/Kontinuierliche Lieferung)</a>! Mit CI/CD kannst du Fehler frühzeitig erkennen, die Qualität des Codes sicherstellen und Software schneller und häufiger bereitstellen.</p>
<h2>Inhaltsverzeichnis</h2>
<ul>
<li><a href="#was-ist-cicd%3F">Was ist CI/CD?</a></li>
<li><a href="#vorteile-von-gitlab-cicd">Vorteile von GitLab CI/CD</a></li>
<li><a href="#die-elemente-von-gitlab-cicd">Die Elemente von GitLab CI/CD</a></li>
<li><a href="#gitlab-ci-einrichten">GitLab CI einrichten</a></li>
<li><a href="#beispiele-f%C3%BCr-die-cicd-konfiguration">Beispiele für die CI/CD-Konfiguration</a></li>
<li><a href="#gitlab-auto-devops">GitLab Auto-DevOps</a></li>
<li><a href="#cicd-katalog">CI/CD-Katalog</a></li>
<li><a href="#ci-vorlagen">CI-Vorlagen</a></li>
<li><a href="#entwicklung-der-n%C3%A4chsten-generation">Entwicklung der nächsten Generation</a></li>
<li><a href="#reihe-%E2%80%9Eerste-schritte-mit-gitlab%E2%80%9C">Reihe „Erste Schritte mit GitLab&quot;</a></li>
</ul>
<h3>Was ist CI/CD?</h3>
<ul>
<li><strong>Kontinuierliche Integration</strong> ist eine Entwicklungsmethode, bei der Entwickler(innen) häufig, nach Möglichkeit mehrmals am Tag, Codeänderungen in ein gemeinsames Repository integrieren. Jede Integration wird dann durch einen automatisierten Build- und Testprozess überprüft, so dass die Teams Probleme frühzeitig erkennen können.</li>
<li><strong>Kontinuierliche Lieferung</strong> erweitert CI, indem sie die Bereitstellungspipeline automatisiert und dafür sorgt, dass dein Code <em>immer</em> in einem einsatzfähigen Zustand ist. Du kannst deine Anwendung mit einem einzigen Klick oder automatisch in verschiedenen Umgebungen (z. B. Staging, Produktion) bereitstellen.</li>
<li><strong>Kontinuierliche Bereitstellung</strong> geht noch einen Schritt weiter, indem sie <em>jeden erfolgreichen Build</em> automatisch für die Produktion bereitstellt. Dies erfordert ein hohes Maß an Vertrauen in deine automatisierten Tests und deinen Bereitstellungsprozess.</li>
</ul>
<h3>Vorteile von GitLab CI/CD</h3>
<p>GitLab CI/CD ist ein leistungsstarkes, eingegliedertes System, das in GitLab integriert ist. Es bietet ein nahtloses Erlebnis für die Automatisierung deines gesamten Software-Entwicklungsprozesses. Mit GitLab CI/CD kannst du:</p>
<ul>
<li><strong>Alles automatisieren:</strong> Erstelle, teste und stelle deine Anwendungen mit Leichtigkeit bereit.</li>
<li><strong>Bugs frühzeitig erkennen:</strong> Erkenne und behebe Fehler, bevor sie die Produktion erreichen.</li>
<li><strong>Schnelleres Feedback erhalten:</strong> Du erhältst sofortige Rückmeldung zu deinen Code-Änderungen.</li>
<li><strong>Die Zusammenarbeit verbessern:</strong> Arbeite mit automatisierten Workflows effektiver im Team zusammen.</li>
<li><strong>Die Bereitstellung beschleunigen:</strong> Veröffentliche Software schneller und häufiger.</li>
<li><strong>Risiken reduzieren:</strong> Minimiere Fehler bei der Bereitstellung und vermeide Rollbacks.</li>
</ul>
<h3>Die Elemente von GitLab CI/CD</h3>
<ul>
<li><code>.gitlab-ci.yml</code><strong>:</strong> Diese <a href="https://docs.gitlab.com/ee/ci/yaml/">YAML-Datei (nur in englischer Sprache verfügbar)</a>, die sich im Stammverzeichnis deines Projekts befindet, definiert deine CI/CD-Pipeline, einschließlich Phasen, Jobs und Runner.</li>
<li><a href="https://docs.gitlab.com/runner/"><strong>GitLab Runner</strong> (nur in englischer Sprache verfügbar)</a><strong>:</strong> Dieser Agent führt deine CI/CD-Jobs auf deiner Infrastruktur aus (z. B. auf physischen Computern, virtuellen Maschinen, Docker-Containern oder Kubernetes-Clustern).</li>
<li><a href="https://docs.gitlab.com/ee/ci/yaml/#stages"><strong>Phasen</strong> (nur in englischer Sprache verfügbar)</a><strong>:</strong> Phasen definieren die Reihenfolge der Ausführung deiner Jobs (z. B. Erstellen, Testen und Bereitstellen).</li>
<li><a href="https://docs.gitlab.com/ee/ci/yaml/#job-keywords"><strong>Jobs</strong> (nur in englischer Sprache verfügbar)</a><strong>:</strong> Jobs sind einzelne Arbeitseinheiten innerhalb einer Phase (z. B. Code kompilieren, Tests ausführen und für das Staging bereitstellen).</li>
</ul>
<h3>GitLab CI einrichten</h3>
<p>Die ersten Schritte mit GitLab CI sind einfach. Hier ist ein einfaches Beispiel für eine <code>.gitlab-ci.yml</code>-Datei:</p>
<pre><code class="language-yaml">
stages:
  - build
  - test
  - deploy

build_job:
  stage: build
  script:
    - echo &quot;Building the application...&quot;

test_job:
  stage: test
  script:
    - echo &quot;Running tests...&quot;

deploy_job:
  stage: deploy
  script:
    - echo &quot;Deploying to production...&quot;
  environment:
    name: production

</code></pre>
<p>Diese Konfiguration definiert drei Phasen: „build“, „test“ und „deploy“. Jede Phase enthält einen Job, der ein einfaches Skript ausführt.</p>
<h3>Beispiele für die CI/CD-Konfiguration</h3>
<p>Sehen wir uns einige realistischere Beispiele an.</p>
<p><strong>Erstellen und Bereitstellen einer Node.js-Anwendung</strong></p>
<p>Die folgende Pipelinedefinition beschreibt die Verwendung von npm, um eine Node.js-Anwendung zu erstellen und zu testen, und <a href="https://docs.gitlab.com/ci/examples/deployment/">dpl (nur in englischer Sprache verfügbar)</a>, um die Anwendung in Heroku bereitzustellen. In der Bereitstellungsphase der Pipeline werden die <a href="https://docs.gitlab.com/ci/variables/">GitLab-CI/CD-Variablen (nur in englischer Sprache verfügbar)</a> verwendet, mit denen Entwickler(innen) vertrauliche Informationen (z. B. Zugangsdaten) speichern und sicher in CI/CD-Prozessen verwenden können. In diesem Beispiel wird ein API-Schlüssel für die Bereitstellung in Heroku unter dem variablen Schlüsselnamen '$HEROKU_API_KEY` gespeichert, den das dpl-Tool verwendet.</p>
<pre><code class="language-yaml">
stages:
  - build
  - test
  - deploy

build:
  stage: build
  image: node:latest
  script:
    - npm install
    - npm run build

test:
  stage: test
  image: node:latest
  script:
    - npm run test

deploy:
  stage: deploy
  image: ruby:latest
  script:
    - gem install dpl
    - dpl --provider=heroku --app=$HEROKU_APP_NAME --api-key=$HEROKU_API_KEY

</code></pre>
<p><strong>Bereitstellung in verschiedenen Umgebungen (Staging und Produktivumgebung)</strong></p>
<p>GitLab bietet auch <a href="https://docs.gitlab.com/ci/environments/">Umgebungen (nur in englischer Sprache verfügbar)</a> mit CI/CD. Mit dieser Funktion können Benutzer(innen) die Bereitstellung von CI/CD auf Infrastrukturziele verfolgen. Im folgenden Beispiel fügt die Pipeline Phasen mit einer Umgebungseigenschaft für eine Staging- und eine Produktivumgebung hinzu. Während die Phase „deploy_staging“ ihr Skript immer ausführt, erfordert die Phase „deploy_production“ eine manuelle Genehmigung, um eine versehentliche Bereitstellung in der Produktionsumgebung zu verhindern.</p>
<pre><code class="language-yaml">
stages:
  - build
  - test
  - deploy_staging
  - deploy_production

build:
  # ...

test:
  # ...

deploy_staging:
  stage: deploy_staging
  script:
    - echo &quot;Deploying to staging...&quot;
  environment:
    name: staging

deploy_production:
  stage: deploy_production
  script:
    - echo &quot;Deploying to production...&quot;
  environment:
    name: production
  when: manual  # Requires manual approval

</code></pre>
<h3>GitLab Auto-DevOps</h3>
<p><a href="https://docs.gitlab.com/ee/topics/autodevops/">GitLab Auto-DevOps (nur in englischer Sprache verfügbar)</a> vereinfacht CI/CD, indem es eine vordefinierte Konfiguration bereitstellt, mit der deine Anwendungen automatisch erstellt, getestet und bereitgestellt werden. Es nutzt bewährte Methoden und Branchenstandards, um deinen Workflow zu optimieren.</p>
<p>So aktivierst du Auto-DevOps:</p>
<ol>
<li>Gehe in deinem Projekt zu <strong>Einstellungen &gt; CI/CD &gt; Allgemeine Pipelines</strong>.</li>
<li>Aktiviere die Option <strong>Auto-DevOps</strong>.</li>
</ol>
<p>Auto-DevOps erkennt automatisch die Sprache und das Framework deines Projekts und konfiguriert die erforderlichen Build-, Test- und Bereitstellungsphasen. Du musst nicht einmal eine <code>.gitlab-ci.yml</code>-Datei erstellen.</p>
<h3>CI/CD-Katalog</h3>
<p>Der <a href="https://about.gitlab.com/blog/faq-gitlab-ci-cd-catalog/">CI/CD-Katalog (nur in englischer Sprache verfügbar)</a> ist eine Liste von Projekten mit veröffentlichten <a href="https://docs.gitlab.com/ee/ci/components/">CI/CD-Komponenten (nur in englischer Sprache verfügbar)</a>, die du zur Erweiterung deines CI/CD-Workflows nutzen kannst. Jeder kann ein Komponentenprojekt erstellen und es zum CI/CD-Katalog hinzufügen oder zu einem bestehenden Projekt beitragen, um die verfügbaren Komponenten zu verbessern. Die veröffentlichten Komponenten findest du im <a href="https://gitlab.com/explore/catalog">CI/CD-Katalog</a> auf GitLab.com.</p>
<blockquote>
<p><a href="https://about.gitlab.com/blog/tutorial-how-to-set-up-your-first-gitlab-ci-cd-component/">Tutorial: So richtest du deine erste GitLab-CI/CD-Komponente ein (nur in englischer Sprache verfügbar)</a></p>
</blockquote>
<h3>CI-Vorlagen</h3>
<p>Du kannst auch deine eigenen <a href="https://docs.gitlab.com/ee/ci/examples/">CI-Vorlagen (nur in englischer Sprache verfügbar)</a> erstellen, um CI/CD-Konfigurationen zu standardisieren und über mehrere Projekte hinweg wiederzuverwenden. Das fördert die Konsistenz und reduziert doppelte Arbeit.</p>
<p>So erstellst du eine CI-Vorlage:</p>
<ol>
<li>Erstelle eine <code>.gitlab-ci.yml</code>-Datei in einem eigenen Projekt oder Repository.</li>
<li>Definiere deine CI/CD-Konfiguration in der Vorlage.</li>
<li>Verwende in der <code>.gitlab-ci.yml</code>-Datei deines Projekts das Schlüsselwort <code>include</code>, um die Vorlage einzuschließen.</li>
</ol>
<h2>Entwicklung der nächsten Generation</h2>
<p>GitLab CI/CD ist ein leistungsstarkes Tool, das deinen Workflow bei der Entwicklung verbessern kann. Wenn du die Konzepte von CI/CD verstehst, deine Pipelines konfigurierst und Funktionen wie Auto-DevOps, den CI/CD-Katalog und CI-Vorlagen nutzt, kannst du deinen gesamten Software-Entwicklungsprozess automatisieren und schneller und effizienter hochwertige Software liefern.</p>
<blockquote>
<p>Willst du dein Wissen vertiefen? Registriere dich für die <a href="https://university.gitlab.com/">englischsprachigen Kurse der GitLab University</a>. Du kannst auch sofort mit der <a href="https://about.gitlab.com/de-de/free-trial/?hosted=saas">kostenlosen 60-tägigen Testversion von GitLab Ultimate</a> loslegen.</p>
</blockquote>
<h2>Reihe „Erste Schritte mit GitLab“</h2>
<p>Weitere Artikel in unserer Serie „Erste Schritte mit GitLab“:</p>
<ul>
<li><a href="https://about.gitlab.com/de-de/blog/getting-started-with-gitlab-how-to-manage-users/">Benutzerverwaltung</a></li>
<li><a href="https://about.gitlab.com/blog/getting-started-with-gitlab-how-to-import-your-projects-to-gitlab/">Projekte in GitLab importieren (nur in englischer Sprache verfügbar)</a></li>
<li><a href="https://about.gitlab.com/de-de/blog/getting-started-with-gitlab-mastering-project-management/">Projektmanagement</a></li>
<li><a href="https://about.gitlab.com/de-de/blog/automating-agile-workflows-with-the-gitlab-triage-gem/">Automatisiere Agile-Workflows mit dem gem gitlab-triage</a></li>
</ul>
]]></content>
        <author>
            <name>GitLab</name>
            <uri>https://about.gitlab.com/blog/authors/gitlab</uri>
        </author>
        <published>2025-04-25T00:00:00.000Z</published>
    </entry>
    <entry>
        <title type="html"><![CDATA[Die Breaking Changes in GitLab 18.0]]></title>
        <id>https://about.gitlab.com/de-de/blog/a-guide-to-the-breaking-changes-in-gitlab-18-0/</id>
        <link href="https://about.gitlab.com/de-de/blog/a-guide-to-the-breaking-changes-in-gitlab-18-0/"/>
        <updated>2025-04-18T00:00:00.000Z</updated>
        <content type="html"><![CDATA[<p>GitLab 18.0, unser nächstes Major Release, wird vollgepackt sein mit neuen Funktionen, die die Grenzen der DevSecOps-Innovation sprengen. Gleichzeitig werden wir einige veraltete Funktionen aus GitLab entfernen. Hier erfährst du, was du über diese Änderungen wissen musst und wie du ihre Auswirkungen minimieren kannst.</p>
<h2>Inhaltsverzeichnis</h2>
<ul>
<li><a href="#bereitstellungsfenster">Bereitstellungsfenster</a></li>
<li><a href="#gitlabcom">GitLab.com</a></li>
<li><a href="#gitlab-self-managed">GitLab Self-Managed</a></li>
<li><a href="#gitlab-dedicated">GitLab Dedicated</a></li>
<li><a href="#breaking-changes">Breaking Changes</a></li>
<li><a href="#hohe-auswirkungen">Hohe Auswirkungen</a></li>
<li><a href="#mittlere-auswirkungen">Mittlere Auswirkungen</a></li>
<li><a href="#geringe-auswirkungen">Geringe Auswirkungen</a></li>
<li><a href="#tools-und-ressourcen-um-deine-auswirkungen-zu-verwalten">Tools und Ressourcen, um deine Auswirkungen zu verwalten</a></li>
</ul>
<h2>Bereitstellungsfenster</h2>
<h3>GitLab.com</h3>
<p>Breaking Changes für GitLab.com waren auf diese drei Zeitfenster beschränkt:</p>
<ul>
<li>21.–23. April 2025</li>
<li>28.–30. April 2025</li>
<li>5.–7. Mai 2025</li>
</ul>
<p>Viele weitere Änderungen werden im Laufe des Monats eingeführt. In dieser <a href="https://docs.gitlab.com/update/breaking_windows/">englischsprachigen Dokumentation zu den grundlegenden Änderungen</a> erfährst du mehr über die wichtigsten Änderungen in jedem dieser Zeitfenster.</p>
<p><em><strong>Hinweis:</strong> In Ausnahmefällen können Breaking Changes geringfügig außerhalb dieser Zeitfenster liegen.</em></p>
<h3>GitLab Self-Managed</h3>
<p>GitLab 18.0 ist ab dem 15. Mai verfügbar. Mehr über den Release-Zeitplan erfährst du <a href="https://about.gitlab.com/releases/">hier (nur in englischer Sprache verfügbar)</a>.</p>
<h3>GitLab Dedicated</h3>
<p>Das Upgrade auf GitLab 18.0 findet während deines Wartungsfensters vom 24.–29. Juni 2025 statt. Mehr dazu erfährst du <a href="https://docs.gitlab.com/administration/dedicated/maintenance/#release-rollout-schedule">hier (nur in englischer Sprache verfügbar)</a>. Dort findest du auch dein zugewiesenes Wartungsfenster.</p>
<p>Wir haben außerdem spezielle Tools und Ressourcen entwickelt, die dir dabei helfen, die Auswirkungen der Änderungen auf deine Umgebung abzuschätzen und alle notwendigen Maßnahmen vor dem Upgrade auf 18.0 zu planen. <a href="#tools-and-resources-to-manage-your-impact">Informationen zu diesen Tools und Ressourcen zur Risikominderung</a> findest du weiter unten in diesem Artikel.</p>
<p>Auf der <a href="https://docs.gitlab.com/ee/update/deprecations?removal_milestone=18.0">Seite zu veralteten Funktionen (nur in englischer Sprache verfügbar)</a>, findest du eine vollständige Liste der Komponenten, die in 18.0 entfernt werden sollen. Im Folgenden erfährst du, was auf dich zukommt und wie du dich auf die diesjährige Version vorbereiten kannst, je nachdem, welche Bereitstellung du verwendest.</p>
<h2>Breaking Changes</h2>
<h3>Hohe Auswirkungen</h3>
<p><strong>1. CI/CD-Job-Token – Entfernung der Einstellung „Zugriff von deinem Projekt beschränken“</strong></p>
<p>GitLab.com | Self-Managed | Dedicated</p>
<p>In GitLab 14.4 haben wir eine Einstellung eingeführt, um <strong><a href="https://docs.gitlab.com/ci/jobs/ci_job_token/#limit-your-projects-job-token-access">den Zugriff <em>von</em> den CI/CD-Job-Token (CI_JOB_TOKEN) deines Projekts zu beschränken (nur in englischer Sprache verfügbar)</a></strong> und so die Sicherheit zu erhöhen. Diese Einstellung wurde <strong>CI_JOB_TOKEN-Zugriff beschränken</strong> genannt. In GitLab 16.3 haben wir diese Einstellung aus Gründen der Übersichtlichkeit in <strong>Zugriff <em>von</em> diesem Projekt beschränken</strong> umbenannt.</p>
<p>In GitLab 15.9 haben wir die alternative Einstellung <strong><a href="https://docs.gitlab.com/ci/jobs/ci_job_token/#add-a-group-or-project-to-the-job-token-allowlist">Autorisierte Gruppen und Projekte (nur in englischer Sprache verfügbar)</a></strong> eingeführt. Diese Einstellung steuert den Zugriff von Job-Token auf dein Projekt mithilfe einer Zulassungsliste. Diese neue Einstellung ist eine deutliche Verbesserung gegenüber der ursprünglichen Einstellung. Die erste Iteration wurde in GitLab 16.0 als veraltet markiert und soll in GitLab 18.0 entfernt werden.</p>
<p>Die Einstellung <strong>Zugriff <em>von</em> diesem Projekt beschränken</strong> ist für alle neuen Projekte standardmäßig deaktiviert. Ab GitLab 16.0 kannst du diese Einstellung nicht wieder aktivieren, nachdem sie in einem Projekt deaktiviert wurde. Verwende stattdessen die Einstellung <strong>Autorisierte Gruppen und Projekte</strong>, um den Zugriff von Job-Token auf deine Projekte zu steuern.</p>
<ul>
<li><a href="https://docs.gitlab.com/update/deprecations/#cicd-job-token---limit-access-from-your-project-setting-removal">Hinweis zur Deaktivierung (nur in englischer Sprache verfügbar)</a></li>
<li><a href="https://gitlab.com/gitlab-com/support/toolbox/gitlab-detective/-/blob/main/README.md">Überprüfung über GitLab Detective verfügbar</a></li>
</ul>
<p><strong>2. CI/CD-Job-Token – Durchsetzung der Zulassungsliste für autorisierte Gruppen und Projekte</strong></p>
<p>GitLab.com | Self-Managed | Dedicated</p>
<p>Mit der <strong><a href="https://docs.gitlab.com/ee/ci/jobs/ci_job_token.html#add-a-group-or-project-to-the-job-token-allowlist">Einstellung für autorisierte Gruppen und Projekte (nur in englischer Sprache verfügbar)</a></strong> (in GitLab 15.9 eingeführt und in GitLab 16.3 in <strong>Zugriff auf dieses Projekt beschränken</strong> umbenannt) kannst du den Zugriff von CI/CD-Job-Token auf dein Projekt verwalten. Wenn du <strong>Nur dieses Projekt und alle Gruppen und Projekte in der Zulassungsliste</strong> auswählst, können nur Gruppen oder Projekte, die der Zulassungsliste hinzugefügt wurden, Job-Token verwenden, um auf dein Projekt zuzugreifen.</p>
<ul>
<li><strong>Vor GitLab 15.9</strong> war die Zulassungsliste standardmäßig deaktiviert (Einstellung <a href="https://docs.gitlab.com/ee/ci/jobs/ci_job_token.html#allow-any-project-to-access-your-project"><strong>Alle Gruppen und Projekte</strong> (nur in englischer Sprache verfügbar)</a>), sodass der Zugriff von Job-Token aus jedem Projekt möglich war.</li>
<li><strong>Seit GitLab 17.6</strong> haben Administrator(inn)en von GitLab-Self-Managed- und Dedicated-Instanzen die Möglichkeit, <a href="https://docs.gitlab.com/ee/administration/settings/continuous_integration.html#job-token-permissions"><strong>eine sicherere Einstellung für alle Projekte zu erzwingen</strong> (nur in englischer Sprache verfügbar)</a>, die verhindert, dass Projektbetreuer(innen) <strong>Alle Gruppen und Projekte</strong> auswählen. Diese Änderung sorgt für ein höheres Maß an Sicherheit zwischen Projekten.</li>
<li>In GitLab 18.0 ist diese Einstellung standardmäßig aktiviert. Auf GitLab.com werden wir die Zulassungslisten deiner Projekte automatisch auf der Grundlage deiner Projekt-Authentifizierungsprotokolle auffüllen.</li>
<li>Um sich auf diese Änderung auf <strong>GitLab.com</strong> vorzubereiten, sollten Projektbetreuer(innen), die das Job-Token für die projektübergreifende Authentifizierung verwenden, die Zulassungslisten für <strong>Autorisierte Gruppen und Projekte</strong> ihres Projekts belegen. Sie sollten dann die Einstellung auf <strong>Nur</strong> <strong>dieses Projekt und Gruppen und Projekte in der Zulassungsliste</strong> ändern. Wir empfehlen die Verwendung der verfügbaren <a href="https://docs.gitlab.com/ci/jobs/ci_job_token/#auto-populate-a-projects-allowlist">Migrationswerkzeuge (nur in englischer Sprache verfügbar)</a>, um die Erstellung der Zulassungsliste basierend auf den <a href="https://docs.gitlab.com/ci/jobs/ci_job_token/#job-token-authentication-log">Authentifizierungsprotokollen (nur in englischer Sprache verfügbar)</a> des Projekts vor GitLab 18.0 zu <em><strong>automatisieren</strong></em>.</li>
<li><strong>Benutzer(innen) von Self-Managed</strong> sollten die Zulassungslisten vor dem Upgrade auf 18.0 belegen.</li>
<li><strong>Dedicated-Benutzer(innen)</strong> sollten mit ihrem GitLab-Kontoteam zusammenarbeiten, um die geeignete Strategie für ihre spezifische Instanz zu entwickeln.</li>
</ul>
<ul>
<li><a href="https://docs.gitlab.com/update/deprecations/#cicd-job-token---authorized-groups-and-projects-allowlist-enforcement">Hinweis zur Deaktivierung (nur in englischer Sprache verfügbar)</a></li>
<li><a href="https://docs.gitlab.com/ci/jobs/ci_job_token/#add-a-gr">Dokumentation (nur in englischer Sprache verfügbar)</a></li>
<li><a href="https://gitlab.com/gitlab-com/support/toolbox/gitlab-detective/-/blob/main/README.md">Überprüfung über GitLab Detective verfügbar</a></li>
</ul>
<p><strong>3. Durchsetzung des Geltungsbereichs von Abhängigkeits-Proxy-Token</strong></p>
<p>GitLab.com | Self-Managed | Dedicated</p>
<p>Der Abhängigkeits-Proxy für Container akzeptiert die Anfragen <strong><code>docker login</code></strong> und <strong><code>docker pull</code></strong> mit <strong>persönlichen, Projekt-</strong> oder **Gruppen-**Zugriffstoken, ohne deren Geltungsbereich zu validieren.</p>
<p>In GitLab 18.0 benötigt der Abhängigkeits-Proxy sowohl den Geltungsbereich <strong><code>read_registry</code></strong> als auch den Geltungsbereich <strong><code>write_registry</code></strong> für die Authentifizierung. Nach dieser Änderung werden Authentifizierungsversuche mit Token ohne diese Bereiche <strong>abgelehnt</strong>.</p>
<p>Erstelle vor dem Upgrade neue Zugriffstoken mit den <a href="https://docs.gitlab.com/ee/user/packages/dependency_proxy/#authenticate-with-the-dependency-proxy-for-container-images"><strong>erforderlichen Geltungsbereichen</strong> (nur in englischer Sprache verfügbar)</a> und aktualisiere deine Workflow-Variablen und -Skripte mit diesen neuen Token.</p>
<p>Du hast auch die Möglichkeit, den <a href="https://gitlab.com/gitlab-com/cs-tools/gitlab-cs-tools/dependancy-token-checker/"><strong>Dependency Token Checker</strong></a> zu verwenden, ein von der Community entwickeltes Skript, mit dem du Token anzeigen und automatisch rotieren kannst.</p>
<ul>
<li><a href="https://docs.gitlab.com/update/deprecations/#dependency-proxy-token-scope-enforcement">Hinweis zur Deaktivierung (nur in englischer Sprache verfügbar)</a></li>
</ul>
<h3>Mittlere Auswirkungen</h3>
<p><strong>1. Neue Fristen für die Datenaufbewahrung bei Sicherheitslücken auf GitLab.com</strong></p>
<p>GitLab.com – <strong>nur für Kund(inn)en mit Ultimate-Tarif</strong></p>
<p>Ab GitLab 18.1 werden wir mit einem schrittweisen, sechsmonatigen Rollout eine <strong>neue Frist für die Datenaufbewahrung</strong> für GitLab.com <strong>Ultimate</strong>-Kund(inn)en einführen, um die Systemleistung und -zuverlässigkeit zu verbessern. Die Datenaufbewahrungsfrist bestimmt, wie lange die Daten zu deinen Sicherheitslücken gespeichert werden.</p>
<p>Sicherheitslücken, die älter als 12 Monate sind und nicht aktualisiert wurden, werden automatisch in Cold-Storage-Archive verschoben. Diese Archive:</p>
<ul>
<li>bleiben über die GitLab-Benutzeroberfläche zugänglich und können heruntergeladen werden</li>
<li>werden 3 Jahre lang aufbewahrt</li>
<li>werden nach 3 Jahren endgültig gelöscht</li>
</ul>
<ul>
<li><a href="https://docs.gitlab.com/update/deprecations/#new-data-retention-limits-for-vulnerabilities-on-gitlabcom">Hinweis zur Deaktivierung (nur in englischer Sprache verfügbar)</a></li>
<li><a href="https://handbook.gitlab.com/handbook/security/records-retention-deletion/">Dokumentation (nur in englischer Sprache verfügbar)</a></li>
</ul>
<p><strong>2. Ablehnen von Pull-Richtlinien für Container-Images, die nicht in <code>allowed_pull_policies</code> enthalten sind</strong></p>
<p>GitLab.com | Self-Managed | Dedicated</p>
<p>Alle konfigurierten Pull-Richtlinien sollten in der <a href="https://docs.gitlab.com/runner/executors/docker/#allow-docker-pull-policies"><strong>allowed_pull_policies-Konfiguration</strong> (nur in englischer Sprache verfügbar)</a> vorhanden sein, die in der Datei <strong><code>config.toml</code></strong> des Runners angegeben ist. Wenn dies nicht der Fall ist, sollte der Job mit dem Fehler <strong><code>incompatible pull policy</code></strong> fehlschlagen.</p>
<p>Wenn in der aktuellen Implementierung mehrere Pull-Richtlinien definiert sind, werden Jobs übergeben, wenn mindestens eine Pull-Richtlinie mit den Richtlinien in <strong><code>allowed-pull-policies</code></strong> übereinstimmt, auch wenn andere Richtlinien nicht enthalten sind.</p>
<p>In GitLab 18.0 schlagen Jobs nur fehl, wenn keine der Pull-Richtlinien mit den in <strong><code>allowed-pull-policies</code></strong> angegebenen übereinstimmt. Im Gegensatz zum früheren Verhalten verwenden Jobs jedoch nur die in <strong><code>allowed-pull-policies</code></strong> aufgeführten Pull-Richtlinien. Diese Unterscheidung kann dazu führen, dass Jobs, die derzeit erfolgreich ausgeführt werden, in GitLab 18.0 fehlschlagen.</p>
<ul>
<li><a href="https://docs.gitlab.com/update/deprecations/#reject-container-image-pull-policies-not-in-allowed_pull_policies">Hinweis zur Deaktivierung (nur in englischer Sprache verfügbar)</a></li>
<li><a href="https://docs.gitlab.com/runner/executors/docker/#allow-docker-pull-policies">Dokumentation (nur in englischer Sprache verfügbar)</a></li>
</ul>
<p><strong>3. PostgreSQL 14 und 15 werden nicht mehr unterstützt</strong></p>
<p>Self-Managed</p>
<p>GitLab folgt einem <a href="https://handbook.gitlab.com/handbook/engineering/infrastructure-platforms/data-access/database-framework/postgresql-upgrade-cadence/"><strong>jährlichen Upgrade-Rhythmus für PostgreSQL</strong> (nur in englischer Sprache verfügbar)</a>.</p>
<p>Die Unterstützung für PostgreSQL 14 und 15 soll in GitLab 18.0 entfernt werden. Ab GitLab 18.0 ist PostgreSQL 16 die minimal erforderliche Version von PostgreSQL.</p>
<p>PostgreSQL 14 und 15 werden für den gesamten Release-Zyklus von GitLab 17 unterstützt. PostgreSQL 16 wird auch für Instanzen unterstützt, die vor GitLab 18.0 ein Upgrade durchführen möchten.</p>
<p>Um diese Änderung auf Instanzen vorzubereiten, die kein <a href="https://docs.gitlab.com/administration/postgresql/replication_and_failover/"><strong>PostgreSQL-Cluster</strong> (nur in englischer Sprache verfügbar)</a> verwenden (z. B. wenn du eine einzelne PostgreSQL-Instanz ausführst, die du mit einem Omnibus-Linux-Paket installiert hast), versuchen Upgrades auf GitLab 17.11, PostgreSQL automatisch auf Version 16 zu aktualisieren. Wenn du <a href="https://docs.gitlab.com/administration/postgresql/replication_and_failover/"><strong>PostgreSQL-Cluster</strong></a> verwendest oder <a href="https://docs.gitlab.com/omnibus/settings/database/#opt-out-of-automatic-postgresql-upgrades"><strong>dich gegen dieses automatische Upgrade entscheidest</strong> (nur in englischer Sprache verfügbar)</a>, musst du <a href="https://docs.gitlab.com/omnibus/settings/database/#upgrade-packaged-postgresql-server"><strong>manuell ein Upgrade auf PostgreSQL 16</strong></a> durchführen, um ein Upgrade auf GitLab 18.0 durchführen zu können. Stelle sicher, dass du über genügend Speicherplatz verfügst, um das Upgrade durchzuführen.</p>
<ul>
<li><a href="https://docs.gitlab.com/update/deprecations/#postgresql-14-and-15-no-longer-supported">Hinweis zur Deaktivierung (nur in englischer Sprache verfügbar)</a></li>
<li><a href="https://docs.gitlab.com/omnibus/settings/database/#upgrade-packaged-postgresql-server">Dokumentation (nur in englischer Sprache verfügbar)</a></li>
<li><a href="https://docs.gitlab.com/omnibus/development/managing-postgresql-versions/">Migrationsrichtlinien (nur in englischer Sprache verfügbar)</a></li>
</ul>
<p><strong>4. Einstellung der Terraform-CI/CD-Vorlagen</strong></p>
<p>Self-Managed</p>
<p>Die Terraform-CI/CD-Vorlagen werden eingestellt und in GitLab 18.0 entfernt. Dies betrifft die folgenden Vorlagen:</p>
<ul>
<li><code>Terraform.gitlab-ci.yml</code></li>
<li><code>Terraform.latest.gitlab-ci.yml</code></li>
<li><code>Terraform/Base.gitlab-ci.yml</code></li>
<li><code>Terraform/Base.latest.gitlab-ci.yml</code></li>
</ul>
<p>GitLab kann die Binärdatei <strong><code>terraform</code></strong> in den Job-Images nicht auf eine Version aktualisieren, die unter der BSL lizenziert ist.</p>
<p>Um Terraform weiterhin zu verwenden, klone die Vorlagen und das <a href="https://gitlab.com/gitlab-org/terraform-images"><strong>Terraform-Image</strong></a> und pflege sie nach Bedarf. GitLab bietet <a href="https://gitlab.com/gitlab-org/terraform-images"><strong>detaillierte Anweisungen</strong></a> für die Migration zu einem benutzerdefinierten Image.</p>
<p><strong>Als Alternative empfehlen wir die Verwendung der neuen CI/CD-Komponente OpenTofu auf GitLab.com oder der neuen CI/CD-Vorlage OpenTofu in GitLab Self-Managed.</strong> CI/CD-Komponenten sind noch nicht für GitLab Self-Managed verfügbar. <a href="https://gitlab.com/gitlab-org/gitlab/-/issues/415638"><strong>Ticket #415638</strong></a> enthält jedoch den Vorschlag, diese Funktion hinzuzufügen. Wenn CI/CD-Komponenten auf GitLab Self-Managed verfügbar werden, wird die CI/CD-Vorlage OpenTofu entfernt.</p>
<p>Erfahre mehr über die neue <a href="https://gitlab.com/components/opentofu">CI/CD-Komponente OpenTofu</a>.</p>
<ul>
<li><a href="https://docs.gitlab.com/update/deprecations/#deprecate-terraform-cicd-templates">Hinweis zur Deaktivierung (nur in englischer Sprache verfügbar)</a></li>
</ul>
<p><strong>5. Wichtiges Update des Prometheus-Unterdiagramms</strong></p>
<p>Self-Managed</p>
<p>Mit GitLab 18.0 und GitLab Chart 9.0 wird das Prometheus-Unterdiagramm von 15.3 auf 27.3 aktualisiert.</p>
<p>Zusammen mit diesem Update wird standardmäßig Prometheus 3 ausgeliefert.</p>
<p>Für das Upgrade sind manuelle Schritte erforderlich. Wenn du Alertmanager, Node Exporter oder Pushgateway aktiviert hast, musst du auch deine Helm-Werte aktualisieren.</p>
<p>Weitere Informationen findest du im <a href="https://docs.gitlab.com/charts/releases/9_0/#prometheus-upgrade"><strong>Migrationsleitfaden</strong> (nur in englischer Sprache verfügbar)</a>.</p>
<ul>
<li><a href="https://docs.gitlab.com/update/deprecations/#major-update-of-the-prometheus-subchart">Hinweis zur Deaktivierung (nur in englischer Sprache verfügbar)</a></li>
</ul>
<h3>Geringe Auswirkungen</h3>
<p><strong>1. Pakete für SUSE Linux Enterprise Server 15 SP2 werden nicht mehr erstellt</strong></p>
<p>Self-Managed</p>
<p>Die langfristige Unterstützung (LTSS) für SUSE Linux Enterprise Server (SLES) 15 SP2 endete im Dezember 2024.</p>
<p>Daher werden wir die SLES-SP2-Distribution für Linux-Paketinstallationen nicht mehr unterstützen. Du solltest ein Upgrade auf SLES 15 SP6 durchführen, um weiterhin Support zu erhalten.</p>
<ul>
<li><a href="https://docs.gitlab.com/update/deprecations/#support-for-suse-linux-enterprise-server-15-sp2">Hinweis zur Deaktivierung (nur in englischer Sprache verfügbar)</a></li>
</ul>
<p><strong>2. Entfernen des Gitaly-Ratenbegrenzers</strong></p>
<p>Self-Managed</p>
<p>Gitaly unterstützte bisher <a href="https://gitlab.com/gitlab-org/gitaly/-/blob/4b7ea24f6172a03e7989879200b47b6fd0e2d059/doc/backpressure.md#L55-55"><strong>RPC-basierte Ratenbegrenzung</strong></a>. Wir stellen diese Funktion ein, da sie nicht die gewünschten Ergebnisse erzielt. Weitere Informationen findest du im Ticket für die Deaktivierung.</p>
<p>Wenn Kund(inn)en den Ratenbegrenzer konfiguriert haben (der veraltet ist), wird kein Fehler zurückgegeben und die Konfiguration wird einfach ignoriert.</p>
<p>Kund(inn)en sollten stattdessen den <a href="https://docs.gitlab.com/administration/gitaly/concurrency_limiting/"><strong>Gleichzeitigkeitsgrenzwert</strong> (nur in englischer Sprache verfügbar)</a> verwenden.</p>
<ul>
<li><a href="https://docs.gitlab.com/update/deprecations/#gitaly-rate-limiting">Hinweis zur Deaktivierung (nur in englischer Sprache verfügbar)</a></li>
</ul>
<p><strong>3. Einstellung der Unterstützung für NGINX-Controller-Image 1.3.1</strong></p>
<p>Self-Managed</p>
<p>Wir aktualisieren das Standard-NGINX-Controller-Image auf 1.11.2. Diese neue Version erfordert neue RBAC-Regeln und einige Benutzer(innen) setzen <strong>nginx-ingress.rbac.create: false</strong>, um ihre eigenen RBAC-Regeln zu verwalten.</p>
<p>Diese Benutzer(innen) müssen die RBAC-Regeln hinzufügen, bevor sie zu 1.11.2 oder höher migrieren. Wir haben einen Fallback-Mechanismus hinzugefügt, um 1.3.1 nur dann bereitzustellen, wenn dieser Helm-Wert wie oben festgelegt ist. Wir haben auch <strong>nginx-ingress.controller.image.disableFallback</strong> hinzugefügt, das standardmäßig auf „false“ gesetzt ist. Benutzer(innen), die ihr eigenes RBAC verwalten, können diesen Wert auf „true“ setzen, damit ihre Bereitstellungen auch 1.11.2 verwenden können, nachdem sie sichergestellt haben, dass die neuen RBAC-Regeln in Kraft sind.</p>
<p>Wir planen, die Unterstützung für das 1.3.1-Image und den Fallback-Mechanismus mit der Version 17.5 einzustellen, damit wir diese Unterstützung vollständig entfernen und nur noch 1.11.2 verwenden können, das zahlreiche Sicherheitsvorteile bietet.</p>
<p><a href="https://docs.gitlab.com/update/deprecations/#fallback-support-for-gitlab-nginx-chart-controller-image-v131">Hinweis zur Deaktivierung (nur in englischer Sprache verfügbar)</a></p>
<p><strong>4. Update der Hauptversion der Analysatoren der Anwendungssicherheitstests</strong></p>
<p>GitLab.com | Self-Managed | Dedicated</p>
<p>Die Phase der Anwendungssicherheitstests wird die Hauptversionen der Analysatoren zusammen mit der Veröffentlichung von GitLab 18.0 aktualisieren.</p>
<p>Wenn du nicht die standardmäßig enthaltenen Vorlagen verwendest oder deine Analysator-Versionen fixiert hast, musst du deine CI/CD-Job-Definition aktualisieren, um entweder die fixierte Version zu entfernen oder die neueste Hauptversion zu aktualisieren.</p>
<p>Benutzer(innen) von GitLab 17.0–17.11 erhalten bis zur Veröffentlichung von GitLab 18.0 weiterhin normale Analysator-Updates. Nach GitLab 18.0 werden alle neu behobenen Bugs und Funktionen nur noch in der neuen Hauptversion der Analysatoren veröffentlicht.</p>
<p>Gemäß unseren Wartungsrichtlinien portieren wir keine Fehler und Funktionen in veraltete Versionen zurück. Sicherheitspatches werden bei Bedarf in die letzten drei Nebenversionen zurückportiert.</p>
<ul>
<li><a href="https://docs.gitlab.com/update/deprecations/#application-security-testing-analyzers-major-version-update">Hinweis zur Deaktivierung (nur in englischer Sprache verfügbar)</a></li>
</ul>
<p><strong>5. API-Entdeckung verwendet standardmäßig Branch-Pipelines</strong></p>
<p>GitLab.com | Self-Managed | Dedicated</p>
<p>In GitLab 18.0 aktualisieren wir das Standardverhalten der CI/CD-Vorlage für die API-Erkennung (<strong>API-Discovery.gitlab-ci.yml</strong>).</p>
<p>Vor GitLab 18.0 konfiguriert diese Vorlage Jobs so, dass sie standardmäßig in <a href="https://docs.gitlab.com/ci/pipelines/merge_request_pipelines/"><strong>Merge Request-Pipelines</strong> (nur in englischer Sprache verfügbar)</a> ausgeführt werden, wenn ein MR geöffnet ist.</p>
<p>Ab GitLab 18.0 richten wir das Verhalten dieser Vorlage am Verhalten der <a href="https://docs.gitlab.com/user/application_security/detect/roll_out_security_scanning/#template-editions"><strong>stabilen Vorlagen-Editionen</strong> (nur in englischer Sprache verfügbar)</a> für andere AST-Scanner aus:</p>
<ul>
<li>Standardmäßig führt die Vorlage Scan-Jobs in Branch-Pipelines aus.</li>
<li>Du kannst die CI/CD-Variable <strong>AST_ENABLE_MR_PIPELINES: true</strong> festlegen, um MR-Pipelines zu verwenden, wenn ein MR geöffnet ist. Die Implementierung dieser neuen Variable wird im <a href="https://gitlab.com/gitlab-org/gitlab/-/issues/410880"><strong>Ticket #410880</strong></a> nachverfolgt.</li>
</ul>
<ul>
<li><a href="https://docs.gitlab.com/update/deprecations/#api-discovery-will-use-branch-pipelines-by-default">Hinweis zur Deaktivierung (nur in englischer Sprache verfügbar)</a></li>
</ul>
<p><strong>6. DAST DAST_DEVTOOLS_API_TIMEOUT hat einen niedrigeren Standardwert</strong></p>
<p>GitLab.com | Self-Managed | Dedicated</p>
<p>Die Umgebungsvariable <strong>DAST_DEVTOOLS_API_TIMEOUT</strong> bestimmt, wie lange ein DAST-Scan auf eine Antwort des Browsers wartet. Vor GitLab 18.0 hatte die Variable einen statischen Wert von 45 Sekunden. Ab GitLab 18.0 hat die Umgebungsvariable <strong>DAST_DEVTOOLS_API_TIMEOUT</strong> einen dynamischen Wert, der basierend auf anderen Timeout-Konfigurationen berechnet wird.</p>
<p>In den meisten Fällen war der Wert von 45 Sekunden höher als der Timeout-Wert vieler Scannerfunktionen. Der dynamisch berechnete Wert macht die Variable <strong>DAST_DEVTOOLS_API_TIMEOUT</strong> nützlicher, indem er die Anzahl der Fälle erhöht, für die sie gilt.</p>
<ul>
<li><a href="https://docs.gitlab.com/update/deprecations/#dast-dast_devtools_api_timeout-will-have-a-lower-default-value">Hinweis zur Deaktivierung (nur in englischer Sprache verfügbar)</a></li>
</ul>
<h2>Tools und Ressourcen, um deine Auswirkungen zu verwalten</h2>
<p>Wir haben spezielle Tools entwickelt, um unseren Kund(inn)en zu helfen, zu verstehen, wie sich diese geplanten Änderungen auf ihre GitLab-Instanz(en) auswirken. Sobald du die Auswirkungen für deine Arbeit analysiert hast, solltest du die in der Dokumentation beschriebenen Maßnahmen überprüfen, um einen reibungslosen Übergang zu GitLab 18.0 zu gewährleisten.</p>
<ul>
<li><a href="https://gitlab.com/gitlab-com/cs-tools/gitlab-cs-tools/deprecation-migration-tools/advanced-search-deprecations">Veraltete Funktionen der erweiterten Suche</a>: Dieses Tool nutzt die erweiterte Such-API von GitLab, um Zeichenfolgen zu finden, die in allen GitLab-Gruppen und -Projekten veraltet sind. Es zeigt auch, welche Dateien manuell überprüft werden sollten. <em><strong>Hinweis:</strong> Kann ein paar falsch positive Ergebnisse liefern.</em></li>
<li><a href="https://gitlab.com/security-products/tooling/build-support-detection-helper">Dependency Scanning Build Support Detection Helper</a>: Dieses Tool identifiziert Projekte, die von drei Einstellungen der Abhängigkeitssuche betroffen sind (<a href="https://docs.gitlab.com/update/deprecations/#dependency-scanning-for-javascript-vendored-libraries">1</a>, <a href="https://docs.gitlab.com/update/deprecations/#dependency-scanning-upgrades-to-the-gitlab-sbom-vulnerability-scanner">2</a>, <a href="https://docs.gitlab.com/update/deprecations/#resolve-a-vulnerability-for-dependency-scanning-on-yarn-projects">3</a>; alle auf Version 19.0 verschoben). Es verwendet die API, um nach relevanten Dateien und CI-Job-Namen zu suchen.</li>
<li><a href="https://gitlab.com/gitlab-com/support/toolbox/gitlab-detective/-/blob/main/README.md">GitLab Detective</a> (nur Self-Managed): Dieses experimentelle Tool überprüft automatisch eine GitLab-Installation auf bekannte Probleme. Es führt komplexe Überprüfungen durch, indem es Konfigurationsdateien oder Datenbankwerte analysiert. <strong>Hinweis:</strong> Muss direkt auf deinen GitLab-Knoten ausgeführt werden.</li>
</ul>
<p>Wir haben außerdem eine Reihe von Mikrokursen (15 Minuten oder kürzer) auf der GitLab University gestartet, die dir bei der Planung und Durchführung von Maßnahmen zur Minderung einiger dieser Änderungen helfen. <a href="https://university.gitlab.com/catalog?query=18.0">Starte deine Lernreise hier</a>.</p>
<p>Wenn du einen kostenpflichtigen Tarif hast und Fragen zu diesen Änderungen hast oder Unterstützung benötigst, <a href="https://about.gitlab.com/support/portal/">öffne ein Support-Ticket</a> im GitLab-Support-Portal.</p>
<p>Wenn du <a href="https://about.gitlab.com/support/statement-of-support/#free-users">Benutzer(in) einer kostenlosen Gitlab.com-Lizenz (nur in englischer Sprache verfügbar)</a> bist, kannst du über meist englischsprachige Community-Quellen wie die <a href="https://docs.gitlab.com/">GitLab-Dokumentation</a>, das <a href="https://forum.gitlab.com/">GitLab-Community-Forum</a> und <a href="http://stackoverflow.com/questions/tagged/gitlab">Stack Overflow</a> auf zusätzlichen Support zugreifen.</p>
]]></content>
        <author>
            <name>Martin Brümmer</name>
            <uri>https://about.gitlab.com/blog/authors/martin-brümmer</uri>
        </author>
        <author>
            <name>Fabian Zimmer</name>
            <uri>https://about.gitlab.com/blog/authors/fabian-zimmer</uri>
        </author>
        <author>
            <name>Sam Wiskow</name>
            <uri>https://about.gitlab.com/blog/authors/sam-wiskow</uri>
        </author>
        <published>2025-04-18T00:00:00.000Z</published>
    </entry>
    <entry>
        <title type="html"><![CDATA[GitLab Duo mit Amazon Q: Die für AWS optimierte agentische KI ist jetzt allgemein verfügbar]]></title>
        <id>https://about.gitlab.com/de-de/blog/gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws/</id>
        <link href="https://about.gitlab.com/de-de/blog/gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws/"/>
        <updated>2025-04-17T00:00:00.000Z</updated>
        <content type="html"><![CDATA[<p>Wir freuen uns, heute die allgemeine Verfügbarkeit von <strong><a href="https://about.gitlab.com/de-de/partners/technology-partners/aws/">GitLab Duo mit Amazon Q</a></strong> bekannt zu geben. Damit wird AWS-Kund(inn)en eine <a href="https://about.gitlab.com/de-de/topics/agentic-ai/">agentenbasierte KI</a> während des gesamten Software-Entwicklungsprozesses zur Verfügung gestellt.</p>
<p>GitLab Duo mit Amazon Q basiert auf GitLab Ultimate und enthält viele bekannte Funktionen wie Codevervollständigung, Codeerläuterung, Codegenerierung, Chat sowie Erklärung und Behebung von Sicherheitslücken – allesamt jetzt mit Amazon Q. Es ist mit einem selbstverwalteten Bereitstellungsmodell für Kund(inn)en von Amazon Web Services (AWS) verfügbar.</p>
<p>Da die Agenten von Amazon Q direkt in die DevSecOps-Plattform von GitLab eingebettet sind, können Entwickler(innen) in ihrer gewohnten Umgebung arbeiten und gleichzeitig von leistungsstarken KI-Funktionen profitieren. Das Ergebnis ist eine reibungslose Erfahrung, die Entwicklungszyklen beschleunigt, manuellen Aufwand reduziert und die Codequalität verbessert.</p>
<blockquote>
<p>Durch die Teilnahme am Early-Access-Programm für GitLab Duo mit Amazon Q konnten wir einen Einblick in das transformative Potenzial für unsere Entwicklungs-Workflows gewinnen. <strong>Schon in der Anfangsphase haben wir gesehen, wie die tiefere Integration mit autonomen Agenten unseren Prozess vom Code-Commit bis hin zur Produktion optimieren kann.</strong> Wir sind gespannt, wie unser Team sich mit dieser Technologie auf Innovationen konzentrieren und unsere digitale Transformation beschleunigen kann.</p>
</blockquote>
<p><strong>Osmar Alonso, DevOps Engineer bei Volkswagen Digital Solutions</strong></p>
<h2>Agentische KI für komplexe Kundenumgebungen</h2>
<p>Durch die Kombination von agentischer KI mit einer sicheren und zuverlässigen Cloud-Infrastruktur bieten GitLab und AWS integrierte Sicherheit, Skalierbarkeit und Zuverlässigkeit für komplexe Kundenumgebungen, sodass diese von folgenden Vorteilen profitieren können:</p>
<p><strong>Einheitliche Entwicklererfahrung für optimierte Entwicklung</strong></p>
<p>Entwickler(innen) können über die Schnittstelle von GitLab Duo Chat von ihrer bevorzugten IDE oder der GitLab-Weboberfläche aus mit Amazon Q interagieren. Dadurch entfällt der Kontextwechsel zu anderen Tools und Entwickler(innen) können sich besser auf das Projekt konzentrieren, an dem sie gerade arbeiten.</p>
<p><strong>Eine Lösung für den gesamten Software-Entwicklungsprozess</strong></p>
<p>Codevorschläge und -optimierungen nutzen AWS-spezifische Muster und Vorgehensweisen, während Testtools die Interaktionen und Abhängigkeiten der AWS-Services verstehen. Ein gemeinsamer Datenspeicher für alle Phasen liefert KI-Agenten wichtige Kontextinformationen und ermöglicht so vollständige Transparenz und Nachverfolgbarkeit relevanter Aktionen.</p>
<p><strong>Sichere Entwicklung mit Leitlinien auf Unternehmensebene</strong></p>
<p>End-to-End-Sicherheit und Compliance sind direkt in die Entwicklungsplattform integriert, mit Leitlinien, die Risiken reduzieren, ohne die Geschwindigkeit zu beeinträchtigen. Dieser sichere Ansatz für die Softwareentwicklung sorgt für Transparenz und Überprüfbarkeit durch KI-Agenten und lässt sich nahtlos in AWS-Sicherheitsdienste und Compliance-Frameworks integrieren.</p>
<h2>So kannst du GitLab Duo mit Amazon Q nutzen</h2>
<p>Hier sind fünf Anfangsbeispiele, die wir uns vorgenommen haben, um Teams dabei zu helfen, mit agentenbasierter KI schneller sichere Software zu entwickeln:</p>
<ol>
<li><strong>Schnellere Entwicklung von Funktionen</strong> - Erstellt Ticketbeschreibungen, macht Implementierungspläne auf Basis deiner bestehenden Codebase und erstellt komplette Merge Requests, die sofort überprüft werden können. Das beschleunigt die Bereitstellung von Funktionen und sorgt gleichzeitig für die Einhaltung der internen Entwicklungsstandards.</li>
<li><strong>Modernisieren von älteren Anwendungen</strong> - Analysiert deine alte Java-Codebase, erstellt einen umfassenden Upgrade-Plan und generiert einen Merge Request mit allen notwendigen Codeänderungen. Dadurch werden Java-Upgrades beschleunigt und ein klarer Audit-Trail für alle Codetransformationen bereitgestellt. Die Unterstützung für .NET und andere Sprachen ist für zukünftige Versionen geplant.</li>
<li><strong>Verbessern der Qualitätssicherung</strong> - Analysiert Code und erstellt automatisch umfassende Unit-Tests, die deine Anwendungslogik und die Interaktionen mit AWS-Services berücksichtigen. Dies erhöht die Testabdeckung, reduziert den Aufwand für das manuelle Schreiben von Tests und trägt dazu bei, eine konsistente Testqualität über alle Anwendungen hinweg sicherzustellen.</li>
<li><strong>Optimieren der Code Review</strong> - Bietet Inline-Feedback zu Codeänderungen, schlägt Verbesserungen auf Basis von Entwicklungsstandards vor und hebt Sicherheits- und Leistungsaspekte hervor. Dies ermöglicht kürzere Code-Review-Zyklen und die Bereitstellung hochwertigerer Codezusammenführungen für die Bereitstellung.</li>
<li><strong>Beheben von Sicherheitslücken</strong> - Erläutert erkannte Sicherheitslücken anhand klarer, detaillierter Beschreibungen und ermöglicht die Behebung mit einem Klick auf Basis empfohlener Codeänderungen, wodurch die Zeit zwischen Erkennung und Behebung erheblich verkürzt wird.</li>
</ol>
<p>Sieh dir GitLab Duo mit Amazon Q in Aktion an:</p>
<p>&lt;div style=&quot;padding:56.25% 0 0 0;position:relative;&quot;&gt;&lt;iframe src=&quot;https://player.vimeo.com/video/1075753390?badge=0&amp;autopause=0&amp;player_id=0&amp;app_id=58479&quot; frameborder=&quot;0&quot; allow=&quot;autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media&quot; style=&quot;position:absolute;top:0;left:0;width:100%;height:100%;&quot; title=&quot;Technical Demo: GitLab Duo with Amazon Q&quot;&gt;&lt;/iframe&gt;&lt;/div&gt;&lt;script src=&quot;https://player.vimeo.com/api/player.js&quot;&gt;&lt;/script&gt;</p>
<h4>Profitiere noch heute von den Vorteilen von GitLab Duo mit Amazon Q</h4>
<p>Die einheitliche, KI-gestützte DevSecOps-Plattform von GitLab mit den fortschrittlichen KI-Funktionen von Amazon Q bietet AWS-Kund(inn)en eine Lösung, die die Art und Weise, wie Teams Software entwickeln und bereitstellen, verändert.</p>
<p>Besuche uns auf einem bevorstehenden <a href="https://about.gitlab.com/de-de/events/aws-summits/">AWS Summit in einer Stadt in deiner Nähe</a> oder <a href="https://about.gitlab.com/de-de/partners/technology-partners/aws/">wende dich an deine<em>n GitLab-Vertreter</em>in</a>, um mehr über GitLab Duo mit Amazon Q zu erfahren.</p>
]]></content>
        <author>
            <name>Emilio Salvador</name>
            <uri>https://about.gitlab.com/blog/authors/emilio-salvador</uri>
        </author>
        <published>2025-04-17T00:00:00.000Z</published>
    </entry>
    <entry>
        <title type="html"><![CDATA[Was ist Generative KI?]]></title>
        <id>https://about.gitlab.com/de-de/blog/what-is-generative-ai/</id>
        <link href="https://about.gitlab.com/de-de/blog/what-is-generative-ai/"/>
        <updated>2025-04-16T00:00:00.000Z</updated>
        <content type="html"><![CDATA[<h1>Was ist Generative KI?</h1>
<p>Generative KI ist eine revolutionäre Technologie, die über die reine Analyse bestehender Daten hinausgeht und eigenständig neue Inhalte wie Texte, Bilder, Musik oder Code erstellt. Sie unterstützt kreative Prozesse und treibt Innovationen in unterschiedlichsten Branchen voran.</p>
<p>Aber wie funktioniert diese fortschrittliche Technologie, was macht sie so einzigartig und welche Modelle stecken dahinter? In diesem Artikel erhältst du umfassende Antworten auf diese Fragen sowie praxisnahe Beispiele und spannende Anwendungsfälle.</p>
<h2>Generative KI: Definition</h2>
<p>Generative künstliche Intelligenz ist ein spezieller Bereich der künstlichen Intelligenz, der nicht nur bestehende Daten analysiert oder kategorisiert, sondern eigenständig neue Inhalte erschafft.</p>
<p>Mithilfe komplexer Algorithmen und neuronaler Netzwerke entstehen Texte, Bilder, Musik oder andere Inhalte, die so realistisch wirken sollen, dass sie zukünftig kaum von menschlich erstellten Werken zu unterscheiden sind. Die Technologie lernt aus vorhandenen Mustern und wendet dieses Wissen an, um innovative und kreative Ergebnisse zu erzielen.</p>
<h2>Wie unterscheidet sich generative KI von KI?</h2>
<p>Der Begriff „künstliche Intelligenz“ umfasst viele Technologien, doch generative KI ist ein spezifischer Teilbereich davon. Klassische KI-Modelle erkennen Muster, treffen Entscheidungen oder automatisieren Prozesse, während generative KI auf die Erzeugung neuer Inhalte spezialisiert ist.</p>
<h3>KI und generative KI: Unterschiede im Überblick:</h3>
<p><strong>Klassische KI</strong> wird vor allem für Analyse, Vorhersagen und Automatisierung eingesetzt. Typische Technologien sind Entscheidungsbäume, Regressionsmodelle oder Klassifikatoren. Anwendungen finden sich zum Beispiel in Chatbots, Sprachassistenten oder Empfehlungssystemen.</p>
<p><strong>Generative KI</strong> hingegen geht einen Schritt weiter: Sie kann eigenständig neue Inhalte erzeugen. Möglich machen das fortschrittliche Modelle wie GANs (Generative Adversarial Networks), Transformer oder Diffusionsmodelle. So entstehen KI-generierte Texte, Bilder, Musik oder Videos – etwa mit Tools wie ChatGPT oder DALL-E.</p>
<p><strong>Die beiden KI-Formen verfolgen also unterschiedliche Ziele: Während klassische KI auf Analyse basiert, steht bei generativer KI die kreative Inhaltserstellung im Fokus.</strong></p>
<h3>Warum ist der Unterschied wichtig?</h3>
<p>Generative KI eröffnet neue Anwendungsfelder: Statt nur zu reagieren oder Aufgaben zu automatisieren, können nun innovative und kreative Prozesse unterstützt werden. Das hat auch Auswirkungen auf kreative Berufe, Produktentwicklung oder auch die Art, wie wir miteinander kommunizieren.</p>
<h2>Wie funktioniert generative KI?</h2>
<p>Die Funktionsweise generativer KI basiert auf komplexen mathematischen Modellen, die von neuronalen Netzwerken trainiert werden. Diese Netzwerke analysieren riesige Datenmengen und lernen, Muster und Beziehungen innerhalb dieser Daten zu erkennen.</p>
<h3>Grundlagen der Funktionsweise generativer KI</h3>
<p>Generative KI ist ein faszinierendes Feld, das sich auf die Erstellung neuer Inhalte aus bestehenden Daten konzentriert.</p>
<p>Hier sind die wesentlichen Grundlagen, wie diese Technologien arbeiten und welche Modelle dabei eine Rolle spielen.</p>
<ol>
<li>
<p><strong>Training mit Daten:</strong> Das Modell wird mit großen Mengen an Daten, wie Texte, Bilder oder Videos, gefüttert. Ziel ist es, Muster und Zusammenhänge in diesen Daten zu erkennen.</p>
</li>
<li>
<p><strong>Modelltypen:</strong> Die häufigsten Modelle, die in der generativen KI verwendet werden, sind:</p>
</li>
</ol>
<ul>
<li>
<p><strong>GANs (Generative Adversarial Networks):</strong> Zwei Netzwerke arbeiten gegeneinander – eines generiert Inhalte, das andere bewertet deren Qualität.</p>
</li>
<li>
<p><strong>Transformermodelle:</strong> Diese Modelle, wie GPT, setzen auf Kontextverständnis, um kohärente und logische Inhalte zu erstellen.</p>
</li>
<li>
<p><strong>Diffusionsmodelle:</strong> Sie erstellen Inhalte, indem sie Rauschen schrittweise reduzieren und werden häufig in der Bildgenerierung eingesetzt.</p>
</li>
</ul>
<ol start="3">
<li><strong>Generierung neuer Inhalte:</strong> Nach dem Training kann das Modell auf neue Eingaben reagieren und basierend auf gelernten Mustern neue Inhalte erstellen.</li>
</ol>
<p>Mit diesen Modellen kann generative KI erstaunliche Inhalte erzeugen, die in vielen Bereichen Anwendung finden – von der Texterstellung bis hin zur Kunst- und Bildproduktion.</p>
<h2>Wie Deep Learning die generative KI vorantreibt</h2>
<p>Deep Learning ist die treibende Kraft hinter generativer KI. Als Teilgebiet des maschinellen Lernens setzt es auf neuronale Netzwerke mit mehreren Schichten, um komplexe Muster in Daten zu erkennen und darauf aufbauend neue Inhalte zu generieren. Diese Methode ist besonders leistungsfähig, da sie in der Lage ist, tiefere Zusammenhänge in Daten zu verstehen. Dadurch werden qualitativ hochwertige Ergebnisse erzielt.</p>
<h3>Was ist Deep Learning?</h3>
<p>Deep Learning ist eine Technologie, die künstliche neuronale Netzwerke verwendet, um Daten Schritt für Schritt zu analysieren. Jede Schicht des Netzwerks verarbeitet spezifische Merkmale der Daten und übergibt die Ergebnisse an die nächste Ebene.
Dieser schichtweise Ansatz ermöglicht es, sowohl einfache als auch komplexe Muster zu erkennen, was für die Generierung neuer Inhalte essenziell ist.</p>
<h3>Die Rolle von Deep Learning</h3>
<p>Deep Learning ist für generative KI unverzichtbar, weil es:
Skalierbar ist und große Datenmengen effizient verarbeiten kann.
Flexibel für verschiedene Datentypen wie Text, Bilder und Audio einsetzbar ist.
Leistungsstark durch Fortschritte in Algorithmen und Rechenleistung immer präzisere Ergebnisse liefert.</p>
<h3>Warum ist Deep Learning entscheidend?</h3>
<p>Offensichtlich beeinflusst Deep Learning generative KI grundlegend. Ohne Deep Learning wäre sie in ihrer heutigen Form nicht möglich. Es ermöglicht nicht nur die Erstellung realistischer Inhalte, sondern treibt auch die Weiterentwicklung von Modellen voran.
Dadurch kann generative KI in immer mehr Bereichen eingesetzt werden und liefert innovative Lösungen für kreative und technische Herausforderungen.</p>
<h2>Generative KI – Modelle</h2>
<p>Generative KI stützt sich auf verschiedene Modelltypen, die jeweils für unterschiedliche Anwendungen optimiert sind. Jedes Modell hat eigene Stärken und Schwächen und wird je nach Anwendungsfall eingesetzt.</p>
<h3>GANs (Generative Adversarial Networks)</h3>
<p>GANs bestehen aus zwei miteinander konkurrierenden neuronalen Netzwerken:</p>
<p><strong>Der Generator</strong> erstellt neue Inhalte.</p>
<p><strong>Der Diskriminator</strong> bewertet, ob die Inhalte echt oder künstlich sind.
Dieser Wettbewerb zwischen den Netzwerken verbessert die Qualität der generierten Inhalte kontinuierlich, was GANs besonders für die Erstellung von Bildern, Videos und anderen visuellen Medien prädestiniert.</p>
<h3>Transformermodelle</h3>
<p>Transformermodelle wie GPT (Generative Pre-trained Transformer) basieren auf der Fähigkeit, den Kontext von Wörtern und Sätzen zu verstehen. Sie sind besonders effektiv bei der Verarbeitung und Erstellung von Texten. Transformermodelle analysieren Daten in Sequenzen, um sinnvolle und kohärente Inhalte zu generieren.</p>
<h3>Variational Autoencoders (VAEs)</h3>
<p>VAEs komprimieren Daten in ein kompaktes Format, um sie später zu rekonstruieren. Sie erzeugen neue Inhalte, indem sie Variationen innerhalb eines Datensatzes erstellen. VAEs werden häufig in der Bild- und Tondatenverarbeitung eingesetzt und eignen sich gut für Aufgaben, bei denen Variationen auf Basis bestehender Muster benötigt werden.</p>
<h3>Diffusionsmodelle</h3>
<p>Diffusionsmodelle entfernen schrittweise Rauschen aus einer Pixelmatrix, um realistische Bilder zu erstellen. Diese Modelle sind besonders beliebt in der Bildgenerierung, da sie detaillierte und hochqualitative Ergebnisse liefern können.</p>
<h2>Generative KI-Anwendungen in unterschiedlichen Bereichen</h2>
<p>Generative KI hat das Potenzial, Branchen zu transformieren, Arbeitsprozesse zu vereinfachen und zu automatisieren und große Datenmengen schneller zu verarbeiten.</p>
<h3>Generative KI in Marketing und Kommunikation</h3>
<p>In Marketing und Kommunikation wird generative KI wie ChatGPT vor allem für die automatisierte Erstellung von Inhalten wie Blogbeiträgen, Social-Media-Posts oder Produktbeschreibungen genutzt. Sie kann auch personalisierte Anzeigen generieren, die gezielt auf die Interessen der Zielgruppe zugeschnitten sind.</p>
<p>Allerdings gibt es Herausforderungen: KI-generierte Inhalte wirken oft unpersönlich, können kulturelle Feinheiten übersehen und dadurch Missverständnisse auslösen. Zudem kann die Authentizität fehlen, was die Markenbindung negativ beeinflusst.</p>
<h3>Generative KI in der Bildung</h3>
<p>In der Bildung wird generative KI eingesetzt, um personalisierte Lernmaterialien zu erstellen, die sich an den individuellen Fortschritt der Lernenden anpassen. Auch virtuelle Simulationen werden immer häufiger genutzt, um praxisnahes Lernen zu fördern, etwa in der Medizin oder Technik.</p>
<p>Vorteile sind die Anpassungsfähigkeit und die interaktive Gestaltung des Lernens. Allerdings müssen generierte Inhalte überprüft werden, um Fehler zu vermeiden, und die Implementierung solcher Technologien kann kostenintensiv sein.</p>
<h3>Generative KI in der Forschung und Entwicklung</h3>
<p>Generative KI unterstützt die Forschung und Entwicklung, indem sie neue Prototypen und Designs generiert und komplexe Daten analysiert. Dadurch werden Innovationsprozesse beschleunigt und neue Zusammenhänge schneller erkannt.</p>
<p>Während die Effizienz dadurch deutlich steigt, bleibt die Abhängigkeit von der Datenqualität ein Schwachpunkt. Fehlerhafte Daten können die Ergebnisse negativ beeinflussen, und der hohe Rechenaufwand macht die Nutzung oft teuer.</p>
<h2>Beispiele für Generative-KI-Anwendungen in der Arbeitswelt</h2>
<p>Generative KI hat ihren Weg in zahlreiche Branchen gefunden und bietet eine Vielzahl von Anwendungsmöglichkeiten.</p>
<h2>Kreative Anwendungen</h2>
<p><strong>Texterstellung:</strong> Tools wie ChatGPT oder Jasper AI erstellen Artikel, Blogbeiträge oder Produktbeschreibungen.</p>
<p><strong>Bildgenerierung:</strong> Mit Tools wie DALL-E oder MidJourney können Benutzer(innen) Bilder auf Basis einfacher Texteingaben erzeugen.</p>
<p><strong>Musikproduktion:</strong> Plattformen wie Amper Music oder AIVA komponieren Musikstücke für Filme oder Podcasts.</p>
<h3>Industrie und Technologie</h3>
<p><strong>Code-Generierung:</strong> Entwickler(innen) nutzen Tools wie <a href="https://about.gitlab.com/de-de/gitlab-duo/">GitLab Duo</a>, um automatisiert Codevorschläge zu erhalten.</p>
<p><strong>Prototypen-Design:</strong> Generative KI hilft Entwickler(inn)en und Designer(innen) bei der Entwicklung neuer Produkte.</p>
<p><strong>Automatisierte Tests:</strong> Softwaretests können durch KI schneller und effizienter gestaltet werden.</p>
<h3>Gesundheit und Wissenschaft</h3>
<p><strong>Medikamentenentwicklung:</strong> KI-Modelle wie <a href="https://alphafold.ebi.ac.uk/">AlphaFold</a> haben die Vorhersage von Proteinstrukturen revolutioniert.</p>
<p><strong>Diagnostik:</strong> Generative KI analysiert medizinische Bilder und erkennt Krankheiten wie Tumore oder Anomalien.</p>
<h3>Unterhaltung und Gaming</h3>
<p><strong>Spieldesign:</strong> Generative KI erschafft neue Level, Charaktere oder Szenarien für Videospiele.</p>
<p><strong>Filmproduktion:</strong> Erstellung von Drehbüchern oder visuellen Effekten, die durch KI unterstützt werden.</p>
<h2>Best Practices für den Einsatz von Generativer KI</h2>
<p>Der erfolgreiche Einsatz von generativer KI erfordert durchdachte Ansätze, um Qualität, Sicherheit und Effektivität zu gewährleisten.</p>
<p><strong>Definierte Ziele setzen:</strong> Bevor ein KI-Modell eingesetzt wird, sollte klar definiert sein, welche spezifischen Aufgaben oder Probleme es lösen soll. Eine präzise Zielsetzung verhindert Fehlentwicklungen und verbessert die Ergebnisse.</p>
<p><strong>Kontext berücksichtigen:</strong> Die generierten Inhalte müssen immer mit ihrem Einsatzzweck übereinstimmen. Dies umfasst die Berücksichtigung kultureller, sozialer oder geschäftlicher Anforderungen, um relevante und angemessene Ergebnisse zu erzielen.</p>
<p><strong>Vielfältige Evaluation:</strong> Die Leistung von KI-Modellen sollte mit verschiedenen Methoden überprüft werden. Neben technischen Metriken ist auch qualitatives Feedback von Expert(inn)en und Nutzer(inne)n entscheidend, um die Anwendbarkeit und Qualität sicherzustellen.</p>
<p><strong>Kontinuierliche Optimierung:</strong> KI-Modelle sollten regelmäßig überprüft und weiterentwickelt werden, um auf veränderte Daten, Anforderungen oder Technologien reagieren zu können.</p>
<h2>Herausforderungen und ethische Aspekte von generativer KI</h2>
<p>Neben den zahlreichen Vorteilen bringt der Einsatz generativer KI auch einige Herausforderungen mit sich:</p>
<p><strong>Urheberrechtsfragen:</strong> Es bleibt unklar, wem die Rechte an KI-generierten Inhalten gehören – den Entwicklern, den Nutzern oder sogar den Datengrundlagen?</p>
<p><strong>Verzerrungen in den Ergebnissen:</strong> Wenn die zugrunde liegenden Trainingsdaten voreingenommen sind, können die generierten Inhalte diese Vorurteile widerspiegeln und verstärken.</p>
<p><strong>Potenzial für Missbrauch:</strong> Generative KI kann für negative Zwecke eingesetzt werden, etwa zur Verbreitung von Fehlinformationen oder zur Durchführung von Cyberangriffen.</p>
<p>Um die Herausforderungen im Umgang mit generativer KI zu bewältigen, ist es entscheidend, mehr Transparenz bei der Entwicklung und Nutzung von KI-Modellen zu schaffen. Darüber hinaus sollten klare ethische Standards sowie gesetzliche Regelungen eingeführt und konsequent eingehalten werden, um potenzielle Risiken zu minimieren und einen verantwortungsvollen Einsatz sicherzustellen.</p>
<h2>Wie setzt GitLab generative KI ein</h2>
<p><a href="https://about.gitlab.com/de-de/">GitLab</a> integriert generative KI umfassend in seine DevSecOps-Plattform, um den gesamten Softwareentwicklungsprozess zu optimieren. Durch die Partnerschaft mit Unternehmen wie Anthropic nutzt GitLab fortschrittliche KI-Modelle, um Entwickler(innen) bei verschiedenen Aufgaben zu unterstützen.</p>
<p><strong>Code-Vorschläge:</strong> Die Funktion <a href="https://about.gitlab.com/blog/gitlab-uses-anthropic-for-smart-safe-ai-assisted-code-generation/">Code Suggestions</a> bietet während des Tippens kontextbezogene Code-Vorschläge, was die Effizienz beim <a href="https://about.gitlab.com/de-de/blog/refactor-code-into-modern-languages-with-ai-powered-gitlab-duo/">Code Refactoring</a> erhöht.</p>
<p><strong>Automatische Reviewer-Zuweisung:</strong> Mit <a href="https://about.gitlab.com/blog/gitlab-ai-assisted-features/">Suggested Reviewers</a> identifiziert die KI geeignete Personen für die Überprüfung von Merge Requests, was den Review-Prozess beschleunigt.</p>
<p><strong>Zusammenfassungen von Merge Requests:</strong> Die KI generiert prägnante Zusammenfassungen von Änderungen in Merge Requests, um die Kommunikation zwischen Teammitgliedern zu erleichtern.</p>
<p><strong>Erklärung von Schwachstellen:</strong> Die Funktion „Explain This Vulnerability” hilft Entwickler(innen), Sicherheitslücken besser zu verstehen und effizienter zu beheben.</p>
<p><strong>Testgenerierung in Merge Requests:</strong> Die KI kann automatisch Tests für neuen Code generieren, um die Qualitätssicherung zu unterstützen.</p>
<h3>GitLab Duo – weiter hilfreiche KI-Funktionen</h3>
<p>Durch diese erweiterten KI-Funktionen fördert GitLab eine effizientere, sicherere und innovativere Softwareentwicklung.</p>
<p><strong><a href="https://docs.gitlab.com/development/ai_features/duo_chat/">GitLab Duo Chat:</a></strong> Ein KI-gestützter Chatbot, der Fragen beantwortet und bei der Navigation durch die Plattform hilft, um den Lernprozess zu unterstützen.</p>
<p><strong>Refactoring von Code in moderne Sprachen:</strong> GitLab Duo unterstützt Entwickler(innen) dabei, bestehenden Code in moderne Programmiersprachen zu überführen. Dies erleichtert die Modernisierung von Anwendungen und das Erlernen neuer Sprachfunktionen.</p>
<p><strong>Sicheres Testen von KI-generiertem Code:</strong> Durch die Kombination von GitLab Duo mit GitLab Pages können Entwickler(innen) KI-generierten Code gründlich testen und Sicherheitslücken identifizieren. Dies gewährleistet die Zuverlässigkeit und Sicherheit des Codes.</p>
<p><strong>Automatisierte Entwicklung mit GitLab Duo Workflow:</strong> <a href="https://about.gitlab.com/de-de/blog/meet-gitlab-duo-workflow-the-future-of-ai-driven-development/">GitLab Duo Workflow</a> transformiert die Softwareentwicklung, indem es repetitive Aufgaben automatisiert und Entwickler(innen) ermöglicht, sich auf innovative Problemlösungen zu konzentrieren.</p>
<p><a href="https://about.gitlab.com/de-de/gitlab-duo/">Teste GitLab Duo jetzt kostenlos!</a></p>
<h2>FAQs - Generative KI</h2>
<h3>Was ist der Unterschied zwischen AI und KI?</h3>
<p>Es gibt keinen Unterschied zwischen AI und KI. „AI” steht für „Artificial Intelligence”, „KI” steht für „Künstliche Intelligenz” und ist der deutsche Begriff für AI. Häufig werden beide Begriffe verwendet – die Bedeutung ist jedoch immer dieselbe.</p>
<h3>Wo wird generative KI angewendet?</h3>
<p>Generative KI findet Anwendung in der Content-Erstellung, bei Designprozessen, in der Medizin zur Analyse und Modellierung, in der Softwareentwicklung für automatisierte Codegenerierung und in der Unterhaltungsindustrie zur Erstellung von Filmen, Musik und Spielen.</p>
<h3>Was unterscheidet generative KI von klassischer KI?</h3>
<p>Klassische KI verarbeitet und analysiert Daten, um Entscheidungen zu treffen oder Prozesse zu automatisieren. Generative KI hingegen erschafft eigenständig neue Inhalte, die sich an den erlernten Daten orientieren, aber originell und innovativ sind.</p>
<h3>Welche Arten von generativer KI gibt es?</h3>
<p>Zu den gängigen Modellen gehören GANs, Transformermodelle, Variational Autoencoders und Diffusionsmodelle. Jedes Modell ist auf spezifische Anwendungen wie die Generierung von Texten, Bildern oder Audio spezialisiert.</p>
<h3>Wie sicher ist generative KI?</h3>
<p>Die Sicherheit generativer KI hängt stark von ihrem Einsatz ab. Während sie viele positive Anwendungen hat, können Risiken wie die Erstellung von Falschinformationen oder urheberrechtliche Konflikte auftreten, wenn sie nicht verantwortungsvoll genutzt wird.</p>
<h3>Welche Herausforderungen gibt es bei generativer KI?</h3>
<p>Herausforderungen umfassen den hohen Rechenaufwand, die Qualität der Trainingsdaten, ethische Fragen wie Bias in Modellen und mögliche Missbrauchsrisiken, etwa durch die Generierung manipulativer Inhalte.</p>
<h3>Wie wird generative KI bei GitLab eingesetzt?</h3>
<p>GitLab nutzt generative KI, um Entwicklungsprozesse zu optimieren. Sie wird unter anderem für automatisierte Code-Vorschläge, Dokumentationserstellung und Fehlerbehebung eingesetzt, wodurch Entwickler(innen) Zeit sparen und effizienter arbeiten können.</p>
]]></content>
        <author>
            <name>GitLab Germany Team</name>
            <uri>https://about.gitlab.com/blog/authors/gitlab-germany team</uri>
        </author>
        <published>2025-04-16T00:00:00.000Z</published>
    </entry>
    <entry>
        <title type="html"><![CDATA[20 Jahre GitLab: Begib dich mit uns auf eine Reise]]></title>
        <id>https://about.gitlab.com/de-de/blog/journey-through-gits-20-year-history/</id>
        <link href="https://about.gitlab.com/de-de/blog/journey-through-gits-20-year-history/"/>
        <updated>2025-04-14T00:00:00.000Z</updated>
        <content type="html"><![CDATA[<p>Das Git-Projekt ist gerade 20 Jahre alt geworden. In diesen Jahren ist viel passiert – während das konzeptionelle Design von <a href="https://about.gitlab.com/de-de/">GitLab</a> seit seiner Entstehung nicht wesentlich verändert wurde, hat sich doch die Art und Weise, wie Benutzer(innen) mit dem Tool interagieren, deutlich geändert. Wir bei GitLab sind stolz darauf, auf dieser wichtigen Software aufzubauen und Teil ihrer Erfolgsgeschichte zu sein.</p>
<p>Begleite uns auf einer Reise durch die Geschichte von Git und entdecke, wie sich das System im Laufe der Jahre entwickelt hat.</p>
<h2>Der erste Commit</h2>
<p>Der erste Commit wurde am 7. April 2005 von <a href="https://about.gitlab.com/de-de/blog/celebrating-gits-20th-anniversary-with-creator-linus-torvalds/">Linus Torvalds</a>, dem Schöpfer des Linux-Kernels, vorgenommen: <code>e83c5163316 (Initial revision of &quot;git&quot;, the information manager from hell, 2005-04-07)</code>.</p>
<p>Wie wir sehen können, enthält dieser Commit nicht viele Dateien:</p>
<pre><code class="language-shell">$ git ls-tree e83c5163316
100644 blob a6bba79ba1f46a1bbf7773449c3bd2bb9bf48e8b	Makefile
100644 blob 27577f76849c09d3405397244eb3d8ae1d11b0f3	README
100644 blob 98a32a9ad39883c6d05a000a68511d4b1ee2b3c7	cache.h
100644 blob 74a0a234dd346fff51c773aa57d82fc4b83a8557	cat-file.c
100644 blob 840307af0cfaab31555795ce7175d5e9c9f981a0	commit-tree.c
100644 blob 25dc13fe101b219f74007f3194b787dd99e863da	init-db.c
100644 blob c924a6e0fc4c36bad6f23cb87ee59518c771f936	read-cache.c
100644 blob 1b47742d8cbc0d98903777758b7b519980e7499e	read-tree.c
100644 blob b8522886a15db861508fb6d03d4d88d6de912a4b	show-diff.c
100644 blob 5085a5cb53ee52e1886ff6d46c609bdb2fc6d6cd	update-cache.c
100644 blob 921f981353229db0c56103a52609d35aff16f41b	write-tree.c
</code></pre>
<p>Neben der Build-Infrastruktur bietet der erste Commit sieben Top-Level-Befehle:</p>
<ul>
<li><code>init-db</code> zum Initialisieren eines neuen Git-Repositorys</li>
<li><code>update-cache</code> zum Hinzufügen von Dateien zum Index</li>
<li><code>write-tree</code>, um den Inhalt des Index heranzuziehen und daraus einen neuen Baum zu erstellen</li>
<li><code>read-tree</code> zum Lesen eines Baum-Objekts</li>
<li><code>commit-tree</code> zum Erstellen eines Commits aus einem Baum</li>
<li><code>cat-file</code> zum Lesen eines spezifischen Objekts in eine temporäre Datei</li>
</ul>
<p>Beachte, dass der Befehl <code>git</code> zu der Zeit noch gar nicht existierte.</p>
<p>Stattdessen mussten diese Befehle direkt ausgeführt werden.</p>
<p>Erstellen wir zum Beispiel ein neues Repository:</p>
<pre><code class="language-shell">$ mkdir repo
$ cd repo
$ init-db
defaulting to private storage area
$ ls -a
.  ..  .dircache
</code></pre>
<p>Das sieht ziemlich unbekannt aus: Es gibt kein <code>.git</code>-Verzeichnis, aber dafür gibt es das Verzeichnis <code>.dircache</code>. Und wo war der private Speicherbereich?</p>
<p>Das frühe Design von Git unterschied zwischen einem „geteilten“ und einem „privaten“ Objektspeicherbereich. In diesem Objektspeicherbereich befanden sich alle Git-Objekte. Zum Beispiel deine Commits und Blobs.</p>
<p>Standardmäßig erstellte <code>init-db</code> einen privaten Objektspeicherbereich, der nur für das verwaltete Verzeichnis verwendet wurde, in dem es erstellt wurde. Ein „geteilter“ Objektspeicherbereich hingegen teilte Objektinhalte über mehrere verwaltete Verzeichnisse, so dass dasselbe Objekt nicht zweimal gespeichert werden musste.</p>
<h3>Einen Commit erstellen</h3>
<p>Wir haben nun ein Repository, doch wie wurde damals ein Commit erstellt? Das war nicht ganz so einfach wie heute mit <code>git add . &amp;&amp; git commit</code>. Stattdessen musste man wie folgt vorgehen:</p>
<ol>
<li>Man musste den Index aktualisieren, indem man <code>update-cache</code> für jede Datei aufrief, die man hinzufügen wollte.</li>
<li>Dann schrieb man einen neuen Baum, indem man <code>write-tree</code> aufrief, wodurch alles herangezogen wurde, was zum Index hinzugefügt worden war.</li>
<li>Man richtete Umgebungsvariablen ein, um Git mitzuteilen, wer man ist.</li>
<li>Dann schrieb man ein Commit-Objekt, indem man <code>commit-tree</code> aufrief.</li>
</ol>
<p>Erstellen wir einen Commit im Repository:</p>
<pre><code class="language-shell">$ echo content-1 &gt;file-a
$ update-cache file-a
$ echo content-2 &gt;file-b
$ update-cache file-b
$ write-tree
3f143dfb48f2d84936626e2e5402e1f10c2050fb
$ export COMMITTER_NAME=&quot;Patrick Steinhardt&quot;
$ export COMMITER_EMAIL=ps@pks.im
$ echo &quot;commit message&quot; | commit-tree 3f143dfb48f2d84936626e2e5402e1f10c2050fb
Committing initial tree 3f143dfb48f2d84936626e2e5402e1f10c2050fb
5f8e928066c03cebe5fd0a0cc1b93d058155b969
</code></pre>
<p>Das ist nicht gerade ergonomisch, aber es funktioniert! Werfen wir einen Blick auf den generierten Commit:</p>
<pre><code class="language-shell">$ cat-file 5f8e928066c03cebe5fd0a0cc1b93d058155b969
temp_git_file_rlTXtE: commit
$ cat temp_git_file_rlTXtE
tree 3f143dfb48f2d84936626e2e5402e1f10c2050fb
author Patrick Steinhardt &lt;ps@pks.im&gt; Wed Mar 26 13:10:16 2025
committer Patrick Steinhardt &lt;ps@pks.im&gt; Wed Mar 26 13:10:16 2025

commit message
</code></pre>
<p>Beachte, dass <code>cat-file</code> den Inhalt nicht direkt gedruckt hat, sondern ihn zuerst in eine temporäre Datei geschrieben hat. Der Inhalt der Datei sieht jedoch genauso aus, wie ein moderner Commit aussehen würde.</p>
<h3>Änderungen vornehmen</h3>
<p>Wie können wir nun den Status der Dateien ermitteln? Vielleicht hast du es erraten: mit <code>show-diff</code>:</p>
<pre><code class="language-shell">$ show-diff
file-a: ok
file-b: ok

$ echo modified-content &gt;file-a
$ show-diff
--- -	2025-03-26 13:14:53.457611094 +0100
+++ file-a	2025-03-26 13:14:52.230085756 +0100
@@ -1 +1 @@
-content-1
+modified-content
file-a:  46d8be14cdec97aac6a769fdbce4db340e888bf8
file-b: ok
</code></pre>
<p>Lustigerweise konnte <code>show-diff</code> bereits diffs zwischen dem alten und neuen Zustand der geänderten Datei generieren! Git hat das jedoch erreicht, indem es einfach das Unix-Tool diff(1) ausgeführt hat.</p>
<p>Zusammenfassend lässt sich sagen, dass dies zwar alles noch recht spartanisch war, aber das Nötige bot, um den Verlauf nachzuverfolgen. Es gab aber noch viele Einschränkungen:</p>
<ul>
<li>Es gab noch keine einfache Möglichkeit, zwischen Commits zu wechseln.</li>
<li>Es gab keine Möglichkeit, Protokolle anzuzeigen.</li>
<li>Es gab keine Branches, Tags und nicht einmal Referenzen. Von den Benutzer(inne)n wurde erwartet, dass sie die Objekt-IDs manuell verfolgen.- Es gab keine Möglichkeit, zwei Repositories miteinander zu synchronisieren. Stattdessen wurde von den Benutzer(inne)n erwartet, dass sie „rsync(1)“ verwenden, um die <code>.dircache</code>-Verzeichnisse zu synchronisieren.</li>
<li>Es gab keine Möglichkeit, Merges durchzuführen.</li>
</ul>
<h2>Git 0.99</h2>
<p>Die erste Testversion von Git war Version 0.99. Diese Release kam nur zwei Monate nach dem ersten Commit auf, enthielt aber bereits 1.076 Commits. Es waren fast 50 verschiedene Entwickler(innen) beteiligt. Der häufigste Commiter war zu diesem Zeitpunkt Linus selbst, dicht gefolgt von Junio Hamano, dem aktuellen Betreuer.</p>
<p>Viele Dinge hatten sich seit dem ersten Commit geändert:</p>
<ul>
<li>Git begann, verschiedene Entwicklungs-Branches mithilfe von Referenzen zu verfolgen, wodurch in den meisten Fällen Objekt-IDs nicht mehr manuell nachverfolgt werden mussten.</li>
<li>Es gab ein neues Remote-Protokoll, das es zwei Repositories ermöglichte, Objekte miteinander auszutauschen.</li>
<li>Das Verzeichnis <code>.dircache</code> wurde in <code>.git</code> umbenannt.</li>
<li>Es wurde möglich, einzelne Dateien zusammenzuführen.</li>
</ul>
<p>Die wichtigste offensichtliche Änderung war jedoch die Einführung des Top-Level-Befehls <code>git</code> und seiner Unterbefehle. Interessanterweise wurden mit dieser Version auch die Befehle „Plumbing“ und „Porcelain“ eingeführt:</p>
<ul>
<li>„Plumbing“-Tools sind Low-Level-Befehle, die auf das zugrunde liegende Git-Repository zugreifen.</li>
<li>„Porcelain“-Tools sind Shell-Skripte, die die Plumbing-Befehle einpacken, um eine schönere, hochwertige Benutzeroberfläche zu bieten.Diese Aufteilung existiert auch heute noch, wie in <a href="https://git-scm.com/docs/git#_high_level_commands_porcelain"><code>git(1)</code></a> dokumentiert ist. Da die meisten Porcelain-Tools jedoch von Shell-Skripten zu C umgeschrieben wurden, verschwimmt die Trennung zwischen den beiden Kategorien mittlerweile deutlich.</li>
</ul>
<h2>Linus übergibt die Leitung</h2>
<p>Linus hat Git nie gegründet, weil sein Herz für Versionskontrollsysteme schlägt, sondern weil er für die Entwicklung des Linux-Kernels eine brauchbare Alternative zu BitKeeper suchte. Daher hatte er nie vor, Git für immer zu leiten. Die Absicht war, es so lange zu leiten, bis er eine(n) vertrauenswürdige(n) Nachfolger(in) gefunden hatte.</p>
<p>Dieser Jemand war Junio Hamano. Junio stieg etwa eine Woche nach dem ersten Commit von Linus bei Git ein und hatte nach der Veröffentlichung von Git 0.99 bereits einige hundert Commits im Verlauf. Am 26. Juli 2005 machte <a href="https://lore.kernel.org/git/Pine.LNX.4.58.0507262004320.3227@g5.osdl.org/">Linus daher Junio zum neuen Betreuer des Git-Projekts</a>. Linus trug zwar weiter zu Git bei, doch seine Beteiligung wurde nach und nach immer weniger – nicht verwunderlich, da er als Leiter des Linux-Projektes ziemlich beschäftigt ist.</p>
<p>Junio leitet das Git-Projekt auch heute noch.</p>
<blockquote>
<p>Lies unser großes <a href="https://about.gitlab.com/de-de/blog/celebrating-gits-20th-anniversary-with-creator-linus-torvalds/">Interview mit Linus Torvalds</a> und erfahre noch mehr über die Geschichte von Git.</p>
</blockquote>
<h2>Git 1.0</h2>
<p>Die erste größere Version von Git wurde am 21. Dezember 2005 von Junio veröffentlicht. Interessanterweise gab es 34 Releases zwischen Version 0.99 und Version 1.0: 0.99.1 bis 0.99.7, 0.99.7a bis 0.99.7d, 0.99.8 bis 0.99.8g und 0.99.9 bis 0.99.9n.</p>
<p>Einer der wichtigsten Meilensteine seit Version 0.99 war wahrscheinlich der Befehl <code>git-merge(1)</code>, der hinzugefügt wurde und mit dem man zwei Bäume zusammenführen kann. Dies ist eine enorme Veränderung zu vorher, wo man im Grunde die Zusammenführungen Datei für Datei skripten musste.</p>
<h3>Remotes</h3>
<p>Eine weitere wesentliche Änderung war die Einführung der Kurzschreibweise für Remote-Repositories. Während Git bereits wusste, wie man mit Remote-Repositories kommuniziert, mussten Benutzer(innen) jedes Mal die URL angeben, von der sie abrufen wollten, um Änderungen daran vorzunehmen. Dies war ziemlich unpraktisch für die Benutzer(innen), da sie im Normalfall immer wieder mit demselben Remote interagieren wollten.</p>
<p>Du weißt vielleicht, wie Remotes jetzt funktionieren, aber der Vorgang war damals noch deutlich anders. Es gab keinen <code>git-remote(1)</code>-Befehl, mit dem man seine Remotes verwalten konnte. Remotes wurden nicht einmal in der Datei <code>.git/config</code> gespeichert. Als Remotes in Version 0.99.2 eingeführt wurden, <em>gab</em> es in Git nicht einmal Konfigurationsdateien.</p>
<p>Stattdessen musste man Remotes konfigurieren, indem man eine Datei in das Verzeichnis <code>.git/branches</code> schrieb, was dem heutigen Empfinden nach gegen jegliche Intuition geht. Aber der Mechanismus funktioniert auch heute noch:</p>
<pre><code class="language-shell">$ git init repo --
Initialized empty Git repository in /tmp/repo/.git/
$ cd repo
$ mkdir .git/branches
$ echo https://gitlab.com/git-scm/git.git &gt;.git/branches/origin
$ git fetch origin refs/heads/master
</code></pre>
<p>Aber das ist noch nicht alles! Das Verzeichnis wurde bald darauf mit der Git-Version 0.99.5 in „remotes“ umbenannt, also gibt es in einem modernen Git-Client insgesamt drei verschiedene Möglichkeiten, Remotes zu konfigurieren.</p>
<p>Die meisten von euch haben wahrscheinlich weder <code>.git/branches</code> noch <code>.git/remotes</code> verwendet, denn beide Mechanismen gelten seit 2005 bzw. 2011 als veraltet. Darüber hinaus werden diese Verzeichnisse in Git 3.0 endgültig entfernt.</p>
<h2>Git-Branding</h2>
<p>Im Jahr 2007 wurde das erste Git-Logo erstellt. Ob man das schon als Logo bezeichnen kann, ist fraglich, da es nur aus drei roten Minuszeichen über drei grünen Pluszeichen bestand. Dies sollte widerspiegeln, wie die Ausgabe von <code>git diff</code> aussah:</p>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097388/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097387927.png" alt="Drei rote Minuszeichen über drei grünen Pluszeichen, die die Ausgabe von  widerspiegeln"></p>
<p>Etwas später, im Jahr 2008, wurde die Website <a href="https://git-scm.com">git-scm.com</a> veröffentlicht:</p>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097388/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750097387930.png" alt="Startseite für git-scm.com im Jahr 2006"></p>
<p>Im Jahr 2012 wurde die Git-Webseite von Scott Chacon und Jason Long <a href="https://lore.kernel.org/git/CAP2yMaJy=1c3b4F72h6jL_454+0ydEQNXYiC6E-ZeQQgE0PcVA@mail.gmail.com/">überarbeitet</a>. Sie sieht ziemlich ähnlich aus wie heute:</p>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097388/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097387932.png" alt="Die Git-Website wurde 2012 überarbeitet"></p>
<p>Dieses neue Design der Website weist das neue rot-orangefarbene Logo von Jason Long auf, das auch derzeit verwendet wird:</p>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097388/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097387934.png" alt="Git-Logo"></p>
<h2>Git 2.0</h2>
<p>Git begann schon in der Version 1.0, dem modernen Git sehr ähnlich zu sehen. Daher folgt nun der große historische Sprung zu Git 2.0. Diese Version wurde etwa 10 Jahre nach Git 1.0 veröffentlicht und war die erste Version, die absichtlich abwärtskompatible Änderungen in zentralen Workflows enthielt.</p>
<h3>Standardverhalten von <code>git-push(1)</code></h3>
<p>Die Änderung, die wohl die meiste Verwirrung in dieser Version verursachte, war das geänderte Standardverhalten von <code>git-push(1)</code>.</p>
<p>Es gibt ein paar verschiedene Aktionen, die Git ausführen kann, wenn du in ein Remote-Repository pusht und nicht genau angibst, was genau du pushen möchtest:</p>
<ul>
<li>Git kann verweigern, irgendetwas zu tun, und bittet dich um weitere Informationen darüber, was genau du pushen möchtest.</li>
<li>Git kann den aktuell ausgecheckten Branch pushen.</li>
<li>Git kann den aktuell ausgecheckten Branch pushen, aber nur, wenn es weiß, dass es ein Äquivalent auf der Remote-Seite gibt.</li>
<li>Git kann alle deine Branches pushen, die ein Äquivalent auf der Remote-Seite haben.</li>
</ul>
<p>Das Verhalten des modernen Git ist die sogenannte „einfache“ Strategie, also die dritte der oben angeführten Optionen. Vor Git 2.0 war das Standardverhalten jedoch die „Matching“-Strategie, also die letzte der genannten Optionen.</p>
<p>Die „Matching“-Strategie war deutlich riskanter. Man musste vor dem Pushen immer sicherstellen, dass es in Ordnung war, alle lokalen Branches zu pushen, die ein Äquivalent auf der Remote-Seite haben. Andernfalls hätte man möglicherweise unbeabsichtigt Änderungen gepusht. Daher wurde beschlossen, die Strategie auf die „einfache“ Strategie zu ändern, um das Risiko zu verringern und Einsteiger(inne)n die ersten Schritte mit Git zu erleichtern.</p>
<h3><code>git-add(1)</code></h3>
<p>Eine weitere große Änderung war das Standardverhalten von <code>git-add(1)</code> im Hinblick auf nachverfolgte Dateien, die gelöscht wurden. Vor Git 2.0 hätte <code>git-add(1)</code> gelöschte Dateien nicht automatisch gestaged, sondern du hättest jede gelöschte Datei manuell mit <code>git-rm(1)</code> hinzufügen müssen, damit sie Teil des Commits ist. Mit Git 2.0 wurde dieses Verhalten geändert, sodass <code>git-add(1)</code> auch gelöschte Dateien zum Index hinzufügt.</p>
<h2>Wir feiern die Git-Community</h2>
<p>Ich werde dich nicht mit Details darüber langweilen, wie Git heute funktioniert – du nutzt es wahrscheinlich ohnehin täglich, und wenn nicht, gibt es viele tolle Tutorials, die dir beim Einstieg helfen. Stattdessen wollen wir die Git-Community hochleben lassen – sie ist es nämlich, dank der Git auch 20 Jahre später noch wunderbar funktioniert.</p>
<p>Im Laufe der Zeit hat Git:</p>
<ul>
<li>56 721 Commits seit der Veröffentlichung von Git 2.49 erhalten.</li>
<li>Beiträge von mehr als 2 000 verschiedenen Personen erhalten.</li>
<li>60 Hauptversionen veröffentlicht.Das Git-Projekt hat auch einen stetigen Zustrom neuer Mitwirkender durch die Teilnahme am <a href="https://summerofcode.withgoogle.com/">Google Summer of Code</a> und <a href="https://www.outreachy.org/">Outreachy</a> erfahren. Neue Mitwirkende wie diese werden dafür sorgen, dass das Git-Projekt auch langfristig weitergeführt wird.</li>
</ul>
<p>Daher möchte ich allen Mitwirkenden von Herzen danken. Es sind eure Beiträge, die Git erst möglich gemacht haben.</p>
<h2>Ein Blick in die Zukunft</h2>
<p>Es steht außer Frage, dass Git den Wettlauf um das beste Versionskontrollsystem gewonnen hat. Es hat einen bedeutenden Marktanteil, und es ist nicht einfach, Open-Source-Projekte zu finden, die ein anderes Versionskontrollsystem als Git verwenden. Git hat also eindeutig vieles richtig gemacht.</p>
<p>Dennoch ist die Entwicklung nicht stillgestanden und auch in Zukunft werden viele Herausforderungen auf Git warten. Einerseits sind das technische Herausforderungen:</p>
<ul>
<li>Modernisierung einer alternden Codebasis</li>
<li>Skalierung mit der ständig wachsenden Größe von Monorepos</li>
<li>Bessere Handhabung großer Binärdateien</li>
</ul>
<p>Andererseits tauchen Probleme sozialer Art auf:</p>
<ul>
<li>Verbesserung der Benutzerfreundlichkeit von Git</li>
<li>Förderung der Git-Community, damit das Projekt langfristig gesund bleibt</li>
</ul>
<p>Es gibt immer noch viel zu tun und wir bei GitLab sind stolz darauf, Teil dieser Bemühungen zu sein. Gemeinsam können wir sicherstellen, dass Git auch in den nächsten 20 Jahren ein so fantastisches Versionskontrollsystem bleibt.</p>
<h2>Erfahre mehr über Git</h2>
<ul>
<li><a href="https://about.gitlab.com/de-de/blog/celebrating-gits-20th-anniversary-with-creator-linus-torvalds/">Wir feiern das 20-jährige Git-Jubiläum mit dessen Erfinder Linus Torvalds</a></li>
<li><a href="https://about.gitlab.com/de-de/blog/whats-new-in-git-2-49-0/">Was gibt es Neues in Git 2.49.0?</a></li>
<li><a href="https://about.gitlab.com/de-de/blog/whats-new-in-git-2-48-0/">Was gibt es Neues in Git 2.48.0?</a></li>
<li><a href="https://about.gitlab.com/de-de/blog/a-beginners-guide-to-the-git-reftable-format/">Der Anfängerleitfaden zum „reftable“-Format von Git</a></li>
</ul>
]]></content>
        <author>
            <name>Patrick Steinhardt</name>
            <uri>https://about.gitlab.com/blog/authors/patrick-steinhardt</uri>
        </author>
        <published>2025-04-14T00:00:00.000Z</published>
    </entry>
    <entry>
        <title type="html"><![CDATA[Linux-Server: Warum sich die Installation lohnt]]></title>
        <id>https://about.gitlab.com/de-de/blog/what-is-a-linux-server/</id>
        <link href="https://about.gitlab.com/de-de/blog/what-is-a-linux-server/"/>
        <updated>2025-04-14T00:00:00.000Z</updated>
        <content type="html"><![CDATA[<h1>Linux-Server: Warum sich die Installation lohnt</h1>
<p>Server bilden die Basis des Internets. Und Linux bildet weltweit die Basis für die meisten Server. Seit der Entwicklung von Linux hat sich das Betriebssystem gegenüber weitaus größeren Konkurrenten wie Microsoft nicht nur behaupten, sondern seine Vormachtstellung sogar weiter ausbauen können.</p>
<p>In diesem Artikel gehen wir auf alle Aspekte eines Linux-Servers ein. Wir wägen Vorteile eines Linux-Servers gegen eventuelle Nachteile ab und stellen dir alle kostenfreien und kommerziellen Varianten („Distributionen“) vor, die aktuell erhältlich sind. Wir zeigen dir, wie du einen Linux-Server verbindest und ein Backup erstellst.</p>
<p>In der Softwareentwicklung und generell bei DevOps-Projekten eignet sich GitLab besonders gut für die Nutzung auf einem Linux-Server. Dafür gibt es sehr gute Gründe, die wir dir ebenfalls gerne vorstellen möchten.</p>
<h2>Was ist ein Linux-Server?</h2>
<p><strong>Ein Linux-Server ist ein Server, der Linux OS als Betriebssystem nutzt. Bei Linux handelt es sich um ein modulares, monolithisches OS („Operating System“), das in den frühen 1990ern von dem finnisch-amerikanischen Programmierer Linus Torvalds entwickelt wurde.</strong></p>
<ul>
<li>
<p><strong>„Modular“</strong> bezieht sich darauf, dass Linux sowohl um einige Komponenten reduziert, als auch um neue erweitert werden kann, ohne seine Funktionsfähigkeit zu verlieren.</p>
</li>
<li>
<p>Gleichzeitig aber ist Linux <strong>„monolithisch“</strong>, was bedeutet, dass der Kern (Kernel) des Betriebssystems nicht geteilt werden kann. Schlankere Ansätze wie beispielsweise Minix arbeiten hingegen mit einem Microkernel, der stets nur die Module nutzt, die wirklich benötigt werden.</p>
</li>
</ul>
<p>Torvalds konzipierte sein eigenes System von Anfang an als Open-Source-Projekt und legte den Quellcode offen. Das bedeutet: Grundsätzlich kannst du Linux in seiner grundlegenden Basisversion nutzen, ohne Lizenzgebühren abzuführen.</p>
<h2>Was ist ein Windows-Server?</h2>
<p>Ein Windows-Server ist ein Server, der Microsoft Windows als Betriebssystem nutzt. Dies ist kein Artikel über Microsoft-Server, aber ein kurzer Blick auf ihre Architektur ist hilfreich um zu verstehen, was Linux-Server ausmacht und worauf es sich bei der Auswahl des für dich passenden OS zu achten lohnt.</p>
<p>Auch Microsoft Windows ist monolithisch und eingeschränkt modular. Allerdings nutzt Windows ein grafisches Benutzer-Interface („GUI“), während Linux zumindest in seiner Basisvariante ein Command-Line-Interface („CLI“) verwendet – also über Text und Code angesteuert wird.</p>
<p>Das GUI macht Windows weitaus intuitiver in der Anwendung. GUIs aber verbrauchen sehr viel Arbeitsspeicher und machen das System somit weitaus langsamer und weniger effizient.</p>
<p>Der zweite wichtige Unterschied besteht darin, dass Windows geschlossen und sein Quellcode somit nicht frei einsehbar ist. Daraus ergibt sich eine Vielzahl von Konsequenzen, die größtenteils erklären, weshalb es Microsoft bis heute nicht gelungen ist, das Quasi-Monopol von Linux im Serverbereich aufzubrechen.</p>
<h2>Linux-Server: Vorteile und Entscheidungsgrundlagen</h2>
<p>Wie erwähnt ist Linux weltweit führend bei Server-Betriebssystemen. Aktuellen Schätzungen zufolge hatte Linux hier einen Marktanteil von über 80 %. Trotzdem sind sich Expert(inn)en      einig darüber, dass Linux nicht in jedem Fall die beste Wahl ist.</p>
<p><strong>Ob eine Linux-Architektur für dich geeignet ist, kannst du anhand von vier Kriterien entscheiden:</strong></p>
<p><strong>- Stabilität</strong></p>
<p><strong>- Sicherheit</strong></p>
<p><strong>- Skalierbarkeit und Kundenorientierung</strong></p>
<p><strong>- Kosten</strong></p>
<p>In den folgenden Abschnitten sehen wir uns diese Punkte genauer an, um dir zu zeigen, wie die Vorteile eines Linux-Servers in der Praxis aussehen.</p>
<h2>Stabilität</h2>
<p>Monolithische Server sind sehr leistungsfähig. Aber sie sind nicht die stabilste Option.</p>
<p>Weil stets der gesamte Kernel genutzt wird, können selbst kleine Fehler in einem isolierten Teil des Betriebssystems zum Absturz führen. Wer wurde nicht schon einmal von dem blauen Bildschirm in Windows „überrascht“! Gerade wenn auf einem Server wichtige Daten liegen oder wenn über ihn eine Website läuft, können sogar kurzzeitige Aussetzer zu hohen Gewinnausfällen oder Kosten führen.</p>
<p>Linux umgeht dieses grundlegende Problem mit einer äußerst schlanken Architektur, die auch der Geschwindigkeit des OS zugutekommt. Diese Leichtigkeit beansprucht weniger Hardware-Ressourcen und stabilisiert das monolithische System auf eine sehr überzeugende Weise.</p>
<p>Darüber hinaus kommt Linux sein offener Quellcode und die Einbettung in die Open-Source-Comunity zugute. Seit 30 Jahren tauschen sich Entwickler(innen) und Systemadministrator(inn)en täglich zu Problemen und Lösungen aus. Sogar akute, schwere Ausfälle können so oftmals schnell behoben werden.</p>
<p>Die „Uptime“ von Linux-Servern, also die Zeit, die ein Server am Stück und ohne Ausfälle online ist, ist bemerkenswert. Bei einigen Linux-Distributionen sind Zeiten von über einem Jahr keine Seltenheit.</p>
<h2>Sicherheit</h2>
<p>Sicherheit ist für die meisten Unternehmen neben der Stabilität und Performance der wichtigste Betrachtungspunkt bei der Serverwahl.</p>
<p>Linux wurde von Anfang an mit einigen Features versehen, die das Betriebssystem besonders gut vor eventuellen Angriffen oder ungewünschter Datennutzung schützen. Hier findet sich bereits ein erster Überschneidungspunkt mit der GitLab-Philosophie, bei der Planungseffizienz, Kundenorientierung und Sicherheit stets Hand in Hand gehen.</p>
<p>Dazu gehört das standardmäßige Absichern eines Downloads mit einer erzwungenen (Root-)Passwortabfrage oder auch das Abgleichen eines Downloads mit einer Liste als sicher geltender Webseiten.</p>
<p>Besonders vorteilhaft ist, dass Updates auf Linux-Servern im laufenden Betrieb direkt implementiert werden können. Windows verlangt hierzu einen Neustart. Das wird einige Administrator(inn)en dazu verleiten, Updates zu verschieben und damit die Uptime gegenüber      der Sicherheit zu priorisieren. Solche Konflikte entstehen bei Linux nicht.</p>
<h2>Kosten</h2>
<p>Linux ist als Open-Source-Produkt grundsätzlich kostenfrei nutzbar. Die Nutzung von Windows wird über eine Server-Lizenz abgeglichen. So erscheint Linux als die ideale Option für alle, die ihre Kosten möglichst niedrig halten möchten.</p>
<p>In Wahrheit sind die Kostenunterschiede in der Praxis jedoch nicht so auffällig. In seiner einfachsten Variante erfordert Linux beispielsweise gut geschulte Administrator(inn)en, die mit diesem System arbeiten und es für den konkreten Praxiseinsatz konfigurieren können.</p>
<p>Auch bedarf es einer gewissen Erfahrung, den Kontakt mit der Linux-Community zu nutzen. Hier sind die Support- und Sicherheitspakete kommerzieller Anbieter gelegentlich günstiger.</p>
<p>Der wahre Grund, warum so viele Betriebe auf Linux setzen, ist vielmehr ein anderer:</p>
<h2>Skalierbarkeit und Kundenorientierung</h2>
<p>Eine häufig genannte Statistik ist die Dominanz des Linux OS im Supercomputer-Bereich, also seinem Einsatz auf den 500 schnellsten Rechnern der Welt. Hier nähert sich der Wert seit vielen Jahren immer mehr den 100 % an. Tatsächlich wenden gerade große Unternehmen verschiedene Linux-Distributionen besonders gerne an.</p>
<p>Sicherlich ist Skalierbarkeit kein Alleinstellungsmerkmal von Linux. Wohl aber wird das traditionelle kommerzielle Lizenzmodell von Windows gerade für rasch wachsende Unternehmen zum Kostenfaktor. Linux hingegen bietet aufgrund seiner inhärent modularen Konstruktion einfache Aufstockungsoptionen – ohne deinen Betrieb dabei finanziell übermäßig zu belasten.</p>
<p>Allerdings brauchen auch mittelgroße und kleine Unternehmen nicht zwangsläufig auf Windows zu setzen. Schließlich wurde Torvalds ursprünglich unter anderem dazu motiviert, Linux zu entwickeln, um die Funktionalität eines großen Servers auf sehr moderater Hardware zu liefern.</p>
<h2>Was sind “Linux-Distributionen”?</h2>
<p>In seiner Basis-Variante wird Linux sich nur für wenige Unternehmen eignen. Sogar, wenn du die Kosten so niedrig wie möglich halten möchtest, wirst du sehr wahrscheinlich einige Anpassungen vornehmen müssen.</p>
<p>Um dir diese Arbeit abzunehmen und um Linux an deine spezifischen Bedürfnisse anzupassen, haben sich feste Systemkonfigurationen herauskristallisiert. Alle nutzen den Linux-Kernel als Ausgangspunkt und haben ihn um gewisse Elemente und Features erweitert.</p>
<p>Die beliebtesten, offiziell unterstützen Pakete sind Ubuntu, Debian, CentOS, AlmaLinux, Amazon Linux, OpenSUSE Leap und Raspberry Pi OS. Jede dieser Linux-Distributionen hat ihre eigenen Vor- und Nachteile. Sehen wir sie uns der Reihe nach an.</p>
<h2>Linux-Distribution #1: Ubuntu</h2>
<p>Ubuntu ist einer der frühesten Linux-Distributionen. Daraus ergibt sich auch unmittelbar einer seiner Hauptvorteile: Die Ubuntu-Community ist global und groß und eventuelle Fragen können in der Regel schnell und effizient beantwortet werden.</p>
<p>Ubuntu ist noch immer eine hervorragende Möglichkeit, in die Linux-Welt einzusteigen – auch wenn es inzwischen intuitivere Alternativen gibt. Das User Interface erfordert eine gewisse Einarbeitungs- und Eingewöhnungsphase, ist aber keineswegs komplex und zudem sehr logisch aufgebaut.</p>
<p>Für Privatnutzer ist Ubuntu kostenlos. Die verschiedenen Lizenzlevels für eine kommerzielle Nutzung sind an die Möglichkeiten der jeweiligen Nutzer(innen) angepasst.</p>
<h2>Linux-Distribution #2: Debian</h2>
<p>Debian ist die wohl langlebigste Linux-Distribution. In vielen Ländern, darunter auch Deutschland, bleibt sie die meistgenutzte Linux-Umsetzung für Server.
Dieser Erfolg beruht auf der unvergleichlichen Sicherheit und Stabilität von Debian, die seinesgleichen sucht.</p>
<p>Gerade weil Debian so zuverlässig ist, nutzen viele Entwickler(innen) es, um um seinen Core herum eine neue Distribution zu entwickeln. Doch bleibt auch 2024 das ursprüngliche Debian für Linux-Server eine hervorragende Wahl.</p>
<p>Alternativ steht dir mit Raspberry Pi OS ein exzellenter Debian-Klon zur Verfügung.</p>
<h2>Linux-Distribution #3: CentOS</h2>
<p>Nach Ubuntu ist CentOS die weltweit beliebteste Linux-Distribution. Von RedHat entwickelt zeichnet sich auch CentOS vor allem durch seine Stabilität und Sicherheit aus. Auch seine einfache Kontrolle und Skalierbarkeit sind hervorzuheben. Und im direkten Vergleich mit anderen Distributionen fällt die bemerkenswerte Geschwindigkeit auf, die für viele Anwender(innen) ein absolutes Alleinstellungsmerkmal darstellt.</p>
<p>Leider wurde der Support von CentOS für Linux eingestellt. Damit werden zwar nicht sofort alle mit dieser Distribution ausgestatteten Server obsolet, zum      Einstieg eignet sich CentOS nach aktuellem Stand aber nicht mehr.</p>
<h2>Linux-Distribution #4: AlmaLinux</h2>
<p>Die Ansprüche von AlmaLinux sind hoch. So hat sich diese Linux Distribution zum Ziel gesetzt, den Status eines Enterprise-Level-Betriebssystems zu erreichen. Um diese Auszeichnung tragen zu dürfen, müssen bestimmte, hohe Kriterien in Bezug auf die Sicherheit und Funktionalität des Systems erreicht werden und es muss durch außenstehende Dienstleister verwaltet und gewartet werden können.</p>
<p>Damit bietet AlmaLinux das volle Leistungspaket für Unternehmen jeder Größenordnung, bleibt aber wegen seines OpenSource-Ansatzes weiter kostenfrei. Durch seine Einbindung in die CentOS-Architektur wird es zudem regelmäßig aktualisiert.</p>
<p>Nachteilig wirkt sich allerdings aus, dass die zeitlichen Abstände zwischen neuen Versionen dieser Linux-Distribution eher lang ausfallen. Darüber hinaus ist die Softwareumgebung für Alma eher klein. Das bedeutet, dass du für bestimmte Herausforderungen in deinem Betrieb möglicherweise nicht die passende Lösung findest.</p>
<h2>Linux-Distribution #5: Amazon Linux</h2>
<p>Amazon ist einer der jüngsten Anbieter im Linux-Bereich. Bei Amazon Linux dreht sich alles um die Einbindung in die Amazon Web Services (AWS). Daraus ergeben sich Vorteile in Sachen Kosten und Performance.</p>
<p>Andererseits bedeutet diese enge Verknüpfung auch, dass dir für eventuelle Unterstützung nur eine kleine Community zur Verfügung steht. Das könnte der Grund dafür sein, dass, trotz der Marktmacht, die Amazon hat, das vom Online-Retailer angebotene OS bisher nur einen Anteil von einem halben Prozent erlangt hat.</p>
<h2>Linux-Distribution #6: OpenSUSE Leap</h2>
<p>Das deutsche Unternehmen SUSE hat mit dieser Distribution eine der derzeit beliebtesten neuen Linux-Distributionen vorgelegt. Gerade unter Software-Entwickler(inne)n genießt es eine sehr hohe Wertschätzung.</p>
<p>OpenSUSE Leap macht einiges anders als andere Distributionen. Dazu gehört der hervorragende Package Manager sowie ein optionales grafisches Interface (GUI). Auch in Sachen Sicherheit hat es einigen der etablierteren Distributionen den Rang abgelaufen.</p>
<h2>GitLab und Linux-Server</h2>
<p>Bei Git handelt es sich um eine Softwareentwicklungs- und Kollaborationsplattform, die eng mit der agilen Methodologie verknüpft ist. Es mag noch andere Version-Control-Programme geben, doch keines ist so gut für den Einsatz auf einem Linux-Server geeignet wie Git.</p>
<p>Dafür reicht ein kurzer Blick in die Geschichte von Git aus. So wurde die Plattform ebenfalls von Linus Torvalds geschrieben, ganz spezifisch für einen Einsatz auf einem Linux-OS. Daraus ergibt sich eine enge Abstimmung, die eine optimale Performance garantiert.</p>
<p>GitLab ist eine der weltweit führenden Git-Plattformen und ergänzt den dahintersteckenden DevOps-Gedanken noch um eine besondere Betonung des Themas Sicherheit.
Um GitLab unter Linux zu nutzen, richte zunächst den Linux-Server ein und installiere anschließend GitLab.</p>
<h2>Einen Linux-Server einrichten</h2>
<p>Jede der genannten Linux-Distributionen hat ihre Eigen- und Besonderheiten.</p>
<p><strong>Das Einrichten und Verbinden eines Linux-Servers allerdings folgt jeweils einem nahezu identischen Ablauf:</strong></p>
<p><strong>- Lade die aktuelle Version der jeweiligen Software auf deinen Rechner und erstelle ein Boot-Medium – entweder auf einem optischen Träger oder einem USB-Stick.</strong></p>
<p><strong>- Verbinde das Boot-Medium mit deinem Linux-Server und installiere die Software.</strong></p>
<p><strong>- Installiere anschließend den für dich passenden Datenbankserver, einen Webserver und lege die Skriptsprache fest.</strong></p>
<p><strong>- Nun kannst du noch eine grafische Benutzeroberfläche hinzufügen oder den Server über Text ansteuern.</strong></p>
<p>Installiere anschließend sämtliche weitere Software, die du benötigst.</p>
<h2>Einen Linux-Server sichern</h2>
<p>Nach dem Einrichten deines Linux-Servers läuft das Absichern genauso ab wie bei einem Standard-Desktop-PC.</p>
<p>Entscheidend ist, dass du das Linux-Server-Backup wirklich häufig und regelmäßig vornimmst und genau festlegst, was gesichert und was nicht gesichert werden soll. Weil auf Servern oftmals große Datenmengen gespeichert sind, kommt diesem Punkt hier eine noch höhere Bedeutung als im Heimbereich zu. Als Speicherort kann eine hochwertige zweite Festplatte dienen.</p>
<p>Wichtig ist die Wahl des besten Backup-Tools. In dieser Übersicht zu Server-Backups unter Linux werden die Vorteile und Nachteile einander anschaulich gegenübergestellt.</p>
<h2>GitLab auf einem Linux-Server nutzen</h2>
<p>Um von den Vorteilen einer GitLab-Nutzung unter Linux profitieren zu können, installiere den Git-Repository-Manager auf einer der obengenannten Distributionen deiner Wahl.</p>
<p><strong>Der Ablauf der Installation besteht dabei aus drei Schritten:</strong></p>
<p><strong>- Dem Installieren und Konfigurieren der verlangten externen Software und/oder Bibliotheken</strong></p>
<p><strong>- Dem Hinzufügen des GitLab-Repository und der Installation des Pakets.</strong></p>
<p><strong>- Dem Ausführen des Setups.</strong></p>
<p>Anschließend kannst du von den Funktionen von GitLab für deine Teamarbeit voll profitieren – zum Beispiel im Rahmen deiner Epics und User Stories.</p>
]]></content>
        <author>
            <name>GitLab Germany Team</name>
            <uri>https://about.gitlab.com/blog/authors/gitlab-germany team</uri>
        </author>
        <published>2025-04-14T00:00:00.000Z</published>
    </entry>
    <entry>
        <title type="html"><![CDATA[Verbesserte Qualitätssicherung von Anwendungen mit GitLab Duo Workflow]]></title>
        <id>https://about.gitlab.com/de-de/blog/use-gitlab-duo-workflow-to-improve-application-quality-assurance/</id>
        <link href="https://about.gitlab.com/de-de/blog/use-gitlab-duo-workflow-to-improve-application-quality-assurance/"/>
        <updated>2025-04-10T00:00:00.000Z</updated>
        <content type="html"><![CDATA[<p>Die Qualität deiner Anwendungen durch testbasiertes Design, gute Testabdeckung und Fehlererkennung sicherzustellen, ist für deine Kund(inn)en und deinen Ruf immens wichtig, kann aber auch ziemlich zeitaufwändig sein. <a href="https://about.gitlab.com/de-de/gitlab-duo/workflow/">GitLab Duo Workflow</a>, eine agentische KI, die auf der umfassendsten DevSecOps-Plattform aufbaut, kann dir dabei helfen, Entwicklungsaufgaben wie das Hinzufügen von Unit-Tests zu einer Java-Anwendung schnell zu erledigen. In diesem Tutorial siehst du anhand eines <a href="https://gitlab.com/gitlab-da/playground/csaavedra/gdw/prodmgr-gdw">Java-Beispielprojekts</a>, wie das geht.</p>
<blockquote>
<p>Der GitLab Duo Workflow befindet sich derzeit in der privaten Beta-Phase. Trag dich in die <a href="https://about.gitlab.com/de-de/gitlab-duo/workflow/">Warteliste</a> ein, um zu erfahren, was du mit KI-Tools, die deinen gesamten SDLC verstehen, alles machen kannst.</p>
</blockquote>
<h2>Öffne dein Projekt in VS Code</h2>
<ol>
<li>
<p>Öffne das Java-Projekt in Visual Studio Code (nachdem du es auf deinen lokalen Computer geklont hast). Stelle sicher, dass du dich in einem Feature-Branch befindest (nicht im main- oder default-Branch), bevor du beginnst. Wenn du schon an einem Merge Request arbeitest, hat dieser einen eigenen Feature-Branch.</p>
</li>
<li>
<p>(Dieser Schritt ist optional.) Gehe zu der Datei, die die Java-Klasse definiert, für die du mit GitLab Duo Workflow Unit-Tests erstellen möchtest. Sieh sie dir genau an, damit du später überprüfen kannst, ob die generierten Unit-Tests die Komponenten der Klasse abdecken. Das solltest du sehen:</p>
</li>
</ol>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097627/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097627482.png" alt="Datei, die die Java-Klasse definiert, für die du mit GitLab Duo Workflow Unit-Tests erstellen möchtest"></p>
<p><strong>Hinweis:</strong> Wir gehen davon aus, dass du die Erweiterung von GitLab Duo Workflow in VS Code bereits aktiviert hast. Wenn nicht, lies dir die <a href="https://docs.gitlab.com/user/duo_workflow/#use-workflow-in-vs-code">Einrichtungsdokumentation</a> durch (nur in englischer Sprache verfügbar).</p>
<ol start="3">
<li>Starte GitLab Duo Workflow, indem du die Befehlspalette von VS Code öffnest [Strg + Umschalt + P], „GitLab Duo Workflow“ eingibst und <strong>GitLab: Duo Workflow anzeigen</strong> auswählst. Es erscheint eine Registerkarte, die wie folgt aussieht:</li>
</ol>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097628/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097627483.png" alt="Starten von GitLab Duo Workflow mit VS Code"></p>
<ol start="4">
<li>Im nächsten Schritt fügst du Tests für den Standardkonstruktor, die Überprüfung der Objekterstellung und den Anfangszustand der Eigenschaften der Klasse „Product“ hinzu. Dazu gibst du den folgenden Prompt in den Textbereich in GitLab Duo Workflow ein:</li>
</ol>
<pre><code class="language-unset">Create unit tests for class defined in the Product.java file and store the unit tests in its own file titled ProductTest.java
</code></pre>
<p>(Erstelle Unit-Tests für die in der Datei „Product.java“ definierte Klasse und speichere die Unit-Tests in einer eigenen Datei mit dem Namen „ProductTest.java“.)</p>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097628/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750097627484.png" alt="Eingabe eines Prompts in GitLab Duo Workflow"></p>
<ol start="5">
<li>Klick in GitLab Duo Workflow auf die Schaltfläche <strong>Start</strong>. Es werden zwei neue Fenster angezeigt: eins in der Mitte des Bildschirms und eins rechts davon. Das rechte Fenster zeigt die Analyse an, die GitLab Duo Workflow durchführt, um einen Plan zu erstellen, mit dem das in deinem Prompt angegebene Ziel erreicht werden kann. Der Plan wird im mittleren Fenster angezeigt. Nach Abschluss der Analyse und der Planerstellung sollte eine Ausgabe wie die folgende angezeigt werden:</li>
</ol>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097627/Blog/Content%20Images/Blog/Content%20Images/image8_aHR0cHM6_1750097627486.png" alt="Von GitLab Duo Workflow generierte Analyse und Plan"></p>
<ol start="6">
<li>
<p>Sieh dir die Analyse und den Plan an und klick unten im Fenster auf <strong>Plan genehmigen</strong>, wenn du damit einverstanden bist.</p>
</li>
<li>
<p>GitLab Duo Workflow beginnt mit der Ausführung des genehmigten Plans und nimmt die entsprechenden Änderungen an deinem Projekt vor.</p>
</li>
<li>
<p>Sobald die Ausführung des Plans abgeschlossen ist, siehst du im Projekt ein neues Verzeichnis <code>src/test/java/csaa/jspring/ProductManager</code> mit einer neuen Datei mit dem Namen <code>ProductTest.java</code>, die alle Unit-Tests für die Klasse <code>Product.java</code> enthält.</p>
</li>
</ol>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097628/Blog/Content%20Images/Blog/Content%20Images/image7_aHR0cHM6_1750097627488.png" alt="Neues Verzeichnis im Projekt mit einem neuen Dateinamen „ProductTest.java“"></p>
<ol start="9">
<li>Navigiere zu der neu erstellten Datei <code>ProductTest.java</code>. Du wirst sehen, dass einige Importanweisungen rot unterstrichen sind, was auf Importfehler hinweist:</li>
</ol>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097628/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097627489.png" alt="„ProductTest.java“ enthält Importanweisungen und Fehleranzeigen in Rot"></p>
<p>GitLab Duo Workflow soll das für uns beheben.</p>
<p><strong>Hinweis:</strong> Wir hätten GitLab Duo Workflow auch in unserem ersten Prompt bitten können, die Datei <code>pom.xml</code> entsprechend zu aktualisieren. Da wir das aber nicht gemacht haben, beheben wir diese Fehler in einem neuen Workflow.</p>
<h2>Starten von GitLab Duo Workflow, um Fehler im generierten Code zu beheben</h2>
<ol start="10">
<li>Starte einen neuen Workflow, indem du unten im Analysefenster auf der rechten Seite deines Bildschirms auf die Schaltfläche <strong>Neuer Workflow</strong> klickst.</li>
</ol>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097628/Blog/Content%20Images/Blog/Content%20Images/image6_aHR0cHM6_1750097627491.png" alt="Schaltfläche „Neuer Workflow“"></p>
<ol start="11">
<li>Gib im Textbereich für den Prompt Folgendes ein:</li>
</ol>
<pre><code class="language-unset">The file ProductTest.java has an error “The import org.junit cannot be resolved”. Please fix it
</code></pre>
<p>(Die Datei „ProductTest.java“ hat einen Fehler: „Der Import org.junit kann nicht aufgelöst werden“. Bitte behebe diesen Fehler.)</p>
<ol start="12">
<li>Nachdem du den vorgeschlagenen Plan genehmigt hast, startet GitLab Duo Workflow seine Analyse, indem es die aktuelle <code>pom.xml</code>-Datei liest. Anschließend wird sie bearbeitet und die veraltete JUnit-Abhängigkeit entfernt. Danach werden die richtige Abhängigkeit und Version für JUnit hinzugefügt. Zuletzt wird die Datei <code>ProductTest.java</code> gelesen, um alle Abhängigkeitsfehler zu beheben.</li>
</ol>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097627/Blog/Content%20Images/Blog/Content%20Images/image5_aHR0cHM6_1750097627492.png" alt="GitLab Duo Workflow führt eine Analyse durch, indem es die Datei „pom.xml“ liest."></p>
<h2>Sieh dir das Tutorial an</h2>
<p>Durch die Ausführung dieses Plans führt GitLab Duo Workflow effektiv Aktualisierungen am Projekt durch, um die im Prompt geforderten Aufgaben zu erfüllen. Das spart Zeit und Aufwand und steigert die Produktivität, sodass Entwickler(innen) mehr Zeit für Innovationen und die Schaffung von Mehrwert für ihr Unternehmen aufwenden können.</p>
<p>Wenn du sehen möchtest, wie das oben Beschriebene in der Praxis funktioniert, sieh dir das folgende Video an:</p>
<p>&lt;!-- blank line --&gt;
&lt;figure class=&quot;video_container&quot;&gt;
&lt;iframe src=&quot;https://www.youtube.com/embed/Tuj7TgqY81Q?si=RReuL1pUsLafvAzs&quot; frameborder=&quot;0&quot; allowfullscreen=&quot;true&quot;&gt; &lt;/iframe&gt;
&lt;/figure&gt;
&lt;!-- blank line -&gt;</p>
<blockquote>
<p>Trag dich in die <a href="https://about.gitlab.com/de-de/gitlab-duo/workflow/">Warteliste für die private Beta-Version von GitLab Duo Workflow</a> ein, um zu sehen, was du mit KI-Tools machen kannst, die deinen gesamten SDLC verstehen.</p>
</blockquote>
<h2>Mehr über GitLab Duo Workflow und agentische KI</h2>
<ul>
<li><a href="https://about.gitlab.com/de-de/blog/gitlab-duo-workflow-enterprise-visibility-and-control-for-agentic-ai/">GitLab Duo Workflow: Transparenz und Kontrolle für agentische KI auf Enterprise-Niveau</a></li>
<li><a href="https://docs.gitlab.com/user/duo_workflow/">Dokumentation für GitLab Duo Workflow (nur in englischer Sprache verfügbar)</a></li>
<li><a href="https://about.gitlab.com/de-de/gitlab-duo/">GitLab Duo</a></li>
<li><a href="https://about.gitlab.com/the-source/ai/agentic-ai-unlocking-developer-potential-at-scale/">Agentische KI: Entwicklerpotenzial in großem Maßstab freisetzen (The Source) (nur in englischer Sprache verfügbar)</a></li>
</ul>
]]></content>
        <author>
            <name>Cesar Saavedra</name>
            <uri>https://about.gitlab.com/blog/authors/cesar-saavedra</uri>
        </author>
        <published>2025-04-10T00:00:00.000Z</published>
    </entry>
    <entry>
        <title type="html"><![CDATA[SAFe ohne Silos in GitLab]]></title>
        <id>https://about.gitlab.com/de-de/blog/safe-without-silos-in-gitlab/</id>
        <link href="https://about.gitlab.com/de-de/blog/safe-without-silos-in-gitlab/"/>
        <updated>2025-04-08T00:00:00.000Z</updated>
        <content type="html"><![CDATA[<p>Was passiert eigentlich, wenn dein Unternehmen das Scaled Agile Framework (SAFe) einführt, um auf Unternehmensebene zu skalieren? Du hast mehrere Teams, die an komplexen Produkten arbeiten, und benötigst eine Möglichkeit, diese Arbeit zu koordinieren. Aber hier ist ein häufiges Problem: Deine Planung erfolgt in einem Tool, während deine eigentliche Entwicklungsarbeit ganz woanders stattfindet.</p>
<p>Diese Trennung schafft überall Probleme: Entwickler(innen) springen ständig zwischen Systemen hin und her. Produktmanager(innen) haben Schwierigkeiten, sich ein genaues Bild vom Fortschritt zu machen. Und jeder verschwendet Zeit damit, Informationen manuell von einem Ort zum anderen zu kopieren. Es ist genau diese Art von fehlendem Zusammenhang, die SAFe beseitigen soll.</p>
<p>Auch wenn deine Entwicklungsteams <a href="https://about.gitlab.com/de-de/">GitLab</a> möglicherweise bereits für die Quellcodeverwaltung, CI/CD und Sicherheit verwenden, fragst du dich vielleicht, ob GitLab auch deine Planungsanforderungen innerhalb des SAFe-Frameworks unterstützen kann. Die gute Nachricht ist, dass die agilen Projektmanagementfunktionen von GitLab SAFe umfassend unterstützen. In diesem Artikel erfährst du, wie GitLab SAFe-Konzepte und -Zeremonien abbildet, und das alles innerhalb derselben DevSecOps-Plattform, die deine Softwareentwickler(innen) bereits kennen und lieben.</p>
<h2>Was ist SAFe?</h2>
<p>SAFe oder das Scaled Agile Framework ist eine Möglichkeit, agile Prinzipien in große Unternehmen zu bringen, ohne an Geschwindigkeit, Ausrichtung oder Kundenorientierung einzubüßen. Es nimmt das iterative und flexible Teamwork-Modell kleiner Teams auf und wendet diese Prinzipien in großen Unternehmen mit mehreren Teams, Roadmaps und Stakeholdern an. Dies bringt die Organisation in Einklang, da jedes Planen und Ausführen im Einklang erfolgt. SAFe hilft Produktmanager(inne)n, die Strategie mit der Umsetzung zu verbinden, sodass du nicht nur schnell, sondern auch die richtigen Dinge lieferst, unterstützt durch klare Prioritäten und teamübergreifende Abstimmung.</p>
<p>SAFe reduziert Silos, fördert die Zusammenarbeit und hilft Teams, sich auf Kundenergebnisse zu konzentrieren, nicht nur auf Aufgaben. Wenn es in GitLab integriert ist, passiert etwas scheinbar Magisches: Sichtbarkeit, Nachvollziehbarkeit und Lieferung befinden sich alle an einem Ort.</p>
<h2>SAFe-Terminologie in GitLab</h2>
<p>Zunächst müssen wir festlegen, wie SAFe-Konzepte GitLab zugeordnet werden:</p>
<table>
<thead>
<tr>
<th style="text-align:left">SAFe</th>
<th style="text-align:left">GitLab</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align:left">Epic</td>
<td style="text-align:left">Top-Level-Epic</td>
</tr>
<tr>
<td style="text-align:left">Möglichkeit</td>
<td style="text-align:left">Sub-Epic (Level 1)</td>
</tr>
<tr>
<td style="text-align:left">Funktion</td>
<td style="text-align:left">Sub-Epic (Level 2)</td>
</tr>
<tr>
<td style="text-align:left">User Story</td>
<td style="text-align:left">Issue</td>
</tr>
<tr>
<td style="text-align:left">Aufgabe</td>
<td style="text-align:left">Aufgabe</td>
</tr>
<tr>
<td style="text-align:left">Team</td>
<td style="text-align:left">Benutzerdefiniertes Feld/Label mit begrenztem Geltungsbereich</td>
</tr>
<tr>
<td style="text-align:left">Sprint</td>
<td style="text-align:left">Iteration</td>
</tr>
<tr>
<td style="text-align:left">Programminkrement (PI)</td>
<td style="text-align:left">Meilenstein</td>
</tr>
<tr>
<td style="text-align:left">Wertschöpfungskette</td>
<td style="text-align:left">Top-Level-Gruppe</td>
</tr>
<tr>
<td style="text-align:left">Agile Release Train (ART)</td>
<td style="text-align:left">Top-Level-Gruppe</td>
</tr>
</tbody>
</table>
<p>&lt;br&gt;&lt;/br&gt;</p>
<p>Mit dieser Zuordnung als Leitfaden kannst du GitLab so einrichten, dass es deine SAFe-Implementierung widerspiegelt. Mit der Gruppenstruktur kannst du dich um deine Wertschöpfungsketten und ARTs herum organisieren, während die Workitem-Hierarchie (mit bis zu sieben Ebenen verschachtelter Epics!) dir die nötige Tiefe für komplexe Produktportfolios bietet. Unabhängig davon, ob du auf Portfolioebene (mit Top-Level-Gruppen), auf Programmebene (mit Untergruppen) oder auf Teamebene (mit Projekten) arbeitest, passt die Organisationsstruktur von GitLab perfekt zur SAFe-Hierarchie.</p>
<h2>Unterstützung von SAFe-Zeremonien in GitLab</h2>
<p>Nun zum vergnüglichen Teil – wie führst du deine SAFe-Zeremonien in GitLab durch? Gehen wir jede einzelne durch.</p>
<h3>PI-Planen</h3>
<p>Um die teamübergreifende Abstimmung und das Abhängigkeitsmanagement zu erleichtern, die ein erfolgreiches PI-Planen ausmachen, bietet GitLab mehrere Möglichkeiten:</p>
<ul>
<li>Verwende die <a href="https://docs.gitlab.com/user/group/roadmap/">Roadmap</a>-Ansicht, um Funktionen team- und zeitübergreifend zu visualisieren.</li>
<li>Weise dem PI-<a href="https://docs.gitlab.com/user/project/milestones/">Meilenstein</a> Funktionen zu.</li>
<li>Dokumentiere und visualisiere teamübergreifende <a href="https://docs.gitlab.com/user/project/issues/related_issues/#blocking-issues">Abhängigkeiten</a>, sobald sie identifiziert wurden.</li>
</ul>
<p>GitLab bietet dir Flexibilität beim PI-Planen sowohl über die Epic-Boards (die so konfiguriert werden können, dass sie Teamzuweisungen anzeigen) als auch über die Roadmap-Ansicht (die Funktionen im Zeitverlauf wie ein Gantt-Diagramm anzeigt). Du kannst während deiner Planungs-Sessions zwischen diesen Ansichten wechseln, je nachdem, ob du dich auf die Zeitachse oder die Teamorganisation konzentrierst.</p>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097577/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097576746.gif" alt="Roadmap-Ansicht und Epic-Board"></p>
<p>&lt;br&gt;&lt;/br&gt;</p>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097577/Blog/Content%20Images/Blog/Content%20Images/image5_aHR0cHM6_1750097576747.png" alt="Roadmap-Ansicht mit Gantt-Diagramm"></p>
<h3>Refinement</h3>
<p>Als Produktmanager(in) bedeutet das Durchführen effektiver Refinement-Sessions, dass du einen klaren Überblick über deinen Funktionen-Backlog hast. Du kannst deine Refinement-Session direkt in GitLab durchführen. Du musst nicht mehr während der Besprechung ein Tool aktualisieren und anschließend ein anderes Tool aktualisieren.</p>
<p>GitLab unterstützt Refinement-Sessions mit:</p>
<ul>
<li><a href="https://docs.gitlab.com/user/group/epics/epic_boards/">Epic-Boards</a>, die Funktionen nach Status gruppieren.</li>
<li>Der Möglichkeit, Story-Punkte direkt in der <a href="https://docs.gitlab.com/user/group/epics/epic_boards/#view-count-of-issues-weight-and-progress-of-an-epic">Übersicht</a> anzuzeigen.</li>
<li>Umfassenden <a href="https://docs.gitlab.com/user/group/epics/manage_epics/#open-epics-in-a-drawer">Drawer-Ansichten</a>, mit denen du mit Workitems interagieren kannst, ohne den Kontext zu verlieren.</li>
<li>Der Möglichkeit, <a href="https://docs.gitlab.com/user/group/epics/manage_epics/#add-an-issue-to-an-epic">untergeordnete Issues</a> direkt aus Epics zu erstellen und zu verknüpfen.</li>
</ul>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097577/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097576749.gif" alt="SAFe – Bild 3"></p>
<h3>Sprint-Planung</h3>
<p>Wenn es darum geht, herauszufinden, was dein Team im nächsten Sprint bewältigen kann, bietet GitLab dir:</p>
<ul>
<li><a href="https://docs.gitlab.com/user/project/issue_board/">Issue-Übersichten</a>, die einen umfassenden Überblick über deinen Backlog bieten.</li>
<li>Eine <a href="https://docs.gitlab.com/user/project/issue_board/#sum-of-issue-weights">Gesamtgewichtung</a> von User Storys, die direkt auf den Boards angezeigt werden.</li>
<li>Die Möglichkeit, Tickets einfach zwischen Iterationen zu verschieben.</li>
<li>Eine zusammenklappbare Ansicht, die das Verschieben von Storys zwischen Sprints vereinfacht.</li>
</ul>
<p>Das bedeutet, dass du alles an einem Ort aufbewahren und deine Planungsbesprechungen tatsächlich mit dem Planen verbringen kannst, anstatt zwischen den Tools zu wechseln.</p>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097577/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750097576751.gif" alt="Sprint-Planung mit GitLab"></p>
<p><em>💡 In <a href="https://docs.gitlab.com/tutorials/scrum_events/">diesem Tutorial zur Verwendung von GitLab für Scrum</a> erhältst du einen detaillierten Einblick in die Möglichkeiten von GitLab für Agile Planning und Sprint-Verfolgung.</em></p>
<h3>Tägliche Stand-up-Meetings</h3>
<p>Dein Team kann sich während der täglichen Stand-up-Meetings um das Board versammeln und sehen, woran alle arbeiten, wo es Probleme gibt und was zur Überprüfung bereit ist – alles in einer einzigen Ansicht. Für die täglichen Stand-up-Meetings deines Entwicklungsteams bietet GitLab dir folgende Möglichkeiten:</p>
<ul>
<li>Erstellen von <a href="https://docs.gitlab.com/user/project/issue_board/#iteration-lists">iterationsbezogenen</a> Boards, die die Arbeit des aktuellen Sprints anzeigen.</li>
<li>Die Anzeige von Story-Punkten/Gewichtungen direkt auf Karten.</li>
<li>Die Verwendung der <a href="https://docs.gitlab.com/user/project/issues/managing_issues/#open-issues-in-a-drawer">Drawer-Ansicht</a>, um auf Details zuzugreifen, ohne den Kontext zu verlassen.</li>
<li>Die Hervorhebung gefährdeter Aufgaben durch den <a href="https://docs.gitlab.com/user/project/issues/managing_issues/#health-status">Integritätsstatus</a></li>
</ul>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097577/Blog/Content%20Images/Blog/Content%20Images/image6_aHR0cHM6_1750097576755.png" alt="Board für tägliche Stand-up-Meetings"></p>
<h3>Sprint-Review</h3>
<p>Möchtest du wissen, wie sich dein Team im Laufe der Zeit entwickelt? GitLab bietet umfassende Metriken mit:</p>
<ul>
<li><a href="https://docs.gitlab.com/user/group/iterations/#iteration-burndown-and-burnup-charts">Abarbeitungs- und Burnup-Diagrammen</a> für Iterationen</li>
<li>Geschwindigkeitsverfolgung</li>
<li><a href="https://docs.gitlab.com/user/group/value_stream_analytics/#lifecycle-metrics">Lead- und Zykluszeit</a>-Metriken</li>
<li>Dashboards, die auf Teams ausgerichtet werden können</li>
</ul>
<p>Diese Metriken helfen dir zu verstehen, ob dein Team schneller wird, wo es stecken bleibt und worüber du vielleicht in deiner nächsten Retrospektive sprechen möchtest.</p>
<p><img src="https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097577/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097576758.png" alt="Abarbeitungs- und Burnup-Diagramme"></p>
<h2>5 Gründe, warum eine einheitliche Plattform einen Vorteil bietet</h2>
<p>Es gibt viele Planungstools, die SAFe-Zeremonien handhaben können. Aber es gibt sehr gute Gründe, die für GitLab sprechen:</p>
<ol>
<li><strong>Kein Kontextwechsel mehr</strong>: Planung, Programmierung, Testen und Sicherheit finden alle an einem Ort statt.</li>
<li><strong>Alles ist miteinander verbunden</strong>: Du kannst die Arbeit vom großen Epic bis hinunter zum Code und zur Bereitstellung verfolgen.</li>
<li><strong>Alle sind auf dem gleichen Stand</strong>: Entwickler(innen), Produktverantwortliche und Sicherheitsteams arbeiten alle mit demselben Tool zusammen.</li>
<li><strong>Vollständige Transparenz</strong>: Stakeholder haben einen zentralen Ort, an dem sie nach Updates suchen können.</li>
<li><strong>Das Gesamtbild</strong>: Du siehst Planungs- und Entwicklungsmetriken zusammen, damit du weißt, was wirklich vor sich geht.</li>
</ol>
<p>Wenn deine Entwicklungsteams GitLab bereits schätzen, warum sollten sie dann für das Planen zu einem anderen Tool wechseln oder komplexe, zusammengeschusterte Integrationen erstellen? Wenn du deine SAFe-Planung in GitLab integrierst, wird die Arbeit für alle Beteiligten erheblich vereinfacht.</p>
<h2>Implementierungsgrundsätze</h2>
<p>Ich habe mit Teams zusammengearbeitet, die von traditionellen SAFe-Tools zu GitLab wechselten. Dabei habe ich Folgendes gelernt: Konzentriere dich auf <strong>das, was jede Zeremonie zu erreichen versucht</strong>, und nicht auf die exakte Nachbildung deiner alten Tools.</p>
<p>Die Teams, die GitLab optimal nutzen, sind diejenigen, die die nativen Funktionen nutzen, anstatt dagegen anzukämpfen. Ja, es erfordert einige Vorarbeit, um herauszufinden, wie du deine SAFe-Konzepte abbilden und deine Workflows einrichten kannst. Aber wenn das einmal erledigt ist, wirst du feststellen, dass deine Prozesse tatsächlich einfacher und nicht komplexer werden.</p>
<p>Der Schlüssel liegt in der Definition von Konventionen, die jeder befolgt. Welche Labels stehen für was? Wie wirst du Teams verfolgen? Was gehört in ein Epic und was in ein Ticket? Mit ein wenig Vorarbeit bei diesen Entscheidungen erhältst du ein intuitives System, das den gesamten Koordinationsaufwand zwischen verschiedenen Tools eliminiert.</p>
<h2>Erste Schritte</h2>
<p>Bereit, es auszuprobieren? So beginnst du mit der Implementierung von SAFe in GitLab:</p>
<ol>
<li><strong>Richte deine Struktur ein</strong>: Erstelle Gruppen und Untergruppen, die <a href="https://about.gitlab.com/de-de/blog/best-practices-to-set-up-organizational-hierarchies-that-scale/">deiner Organisation entsprechen</a>.</li>
<li><strong>Definiere deine Aufgabenverteilung</strong>: Entscheide, wie du <a href="https://about.gitlab.com/de-de/blog/unlocking-agile-excellence-gitlab-epics-for-seamless-portfolio-management/">Epics</a>, <a href="https://docs.gitlab.com/user/project/issues/managing_issues/">Tickets</a> und <a href="https://docs.gitlab.com/user/tasks/">Aufgaben</a> verwenden möchtest.</li>
<li><strong>Erstelle deine Iterationen</strong>: Richte deinen <a href="https://docs.gitlab.com/user/group/iterations/#create-an-iteration-cadence">Sprint-Zeitplan</a> ein.</li>
<li><strong>Füge deine Meilensteine hinzu</strong>: <a href="https://docs.gitlab.com/user/project/milestones/#create-a-milestone">Meilensteine</a> stellen deine Programmschritte in GitLab dar.</li>
<li><strong>Erstelle deine Boards</strong>: Erstelle verschiedene Ansichten für verschiedene Zeremonien.</li>
<li><strong>Konventionen vereinbaren</strong>: Dokumentiere, wie du Labels und benutzerdefinierte Felder verwendest.</li>
</ol>
<p>Wenn du dir im Voraus die Zeit nimmst, diese Entscheidungen zu überdenken, ersparst du dir später viele Kopfschmerzen. Und denke daran, dass du es nicht am ersten Tag perfekt machen musst – du kannst jederzeit Anpassungen vornehmen, während du dazulernst.</p>
<h2>Alles zusammenbringen</h2>
<p>GitLab bietet dir eine solide Grundlage für die Ausführung von SAFe, insbesondere wenn deine Entwicklungsteams bereits von GitLab begeistert sind. Wenn du Planung und Entwicklung in einem einzigen Tool vereinst, eliminierst du lästige Übergaben, erleichterst die Zusammenarbeit und beschleunigst den gesamten Prozess.</p>
<p>Das Schöne an den Planungstools von GitLab ist, dass sie flexibel genug sind, um sich an deine spezifischen SAFe-Anforderungen anzupassen. Du bist nicht an starre Arbeitsabläufe gebunden, sondern kannst deinen Ansatz weiterentwickeln, wenn deine Teams erfahrener werden und sich deine Bedürfnisse ändern.</p>
<blockquote>
<p>Bist du bereit zu erkennen, wie viel besser das Leben ohne diese Planungsinseln ist? <a href="https://about.gitlab.com/de-de/free-trial/">Starte noch heute deine kostenlose Testversion</a> und erfahre aus erster Hand, wie GitLab deine SAFe-Implementierung verändern kann.</p>
</blockquote>
<ul>
<li>💡 Wenn dir dieser Beitrag gefallen hat, lies auch den folgenden Beitrag dazu: <a href="https://about.gitlab.com/de-de/blog/gitlab-for-agile-software-development/">GitLab für die Agile-Softwareentwicklung</a>*</li>
</ul>
]]></content>
        <author>
            <name>Amanda Rueda</name>
            <uri>https://about.gitlab.com/blog/authors/amanda-rueda</uri>
        </author>
        <published>2025-04-08T00:00:00.000Z</published>
    </entry>
    <entry>
        <title type="html"><![CDATA[Wir feiern das 20-jährige Git-Jubiläum mit dessen Erfinder Linus Torvalds]]></title>
        <id>https://about.gitlab.com/de-de/blog/celebrating-gits-20th-anniversary-with-creator-linus-torvalds/</id>
        <link href="https://about.gitlab.com/de-de/blog/celebrating-gits-20th-anniversary-with-creator-linus-torvalds/"/>
        <updated>2025-04-07T00:00:00.000Z</updated>
        <content type="html"><![CDATA[<p>Das Versionskontrollsystem Git wurde am 7. April 2005 vom &quot;Vater&quot; des Linux-Kernels, Linus Torvalds, veröffentlicht. Heute feiern wir den 20. Jahrestag dieses wichtigen Projekts, das mittlerweile von fast allen Entwickler(inne)n verwendet wird. Zu diesem Anlass habe ich mit Linus über die Geschichte von Git und darüber gesprochen, warum er die Rolle des Chefentwicklers von Git abgegeben hat und was seiner Meinung nach die wichtigsten Meilensteine sind.</p>
<p><strong>2005 warst du bereits Betreuer des aufstrebenden Linux-Kernels. Warum hast du dich entschieden, ein neues Versionskontrollsystem zu entwickeln?</strong></p>
<p>Anfangs habe ich Versionskontrolle wirklich gehasst.</p>
<p>Ich habe herkömmliche Versionskontrollsysteme (CVS/RCS/SCCS) sowohl als Endbenutzer (z. B. beim Nachverfolgen von Open-Source-Projekten wie <a href="https://gcc.gnu.org/">GCC</a>) als auch als Entwickler (bei Transmeta haben wir für alles CVS genutzt) kennengelernt und hatte wirklich eine tiefe Abneigung dagegen.</p>
<p>&lt;img src=&quot;https://about.gitlab.com/images/blogimages/linustorvalds.png&quot; align=&quot;left&quot; width=&quot;200px&quot; style=&quot;padding-right: 20px; padding-bottom: 10px&quot;/&gt;</p>
<p>Damals wechselten die meisten Projekte, die CVS verwendeten, vermutlich zu <a href="https://subversion.apache.org/">SVN</a>, aber für mich war das ehrlich gesagt nur Schönrederei. SVN war ja nichts als CVS in einer anderen Form und mit einem geringfügig besseren UI, aber die grundlegenden Dinge waren nicht besser und es wurden sogar einige neue Probleme hinzugefügt.</p>
<p>Es gibt zu viele Probleme mit CVS und den anderen Lösungen, um sie hier alle aufzulisten. Glücklicherweise wurden sie alle zum Großteil obsolet und junge Entwickler(innen) müssen sich wahrscheinlich nie mit einem dieser Systeme beschäftigen. Ich weigerte mich also kategorisch, für den Kernel damit zu arbeiten, auch wenn wir für die Nachverfolgung des Codes einiger Untersysteme (vor allem beim Netzwerk) in den 90ern tatsächlich CVS verwendeten.</p>
<p>Damals lebte ich in der Bay Area. Larry McVoy, den ich von früheren Projekten kannte (vor allem von <a href="https://www.usenix.org/legacy/publications/library/proceedings/sd96/full_papers/mcvoy.pdf">Imbench</a>), hatte BitMover gegründet, bei dem ein neues Versionskontrollmodell namens BitKeeper, oder kurz BK, verwendet wurde.</p>
<p>BK war zwar nicht Open Source, aber Larry hatte eine Vorliebe für Open-Source-Projekte und hatte das Gefühl, dass die fehlende Versionskontrolle die Entwicklung des Kernels wirklich ausbremste. Er hatte nicht unrecht, aber die traditionelle Quellcodeverwaltung funktionierte für mich einfach nicht. Larry verbrachte einige Zeit damit, mir und David Miller (einem Netzwerkbetreuer und bestehendem CVS-Benutzer) zu zeigen, was BitKeeper alles konnte.</p>
<p>BK war nicht perfekt und basierte wie so viele andere Systeme zur Quellcodeverwaltung auf dem Source Code Control System (SCCS) und setzte daher wie alle anderen auf dasselbe unzureichende Modell mit „dateibasiertem Verlauf“. Dieses verursachte riesige, fundamentale Probleme, wenn Dateien umbenannt und gelöscht wurden.</p>
<p>Andererseits war BK nicht nur reine Schönrederei. Es basierte zwar grundlegend auf SCCS, aber auf höherer Ebene behob es einige wirklich fundamentale Probleme und ermöglichte eine echte verteilte Entwicklung. Zudem hatte es einen echten globalen – keinen reinen dateibasierten – Verlauf, sodass es tatsächlich Code von verschiedenen Entwicklungszweigen zusammenführen konnte.</p>
<p>Mit CVS war das Erstellen von Branches und deren Zusammenführung etwas, das man mit anderen planen und besprechen musste – also ein großes Ereignis. Mit BK war jedes Repository ein Branch. Heute halten wir das für selbstverständlich, und natürlich ist Git noch viel weiter gegangen: Es gibt viele Branches <em>pro</em> Repository. Doch auch das viel eingeschränktere Modell von BK war zu diesem Zeitpunkt ein echter Wendepunkt.</p>
<p>Aber wie gesagt, BK war nicht perfekt. Es nutzte einen dateibasierten Verlauf, was ein fundamentales Problem ist, denn dadurch können Dateien einfach nicht zuverlässig umbenannt und zusammengeführt werden, was unvermeidlich zu Chaos und Probleme führt (alle, die CVS kennen: Denkt an Attic …). Außerdem gab es Einschränkungen bei der Skalierbarkeit. Diese wurden aber nur langsam etwas problematischer.</p>
<p>Das größte Problem bei BK war die Lizenzierung. Auch wenn im Laufe der Jahre (wir verwendeten BK von 2002 bis 2005) viele Kernel-Betreuer(innen) zu diesem System wechselten, gab es immer wieder Schwierigkeiten damit. Diese Schwierigkeiten spitzten sich Ende 2004 zu, als der Einsatz von BK für den Kernel einige Monate später praktisch nicht mehr möglich war.</p>
<p>Ich war nun in der Situation, dass ich drei Jahre lang endlich eine Versionskontrolle verwendet hatte, die tatsächlich funktionierte und viele Probleme gelöst hat. Ich wollte also keinesfalls wieder zum Zustand vor der Versionskontrolle zurückkehren, doch in den Jahren, in denen wir BK eingesetzt hatten, war von der Open-Source-Community nicht wirklich eine bessere Lösung gekommen.</p>
<p>Sicher, die Leute wussten, dass CVS und SVN nicht wirklich gut funktionierten, und es gab Projekte, in denen alternative Ansätze verfolgt wurden, doch diese waren teilweise sogar noch schlechter (sie waren im Grunde einfach nur schick verpacktes Patch-Tracking). Einige dagegen hatten zwar gute Ideen, machten aber schreckliche Entwicklungsfehler (siehe <a href="https://www.monotone.ca/">Monotone</a>).</p>
<p>Ich sah mich also eine Weile um und erkannte dann, dass es nur einen Ausweg gab: Ich musste meine eigene Lösung programmieren.</p>
<p>Technisch gesehen dauerte es nur wenige Tage, die erste Version von Git zu erstellen – das kann man alles im Git-Commit-Verlauf nachlesen. Dort sieht man wunderbar, wie es von quasi Null zu einer gerade so nutzbaren Lösung wurde, für die ich dann eine Woche später Patches veröffentlichte (und die dann einige Tage danach aktiv für den Kernel verwendet wurde).</p>
<p>Dabei wird aber die Tatsache außer Acht gelassen, dass ich bis zu diesem Zeitpunkt schon eine Weile über das Problem <em>nachgedacht</em> hatte. Programmieren ist einfach. Ein gutes Konzept ist das, was zählt. Hinter diesen wenigen Tagen steckt also einiges an Vorarbeit, die sehr wichtig ist – und das sieht man im Verlauf nicht.</p>
<p>Diese erste Version war sehr, sehr einfach und konnte vieles von dem nicht, was später noch kommen sollte. Man kann aber auch in diesen ersten Tagen schon viel vom Kernkonzept sehen.</p>
<p><strong>Kannst du uns einen kurzen Rückblick über die ersten Tage und Wochen des Git-Projekts geben?</strong></p>
<p>Ich hatte im Grunde beschlossen, die Kernel-Entwicklung einzustellen, bis ich eine Alternative hatte, die für mich funktionierte. Das Resultat sollte eine verteilte Entwicklung und Höchstleistung ermöglichen sowie ein System sein, mit dem man absolut verlässlich jegliche Beeinträchtigung verhindern kann.</p>
<p>Ich möchte betonen, dass ich mich nicht wirklich für Quellcodeverwaltungssysteme interessierte. Ich war am Endergebnis interessiert, nicht am Prozess. Git war mir also nie so wichtig wie der Kernel: Ich arbeite an Linux, weil ich Kernels spannend finde. Ich habe an Git gearbeitet, weil ich es musste.</p>
<p>Damit wären wir dann auch schon bei deiner nächsten Frage.</p>
<p><strong>Du hast die Rolle des Chefentwicklers von Git nach einigen Monaten an Junio Hamano übergeben, der dies noch immer ist. Warum hast du deine Position abgegeben, und warum an Junio?</strong></p>
<p>Die Übergabe der Rolle war keine schwierige Entscheidung. Es war vielmehr so: „Sobald ich jemanden finde, dem ich das Projekt anvertrauen kann, gehe ich wieder zurück und arbeite nur noch am Kernel.“</p>
<p>Das soll nicht heißen, dass ich einfach alles hingeworfen und auf das Beste gehofft habe. Ich war rund vier Monate lang Chefentwickler von Git, weil ich spürte, dass ich jemanden finden musste, der gekommen war, um zu bleiben, und der diesen ominösen „guten Riecher“ hatte.</p>
<p>Junio war als einer der Ersten dabei – quasi ab der ersten Woche. Aber ich bin nicht einfach zu ihm hin gerannt und habe gesagt: „Du bist dran.“ Es braucht eine Weile, bis man sieht, wer wirklich dabei bleibt und wer sinnvollen Code schreibt und sinnvolle Entscheidungen trifft.</p>
<p>Und ich denke, Junio war ein echtes Vorbild. Ich bekomme viel zu viel Lob für die paar Monate, die ich in Git gesteckt habe – besonders angesichts des 20-jährigen Jubiläums. Ich bin zwar dafür verantwortlich, dass das Kernkonzept richtig umgesetzt und das Projekt zum Laufen gebracht wurde, aber Junio hat das Projekt wirklich geleitet (damit will ich nicht die hunderten anderen Beteiligten vergessen).</p>
<p><strong>Die erste Version des Versionskontrollsystems Mercurial wurde 12 Tage nach der ersten Version von Git am 19. April 2005 veröffentlicht. Viele Leute behaupten, dass die User Experience von Mercurial der von Git überlegen war, aber heute ist Git deutlich beliebter. Warum glaubst du, hat Git sich gegen Mercurial durchgesetzt?</strong></p>
<p>Oh, ein großer Teil davon sind offensichtlich nur Netzwerkeffekte, und Quellcodeverwaltungssysteme haben sehr starke Netzwerkeffekte. Deshalb hat CVS trotz all seiner Einschränkungen so lange überlebt.</p>
<p>Der Kernel verwendete Git und es wurde irgendwann in der Community von Ruby on Rails sehr beliebt – und dann setzte es sich überall durch.</p>
<p>Aber ich bin wirklich überzeugt, dass das Konzept von Git besser ist. Das Kernmodell ist sowohl sehr einfach als auch sehr leistungsfähig, und ich denke, das machte es einfacher, es in andere Umgebungen zu übertragen. JGit war ein frühes Beispiel dafür, aber es gibt natürlich Implementierungen wie das virtuelle Dateisystem MSgit usw.</p>
<p>Während Git anfangs berühmt-berüchtigterweise schwierig zu nutzen war, glaube ich, dass vieles davon darauf zurückzuführen ist, dass die Leute Dinge zuvor „richtig“ machen mussten. Die Leute kamen nämlich von anderen Umgebungen und fanden Git nicht intuitiv, da Git ein paar harte Entscheidungen getroffen hatte, die Nutzer(innen) von herkömmlichen Quellcodeverwaltungssystemen niemals gemacht hätten.</p>
<p><strong>Das Git-Projekt ist nie stehengeblieben, seit du die Rolle des Chefentwicklers an Junio übergeben hast, und die Community arbeitet kontinuierlich an neuen Funktionen. Was waren deiner Meinung nach die wichtigsten Meilensteine, nachdem du das Projekt verlassen hast?</strong></p>
<p>Das ist schwer zu beantworten, da ich Git ja so entwickelt hatte, dass es für mich funktionierte. Die Dinge, die <em>ich</em> verwende, haben also quasi vom ersten Tag an funktioniert. Ein offensichtliches Beispiel: Für viele Leute war es offensichtlich ein riesiger Schritt, Git auf Windows zum Laufen zu bringen, aber <em>mich</em> betraf das überhaupt nicht. ;-)</p>
<p>Git hat ja auch eine ganze Infrastruktur, mit der es einfacher zu nutzen ist. Die größten Meilensteine entstanden meiner Meinung nach aber, als die Menschen die Git-Infrastruktur heranzogen und Dinge darauf aufbauend entwickelten. Diese fließen natürlich oft auch wieder in Git-Funktionen ein, aber gleichzeitig ist der Meilenstein etwas Externes.</p>
<p>Ein offensichtliches Beispiel: Alle großen Git-Hosting-Websites waren große Meilensteine. Dadurch, dass Git verteilt war, waren diese viel einfacher zu entwickeln, aber der <em>Meilenstein</em> war dann, dass das Hosting es den Benutzer(innen) so einfach machte, Git für verschiedenste Projekte zu nutzen.</p>
<p><strong>Wenn du wieder in der Lage wärst, hauptberuflich an Git zu arbeiten, gäbe es etwas, das du gerne implementieren würdest?</strong></p>
<p>Auf keinen Fall. Git hat von Anfang an alles getan, was ich brauchte – ich nutze es tatsächlich nur ziemlich eingeschränkt, und mir ist nur ein Projekt wichtig.</p>
<p>Und ich sage „Auf keinen Fall“, weil ich mich auf eine meiner früheren Antworten beziehe: Ich war noch nie wirklich an Quellcodeverwaltungssystemen interessiert. Ich denke, ein wichtiger Grund dafür, dass Git sich von anderen Quellcodeverwaltungssystemen so sehr unterscheidet – größtenteils im positiven Sinne – ist, dass ich Git eher wie ein verteiltes Journaling-Dateisystem angegangen bin und nicht wie eine herkömmliche Quellcodeverwaltung.</p>
<p><strong>Gibt es eine Funktion oder eine konzeptionelle Entscheidung in Git, die du im Nachhinein bereust?</strong></p>
<p>Konzeptionelle Entscheidungen? Nein. Ich bin immer noch überzeugt, dass das übergeordnete Konzept sehr gut ist. Man kann verschiedene Git-Konzepte diskutieren, ohne auf die kleinteilige Komplexität der eigentlichen Implementierung eingehen zu müssen.</p>
<p>Und ich denke, das ist wichtig in einem Projekt. Man benötigt ein bestimmtes übergeordnetes Prinzip, dem die konzeptionelle Ausrichtung eines Projekts folgt.</p>
<p>Manchmal treiben die Leute das zu weit und denken, dass das übergeordnete Konzept bedeutet, dass die Implementierung dann sklavisch einem Kernprinzip folgen muss. Das ist aber auch falsch – die <em>Implementierung</em> hat viele hässliche Grenzfälle, da die Realität nun einmal hart ist und Menschen seltsame Dinge wollen. Es ist schon eine Art übergeordnetes Konzept nötig, auf das man sich beziehen kann und über das man auf übergeordneter Ebene argumentieren kann, bevor man sich die Hände an der harten Realität schmutzig macht.</p>
<p>Ich denke, Git hat da ein gutes Gleichgewicht gefunden. Ein sehr geradliniges Objektspeicher-Konzept („strukturierte Merkle-Bäume“, wenn du aus dem CS-Bereich kommst, oder stell sie dir einfach als „inhaltsadressierbaren Speicher“ vor, wenn du aus dem Dateisystem-Bereich kommst). Dieses Kernkonzept ist da, ist aber gleichzeitig in der Realität nur ein winziger Teil des eigentlichen Codes. Der größte Teil des <em>Codes</em> betrifft all die Dinge, die man mit dem Kernkonzept machen kann. Diese grundlegende konzeptionelle Klarheit gibt dem Projekt trotzdem eine Art übergeordnete Struktur.</p>
<p>Es ist die gleiche Art von übergeordneter Struktur, die Unix selbst hatte, von „alles ist eine Datei“ bis hin zur Prozessabwicklung. Es gibt zwar ein paar übergeordnete „Konzepte“, aber bei 99 % des Codes geht es ganz einfach darum, das, was man auf diesem Design aufgebaut ist, so zu gestalten, dass es uns in der realen Welt nutzt.</p>
<p>Ich habe zwei Mantras hinsichtlich der Technologie: „Wenn ich weiter geblickt habe, so deshalb, weil ich auf den Schultern von Riesen stehe“ (Newton) und „Genie ist 1 % Inspiration und 99 % Prozent Transpiration“ (Edison).</p>
<p>Aber da wir schon über die 99 % Transpiration sprechen: Obwohl ich mit dem Gesamtdesign sehr zufrieden bin, gibt es sicherlich verschiedene Details, die ich anders gemacht hätte, wenn ich Git heute entwickeln würde.</p>
<p>Ehrlich gesagt, sind sie aber nicht so wichtig. Viel wichtiger sind all die <em>guten</em> Details, die in den letzten zwei Jahrzehnten entwickelt wurden.</p>
<p><strong>Im Linux-Kernel wurde Rust als Programmiersprache für einige der Subsysteme eingeführt. Glaubst du, dass es sinnvoll ist, solche neueren Programmiersprachen auch in Git zu verwenden?</strong></p>
<p>Ich vermute, dass es bei Git weniger Gründe gibt, Sprachen zu mischen, was immer etwas schwierig ist.</p>
<p>Im Kernel ist das Endergebnis eine einzige Kernel-Binärdatei – auch wenn der Großteil davon dynamisch als Module geladen werden kann, sind sie immer noch effektiv in einer einzige Binärdatei verbunden.</p>
<p>Das macht die Verwendung mehrerer Sprachen komplexer. Andererseits gibt es für den Kernel auch mehr Gründe, sich mit der Speichersicherheit und folglich mit neueren Sprachen zu befassen.</p>
<p>Wenn jemand Teile von Git in Rust oder einer anderen Programmiersprache schreiben möchte, ist es vermutlich viel sinnvoller, einfach eine separate Implementierung zu erstellen, anstatt zu versuchen, in einer Binärdatei mehrere Sprachen zu mischen.</p>
<p>Die Kernideen von Git sind im Grunde so einfach, dass es vermutlich nicht allzu schwierig ist, einfach parallele Implementierungen des Kernel zu haben. Dann kann man bestimmte Problembereiche gezielt angehen, in denen unterschiedliche Sprachen sinnvoll sind.</p>
<p>Das haben wir natürlich schon in Git gesehen: Genau das ist JGit. Hier wurde eine andere Programmiersprache verwendet, die sinnvoller für die webbasierte Umgebung war.</p>
<p>Ich weiß, dass es bereits Rust-Implementierungen einiger der Kernfunktionen von Git gibt. Hier ist die Situation vermutlich ähnlich: Sie werden in bestimmten Situationen sinnvoller sein als einfach alles in Rust umzuwandeln.</p>
<p>Allen, die sich für die Implementierung mit Rust interessieren, empfehle ich, nach Bereichen Ausschau zu halten, in denen die Vorteile von Rust offensichtlicher sind. Ich glaube nicht, dass die Verwendung von C für den Standard-Quellcode von Git wirklich so problematisch ist.</p>
<p><strong>Alle paar Jahre tauchen neue Versionskontrollsysteme auf. Glaubst du, dass Git auch in Zukunft vorne dabei bleiben wird?</strong></p>
<p>Ich habe bereits die Netzwerkeffekte bei Quellcodeverwaltungssystemen erwähnt. Meiner Meinung nach muss ein neues System daher nicht einfach nur ein bisschen, sondern viel, viel besser sein, um Git zu ersetzen. Oder aber so kompatibel, dass es dann eigentlich nur eine neue Implementierung von Git ist.</p>
<p>Ich denke, dass sich die Situation in der Quellcodeverwaltung geändert hat: Git hat nicht die riesigen, fundamentalen Lücken, die Quellcodeverwaltungssysteme vor Git hatten. Es ist also ziemlich schwer, „enorm besser“ zu sein.</p>
<p>Also, ja, ich gehe davon aus, dass Git auf absehbare Zeit vorne dabei bleibt und die Leute eher an Verbesserungen <em>an</em> Git arbeiten als an Ersatzlösungen.</p>
<p><em>Hinweis: Dieses Interview wurde aus Platzgründen und zur besseren Übersichtlichkeit bearbeitet.</em></p>
<h2>Erfahre mehr über Git</h2>
<ul>
<li><a href="https://about.gitlab.com/de-de/blog/whats-new-in-git-2-49-0/">Was gibt es Neues in Git 2.49.0?</a></li>
<li><a href="https://about.gitlab.com/de-de/blog/whats-new-in-git-2-48-0/">Was gibt es Neues in Git 2.48.0?</a></li>
<li><a href="https://about.gitlab.com/de-de/blog/a-beginners-guide-to-the-git-reftable-format/">Der Anfängerleitfaden zum „reftable“-Format von Git</a></li>
<li><a href="https://git-scm.com/">Git-Projekt</a></li>
</ul>
]]></content>
        <author>
            <name>Patrick Steinhardt</name>
            <uri>https://about.gitlab.com/blog/authors/patrick-steinhardt</uri>
        </author>
        <published>2025-04-07T00:00:00.000Z</published>
    </entry>
</feed>