[{"data":1,"prerenderedAt":1637},["ShallowReactive",2],{"/en-us/blog/tags/features/":3,"navigation-de-de":19,"banner-de-de":440,"footer-de-de":453,"features-tag-page-de-de":662},{"_path":4,"_dir":5,"_draft":6,"_partial":6,"_locale":7,"content":8,"config":10,"_id":12,"_type":13,"title":14,"_source":15,"_file":16,"_stem":17,"_extension":18},"/en-us/blog/tags/features","tags",false,"",{"tag":9,"tagSlug":9},"features",{"template":11},"BlogTag","content:en-us:blog:tags:features.yml","yaml","Features","content","en-us/blog/tags/features.yml","en-us/blog/tags/features","yml",{"_path":20,"_dir":21,"_draft":6,"_partial":6,"_locale":7,"data":22,"_id":436,"_type":13,"title":437,"_source":15,"_file":438,"_stem":439,"_extension":18},"/shared/de-de/main-navigation","de-de",{"logo":23,"freeTrial":28,"sales":33,"login":38,"items":43,"search":377,"minimal":413,"duo":427},{"config":24},{"href":25,"dataGaName":26,"dataGaLocation":27},"/de-de/","gitlab logo","header",{"text":29,"config":30},"Kostenlose Testversion anfordern",{"href":31,"dataGaName":32,"dataGaLocation":27},"https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com&glm_content=default-saas-trial/","free trial",{"text":34,"config":35},"Vertrieb kontaktieren",{"href":36,"dataGaName":37,"dataGaLocation":27},"/de-de/sales/","sales",{"text":39,"config":40},"Anmelden",{"href":41,"dataGaName":42,"dataGaLocation":27},"https://gitlab.com/users/sign_in/","sign in",[44,88,187,192,298,358],{"text":45,"config":46,"cards":48,"footer":71},"Plattform",{"dataNavLevelOne":47},"platform",[49,55,63],{"title":45,"description":50,"link":51},"Die umfassendste KI-basierte DevSecOps-Plattform",{"text":52,"config":53},"Erkunde unsere Plattform",{"href":54,"dataGaName":47,"dataGaLocation":27},"/de-de/platform/",{"title":56,"description":57,"link":58},"GitLab Duo (KI)","Entwickle Software schneller mit KI in jeder Phase der Entwicklung",{"text":59,"config":60},"Lerne GitLab Duo kennen",{"href":61,"dataGaName":62,"dataGaLocation":27},"/de-de/gitlab-duo/","gitlab duo ai",{"title":64,"description":65,"link":66},"Gründe, die für GitLab sprechen","10 Gründe, warum Unternehmen sich für GitLab entscheiden",{"text":67,"config":68},"Mehr erfahren",{"href":69,"dataGaName":70,"dataGaLocation":27},"/de-de/why-gitlab/","why gitlab",{"title":72,"items":73},"Erste Schritte mit",[74,79,84],{"text":75,"config":76},"Platform Engineering",{"href":77,"dataGaName":78,"dataGaLocation":27},"/de-de/solutions/platform-engineering/","platform engineering",{"text":80,"config":81},"Entwicklererfahrung",{"href":82,"dataGaName":83,"dataGaLocation":27},"/de-de/developer-experience/","Developer experience",{"text":85,"config":86},"MLOps",{"href":87,"dataGaName":85,"dataGaLocation":27},"/de-de/topics/devops/the-role-of-ai-in-devops/",{"text":89,"left":90,"config":91,"link":93,"lists":97,"footer":169},"Produkt",true,{"dataNavLevelOne":92},"solutions",{"text":94,"config":95},"Alle Lösungen anzeigen",{"href":96,"dataGaName":92,"dataGaLocation":27},"/de-de/solutions/",[98,124,147],{"title":99,"description":100,"link":101,"items":106},"Automatisierung","CI/CD und Automatisierung zur Beschleunigung der Bereitstellung",{"config":102},{"icon":103,"href":104,"dataGaName":105,"dataGaLocation":27},"AutomatedCodeAlt","/solutions/delivery-automation/","automated software delivery",[107,111,115,120],{"text":108,"config":109},"CI/CD",{"href":110,"dataGaLocation":27,"dataGaName":108},"/de-de/solutions/continuous-integration/",{"text":112,"config":113},"KI-unterstützte Entwicklung",{"href":61,"dataGaLocation":27,"dataGaName":114},"AI assisted development",{"text":116,"config":117},"Quellcodeverwaltung",{"href":118,"dataGaLocation":27,"dataGaName":119},"/de-de/solutions/source-code-management/","Source Code Management",{"text":121,"config":122},"Automatisierte Softwarebereitstellung",{"href":104,"dataGaLocation":27,"dataGaName":123},"Automated software delivery",{"title":125,"description":126,"link":127,"items":132},"Sicherheit","Entwickle schneller, ohne die Sicherheit zu gefährden",{"config":128},{"href":129,"dataGaName":130,"dataGaLocation":27,"icon":131},"/de-de/solutions/security-compliance/","security and compliance","ShieldCheckLight",[133,138,143],{"text":134,"config":135},"Application Security Testing",{"href":136,"dataGaName":137,"dataGaLocation":27},"/solutions/application-security-testing/","Application security testing",{"text":139,"config":140},"Schutz der Software-Lieferkette",{"href":141,"dataGaLocation":27,"dataGaName":142},"/de-de/solutions/supply-chain/","Software supply chain security",{"text":144,"config":145},"Software Compliance",{"href":146,"dataGaName":144,"dataGaLocation":27},"/solutions/software-compliance/",{"title":148,"link":149,"items":154},"Bewertung",{"config":150},{"icon":151,"href":152,"dataGaName":153,"dataGaLocation":27},"DigitalTransformation","/de-de/solutions/visibility-measurement/","visibility and measurement",[155,159,164],{"text":156,"config":157},"Sichtbarkeit und Bewertung",{"href":152,"dataGaLocation":27,"dataGaName":158},"Visibility and Measurement",{"text":160,"config":161},"Wertstrommanagement",{"href":162,"dataGaLocation":27,"dataGaName":163},"/de-de/solutions/value-stream-management/","Value Stream Management",{"text":165,"config":166},"Analysen und Einblicke",{"href":167,"dataGaLocation":27,"dataGaName":168},"/de-de/solutions/analytics-and-insights/","Analytics and insights",{"title":170,"items":171},"GitLab für",[172,177,182],{"text":173,"config":174},"Enterprise",{"href":175,"dataGaLocation":27,"dataGaName":176},"/de-de/enterprise/","enterprise",{"text":178,"config":179},"Kleinunternehmen",{"href":180,"dataGaLocation":27,"dataGaName":181},"/de-de/small-business/","small business",{"text":183,"config":184},"den öffentlichen Sektor",{"href":185,"dataGaLocation":27,"dataGaName":186},"/de-de/solutions/public-sector/","public sector",{"text":188,"config":189},"Preise",{"href":190,"dataGaName":191,"dataGaLocation":27,"dataNavLevelOne":191},"/de-de/pricing/","pricing",{"text":193,"config":194,"link":196,"lists":200,"feature":285},"Ressourcen",{"dataNavLevelOne":195},"resources",{"text":197,"config":198},"Alle Ressourcen anzeigen",{"href":199,"dataGaName":195,"dataGaLocation":27},"/de-de/resources/",[201,234,257],{"title":202,"items":203},"Erste Schritte",[204,209,214,219,224,229],{"text":205,"config":206},"Installieren",{"href":207,"dataGaName":208,"dataGaLocation":27},"/de-de/install/","install",{"text":210,"config":211},"Kurzanleitungen",{"href":212,"dataGaName":213,"dataGaLocation":27},"/de-de/get-started/","quick setup checklists",{"text":215,"config":216},"Lernen",{"href":217,"dataGaLocation":27,"dataGaName":218},"https://university.gitlab.com/","learn",{"text":220,"config":221},"Produktdokumentation",{"href":222,"dataGaName":223,"dataGaLocation":27},"https://docs.gitlab.com/","product documentation",{"text":225,"config":226},"Best-Practice-Videos",{"href":227,"dataGaName":228,"dataGaLocation":27},"/de-de/getting-started-videos/","best practice videos",{"text":230,"config":231},"Integrationen",{"href":232,"dataGaName":233,"dataGaLocation":27},"/de-de/integrations/","integrations",{"title":235,"items":236},"Entdecken",[237,242,247,252],{"text":238,"config":239},"Kundenerfolge",{"href":240,"dataGaName":241,"dataGaLocation":27},"/de-de/customers/","customer success stories",{"text":243,"config":244},"Blog",{"href":245,"dataGaName":246,"dataGaLocation":27},"/de-de/blog/","blog",{"text":248,"config":249},"Remote",{"href":250,"dataGaName":251,"dataGaLocation":27},"https://handbook.gitlab.com/handbook/company/culture/all-remote/","remote",{"text":253,"config":254},"TeamOps",{"href":255,"dataGaName":256,"dataGaLocation":27},"/de-de/teamops/","teamops",{"title":258,"items":259},"Vernetzen",[260,265,270,275,280],{"text":261,"config":262},"GitLab-Services",{"href":263,"dataGaName":264,"dataGaLocation":27},"/de-de/services/","services",{"text":266,"config":267},"Community",{"href":268,"dataGaName":269,"dataGaLocation":27},"/community/","community",{"text":271,"config":272},"Forum",{"href":273,"dataGaName":274,"dataGaLocation":27},"https://forum.gitlab.com/","forum",{"text":276,"config":277},"Veranstaltungen",{"href":278,"dataGaName":279,"dataGaLocation":27},"/events/","events",{"text":281,"config":282},"Partner",{"href":283,"dataGaName":284,"dataGaLocation":27},"/partners/","partners",{"backgroundColor":286,"textColor":287,"text":288,"image":289,"link":293},"#2f2a6b","#fff","Perspektiven für die Softwareentwicklung der Zukunft",{"altText":290,"config":291},"the source promo card",{"src":292},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758208064/dzl0dbift9xdizyelkk4.svg",{"text":294,"config":295},"Lies die News",{"href":296,"dataGaName":297,"dataGaLocation":27},"/de-de/the-source/","the source",{"text":299,"config":300,"lists":302},"Unternehmen",{"dataNavLevelOne":301},"company",[303],{"items":304},[305,310,316,318,323,328,333,338,343,348,353],{"text":306,"config":307},"Über",{"href":308,"dataGaName":309,"dataGaLocation":27},"/de-de/company/","about",{"text":311,"config":312,"footerGa":315},"Karriere",{"href":313,"dataGaName":314,"dataGaLocation":27},"/jobs/","jobs",{"dataGaName":314},{"text":276,"config":317},{"href":278,"dataGaName":279,"dataGaLocation":27},{"text":319,"config":320},"Geschäftsführung",{"href":321,"dataGaName":322,"dataGaLocation":27},"/company/team/e-group/","leadership",{"text":324,"config":325},"Team",{"href":326,"dataGaName":327,"dataGaLocation":27},"/company/team/","team",{"text":329,"config":330},"Handbuch",{"href":331,"dataGaName":332,"dataGaLocation":27},"https://handbook.gitlab.com/","handbook",{"text":334,"config":335},"Investor Relations",{"href":336,"dataGaName":337,"dataGaLocation":27},"https://ir.gitlab.com/","investor relations",{"text":339,"config":340},"Trust Center",{"href":341,"dataGaName":342,"dataGaLocation":27},"/de-de/security/","trust center",{"text":344,"config":345},"AI Transparency Center",{"href":346,"dataGaName":347,"dataGaLocation":27},"/de-de/ai-transparency-center/","ai transparency center",{"text":349,"config":350},"Newsletter",{"href":351,"dataGaName":352,"dataGaLocation":27},"/company/contact/","newsletter",{"text":354,"config":355},"Presse",{"href":356,"dataGaName":357,"dataGaLocation":27},"/press/","press",{"text":359,"config":360,"lists":361},"Kontakt",{"dataNavLevelOne":301},[362],{"items":363},[364,367,372],{"text":34,"config":365},{"href":36,"dataGaName":366,"dataGaLocation":27},"talk to sales",{"text":368,"config":369},"Support",{"href":370,"dataGaName":371,"dataGaLocation":27},"/support/","get help",{"text":373,"config":374},"Kundenportal",{"href":375,"dataGaName":376,"dataGaLocation":27},"https://customers.gitlab.com/customers/sign_in/","customer portal",{"close":378,"login":379,"suggestions":386},"Schließen",{"text":380,"link":381},"Um Repositories und Projekte zu durchsuchen, melde dich an bei",{"text":382,"config":383},"gitlab.com",{"href":41,"dataGaName":384,"dataGaLocation":385},"search login","search",{"text":387,"default":388},"Vorschläge",[389,392,397,399,404,409],{"text":56,"config":390},{"href":61,"dataGaName":391,"dataGaLocation":385},"GitLab Duo (AI)",{"text":393,"config":394},"Code Suggestions (KI)",{"href":395,"dataGaName":396,"dataGaLocation":385},"/de-de/solutions/code-suggestions/","Code Suggestions (AI)",{"text":108,"config":398},{"href":110,"dataGaName":108,"dataGaLocation":385},{"text":400,"config":401},"GitLab auf AWS",{"href":402,"dataGaName":403,"dataGaLocation":385},"/de-de/partners/technology-partners/aws/","GitLab on AWS",{"text":405,"config":406},"GitLab auf Google Cloud",{"href":407,"dataGaName":408,"dataGaLocation":385},"/de-de/partners/technology-partners/google-cloud-platform/","GitLab on Google Cloud",{"text":410,"config":411},"Warum GitLab?",{"href":69,"dataGaName":412,"dataGaLocation":385},"Why GitLab?",{"freeTrial":414,"mobileIcon":419,"desktopIcon":424},{"text":415,"config":416},"Kostenlos testen",{"href":417,"dataGaName":32,"dataGaLocation":418},"https://gitlab.com/-/trials/new/","nav",{"altText":420,"config":421},"GitLab-Symbol",{"src":422,"dataGaName":423,"dataGaLocation":418},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758203874/jypbw1jx72aexsoohd7x.svg","gitlab icon",{"altText":420,"config":425},{"src":426,"dataGaName":423,"dataGaLocation":418},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758203875/gs4c8p8opsgvflgkswz9.svg",{"freeTrial":428,"mobileIcon":432,"desktopIcon":434},{"text":429,"config":430},"Erfahre mehr über GitLab Duo",{"href":61,"dataGaName":431,"dataGaLocation":418},"gitlab duo",{"altText":420,"config":433},{"src":422,"dataGaName":423,"dataGaLocation":418},{"altText":420,"config":435},{"src":426,"dataGaName":423,"dataGaLocation":418},"content:shared:de-de:main-navigation.yml","Main Navigation","shared/de-de/main-navigation.yml","shared/de-de/main-navigation",{"_path":441,"_dir":21,"_draft":6,"_partial":6,"_locale":7,"title":442,"button":443,"config":448,"_id":450,"_type":13,"_source":15,"_file":451,"_stem":452,"_extension":18},"/shared/de-de/banner","GitLab Duo Agent Platform ist jetzt in öffentlicher Beta!",{"text":444,"config":445},"Beta testen",{"href":446,"dataGaName":447,"dataGaLocation":27},"/de-de/gitlab-duo/agent-platform/","duo banner",{"layout":449},"release","content:shared:de-de:banner.yml","shared/de-de/banner.yml","shared/de-de/banner",{"_path":454,"_dir":21,"_draft":6,"_partial":6,"_locale":7,"data":455,"_id":658,"_type":13,"title":659,"_source":15,"_file":660,"_stem":661,"_extension":18},"/shared/de-de/main-footer",{"text":456,"source":457,"edit":463,"contribute":468,"config":473,"items":478,"minimal":650},"Git ist eine Marke von Software Freedom Conservancy und unsere Verwendung von „GitLab“ erfolgt unter Lizenz.",{"text":458,"config":459},"Quelltext der Seite anzeigen",{"href":460,"dataGaName":461,"dataGaLocation":462},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/","page source","footer",{"text":464,"config":465},"Diese Seite bearbeiten",{"href":466,"dataGaName":467,"dataGaLocation":462},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/content/","web ide",{"text":469,"config":470},"Beteilige dich",{"href":471,"dataGaName":472,"dataGaLocation":462},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/CONTRIBUTING.md/","please contribute",{"twitter":474,"facebook":475,"youtube":476,"linkedin":477},"https://x.com/gitlab","https://www.facebook.com/gitlab","https://www.youtube.com/channel/UCnMGQ8QHMAnVIsI3xJrihhg","https://www.linkedin.com/company/gitlab-com",[479,502,557,586,620],{"title":45,"links":480,"subMenu":485},[481],{"text":482,"config":483},"DevSecOps-Plattform",{"href":54,"dataGaName":484,"dataGaLocation":462},"devsecops platform",[486],{"title":188,"links":487},[488,492,497],{"text":489,"config":490},"Tarife anzeigen",{"href":190,"dataGaName":491,"dataGaLocation":462},"view plans",{"text":493,"config":494},"Vorteile von Premium",{"href":495,"dataGaName":496,"dataGaLocation":462},"/de-de/pricing/premium/","why premium",{"text":498,"config":499},"Vorteile von Ultimate",{"href":500,"dataGaName":501,"dataGaLocation":462},"/de-de/pricing/ultimate/","why ultimate",{"title":503,"links":504},"Lösungen",[505,510,513,515,520,525,529,532,535,540,542,544,547,552],{"text":506,"config":507},"Digitale Transformation",{"href":508,"dataGaName":509,"dataGaLocation":462},"/de-de/topics/digital-transformation/","digital transformation",{"text":511,"config":512},"Sicherheit und Compliance",{"href":136,"dataGaName":137,"dataGaLocation":462},{"text":121,"config":514},{"href":104,"dataGaName":105,"dataGaLocation":462},{"text":516,"config":517},"Agile Entwicklung",{"href":518,"dataGaName":519,"dataGaLocation":462},"/de-de/solutions/agile-delivery/","agile delivery",{"text":521,"config":522},"Cloud-Transformation",{"href":523,"dataGaName":524,"dataGaLocation":462},"/de-de/topics/cloud-native/","cloud transformation",{"text":526,"config":527},"SCM",{"href":118,"dataGaName":528,"dataGaLocation":462},"source code management",{"text":108,"config":530},{"href":110,"dataGaName":531,"dataGaLocation":462},"continuous integration & delivery",{"text":160,"config":533},{"href":162,"dataGaName":534,"dataGaLocation":462},"value stream management",{"text":536,"config":537},"GitOps",{"href":538,"dataGaName":539,"dataGaLocation":462},"/de-de/solutions/gitops/","gitops",{"text":173,"config":541},{"href":175,"dataGaName":176,"dataGaLocation":462},{"text":178,"config":543},{"href":180,"dataGaName":181,"dataGaLocation":462},{"text":545,"config":546},"Öffentlicher Sektor",{"href":185,"dataGaName":186,"dataGaLocation":462},{"text":548,"config":549},"Bildungswesen",{"href":550,"dataGaName":551,"dataGaLocation":462},"/de-de/solutions/education/","education",{"text":553,"config":554},"Finanzdienstleistungen",{"href":555,"dataGaName":556,"dataGaLocation":462},"/de-de/solutions/finance/","financial services",{"title":193,"links":558},[559,561,563,565,568,570,572,574,576,578,580,582,584],{"text":205,"config":560},{"href":207,"dataGaName":208,"dataGaLocation":462},{"text":210,"config":562},{"href":212,"dataGaName":213,"dataGaLocation":462},{"text":215,"config":564},{"href":217,"dataGaName":218,"dataGaLocation":462},{"text":220,"config":566},{"href":222,"dataGaName":567,"dataGaLocation":462},"docs",{"text":243,"config":569},{"href":245,"dataGaName":246,"dataGaLocation":462},{"text":238,"config":571},{"href":240,"dataGaName":241,"dataGaLocation":462},{"text":248,"config":573},{"href":250,"dataGaName":251,"dataGaLocation":462},{"text":261,"config":575},{"href":263,"dataGaName":264,"dataGaLocation":462},{"text":253,"config":577},{"href":255,"dataGaName":256,"dataGaLocation":462},{"text":266,"config":579},{"href":268,"dataGaName":269,"dataGaLocation":462},{"text":271,"config":581},{"href":273,"dataGaName":274,"dataGaLocation":462},{"text":276,"config":583},{"href":278,"dataGaName":279,"dataGaLocation":462},{"text":281,"config":585},{"href":283,"dataGaName":284,"dataGaLocation":462},{"title":299,"links":587},[588,590,592,594,596,598,600,604,609,611,613,615],{"text":306,"config":589},{"href":308,"dataGaName":301,"dataGaLocation":462},{"text":311,"config":591},{"href":313,"dataGaName":314,"dataGaLocation":462},{"text":319,"config":593},{"href":321,"dataGaName":322,"dataGaLocation":462},{"text":324,"config":595},{"href":326,"dataGaName":327,"dataGaLocation":462},{"text":329,"config":597},{"href":331,"dataGaName":332,"dataGaLocation":462},{"text":334,"config":599},{"href":336,"dataGaName":337,"dataGaLocation":462},{"text":601,"config":602},"Sustainability",{"href":603,"dataGaName":601,"dataGaLocation":462},"/sustainability/",{"text":605,"config":606},"Vielfalt, Inklusion und Zugehörigkeit",{"href":607,"dataGaName":608,"dataGaLocation":462},"/de-de/diversity-inclusion-belonging/","Diversity, inclusion and belonging",{"text":339,"config":610},{"href":341,"dataGaName":342,"dataGaLocation":462},{"text":349,"config":612},{"href":351,"dataGaName":352,"dataGaLocation":462},{"text":354,"config":614},{"href":356,"dataGaName":357,"dataGaLocation":462},{"text":616,"config":617},"Transparenzerklärung zu moderner Sklaverei",{"href":618,"dataGaName":619,"dataGaLocation":462},"https://handbook.gitlab.com/handbook/legal/modern-slavery-act-transparency-statement/","modern slavery transparency statement",{"title":621,"links":622},"Nimm Kontakt auf",[623,626,628,630,635,640,645],{"text":624,"config":625},"Sprich mit einem Experten/einer Expertin",{"href":36,"dataGaName":37,"dataGaLocation":462},{"text":368,"config":627},{"href":370,"dataGaName":371,"dataGaLocation":462},{"text":373,"config":629},{"href":375,"dataGaName":376,"dataGaLocation":462},{"text":631,"config":632},"Status",{"href":633,"dataGaName":634,"dataGaLocation":462},"https://status.gitlab.com/","status",{"text":636,"config":637},"Nutzungsbedingungen",{"href":638,"dataGaName":639,"dataGaLocation":462},"/terms/","terms of use",{"text":641,"config":642},"Datenschutzerklärung",{"href":643,"dataGaName":644,"dataGaLocation":462},"/de-de/privacy/","privacy statement",{"text":646,"config":647},"Cookie-Einstellungen",{"dataGaName":648,"dataGaLocation":462,"id":649,"isOneTrustButton":90},"cookie preferences","ot-sdk-btn",{"items":651},[652,654,656],{"text":636,"config":653},{"href":638,"dataGaName":639,"dataGaLocation":462},{"text":641,"config":655},{"href":643,"dataGaName":644,"dataGaLocation":462},{"text":646,"config":657},{"dataGaName":648,"dataGaLocation":462,"id":649,"isOneTrustButton":90},"content:shared:de-de:main-footer.yml","Main Footer","shared/de-de/main-footer.yml","shared/de-de/main-footer",{"allPosts":663,"featuredPost":1616,"totalPagesCount":1635,"initialPosts":1636},[664,688,715,734,758,778,799,821,847,869,891,914,935,956,979,1002,1024,1045,1066,1086,1106,1125,1148,1169,1189,1212,1232,1253,1273,1292,1314,1334,1353,1374,1395,1414,1434,1457,1475,1495,1515,1534,1554,1574,1595],{"_path":665,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":666,"content":670,"config":681,"_id":684,"_type":13,"title":685,"_source":15,"_file":686,"_stem":687,"_extension":18},"/de-de/blog/a-developers-guide-to-building-secure-retail-apps-with-gitlab",{"config":667,"title":668,"description":669},{"noIndex":6},"Leitfaden für das Entwickeln sicherer Retail-Apps mit GitLab","So hilft die DevSecOps-Plattform Händlern bei der Entwicklung sicherer, konformer Software für komplexe Retail-Umgebungen.",{"title":668,"description":669,"authors":671,"body":674,"category":675,"tags":676,"date":679,"heroImage":680},[672,673],"Itzik Gan Baruch","Rebeca Fenoy-Anthony","Händler stehen bei der Anwendungssicherheit vor besonderen Herausforderungen – hauptsächlich weil die **Angriffsfläche durch die Komplexität des modernen Handels größer ist als je zuvor**. Von mobilen Apps und KI-gestützter Personalisierung bis zu Omni-Channel-Plattformen und IoT im Geschäft – jeder Berührungspunkt erhöht die Anzahl der Systeme, die gesichert und überwacht werden müssen. Eine einzelne Schwachstelle betrifft nicht nur eine Komponente, sondern kann sich auf Zahlungsabwickler, Bestandssysteme, Kundendaten und letztendlich das Markenvertrauen auswirken.\n\nTraditionelle Sicherheitsansätze, die früher funktionierten, können heute nicht mehr mithalten. Sicherheitsprozesse werden oft nachträglich hinzugefügt, was Teams verlangsamt und Risiken erhöht. Aber so muss es nicht sein.\n\n**Moderne Plattformen integrieren Sicherheit in den gesamten Entwicklungs-Lebenszyklus** und machen Security zu einem nahtlosen Teil des Entwickler-Workflows, nicht zu einer Barriere für die Bereitstellung. Dieser Ansatz verwandelt Sicherheit in einen strategischen Vorteil und ermöglicht Innovation ohne Kompromisse.\n\nIn diesem Artikel erfährst du, wie eine integrierte DevSecOps-Plattform Retail-Teams dabei hilft, steigenden Sicherheitsanforderungen gerecht zu werden, **ohne die Bereitstellung zu verlangsamen oder die Kundenerfahrung zu beeinträchtigen**.\n\n## Warum Retail-Sicherheit einen anderen Ansatz erfordert\n\nIm Einzelhandel geht es bei Sicherheit um mehr als nur Datenschutz – es geht um den Schutz der Kundenerfahrung, die für das Geschäftsergebnis entscheidend ist. Jede Verlangsamung, jeder Ausfall oder jede Schwachstelle kann zu Umsatzverlusten und gebrochenem Vertrauen führen. Handelsplattformen müssen online bleiben, Compliance-Standards erfüllen und sich gegen ununterbrochene Angriffe aus dem offenen Internet verteidigen. Im Gegensatz zu Unternehmenssystemen sind sie vollständig öffentlich zugänglich und haben eine viel breitere Angriffsfläche. Füge Drittanbieter-Integrationen, APIs und Legacy-Systeme hinzu, und es wird klar: Traditionelle Sicherheitsansätze reichen nicht aus.\n\nZur Komplexität kommt hinzu, dass Händler vor einzigartigen Herausforderungen stehen, die ihre Sicherheitsrisiken weiter erhöhen, darunter:\n\n### Fragilität der Lieferkette und API-Wildwuchs\n\nVersandverzögerungen, globale Instabilität und vernetzte Systeme stören die Logistik. Fast die Hälfte der Händler berichtet über Probleme mit der Produktverfügbarkeit, und 25 % fehlt die Echtzeit-Bestandstransparenz, laut einer [Umfrage von Fluent Commerce 2024](https://premierconstructionnews.com/2024/05/25/retails-revival-fluent-commerce-study-finds-93-of-uk-retailers-expect-business-growth-over-next-year-despite-economic-challenges-and-supply-chain-disruption/). Während KI-gestützte Prognosen helfen, schaffen unsichere APIs und fragile Integrationen in der digitalen Lieferkette Angriffsvektoren.\n\n### Legacy-Systeme treffen auf moderne Anforderungen\n\nViele Händler arbeiten mit monolithischen, veralteten Systemen, die Schwierigkeiten haben, mobile Apps, IoT-Geräte und Echtzeit-Analysen sicher zu unterstützen. Ohne sichere, agile Grundlagen wird jeder neue digitale Berührungspunkt zu einer potenziellen Schwachstelle.\n\n### KI- und Compliance-Komplexität\n\nKI verändert Einzelhandelserlebnisse durch personalisierte Empfehlungen und fortschrittliche Kundenverfolgungstechnologien wie Beacon-Sensoren, Gesichtserkennung und mobile App-Standortdienste, die Bewegungen und Verhalten in physischen Geschäften überwachen. Diese KI-gestützten Systeme verbessern sowohl Kundenerlebnisse als auch Nachfrageprognosen für Händler. Allerdings erfordern die [DSGVO](https://gdpr.eu/what-is-gdpr/) (die Datenschutz-Grundverordnung der Europäischen Union) und ähnliche globale Datenschutzgesetze sichere Datenverarbeitung und transparente KI-Logik. Sicherheitsfehler können zu erheblichen Geldstrafen und dauerhaftem Reputationsschaden führen.\n\n### Risiken bei kundenorientierten Automatisierungen\n\nSelf-Checkouts, Kioske und Chatbots versprechen Komfort und Kosteneinsparungen, aber oft fehlt die Sicherheitshärtung. Diese Berührungspunkte werden zu Einstiegspunkten für Cyberangreifer und ermöglichen traditionellen Diebstahl durch schwache Betrugserkennung, begrenzte Überwachung und leicht manipulierbare Systeme, die Ladendiebstahl schwerer erkennbar machen.\n\n### Unterschiedliche Bedrohungsflächen\n\nHändler befinden sich in einer einzigartigen Position, in der sie über mehrere Vektoren hinweg sichern müssen, die oft von global verteilten Teams gepflegt werden (je nach Größe der Organisation). E-Commerce-Plattformen, mobile Anwendungen, Point-of-Sale-(POS-)Systeme und IoT-Geräte im Geschäft bieten jeweils einen Einstiegspunkt für Bedrohungsakteure mit einzigartigen Eigenschaften, die verschiedene Sicherheitslösungen erfordern, um Widerstandsfähigkeit zu gewährleisten.\n\nDies schafft ein einzigartiges Paradoxon: Händler müssen schneller als je zuvor innovieren und gleichzeitig höhere Sicherheitsstandards als die meisten Branchen einhalten, während sie nahtlose Kundenerlebnisse über jeden Kanal hinweg liefern.\n\n## Warum traditionelle AppSec im Einzelhandel versagt\n\nDie meisten Händler verlassen sich auf unverbundene Sicherheitstools wie statische Anwendungssicherheitstests (SAST), Lizenzprüfer und Schwachstellenbewertungen, die isoliert arbeiten. Dieser fragmentierte Ansatz schafft kritische Lücken:\n\n* **Begrenzte Lebenszyklusabdeckung:** Tools konzentrieren sich auf enge Entwicklungsphasen und verpassen Lieferketten- und Laufzeitrisiken.\n* **Integrationsherausforderungen:** Lücken in Legacy-Systemen und schlechte Tool-Konnektivität schaffen Sicherheitsblindpunkte zwischen Teams und Lösungen.\n* **Manuelle Prozesse:** Sicherheitsübergaben schaffen Engpässe, und Probleme werden oft spät entdeckt, wenn sie kostspieliger zu beheben sind.\n* **Team-Silos:** Sicherheit bleibt isoliert von täglichen Entwicklungsworkflows und getrennt von Compliance- und IT-Teams.\n\n### Der Weg nach vorn\n\nIn der heutigen Einzelhandelslandschaft kann Sicherheit Innovation nicht verlangsamen. Die direkte Einbettung in den Entwicklungslebenszyklus und die Zusammenführung aller Teams auf einer einheitlichen DevSecOps-Plattform macht Sicherheit zu einem strategischen Vorteil statt zu einem Engpass.\n\n### Eine DevSecOps-Plattform ermöglicht sichere Innovation im großen Maßstab\n\nGitLab bietet das umfassendste Set an Sicherheitsscannern zur Maximierung der Anwendungsabdeckung, einschließlich:\n\n* [SAST](https://docs.gitlab.com/user/application_security/sast/)  \n* [DAST](https://docs.gitlab.com/user/application_security/dast/)  \n* [Abhängigkeitsscannen](https://docs.gitlab.com/user/application_security/dependency_scanning/dependency_scanning_sbom/) \n* [Container-Scannen](https://docs.gitlab.com/user/application_security/container_scanning/)  \n* [Geheimnis-Erkennung](https://docs.gitlab.com/user/application_security/secret_detection/)  \n* [Infrastructure-as-Code-Scannen](https://docs.gitlab.com/user/application_security/iac_scanning/)  \n* [Fuzz-Testing](https://docs.gitlab.com/user/application_security/api_fuzzing/)\n\nAber bei Sicherheit geht es nicht nur ums Scannen. Es geht darum, [die richtigen Richtlinien durchzusetzen](https://docs.gitlab.com/user/compliance/compliance_frameworks/), um sicherzustellen, dass Schwachstellen konsistent identifiziert und behoben werden. Mit GitLab erhalten Sicherheitsteams volle Kontrolle, um sicherzustellen, dass der richtige Scan zur richtigen Zeit auf der richtigen Anwendung ausgeführt wird und dass die Ergebnisse behandelt werden, bevor sie in die Produktion gelangen.\n\n![Sicherheitsscans in Pipeline](https://res.cloudinary.com/about-gitlab-com/image/upload/v1756988740/x2dteagn1z8tjfahmobv.png)\n\n\u003Ccenter>\u003Ci>Sicherheitsscans laufen in der CI/CD-Pipeline und liefern sofortiges Feedback zu potenziellen Schwachstellen.\u003C/i>\u003C/center>\n\u003Cp>\u003C/p>\n\n![Der Schwachstellenbericht zeigt alle Schwachstellen für ein bestimmtes Projekt oder eine Gruppe.](https://res.cloudinary.com/about-gitlab-com/image/upload/v1756988740/npsgvu5e0sd2kpoxug7f.png)\n\n\u003Ccenter>\u003Ci>Der Schwachstellenbericht zeigt alle Schwachstellen für ein bestimmtes Projekt oder eine Gruppe.\u003C/i>\u003C/center>\n\n### Eine Plattform für Dev, Sec und Ops\n\nRetail-Teams verschwenden unzählige Stunden damit, zwischen Tools zu wechseln, Daten manuell zu übertragen, Informationen zwischen Systemen aufgrund fragiler Integrationen zu verlieren und widersprüchliche Berichte abzugleichen. Eine einheitliche Plattform beseitigt diese Reibung:\n\n* **Einzige Quelle der Wahrheit** für Quellcode, Pipelines, Schwachstellen und Compliance  \n* **Kein Integrationsaufwand** oder Tool-Kompatibilitätsprobleme  \n* **Konsistente Workflows** über alle Teams und Projekte\n\nDas Ergebnis? Teams verbringen Zeit mit der Lösung von Problemen anstatt mit der Verwaltung von Tools.\n\n![Compliance-Center, wo Sie Compliance-Frameworks für Ihre Projekte durchsetzen können.](https://res.cloudinary.com/about-gitlab-com/image/upload/v1756988739/d2nzltd1a2gypywzhv5f.png)\n\n\u003Ccenter>\u003Ci>Im Compliance-Center kannst du Compliance-Frameworks für deine Projekte durchsetzen.\u003C/i>\u003C/center>\n\u003Cp>\u003C/p>\n\n![Im Merge Request benötigen Entwickler(innen) eine Genehmigung, wenn Risiken erkannt werden, bevor Code gemergt wird, gemäß definierten Richtlinien.](https://res.cloudinary.com/about-gitlab-com/image/upload/v1756988740/szoocztazaup2avkaxhu.png)\n\n\u003Ccenter>\u003Ci>Im Merge Request benötigen Entwickler(innen) eine Genehmigung, wenn Risiken erkannt werden, bevor Code gemergt wird, gemäß definierten Richtlinien.\u003C/i>\u003C/center>\n\n### Geteilte Sicherheitsverantwortung, keine Silos\n\nDie erfolgreichsten Retail-Sicherheitsprogramme machen Sicherheit zur Verantwortung aller, nicht nur zur Last des Sicherheitsteams.\n\n**Entwickler(innen)-Ermächtigung**\n\nSicherheits- und Compliance-Anleitungen erscheinen direkt in Merge Requests, wodurch es unmöglich wird, kritische Probleme zu übersehen. Entwickler(innen) erhalten sofortiges Feedback zu jedem Commit mit klaren Erklärungen zu Risiken und Behebungsschritten. Zum Beispiel helfen KI-gestützte Schwachstellenerklärung und Schwachstellenbehebung Entwickler(inne)n, Sicherheitsprobleme unabhängig zu verstehen und zu beheben, wodurch Engpässe reduziert und Sicherheitsexpertise im gesamten Team aufgebaut wird.\n\n![Schwachstellenseite mit Schaltfläche zur Erklärung oder Lösung von Problemen mit KI. Hilft, die Wissenslücke mit KI zu überbrücken.](https://res.cloudinary.com/about-gitlab-com/image/upload/v1756988741/uenrjye3arfg9wjtwss1.png)\n\n\u003Ccenter>\u003Ci>Schwachstellenseite mit Schaltfläche zur Erklärung oder Lösung von Problemen mit KI. Hilft, die Wissenslücke mit KI zu überbrücken.\u003C/i>\u003C/center>\n\n\u003Cp>\u003C/p>\n\n**Automatisierte Compliance**\n\nGeneriere Audit-Berichte, verfolge die Lizenznutzung und pflege eine Software-Stückliste (SBOM) ohne manuellen Aufwand.\n\n![GitLabs automatisierter Abhängigkeitsbericht bietet eine umfassende SBOM, die alle Projektabhängigkeiten mit ihrem Schwachstellenstatus, Lizenzdetails und Sicherheitsergebnissen für vollständige Transparenz und Compliance anzeigt.](https://res.cloudinary.com/about-gitlab-com/image/upload/v1756988739/gpakhdvkegloqxhaeje8.png)\n\n\u003Ccenter>\u003Ci>GitLabs automatisierter Abhängigkeitsbericht bietet eine umfassende SBOM, die alle Projektabhängigkeiten mit ihrem Schwachstellenstatus, Lizenzdetails und Sicherheitsergebnissen für vollständige Transparenz und Compliance anzeigt.\u003C/i>\u003C/center>\n\u003Cp>\u003C/p>\n\nDieser Ansatz verwandelt Sicherheit von einem HIndernis, das die Bereitstellung verlangsamt, in ein Fundament, das selbstbewusste, schnelle Innovation ermöglicht.\n\n## Plattform vs. Einzeltools: Was Händler wissen müssen\n\n| Fähigkeit                      | Einzeltools              | GitLab DevSecOps-Plattform                     |\n| ------------------------------ | ------------------------ | ---------------------------------------------- |\n| SAST/DAST/API/Fuzz             | Getrennt & begrenzt      | Vollständig integriert                         |\n| Lizenz- & Abhängigkeitsscannen | Oft externe Tools        | Eingebaut                                      |\n| Compliance- & Audit-Berichte   | Manuell oder unverbunden | Automatisiert mit Nachverfolgbarkeit           |\n| Zusammenarbeit zwischen Teams  | Fragmentiert             | Einheitliche Umgebung                          |\n| End-to-End-Sichtbarkeit        | Tool-spezifisch          | Vollständiger Lebenszyklus + Wertstrom-Ansicht |\n\n## Das Fazit: Sicherheitsexzellenz treibt den Einzelhandelserfolg voran\n\nIm Einzelhandel geht es bei Sicherheit nicht nur um Datenschutz, sondern um den Schutz der Kundenerfahrung, die den Umsatz antreibt. Wenn Sicherheit Veröffentlichungen verlangsamt oder Schwachstellen schafft, wirkt sich das direkt auf den Umsatz aus. Kunden erwarten jedes Mal sichere, nahtlose Erlebnisse.\n\nGitLabs integrierte DevSecOps-Plattform hilft Händlern:\n\n* **Schneller bereitzustellen ohne Sicherheitskompromisse** mit automatisierten Scans, die Probleme erkennen, bevor Kunden es tun.  \n* **Compliance-Anforderungen mühelos zu erfüllen** durch integrierte Berichterstattung für DSGVO, PCI-DSS und Branchenstandards.  \n* **Sicherheitstoolkosten erheblich zu senken** durch Ersatz mehrerer Einzellösungen mit einer Plattform.  \n* **Entwickler(innen) zu Sicherheitsbefürwortern zu machen** mit Anleitung und Automatisierung, nicht mit Hindernissen.\n\nTeste hier einige der Sicherheitsfunktionen von GitLab:\n\n* [Schwachstellen mit GitLab Duo beheben](https://gitlab.navattic.com/ve-vr-short)   \n* [Scans zur Pipeline hinzufügen](https://gitlab.navattic.com/gitlab-scans)  \n* [Compliance-Frameworks](https://gitlab.navattic.com/compliance-short)  \n* [Erweiterte SAST](https://gitlab.navattic.com/advanced-sast-short)\n\n> Bereit loszulegen? Entdecke, wie GitLab Ultimate mit Duo Enterprise deine Retail-Sicherheitsstrategie mit einer [kostenlosen Testversion](https://about.gitlab.com/free-trial/) optimieren kann.","security",[675,677,9,678],"product","AI/ML","2025-09-04","https://res.cloudinary.com/about-gitlab-com/image/upload/v1756989645/fojzxakmfdea6jfqjkrl.png",{"featured":90,"template":682,"slug":683},"BlogPost","a-developers-guide-to-building-secure-retail-apps-with-gitlab","content:de-de:blog:a-developers-guide-to-building-secure-retail-apps-with-gitlab.yml","A Developers Guide To Building Secure Retail Apps With Gitlab","de-de/blog/a-developers-guide-to-building-secure-retail-apps-with-gitlab.yml","de-de/blog/a-developers-guide-to-building-secure-retail-apps-with-gitlab",{"_path":689,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":690,"content":698,"config":709,"_id":711,"_type":13,"title":712,"_source":15,"_file":713,"_stem":714,"_extension":18},"/de-de/blog/automating-with-gitlab-duo-part-1-generating-tests",{"title":691,"description":692,"ogTitle":691,"ogDescription":692,"noIndex":6,"ogImage":693,"ogUrl":694,"ogSiteName":695,"ogType":696,"canonicalUrls":694,"schema":697},"Automatisierung mit GitLab Duo, Teil 1: Generierung von Tests","Hier erfährst du, wie wir die KI-gestützte DevSecOps-Plattform genutzt haben, um automatisierte Tests zu erstellen und unsere Entwicklungsgeschwindigkeit und -qualität zu verbessern.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097480/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%284%29_3LZkiDjHLjhqEkvOvBsVKp_1750097480784.png","https://about.gitlab.com/blog/automating-with-gitlab-duo-part-1-generating-tests","https://about.gitlab.com","article","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Automatisierung mit GitLab Duo, Teil 1: Generierung von Tests\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Byron Boots\"}],\n        \"datePublished\": \"2024-12-02\",\n      }\n                  ",{"title":691,"description":692,"authors":699,"heroImage":693,"date":701,"body":702,"category":703,"tags":704,"updatedDate":708},[700],"Byron Boots","2024-12-02","Automatisierte Tests sind zeitaufwändig und können das Gefühl vermitteln, ein Projekt nicht voranzubringen. Doch wie viele Entwickler(innen) wahrscheinlich schon erlebt haben, machen sich automatisierte Tests insgesamt positiv bemerkbar. Für die Entwicklung eines benutzerdefinierten Moduls (in diesem Artikel nennen wir es gitlab-helper) traf dies besonders zu.\n\nZu Beginn der Entwicklung konzentrierten wir uns darauf, bewährte Funktionen aus bestehenden Skripts in ein neues Modul zu migrieren, dessen einziger Zweck es war, als Grundlage für zukünftige Funktionen zu dienen. Obwohl die bestehenden Skripts nicht automatisiert getestet wurden, war ihre konsequente Nutzung ein deutlicher Beweis dafür, dass die Funktionen wie erwartet funktionierten.\n\nUnser Ziel war es, eine ausgereiftere Lösung für dieses Problem zu entwickeln, sodass automatisierte Tests unumgänglich wurden. Das stellte uns vor die Herausforderung, die Entwicklung effizient zu gestalten und gleichzeitig die Zeit für das Testen und die Sicherstellung eines robusten Produkts unter einen Hut zu bringen; mit insgesamt nur drei Teammitgliedern war das gar nicht mal so einfach. Deshalb entschied sich das Team, für die Testerstellung die Vorteile unserer KI-Suite [GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/) zu nutzen und so die Entwicklungsgeschwindigkeit und Qualität des fertigen Produkts zu verbessern.\n\nIn dieser dreiteiligen Serie zur Automatisierung mit GitLab Duo behandeln wir die folgenden Punkte:\n\n1. Wie wir GitLab Duo verwendet haben, um Tests für unseren Code zu erstellen  \n2. Wie wir bei komplexeren Situationen interaktiv mit GitLab Duo gearbeitet haben  \n3. Die Ergebnisse, die wir erzielen konnten (Spoiler: 1 Person + GitLab Duo = 84 % Testabdeckung in 2 Tagen)\n\n## GitLab Duo zur Erstellung von Tests für Code verwenden\n\nDieser Artikel behandelt die Verwendung von GitLab Duo in VS Code mit der [GitLab Workflow Extension for VS Code](https://marketplace.visualstudio.com/items?itemName=GitLab.gitlab-workflow) (nur in englischer Sprache verfügbar), um Tests zu generieren. Diese Funktionalität ist in mehreren Tools verfügbar. Links zu anderen GitLab-Duo-Optionen findest du in den [Referenzen](#Referenzen) weiter unten.\n\n### GitLab Duo installieren und aktivieren\n\nUm GitLab Duo nutzen zu können, benötigen wir ein Konto, auf dem GitLab Duo aktiviert ist. Wenn du GitLab Duo noch nicht aktiviert hast, kannst du dich für eine [kostenlose Testversion anmelden](https://about.gitlab.com/de-de/solutions/gitlab-duo-pro/sales/?type=free-trial).Um GitLab Duo Chat in VS Code zu verwenden, folgten wir den [Anweisungen zur Installation](https://docs.gitlab.com/ee/user/gitlab_duo_chat/#use-gitlab-duo-chat-in-vs-code) (nur in englischer Sprache verfügbar). Dann war die GitLab-Duo-Chat-Erweiterung in der Seitenleiste verfügbar und wir konnten das Chat-Fenster öffnen.\n\n![Stelle-eine-Frage-Fenster](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097489/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750097488918.png)\n\n### Tests mit Chat generieren\n\ngitlab-helper ist ein benutzerdefiniertes Modul, das für die Standardisierung der Interaktion mit der GitLab-API innerhalb des Teams entwickelt wurde und andere Bibliotheksfunktionen erweitert, um die Entwicklungs- und Skriptarbeit zu vereinfachen. Sobald eine Methode oder Funktion in gitlab-helper migriert wurde und angemessen implementiert zu sein schien, konnten ganz einfach Tests dafür erstellt werden:\n- Wir wählten die Methode, die Klasse oder die gesamte Datei in der IDE aus.\n- Wir öffneten das Menü für den ausgewählten Code mit der rechten Maustaste.\n- Unter **GitLab Duo Chat** wählten wir **Tests generieren** aus.\n\n![Reihenfolge für die Erstellung von Tests, einschließlich der Auswahl-Liste für die Erstellung von Tests](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097489/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097488919.png)\n\nInnerhalb weniger Sekunden waren die Tests erstellt und im GitLab-Duo-Chat-Fenster angezeigt. Diese Tests können überprüft und/oder durch Kopieren/Einfügen in bestehende oder neue Testdateien zur Codebase hinzugefügt werden. Wie bei den meisten Ergebnissen von linguistischer Datenverarbeitung, vor allem wenn es um den Kontext geht, schlugen einige der ersten von GitLab Duo erstellten Tests fehl, so dass eine Feinabstimmung erforderlich war (z. B. beim Umgang mit verschachtelten Abhängigkeiten).\n\n> **Profi-Tipp:** GitLab Duo erstellt nicht automatisch Dateien, in die generierte Tests eingefügt werden können. Wir haben festgestellt, dass es hilfreich ist, neue Testdateien zu erstellen und sie mit dem Kommentar `# Tests Generated by Duo` zu versehen und ihnen den Zusatz `_duo.py` hinzuzufügen, um anzugeben, woher die Tests stammen.\n\nGitLab Duo war ein großartiger Ausgangspunkt für die Entwicklung der automatisierten Tests von gitlab-helper und hat die Effizienz beim Schreiben von Tests und die Testabdeckung erheblich verbessert, was den Entwicklungsprozess erheblich beschleunigt hat. Neben GitLab Duo wurden zahlreiche sinnvolle Tests unter menschlicher Aufsicht in das gitlab-helper-Modul integriert.\n\nIm nächsten Teil dieser Serie erfährst du, [was wir bei der Verwendung von GitLab Duo für die Erstellung automatisierter Tests und die interaktive Arbeit mit KI für komplexere Situationen gelernt haben](https://about.gitlab.com/de-de/blog/automating-with-gitlab-duo-part-2-complex-testing/).\n\n## Referenzen\n\nEs gibt mehr als eine Möglichkeit, GitLab Duo zu verwenden, um Tests zu generieren. Sieh dir die anderen Optionen unten an:\n\n* Die GitLab-Benutzeroberfläche  \n* [Die GitLab-Web-IDE (VS Code in der Cloud)](https://docs.gitlab.com/ee/user/project/web_ide/index.html) (nur in englischer Sprache verfügbar) \n* VS Code, mit der [GitLab Workflow Extension for VS Code](https://marketplace.visualstudio.com/items?itemName=GitLab.gitlab-workflow) (nur in englischer Sprache verfügbar)\n* JetBrains IDEs, mit dem [GitLab-Duo-Plugin für JetBrains](https://plugins.jetbrains.com/plugin/22325-gitlab-duo)  (nur in englischer Sprache verfügbar) \n* Visual Studio für Windows mit der [GitLab-Erweiterung für Visual Studio](https://marketplace.visualstudio.com/items?itemName=GitLab.GitLabExtensionForVisualStudio) (nur in englischer Sprache verfügbar)\n","ai-ml",[678,705,706,707,9],"tutorial","testing","DevSecOps platform","2025-01-14",{"slug":710,"featured":6,"template":682},"automating-with-gitlab-duo-part-1-generating-tests","content:de-de:blog:automating-with-gitlab-duo-part-1-generating-tests.yml","Automating With Gitlab Duo Part 1 Generating Tests","de-de/blog/automating-with-gitlab-duo-part-1-generating-tests.yml","de-de/blog/automating-with-gitlab-duo-part-1-generating-tests",{"_path":716,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":717,"content":723,"config":728,"_id":730,"_type":13,"title":731,"_source":15,"_file":732,"_stem":733,"_extension":18},"/de-de/blog/automating-with-gitlab-duo-part-3-validating-testing",{"title":718,"description":719,"ogTitle":718,"ogDescription":719,"noIndex":6,"ogImage":720,"ogUrl":721,"ogSiteName":695,"ogType":696,"canonicalUrls":721,"schema":722},"Automatisierung mit GitLab Duo, Teil 3: Validierung von Tests","Hier erfährst du, welche Tests wir durchgeführt haben, um die Auswirkungen von GitLab Duo auf die automatisierten Tests unseres Teams zu überprüfen – und welche Ergebnisse wir erzielt haben.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097447/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%284%29_3LZkiDjHLjhqEkvOvBsVKp_1750097447404.png","https://about.gitlab.com/blog/automating-with-gitlab-duo-part-3-validating-testing","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Automatisierung mit GitLab Duo, Teil 3: Validierung von Tests\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Byron Boots\"}],\n        \"datePublished\": \"2024-12-17\",\n      }\n                  ",{"title":718,"description":719,"authors":724,"heroImage":720,"date":725,"body":726,"category":703,"tags":727},[700],"2024-12-17","In früheren Beiträgen dieser Serie haben wir beschrieben, [wie wir GitLab Duo zur Erstellung von Tests für unseren Code verwendet haben](https://about.gitlab.com/de-de/blog/automating-with-gitlab-duo-part-1-generating-tests/) und [was wir bei der Verwendung von GitLab Duo zur Erstellung automatisierter Tests gelernt haben](https://about.gitlab.com/de-de/blog/automating-with-gitlab-duo-part-2-complex-testing/). Wir haben auch darüber berichtet, wie wir Änderungen an den von GitLab Duo generierten Tests vorgenommen haben. In diesem letzten Artikel der Reihe geht es um einen Test, den wir durchgeführt haben, um die Auswirkungen von GitLab Duo auf die automatisierten Tests unseres Teams zu validieren, und um die beeindruckenden Ergebnisse, die wir bis jetzt erzielt haben.\n\n### Ergebnisse des Validierungstests\n\nUm zu überprüfen, ob die Nutzung von GitLab Duo zur Erstellung von Tests den erwarteten Mehrwert bringt, haben wir uns selbst und GitLab Duo vor die Aufgabe gestellt, Tests zu ersetzen und die Testabdeckung zu erhöhen. Das Team entfernte alle bereits geschriebenen Tests, um die Testabdeckung auf 0 % zu bringen. Dann ging es methodisch durch das Repository und erstellte neue Testdateien, um die von GitLab Duo generierten Tests zu speichern.\n\nVon diesem Ausgangspunkt aus folgte das Team den Schritten, die im [ersten Blogbeitrag](https://about.gitlab.com/de-de/blog/automating-with-gitlab-duo-part-1-generating-tests/) beschrieben sind, um Tests zu erstellen. Um eine stabile Kontrollgruppe zu haben, wurden die Tests und Testdateien nicht von Menschen verändert. Für die Identifizierung, woher die Tests stammen, wurde am Anfang der Datei der Kommentar `Tests Generated by Duo` sowie am Ende der Zusatz `duo.py` hinzugefügt.\n\nAlle Iterationen der Tests erfolgten ausschließlich durch Interaktion mit GitLab Duo über `Generate Tests` und das GitLab-Duo-Chat-Fenster, wie [im zweiten Blogartikel dieser Reihe](https://about.gitlab.com/de-de/blog/automating-with-gitlab-duo-part-2-complex-testing/) beschrieben. Wie bereits erwähnt, haben wir GitLab Duo gebeten, Aktualisierungen vorzunehmen, die auf aufgetretenen Fehlern, fehlgeschlagenen Tests und Beispielcode-Schnipseln basieren, die GitLab Duo als zusätzlichen Kontext verwenden kann.\n\nBeim Testen mit GitLab Duo haben wir ständig Tests ausgeführt und Abdeckungsberichte erstellt, damit wir sehen konnten, ob unsere von GitLab Duo generierten Tests die Testabdeckung erhöhen und den erwarteten Mehrwert bringen. Mit der [Visualisierung der Testabdeckung von GitLab](https://docs.gitlab.com/ee/ci/testing/test_coverage_visualization/) (nur in englischer Sprache verfügbar) konnten wir die Ergebnisse unserer Arbeit kontinuierlich überwachen.\n\nNachdem wir mit GitLab Duo die Tests für den Code neu erstellt hatten, der zuvor hauptsächlich durch manuelle Tests abgedeckt war, konnten wir schließlich eine Testabdeckung von 84 % erreichen. Das war ein großer Erfolg für das Team, denn:\n\n1. Es war eine signifikante Verbesserung gegenüber der vorherigen Abdeckung, die bei 74 % lag.  \n2. Eine einzelne Person brauchte etwa zwei Tage, um eine Testabdeckung von 84 % zu erreichen, während zuvor mehrere Entwickler(innen) etwa vier Wochen für die manuelle Testabdeckung von 74 %  benötigt hatten.\n\nSeit diesem Experiment hat das Team die Abdeckung mit Hilfe von GitLab Duo sogar noch auf 89 % erhöht und gleichzeitig neue Funktionen eingeführt.\n\n![Abbildung der Erfolge](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097456/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097456771.png)\n\nDurch den Einsatz von GitLab Duo konnten die Testeffizienz und die Testabdeckung erhöht werden. Außerdem konnten Entwickler(innen), die mit dem vorhandenen Code weniger vertraut sind, schnell sinnvolle Tests schreiben. Das hat das Vertrauen des Teams gestärkt, neue Funktionen zu entwickeln, ohne befürchten zu müssen, Fehler einzuführen.\n\n> Wenn du [GitLab Duo ausprobieren](https://about.gitlab.com/de-de/solutions/gitlab-duo-pro/sales/) möchtest, melde dich noch heute für eine kostenlose Testversion an!\n",[678,706,707,9],{"slug":729,"featured":6,"template":682},"automating-with-gitlab-duo-part-3-validating-testing","content:de-de:blog:automating-with-gitlab-duo-part-3-validating-testing.yml","Automating With Gitlab Duo Part 3 Validating Testing","de-de/blog/automating-with-gitlab-duo-part-3-validating-testing.yml","de-de/blog/automating-with-gitlab-duo-part-3-validating-testing",{"_path":735,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":736,"content":742,"config":752,"_id":754,"_type":13,"title":755,"_source":15,"_file":756,"_stem":757,"_extension":18},"/de-de/blog/best-practices-to-set-up-organizational-hierarchies-that-scale",{"ogTitle":737,"schema":738,"ogImage":739,"ogDescription":740,"ogSiteName":695,"noIndex":6,"ogType":696,"ogUrl":741,"title":737,"canonicalUrls":741,"description":740},"Skalierbare Unternehmenshierarchien: Bewährte Methoden","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Bewährte Methoden zum Einrichten von Unternehmenshierarchien, die skalierbar sind\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Amanda Rueda\"}],\n        \"datePublished\": \"2024-07-22\",\n      }","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098165/Blog/Hero%20Images/Blog/Hero%20Images/agile_agile.png_1750098164666.png","Erfahre, wie du eine Organisationshierarchie in GitLab modellierst. Erstelle Strukturen mit klaren Kommunikationslinien, strategischer Ausrichtung und mehr und halte gleichzeitig die Prinzipien der Agile-Methodik ein.","https://about.gitlab.com/blog/best-practices-to-set-up-organizational-hierarchies-that-scale",{"heroImage":739,"body":743,"authors":744,"updatedDate":746,"date":747,"title":748,"tags":749,"description":740,"category":751},"Um die Vorteile deines GitLab-Abonnements optimal zu nutzen, muss dein Unternehmen effektiv eingerichtet werden. Hier findest du eine einfache Anleitung, um deine Gruppen-, Untergruppen und Projektstruktur zu konfigurieren und so dein GitLab-Erlebnis zu optimieren.\n\n## Struktur verstehen: Gruppen, Untergruppen und Projekte\n\nMit Gruppen und Projekten kannst du deine Organisationshierarchie nachbilden, eine erweiterte Berechtigungsverwaltung ermöglichen und eine Planung eines „Teams von Teams“ entwickeln. Verwende Gruppen und Untergruppen für die strategische Planung und ein Konfigurationsmanagement, das sich in Untergruppen und Projekte, die weiter unten in der Hierarchie stehen, untergliedert.\n\nDarüber hinaus kannst du auch deine Wertschöpfungsketten nachbilden, das Projektmanagement optimieren sowie die Zusammenarbeit in deinem Unternehmen verbessern.\n\n- **Projektebene (Teamebene)**\n    - Projekte sind innerhalb von Gruppen oder Untergruppen verschachtelt und sind der Ort, an dem deine eigentliche Arbeit erfolgt. Hier befinden sich Repositories und die projektspezifischen Einstellungen werden hier verwaltet. Auf dieser Ebene erhältst du Einblick in die täglichen Aktivitäten und die detaillierte Projektverfolgung.\n    - Eine effektive Projektkonfiguration sorgt für klare, organisierte Daten, die wiederum unerlässlich für genaue Berichte und Analysen sind.\n\n- **Untergruppenebene (Team aus Teams)**\n    - Untergruppen bieten eine granulare Berechtigungsverwaltung und können an die Anforderungen bestimmter Teams und Projekte angepasst werden. So stellen sie einen konsistenten Workflow im gesamten Unternehmen sicher. \n    - Untergruppen fungieren als Cluster verwandter Projekte, ähnlich wie ein „Team von Teams“ in Agile. \n    - Diese Ebene ist ideal für die Verwaltung mehrerer Teams, die an einem gemeinsamen Produkt oder einen gemeinsamen Dienst arbeiten. Sie erleichtert die projektübergreifende Sichtbarkeit und Integration, was die Synchronisation zwischen Teams unterstützt, um Abhängigkeiten oder gemeinsame Ziele abzustimmen.\n\n- **Gruppenebene (Team aus Team aus Teams)**\n    - Stell dir Gruppen als organisatorische Säulen in GitLab vor, mit denen breite Berechtigungen und Zugriffsrechte verwaltet werden.\n    - Auf höchster Ebene umfassen Gruppen mehrere Untergruppen und sind die strategische Ebene im Projektmanagement, ähnlich wie „Team aus Team aus Teams“ in Agile.\n    - In dieser Stufe werden übergeordnete Ziele und Strategien festgelegt, Einstellungen definiert und Ressourcen über Projekte und Untergruppen übergreifend zugewiesen, um sicherzustellen, dass diese den übergeordneten Geschäftszielen entsprechen.\n\nIndem du dein Unternehmen mit GitLab strukturierst, bildest du deine gewählte Agile Methodik ab. Dies kann dir dabei helfen, die Agile-Prinzipien selbstverständlicher in deinen Projekten umzusetzen. Diese Struktur fördert klare Kommunikationslinien, effektives Ressourcenmanagement und eine strategische Ausrichtung, während gleichzeitig die Flexibilität und Reaktionsschnelligkeit, die für Agile Methoden ausschlaggebend sind, beibehalten werden.\n\n> Informiere dich über Neuigkeiten und Erkenntnisse zur [Agile Planung mit GitLab](https://about.gitlab.com/blog/categories/agile-planning/).\n\n## Nutzung des GitLab-Vererbungsmodells\n\nEine der leistungsstarken Funktionen von GitLab ist das [Vererbungsmodell](https://docs.gitlab.com/ee/tutorials/scrum_events/index.html#understanding-the-inheritance-model-in-gitlab), mit dem Einstellungen, Berechtigungen und Konfigurationen auf höheren Ebenen automatisch auf niedrigere Ebenen in der Hierarchie angewendet werden können. Umgekehrt stehen Daten auf niedrigeren Ebenen sofort auf höheren Ebenen in der Struktur zur Verfügung. Mit dem Vererbungsmodell erhältst du aus übergeordneten Gruppen Sichtbarkeit über das gesamte Portfolio und stellst weiter unten in der Hierarchie eigene Orte bereit, in denen die einzelnen Teams ihre Arbeit verwalten können.\n\nBeispiele:\n- **Erstelle Meilensteine und Labels in deinen höheren Gruppen**, um diese auf alle Untergruppen und Projekte zu verteilen. So förderst du Konsistenz und die Einhaltung von Unternehmensstandards.\n- **Tickets und Epics** in untergeordneten Projekten und Untergruppen werden in der Wertstromhierarchie nach oben befördert, damit das Programm-Management und die Führungsebene leichter darauf zugreifen können. \n- **Verwalte Benutzerberechtigungen auf Gruppenebene oder in der Hauptuntergruppe**, um die Berechtigungen und die Zugriffskontrolle zu optimieren. Dadurch kann die Verwaltung der Zugangskontrolle vereinfacht und sichergestellt werden, dass die richtigen Personen über mehrere Projekte hinweg den richtigen Zugriff haben, ohne dass die Konfiguration mehrfach vorgenommen werden muss.\n\nDiese Tipps optimieren nicht nur den Verwaltungsaufwand, sondern verbessern auch Sicherheit und Compliance, indem sichergestellt wird, dass Änderungen auf einer höheren Ebene immer auch auf untergordnete Hierarchieebenen übertragen werden.\n\n![Organisatorisches Hierarchiediagramm](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098179/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750098179305.png)\n\n## Bewährte Methoden für die Einrichtung von GitLab\n\nWenn du deine GitLab-Organisationshierarchie einrichtest, solltest du je nach den Bedürfnissen deines Unternehmens die folgenden Optionen beachten. Self-Managed-Kund(inn)en können die Root-Gruppen-Ebene „Unternehmensname“ weglassen, da diese zusätzliche Organisationsebene für Self-Managed-Bereitstellungen nicht nötig ist. Durch diese Flexibilität kannst du sicherstellen, dass dein GitLap-Setup an deine spezifische Unternehmensstruktur und Präferenzen bei der Bereitstellung angepasst ist.\n\n### Option 1: Berechtigungen und Zugriffsrechte werden auf der Ebene der Organisationsuntergruppe vergeben\n\nDiese Option ist ideale für komplexe Berechtigungsstrukturen oder große Unternehmen, bei denen zahlreiche Benutzer(innen) effizient gemeinsam an Projekten arbeiten müssen.\n\n#### Beispielstruktur\n\n- Organisationsgruppe \n    - Verarbeitet umfassende Berechtigungen normalerweise durch die Integration mit den Bereitstellungssystemen des Unternehmens.\n    - Benutzer(innen) werden zu Untergruppen hinzugefügt, die als Grundlage für die gemeinsame Nutzung der gesamten Gruppe mit einer anderen [Gruppe](https://docs.gitlab.com/ee/user/group/manage.html#share-a-group-with-another-group) oder einem [Projekt](https://docs.gitlab.com/ee/user/project/members/share_project_with_groups.html) dienen, um den Aufwand für die direkte Benutzerverwaltung zu minimieren.\n    - Wenn du Benutzergruppen erstellst, kannst du [Gruppenerwähnungen](https://docs.gitlab.com/ee/user/discussions/index.html#mentions) in GitLab verwenden, um große Benutzergruppen gleichzeitig zu erwähnen.\n\n- Entwicklungsgruppe\n    - Bietet Transparenz auf Führungsebene und Programm-Management-Ebene über alle Entwicklungsprojekte auf Ebene der Hauptentwicklungsgruppe.\n    - Funktionen werden auf Untergruppenebene für den Zugriff über mehrere Repos hinweg erstellt.\n    - Es werden Projekte erstellt, die Entwicklungs-Repos enthalten. Dies ist die Ebene für die Teamsichtbarkeit.\n\n![Organigramm für Untergruppenebene](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098179/Blog/Content%20Images/Blog/Content%20Images/Image_1_aHR0cHM6_1750098179306.png)\n\n### Option 2: Berechtigungen und Zugriffsrechte werden auf jeder Ebene vergeben\nDiese Option ist am besten für kleinere Unternehmen mit weniger komplexen Zugriffsanforderungen geeignet. Benutzer(innen) werden einzeln zu den Bereichsgruppen, Untergruppen oder Projekten hinzugefügt, wenn ein Zugriff erforderlich ist. Dies ermöglicht direkte Kontrolle über das Projektmanagement und die betriebliche Sichtbarkeit.\n\n#### Highlights\n- Benutzer(innen) können je nach Granularität der Zugriffsanforderungen einer übergeordneten Gruppe oder einer untergeordneten Untergruppe/einem Projekt hinzugefügt werden. Jedes Mitglied müsste einzeln hinzugefügt werden, anstatt mit einer Aufgabe eine ganze Gruppe zu teilen.\n- Transparenz auf Führungsebene und Programm-Management-Ebene über alle Entwicklungsprojekte in der Hauptentwicklungsgruppe.\n- Funktionen werden auf Untergruppenebene für den Zugriff über mehrere Repos hinweg erstellt.\n- Es werden Projekte erstellt, die Entwicklungs-Repos enthalten. Dies ist die Ebene für die Teamsichtbarkeit.\n\n![Berechtigungen auf jeder Ebene](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098179/Blog/Content%20Images/Blog/Content%20Images/Image_2_aHR0cHM6_1750098179307.png)\n\n### Zusätzliche Konfigurationsüberlegungen\n\n- Meilensteine und Iterationen \n    - Erstelle Meilensteine auf Gruppenebene für eine breite Sichtbarkeit oder wenn Meilensteine gruppenübergreifend geteilt werden müssen.  \n    - Erstelle Meilensteine auf Projektebene, wenn der Meilenstein für ein einzelnes Projekt spezifisch ist. \n    - Für Teams, die über verschiedene Gruppen hinweg arbeiten, ist es von Vorteil, Iterationen auf der Ebene der übergeordneten Gruppe festzulegen, um eine einheitliche Nachverfolgung zu ermöglichen.\n\n- Datenverwaltung \n    - Nutze die Roadmaps, Übersichten und Listen von GitLab, um Daten abzurufen, die dein Unternehmens-Setup widerspiegeln. Damit kannst du den Fortschritt visualisieren und effektiv über verschiedene Ebenen deiner Struktur hinweg planen. \n    - GitLab stellt Daten in übergeordneten Gruppen zur Verfügung, auch wenn die Daten auf niedrigeren Ebenen erstellt werden. \n    - Erstelle deine Ansichten auf höheren Ebenen, wenn du Daten gruppen- und projektübergreifend anzeigen möchtest, und auf niedrigeren Ebenen, wenn du die Daten nur für eine bestimmte Gruppe oder ein bestimmtes Projekt nutzen möchtest.\n\n- Erstellung von Vorlagen \n    - Erstelle Vorlagen auf höheren Ebenen, um sicherzustellen, dass sie für alle untergeordneten Untergruppen und Projekte kaskadiert werden, wobei allgemeine Richtlinien mit projektspezifischen Anforderungen kombiniert werden.\n    - Vorlagen werden in ihrem eigenen Repository innerhalb der entsprechenden Gruppe erstellt ([zugehörige Dokumentation](https://docs.gitlab.com/ee/user/project/description_templates.html)).\n\n- Labels \n    - Erstelle Labels auf höheren Ebenen, um sicherzustellen, dass sie für alle untergeordneten Untergruppen und Projekte kaskadiert werden, wobei Unternehmenslabels mit projektspezifischen Labels gemischt werden.\n    - Verwende Labels mit begrenztem Geltungsbereich, um Organisationsstrukturen wie Teams und den Workflow-Status zu definieren.\n\n![Issue-Übersicht mit Labels](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098179/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750098179310.png)\n\n## Nutze die Funktionen von GitLab für optimale Performance\n\nWenn du die richtige Struktur in GitLab implementierst, optimierst du nicht nur das Management deiner Softwareprojekte, sonder verbesserst auch die Sichtbarkeit auf den verschiedenen Ebenen deines Unternehmens. So kann sichergestellt werden, dass alle vom obersten Management bis zu den einzelnen Mitwirkenden die Informationen haben, die sie für fundierte Entscheidungen brauchen. \n\n> Starte noch heute und modelliere deine Organisationshierarchie [mit einer kostenlosen Testversion von GitLab Ultimate](https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com/blog&glm_content=default-saas-trial).\n",[745],"Amanda Rueda","2024-11-19","2024-07-22","Bewährte Methoden zum Einrichten von Unternehmenshierarchien, die skalierbar sind",[750,9,707],"agile","agile-planning",{"slug":753,"featured":6,"template":682},"best-practices-to-set-up-organizational-hierarchies-that-scale","content:de-de:blog:best-practices-to-set-up-organizational-hierarchies-that-scale.yml","Best Practices To Set Up Organizational Hierarchies That Scale","de-de/blog/best-practices-to-set-up-organizational-hierarchies-that-scale.yml","de-de/blog/best-practices-to-set-up-organizational-hierarchies-that-scale",{"_path":759,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":760,"content":763,"config":772,"_id":774,"_type":13,"title":775,"_source":15,"_file":776,"_stem":777,"_extension":18},"/de-de/blog/bridging-the-visibility-gap-in-software-supply-chain-security",{"noIndex":6,"title":761,"description":762},"GitLab 18.2: Lücken in der Software Supply Chain Security schließen","Umfassende Scanner-Abdeckung und Visualisierung transitiver Abhängigkeiten. Security Inventory & Dependency Path für vollständige Transparenz. Jetzt testen!",{"title":764,"description":765,"authors":766,"heroImage":768,"date":769,"body":770,"category":675,"tags":771},"Die Sichtbarkeitslücke in der Software Supply Chain Security schließen","GitLab 18.2 bietet Unterstützung für umfassende Scanner-Abdeckung und Visualisierung transitiver Abhängigkeiten.",[767],"Salman Ladha","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749661926/Blog/Hero%20Images/security-patch-blog-image-r2-0506-700x400-fy25_2x.jpg","2025-07-21","Unser neuestes Release, [GitLab 18.2](https://about.gitlab.com/de-de/releases/2025/07/17/gitlab-18-2-released/), führt zwei neue Funktionen zur Verbesserung der Software Supply Chain Security ein: Security Inventory und Dependency Path-Visualisierung.\nSecurity Inventory bietet Application Security Teams eine zentrale, portfolioweite Übersicht über Risiken und Scan-Abdeckung über alle GitLab-Gruppen und -Projekte hinweg. So können sie blinde Flecken identifizieren und Maßnahmen zur Risikominderung priorisieren. Die Dependency Path-Visualisierung zeigt Entwickler(inne)n klar auf, wie Open-Source-Schwachstellen durch die Abhängigkeitskette eingeführt werden, was es einfacher macht, die richtige Lösung zu finden.\nGemeinsam helfen diese Funktionen Sicherheits- und Entwicklungsteams dabei, sicherere Anwendungen zu erstellen, indem sie Transparenz darüber schaffen, wo Risiken bestehen, Kontext zur Behebung liefern und Workflows bereitstellen, die die Zusammenarbeit unterstützen. Im Gegensatz zu anderen Lösungen geschieht all das in derselben Plattform, die Entwickler(innen) zum Erstellen, Überprüfen und Bereitstellen von Software verwenden – ohne den zusätzlichen Integrationsaufwand.\n\n## Open Source erweitert die Angriffsfläche\n\nModerne Anwendungen verlassen sich [stark](https://about.gitlab.com/de-de/developer-survey/) auf Open-Source-Software. Open Source bringt jedoch ein erhebliches Sicherheitsrisiko mit sich – Komponenten können veraltet, nicht mehr gewartet oder unwissentlich anfällig sein. Deshalb ist die Software Composition Analysis (SCA) zu einem Eckpfeiler moderner AppSec-Programme geworden.\nEine zentrale Herausforderung im Schwachstellen-Management ist die effektive Verwaltung des *Risikos transitiver Abhängigkeiten*. Diese Komponenten sind oft tief in der Abhängigkeitskette vergraben. Daher ist es schwierig nachzuvollziehen, wie eine Schwachstelle eingeführt wurde. Ebenso schwer ist es zu bestimmen, was aktualisiert werden muss. Noch schlimmer: Sie machen fast [zwei Drittel](https://arxiv.org/abs/2503.22134?) der bekannten Open-Source-Schwachstellen aus. Ohne klare Sicht auf den gesamten Abhängigkeitspfad sind Teams auf Vermutungen angewiesen, was die Behebung verzögert und das Risiko erhöht.\n\n> Transitive Abhängigkeiten sind Pakete, die deine Anwendung indirekt verwendet. Sie werden automatisch von den direkten Abhängigkeiten eingezogen, die du explizit einbindest. Diese verschachtelten Abhängigkeiten können Schwachstellen einführen, ohne dass der/die Entwickler(in) jemals weiß, dass sie im Projekt vorhanden sind.\n> Diese Herausforderung wird exponentiell schwieriger bei großem Umfang. Sicherheitsteams verwalten oft Hunderte oder Tausende von Repositories. Jedes Repository hat eigene Abhängigkeiten, Build-Pipelines und Verantwortliche. In diesem Umfang wird selbst die Beantwortung grundlegender Sicherheitsfragen zur Herausforderung. Und in einer Zeit wachsender Software Supply Chain-Bedrohungen, in der sich Schwachstellen über geteilte Bibliotheken und CI/CD-Konfigurationen systemübergreifend ausbreiten können, haben diese blinden Flecken noch gravierendere Folgen.\n\n## Security Inventory: Skalierbare Transparenz\n\nSecurity Inventory konsolidiert Risikoinformationen aller Gruppen und Projekte in einer einheitlichen Ansicht. Es zeigt auf, welche Assets durch Sicherheitsscans abgedeckt sind und welche nicht. Anstatt Probleme isoliert zu verwalten, können Sicherheitsteams die Lage ganzheitlich bewerten. So identifizieren sie schnell, wo sie ihre Bemühungen fokussieren sollten.\nDiese zentrale Übersicht ist besonders wichtig für Organisationen mit vielen Repositories. Plattform- und AppSec-Teams verstehen sofort, wo Risiken existieren. Das System hebt ungescannte oder unzureichend geschützte Projekte hervor.\nAußerdem können Teams direkt aus der Oberfläche heraus handeln und über das bloße Bewusstsein hinausgehen. Mit vollem Kontext verstehen sie, welche Anwendungen das größte Risiko darstellen. Security Inventory wandelt fragmentierte Einblicke in eine zentrale Informationsquelle um. So können Organisationen von reaktiver Problem-Triage zu strategischer, datengesteuerter Sicherheits-Governance wechseln.\n![Security Inventory-Anzeige](https://res.cloudinary.com/about-gitlab-com/image/upload/v1753101068/qhujktnbkhl2rzgqfead.png)\nErfahre mehr, indem du dir Security Inventory in Aktion ansiehst:\n\n\u003C!-- blank line --> \u003Cfigure class=\"video_container\"> \u003Ciframe src=\"https://www.youtube.com/embed/yqo6aJLS9Fw?si=CtYmsF-PLN1UKt83\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe> \u003C/figure> \u003C!-- blank line -->\n\n> **Von 18 auf 3 Monate: So beschleunigt die Deutsche Telekom ihre Releases mit GitLab** 13.000 Entwickler(innen) arbeiten effizienter zusammen und bringen Produkte 6x schneller auf den Markt – erfahre, wie GitLab Ultimate die DevSecOps-Transformation vorantreibt, Silos aufbricht und Sicherheit in den Entwicklungsprozess bringt. [Erfolgsstory lesen](https://about.gitlab.com/de-de/customers/deutsche-telekom/)\n\n## Dependency Path-Visualisierung: Klarheit für effektive Behebung\n\nSecurity Inventory zeigt auf hoher Ebene, wo die Risiken liegen; die Dependency Path-Visualisierung zeigt, wie man sie behebt.\nWenn eine Schwachstelle tief in einer Abhängigkeitskette entdeckt wird, kann die Identifizierung der richtigen Lösung kompliziert sein. Die meisten Sicherheitstools heben das betroffene Paket hervor, erklären aber nicht, wie es in die Codebasis gelangt ist. Entwickler(innen) müssen raten, welche Abhängigkeiten direkt eingeführt werden und welche transitiv eingezogen werden, was es schwierig macht zu bestimmen, wo eine Änderung erforderlich ist – oder schlimmer noch: Patches anzuwenden, die die Grundursache nicht beheben.\nUnsere neue Dependency Path-Visualisierung zeigt nach einem SCA-Scan den vollständigen Weg auf: vom Top-Level-Paket zur anfälligen Komponente. Diese wird manchmal auch als Abhängigkeitsgraph bezeichnet. Diese Klarheit ist unerlässlich. Denn tief eingebettete Schwachstellen sind in Abhängigkeitsketten weit verbreitet. Die Funktion ist direkt in den GitLab-Workflow integriert. Dadurch erhalten Entwickler(innen) umsetzbare Einblicke ohne Kontextwechsel oder Rätselraten. Sicherheitsteams können Probleme effektiver priorisieren. Gleichzeitig haben Entwickler(innen) die Gewissheit, dass ihre Behebungen die Grundursachen angehen.\n![Dependency Path-Visualisierung](https://res.cloudinary.com/about-gitlab-com/image/upload/v1753101069/kf5ym62gylm5ck6iebjk.png)\n\n## Entwicklerorientierte Sicherheit: Risiken strategisch mindern\n\nDiese Funktionen sind Teil von GitLabs umfassenderer Strategie: Sicherheit innerhalb derselben Plattform bereitzustellen, in der Code geplant, erstellt und bereitgestellt wird. GitLab bettet Sicherheitseinblicke direkt in den DevSecOps-Workflow ein. Das reduziert Reibung und fördert die Zusammenarbeit zwischen Entwicklungs- und Sicherheitsteams.\nSecurity Inventory und Dependency Path-Visualisierung bieten komplementäre Perspektiven: Security Inventory ermöglicht skalierungsbewusste Überwachung, Dependency Path unterstützt präzise Korrekturen. Diese Kombination hilft Teams, das Wichtigste zu priorisieren und Lücken zu schließen. Und das ohne neue Tools oder komplexe Integrationen.\n\n> Starte noch heute mit Security Inventory und Dependency Path-Visualisierung! Melde dich für eine [kostenlose Testversion von GitLab Ultimate](https://about.gitlab.com/de-de/free-trial/) an.\n\n## Weiterlesen\n\n* [GitLab 18.2 veröffentlicht](https://about.gitlab.com/de-de/releases/2025/07/17/gitlab-18-2-released/)\n* [GitLab-Sicherheitslösungen](https://about.gitlab.com/de-de/solutions/security-compliance/)\n* [Ein Leitfaden zu Bedrohungsvektoren in der Software Supply Chain](https://about.gitlab.com/de-de/the-source/security/field-guide-to-threat-vectors-in-the-software-supply-chain/)",[675,9,677],{"featured":6,"template":682,"slug":773},"bridging-the-visibility-gap-in-software-supply-chain-security","content:de-de:blog:bridging-the-visibility-gap-in-software-supply-chain-security.yml","Bridging The Visibility Gap In Software Supply Chain Security","de-de/blog/bridging-the-visibility-gap-in-software-supply-chain-security.yml","de-de/blog/bridging-the-visibility-gap-in-software-supply-chain-security",{"_path":779,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":780,"content":784,"config":793,"_id":795,"_type":13,"title":796,"_source":15,"_file":797,"_stem":798,"_extension":18},"/de-de/blog/custom-admin-roles-now-ga",{"config":781,"title":782,"description":783},{"noIndex":6},"Custom Admin Roles sind jetzt allgemein verfügbar","GitLab unterstützt granulare Berechtigungen im Admin-Bereich und reduziert damit den Bedarf an vollprivilegierten Administratoren.",{"heroImage":785,"body":786,"authors":787,"updatedDate":789,"date":790,"title":782,"tags":791,"description":792,"category":677},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1756122536/akivvcnafog9c4dhhzkp.png","GitLab führt granulare Berechtigungen für den Admin-Bereich in GitLab Self-Managed und GitLab Dedicated Instanzen ein. Diese Custom Admin Roles ermöglichen es Organisationen, das [Principle of Least Privilege](https://about.gitlab.com/blog/the-ultimate-guide-to-least-privilege-access-with-gitlab/) für ihre Instanzen umzusetzen und gleichzeitig die operative Effizienz zu erhalten. Ähnlich wie Custom Roles für Gruppen und Projekte bieten Custom Admin Roles detaillierte Berechtigungen zur Kontrolle des Zugriffs auf den Admin-Bereich.\n\nDiese granularen Admin-Berechtigungen ermöglichen es Organisationen, zweckgebundene administrative Rollen zu erstellen, anstatt Benutzern vollständigen Administratorzugang zu gewähren. Mögliche Anwendungsfälle umfassen:\n\n- **Platform Team:** Zugriff auf Runner-Management, Instanz-Monitoring und Performance-Metriken\n- **Support Team:** Zugriff auf User-Management und Troubleshooting-Workflows\n- **Leadership Team:** Zugriff auf Dashboards, Nutzungsstatistiken und Lizenzierung\n\n![Custom Admin Role](https://res.cloudinary.com/about-gitlab-com/image/upload/v1756121189/xnnoyowwutlbxu9unho5.png)\n\n## Funktionen\n- **Granulare Berechtigungen:** Custom Permissions ermöglichen es, eine Rolle zu erstellen, die den spezifischen Anforderungen entspricht.\n- **Management auf Instanzebene:** Custom Admin Roles werden zentral erstellt und verwaltet.\n- **LDAP-Integration:** Unterstützung für die Zuweisung großer Benutzergruppen zu Rollen über Directory-Server.\n- **Audit-Integration:** Funktioniert mit dem bestehenden [Admin-Modus](https://docs.gitlab.com/administration/settings/sign_in_restrictions/#admin-mode) und Audit-Events.\n\n![Custom Admin Role](https://res.cloudinary.com/about-gitlab-com/image/upload/v1756121190/wedoc6gi4upivvjezyeu.png)\n\n## Mission: Die Sicherheit der Software-Supply-Chain verbessern\nDiese Funktion stellt einen wichtigen Schritt in GitLabs übergeordneter Mission dar, die Sicherheit der Software-Supply-Chain zu verbessern. Als Teil dieser Mission hat GitLab auch Custom Roles für Projekte und Gruppen sowie [granulare Berechtigungen für CI/CD Job Tokens](https://docs.gitlab.com/ci/jobs/fine_grained_permissions/) hinzugefügt.\n\nWeitere Informationen zu Custom Admin Roles finden sich unter [Custom Roles](https://docs.gitlab.com/user/custom_roles/). Zusätzliche Berechtigungen sind für zukünftige Releases geplant. Um Feedback zu teilen, siehe das [Custom Roles Issue](https://gitlab.com/gitlab-org/gitlab/-/issues/509376).\n",[788],"Joe Randazzo","2025-09-03","2025-08-25",[677,9],"GitLab unterstützt ab sofort granulare Berechtigungen im Admin-Bereich und reduziert damit den Bedarf an vollprivilegierten Administratoren.",{"featured":6,"slug":794,"template":682},"custom-admin-roles-now-ga","content:de-de:blog:custom-admin-roles-now-ga.yml","Custom Admin Roles Now Ga","de-de/blog/custom-admin-roles-now-ga.yml","de-de/blog/custom-admin-roles-now-ga",{"_path":800,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":801,"content":807,"config":815,"_id":817,"_type":13,"title":818,"_source":15,"_file":819,"_stem":820,"_extension":18},"/de-de/blog/data-driven-devsecops-exploring-gitlab-insights-dashboards",{"title":802,"description":803,"ogTitle":802,"ogDescription":803,"noIndex":6,"ogImage":804,"ogUrl":805,"ogSiteName":695,"ogType":696,"canonicalUrls":805,"schema":806},"Datengesteuerte DevSecOps: Entdecke die Dashboards von GitLab Insights","Erfahre, wie du die Dashboards von GitLab Insights nutzen kannst, um wichtige Metriken zu visualisieren, Projekte nachzuverfolgen und die Produktivität deines Teams zu steigern.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097210/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%2811%29_78Dav6FR9EGjhebHWuBVan_1750097210214.png","https://about.gitlab.com/blog/data-driven-devsecops-exploring-gitlab-insights-dashboards","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Datengesteuerte DevSecOps: Entdecke die Dashboards von GitLab Insights\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Ricardo Amarilla Villalba\"}],\n        \"datePublished\": \"2024-11-20\",\n      }\n                  ",{"title":802,"description":803,"authors":808,"heroImage":804,"date":810,"body":811,"category":677,"tags":812,"updatedDate":814},[809],"Ricardo Amarilla Villalba","2024-11-20","Metriken und Analysen spielen eine entscheidende Rolle, wenn es darum geht, Produktivität, Qualität und Erfolg zu steigern. [GitLab](https://about.gitlab.com/de-de/platform/) ist eine umfassende DevSecOps-Plattform und bietet leistungsstarke Tools, um diese wichtigen Metriken über die Insights-Dashboards zu verfolgen und zu visualisieren. In diesem Artikel erfährst du, wie du die Insights-Dashboards in deiner Umgebung verwenden kannst.\n\n## Inhaltsverzeichnis\n\n- [Einführungen in GitLab-Metriken und Analysen](#einführungen-in-gitlab-metriken-und-analysen)\n- [Nutze Labels für bestimmte Metriken](#nutze-labels-für-bestimmte-metriken)\n- [So konfigurierst du GitLab Insights](#so-konfigurierst-du-gitlab-insights)\n- [Einblicke in Merge Requests anpassen](#einblicke-in-merge-requests-anpassen)\n- [Merge-Request-Einblicke für jede Squad und jeden Anforderungstyp](#merge-request-einblicke-für-jede-squad-und-jeden-anforderungstyp)\n  - [Richte Squad-basierte Metriken ein](#richte-squad-basierte-metriken-ein)\n- [Lege jetzt los](#lege-jetzt-los)\n- [Mehr erfahren](#mehr-erfahren)\n\n## Einführungen in GitLab-Metriken und Analysen\n\nGitLab stellt verschiedenste Metriken und Analysetools für unterschiedliche Aspekte des DevSecOps-Lebenszyklus bereit:\n\n1. [Produktivitätsanalyse (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/ee/user/analytics/productivity_analytics.html): Damit kannst du die Geschwindigkeit deines Teams, Bearbeitungszeiten und Abarbeitungsdauer nachverfolgen.\n2. [Code-Review-Analysen (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/ee/user/analytics/code_review_analytics.html): Damit kannst du die Codequalität, die Testabdeckung und die Effizienz der Überprüfung messen.\n3. [CI/CD-Analyse (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/ee/user/analytics/ci_cd_analytics.html): Damit kannst du die Pipeline-Performance und die Bereitstellungshäufigkeit überwachen.\n4. [Wertstromanalyse (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/ee/user/group/value_stream_analytics/): Damit kannst du den Arbeitsfluss von der Idee bis zur Produktion visualisieren.\n5. [Einblicke (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/ee/user/project/insights/): Entdecke und visualisiere Daten über deine Projekte und Gruppen.\n\nDiese Metriken bieten wertvolle Einblicke in deinen Entwicklungsprozess und helfen Teams dabei, Engpässe zu identifizieren, Workflows zu optimieren und datengestützte Entscheidungen zu treffen.\n\n## Nutze Labels für bestimmte Metriken\n\nEine der leistungsstärksten und doch unterschätztesten Funktionen von GitLab sind Labels, mit denen du Metriken mit absoluter Präzision filtern kannst. Wenn du Labels strategisch Tickets, Merge Requests und Epics zuweist, kannst du individuelle Ansichten erstellen, die zielgenaue Einblicke in die Leistung und den Fortschritt deines Projekts bieten.\n\nLabels fungieren in GitLab als vielseitige Kennungen, mit denen du deine Workitems flexibel kategorisieren und organisieren kannst. Egal, ob du die Entwicklung von Funktionen, Bug Fixes oder teamspezifische Aufgaben nachverfolgst: Mit Labels kannst du deine Projektdaten aufschlüsseln und erkenntnisreiche Muster und Entwicklungen aufdecken. \n\nDas Konzept ist ähnlich wie Tags in Cloud-Bereitstellungen, wo die Ressourcen gekennzeichnet werden, um sie einfacher verwalten, die Kosten zuordnen und betriebliche Einblicke gewinnen zu können. Indem du deine Workitems sorgfältig mit Labels kennzeichnest, baust du ein cleveres Label-System auf, mit dem du ganz einfach individuelle Dashboards und Berichte erstellen kannst. Durch diesen Ansatz kannst du dich auf die Metriken konzentrieren, die für dein Team oder deine Stakeholder am wichtigsten sind. So erhältst du eine klare Fokusansicht des Zustands und der Dynamik deines Projekts.\n\n## So konfigurierst du GitLab Insights\n\nMit GitLab Insights kannst du Daten über deine Projekte und Gruppen untersuchen und visualisieren. Sie bieten wichtige Analysen zu verschiedensten Aspekten, wie etwa den in einem bestimmten Zeitraum erstellten und geschlossenen Tickets, die durchschnittliche Zeit, die es bis zur Zusammenführung eines Merge Request dauert, sowie die Qualität der Priorisierung. Einblicke können sowohl für Projekte als auch für Gruppen konfiguriert werden.\n\n**So konfigurierst du Insights:**\n\n1. Für Projekteinblicke:\n   * Erstelle eine Datei mit dem Namen `.gitlab/insights.yml` im Stammverzeichnis deines Projekts.\n2. Für Gruppeneinblicke:\n   * Erstelle die Datei `.gitlab/insights.yml` in einem Projekt, das zu deiner Gruppe gehört.\n * Gehe zu **Einstellungen > Allgemein** deiner Gruppe.\n * Klappe den Abschnitt **Analyse** aus und suche den Abschnitt **Insights**.\n * Wähle das Projekt aus, das die Konfigurationsdatei enthält, und speichere die Änderungen.\n\nDie Datei `.gitlab/insights.yml` ist eine YAML-Datei, in der du die Struktur und Reihenfolge der Diagramme in einem Bericht sowie den Stil der anzuzeigenden Diagramme definieren kannst. Jede Diagrammdefinition enthält Parameter wie Titel, Beschreibung, Typ und Abfrage, um die Datenquelle und die Filterbedingungen anzugeben.\n\nUm Einblicke anzuzeigen, gehe in deinem Projekt oder deiner Gruppe zu **Analysieren > Insights**.\n\n![Standard-Dashboard für Insights anzeigen](https://res.cloudinary.com/about-gitlab-com/image/upload/v1752378202/Blog/oqek65jmi5kclpbaqsca.png)\n\n## Einblicke in Merge Requests anpassen\n\nWährend die Standardansicht wertvolle Rohinformationen liefert, können wir das Insights-Dashboard anpassen, um zusätzliche Informationsebenen anzuzeigen, z. B. welches Team für welchen Merge Request verantwortlich war und welche Art von Problem gelöst wurde.\n\n## Merge-Request-Einblicke für jede Squad und jeden Anforderungstyp\n\nEs kann herausfordernd sein, die Produktivität einer Squad in GitLab zu messen, vor allem wenn die Gruppen- und Untergruppenstruktur in GitLab nicht perfekt mit der Organisation deines Squad übereinstimmt. So kannst du diese Herausforderungen meistern und die Produktivität deiner Squads effektiv verfolgen:\n\n### Richte Squad-basierte Metriken ein\n\n1. **Erstelle Labels:** Erstelle eindeutige Labels mit begrenztem Geltungsbereich für jede Squad (z. B. `squad::alpha`, `squad::beta`) und jeden Anforderungstyp (z. B. `type::bug`, `type::feature`, `type::maintenance`).\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/ZUOzORIUJeU?si=T8eHeGizS3blYFHB\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n2. **Weise Labels zu:** Weise diese Squad-Labels konsequent allen Tickets und Merge Requests zu, die von der jeweiligen Squad bearbeitet werden, egal in welchem Projekt oder welcher Gruppe sie sind.\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/fJ9entEBZG8?si=MlM6mKirEdkmwDDJ\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n**Tipps:**\n   * Verwende die GitLab-API, um Labels gesammelt an bestehende geöffnete, zusammengeführte und geschlossene MRs zuzuweisen.\n   * Du kannst Labels im Rahmen deiner GitLab-CI-Pipeline hinzufügen/entfernen/aktualisieren.\n * Nutze den GitLab Triage Bot, um den Label-Prozess zu automatisieren.\n\n3. Richte ein Dashboard ein: Erstelle die Datei `.gitlab/insights.yml` in deinem Projekt-Repository mit benutzerdefinierten Diagrammen für teamspezifische und typspezifische Einblicke in Merge Requests.\n\n```\n\n## Default Merge Requests insights.yml \nmergeRequests:\n  title: Merge requests dashboard\n  charts:\n    - title: Merge requests merged per week \n      type: bar\n      query:\n        data_source: issuables\n        params:\n          issuable_type: merge_request\n          issuable_state: merged\n          group_by: week\n          period_limit: 12\n    - title: Merge requests merged per month\n      type: bar\n      query:\n        data_source: issuables\n        params:\n          issuable_type: merge_request\n          issuable_state: merged\n          group_by: month\n          period_limit: 3\n\n## Per-teams Merge Requests insights.yml\nmergeRequestsTeams:\n  title: Merge requests dashboard per teams\n  charts:\n    - title: Merge requests merged per week \n      type: stacked-bar\n      query:\n        data_source: issuables\n        params:\n          issuable_type: merge_request\n          issuable_state: merged\n          group_by: week\n          period_limit: 12\n          collection_labels:\n            - squad::alpha\n            - squad::beta\n    - title: Merge requests merged per month\n      type: stacked-bar\n      query:\n        data_source: issuables\n        params:\n          issuable_type: merge_request\n          issuable_state: merged\n          group_by: month\n          period_limit: 3\n          collection_labels:\n            - squad::alpha\n            - squad::beta\n\n## Per-teams and Type Merge Requests insights.yml\nmergeRequestsTeamsAndType:\n  title: Per Teams and Type - Merge requests dashboard\n  charts:\n    - title: Merge requests merged per week - Squad Alpha\n      type: stacked-bar\n      query:\n        data_source: issuables\n        params:\n          issuable_type: merge_request\n          issuable_state: merged\n          filter_labels: squad::alpha\n          collection_labels:\n            - type::feature\n            - type::bug\n            - type::maintenance\n          group_by: week\n          period_limit: 12\n    - title: Merge requests merged per month - Squad Alpha\n      type: stacked-bar\n      query:\n        data_source: issuables\n        params:\n          issuable_type: merge_request\n          issuable_state: merged\n          filter_labels: squad::alpha\n          collection_labels:\n            - type::feature\n            - type::bug\n            - type::maintenance\n          group_by: month\n          period_limit: 3\n    - title: Merge requests merged per week - Squad Beta\n      type: stacked-bar\n      query:\n        data_source: issuables\n        params:\n          issuable_type: merge_request\n          issuable_state: merged\n          filter_labels: squad::beta\n          collection_labels:\n            - type::feature\n            - type::bug\n            - type::maintenance\n          group_by: week\n          period_limit: 12\n    - title: Merge requests merged per month - Squad Beta\n      type: stacked-bar\n      query:\n        data_source: issuables\n        params:\n          issuable_type: merge_request\n          issuable_state: merged\n          filter_labels: squad::beta\n          collection_labels:\n            - type::feature\n            - type::bug\n            - type::maintenance\n          group_by: month\n          period_limit: 3\n\n```\n\nIndem du diese Anpassungen implementierst, kannst du sinnvolle Dashboards erstellen, in denen du einen klaren Überblick über die Merge-Request-Aktivitäten pro Team und Anforderungstyp erhältst. So kannst du Trends im Zeitverlauf visualisieren, die Leistung zwischen Squads vergleichen und die Verteilung der verschiedenen Arbeiten für jede Squad analysieren.\n\n![Dashboards mit Ansicht der MR-Aktivität pro Team und Anforderungstyp](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097218/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097217972.png)\n\n![Dashboard zum Vergleich der Leistung zwischen Squads](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097218/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097217972.png)\n\n## Lege jetzt los\n\nGitLab Insights ist nur die Spitze des Eisbergs, wenn es um Indikatoren und Analysen geht. Um die gesamte Palette der leistungsstarken Analysefunktionen von GitLab wie Wertstromanalyse, CI/CD-Analyse und Code-Review-Metriken zu entdecken, sieh dir unsere Produkttour zum Wertstrommanagement an:\n\n[![Produkttour zum Wertstrommanagement](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097218/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097217974.png)]( https://gitlab.navattic.com/vsm)\n\n> Bist du bereit, jetzt selbst Metriken zu nutzen? Melde dich jetzt für eine [kostenlose Testversion von GitLab Ultimate](https://gitlab.com/-/trials/new?glm_content=default-saas-trial&glm_source=about.gitlab.com%2F) an und schöpfe das volle Potenzial von datengestützten DevSecOps aus.\n\n## Mehr erfahren\n- [Tool zur Erstellung geplanter Berichte vereinfacht das Wertstrommanagement (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/new-scheduled-reports-generation-tool-simplifies-value-stream-management/)\n- [Erste Schritte mit dem neuen Wertstrom-Dashboard von GitLab (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/getting-started-with-value-streams-dashboard/)\n- [KI-Impact-Analyse-Dashboard misst den ROI von KI](https://about.gitlab.com/de-de/blog/developing-gitlab-duo-ai-impact-analytics-dashboard-measures-the-roi-of-ai/)\n",[108,707,677,9,705,813],"solutions architecture","2025-06-06",{"slug":816,"featured":90,"template":682},"data-driven-devsecops-exploring-gitlab-insights-dashboards","content:de-de:blog:data-driven-devsecops-exploring-gitlab-insights-dashboards.yml","Data Driven Devsecops Exploring Gitlab Insights Dashboards","de-de/blog/data-driven-devsecops-exploring-gitlab-insights-dashboards.yml","de-de/blog/data-driven-devsecops-exploring-gitlab-insights-dashboards",{"_path":822,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":823,"content":829,"config":841,"_id":843,"_type":13,"title":844,"_source":15,"_file":845,"_stem":846,"_extension":18},"/de-de/blog/demystifying-ci-cd-variables",{"ogTitle":824,"schema":825,"ogImage":826,"ogDescription":827,"ogSiteName":695,"noIndex":6,"ogType":696,"ogUrl":828,"title":824,"canonicalUrls":828,"description":827},"GitLab Umgebungsvariablen einfach erklärt ","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"GitLab-Umgebungsvariablen entmystifiziert\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Veethika Mishra\"}],\n        \"datePublished\": \"2021-04-09\",\n      }","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749664679/Blog/Hero%20Images/blog-image-template-1800x945__24_.png","Wir zeigen dir, was sich hinter Umgebungsvariablen bei GitLab verbirgt. ✓ Definition ✓ Funktionsweise ✓ Typen ✓ Anwendung ➤ Jetzt Leitfaden lesen!","https://about.gitlab.com/blog/demystifying-ci-cd-variables",{"heroImage":826,"body":830,"authors":831,"updatedDate":833,"date":834,"title":824,"tags":835,"description":839,"category":840},"Es gibt viel Flexibilität bei der Definition und Verwendung von Variablen\nfür [CI/CD](https://about.gitlab.com/de-de/topics/ci-cd/). Variablen sind\nsehr nützlich für die Steuerung von Jobs und Pipelines und sie helfen dir zu\nvermeiden, Werte in der Konfigurationsdatei `.gitlab-ci.yml` festlegen zu\nmüssen. Dieser Blogbeitrag soll ein umfassenderes Bild vermitteln, indem er\nalle (oder die meisten) Informationen über die Definition und die Handhabung\nder Variablen zusammenfasst, um das Verständnis des Geltungsbereichs und der\nMöglichkeiten zu erleichtern. Die relevante Dokumentation in dem Beitrag\nverlinkt und ist aktuell nur in englischer Sprache verfügbar.\n\n\nIn [GitLab CI/CD](https://docs.gitlab.com/ee/ci/) können mit Variablen Werte definiert und gespeichert werden, um Jobs anzupassen. Bei der Verwendung von Variablen müssen Werte nicht im Klartext gespeichert werden. In GitLab können CI/CD-Variablen unter **Einstellungen >> CI/CD >> Variablen** oder einfach in der Datei `.gitlab-ci.yml` definiert werden.\n\n\nVariablen sind nützlich, um Dienste von Drittanbietern für verschiedene Bereitstellungsumgebungen zu konfigurieren, z. B. `testing`, `staging`, `production` usw. Passe an, welche Dienste mit diesen Umgebungen verknüpft sind, indem du einfach die Variable änderst, die auf den API-Endpunkt zeigt, den die Dienste verwenden sollen. Verwende auch Variablen, um Jobs zu konfigurieren, und stelle sie dann als Umgebungsvariablen innerhalb der Jobs zur Verfügung, wenn diese ausgeführt werde.\n\n\n![GitLab liest die Datei .gitlab-ci.yml, um die referenzierte Variable zu scannen und sendet die Informationen an den GitLab Runner. Die Variablen werden auf dem Runner angezeigt und vom Runner ausgegeben.](https://about.gitlab.com/images/blogimages/demystifying-ci-cd-variables/variables_processing.jpeg)\n\n\n## Die Beziehung zwischen Variablen und Umgebungen\n\n\nDer Prozess der Softwareentwicklung umfasst verschiedene Phasen, in denen ein Produkt getestet wird, bevor es an die Benutzer(innen) ausgeliefert wird. Zur Definition dieser Phasen werden [Umgebungen](https://docs.gitlab.com/ee/ci/environments/) verwendet, die von Team zu Team und zwischen Unternehmen unterschiedlich sein können.\n\n\nVariablen sind dagegen Datenwerte, die sich durch die Interaktion der Benutzer(innen) mit dem Produkt ändern können. Beispielsweise kann ihr Alter, ihre Vorlieben oder eine beliebige andere Eingabe den nächsten Schritt in der Aufgabenfolge des Produkts bestimmen.\n\n\nWir hören oft den Begriff [Umgebungsvariable](https://docs.gitlab.com/ee/administration/environment_variables.html). Dabei handelt es sich um Variablen, die in einer bestimmten Umgebung, aber außerhalb der Anwendung definiert sind. CI/CD-Variablen von GitLab bieten Entwickler(inne)n die Möglichkeit, Werte in ihrem Code zu konfigurieren. Variablen sind hilfreich, da sie sicherstellen, dass der Code flexibel ist. Mit CI/CD-Variablen von GitLab können Beutzer(innen) eine in einer bestimmten Umgebung bereitgestellte Anwendung ändern, ohne den Code zu ändern. Es ist einfach, Tests durchzuführen oder sogar Dienste von Drittanbietern zu integrieren, indem eine Umgebungsvariable außerhalb der Anwendung geändert wird.\n\n\n## Geltungsbereich der Variablen für CI/CD\n\n\n![Hierarchie für CI/CD-Variablen: 1) Variablen für die manuelle Ausführung, Auslösung und Planung von Pipelines, 2) Geschützte Variablen auf Projekt-, Gruppen- und Instanzebene, 3) Geerbte CI/CD-Variablen, 4) Job-Ebene, globale yml-definierte Variablen, 5) Bereitstellungsvariablen, 6) Vordefinierte CI/CD-Variablen](https://about.gitlab.com/images/blogimages/demystifying-ci-cd-variables/variables_precedence.jpeg)\n\n\n### `.gitlab-ci.yml`-definierte Variablen\n\n\nVariablen, die in der Arbeitsumgebung verfügbar sein müssen, können zu GitLab hinzugefügt werden. Diese CI/CD-Variablen sind dazu gedacht, nicht-sensible Projektkonfigurationen wie z. B. die URL der Datenbank in der Datei `.gitlab-ci.yml` zu speichern. Verwende diese Variable in mehreren Jobs oder Skripten, wo immer der Wert benötigt wird. Wenn sich der Wert ändert, musst du die Variable nur einmal aktualisieren und die Änderung wird überall dort übernommen, wo die Variable verwendet wird.\n\n\n### Projekt-CI/CD-Variablen\n\n\nEinen Schritt über die Repository-spezifischen Anforderungen hinaus kannst du CI/CD-Variablen in den [Projekt-Einstellungen](https://docs.gitlab.com/ee/ci/variables/#for-a-project) definieren und für CI/CD-Pipelines verfügbar machen. Diese werden aus dem Repository heraus gespeichert (nicht in der Datei `.gitlab-ci.yml`), sind aber weiterhin in der CI/CD-Konfiguration und den Skripten verfügbar. Durch das Speichern der Variablen außerhalb der Datei `.gitlab-ci.yml` werden diese Werte auf einen reinen Projektgeltungsbereich beschränkt und nicht als Klartext im Projekt gespeichert.\n\n\n### CI/CD-Variablen für Gruppen und Instanzen\n\n\nEinige Variablen sind auf Gruppen- oder sogar Instanzebene relevant und können für alle Projekte in einer Gruppe oder Instanz nützlich sein. Definiere die Variablen in den [Gruppen- oder Instanzeinstellungen](https://docs.gitlab.com/ee/ci/variables/#for-a-group), sodass alle Projekte innerhalb dieser Bereiche die Variablen verwenden können, ohne den Wert zu kennen oder die Variablen für den untergeordneten Bereich erstellen zu müssen. Zum Beispiel kann ein gemeinsamer Wert, der in mehreren Projekten aktualisiert werden muss, leicht verwaltet werden, wenn er an einer einzigen Stelle aktualisiert wird. Alternativ können mehrere Projekte ein bestimmtes Passwort verwenden, ohne den Wert des Passworts selbst kennen zu müssen.\n\n\n## Jobs und Pipelines als Umgebungen\n\n\nDie CI/CD-Variablen von GitLab werden nicht nur als Umgebungsvariablen verwendet, sondern auch in der Konfigurationsdatei `.gitlab-ci.yml`, um das Verhalten der Pipeline unabhängig von der Umgebung zu konfigurieren. Die Variablen können in den Projekt-/Gruppen-/Instanzeinstellungen gespeichert und Jobs in Pipelines zur Verfügung gestellt werden.\n\n\nZum Beispiel:\n\n\n```  \n\njob:  \n  rules:  \n    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH  \n  script:  \n  - echo \"This job ran on the $CI_COMMIT_BRANCH branch.\"  \n```\n\n\nDie Variable `($CI_COMMIT_BRANCH)` im Skriptabschnitt wird in dem Bereich des Jobs ausgeführt, in dem sie definiert wurde. Dieser Bereich ist die „Job-Umgebung“ – das heißt, wenn der Job gestartet wird, startet der GitLab-Runner einen Docker-Container und führt den Job in dieser Umgebung aus. Der Runner stellt diese Variable (und alle anderen vordefinierten oder benutzerdefinierten Variablen) dem Job zur Verfügung und kann ihren Wert bei Bedarf in der Protokollausgabe anzeigen.\n\n\nDie Variable wird jedoch **auch** im Abschnitt `if:` verwendet, um zu bestimmen, wann der Job ausgeführt werden soll. Dies ist an sich keine Umgebung, weshalb wir diese CI/CD-Variablen aufrufen. Sie können verwendet werden, um CI/CD-Jobs dynamisch zu konfigurieren, **sowie** als Umgebungsvariablen, wenn der Job ausgeführt wird.\n\n\n## Vordefinierte Variablen\n\n\nEine Reihe von Variablen werden [vordefiniert](https://docs.gitlab.com/ee/ci/variables/predefined_variables.html), wenn eine GitLab-CI/CD-Pipeline gestartet wird. Benutzer(innen) können sofort auf Werte für Commit-, Projekt- oder Pipeline-Details zugreifen, ohne die Variablen selbst definieren zu müssen.\n\n\n## Benutzerdefinierte CI/CD-Variablen\n\n\n![Runner können zwei Arten von benutzerdefinierten CI/CD-Variablen erstellen: Typ und Datei.](https://about.gitlab.com/images/blogimages/demystifying-ci-cd-variables/variable_types.jpeg)\n\n\nWenn eine CI/CD-Variable in den Einstellungen erstellt wird, gibt GitLab den Benutzer(innen) mehr Konfigurationsmöglichkeiten für die Variable. Verwende diese zusätzlichen Konfigurationsoptionen für eine strengere Kontrolle sensibler Variablen:\n\n\n**Geltungsbereich: Umgebung:** Wenn eine Variable nur in einer bestimmten Umgebung verwendet werden soll, konfiguriere sie so, dass sie nur in dieser Umgebung verfügbar ist. Du kannst beispielsweise festlegen, dass ein Bereitstellungstoken nur in der Umgebung `production` verfügbar ist.\n\n\n**Geschützte Variablen:** Ähnlich wie bei der Option „Geltungsbereich: Umgebung“ kann eine Variable so konfiguriert werden, dass sie nur verfügbar ist, wenn die Pipeline in einem geschützten Branch ausgeführt wird, z. B. in deinem Standard-Branch.\n\n\n**Variablentyp:** Für einige Anwendungen musst du die Konfiguration in Form einer Datei übergeben. Wenn du eine Anwendung hast, die diese Konfiguration erfordert, lege den Variablentyp einfach auf „Datei“ fest. Wenn die CI/CD-Variable auf diese Weise konfiguriert wird, schreibt der Runner die Variable in eine temporäre Datei und speichert den Pfad zu dieser Datei als Wert, wenn er sie in der Umgebung verfügbar macht. Als Nächstes können die Benutzer(innen) den Pfad zu der Datei an alle Anwendungen weitergeben, die sie benötigen.\n\n\nZusätzlich zu den genannten Methoden zur Definition und Verwendung von Variablen hat GitLab eine Funktion eingeführt, die vorgefertigte Variablen generiert, wenn eine Pipeline manuell ausgeführt werden muss. Vorgefertigte Variablen reduzieren die Fehlerwahrscheinlichkeit und erleichtern die Bedienung der Pipeline.\n\n\n**Maskierte Variablen:** [Maskierte Variablen](https://docs.gitlab.com/ee/ci/variables/#mask-a-cicd-variable) sind CI-Variablen, die in Job-Protokollen **maskiert** wurden, um zu verhindern, dass der Wert der Variablen angezeigt wird. \n\n\n**Maskierte und versteckte Variablen:** Die in [GitLab 17.4](https://about.gitlab.com/releases/2024/09/19/gitlab-17-4-released/#hide-cicd-variable-values-in-the-ui) eingeführten [maskierten und versteckten Variablen](https://docs.gitlab.com/ee/ci/variables/#hide-a-cicd-variable) bieten die gleiche Maskierungsfunktion für Job-Protokolle und **verstecken den Wert** **in der Einstellungsoberfläche**. Wir empfehlen, keine dieser Variablen für sensible Daten (z. B. Geheimnisse) zu verwenden, da diese versehentlich offengelegt werden könnten.\n\n\n## Geheimnisse\n\n\nGeheimnisse sind sensible Zugangsdaten, die vertraulich behandelt werden sollten. Beispiele für Geheimnisse sind\n\n\n* Passwörter  \n\n* SSH-Schlüssel  \n\n* Zugriffstoken  \n\n* Alle anderen Arten von Zugangsdaten, deren Offenlegung für ein Unternehmen schädlich wäre.\n\n\nGitLab ermöglicht es seinen Benutzer(innen) derzeit mit Hilfe von HashiCorp Vault, Google Cloud Secret Manager und Azure Key Vault, [externe Geheimnisse für CI zu verwenden](https://docs.gitlab.com/ee/ci/secrets/), um Schlüssel, Token und andere Geheimnisse auf Projektebene sicher zu verwalten. So können Benutzer(innen) diese Geheimnisse aus Sicherheitsgründen von anderen CI/CD-Variablen trennen.\n\n\n### GitLab Geheimnismanager\n\n\nNeben der Unterstützung für externe Geheimnisse in CI arbeitet GitLab auch an der Einführung einer [nativen Lösung zur Verwaltung von Geheimnissen](https://gitlab.com/groups/gitlab-org/-/epics/10108), um Geheimnisse sicher und bequem in GitLab zu speichern. Diese Lösung wird Kund(inn)en auch dabei helfen, gespeicherte Geheimnisse in GitLab-spezifischen Komponenten und Umgebungen zu verwenden und den Zugriff auf Namensraum-Gruppen und Projektebene einfach zu verwalten. \n\n\n## Mehr lesen\n\n* [Nativer GitLab Geheimnismanager für mehr Sicherheit in der Software-Lieferkette](https://about.gitlab.com/blog/gitlab-native-secrets-manager-to-give-software-supply-chain-security-a-boost/) (nur in englischer Sprache verfügbar)\n\n\n***Haftungsausschlussklausel:** Dieser Blog enthält Informationen über kommende Produkte, Funktionen oder 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.*\n",[832],"Veethika Mishra","2025-01-28","2021-04-09",[836,9,837,838,108,705],"CD","inside GitLab","CI","CI/CD-Variablen sind nützliche (und flexible) Tools zur Steuerung von Jobs und Pipelines. Wir verraten dir alles, was du über GitLab-Umgebungsvariablen wissen musst.","engineering",{"slug":842,"featured":6,"template":682},"demystifying-ci-cd-variables","content:de-de:blog:demystifying-ci-cd-variables.yml","Demystifying Ci Cd Variables","de-de/blog/demystifying-ci-cd-variables.yml","de-de/blog/demystifying-ci-cd-variables",{"_path":848,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":849,"content":855,"config":863,"_id":865,"_type":13,"title":866,"_source":15,"_file":867,"_stem":868,"_extension":18},"/de-de/blog/developing-gitlab-duo-a-roundup-of-recent-chat-enhancements",{"title":850,"description":851,"ogTitle":850,"ogDescription":851,"noIndex":6,"ogImage":852,"ogUrl":853,"ogSiteName":695,"ogType":696,"canonicalUrls":853,"schema":854},"GitLab Duo: Ein Überblick über die neuesten Verbesserungen im Chat","Entdecke die neusten Verbesserungen beim Chat von GitLab Duo, darunter eine neue Integration, der Abbruch von Prompts sowie Architektur-Upgrades.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098374/Blog/Hero%20Images/Blog/Hero%20Images/blog-hero-banner-1-0178-820x470-fy25_7JlF3WlEkswGQbcTe8DOTB_1750098374059.png","https://about.gitlab.com/blog/developing-gitlab-duo-a-roundup-of-recent-chat-enhancements","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"GitLab Duo: Ein Überblick über die neuesten Verbesserungen im Chat\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Jannik Lehmann\"},{\"@type\":\"Person\",\"name\":\"David O'Regan\"}],\n        \"datePublished\": \"2024-07-10\",\n      }\n                  ",{"title":850,"description":851,"authors":856,"heroImage":852,"date":859,"body":860,"category":703,"tags":861,"updatedDate":862},[857,858],"Jannik Lehmann","David O'Regan","2024-07-10","GitLab ist bestrebt, [den Chat von GitLab Duo](https://gitlab.com/gitlab-org/gitlab/-/issues/430124), unseren KI-Assistenten, kontinuierlich zu verbessern, um den sich wandelnden Bedürfnissen unserer Benutzer(innen) gerecht zu werden. Hier findest du einige neue Verbesserungen, die deinen Workflow optimieren und deine Produktivität steigern werden.\n\n> Entdecke die Zukunft von KI-gestützter Softwareentwicklung mit unserem virtuellen Launch-Event zu GitLab 17.  [Sieh es dir jetzt an](https://about.gitlab.com/seventeen/)!\n\n## Erklärung von Sicherheitslücken: neue Integration\n\nWir haben einen wichtigen Meilenstein bei der Evolution des Chats erreicht: die Integration der [Erklärung von Sicherheitslücken in GitLab Duo](https://about.gitlab.com/the-source/ai/understand-and-resolve-vulnerabilities-with-ai-powered-gitlab-duo/). Dies ist die erste Funktion in [GitLab Duo](https://about.gitlab.com/gitlab-duo/), die von einem Team außerhalb unserer KI-Gruppe in den Chat integriert wurde. Dies zeigt, wie großen Wert man bei GitLab auf Zusammenarbeit und funktionsübergreifende Fähigkeiten legt.\n\n### Die wichtigsten Höhepunkte dieser Integration:\n\n- **Rasche Ausführung:** Das Team schaffte es in nur drei Wochen von einer Nachfragespitze zur Implementierung und bewies dadurch Agilität und Ausführungsstärke.\n- **Teamübergreifende Zusammenarbeit:** Diese Integration wurde von Teams außerhalb der KI-Gruppe geleitet und ebnete so den Weg für weitere, unterschiedliche Funktionsintegrationen, die die Zukunft bringen könnte.\n- **Verbesserte Sicherheitseinblicke:** Benutzer(innen) können demnächst den Chat nutzen, um ein tieferes Verständnis für Sicherheitslücken zu erhalten, die in ihren Projekten gefunden wurden.\n\nDiese Integration ist ein wichtiger Schritt, um den Chat zu einem noch leistungsstärkeren und vielseitigeren Tool für Entwickler(innen) zu machen, insbesondere im Bereich der Sicherheit.\n\n## Verbessertes Kontextbewusstsein\n\nWir haben erhebliche Fortschritte darin gemacht, das Kontextbewusstsein des Chats zu verbessern. Dadurch wurde er in verschiedenen Szenarien intelligenter und hilfreicher.\n\n### Immer verfügbares Wissen\n\nGitLab Duo Chat hat immer Zugriff auf:\n- GitLab-Dokumentation\n- Allgemeine Programmier- und Codierkenntnisse \n\nEs ist wichtig zu verstehen, dass der Chat keinen uneingeschränkten Zugriff auf deine gesamte GitLab-Instanz oder Codebase hat. Er verarbeitet nur die spezifischen Informationen, die du in deiner Abfrage angibst, bzw. das, was in der UI oder IDE in GitLab in deiner derzeitigen Ansicht unmittelbar relevant ist.\n\nWir arbeiten kontinuierlich daran, das Kontextbewusstsein des Chats auszubauen und weitere Inhaltstypen zu integrieren. Natürlich achten wir dabei immer auf die Privatsphäre der Benutzer(innen) sowie den Datenschutz. Durch diese schrittweise Erweiterung wird der Chat nach und nach zu einem immer leistungsstärkeren Assistenten für deinen Entwicklungs-Workflow, während die nötigen Einschränkungen für den Datenzugriff beibehalten werden.\n\n### Erweitertes Kontextwissen\n\nGitLab Duo Chat bietet jetzt [ein besseres Verständnis des Kontexts, in dem du arbeitest](https://docs.gitlab.com/ee/user/gitlab_duo_chat/#the-context-chat-is-aware-of), sowohl in der GitLab-UI als auch in IDEs. Hier haben wir für dich aufgeschlüsselt, was der Chat erkennt.\n\nIn der GitLab-UI:\n- **Epics** - Der Chat versteht, wenn du dich auf „dieses Epic“ beziehst oder die URL des Epics verwendest.\n- **Tickets** - Ähnlich wie bei Epics erkennt der Chat „dieses Ticket“ oder die URL des Tickets.\n- **Codedateien** - Beim Anzeigen einer einzelnen Datei kann der Chat Anfragen zu „diesem Code“ oder „dieser Datei“ interpretieren.\n\nIn IDEs:\n- **Ausgewählter Code** - Der Chat kann den von dir ausgewählten Code analysieren, wenn du nach „diesem Code“ oder „dieser Datei“ fragst.\n- **Epics und Tickets** -  Der Chat kann den Kontext verstehen, wenn du die URL angibst.\n\nWenn du in IDEs Slash-Befehle wie `/explain`, `/refactor`, oder `/tests` verwendest, hat der Chat außerdem Zugriff auf den ausgewählten Code.\n\n![Screenshot des GitLab Duo Chat-Fensters](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098382/Blog/Content%20Images/Blog/Content%20Images/image5_aHR0cHM6_1750098382107.png)\n\n### Chatverlauf und Caching\nDer GitLab Duo Chat behält die letzten 50 Nachrichten im Chat-Verlauf bei. Dieser Verlauf läuft drei Tage nach der letzten Verwendung ab. Wenn du deinen Browser oder deine IDE schließt, wird dein Chat-Verlauf innerhalb dieses Zeitraums nicht dauerhaft gelöscht. Bitte beachte jedoch, dass die langfristige Speicherung von Chat-Daten derzeit nicht unterstützt wird.\n\n## Abbruch von Prompts: Antworten bei Bedarf stoppen\n\nEine der am sehnlichsten erwarteten Funktionen ist jetzt verfügbar: [der Abbruch von Prompts](https://gitlab.com/groups/gitlab-org/-/epics/13662). Benutzer(innen) können jetzt laufende Prompts im Chat auf GitLab.com abbrechen und haben so [mehr Kontrolle über ihre Interaktionen](https://gitlab.com/gitlab-org/gitlab/-/issues/458397).- Jetzt verfügbar: Diese Funktion wurde auf GitLab.com eingeführt.\n- Demnächst verfügbar: Diese Funktion wird in unserer nächsten Version für selbstverwaltete Instanzen verfügbar sein. Benutzer(innen) von GitLab Dedicated erhalten sie im monatlichen Upgrade.\n- Offen: [Integration für Editor-Erweiterungen](https://docs.gitlab.com/ee/editor_extensions/) – [folge den Neuheiten im Ticket](https://gitlab.com/gitlab-org/editor-extensions/gitlab-jetbrains-plugin/-/issues/335).\n\nMit dieser Erweiterung kannst du eine Antwort stoppen, wenn du einen Prompt zu früh gesendet hast oder während des Wartens eine Änderung vorgenommen hast. Es ist eine kleine, aber leistungsstarke Funktion, die dir Zeit und Frust sparen kann.\n\nUm einen Prompt im GitLab Duo Chat abzubrechen, gehe wie folgt vor:\n1. Öffne den GitLab Duo Chat auf GitLab.com.\n2. Gib einen Prompt oder eine Frage ein, z. B. `What is this issue about?`.\n\n![Bildschirm mit dem Abbruch von Prompts im GitLab Duo Chat](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098382/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750098382108.png)\n\n3. Wenn du nach dem Senden des Prompts die Antwort abbrechen möchtest, suche nach der neuen Schaltfläche „Abbrechen“, die angezeigt wird, während der Chat eine Antwort generiert.\n\n![Screenshot der Schaltfläche „Abbrechen“ im Chat](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098382/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750098382110.png)\n\n4. Klicke auf die Schaltfläche „Abbrechen“, um die Antwortgenerierung sofort zu stoppen.\n\n![Screenshot zeigt, dass die Antwort abgebrochen wurde](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098382/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750098382112.png)\n\n## Architekturverbesserungen\n\nHinter den Kulissen haben wir an Architekturverbesserungen gearbeitet, um den GitLab Duo Chat robuster und effizienter zu machen:\n\n- Umstieg auf das Language Server Protocol ([LSP](https://gitlab.com/gitlab-org/editor-extensions/gitlab-lsp)): Dadurch wird die Integration des Chats in verschiedene Entwicklungsumgebungen verbessert. \n- GitLab Language Server ist ein experimentelles TypeScript-Projekt, das eine gemeinsame Schnittstelle für IDE-Erweiterungen zum Erstellen von GitLab-Funktionen bietet. Es unterstützt derzeit Codevorschläge für GitLab Duo und wird in Kürze auch GitLab Duo Chat unterstützen.\n\nObwohl diese Änderung hauptsächlich die zugrunde liegende Architektur betrifft, bemerken Benutzer(innen) vielleicht Folgendes:\n- Verbesserte Reaktion und Leistung bei der Nutzung des Chats in verschiedenen IDEs und Editoren.\n- Konsistenteres Verhalten der Chat-Funktionen in verschiedenen Entwicklungsumgebungen.\n- Verbesserte Möglichkeit, in Zukunft neue Funktionen und Verbesserungen hinzuzufügen.\n\nSieh dir in diesem Video eine Einführung dazu an, wie GitLab Language Server Codevorschläge ermöglicht:\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/VQlWz6GZhrs?si=_G5mOyYqEGAmnRv4\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n## Wie geht es weiter?\n\nWir arbeiten kontinuierlich daran, GitLab Duo Chat zu verbessern. Hier sind einige Highlights:\n\n- Wir sind dabei, unsere KI-Funktionen auf [Claude 3.5 Sonnet](https://gitlab.com/gitlab-org/gitlab/-/issues/468334) zu migrieren. Dieses Upgrade bringt eine verbesserte Leistung und Funktionen für den Chat und andere KI-gestützte Funktionen.\n- Wir arbeiten aktiv daran, dass der [Chat auch mit benutzerdefinierten, selbst gehosteten Modellen funktioniert](https://gitlab.com/groups/gitlab-org/-/epics/13760). Dadurch können Unternehmen ihre eigenen KI-Modelle mit dem Chat nutzen und haben so mehr Kontrolle über die Wissensdatenbank der KI. Außerdem wird die Leistung bei domain-spezifischen Aufgaben potenziell verbessert.\n- Wir sind derzeit dabei, die [Synchronisierung von Nachrichten über alle Clients hinweg](https://gitlab.com/gitlab-org/gitlab/-/issues/418760), einschließlich WebUI, abzuschließen, um eine nahtlose Kommunikation zu gewährleisten und alle deine Clients synchron zu halten und so deine Zusammenarbeit zu verbessern.\n- Wir [migrieren die Funktion „Kommentare zusammenfassen“ in den Chat](https://gitlab.com/gitlab-org/gitlab/-/merge_requests/156650). Du kannst mehrere Kommentare direkt im Chat zu einem Ticket zusammenfassen, um die wichtigsten Punkte und Erkenntnisse aus Diskussionen schnell zu verstehen und so deine Zusammenarbeit zu verbessern.\n\nWir freuen uns auf [dein Feedback zu diesen Verbesserungen](https://gitlab.com/gitlab-org/gitlab/-/issues/430124). Bleib dran, während wir GitLab Duo Chat weiterentwickeln.\n\n> Erfahre in unserer laufenden Serie noch mehr darüber, [wie wir GitLab Duo entwickeln](https://about.gitlab.com/blog/developing-gitlab-duo-series/).\n",[678,9,677],"2024-11-13",{"slug":864,"featured":90,"template":682},"developing-gitlab-duo-a-roundup-of-recent-chat-enhancements","content:de-de:blog:developing-gitlab-duo-a-roundup-of-recent-chat-enhancements.yml","Developing Gitlab Duo A Roundup Of Recent Chat Enhancements","de-de/blog/developing-gitlab-duo-a-roundup-of-recent-chat-enhancements.yml","de-de/blog/developing-gitlab-duo-a-roundup-of-recent-chat-enhancements",{"_path":870,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":871,"content":877,"config":885,"_id":887,"_type":13,"title":888,"_source":15,"_file":889,"_stem":890,"_extension":18},"/de-de/blog/developing-gitlab-duo-ai-impact-analytics-dashboard-measures-the-roi-of-ai",{"ogTitle":872,"schema":873,"ogImage":874,"ogDescription":875,"ogSiteName":695,"noIndex":6,"ogType":696,"ogUrl":876,"title":872,"canonicalUrls":876,"description":875},"GitLab Duo: KI-Impact-Analyse-Dashboard misst den ROI von KI","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Entwicklung von GitLab Duo: KI-Impact-Analyse-Dashboard misst den ROI von KI\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Haim Snir\"}],\n        \"datePublished\": \"2024-05-15\",\n      }","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098611/Blog/Hero%20Images/Blog/Hero%20Images/blog-hero-banner-1-0178-820x470-fy25_7JlF3WlEkswGQbcTe8DOTB_1750098611370.png","In unserem Blog stellen wir eine neue Funktion vor, mit der du die Effektivität deiner Investitionen in die KI besser nachvollziehen kannst. Dies wird durch detaillierte Metriken wie die Nutzungsquote von Codevorschlägen ermöglicht.","https://about.gitlab.com/blog/developing-gitlab-duo-ai-impact-analytics-dashboard-measures-the-roi-of-ai",{"title":878,"description":875,"authors":879,"heroImage":874,"date":881,"body":882,"category":703,"tags":883},"Entwicklung von GitLab Duo: KI-Impact-Analyse-Dashboard misst den ROI von KI",[880],"Haim Snir","2024-05-15","***Generative KI bedeutet einen monumentalen Wandel in der Softwareentwicklungsbranche, da sie es einfacher macht, Software zu entwickeln, zu sichern und zu betreiben. Unsere neue Blog-Serie von unseren Produkt- und Entwicklungsteams gibt einen Einblick darin, wie wir die KI-Funktionen erstellen, testen und bereitstellen, die in deinem Unternehmen benötigt werden. Lerne neue Funktionen innerhalb von GitLab Duo kennen und wie sie DevSecOps-Teams dabei helfen werden, bessere Ergebnisse für Kund(inn)en zu erzielen.***\n\nWenn Unternehmen [GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/), unsere Suite von KI-Funktionen zur Unterstützung von DevSecOps-Workflows, einführen, benötigen Führungskräfte aus Wirtschaft und Technik einen Echtzeit-Überblick über den ROI der Technologie. Granulare Nutzungsdaten, Leistungsverbesserungen, der Kompromiss zwischen Geschwindigkeit, Sicherheit und Qualität und andere [Produktivitätsmetriken](https://about.gitlab.com/blog/measuring-ai-effectiveness-beyond-developer-productivity-metrics/) sind unerlässlich, um die Effektivität von KI in der Softwareentwicklung zu bewerten. Aus diesem Grund haben wir das KI-Impact-Analyse-Dashboard für GitLab Duo erstellt, das ab GitLab 17.0 verfügbar ist, um den ROI von KI zu messen.\n\n> Live-Demo! Entdecke die Zukunft der KI-gesteuerten Softwareentwicklung mit unserem virtuellen Launch-Event für GitLab 17. [Registriere dich noch heute](https://about.gitlab.com/seventeen/)!\n\n## Den ROI der KI-gestützten Funktionen von GitLab Duo verstehen\n\nUnternehmen haben uns in Bezug auf die Auswirkungen von KI auf den Lebenszyklus der Softwareentwicklung ihre Wünsche mitgeteilt:\n- Visualisieren der Metriken, die sich durch die Investitionen in KI verbessert haben.\n- Vergleich der Leistung von Teams, die KI einsetzen, mit Teams, die keine KI einsetzen.\n- Verfolgen des Fortschritts bei der Einführung von KI.\n- Automatisieren der Erkenntnisgewinnung aus einer großen Menge von Leistungsdaten.\n\nDas KI-Impact-Analyse-Dashboard bietet diese und weitere Funktionen mit anpassbarer Visualisierung. Teams können damit Folgendes tun:\n- **Überwachen der KI-Einführung:** Die Überwachung der Einführungsrate von KI ermöglicht es Unternehmen, ihre Strategien zu bewerten, um den ROI ihrer Technologieinvestitionen zu maximieren. \n- **Verfolgen von Leistungsverbesserungen:** Durch die Verfolgung von Metriken und die Beobachtung von Veränderungen nach der Einführung von KI können Führungskräfte die Vorteile und den geschäftlichen Wert von KI-Funktionen rasch beurteilen.\n\n## Was ist das KI-Impact-Analyse-Dashboard?\n\nIn dieser ersten Version des KI-Impact-Analyse-Dashboards konzentrieren wir uns auf die Bereitstellung von Einblicken und Metriken für die Akzeptanz von GitLab Duo Codevorschlägen, einschließlich:\n\n- **Detaillierte Nutzungsmetriken:** Ermittle das Verhältnis zwischen der monatlichen Nutzung von Codevorschlägen und der Gesamtzahl der Mitwirkenden, um herauszufinden, wie stark Codevorschläge in deinen Teams angenommen werden.\n- **Korrelationsbeobachtungen:** Untersuche, wie sich die Entwicklung der KI-Nutzung im aktuellen Monat und über die letzten sechs Monate auf andere wichtige Metriken eines Projekts oder einer Gruppe auswirkt. \n    - Für diese Korrelationsanalyse haben wir die neue Metrik „Nutzungsquote von Codevorschlägen“ als unabhängige Variable (die Ursache) hinzugefügt. Die monatliche Nutzungsrate von Codevorschlägen errechnet sich aus der Anzahl der monatlich eindeutigen Benutzer(innen), die Codevorschläge verwenden, geteilt durch die Gesamtzahl der monatlich eindeutigen [Mitwirkenden](https://docs.gitlab.com/ee/user/profile/contributions_calendar.html#user-contribution-events). GitLab betrachtet hierbei die Summe der monatlichen eindeutigen Code-Mitwirkenden, d. h. nur Benutzer(innen), die Ereignisse gepusht haben, werden in die Berechnung einbezogen.\n    - Als abhängige Variable (den Effekt) haben wir die folgenden [Leistungsmetriken](https://docs.gitlab.com/ee/user/analytics/value_streams_dashboard.html#dashboard-metrics-and-drill-down-reports) hinzugefügt: Bearbeitungszeit, Abarbeitungsdauer und Häufigkeit der Bereitstellung. Und die [Qualitäts- und Sicherheitsmetriken](https://docs.gitlab.com/ee/user/analytics/value_streams_dashboard.html#dashboard-metrics-and-drill-down-reports) sind die Änderungsfehlerrate und kritische Sicherheitslücken. \n- **Vergleichsansicht:**  Erfasse den Leistungsunterschied zwischen Teams, die KI einsetzen, und solchen, die sie nicht einsetzen, und finde einen Kompromiss zwischen Geschwindigkeit, Qualität und Sicherheitsrisiko.\n\n![Vergleich von KI-Nutzung und SDLC-Leistung](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098621/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750098620998.png)\n\n## Wie geht es weiter mit dem KI-Impact-Analyse-Dashboard?\n\nWir haben große Pläne, um die Möglichkeiten des KI-Impact-Analyse-Dashboards zu erweitern. Hier sind einige der Highlights:\n\n1. Neue Kachelvisualisierungen wie „GitLab Duo-Plätze: Zugewiesen und genutzt“, „Codevorschläge: Übernahmequote %“ und „GitLab Duo Chat: Eindeutige Benutzer(innen)“, um einen tieferen Einblick in das Nutzungsverhalten von GitLab Duo zu erhalten.\n\n![KI-Impact-Analyse-Dashboard](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098621/Blog/Content%20Images/Blog/Content%20Images/Screenshot_2024-07-17_at_12.50.31_aHR0cHM6_1750098620999.png)\n\n2. Ein neues Vergleichsbalkendiagramm, mit dem du beobachten kannst, wie Veränderungen in einer Metrik mit Veränderungen in anderen Metriken korrelieren:\n\n![KI-Impact-Vergleichsbalkendiagramm](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098621/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750098621000.png)\n\n3. KI-Statistiken im [Bericht zur Beitragsanalyse](https://docs.gitlab.com/ee/user/group/contribution_analytics/index.html), um zu verstehen, wie Benutzer(innen) mit KI-Funktionen interagieren. Ermittle, welche Benutzer(innen) KI-Funktionen nutzen und ob sich ihre Leistung im Laufe der Zeit verändert hat:\n\n![Bericht zur Beitragsanalyse](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098621/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750098621001.png)\n\n## Lege noch heute los\n\nWir sind vom Potential des KI-Impact-Analyse-Dashboard begeistert. Es zeigt nicht nur die realen Geschäftsergebnisse der KI auf, sondern fördert auch fundierte Entscheidungen über den zukünftigen Einsatz von KI zur Optimierung des DevSecOps-Lebenszyklus. Weitere Informationen über die nächsten Schritte und die Möglichkeit, Feedback zu geben oder Fragen zu stellen, findest du in unserem [KI-Impact-Analyse-Dashboard Epic](https://gitlab.com/groups/gitlab-org/-/epics/12978).\n\nStarte noch heute deine [kostenlose Testversion von GitLab Duo und dem KI-Impact-Analyse-Dashboard](https://about.gitlab.com/de-de/gitlab-duo/#free-trial).\n\n## Weitere Artikel aus der Serie „Entwicklung von GitLab Duo“\n\n- [Entwicklung von GitLab Duo: Wie wir KI-Modelle im großen Maßstab validieren und testen](https://about.gitlab.com/de-de/blog/developing-gitlab-duo-how-we-validate-and-test-ai-models-at-scale/)\n- [Entwicklung von GitLab Duo: Wie wir unsere KI-Funktionen selbst verwenden (dogfooding)](https://about.gitlab.com/de-de/blog/developing-gitlab-duo-how-we-are-dogfooding-our-ai-features/)\n\n_Haftungsausschluss: 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._",[678,884,9],"performance",{"slug":886,"featured":90,"template":682},"developing-gitlab-duo-ai-impact-analytics-dashboard-measures-the-roi-of-ai","content:de-de:blog:developing-gitlab-duo-ai-impact-analytics-dashboard-measures-the-roi-of-ai.yml","Developing Gitlab Duo Ai Impact Analytics Dashboard Measures The Roi Of Ai","de-de/blog/developing-gitlab-duo-ai-impact-analytics-dashboard-measures-the-roi-of-ai.yml","de-de/blog/developing-gitlab-duo-ai-impact-analytics-dashboard-measures-the-roi-of-ai",{"_path":892,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":893,"content":899,"config":908,"_id":910,"_type":13,"title":911,"_source":15,"_file":912,"_stem":913,"_extension":18},"/de-de/blog/developing-gitlab-duo-blending-ai-and-root-cause-analysis-to-fix-ci-cd",{"ogTitle":894,"schema":895,"ogImage":896,"ogDescription":897,"ogSiteName":695,"noIndex":6,"ogType":696,"ogUrl":898,"title":894,"canonicalUrls":898,"description":897},"GitLab Duo – die KI löst Probleme bei CI/CD-Pipelines ","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Entwicklung von GitLab Duo: mit KI und Ursachenanalyse zur Problembehebung bei CI/CD-Pipelines\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Rutvik Shah\"},{\"@type\":\"Person\",\"name\":\"Michael Friedrich\"}],\n        \"datePublished\": \"2024-06-06\",\n      }","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097321/Blog/Hero%20Images/Blog/Hero%20Images/blog-hero-banner-1-0178-820x470-fy25_7JlF3WlEkswGQbcTe8DOTB_1750097321081.png","Entdecke, wie wir die Ursachenanalyse mit KI aufgepeppt haben, um fehlerhafte CI/CD-Pipelines wieder zum Laufen zu bringen. Dabei erwarten dich Beispiele und Übungen, die du selbst ausprobieren kannst.","https://about.gitlab.com/blog/developing-gitlab-duo-blending-ai-and-root-cause-analysis-to-fix-ci-cd",{"title":900,"description":897,"authors":901,"heroImage":896,"date":904,"body":905,"category":703,"tags":906},"Entwicklung von GitLab Duo: mit KI und Ursachenanalyse zur Problembehebung bei CI/CD-Pipelines",[902,903],"Rutvik Shah","Michael Friedrich","2024-06-06","***Generative KI bedeutet einen monumentalen Wandel in der\nSoftwareindustrie, da sie die Entwicklung, die Sicherheit und den Betrieb\nvon Software vereinfacht. Unsere neue Blog-Reihe, von unseren Produkt- und\nEntwicklungsteams, gibt einen Einblick darin, wie wir die\nKI-Funktionalitäten entwickeln, testen und bereitstellen, die in deinem\nUnternehmen benötigt werden. Lerne neue Funktionen innerhalb von GitLab Duo\nkennen und erfahre, wie diese DevSecOps-Teams dabei helfen werden, bessere\nErgebnisse für Kund(inn)en zu erzielen.***\n\n\nHattest du schon einmal eine defekte [CI/CD-Pipeline](https://about.gitlab.com/topics/ci-cd/benefits-continuous-integration/) und musstest deinen DevSecOps-Workflow unterbrechen oder sogar das Deployment verzögern, um die Ursache herauszufinden? Wenn bei der Entwicklung von Software etwas schief läuft, müssen Entwickler(innen) traditionellerweise die Fehler selbst beheben, Logdatei über Logdatei durchforsten und oft viele Behebungsversuche durchführen. Mit der [Ursachenanalyse von GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/), die Teil unserer Suite aus KI-Funktionen ist, hat das Rätselraten nun ein Ende, denn diese findet für dich die Ursache einer defekten CI/CD-Pipeline. In diesem Artikel erfährst du, was die Ursachenanalyse ist und wie du die KI-Funktionen von GitLab Duo in deinen DevSecOps-Workflow einbauen kannst.\n\n\n> Entdecke die Zukunft von KI-gestützter Softwareentwicklung mit unserem virtuellen Launch-Event zu GitLab 17. [Jetzt ansehen!](https://about.gitlab.com/de-de/seventeen/)\n\n\n## Was ist eine Ursachenanalyse?\n\n\nDie Ursachenanalyse von GitLab Duo ist eine KI-Funktionalität, die dir dabei hilft, die Grundursache eines fehlerhaften CI/CD-Joblauf herauszufinden. Sie analysiert die Protokolle und schlägt dir dann Möglichkeiten zur Behebung vor. Während die Ursachenanalyse oft im Incident Management angesiedelt ist, sind ihre Workflows und die Fehlersuche Teil eines jeden DevSecOps-Workflows. Ops-Teams, Adminstrator(inn)en und Plattformentwickler(innen) stehen durch Bereitstellungsprobleme, die durch Infrastructure as Code (IaC) entstehen, Kubernetes- und GitOps-Probleme oder durch die lange Nachverfolgung von Stacktraces und Untersuchung von Pipeline-Fehlschlägen vor Herausforderungen.\n\n\nMit der Ursachenanalyse von GitLab Duo nutzen alle dasselbe Interface. Mit Hilfe von KI werden Fehler zusammengefasst, analysiert und Lösungsvorschläge gemacht, damit Unternehmen schneller sichere Software veröffentlichen können.\n\n\nEine Pipeline kann aus verschiedensten Gründen Fehler aufweisen, darunter Syntax-Fehler im Code, fehlende Abhängigkeiten, auf denen die Pipeline basiert, Testfehler während des Build-Vorgangs, Zeitüberschreitungen bei Kubernetes- und IaC-Bereitstellungen sowie zahlreiche weitere Probleme. Wenn solche Probleme auftreten, liegt es in der Verantwortung von allen, die durch die Pipeline erstellten Logs genauestens zu überprüfen. Bei der Überprüfung der Logs wird dann der detaillierte Output untersucht, um spezifische Fehlschläge aufzudecken und die Ursache der defekten Pipeline zu finden. Die folgende Pipeline hat beispielsweise mehrere fehlgeschlagene Jobs, die untersucht und repariert werden müssen.\n\n\n![Bild mit mehreren Job-Ausfällen](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097332/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097332601.png)\n\n\nEs kann unterschiedlich lange dauern, diese Probleme zu beheben. Das hängt zum Großteil von Faktoren wie den folgenden ab:\n\n\n* Wie vertraut die Entwickler(innen) mit dem Projekt sind\n\n* Ihr Erfahrungsniveau beim Umgang mit ähnlichen Problemen\n\n* Ihr allgemeines Kenntnislevel in der Fehlerbehebung im Kontext der Pipeline.\n\n\nDie manuelle Analyse kann unglaublich herausfordernd und zeitaufwändig sein, da die Logs aus Anwendungsprotokollen und Systemmeldungen mit einer Vielzahl an Fehlerquellen bestehen. Die typische Behebung einer Pipeline besteht aus mehreren Iterationen und Kontextwechseln. Aufgrund der Komplexität und der unstrukturierten Natur der Protokolle ist dies ein idealer Bereich, in dem generative KI die Arbeit beschleunigen kann. Durch den Einsatz von KI können Fehler in einer Pipeline signifikant schneller erkannt und behoben werden. Außerdem ist weniger Expertise für die Behebung einer Pipeline wie im obigen Beispiel erforderlich.Sieh dir die Ursachenanalyse von GitLab Duo in Aktion an:\n\n\n\u003C!-- blank line -->\n\n\n\u003Cfigure class=\"video_container\">\n\n \u003Ciframe src=\"https://www.youtube.com/embed/sTpSLwX5DIs?si=J6-0Bf6PtYjrHX1K\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\n\u003C/figure>\n\n\n\u003C!-- blank line -->\n\n\n## Wie funktioniert die Ursachenanalyse?\n\n\nBei der [Ursachenanalyse](https://docs.gitlab.com/ee/user/ai_experiments.html#root-cause-analysis) wird ein Teil des CI/CD-Stacktraces an ein [GitLab-KI-Gateway](https://docs.gitlab.com/ee/architecture/blueprints/ai_gateway/) weitergeleitet. GitLab stellt sicher, dass der weitergeleitete Teil in die Limitierungen des umfangreichen Sprachmodells (LLM) passt und erstellt einen vorgefertigten Prompt, um herauszufinden, warum der Job fehlgeschlagen sein könnte. Der Prompt weist das LLM außerdem an, ein Beispiel aufzuzeigen, wie ein(e) Benutzer(in) den fehlerhaften Job beheben könnte. Nachfolgend sind zwei Beispielszenarien, in denen die Ursachenanalyse hilfreich sein kann.\n\n\n#### 1. Analyse eines Abhängigkeitsfehlers in Python\n\n\nEine Python-Anwendung kann zusätzliche Bibliotheken mit Funktionen importieren, die nicht in der Standardbibliothek enthalten sind. Das Projekt [Ursachenanalyse – Python-Konfiguration](https://gitlab.com/gitlab-da/use-cases/ai/ai-workflows/gitlab-duo-challenges/root-cause-analysis/challenge-root-cause-analysis-python-config) implementiert eine Anwendung, die die Konfiguration parst und eine SQLite-Datenbank initialisiert, wobei beide auch ohne zusätzlich installierte Abhängigkeiten funktionieren. Das Beispiel verwendet Best Practices in CI/CD mit einer Python-Umgebung sowie Cashing. Zuletzt wurde nun ein Redis-Caching-Client hinzugefügt, und jetzt schlägt der CI/CD-Build aus irgendeinem Grund fehl. \n\n\nDurch die Ursachenanalyse erfährst du sofort, dass `ModuleNotFoundError` bedeutet, dass das Modul tatsächlich nicht in der Python-Umgebung installiert ist. GitLab Duo schlägt außerdem einen Fix vor: Installiere das Redis-Modul über den PIP-Paketmanager.\n\n\n![Bild mit „modulenotfounderror“ und Lösungsvorschlag von GL Duo](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097332/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097332602.png)\n\n\nDie fehlerhafte Pipeline kann [hier](https://gitlab.com/gitlab-da/use-cases/ai/ai-workflows/gitlab-duo-challenges/root-cause-analysis/challenge-root-cause-analysis-python-config/-/jobs/6992716398) eingesehen werden. \n\n\nDas Ergebnis der Ursachenanalyse gibt eine Zusammenfassung des Problems aus, das offensichtlich ein Fehler mit einem fehlenden `redis`-Modul ist. Versuchen wir nun, das Problem zu beheben, indem das `redis`-Modul installiert wird. Du kannst entweder `pip install redis` im Abschnitt `script` des CI/CD-Jobs aufrufen oder einen generellen Weg über die Datei `requirements.txt` wählen. Letztere ist nützlich für eine Single Source of Truth (einzige Quelle der Wahrheit) für Abhängigkeiten, die in der Entwicklungsumgebung und in CI/CD-Pipelines installiert wurden.\n\n\n```yaml\n\ntest:\n  extends: [.python-req]\n  stage: test \n  before_script:\n    # [🦊] hint: Root cause analysis. # Solution 1: Install redis using pip\n    - pip install redis\n    # Solution 2: Add redis to requirements.txt, use pip\n    - pip install -r requirements.txt \n\n  script:\n    - python src/main.py\n```\n\n\nNachdem du die fehlende Python-Abhängigkeit behoben hast, schlägt der CI/CD-Job erneut fehl. Führe erneut eine Ursachenanalyse durch, um zu erfahren, dass kein Redis-Service den Job ausführt. Wechsle zum GitLab Duo Chat und gib den Prompt `How to start a Redis service in CI/CD` ein, um zu erfahren, wie du das Attribut `services` im CI/CD-Job konfigurierst.\n\n\n![Zeigt die Aufforderung zum Starten eines Redis-Dienstes](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097333/Blog/Content%20Images/Blog/Content%20Images/image6_aHR0cHM6_1750097332602.png)\n\n\nÄndere `.gitlab-ci.yml` mit dem Job `test` und gib unter service den Dienst `redis` an.\n\n\n```yaml\n\ntest:\n  extends: [.python-req]\n  stage: test \n  before_script:\n    # [🦊] hint: Root cause analysis.\n    # Solution 1: Install redis using pip\n    - pip install redis\n    # Solution 2: Add redis to requirements.txt, use pip\n    - pip install -r requirements.txt \n\n  script:\n    - python src/main.py\n\n  # Solution 3 - Running Redis\n  services:\n    - redis\n```\n\n\nWenn der Redis-Server ausgeführt wird, kannst du die Python-Anwendung erfolgreich ausführen und die Ausgabe im CI/CD-Log sehen.\n\n\n![Ausgabe der Python-Anwendung](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097332/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750097332603.png)\n\n\nDie Lösung kann auch im Unterordner in [/solution](https://gitlab.com/gitlab-da/use-cases/ai/ai-workflows/gitlab-duo-challenges/root-cause-analysis/challenge-root-cause-analysis-python-config/-/tree/main/solution?ref_type=heads) eingesehen werden.\n\n\n**Tipp:** Du kannst den [GitLab Duo Chat](https://docs.gitlab.com/ee/user/gitlab_duo_chat.html) auch bitten, zukünftige Probleme zu verfolgen:\n\n\n```markdown\n\nHow to lint Python code? Which tools are recommended for CI/CD.\n\nHow to pin a package version in Python requirements file?\t\n\nWhat are possible ways that this exception stacktrace is triggered in the future?\n\nAre there ways to prevent the application from failing?\n\n```\n\n\nDas nächste Beispiel ist fortgeschrittener und umfasst mehrere Probleme.\n\n\n#### 2. Fehlende Go-Laufzeit analysieren\n\n\nCI/CD-Jobs können in Containern ausgeführt werden, die über das Attribut `image` konfiguriert werden. Wenn der Container keine Programmiersprachen-Laufzeit bereitstellt, schlagen die ausgeführten Kommandos in `script`, die auf die Binärdatei `go` referenzieren, fehl. Beispielsweise muss dann die Fehlermeldung `/bin/sh: eval: line 149: go: not found` verstanden und behoben werden. \n\n\nWenn der Befehl `go` nicht im Laufzeit Kontext des Containers gefunden wird, kann dies mehrere Gründe haben:\n\n\n1. Der Job verwendet ein minimales Container-Image, z. B. `alpine`, und die Go-Laufzeit wurde nicht installiert.\n\n2. Der Job verwendet das falsche Standard-Container-Image, z. B. das oben in der CI/CD-Konfiguration angegebene oder das Schlüsselwort `default`.\n\n3. Der Job verwendet kein Container-Image, sondern den Shell Executor. Auf dem Host-Betriebssystem ist die Go-Laufzeit nicht installiert oder ist anderweitig defekt/nicht konfiguriert.\n\n\nDas Projekt [Ursachenanalyse – Go GitLab Release Fetcher](https://gitlab.com/gitlab-da/use-cases/ai/ai-workflows/gitlab-duo-challenges/root-cause-analysis/challenge-root-cause-analysis-go-gitlab-release-fetcher) bietet ein Übungsprojekt zur Analyse und Behebung von CI/CD-Problemen mit einer in Go geschriebenen GitLab-Release-Fetcher-Anwendung. Die CI/CD-Jobs `build` und `docker-build` schlagen fehl. Für die Behebung des Problems sind verschiedene Voraussetzungen erforderlich: Du musst verstehen, warum die Go-Laufzeit nicht installiert ist, und etwas über die Syntax `Dockerfile` erfahren.\n\n\n![Screenshot zeigt den fehlgeschlagenen Job „Change Docker Label“](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097332/Blog/Content%20Images/Blog/Content%20Images/image5_aHR0cHM6_1750097332603.png)\n\n\nDas [`solution/`-Verzeichnis](https://gitlab.com/gitlab-da/use-cases/ai/ai-workflows/gitlab-duo-challenges/root-cause-analysis/challenge-root-cause-analysis-go-gitlab-release-fetcher) bietet nach der Ursachenanalyse zwei mögliche Lösungen.\n\n\n## Probiere die Ursachenanalyse aus\n\n\nDie folgenden Szenarien kannst du verwenden, um die Ursachenanalyse auszuprobieren.\n\n\n* Wenn du auf Kubernetes-Bereitstellungsfehler oder Zeitüberschreitungen stößt. \n\n* Wenn OpenTofu- oder Terraform-IAC-Pipelines die Cloud-Ressourcen nicht bereitstellen können.\n\n* Wenn das Ansible-Playbook mit einem kryptischen Berechtigungsfehler in CI/CD fehlschlägt.\n\n* Wenn der Java Stacktracer 10 Seiten lang ist.\n\n* Mit einem Shell-Skript, das einen Ausführungsfehler provoziert.\n\n* Wenn ein Perl-Skript in einer Zeile fehlschlägt, die die einzige Zeile im Skript ist.\n\n* Wenn der CI/CD-Job eine Zeitüberschreitung aufweist und nicht klar ist, welcher Abschnitt diese verursacht.\n\n* Wenn eine Zeitüberschreitung der Netzwerkverbindung erreicht wird und du denkst, dass es kein DNS sein kann.\n\n\n### Wie geht es mit der Ursachenanalyse von GitLab Duo in Zukunft weiter?\n\n\nWir wollen unseren Nutzer(inne)n langfristig helfen, ihre Pipelines in weniger Iterationen und schneller zu reparieren. Die Ursachenanalyse wird dabei in GitLab Duo Chat, unserem KI Assistenten, geöffnet und zeigt die Antwort dort. Benutzer(innen) können die Empfehlung dann direkt verwenden oder weiter mit dem Chat agieren, indem sie spezifische, weiterführende Fragen stellen (z. B. spezifische Fixes für eine bestimmte Programmiersprache) oder indem sie je nach Ursache nach alternativen Lösungen fragen.\n\n\nZum Beispiel ist hier die Ursachenanalyse für einen fehlgeschlagenen Job:\n\n\n![Antwort auf die Grundursachenanalyse](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097332/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097332603.png)\n\n\nBenutzer(innen) können Folgefragen stellen, die auf der von der KI generierten Antwort basieren.\n\n\n* Ich möchte kein eigenes Docker Image erstellen. Bitte erkläre mir andere Möglichkeiten, das Problem zu beheben.\n\n* Ich habe keinen Zugriff auf die Docker-Image-Erstellung. Es sieht so aus, als würde die Go-Binärdatei fehlen. Gibt es alternative Images, die du vorschlagen kannst?\n\n\nGitLab führt außerdem Qualitäts-Vergleiche für die erstellten Antworten durch, um das Nutzererlebnis langfristig zu verbessern.\n\n\nWeitere Informationen findest du in unserem [Epic zur Ursachenanalyse](https://gitlab.com/groups/gitlab-org/-/epics/13080). Wir würden uns auch über dein Feedback zu dieser Funktionalität freuen. Bitte hinterlasst dafür einen Kommentar in unserem [Feedback-Ticket zur Ursachenanalyse](https://gitlab.com/groups/gitlab-org/-/epics/13872).\n\n\n## Erste Schritte mit der Ursachenanalyse\n\n\nIn unserer [Dokumentation](https://docs.gitlab.com/ee/user/ai_experiments.html#root-cause-analysis) findest du Informationen dazu, wie du die Funktion als GitLab-Ultimate-Kund(inn)en aktivieren kannst. Außerdem ist die Ursachenanalyse von GitLab Duo bald in GitLab Self-Managed und GitLab Dedicated verfügbar.\n\n\nBist du kein(e) GitLab-Ultimate-Kunde/Kundin? Starte jetzt [deine kostenlose Testversion](https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com/blog&glm_content=default-saas-trial).\n",[678,705,907,707,9],"DevSecOps",{"slug":909,"featured":90,"template":682},"developing-gitlab-duo-blending-ai-and-root-cause-analysis-to-fix-ci-cd","content:de-de:blog:developing-gitlab-duo-blending-ai-and-root-cause-analysis-to-fix-ci-cd.yml","Developing Gitlab Duo Blending Ai And Root Cause Analysis To Fix Ci Cd","de-de/blog/developing-gitlab-duo-blending-ai-and-root-cause-analysis-to-fix-ci-cd.yml","de-de/blog/developing-gitlab-duo-blending-ai-and-root-cause-analysis-to-fix-ci-cd",{"_path":915,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":916,"content":922,"config":929,"_id":931,"_type":13,"title":932,"_source":15,"_file":933,"_stem":934,"_extension":18},"/de-de/blog/developing-gitlab-duo-how-we-are-dogfooding-our-ai-features",{"title":917,"description":918,"ogTitle":917,"ogDescription":918,"noIndex":6,"ogImage":919,"ogUrl":920,"ogSiteName":695,"ogType":696,"canonicalUrls":920,"schema":921},"Entwicklung von GitLab Duo: Dogfooding unserer KI-Funktionen","Im Rahmen unserer Blog-Reihe zeigen wir mithilfe von Beispielen aus der Praxis, wie wir KI in den Lebenszyklus unserer Softwareentwicklung integrieren und ihren Erfolg anhand von Metriken messen.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098360/Blog/Hero%20Images/Blog/Hero%20Images/blog-hero-banner-1-0178-820x470-fy25_7JlF3WlEkswGQbcTe8DOTB_1750098360821.png","https://about.gitlab.com/blog/developing-gitlab-duo-how-we-are-dogfooding-our-ai-features","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Entwicklung von GitLab Duo: Dogfooding unserer KI-Funktionen\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"David O'Regan\"}],\n        \"datePublished\": \"2024-05-20\",\n      }\n                  ",{"title":917,"description":918,"authors":923,"heroImage":919,"date":924,"body":925,"category":703,"tags":926},[858],"2024-05-20","***Generative KI bedeutet einen monumentalen Wandel in der Softwareentwicklungsbranche, da sie es einfacher macht, Software zu entwickeln, zu sichern und zu betreiben. Unsere neue Blog-Serie von unseren Produkt- und Entwicklungsteams gibt einen Einblick darin, wie wir die KI-Funktionen erstellen, testen und bereitstellen, die in deinem Unternehmen benötigt werden. Lerne neue Funktionen innerhalb von GitLab Duo kennen und erfahre, wie diese DevSecOps-Teams dabei helfen werden, bessere Ergebnisse für Kund(inn)en zu erzielen.***\n\n[GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/), unsere Suite von KI-gestützten Funktionen, hat unsere internen technischen Workflows verändert und die Effizienz in unserem gesamten Entwicklungsprozess gesteigert. Da wir völlig überzeugt sind von Dogfooding und Transparenz, möchten wir zeigen, wie unsere Teams täglich KI einsetzen, einschließlich hervorragender Produkte wie GitLab Duo Codevorschläge und GitLab Duo Chat, um Entwicklungsprozesse zu rationalisieren, den manuellen Aufwand zu reduzieren und die Produktivität zu steigern. Du wirst mehr über die Vorteile erfahren, von denen hochtechnische Teams wie das Engineering-Team und auch weniger technische Teams wie das Dokumentations- und das Produktmanagementteam profitiert haben.\n\n> Live-Demo! Entdecke die Zukunft von KI-gesteuerter Softwareentwicklung mit unserer virtuellen Produktpräsentation zu GitLab 17. [Registriere dich noch heute!](https://about.gitlab.com/seventeen/)\n\n## Anwendungsfälle aus der Praxis\n\nUnsere Teams haben die [vielen Funktionen von GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/#features) in ihre täglichen Abläufe integriert. Hier sind einige Beispiele dafür, wie GitLab Duo den verschiedenen Teams bei der Durchführung alltäglicher Aktivitäten hilft.\n\n### Zusammenfassung und Dokumentation\n\n- **Code-Review-Prozess optimieren:** Teammitglied und Backend-Entwicklerin [Gosia Ksionek](https://about.gitlab.com/company/team/#mksionek) zeigt die praktischen Vorteile von KI in ihrem Workflow auf. Zur Optimierung des Code-Review-Prozesses verwendet sie GitLab Duo. Sie nutzt GitLab Duo effektiv, um [Merge Requests zusammenzufassen](https://youtu.be/3SIhe8dgFEc). Dadurch können Codeänderungen einfacher und schneller geprüft werden. Gosia fasst mit GitLab Duo nicht nur Merge Requests zusammen, sondern setzt es auch ein, um [Fragen zur Programmierung zu beantworten](https://www.youtube.com/watch?v=6n0I53XsjTc) und [komplexe Code-Schnipsel zu erklären](https://www.youtube.com/watch?v=3m2YRxa1SCY). So steigert sie ihre Produktivität und kann komplizierte Codebases besser verstehen und verwalten. Anhand dieser Demonstrationen zeigt Gosia, wie GitLab Duo die Effizienz und Klarheit im Entwicklungsprozess deutlich verbessern kann und damit unschätzbar wertvoll für Entwickler(innen) ist.\n\n\u003Ccenter>\n\nSieh dir an, wie Gosia die GitLab Duo Merge Request-Zusammenfassung verwendet:\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/3SIhe8dgFEc?si=Q8JG3Ix3K_THhbpv\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\nSieh dir an, wie Gosia GitLab Duo verwendet, um Fragen zur Programmierung zu beantworten: \n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/6n0I53XsjTc?si=LA9VBHrgXpfJImSL\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\nSieh dir an, wie Gosia mit GitLab Duo komplexe Code-Schnipsel erklärt:\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/3m2YRxa1SCY?si=oms3szKwZoz-4yeq\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n\u003C/center>\n\n- **Kommentar-Threads zusammenfassen:** [Bartek Marnane](https://about.gitlab.com/company/team/#bmarnane), Vice President of Expansion Software Development, fasst mit GitLab Duo lange Kommentar-Threads kompakt zusammen und stellt dabei sicher, dass alle relevanten Details bei der Aktualisierung der Ticketbeschreibungen erfasst werden.\n\n- **Neue Dokumentation erstellen:** [Taylor McCaslin](https://about.gitlab.com/company/team/#tmccaslin), Group Manager, Product – Data Science Section, hat GitLab Duo genutzt, um [für GitLab Duo selbst neue Dokumentation zu erstellen](https://docs.gitlab.com/ee/user/ai_features.html). Dies ist ein Beispiel für einen Meta-Anwendungsfall, der die Klarheit und Konsistenz verbessert und die Zeit für die Dokumentation neuer Funktionen erheblich reduziert.\n\n- **Versionshinweise erstellen:** [Amanda Rueda](https://about.gitlab.com/company/team/#amandarueda), Senior Product Manager des Produktplanungsteams, verwendet GitLab Duo, um [kurze, wirkungsvolle Zusammenfassungen für Versionshinweise zu erstellen](https://gitlab.com/groups/gitlab-org/-/epics/10267) und dabei die Änderungen und deren Wert für die Benutzer(innen) hervorzuheben. Durch die Verwendung gut formulierter Prompts wie den folgenden stärkt Amanda ihren Workflow und stellt sicher, dass jeder Versionshinweis klar, prägnant und benutzerorientiert ist. Dadurch werden die gesamte Kommunikation und das Benutzererlebnis verbessert:\u003Cbr>\u003Cbr>\n*„Bitte erstelle eine Zusammenfassung dieser Änderung in zwei Sätzen, die für unsere Versionshinweise verwendet werden kann. Der Ton sollte umgangssprachlich sein und in der zweiten Person verfasst werden. Die Zusammenfassung sollte eine Beschreibung des Problems oder der Änderung enthalten und mit dem Wert verbunden sein, den wir für euch, die Benutzer(innen), schaffen.“*\n\u003Cbr>\u003Cbr>\n\n- Hier sind einige Beispiele für Versionshinweise, die gemeinsam mit GitLab Duo erstellt wurden:\n  - [Erweiterte Optionen zum Sortieren eurer Roadmap](https://gitlab.com/gitlab-org/gitlab/-/issues/460492)\n  - [Jetzt Ticketübersicht-Klarheit mit Meilenstein und Iteration](https://gitlab.com/gitlab-org/gitlab/-/issues/25758)\n  - [Design-Management-Funktionen auf Produktteams erweitert](https://gitlab.com/gitlab-org/gitlab/-/issues/438829)\n\n- **Optimierung der Navigation auf der Seite des Dokumentationsteams:** [Suzanne Selhorn](https://about.gitlab.com/company/team/#sselhorn), Teammitglied und Technische Redakteurin, setzte GitLab Duo ein, um [die linke Navigationsseite der Dokumentationsabteilung zu optimieren](https://docs.gitlab.com/ee/user/get_started/get_started_projects.html). Dazu stellte sie eine workflowbasierte Reihenfolge der Seiten bereit. Suzanne stellte GitLab Duo eine Liste von Funktionen zur Verfügung, womit die optimale Reihenfolge generiert und die linke Navigation entsprechend aktualisiert wurde. GitLab Duo hat auch einen Entwurf der Dokumentation für die [Ersten Schritte](https://docs.gitlab.com/ee/user/get_started/get_started_planning_work.html) viel schneller erstellt, als wenn Suzanne mit traditionellen, manuellen Methoden arbeiten würde.\n\n### Zielsetzung und Teamausrichtung\n\n- **Entwerfen und Verfeinern von OKRs:** [François Rosé](https://about.gitlab.com/company/team/#francoisrose), Engineering Manager, Entwicklung: Code-Review-Backend, betrachtet [GitLab Duo Chat](https://about.gitlab.com/blog/gitlab-duo-chat-now-generally-available/) als unschätzbar wertvoll für den Entwurf und die Verfeinerung von OKRs. Indem er Ziele klarer und effektiver formuliert, verbessert François die Zielsetzung und die Ausrichtung des Teams. Mit Chat stellt François sicher, dass alle OKRs präzise, umsetzbar und auf die Ziele des Teams ausgerichtet sind. Dadurch werden die Gesamtleistung und der Zusammenhalt des Teams verbessert. Hier ist ein Beispiel für einen Prompt, den er verwendet:\u003Cbr>\u003Cbr>\n\n    *„Hier ist ein OKR, das ich erstellen möchte:*\n\n    *Ziel: Rückblick auf Retrospektiven, um ein erfolgreiches Team zu fördern*\n\n    *Schlüsselergebnis: Messe die rückwirkende Zufriedenheit von 100 % der Teammitglieder*\n\n    *Schlüsselergebnis: Identifiziere 3 Verbesserungen für die asynchronen Retrospektiven*\n\n    *Schlüsselergebnis: Setze 1 Verbesserung um*\n\n    *Bitte stelle direktes Feedback bereit, wie die Formulierung dieses Ziels und dieser Schlüsselergebnisse verbessert werden können.“*\n\u003Cbr>\u003Cbr>\n\n- **Optimierte Einstellungs- und Rekrutierungsprozesse:** Sieh dir Chat in Aktion an, wie die Funktion [Denys Mishunov](https://about.gitlab.com/company/team/#dmishunov), Teammitglied und Frontend Engineer, dabei geholfen hat, einen klaren und prägnanten Text für [die Aktualisierung der E-Mail-Vorlage für technische Bewerber(innen)](https://gitlab.com/gitlab-com/people-group/hiring-processes/-/merge_requests/2165#note_1904898688) zu formulieren. Sieh dir an, wie das Team bei der Verbesserung der Kommunikation zusammenarbeitet, um so sicherzustellen, dass die Bewerber(innen) alle notwendigen Informationen mithilfe eines Merge Request erhalten. Dieses Beispiel zeigt die praktische Anwendung von KI-Tools zur Verbesserung der Kommunikationsprozesse innerhalb des Einstellungsworkflows.\n\n### Reaktion auf Vorfälle und Konfiguration\n- **Zusammenfassen von Produktionsvorfällen:** [Steve Xuereb](https://about.gitlab.com/company/team/#sxuereb), Site Reliability Engineer im Team, verwendet GitLab Duo, um Produktionsvorfälle zusammenzufassen und detaillierte Vorfall-Reviews zu erstellen und so den Dokumentationsprozess zu optimieren.\n\n- **Boilerplate für ‚.gitlab-ci.yml‘-Dateien erstellen:**  Steve verwendet Chat auch, um eine Boilerplate für ‚.gitlab-ci.yml‘ -Dateien zu erstellen, was seinen Workflow erheblich beschleunigt hat. [Chat](https://docs.gitlab.com/ee/user/gitlab_duo_chat.html) dient als wertvoller Partner für Ideenvorschläge. Darüber hinaus bietet [Code-Erklärung](https://docs.gitlab.com/ee/user/ai_features.html#code-explanation) detaillierte Antworten, die bei Vorfällen hilfreich sind und seine Produktivität und sein Verständnis der Codebase verbessern.\n\n### Codegenerierung und Tests\n- **Full-Stack-Entwicklung:** [Peter Hegman](https://about.gitlab.com/company/team/#peterhegman), Senior Frontend Engineer, hat [Codevorschläge für seine JavaScript- und Ruby-Entwicklung](https://gitlab.com/gitlab-org/gitlab/-/issues/435783#note_1731321963) verwendet. Dies zeigt, dass Codevorschläge zu einem leistungsstarken Tool für Entwickler(innen) bei technischen Fullstacks geworden sind. \n\n- **Generieren von Python-Skripten:** Denys hat [ein Experiment mit GitLab Duo für eine nicht zu GitLab gehörende Aufgabe](https://gitlab.com/gitlab-org/ai-powered/ai-framework/ai-experimentation) durchgeführt. Dieses Beispiel verdeutlicht die Flexibilität und den Nutzen unserer KI-Tools über typische Softwareentwicklungsaufgaben hinaus.\n\n\u003Ccenter>\nSieh dir an, wie Denys mit GitLab Duo Python-Skripte generiert, um Inhaltsdaten abzurufen und lokal zu speichern:\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/30ZTtk4K5yU?si=p5ZcFLg6dTZL5gFE\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n\u003C/center>\n\n### Forschung und Support\n- **Generieren von Test-Quellcode:**  [Michael Friedrich](https://about.gitlab.com/company/team/#dnsmichi), Senior Developer Advocate, verwendet GitLab Duo, um Test-Quellcode für CI/CD-Komponenten zu generieren. Dieser Ansatz wurde in verschiedenen Vorträgen und Präsentationen wie bei der jüngsten Veranstaltung „Open Source @ Siemens“ ([öffentliche Folien](https://go.gitlab.com/duA2Fc)) vorgestellt. Die Verwendung von GitLab Duo auf diese Weise trägt dazu bei, dass der Code konsistent und gut dokumentiert ist und mit unseren Best Practices übereinstimmt. Sieh dir sein [Rust-Beispiel](https://gitlab.com/components/rust#contributing) an.\n\n![Beispiel für Rust](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098367/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750098367547.png)\n\n- **Optimieren von Forschungsaufgaben:** Unsere Teammitglieder nutzen bei Fragen zu GitLab-Funktionen regelmäßig Chat, und optimieren so ihre Forschungs- und Supportaufgaben. Michael teilte mit: „Wenn ich eine Frage zu GitLab-Funktionen habe, verwende ich standardmäßig Chat, anstatt 100 Browser-Tabs zu öffnen. Dieser Workflow hilft mir dabei, die Benutzer(innen) in unserem Community-Forum effizient zu unterstützen. Zum Beispiel habe ich kürzlich mit dieser Methode [einem/r Benutzer(in) bei der SSH-Bereitstellung geholfen](https://forum.gitlab.com/t/how-to-make-ssh-deployment-more-clear-in-gitlab/102051/4?u=dnsmichi).“ Die Verwendung von Chat spart nicht nur Zeit, sondern wir erhalten auch schnell genaue Informationen und verbessern so den Support, den wir unserer Community anbieten.\n\n### Funktionstests\n- **Testen neuer Funktionen:** Unsere Ingenieure verwenden GitLab Duo, um neue Funktionen wie [Markdown-Unterstützung in Codevorschlägen](https://gitlab.com/gitlab-org/gitlab/-/issues/443365) zu testen. Eines unserer Teammitglieder merkte an: „Ich muss die Markdown-Unterstützung in Codevorschlägen testen, um Blog-Posts und GitLab-Dokumente in VS Code zu schreiben. Ich habe gesehen, dass die Unterstützung für Version 17.0 zusammengeführt wurde.“ Indem wir diese Funktionen vor der Veröffentlichung intern testen, stellen wir sicher, dass sie unseren Qualitätsstandards entsprechen.\n\n### Verständnis externer Codebases\n- **Erklären externer Projekte:** Die Funktion ‚/explain‘ von GitLab Duo ist besonders nützlich, um externe Projekte zu verstehen, die in GitLab importiert wurden. Diese Fähigkeit hat er kürzlich in einem Livestream mit dem Open-Source-Experten Eddie Jaoude hervorgehoben. Michael teilte uns mit: „Ich verwende ‚/explain` bei externen Projekten, um den Quellcode zu verstehen. Ich habe diese Idee für das Lernen über Open-Source-Projekte, Abhängigkeiten usw. während des Livestreams vorgestellt.“ Diese Funktion ist von unschätzbarem Wert für Entwickler(innen), die die Funktionalität und Abhängigkeiten unbekannter Codebases schnell erfassen müssen. So sind sie bedeutend effizienter und ihr Verständnis ist sehr viel besser.\n\n\u003Ccenter>\nSieh dir an, wie Michael ‚/explain` während eines Livestreams mit Eddie Jaoude vorstellt:\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/L2Mx8hOhkEE?si=R7W3v4EDqeJCaPOw\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n\u003C/center>\n\n## Vorteile von GitLab Duo\n\nDie Integration von GitLab Duo hat zahlreiche positive Auswirkungen mit sich gebracht und unsere Workflows in den Bereichen Engineering und Produktentwicklung erheblich verbessert:\n\n- Viele Aufgaben, bei denen zuvor manuell eingegriffen werden musste, werden jetzt automatisiert, wodurch unsere Ingenieure wertvolle Zeit gewinnen. Zum Beispiel sind das Zusammenfassen langer Threads und das Erstellen von Boilerplate-Code jetzt effizienter, sodass sich unser Team auf komplexere Probleme konzentrieren kann.\n\n- Die Zeit, die für die Dokumentation und Zusammenfassung von Tickets benötigt wird, hat sich verringert, was eine schnellere Verbreitung von Informationen und Entscheidungsfindung ermöglicht.\n\n- Mit KI-gestützten Codevorschlägen und -erklärungen erstellen unsere Teams qualitativ hochwertigeren Code mit weniger Fehlern und schnelleren Debugging-Prozessen. Die Integration von GitLab Duo in Vorfall-Reviews und die Unterstützung bei der Programmierung hat zu effizienteren und effektiveren Code-Reviews geführt.\n\n- Administrative Aufgaben wie der Entwurf von OKRs und das Erstellen von Versionshinweisen wurden optimiert. \n\nGitLab Duo hat nicht nur dazu beigetragen, unsere Effizienz zu steigern, sondern auch die Qualität und Geschwindigkeit unserer Entwicklungsprozesse zu verbessern, was die transformationelle Kraft von KI in der Softwareentwicklung verdeutlicht.\n\n## Wie geht es weiter?\n\nWir werden weiter KI in unsere Workflows integrieren und die Funktionen von GitLab Duo basierend auf internem Feedback und neuen Bedürfnissen kontinuierlich verbessern. Die fortlaufende Erfassung von Anwendungsfällen und Metriken mit dem [KI-Impact-Analyse-Dashboard](https://about.gitlab.com/de-de/blog/developing-gitlab-duo-ai-impact-analytics-dashboard-measures-the-roi-of-ai/) wird zu Verbesserungen führen und sicherstellen, dass GitLab Duo an der Spitze der KI-gesteuerten Entwicklungs-Tools bleibt.\n\n![Dogfooding Duo – KI-Analyse-Dashboard](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098367/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750098367547.png)\n\n> [Lege noch heute los mit unserer kostenlosen Testversion von GitLab Duo.](https://about.gitlab.com/de-de/gitlab-duo/#free-trial)\n\n## Erfahre mehr zur „Entwicklung von GitLab Duo\n\n- [Entwicklung von GitLab Duo: KI-Impact-Analyse-Dashboard misst den ROI von KI](https://about.gitlab.com/de-de/blog/developing-gitlab-duo-ai-impact-analytics-dashboard-measures-the-roi-of-ai/)\n- [Entwicklung von GitLab Duo: Wie wir KI-Modelle in großem Maßstab validieren und testen](https://about.gitlab.com/de-de/blog/developing-gitlab-duo-how-we-validate-and-test-ai-models-at-scale/)",[678,927,9,707,928],"code review","workflow",{"slug":930,"featured":90,"template":682},"developing-gitlab-duo-how-we-are-dogfooding-our-ai-features","content:de-de:blog:developing-gitlab-duo-how-we-are-dogfooding-our-ai-features.yml","Developing Gitlab Duo How We Are Dogfooding Our Ai Features","de-de/blog/developing-gitlab-duo-how-we-are-dogfooding-our-ai-features.yml","de-de/blog/developing-gitlab-duo-how-we-are-dogfooding-our-ai-features",{"_path":936,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":937,"content":943,"config":950,"_id":952,"_type":13,"title":953,"_source":15,"_file":954,"_stem":955,"_extension":18},"/de-de/blog/developing-gitlab-duo-how-we-validate-and-test-ai-models-at-scale",{"ogTitle":938,"schema":939,"ogImage":940,"ogDescription":941,"ogSiteName":695,"noIndex":6,"ogType":696,"ogUrl":942,"title":938,"canonicalUrls":942,"description":941},"GitLab Duo – Wie wir LLMs validieren & testen","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Entwicklung von GitLab Duo: Wie wir KI-Modelle im großen Maßstab validieren und testen\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Susie Bitters\"}],\n        \"datePublished\": \"2024-05-09\",\n      }","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749659856/Blog/Hero%20Images/blog-hero-banner-1-0178-820x470-fy25.png","Unsere Blog-Serie beginnt mit einem Blick hinter die Kulissen, wie wir LLMs evaluieren, sie an Anwendungsfälle anpassen und sie optimieren, um bessere Ergebnisse für die Benutzer(innen) zu erzielen.","https://about.gitlab.com/blog/developing-gitlab-duo-how-we-validate-and-test-ai-models-at-scale",{"title":944,"description":941,"authors":945,"heroImage":940,"date":947,"body":948,"category":703,"tags":949},"Entwicklung von GitLab Duo: Wie wir KI-Modelle im großen Maßstab validieren und testen",[946],"Susie Bitters","2024-05-09","**_Generative KI markiert einen monumentalen Wandel in der Softwareentwicklungsbranche, der es einfacher macht, Software zu entwickeln, sicherer zu machen und sie zu betreiben. Unsere neue Blog-Serie von unseren Produkt- und Entwicklungsteams gibt einen Einblick darin, wie wir die KI-Funktionen erstellen, testen und bereitstellen, die in deinem Unternehmen benötigt werden. Lerne neue Funktionen innerhalb von GitLab Duo kennen und wie sie DevSecOps-Teams dabei helfen, bessere Ergebnisse für Kund(inn)en zu erzielen._**\n\nGitLab schätzt das Vertrauen unserer Kund(inn)en in uns. Ein Teil der Aufrechterhaltung dieses Vertrauens ist die Transparenz darüber, wie wir die hochwertige Funktionalität unserer [GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/) KI-Funktionen erstellen, bewerten und gewährleisten. Die Funktionen von GitLab Duo basieren auf einer Vielzahl von Modellen, die es uns ermöglichen, eine Vielzahl von Anwendungsfällen zu unterstützen und unseren Kund(inn)en Flexibilität zu bieten. GitLab ist von vornherein nicht an einen einzigen Modellanbieter gebunden. Wir verwenden derzeit Foundation-Modelle von [Google](https://gitlab.com/gitlab-org/modelops/applied-ml/code-suggestions/ai-assist/-/blob/main/ai_gateway/models/vertex_text.py?ref_type=heads#L86) und [Anthropic](https://gitlab.com/gitlab-org/modelops/applied-ml/code-suggestions/ai-assist/-/blob/main/ai_gateway/models/anthropic.py?ref_type=heads#L62). Wir wägen jedoch kontinuierlich ab, welche Modelle für die Anwendungsfälle von GitLab Duo geeignet sind. In diesem Artikel geben wir einen Einblick in unseren Validierungsprozess für KI-Modelle.\n\n## Was sind LLMs\n\nUmfangreiche Sprachmodelle (Large language models, LLMs) sind generative KI-Modelle, die viele KI-Funktionen innerhalb der GitLab Plattform unterstützen. LLMs wurden mit riesigen Datensätzen trainiert und prognostizieren das nächste Wort in einer Sequenz basierend auf dem vorhergehenden Kontext. Als Antwort auf eine Eingabe (Prompt) von Benutzer(innen) erzeugen sie Text, der der Antwort eines Menschen ähnelt, indem sie abhängig vom Prompt aus der Wahrscheinlichkeitsverteilung von Wörtern ein Muster wiedergeben.\n\nLLMs ermöglichen es, intelligente Codevorschläge, Konversations-Chatbots, Code-Erklärungen, Analysen von Sicherheitslücken und mehr umzusetzen. Ihre Fähigkeit, für einen bestimmten Prompt unterschiedliche Antworten zu erzeugen, macht eine standardisierte Qualitätsbewertung schwierig. Da LLMs für verschiedene Eigenschaften optimiert werden können, werden so viele unterschiedliche KI-Modelle aktiv entwickelt.\n\n## Testen im großen Maßstab\n\nIm Gegensatz zu herkömmlichen Softwaresystemen, bei denen Ein- und Ausgaben einfacher definiert und getestet werden können, erzeugen LLMs Ausgaben, die oft nuanciert, vielfältig und kontextabhängig sind. Um diese Modelle zu testen, sind umfassende Strategien erforderlich, die die subjektiven und variablen Interpretationen von Qualität sowie die stochastische Natur ihrer Ergebnisse berücksichtigen. Wir können daher die Qualität der Ergebnisse eines LLM nicht individuell oder anekdotisch beurteilen. Stattdessen müssen wir in der Lage sein, das Gesamtmuster des Verhaltens eines LLM zu untersuchen. Um ein Gefühl für diese Muster zu bekommen, müssen wir in großem Maßstab testen. Darunter versteht man den Prozess der Bewertung der Leistung, Zuverlässigkeit und Robustheit eines Systems oder einer Anwendung über eine große und vielfältige Anzahl von Datensätzen und Anwendungsfällen. Unser [Centralized Evaluation Framework (CEF)](https://about.gitlab.com/direction/ai-powered/ai_framework/ai_evaluation/) verwendet Tausende von Prompts, die mit Dutzenden von Anwendungsfällen verknüpft sind, um signifikante Muster zu identifizieren und das Gesamtverhalten unserer grundlegenden LLMs und der GitLab Duo-Funktionen, in die sie integriert sind, zu bewerten.\n\nTesten im großen Maßstab hilft uns bei der:\n\n- **Gewährleistung von Qualität:** Durch Tests im großen Maßstab können wir die Qualität und Zuverlässigkeit dieser Modelle in einer Vielzahl von Szenarien und Inputs bewerten. Indem wir die Ergebnisse dieser Modelle in großem Maßstab validieren, können wir Muster identifizieren und potenzielle Probleme wie systematische Verzerrungen, Anomalien und Ungenauigkeiten abmildern.\n- **Optimierung der Leistung:** Die Intensivierung der Tests ermöglicht es GitLab, die Leistung und Effizienz von LLMs unter realen Bedingungen zu beurteilen. Dazu gehört die Bewertung von Faktoren wie Ausgabequalität, Latenz und der Kosten für die Optimierung der Bereitstellung und des Einsatzes dieser Modelle in GitLab Duo-Funktionen.\n- **Minderung von Risiken:** Das Testen von LLMs im großen Maßstab trägt dazu bei, die mit der Bereitstellung von LLMs in kritischen Anwendungen verbundenen Risiken zu mindern. Durch gründliche Tests über verschiedene Datensätze und Anwendungsfälle hinweg können wir potenzielle Fehlermodi, Sicherheitslücken und ethische Bedenken identifizieren und diese adressieren und beheben, bevor sie sich auf unsere Kund(inn)en auswirken.\n\nDas Testen von LLMs im großen Maßstab ist unerlässlich, um ihre Zuverlässigkeit und Robustheit für ihre Bereitstellung innerhalb der GitLab-Plattform sicherzustellen. Durch die Investition in umfassende Teststrategien, die verschiedene Datensätze, Anwendungsfälle und Szenarien umfassen, arbeitet GitLab daran, das volle Potenzial von KI-gestützten Workflows auszuschöpfen und gleichzeitig potenzielle Risiken zu mindern.\n\n### Wie wir in großem Maßstab testen\n\nDies sind die notwendigen Schritte, um LLMs in großem Maßstab zu testen.\n\n#### Schritt 1: Erstellen einer Prompt-Bibliothek als Proxy für die Produktion\nWährend andere Unternehmen Kundendaten einsehen und verwenden, um ihre KI-Funktionen zu trainieren, tut GitLab dies derzeit nicht.  Deshalb mussten wir eine umfassende Prompt-Bibliothek entwickeln, die sowohl den Umfang als auch die Aktivität der Produktionsumgebung abbildet.\n\nDiese Prompt-Bibliothek besteht aus Fragen und Antworten. Die Fragen stellen die Art von Abfragen oder Eingaben dar, die wir in der Produktionsumgebung erwarten würden, während die Antworten eine Grundwahrheit darüber darstellen, was unsere ideale Antwort wäre. Diese Referenzantwort könnte auch als Zielantwort formuliert werden. Sowohl die Frage als auch die Antwort können, aber müssen nicht von Menschen generiert werden. Diese Frage-Antwort-Paare geben uns eine Vergleichsbasis und einen Bezugsrahmen, mit dem wir die Unterschiede zwischen Modellen und Funktionen herausarbeiten können. Wenn mehreren Modellen dieselbe Frage gestellt wird und sie unterschiedliche Antworten erzeugen, können wir anhand unserer Referenzantwort feststellen, welches Modell eine Antwort gegeben hat, die unserem Ziel am nächsten kommt, und sie entsprechend bewerten.\n\nAuch hier ist ein zentrales Element einer umfassenden Prompt-Bibliothek, dass sie repräsentativ für die Eingaben ist, die wir in der Produktionsumgebung erwarten. Wir möchten wissen, wie gut die grundlegenden Modelle zu unserem spezifischen Anwendungsfall passen und wie gut unsere Funktionen funktionieren. Es gibt zahlreiche Datensätze mit Benchmark-Prompts, aber diese Datensätze spiegeln möglicherweise nicht die Anwendungsfälle wider, die wir bei GitLab annehmen. Unsere Prompt-Bibliothek ist so konzipiert, dass sie speziell auf die Funktionen und Anwendungsfälle von GitLab zugeschnitten ist.\n\n#### Schritt 2: Leistung des Basismodells\n\nSobald wir eine Prompt-Bibliothek erstellt haben, die die Produktionsaktivitäten genau widerspiegelt, geben wir diese Fragen in [verschiedene Modelle](https://about.gitlab.com/direction/ai-powered/ai_framework/ai_evaluation/foundation_models/) ein, um zu testen, wie gut sie den Bedürfnissen unserer Kund(inn)en entsprechen. Wir vergleichen jede Antwort mit unserer Grundwahrheit und reihen sie in eine Rangfolge ein, die auf einer Reihe von Metriken basiert, wie zum Beispiel: [Cosine Similarity Score](https://about.gitlab.com/direction/ai-powered/ai_framework/ai_evaluation/metrics/#similarity-scores), [Cross Similarity Score](https://about.gitlab.com/direction/ai-powered/ai_framework/ai_evaluation/metrics/#cross-similarity-score),  [LLM Judge](https://about.gitlab.com/direction/ai-powered/ai_framework/ai_evaluation/metrics/#llm-judge), und [Consensus Filtering mit LLM Judge](https://about.gitlab.com/direction/ai-powered/ai_framework/ai_evaluation/metrics/#consensus-filtering-with-llm-judge). Diese erste Iteration liefert uns einen Anhaltspunkt dafür, wie gut die einzelnen Modelle abschneiden, und hilft uns bei der Auswahl eines grundlegenden Modells für unsere Einsatzbereiche. Um uns kurz zu fassen, werden wir hier nicht ins Detail gehen, aber du kannst [hier mehr über die Metriken erfahren](https://about.gitlab.com/direction/ai-powered/ai_framework/ai_evaluation/metrics/). Es ist wichtig zu wissen, dass dieses Problem nicht gelöst ist. Die KI-Branche forscht aktiv an neuen Techniken und entwickelt sie weiter. Das Modellvalidierungsteam von GitLab behält die Branche im Auge und arbeitet ständig daran, wie wir die von GitLab Duo verwendeten LLMs prüfen und bewerten.\n\n#### Schritt 3: Funktionsentwicklung\n\nJetzt, da wir eine Grundlage für die Leistung unseres ausgewählten Modells haben, können wir mit den gewonnen Daten unsere Plattform weiterentwickeln. Prompt-Engineering ist zwar sehr populär, aber wenn man sich ausschließlich darauf konzentriert, das Verhalten eines Modells durch Prompting (oder eine andere Technik) zu verändern, ohne es zu validieren, stochert man im Dunkeln und passt sein Prompting sehr wahrscheinlich zu stark an. Man löst vielleicht ein Problem, aber verursacht ein Dutzend andere. Und es würde wahrscheinlich nie auffallen. Wenn wir eine Grundlinie für die Leistung eines Modells festlegen, können wir verfolgen, wie sich das Verhalten im Laufe der Zeit für alle notwendigen Anwendungsfälle verändert. Bei GitLab überprüfen wir die Leistung unserer GitLab Duo Funktionen während der aktiven Entwicklung täglich neu, um sicherzustellen, dass alle Änderungen die Gesamtfunktionalität verbessern.\n\n#### Schritt 4: Iterieren, iterieren, iterieren\n\nUnsere experimentellen Iterationen funktionieren wie folgt: In jedem Durchgang untersuchen wir die Ergebnisse unserer Tests im großen Maßstab, um Muster zu erkennen:\n\n- Was haben unsere schwächsten Bereiche gemeinsam?\n- Verhält sich unsere Funktion für eine bestimmte Metrik oder in einem bestimmten Anwendungsfall ungünstig?\n- Gibt es bei bestimmten Fragen immer wieder dieselben Fehler?\n\nSolche Muster tauchen nur dann auf, wenn wir in großem Maßstab testen, und nur so können wir unsere Experimente optimieren. Auf der Grundlage dieser Muster schlagen wir verschiedene Experimente oder Ansätze vor, um die Leistung in einem bestimmten Bereich und für eine bestimmte Metrik zu verbessern.\n\nTesten im großen Maßstab ist jedoch sowohl teuer als auch zeitaufwendig. Um eine schnellere und kostengünstigere Iteration zu ermöglichen, erstellen wir einen kleineren Datensatz, der als Mini-Proxy fungiert. Die begrenzte Teilmenge wird so gewichtet, dass sie genau die Frage-Antwort-Paare enthält, die wir verbessern möchten. Die erweiterte Teilmenge enthält auch eine Auswahl aller anderen Anwendungsfälle und Bewertungen, um sicherzustellen, dass sich unsere Änderungen nicht nachteilig auf die allgemeine Funktionalität auswirken. Wir nehmen also Änderungen vor und überprüfen sie gegen eine begrenzte Teilmenge der Daten. Wie sieht die neue Antwort im Vergleich zur Ausgangslage aus? Wie verhält es sich mit der Grundwahrheit?\n\nSobald wir einen Prompt gefunden haben, der sich auf den spezifischen Anwendungsfall bezieht, an dem wir gerade mit der begrenzten Teilmenge arbeiten, validieren wir diesen Prompt anhand einer erweiterten Teilmenge von Daten, um sicherzustellen, dass er sich nicht nachteilig auf andere Bereiche auswirkt. Nur wenn wir durch die Validierungsmetriken der Meinung sind, dass der neue Prompt unsere Leistung in unserem Zielbereich verbessert UND die Leistung an anderer Stelle nicht verschlechtert, setzen wir diese Änderung in der Produktionsumgebung um.\n\nDas gesamte Centralized Evaluation Framework wird dann mit dem neuen Prompt ausgeführt und wir überprüfen, ob die Leistung der gesamten Funktionalität gegenüber der Ausgangssituation vom Vortag verbessert wurde. Auf diese Weise stellt GitLab durch ständige Iterationen sicher, dass du im gesamten GitLab-Ökosystem die neueste und beste Leistung der KI-gestützten Funktionen erhältst. So können wir sicherstellen, dass wir gemeinsam immer schneller arbeiten.\n\n### GitLab Duo noch besser machen\n\nWir hoffen, dass wir dir hiermit einen Einblick geben konnten, wie wir die Funktionen von GitLab Duo verantwortungsvoll entwickeln. Dieser Prozess wurde entwickelt, um [GitLab Duo Codevorschläge](https://docs.gitlab.com/ee/user/project/repository/code_suggestions/) und [GitLab Duo Chat](https://docs.gitlab.com/ee/user/gitlab_duo_chat.html) allgemein verfügbar zu machen. Wir haben diesen Validierungsprozess auch in unseren Entwicklungsprozess integriert, wenn wir die Funktionen von GitLab Duo weiterentwickeln. Es bedeutet unzählige Versuche und Fehlschläge, und oft macht die Korrektur eines Punkts drei andere kaputt. Aber wir erhalten dabei auch datengestützte Einblicke in diese Auswirkungen und können so sicherstellen, dass GitLab Duo immer besser wird.\n\n> Starte noch heute deine [kostenlose Testversion von GitLab Duo](https://about.gitlab.com/gitlab-duo/#free-trial)!\n\n\u003Cfigure class=video_container>\n\u003Ciframe width=560 height=315 src=\"https://www.youtube-nocookie.com/embed/LifJdU3Qagw?si=A4kl6d32wPYC4168\" title=\"YouTube video player\" frameborder=0 allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" allowfullscreen=\"\">\u003C/iframe>\n\u003C/figure>",[678,907,707,9,837],{"slug":951,"featured":90,"template":682},"developing-gitlab-duo-how-we-validate-and-test-ai-models-at-scale","content:de-de:blog:developing-gitlab-duo-how-we-validate-and-test-ai-models-at-scale.yml","Developing Gitlab Duo How We Validate And Test Ai Models At Scale","de-de/blog/developing-gitlab-duo-how-we-validate-and-test-ai-models-at-scale.yml","de-de/blog/developing-gitlab-duo-how-we-validate-and-test-ai-models-at-scale",{"_path":957,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":958,"content":965,"config":973,"_id":975,"_type":13,"title":976,"_source":15,"_file":977,"_stem":978,"_extension":18},"/de-de/blog/developing-gitlab-duo-use-ai-to-remediate-security-vulnerabilities",{"ogTitle":959,"schema":960,"ogImage":961,"ogDescription":962,"ogSiteName":695,"noIndex":6,"ogType":696,"ogUrl":963,"title":959,"canonicalUrls":963,"description":964},"GitLab Duo: KI zur Behebung von Sicherheitslücken nutzen","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Die Entwicklung von GitLab Duo: KI zur Behebung von Sicherheitslücken nutzen \",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Michael Friedrich\"},{\"@type\":\"Person\",\"name\":\"Alana Bellucci\"}],\n        \"datePublished\": \"2024-07-15\",\n      }\n                  ","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098106/Blog/Hero%20Images/Blog/Hero%20Images/blog-hero-banner-1-0178-820x470-fy25_7JlF3WlEkswGQbcTe8DOTB_1750098106040.png","Dieses Tutorial zeigt, wie dir die GitLab-Duo-Funktionen zur Erläuterung und Behebung von Sicherheitslücken zusammen mit unseren anderen KI-basierten Funktionen helfen können, Sicherheitslücken schnell zu beheben.","https://about.gitlab.com/blog/developing-gitlab-duo-use-ai-to-remediate-security-vulnerabilities","Dieses Tutorial zeigt, wie dir die GitLab-Duo-Funktionen zur Erläuterung und Behebung von Sicherheitslücken zusammen mit unseren anderen KI-basierten Funktionen helfen können, Sicherheitslücken zu beheben.",{"heroImage":961,"body":966,"authors":967,"updatedDate":969,"date":970,"title":971,"tags":972,"description":962,"category":703},"Du hast gerade eine neue Stelle angetreten, und gleich an deinem ersten Tag\ngibt es einen schwerwiegenden Vorfall in der Produktion, bei dem alle\nverfügbaren Arbeitskräfte benötigt werden. Eine Reihe kritischer neuer\nSicherheitslücken erfordert sofortige Aufmerksamkeit, Analyse,\nSchadensbegrenzung und Behebung. Aber wo genau fängst du mit deiner\nUntersuchung an?\n\n\nErfahre, wie du mit den GitLab-Duo-Funktionen zur Erläuterung von Sicherheitslücken und Behebung von Sicherheitslücken zusammen mit anderen KI-basierten Funktionen innerhalb weniger Minuten mit der Behebung von Sicherheitslücken beginnen kannst. Anhand eines praktischen Beispiels erfährst du, wie du von der KI-basierten Unterstützung bei der Analyse und Erläuterung von Sicherheitslücken profitieren kannst. Zusätzliche Abhilfemaßnahmen stehen in Form von KI-generierten Codekorrekturen in MRs im Vordergrund, um Sicherheitslücken schneller zu beheben.\n\n\n> Starte [eine kostenlose Testversion von GitLab Duo](https://about.gitlab.com/gitlab-duo/#free-trial), um diese leistungsstarken Vorteile bei der Behebung von Sicherheitslücken auch in deinem Unternehmen zu nutzen.\n\n\n## So gehst du vor: Analyse\n\n\nDer erste Schritt besteht darin, die Auswirkungen und den Schweregrad der Sicherheitslücke zu analysieren. Öffne die GitLab-Benutzeroberfläche und navigiere zum [Sicherheitslückenbericht](https://docs.gitlab.com/ee/user/application_security/vulnerability_report/) im Menü `Schützen > Sicherheitslückenbericht`. Filtere die Liste der Sicherheitslücken nach `SAST` und identifiziere die kritischsten Sicherheitslücken, an denen du arbeiten musst.\n\n\n![Übersicht über Sicherheitslückenberichte](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/vulnerability_reports_overview_aHR0cHM6_1750098116056.png)\n\n\nDie Ergebnisse des SAST-Scanners werden in der Detailansicht zusammengefasst und mit dem Quellcode verknüpft. Sie enthalten Details aus öffentlich zugänglichen Sicherheitshinweisen. Für Entwickler(innen) ist es oft schwierig, direkt aus dem Sicherheitsbericht heraus mit der Analyse zu beginnen, es sei denn, sie kennen den Umfang des Angriffs, die technischen Details und die Sicherheitslücken genau.\n\n\n## Verstehen und Entschärfen mit der Erläuterung von Sicherheitslücken\n\n\nEs ist unerlässlich, dass du die Sicherheitslücke verstehst und weißt, wie du sie am besten und effizientesten beheben kannst. Die Korrekturen dürfen bestehende Funktionen nicht beeinträchtigen. Falls doch, ist eine Besprechung mit den zuständigen Betreuer(inne)n und Product Ownern mit einer Zusammenfassung und möglichen Abhilfemaßnahmen erforderlich. Code, den ein(e) ehemalige(r) Mitarbeiter(in) geschrieben hat, oder Code, für den es keine Tests gibt, kann die Planung eines Fixes noch schwieriger machen.\n\n\nDie KI-basierte Erläuterung von Sicherheitslücken bietet eine Zusammenfassung, wie ein(e) Angreifer(in) die Sicherheitslücke ausnutzen könnte, und liefert weitere Erklärungen zu den Auswirkungen und möglichen Abhilfemaßnahmen.\n\n\nDas folgende Beispiel zeigt eine OS-Command-Injection-Sicherheitslücke unter Verwendung dieses Codeschnipsels:\n\n\n```php\n\n\u003C?php \n\n\n// Read variable name from GET request\n\n$name = $_GET['name'];\n\n\n// Use the variable name to call eval and print its value \n\neval('echo $' . $name . ';');\n\n```\n\n\nDer Sicherheitslückenbericht ist nicht sehr detailliert und setzt voraus, dass du den gesamten Kontext und die Auswirkungen verstehst. Wähle oben rechts `Sicherheitslücke erläutern`, um den GitLab Duo Chat mit einem vordefinierten Prompt zu öffnen. Dieser bietet eine zusätzliche Zusammenfassung der Sicherheitslücke, eine Beschreibung, wie die Sicherheitslücke ausgenutzt werden kann, und einen Lösungsvorschlag.\n\n\n![Unsachgemäße Neutralisierung von\n\nspeziellen Elementen, die in einem Betriebssystembefehl verwendet werden\n\n(„OS Command Injection“) ](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image9_aHR0cHM6_1750098116057.png)\n\n\n### Erläuterung von Sicherheitslücken in einem Gespräch mit Kontext\n\n\nDu wirst auch eine Änderung in der Benutzeroberfläche sehen: Das vorherige Overlay der Erläuterung von Sicherheitslücken wurde durch einen GitLab-Duo-Chat-Workflow ersetzt. Manchmal benötigt eine komplexe Sicherheitslücke mehrere Abhilfemaßnahmen oder sie führt zu unklaren Quellcodepfaden.\n\n\nDu kannst zum Quellcodebaum navigieren und mit demselben Chat-Kontext fortfahren, um dir den Code erläutern zu lassen, ihn zu reparieren, zu überarbeiten und zu testen. \n\n\nProbieren wir den kompletten Workflow anhand eines Beispiels in C aus, bei dem die Sicherheitsscans einen Pufferüberlauf entdeckt haben.\n\n\n1. Öffne die Detailansicht der Sicherheitslücke und wähle oben rechts auf der Schaltfläche „Sicherheitslücke erläutern“. Dies öffnet den Chat-Prompt mit einer Zusammenfassung des Problems, potenziellen Angriffsvektoren und einem Lösungsvorschlag.\n\n\n![KI für Sicherheitslücken – Bild 4](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image11_aHR0cHM6_1750098116059.png)\n\n\n2. Überprüfe den Lösungsvorschlag und bitte Duo Chat in einem Folge-Prompt, dir alternative Lösungsmöglichkeiten anzuzeigen, indem du den folgenden Text eingibst: `Can you show an alternative fix using a different function`. Der Sinn dahinter ist, etwas über Alternativen zur Funktion `strcpy()` zu erfahren, die sicherer zu verwenden sind.\n\n\n![KI für Sicherheitslücken – Bild 3](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750098116060.png)\n\n\n3. Duo Chat bietet im folgenden Beispiel eine alternative Lösung mit `strlcpy()`. Die Funktion kopiert nur so viele Zeichen, wie in der Zielzeichenfolge erlaubt sind, und beendet die Zeichenfolge immer mit Null. Sie gibt auch die Länge der Quellzeichenfolge zurück, um festzustellen, ob die Zeichenfolge abgeschnitten wurde.\n\n\n![KI für Sicherheitslücken – Bild 5](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image10_aHR0cHM6_1750098116062.png)\n\n\n4. Klicke auf die URL der Datei `Location`, um zur Quellcodeansicht zu gelangen. Öffne Duo Chat erneut und vergewissere dich, dass der vorherige Kontext zur Erläuterung der Sicherheitslücke noch vorhanden ist. Als Nächstes möchten wir Tests hinzufügen, bevor wir mit einem Lösungsvorschlag fortfahren. So vermeiden wir, dass Funktionen kaputt gehen oder Regressionen eingeführt werden. Verwende zum Beispiel den folgenden Chat-Prompt: `Based on the vulnerability context and opened source code, how would you add tests for it?`.\n\n\n![KI für Sicherheitslücken – Bild 7](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image8_aHR0cHM6_1750098116063.png)\n\n\n5. Nachdem du Tests erstellt hast (und angenommen, sie wurden jetzt hinzugefügt), kannst du Duo Chat mit dem Prompt `Can you refactor the source code too?` in der gleichen Sitzung auch darum bitten, den Quellcode zu überarbeiten.\n\n\n![KI für Sicherheitslücken – Bild 6](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750098116063.png)\n\n\nDer Workflow zeigt dir, wie du Sicherheitslücken analysierst, verstehst, entschärfst, alternative Ansätze findest, Tests hinzufügst und sogar Refactoring durchführst. \n\n\nDu kannst diesen Weg mit Duo Chat fortsetzen und dann in die Web IDE wechseln, um den Quellcode zu ändern, nachdem du gelernt hast, wie es geht. Zu den weiteren fortlaufenden Workflows gehören das Committen von Änderungen und das Auslösen der CI/CD-Pipeline und von Sicherheitsscans für den gesamten DevSecOps-Lebenszyklus. \n\n\n## Beheben mit KI-unterstützter Behebung von Sicherheitslücken\n\n\nUm eine Sicherheitslücke zu verstehen und zu beheben, sind immer noch Entwicklerfähigkeiten notwendig, um in einem neuen Merge Request eine Lösung für das Problem zu erstellen, Pipelines auszuführen und Sicherheitsscans durchzuführen. Es kann auch erforderlich sein, die Fixes in einer Staging-Umgebung bereitzustellen und über einen längeren Zeitraum zu testen.\n\n\nDie KI kann dir dabei helfen, einen Lösungsvorschlag auf der Grundlage des bereitgestellten Kontexts der Sicherheitslücke und des Quellcodes zu generieren.\n\n\nTipp: Denke an die ärgerlichste Sicherheitslücke, die du in deiner Karriere bisher beheben musstest, und erstelle das Anwendungsbeispiel erneut für GitLab Duo. Die [Mitre CWE Top 25 der gefährlichsten Software-Sicherheitslücken](https://cwe.mitre.org/top25/archive/2023/2023_top25_list.html) bietet ebenfalls einen guten Ausgangspunkt.  \n\n\nDas folgende Beispiel implementiert [CWE-328: Use of a weak hash function (Verwendung einer schwachen Hash-Funktion)](https://cwe.mitre.org/data/definitions/328.html) unter Verwendung von `md5`. Die Sicherheitslücke wird von [SAST-Scannern](https://docs.gitlab.com/ee/user/application_security/sast/) korrekt identifiziert. \n\n\n```python\n\nimport hashlib\n\n\nclass User:\n    def __init__(self, username, password):\n        self.username = username\n        self.password = password\n\n    def set_password(self, password):\n        self.password = hashlib.md5(password.encode()).hexdigest()\n```\n\n\n![KI für Sicherheitslücken – Bild 8](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image7_aHR0cHM6_1750098116064.png)\n\n\nKlicke oben rechts auf die Schaltfläche `Mit Merge Request lösen`.  Dies öffnet einen MR, der KI verwendet, um eine Lösung vorzuschlagen. Eine mögliche Lösung für diese Sicherheitslücke könnte die Verwendung einer anderen Hash-Funktion sein.\n\n\n![KI für Sicherheitslücken – Bild 9](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750098116065.png)\n\n\nEin weiteres häufiges Beispiel für eine Sicherheitslücke ist die Nichtüberprüfung von Funktionsfehlercodes oder möglichen Exceptions. Die folgenden C-Codeschnipsel implementieren ein Beispiel für Timing-Angriffe auf Dateivorgänge mit [CWE-362](https://cwe.mitre.org/data/definitions/362.html) für die Aufrufe `fopen()` und `chmod()`. \n\n\n```c\n\n#include \u003Cstdio.h>\n\n#include \u003Cstring.h>\n\n#include \u003Csys/mman.h>\n\n#include \u003Csys/stat.h>\n\n#include \u003Cunistd.h>\n\n\nint main(int argc, char **argv) {\n\n    // File operations\n    char *fname = \"gitlab.keksi\";\n\n    FILE *fp;\n    fp = fopen(fname, \"r\");\n    fprintf(fp, \"Hello from GitLab Duo Vulnerability Resolution Challenge\");\n    fclose(fp);\n\n    // Potential chmod() timing attacks    \n\n    // Make the file world readable\n    chmod(fname, S_IRWXU|S_IRWXG|S_IRWXO);\n\n    return 0;\n}\n\n```\n\n\nDer SAST-Bericht für `chmod()` kann wie folgt aussehen: \n\n\n![KI für Sicherheitslücken – Bild 10](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image6_aHR0cHM6_1750098116065.png)\n\n\nDer vorgeschlagene Merge Request für `chmod()` beinhaltet die Fehlerbehandlung. Zusätzlich wird ein weiteres potenzielles Problem behoben, durch das Dateien öffentlich beschreibbar sind, indem die Berechtigungen von `777` auf `600` geändert werden.\n\n\n![KI für Sicherheitslücken – Bild 11](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098116/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750098116066.png)\n\n\n> Probiere diese asynchrone Übung aus: Finde, analysiere und behebe die Sicherheitslücke für die Funktion `fopen()`.\n\n\n## Mehr KI-Unterstützung von GitLab Duo erforderlich\n\n\nOft lässt sich ein Sicherheitsproblem mit einer schnellen Lösung oder einem Workaround beheben, der den Entwicklungsteams Zeit gibt, eine längerfristige Lösung zu diskutieren und zu planen. In anderen Fällen wird das Problem komplexer und erfordert die Deaktivierung von Funktions-APIs oder die Behebung von Problemen der Firewall, bis eine angemessene Lösung in die Produktion eingeführt werden kann.\n\n\nGitLab Duo bietet zusätzliche KI-basierte Funktionen, die bei der Lösung dieser Probleme helfen können. \n\n\n**Codeerläuterung:** Als Entwickler(in) oder Sicherheitsingenieur(in) ist es wichtig, dass du dich auf deine Änderungen verlassen kannst. In der IDE kannst du die [Funktion „Codeerläuterung“](https://docs.gitlab.com/ee/user/gitlab_duo_chat/examples.html#explain-code-in-the-ide) verwenden, um die von der KI vorgeschlagene Lösung für die Sicherheitslücke besser zu verstehen. So ist sichergestellt, dass du genau weißt, welche Anpassungen vorgenommen wurden und warum.\n\n\n**Grundursachenanalyse:** Wenn die Lösung deine Pipeline beschädigt, kannst du die [Grundursachenanalyse](https://about.gitlab.com/blog/developing-gitlab-duo-blending-ai-and-root-cause-analysis-to-fix-ci-cd/) verwenden. Dieses Tool hilft dir bei der Identifizierung des zugrunde liegenden Problems und erklärt es dir, damit du es effektiv angehen kannst. Nachdem du die erforderlichen Korrekturen vorgenommen hast, kannst du die Tests erneut ausführen, um eine erfolgreiche Lösung zu gewährleisten.\n\n\n**Refactoring:** Auch wenn die Sicherheitslücke behoben wurde, lohnt es sich zu überlegen, ob der Code nicht sicherer geschrieben werden kann. In der IDE kannst du GitLab Duo Chat öffnen und die [Refactoring-Aktion](https://docs.gitlab.com/ee/user/gitlab_duo_chat/examples.html#refactor-code-in-the-ide) verwenden, um alternative, sicherere Möglichkeiten zum Schreiben deines Codes zu finden. Dieser proaktive Ansatz trägt zur Aufrechterhaltung einer robusten und sicheren Codebase bei.\n\n\nMit diesen Funktionen von GitLab Duo kannst du Sicherheitslücken selbstbewusst erkennen und beheben und so sicherstellen, dass dein Code sicher und effizient bleibt.\n\n\n## Wie geht es weiter?\n\n\nWir planen, sowohl die Erläuterung von Sicherheitslücken als auch die Behebung von Sicherheitslücken „nach links“ zu verschieben, indem wir sie direkt in den MR-Prozess integrieren. Diese Integration stellt sicher, dass du Sicherheitslücken früher im Entwicklungszyklus angehen und beheben kannst, was deinen Workflow optimiert und die Codesicherheit von Anfang an erhöht.\n\n\n## Erste Schritte mit GitLab Duo\n\n\nIn unserer [Dokumentation](https://docs.gitlab.com/ee/user/gitlab_duo/turn_on_off.html) findest du Informationen dazu, wie du die Funktion für unsere GitLab-Ultimate-Kund(inn)en aktivieren kannst. Außerdem sind die GitLab-Duo-Funktionen [Erläuterung von Sicherheitslücken](https://docs.gitlab.com/ee/user/application_security/vulnerabilities/#explaining-a-vulnerability) und [Behebung von Sicherheitslücken](https://docs.gitlab.com/ee/user/application_security/vulnerabilities/#vulnerability-resolution) bald in GitLab Self-Managed und GitLab Dedicated verfügbar.\n\n\nIn [der Blog-Serie „Entwicklung von GitLab Duo“](https://about.gitlab.com/blog/developing-gitlab-duo-series/) erfährst du regelmäßig, was es Neues in GitLab Duo gibt.\n\n\n> Starte [eine kostenlose Testversion von GitLab Duo](https://about.gitlab.com/gitlab-duo/#free-trial), um diese leistungsstarken Vorteile bei der Behebung von Sicherheitslücken auch in deinem Unternehmen zu nutzen!\n",[903,968],"Alana Bellucci","2024-11-29","2024-07-15","Die Entwicklung von GitLab Duo: KI zur Behebung von Sicherheitslücken nutzen ",[678,675,677,9,705],{"slug":974,"featured":90,"template":682},"developing-gitlab-duo-use-ai-to-remediate-security-vulnerabilities","content:de-de:blog:developing-gitlab-duo-use-ai-to-remediate-security-vulnerabilities.yml","Developing Gitlab Duo Use Ai To Remediate Security Vulnerabilities","de-de/blog/developing-gitlab-duo-use-ai-to-remediate-security-vulnerabilities.yml","de-de/blog/developing-gitlab-duo-use-ai-to-remediate-security-vulnerabilities",{"_path":980,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":981,"content":988,"config":996,"_id":998,"_type":13,"title":999,"_source":15,"_file":1000,"_stem":1001,"_extension":18},"/de-de/blog/ensuring-compliance",{"title":982,"description":983,"ogTitle":982,"ogDescription":983,"noIndex":6,"ogImage":984,"ogUrl":985,"ogSiteName":695,"ogType":986,"canonicalUrls":985,"schema":987},"Mit GitLab Aufgabentrennung und Compliance sicherstellen","Nutze deine DevSecOps-Plattform, um die Compliance aufrechtzuerhalten, ohne die Entwicklungsgeschwindigkeit zu beeinträchtigen.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098232/Blog/Hero%20Images/Blog/Hero%20Images/AdobeStock_479904468%20%281%29_4lmOEVlaXP0YC3hSFmOw6i_1750098232241.jpg","https://about.gitlab.com/blog/ensuring-compliance","Artikel","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Artikel\",\n        \"headline\": \"Mit GitLab Aufgabentrennung und Compliance sicherstellen\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Beatriz Barbosa\"},{\"@type\":\"Person\",\"name\":\"Fernando Diaz\"}],\n        \"datePublished\": \"2022-04-04\",\n      }",{"title":982,"description":983,"authors":989,"heroImage":984,"date":992,"body":993,"category":675,"tags":994,"updatedDate":995},[990,991],"Beatriz Barbosa","Fernando Diaz","2022-04-04","In diesem Artikel erfährst du, wie du mit der DevSecOps-Plattform von GitLab die **Aufgabentrennung** und\n\ndie **kontinuierliche Compliance** sicherstellen kannst. Zunächst möchten wir jedoch zwei Schlüsselkonzepte klären:\n\n\n**Compliance** bedeutet, dass du die Richtlinien und Spezifikationen einhältst,\n\ndie entweder von deinem Unternehmen oder von einer Aufsichtsbehörde festgelegt wurden. Compliance trägt dazu bei, die\n\nUnternehmensethik, angemessene Benutzerrichtlinien, Sicherheitsstandards und vieles mehr für\n\ndie Sicherheit der Verbraucher(innen) aufrechtzuerhalten.\n\n\nDie Nichteinhaltung kann zu einer Reihe von Gerichts- und Anwaltskosten sowie Geldstrafen führen, daher ist es sehr wichtig, die Compliance aufrechtzuerhalten. DevSecOps-Teams müssen nicht nur die Compliance gewährleisten, sondern auch eine nachhaltige Entwicklungsgeschwindigkeit sicherstellen und die notwendige Einfachheit, Transparenz und Kontrolle bieten.\n\n\nDie **Aufgabentrennung** erfordert, dass mehrere Personen eine Aufgabe ausführen, um den Schutz vor Fehlern zu erhöhen und böswillige Aktivitäten zu verhindern. Die Aufgabentrennung stellt sicher, dass nur die Rollen, die für die Aufgabe am besten geeignet sind, diese auch ausführen können. Als Beispiel werden einige der folgenden\n\nAkteure und Akteurinnen betrachtet, die jeweils einen bestimmten Zweck erfüllen:\n\n\n- Ein(e) Entwickler(in) ist für die Entwicklung neuer Funktionen verantwortlich.\n\n-Ein(e) Beauftragte(r) für Compliance ist für die Erstellung und Durchsetzung der Nutzung einer Pipeline zuständig.\n\n- Ein(e) Anwendungssicherheitsingenieur(in) ist für die Genehmigung von Merge Requests mit Sicherheitslücken verantwortlich.\n\n\nUnter Berücksichtigung der oben genannten Rollen können wir sicherstellen, dass ein(e) Entwickler(in) eine laufende Pipeline nicht ändern kann.\n\nDiese Aufgabe kann nur von Beauftragten für Compliance durchgeführt werden, um sicherzustellen, dass nur konformer Code ohne Genehmigung gepusht werden kann.\n\n\nEin(e) Anwendungssicherheitsingenieur(in) ist dafür zuständig, Code mit Sicherheitslücken zu überprüfen und zu genehmigen, um sicherzustellen, dass eine ordnungsgemäße Risikominderung durchgeführt werden kann und in Zukunft keine Überraschungen mehr auftreten. In diesem Szenario können Entwickler(innen) Code erst dann zusammenführen, wenn die Compliance-\n\nund Sicherheitsanforderungen erfüllt sind.\n\n\n## Sicherheitsrichtlinien\n\nGitLab bietet **Sicherheitsrichtlinien**, die es Sicherheitsteams ermöglichen, die Ausführung von Sicherheitsscans gemäß einer Konfiguration zu fordern. So können Sicherheitsteams darauf vertrauen, dass die konfigurierten Scans nicht geändert oder deaktiviert wurden.\n\n\nSicherheitsrichtlinien können so festgelegt werden, dass sie bestimmte **Compliance Frameworks** erfüllen. Dies bedeutet, dass dein Projekt bestimmte Compliance-Anforderungen hat und zusätzliche Überwachung benötigt. Dieses Label kann unter **Sichern > Compliance Center > Frameworks** in deiner Hauptgruppe erstellt werden.\n\n\n![Compliance-Framework-Label (nur in englischer Sprache verfügbar)](https://about.gitlab.com/images/blogimages/compliance-04-2022/cf-step-2.png)\n\n\n**Hinweis:** Compliance-Label können nur Projekten innerhalb der Hauptgruppe zugewiesen werden, in der das Label erstellt wird.\n\n\nEs gibt drei Arten von Richtlinien (nur in englischer Sprache verfügbar): [Scan-Ausführungsrichtlinien](https://docs.gitlab.com/ee/user/application_security/policies/scan_execution_policies.html), [Merge-Request-Approvalrichtlinien](https://docs.gitlab.com/ee/user/application_security/policies/merge_request_approval_policies.html) und [Pipeline-Ausführungsrichtlinien](https://docs.gitlab.com/ee/user/application_security/policies/pipeline_execution_policies.html).\n\n\n* **Scan-Ausführungsrichtlinien:** Hier kannst du festlegen, dass Sicherheitsscans nach einem bestimmten Zeitplan oder zusammen mit der Projektpipeline ausgeführt werden.\n\n* **Merge-Request-Approvalrichtlinien:** Ergreife Maßnahmen auf der Grundlage von Scan-Ergebnissen, z. B. die Genehmigung durch das Sicherheitsteam, bevor ein Merge durchgeführt werden kann.\n\n* **Pipeline-Ausführungsrichtlinien:** Erzwinge CI/CD-Jobs für entsprechende Projekte.\n\n\nDiese Richtlinien können über den Richtlinien-Editor in wenigen einfachen Schritten konfiguriert werden.\n\n\n### Scan-Ausführung\n\n\n1. Gehe zu **Sicherheit & Compliance > Richtlinien**.\n\n\n2. Erstelle eine neue Richtlinie, indem du auf die Schaltfläche **Neue Richtlinie** klickst.\n\n\n3. Wähle **Scan-Ausführung** aus.\n\n\n4. Erstelle die Regel. Ich erstelle eine Regel, die erfordert, dass [SAST (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/ee/user/application_security/sast/) konfiguriert ist, damit eine Pipeline ausgeführt werden kann.\n\n\n```yaml\n\nname: force_sast\n\ndescription: 'require sast to run'\n\nenabled: true\n\nrules:\n\n- type: pipeline branches: - main actions:\n\n- scan: sast\n\n```\n\n\n5. Reiche die Richtlinie ein, indem du einen Merge Request erstellst und dann den Merge ausführst.\n\n\nAlle Änderungen der Scan-Ausführungsrichtlinie werden über einen Hintergrundjob angewendet, der alle 10 Minuten ausgeführt wird.\n\nWarte bis zu 10 Minuten, bis alle für dieses Projekt festgelegten Richtlinienänderungen wirksam werden.\n\n\n6. Versuche, eine Pipeline auszuführen. Sie wird nur ausgeführt, wenn SAST in der YAML definiert ist.\n\n\n**Hinweis**: Du kannst SAST auch so einstellen, dass es nach einem Timer ausgeführt wird. Weitere Informationen findest du in der [Dokumentation (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/ee/user/application_security/policies/scan-execution-policies.html) zu den\n\nScan-Ausführungsrichtlinien.\n\n\n### Merge-Request-Approval\n\n\n1. Gehe zu **Sichern > Richtlinien**.\n\n\n2. Erstelle eine neue Richtlinie, indem du auf die Schaltfläche **Neue Richtlinie** klickst.\n\n\n3. Wähle **Merge-Request-Approvalrichtlinien** aus.\n\n\n4. Definiere den Geltungsbereich der Richtlinie.\n\n\n5. Erstelle die Regel.\n\n\n![Aktualisierung der Aufgabentrennung – Bild 1 (nur in englischer Sprache verfügbar)](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098241/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750098241214.png)\n\n\n6. Füge die auszuführende Aktion hinzu.\n\n\n![Aktualisierung der Aufgabentrennung – Bild 2 (nur in englischer Sprache verfügbar)](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098241/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750098241215.png)\n\n\n**Hinweis:** Die Richtlinie wird gemäß den von dir festgelegten Regeln ausgewertet. Das bedeutet, dass eine Genehmigung erforderlich ist, wenn die Regeln ungültig sind oder nicht ausgewertet werden können. Um dies zu verhindern, kann das Feld für das Standard-Fallback-Verhalten auf `offen` geändert werden.\n\n\n![Aktualisierung der Aufgabentrennung – Bild 3 (nur in englischer Sprache verfügbar)](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098241/Blog/Content%20Images/Blog/Content%20Images/image5_aHR0cHM6_1750098241217.png)\n\n\n1. Reiche die Richtlinie ein, indem du einen Merge Request erstellst und dann den Merge ausführst.\n\n\n2. Erstelle einen separaten Merge Request mit Sicherheitslücken.\n\n\nWie du Sicherheitslücken hinzufügen kannst, erfährst du im Abschnitt „Entwickler-Workflow“ des DevSecOps-Workshops von GitLab.\n\n\n3. Überprüfe, ob die Merge-Request-Approvalrichtlinien angewendet werden, indem du den Merge Request anzeigst.\n\n\n### Pipeline-Ausführungsrichtlinie\n\n\nUm eine Pipeline-Ausführungsrichtlinie einzurichten, musst du zunächst ein Projekt erstellen, das die CI-Dateien enthält, die du ausführen möchtest. Stelle sicher, dass nur das Sicherheitsteam und/oder der bzw. die Administrator(in) Zugriff haben, um die Aufgabentrennung zu gewährleisten. Ich habe das Projekt „Compliance und Bereitstellung“ erstellt, das die YAML enthält, die ich durchsetzen möchte.\n\n\n1. Gehe zu **Sichern > Richtlinien**.\n\n\n2. Erstelle eine neue Richtlinie, indem du auf die Schaltfläche **Neue Richtlinie** klickst.\n\n\n3. Wähle **Pipeline-Ausführungsrichtlinie** aus.\n\n\n4. Definiere den Geltungsbereich der Richtlinie.\n\n\n5. Füge die auszuführende Aktion hinzu.\n\n\n![Aktualisierung der Aufgabentrennung – Bild 4 (nur in englischer Sprache verfügbar)](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098241/Blog/Content%20Images/Blog/Content%20Images/image8_aHR0cHM6_1750098241219.png)\n\n\n6. Füge Bedingungen hinzu.\n\n\n7. Reiche die Richtlinie ein, indem du einen Merge Request erstellst und dann den Merge ausführst.\n\n\n8. Versuche, eine Pipeline auszuführen. Du siehst die richtlinienspezifischen Jobs und Phasen in deiner Pipeline.\n\n\n## Auditmanagement und Compliance-Dashboard\n\n\nEin weiterer wichtiger Teil der Compliance ist das Wissen, dass sie in deinen Gruppen/Projekten tatsächlich stattfindet. GitLab verfügt über Audit-Ereignisse und Konformitätsberichte, die dich bei Audits unterstützen.\n\n\nMit **Audit Events** können GitLab-Eigentümer(innen) und -Administrator(innen) wichtige Ereignisse nachverfolgen, wie z. B. wer bestimmte Aktionen durchgeführt hat und wann sie stattgefunden haben.\n\n\n![Audit Events (nur in englischer Sprache verfügbar)](https://about.gitlab.com/images/blogimages/compliance-04-2022/project-audit-events.png)\n\n\nAudit Events zeichnen verschiedene Ereignisse pro Gruppe und pro Projekt auf, die\n\nin der Dokumentation zu [Audit Events (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/ee/administration/audit_events.html) eingesehen werden können.\n\nDu kannst über **Sicherheit & Compliance > Audit Events** auf Audit Events zugreifen.\n\nEinige Beispiele sind:\n\n\n- Benutzer(in) wurde mit seinen oder ihren Berechtigungen dem Projekt hinzugefügt\n\n- Änderung der Berechtigungen einer Benutzerin bzw. eines Benutzers, der/die einem Projekt zugewiesen ist\n\n- Projekt-CI/CD-Variable wurde hinzugefügt, entfernt oder ihr geschützter Status geändert\n\n- Benutzer(in) wurde mit seinen oder ihren Berechtigungen der Gruppe hinzugefügt\n\n- Gruppenname oder -pfad wurde geändert\n\n\nAudit Events können auch mittels Audit-Event-Streaming an einen HTTP-Endpunkt gesendet werden. In diesem [Video (nur in englischer Sprache verfügbar](https://youtu.be/zHwVF9-i7e4?t=52) erfährst du, wie\n\ndu das Streaming von Audit Events implementierst.\n\n\nDie **Einhaltung von Standards** gibt dir die Möglichkeit, die Merge-Request-Aktivität einer Gruppe anzuzeigen. Sie bietet eine allgemeine Ansicht für alle Projekte in der Gruppe.\n\n\n![Aktualisierung der Aufgabentrennung – Bild 5 (nur in englischer Sprache verfügbar)](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098241/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750098241222.png)\n\n\nDu kannst den Bericht verwenden, um:\n\n- einen Überblick über die neuesten Merge Requests für jedes Projekt zu erhalten\n\n- zu sehen, ob und von wem Merge Requests genehmigt wurden\n\n- die Autor(inn)en von Merge Requests zu sehen\n\n- das neueste CI/CD-Pipeline-Ergebnis für jeden Merge Request zu sehen\n\n\nDer Bericht zur Einhaltung von Standards kann in der Hauptgruppe aufgerufen werden, indem du zu **Sichern > Compliance Center** gehst und die Registerkarte **Einhaltung von Standards** auswählst.\n\n\n---\n\n\nVielen Dank für deine Aufmerksamkeit! Weitere Informationen zur Aufgabentrennung in GitLab findest du unter [Kontinuierliche Software-Konformität mit GitLab](/solutions/compliance/)\n",[675,838,836,9],"2024-12-16",{"slug":997,"featured":6,"template":682},"ensuring-compliance","content:de-de:blog:ensuring-compliance.yml","Ensuring Compliance","de-de/blog/ensuring-compliance.yml","de-de/blog/ensuring-compliance",{"_path":1003,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1004,"content":1010,"config":1018,"_id":1020,"_type":13,"title":1021,"_source":15,"_file":1022,"_stem":1023,"_extension":18},"/de-de/blog/from-code-to-production-a-guide-to-continuous-deployment-with-gitlab",{"ogTitle":1005,"schema":1006,"ogImage":1007,"ogDescription":1008,"ogSiteName":695,"noIndex":6,"ogType":696,"ogUrl":1009,"title":1005,"canonicalUrls":1009,"description":1008},"Leitfaden: Kontinuierliche Bereitstellung mit GitLab","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Vom Code bis zur Produktion: Ein Leitfaden für die kontinuierliche Bereitstellung mit GitLab\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Benjamin Skierlak\"},{\"@type\":\"Person\",\"name\":\"James Wormwell\"}],\n        \"datePublished\": \"2025-01-28\",\n      }","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749659478/Blog/Hero%20Images/REFERENCE_-_Use_this_page_as_a_reference_for_thumbnail_sizes.png","Erfahre, wie du mit dem Aufbau einer robusten Pipeline für die kontinuierliche Bereitstellung in GitLab beginnen kannst. In diesem Artikel findest du Schritt-für-Schritt-Anleitungen, praktische Beispiele und Best Practices.","https://about.gitlab.com/blog/from-code-to-production-a-guide-to-continuous-deployment-with-gitlab",{"heroImage":1007,"body":1011,"authors":1012,"updatedDate":1015,"date":833,"title":1016,"tags":1017,"description":1008,"category":677},"Die kontinuierliche Bereitstellung ist eine bahnbrechende Praxis, die es\nTeams ermöglicht, schneller und mit höherem Vertrauen Werte zu schaffen. Das\nEintauchen in erweiterte Bereitstellungs-Workflows – wie GitOps,\nContainer-Orchestrierung mit Kubernetes oder dynamische Umgebungen – kann\njedoch für Teams, die gerade erst anfangen, einschüchternd sein.\n\n\nGitLab setzt sich dafür ein, die Bereitstellung nahtlos und skalierbar zu gestalten. Indem wir es den Teams ermöglichen, sich auf die Grundlagen zu konzentrieren, befähigen wir sie, eine starke Basis zu schaffen, die das Wachstum komplexerer Strategien im Laufe der Zeit unterstützt. Dieser Leitfaden enthält wichtige Schritte, um mit der Implementierung der kontinuierlichen Bereitstellung mit GitLab zu beginnen und die Grundlage für deinen langfristigen Erfolg zu schaffen.\n\n\n## Inhaltsverzeichnis\n\n\n- [Beginne mit einem Workflow-Plan](#beginne-mit-einem-workflow-plan)\n  - [Artefakt-Management-Strategie](#artefakt-management-strategie)\n    - [Artefakte und Versionsstrategien](#artefakte-und-versionsstrategien)\n    - [Artefaktaufbewahrung erstellen](#artefaktaufbewahrung-erstellen)\n    - [Registrierungszugriff und Authentifizierung](#registrierungszugriff-und-authentifizierung)\n  - [Umgebungsstrategie](#umgebungsstrategie)\n  - [Bereitstellungsziele](#bereitstellungsziele)\n- [Deine CD-Pipeline implementieren](#deine-cd-pipeline-implementieren)\n  - [Ein Schritt-für-Schritt-Beispiel](#ein-schritt-für-schritt-beispiel)\n    - [Voraussetzungen](#voraussetzungen)\n  - [Best Practices](#best-practices)\n- [Skaliere deine Bereitstellungsstrategie](#skaliere-deine-bereitstellungsstrategie)\n  - [Erweiterte Sicherheitsmaßnahmen](#erweiterte-sicherheitsmaßnahmen)\n  - [Progressive Bereitstellungsstrategien](#progressive-bereitstellungsstrategien)\n  - [Überwachung und Optimierung](#überwachung-und-optimierung)\n- [Warum GitLab](#warum-gitlab)\n\n- [Noch heute starten](#noch-heute-starten)\n\n\n## Beginne mit einem Workflow-Plan\n\n\nBevor du dich mit der technischen Implementierung befasst, nimm dir Zeit, um deinen Bereitstellungs-Workflow zu planen. Der Erfolg liegt in der sorgfältigen Planung und dem methodischen Vorgehen.\n\n\n### Artefakt-Management-Strategie\n\n\nIm Zusammenhang mit der kontinuierlichen Bereitstellung sind Artefakte die Paket-Ausgaben deines Build-Prozesses, die gespeichert, als Versionen verwaltet und bereitgestellt werden müssen. Darunter fallen:\n\n\n- Container-Images für deine Anwendungen\n\n- Pakete\n\n- kompilierte Binärdateien oder ausführbare Dateien\n\n- Bibliotheken\n\n- Konfigurationsdateien\n\n- Dokumentationspakete\n\n- andere Artefakte\n\n\nJede Art von Artefakt spielt eine bestimmte Rolle in deinem Bereitstellungsprozess. Zum Beispiel könnte eine typische Webanwendung Folgendes generieren:\n\n\n- ein Container-Image für den Backend-Service\n\n- ein ZIP-Archiv mit kompilierten Frontend-Assets\n\n- SQL-Dateien für Datenbankänderungen\n\n- umweltspezifische Konfigurationsdateien\n\n\nDie effektive Verwaltung dieser Artefakte ist für erfolgreiche Bereitstellungen von entscheidender Bedeutung. Hier erfährst du, wie du das Artefakt-Management angehen kannst.\n\n\n#### Artefakte und Versionsstrategien\n\n\nEine Best Practice, um mit einer sauberen Struktur zu beginnen, besteht darin, eine klare Versionsstrategie für deine Artefakte festzulegen. Bei der Erstellung von Releases gilt:\n\n\n- Verwende eine semantische Versionsverwaltung (major.minor.patch) für Release-Tags\n  - Beispiel: `myapp:1.2.3` für ein stabiles Release\n  - Wichtige Versionsänderungen (2.0.0) für Breaking Changes\n  - Geringfügige Versionsänderungen (1.3.0) für neue Funktionen\n  - Patch-Versionsänderungen (1.2.4) für Fehlerbehebungen\n- Pflege einen „neuesten“ Tag für die neueste stabile Version\n  - Beispiel: `myapp:latest` für automatisierte Bereitstellungen\n- Beziehe Commit-SHA für präzises Versions-Tracking ein\n  - Beispiel: `myapp:1.2.3-abc123f` zum Debuggen\n- Berücksichtige Branch-basierte Tags für Entwicklungsumgebungen\n  - Beispiel: `myapp: feature-user-auth` für Funktionstests\n\n#### Artefaktaufbewahrung erstellen\n\n\nImplementiere definierte Aufbewahrungsregeln:\n\n\n- Lege explizite Ablaufzeitrahmen für temporäre Artefakte fest\n\n- Definiere, welche Artefakte dauerhaft aufbewahrt werden müssen\n\n- Konfiguriere Bereinigungsrichtlinien zur Verwaltung des Speichers\n\n\n#### Registrierungszugriff und Authentifizierung\n\n\nSchütze deine Artefakte mit den richtigen Zugangskontrollen:\n\n\n- Implementiere persönliche Zugriffstoken für den Entwicklerzugriff\n\n- Konfiguriere CI/CD-Variablen für die Pipeline-Authentifizierung\n\n- Richte ordnungsgemäße Zugangsumfänge ein\n\n\n### Umgebungsstrategie\n\n\nBetrachte deine Umgebungen frühzeitig, da sie deine gesamte Bereitstellungspipeline prägen:\n\n\n- Konfigurationen der Entwicklungs-, Staging- und Produktionsumgebung\n\n- Umgebungsspezifische Variablen und Geheimnisse\n\n- Zugangskontrollen und Schutzregeln\n\n- Ansatz zur Nachverfolgung und Überwachung der Bereitstellung\n\n\n### Bereitstellungsziele\n\n\nSei dir bewusst, wo und wie du bereitstellen wirst. Diese Entscheidungen sind wichtig und die jeweiligen Vor- und Nachteile sollten berücksichtigt werden:\n\n\n- Infrastrukturanforderungen (VMs, Container, Cloud-Services)\n\n- Netzwerkzugriff und Sicherheitskonfigurationen\n\n- Authentifizierungsmechanismen (SSH-Schlüssel, Zugriffstoken)\n\n- Überlegungen zur Ressourcenzuweisung und Skalierung\n\n\nNachdem wir unsere Strategie definiert und grundlegende Entscheidungen getroffen haben, können wir diese Pläne jetzt in eine funktionierende Pipeline umsetzen. Wir werden ein praktisches Beispiel erstellen, das diese Konzepte demonstriert, beginnend mit einer einfachen Anwendung und dem schrittweisen Hinzufügen von Bereitstellungsfunktionen.\n\n\n## Deine CD-Pipeline implementieren\n\n\n### Ein Schritt-für-Schritt-Beispiel\n\n\nSehen wir uns nun die Implementierung einer grundlegenden Pipeline für die kontinuierliche Bereitstellung für eine Webanwendung an. Wir werden eine einfache HTML-Anwendung als Beispiel verwenden, aber diese Prinzipien gelten für jede Art von Anwendung. Wir werden unsere Anwendung auch als Docker Image auf einer einfachen virtuellen Maschine bereitstellen. Somit können wir uns auf ein kuratiertes Bild mit minimalen Abhängigkeiten stützen und sicherstellen, dass keine umgebungsspezifischen Anforderungen unbeabsichtigt eingeführt werden. Wenn wir an einer virtuellen Maschine arbeiten, werden wir die nativen Integrationen von GitLab nicht nutzen, sodass wir zunächst an einem einfacheren, aber weniger skalierbaren Setup arbeiten können.\n\n\n#### Voraussetzungen\n\n\nIn diesem Beispiel zielen wir darauf ab, eine Anwendung zu containerisieren, die wir auf einer virtuellen Maschine ausführen, die auf einem Cloud-Anbieter gehostet wird. Wir werden diese Anwendung auch lokal auf unserem Computer testen. Diese Liste der Voraussetzungen wird nur für dieses Szenario benötigt.\n\n\n##### Einrichtung der virtuellen Maschine\n\n\n- Stelle eine VM in deinem bevorzugten Cloud-Provider (z. B. GCP, AWS, Azure) bereit\n\n- Konfiguriere die Netzwerkregeln, um den Zugriff auf die Ports 22, 80 und 443 zu ermöglichen\n\n- Zeichne die öffentliche IP-Adresse des Computers für die Bereitstellung auf\n\n\n##### SSH-Authentifizierung einrichten:\n\n\n- Generiere ein öffentliches/privates Schlüsselpaar für die Maschine\n\n- Gehe in GitLab zu **Einstellungen > CI/CD > Variablen**\n\n- Erstelle eine Variable mit dem Namen `GITLAB_KEY`\n\n- Wähle als Typ „Datei“ (für SSH-Authentifizierung erforderlich)\n\n- Füge den privaten Schlüssel in das Feld „Wert“ ein\n\n- Definiere eine BENUTZERVARIABLE; dies ist der Benutzer, der sich anmeldet und die Skripte auf deiner VM ausführt\n\n\n##### Bereitstellungsvariablen konfigurieren\n\n\n- Erstelle Variablen für deine Bereitstellungsziele:\n  - `STAGING_TARGET`: deine Staging-Server-IP/-Domäne\n  - `PRODUCTION_TARGET`: deine Produktionsserver-IP/-Domäne\n\n##### Lokales Entwicklungs-Setup\n\n\n- Installiere Docker auf deinem lokalen Computer, um Bereitstellungen zu testen\n\n\n##### GitLab-Container-Registry-Zugriff\n\n\n- Finde deinen Registry-Pfad:\n  - Navigiere zu **Bereitstellen > Container-Registry**\n  - Kopiere den Registry-Pfad (z. B. registry.gitlab.com/group/project)\n- Authentifizierung einrichten:\n  - Gehe zu **Einstellungen > Zugriffstoken**\n  - Erstelle ein neues Token mit Registry-Zugriff\n  - Token-Ablauf: max. 1 Jahr\n  - Speichere das Token sicher\n- Lokalen Registry-Zugriff konfigurieren:\n\n\n```\n\ndocker login registry.gitlab.com\n\n# Der Benutzername, wenn du einen PAT verwendest, ist gitlab-ci-token\n\n# Passwort: your-access-token\n\n```\n\n\n#### 1. Erstelle deine Anwendung\n\n\nBeginne mit einer grundlegenden Webanwendung. In unserem Beispiel verwenden wir eine einfache HTML-Seite:\n\n\n```\n\n\u003C!|||UNTRANSLATED_CONTENT_START|||-- index.html -->\n\n\u003Chtml>\n  \u003Chead>\n    \u003Cstyle>\n      body {\n        background-color: #171321; /* GitLab dark */\n      }\n    \u003C/style>\n  \u003C/head>\n  \u003Cbody>\n    \u003C!|||UNTRANSLATED_CONTENT_END|||-- Dein Inhalt hier -->\n  \u003C/body>\n\u003C/html>\n\n```\n\n\n#### 2. Containerisiere deine Anwendung\n\n\nErstelle ein Dockerfile, um deine Anwendung zu paketieren:\n\n\n```\n\nFROM nginx:1.26.2\n\nCOPY index.html /usr/share/nginx/html/index.html\n\n```\n\n\nDieses Dockerfile:\n\n\n- Verwendet nginx als Basis-Image für die Bereitstellung von Webinhalten\n\n- Kopiert deine HTML-Datei an die richtige Stelle in der nginx-Verzeichnisstruktur\n\n\n#### 3. Richte deine CI/CD-Pipeline ein\n\n\nErstelle eine `.gitlab-ci.yml`-Datei, um deine Pipeline-Phasen zu definieren:\n\n\n```\n\nvariables:\n  TAG_LATEST: $CI_REGISTRY_IMAGE/$CI_COMMIT_REF_NAME:latest\n  TAG_COMMIT: $CI_REGISTRY_IMAGE/$CI_COMMIT_REF_NAME:$CI_COMMIT_SHA\n\nstages:\n  - publish\n  - deploy\n```\n\n\nSehen wir uns das genauer an:\n\n\n`TAG_LATEST` besteht aus drei Teilen:\n\n\n- `$CI_REGISTRY_IMAGE` ist der Pfad zum Container-Registry deines Projekts in GitLab\n\n\nZum Beispiel: `registry.gitlab.com/your-group/your-project`\n\n\n- `$CI_COMMIT_REF_NAME` ist der Name deiner Branch oder deines Tags\n\n\nZum Beispiel, wenn du dich im Haupt-Branch befindest: `/main`, und wenn du dich in einem Feature-Branch befindest: `/feature-login`\n\n\n- `:latest` ist ein festes Suffix\n\n\nWenn du dich also im Main-Branch befindest, wird `TAG_LATEST` zu: `registry.gitlab.com/your-group/your-project/main:latest`.\n\n\n`TAG_COMMIT` ist fast identisch, aber anstelle von `:latest` verwendet es: `$CI_COMMIT_SHA`, was die Commit-Kennung ist, zum Beispiel: `:abc123def456`.\n\n\nFür denselben Commit im Haupt-Branch wird `TAG_COMMIT` zu: `registry.gitlab.com/your-group/your-project/main:abc123def456`.\n\n\nDer Grund für beides ist, dass `TAG_LATEST` dir eine einfache Möglichkeit bietet, immer die neueste Version zu erhalten, und `TAG_COMMIT` gibt dir eine bestimmte Version, zu der du bei Bedarf zurückkehren kannst.\n\n\n#### 4. Im Container-Registry veröffentlichen\n\n\nFüge den Veröffentlichungsauftrag zu deiner Pipeline hinzu:\n\n\n```\n\npublish:\n  stage: publish\n  image: docker:latest\n  services:\n    - docker:dind\n  script:\n    - docker build -t $TAG_LATEST -t $TAG_COMMIT .\n    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY\n    - docker push $TAG_LATEST\n    - docker push $TAG_COMMIT\n```\n\n\nDieser Job:\n\n\n- verwendet Docker-in-Docker, um Bilder zu entwickeln\n\n- erstellt zwei getaggte Versionen deines Bildes\n\n- authentifiziert sich bei der GitLab-Registrierung\n\n- pusht beide Versionen in das Registry \n\n\nJetzt, da unsere Bilder sicher im Registry gespeichert sind, können wir uns darauf konzentrieren, sie in unseren Zielumgebungen bereitzustellen. Beginnen wir mit lokalen Tests, um unser Setup zu validieren, bevor wir zu Produktionsbereitstellungen übergehen.\n\n\n#### 5. In deiner Umgebung bereitstellen\n\n\nVor der Bereitstellung in der Produktion kannst du einen lokalen Test durchführen. Wir haben unser Image gerade im GitLab-Repository veröffentlicht, das wir lokal abrufen werden. Wenn du dir über den genauen Pfad nicht sicher bist, navigiere zu **Bereitstellen > Container-Registry**. Du solltest ein Symbol sehen, um den Pfad deines Bildes am Ende der Zeile für das Container-Image zu kopieren, das du testen möchtest.\n\n\n```\n\ndocker login registry.gitlab.com \n\ndocker run -p 80:80 registry.gitlab.com/your-project-path/main:latest\n\n```\n\n\nAuf diese Weise solltest du über deinen Webbrowser lokal über deine lokale Host-Adresse auf deine Anwendung zugreifen können.\n\n\nDu kannst jetzt einen Bereitstellungsjob zu deiner Pipeline hinzufügen:\n\n\n```\n\ndeploy:\n  stage: deploy\n  image: alpine:latest\n  script:\n    - chmod 400 $GITLAB_KEY\n    - apk add openssh-client\n    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY\n    - ssh -i $GITLAB_KEY -o StrictHostKeyChecking=no $USER@$TARGET_SERVER \n      docker pull $TAG_COMMIT &&\n      docker rm -f myapp || true &&\n      docker run -d -p 80:80 --name myapp $TAG_COMMIT\n```\n\n\nDieser Job:\n\n\n- richtet einen SSH-Zugriff auf dein Bereitstellungsziel ein\n\n- ruft das neueste Image auf\n\n- entfernt alle vorhandenen Container\n\n- stellt die neue Version bereit\n\n\n#### 6. Bereitstellungen nachverfolgen\n\n\nAktiviere die Nachverfolgung von Bereitstellungen, indem du die Umgebungskonfiguration hinzufügst:\n\n\n```\n\ndeploy:\n  environment:\n    name: production\nurl: https://deine-anwendung-url.com\n\n```\n\n\nDadurch wird ein Umgebungsobjekt im Abschnitt **Betreiben > Umgebungen** von GitLab erstellt, das Folgendes bietet:\n\n\n- Bereitstellungsverlauf\n\n- aktueller Bereitstellungsstatus\n\n- schneller Zugriff auf deine Anwendung\n\n\nWährend eine einzelne Umgebungspipeline ein guter Ausgangspunkt ist, müssen die meisten Teams mehrere Umgebungen verwalten, um ordnungsgemäß zu testen und die Staging-Phase durchzuführen. Lass uns unsere Pipeline erweitern, um dieses realistischere Szenario zu bewältigen.\n\n\n#### 7. Mehrere Umgebungen einrichten\n\n\nFür eine robustere Pipeline, konfiguriere Staging- und Produktionsbereitstellungen:\n\n\n```\n\nstages:\n  - publish\n  - staging\n  - release\n  - version\n  - production\n\nstaging:\n  stage: staging\n  rules:\n    - if: $CI_COMMIT_BRANCH == \"main\" && $CI_COMMIT_TAG == null\n  environment:\n    name: staging\n    url: https://staging.your-app.com\n  # deployment script here\n\nproduction:\n  stage: production\n  rules:\n    - if: $CI_COMMIT_TAG\n  environment:\n    name: production\n    url: https://your-app.com\n  # deployment script here\n```\n\n\nDieses Setup:\n\n\n- stellt die Staging-Phase deines Main-Branch bereit\n\n- verwendet GitLab-Tags, um Produktionsbereitstellungen auszulösen\n\n- bietet separate Nachverfolgung für jede Umgebung\n\n\nHier und in unserem nächsten Schritt nutzen wir eine sehr nützliche GitLab-Funktion: Tags. Durch manuelles Erstellen eines Tags im Abschnitt **Code > Tags** wird das `$CI_COMMIT_TAG` erstellt, wodurch wir Jobs entsprechend auslösen können.\n\n\n#### 8. Automatisierte Versionshinweise erstellen\n\n\nWir werden die Release-Funktionen von GitLab über unsere CI/CD-Pipeline nutzen. Aktualisiere zuerst deine Phasen in `.gitlab-ci.yml`:\n\n\n```\n\nstages:\n\n\n- publish\n\n- staging\n\n- release # New stage for releases\n\n- version\n\n- production\n\n```\n\n\nAls Nächstes fügst du den Release-Job hinzu:\n\n\n```\n\nrelease_job:\n  stage: release\n  image: registry.gitlab.com/gitlab-org/release-cli:latest\n  rules:\n    - if: $CI_COMMIT_TAG                  # Only run when a tag is created\n  script:\n    - echo \"Creating release for $CI_COMMIT_TAG\"\n  release:                                # Release configuration\n    name: 'Release $CI_COMMIT_TAG'\n    description: 'Release created from $CI_COMMIT_TAG'\n    tag_name: '$CI_COMMIT_TAG'           # The tag to create\n    ref: '$CI_COMMIT_TAG'                # The tag to base release on\n```\n\n\nDu kannst dies verbessern, indem du Links zu deinen Container-Bildern hinzufügst:\n\n\n```\n\nrelease:\n  name: 'Release $CI_COMMIT_TAG'\n  description: 'Release created from $CI_COMMIT_TAG'\n  tag_name: '$CI_COMMIT_TAG'\n  ref: '$CI_COMMIT_TAG'\n  assets:\n    links:\n      - name: 'Container Image'\n        url: '$CI_REGISTRY_IMAGE/main:$CI_COMMIT_TAG'\n        link_type: 'image'\n```\n\n\nFür die automatische Erzeugung von Versionshinweisen basierend auf Commit-Nachrichten:\n\n\n```\n\nrelease:\n  name: 'Release $CI_COMMIT_TAG'\n  description: 'Release notes for version $CI_COMMIT_TAG'\n  tag_name: '$CI_COMMIT_TAG'\n  ref: '$CI_COMMIT_TAG'\n  auto_generate_release_notes: true    # Enables automatic notes\n```\n\n\nFür aussagekräftige automatisierte Versionshinweise:\n\n\n- herkömmliche Commits verwenden (feat:, fix:, etc.)\n\n- Issue-Nummern einschließen (#123)\n\n- Betreff mit leerer Zeile vom Text trennen\n\n\nWenn du benutzerdefinierte Versionshinweise mit Bereitstellungsinformationen möchtest:\n\n\n```\n\nrelease_job:\n  script:\n    - |\n      DEPLOY_TIME=$(date '+%Y-%m-%d %H:%M:%S')\n      CHANGES=$(git log $(git describe --tags --abbrev=0 @^)..@ --pretty=format:\"- %s\")\n      cat > release_notes.md \u003C\u003C EOF\n      ## Deployment Info\n      - Deployed on: $DEPLOY_TIME\n      - Environment: Production\n      - Version: $CI_COMMIT_TAG\n\n      ## Changes\n      $CHANGES\n\n      ## Artifacts\n      - Container Image: \\`$CI_REGISTRY_IMAGE/main:$CI_COMMIT_TAG\\`\n      EOF\n  release:\n    description: './release_notes.md'\n```\n\n\nNach der Konfiguration werden Releases automatisch erstellt, wenn du ein Git-Tag erstellst. Du kannst sie in GitLab unter **Bereitstellen > Releases** anzeigen.\n\n\n#### 9. Alles zusammensetzen\n\n\nSo sieht unsere finale YAML-Datei aus:\n\n\n```\n\nvariables:\n  TAG_LATEST: $CI_REGISTRY_IMAGE/$CI_COMMIT_REF_NAME:latest\n  TAG_COMMIT: $CI_REGISTRY_IMAGE/$CI_COMMIT_REF_NAME:$CI_COMMIT_SHA\n  STAGING_TARGET: $STAGING_TARGET    # Set in CI/CD Variables\n  PRODUCTION_TARGET: $PRODUCTION_TARGET  # Set in CI/CD Variables\n\nstages:\n  - publish\n  - staging\n  - release\n  - version\n  - production\n\n# Build and publish to registry\n\npublish:\n  stage: publish\n  image: docker:latest\n  services:\n    - docker:dind\n  rules:\n    - if: $CI_COMMIT_BRANCH == \"main\" && $CI_COMMIT_TAG == null\n  script:\n    - docker build -t $TAG_LATEST -t $TAG_COMMIT .\n    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY\n    - docker push $TAG_LATEST\n    - docker push $TAG_COMMIT\n\n# Deploy to staging\n\nstaging:\n  stage: staging\n  image: alpine:latest\n  rules:\n    - if: $CI_COMMIT_BRANCH == \"main\" && $CI_COMMIT_TAG == null\n  script:\n    - chmod 400 $GITLAB_KEY\n    - apk add openssh-client\n    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY\n    - ssh -i $GITLAB_KEY -o StrictHostKeyChecking=no $USER@$STAGING_TARGET \"\n        docker pull $TAG_COMMIT &&\n        docker rm -f myapp || true &&\n        docker run -d -p 80:80 --name myapp $TAG_COMMIT\"\n  environment:\n    name: staging\n    url: http://$STAGING_TARGET\n\n# Create release\n\nrelease_job:\n  stage: release\n  image: registry.gitlab.com/gitlab-org/release-cli:latest\n  rules:\n    - if: $CI_COMMIT_TAG\n  script:\n    - |\n      DEPLOY_TIME=$(date '+%Y-%m-%d %H:%M:%S')\n      CHANGES=$(git log $(git describe --tags --abbrev=0 @^)..@ --pretty=format:\"- %s\")\n      cat > release_notes.md \u003C\u003C EOF\n      ## Deployment Info\n      - Deployed on: $DEPLOY_TIME\n      - Environment: Production\n      - Version: $CI_COMMIT_TAG\n\n      ## Changes\n      $CHANGES\n\n      ## Artifacts\n       - Container Image: \\`$CI_REGISTRY_IMAGE/main:$CI_COMMIT_TAG\\`\n      EOF\n  release:\n    name: 'Release $CI_COMMIT_TAG'\n    description: './release_notes.md'\n    tag_name: '$CI_COMMIT_TAG'\n    ref: '$CI_COMMIT_TAG'\n    assets:\n      links:\n        - name: 'Container Image'\n          url: '$CI_REGISTRY_IMAGE/main:$CI_COMMIT_TAG'\n          link_type: 'image'\n\n# Version the image with release tag\n\nversion_job:\n  stage: version\n  image: docker:latest\n  services:\n    - docker:dind\n  rules:\n    - if: $CI_COMMIT_TAG\n  script:\n    - docker pull $TAG_COMMIT\n    - docker tag $TAG_COMMIT $CI_REGISTRY_IMAGE/main:$CI_COMMIT_TAG\n    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY\n    - docker push $CI_REGISTRY_IMAGE/main:$CI_COMMIT_TAG\n\n# Deploy to production\n\nproduction:\n  stage: production\n  image: alpine:latest\n  rules:\n    - if: $CI_COMMIT_TAG\n  script:\n    - chmod 400 $GITLAB_KEY\n    - apk add openssh-client\n    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY\n    - ssh -i $GITLAB_KEY -o StrictHostKeyChecking=no $USER@$PRODUCTION_TARGET \"\n        docker pull $CI_REGISTRY_IMAGE/main:$CI_COMMIT_TAG &&\n        docker rm -f myapp || true &&\n        docker run -d -p 80:80 --name myapp $CI_REGISTRY_IMAGE/main:$CI_COMMIT_TAG\"\n  environment:\n    name: production\n    url: http://$PRODUCTION_TARGET\n```\n\n\nDiese komplette Pipeline:\n\n\n- veröffentlicht Images im Registry (Main-Branch)\n\n- stellt das Staging bereit (Main-Branch)\n\n- erstellt Releases (mit Tags)\n\n- bietet die Versionsverwaltung von Images mit Release-Tags \n\n- Stellt die Produktion bereit (für Tags)\n\n\nHauptvorteile:\n\n\n- Saubere, reproduzierbare, lokale Entwicklungs- und Testumgebung\n\n- Klarer Pfad zu Produktionsumgebungen mit Struktur, um Vertrauen in die Bereitstellung aufzubauen\n\n- Muster zur Wiederherstellung nach unerwarteten Fehlern usw.\n\n- Bereit, komplexere Bereitstellungsstrategien zu skalieren/zu übernehmen\n\n\n### Best Practices\n\n\nWährend der gesamten Implementierung solltest du diese Grundsätze einhalten:\n\n\n- Dokumentiere alles, von der variablen Nutzung bis hin zu Bereitstellungsverfahren\n\n- Nutze die integrierten Funktionen von GitLab (Umgebungen, Releases, Registry)\n\n- Implementiere ordnungsgemäße Zugriffskontrollen und Sicherheitsmaßnahmen\n\n- Sorge für Ausfälle mit robusten Rollback-Verfahren vor\n\n- Halte deine Pipeline-Konfigurationen SAUBER (wiederhole dich nicht)\n\n\n## Skaliere deine Bereitstellungsstrategie\n\n\nWie geht es weiter? Hier sind einige Aspekte, die du berücksichtigen solltest, wenn deine kontinuierliche Bereitstellungsstrategie ausgereift ist.\n\n\n### Erweiterte Sicherheitsmaßnahmen\n\n\nErhöhe die Sicherheit durch:\n\n\n- Geschützte Umgebungen mit eingeschränktem Zugang\n\n- Erforderliche Genehmigungen für Produktionseinsätze\n\n- Integriertes Sicherheitsscannen\n\n- Automatisierte Schwachstellenbewertungen\n\n- Branch-Schutzregeln für einsatzbedingte Änderungen\n\n\n### Progressive Bereitstellungsstrategien\n\n\nImplementiere erweiterte Bereitstellungsstrategien:\n\n\n- Feature-Flags für kontrollierte Rollouts\n\n- Canary-Bereitstellungen zur Risikominderung\n\n- Blaugrüne Bereitstellungsstrategien\n\n- A/B-Testfähigkeiten\n\n- Dynamisches Umgebungsmanagement\n\n\n### Überwachung und Optimierung\n\n\nEtabliere robuste Überwachungspraktiken:\n\n\n- Verfolge Bereitstellungsmetriken nach\n\n- Richte eine Leistungsüberwachung ein\n\n- Konfiguriere Bereitstellungswarnungen\n\n- Richte Bereitstellungs-SLOs ein\n\n- Regelmäßige Pipeline-Optimierung\n\n\n## Warum GitLab\n\n\nDurch die kontinuierlichen Bereitstellungsfunktionen ist GitLab eine herausragende Wahl für moderne Bereitstellungsworkflows. Die Plattform zeichnet sich dadurch aus, dass sie den Weg vom Code bis zur Produktion optimiert und eine integrierte Container-Registrierung, ein Umgebungsmanagement und eine Nachverfolgung der Bereitstellung innerhalb einer einzigen Benutzeroberfläche bietet. Die umgebungsspezifischen Variablen von GitLab, die Approval-Gates für die Bereitstellung und die Rollback-Funktionen bieten die Sicherheit und Kontrolle, die für Produktionsbereitstellungen erforderlich sind, während Funktionen wie Review-Apps und Feature-Flags progressive Bereitstellungsansätze ermöglichen. Als Teil der kompletten DevSecOps-Plattform von GitLab lassen sich diese CD-Funktionen nahtlos in deinen gesamten Software-Lebenszyklus integrieren.\n\n\n## Noch heute starten\n\n\nDer Weg zur kontinuierlichen Bereitstellung ist eine Evolution, keine Revolution. Beginne mit den Grundlagen, baue eine solide Grundlage auf und integriere nach und nach erweiterte Funktionen, wenn die Anforderungen deines Teams wachsen. GitLab bietet die Tools und die Flexibilität, um dich in jeder Phase dieser Reise zu unterstützen, von deiner ersten automatisierten Bereitstellung bis hin zu komplexen Bereitstellungspipelines für mehrere Umgebungen.\n\n\n> Melde dich für eine [kostenlose Testversion von GitLab Ultimate](https://about.gitlab.com/free-trial/devsecops/) an, um noch heute mit der kontinuierlichen Bereitstellung zu beginnen.\n",[1013,1014],"Benjamin Skierlak","James Wormwell","2025-05-14","Vom Code bis zur Produktion: Ein Leitfaden für die kontinuierliche Bereitstellung mit GitLab",[836,108,9,677,705],{"slug":1019,"featured":6,"template":682},"from-code-to-production-a-guide-to-continuous-deployment-with-gitlab","content:de-de:blog:from-code-to-production-a-guide-to-continuous-deployment-with-gitlab.yml","From Code To Production A Guide To Continuous Deployment With Gitlab","de-de/blog/from-code-to-production-a-guide-to-continuous-deployment-with-gitlab.yml","de-de/blog/from-code-to-production-a-guide-to-continuous-deployment-with-gitlab",{"_path":1025,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1026,"content":1032,"config":1039,"_id":1041,"_type":13,"title":1042,"_source":15,"_file":1043,"_stem":1044,"_extension":18},"/de-de/blog/getting-started-with-gitlab-how-to-manage-users",{"ogTitle":1027,"schema":1028,"ogImage":1029,"ogDescription":1030,"ogSiteName":695,"noIndex":6,"ogType":696,"ogUrl":1031,"title":1027,"canonicalUrls":1031,"description":1030},"GitLab Benutzerverwaltung: Erste Schritte einfach erklärt","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Erste Schritte mit GitLab: Benutzerverwaltung\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Abubakar Siddiq Ango\"}],\n        \"datePublished\": \"2025-01-14\",\n      }","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097273/Blog/Hero%20Images/Blog/Hero%20Images/blog-getting-started-with-gitlab-banner-0497-option4-fy25_cFwd8DYFLekdnOLmbbChp_1750097273817.png","Wir zeigen dir, wie du die GitLab Benutzerverwaltung nutzt. ✓ Projektmitglieder ✓ Gruppen ✓ Rollen ✓ Berechtigungen ➤ Jetzt mit GitLab loslegen!","https://about.gitlab.com/blog/getting-started-with-gitlab-how-to-manage-users",{"heroImage":1029,"body":1033,"authors":1034,"updatedDate":1015,"date":708,"title":1036,"tags":1037,"description":1038,"category":677},"*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.*\n\nDie Gewährleistung einer sicheren, konformen und kollaborativen Umgebung beginnt mit der grundlegendsten Aufgabe: der Verwaltung von Benutzer(inne)n. In diesem Tutorial zeigen wir dir, wie du Projektmitglieder einrichtest, Rollen und Berechtigungen zuweist und Gruppen und Untergruppen erstellst.\n\nHinweis: Um diesem Lernprogramm folgen zu können, solltest du ein GitLab-Konto besitzen, entweder über GitLab.com oder die Self-Managed-Instanz deines Unternehmens. Wenn du Hilfe brauchst, besuche unseren Grundlagenbereich der [GitLab University](https://university.gitlab.com/). (Die Kurse sind aktuell nur in englischer Sprache verfügbar.)\n\nLos geht’s.\n\n## Inhaltsverzeichnis\n\n- [Projektmitglieder](#projektmitglieder)\n- [Gruppenmitgliedschaften](#gruppenmitgliedschaften)\n  - [Untergruppen erstellen](#untergruppen-erstellen)\n  - [Gruppen verwalten](#gruppen-verwalten)\n- [Mehr erfahren](#mehr-erfahren)\n\nWenn du GitLab-Benutzer(innen) anlegst, haben sie nur Zugriff auf [ihre privaten und öffentlichen Projekte sowie auf Projekte mit interner Sichtbarkeit](https://docs.gitlab.com/ee/user/public_access.html) (nur in englischer Sprache verfügbar). Für dieses Tutorial ist dein Projekt streng geheim und nur eingeladene Mitglieder sollten darauf Zugriff haben – mit unterschiedlichen Berechtigungen. Um dies sicherzustellen, kannst du Benutzer(innen) als [Mitglieder des Projekts](https://docs.gitlab.com/ee/user/project/members/) (nur in englischer Sprache verfügbar) einladen.\n\n## Projektmitglieder\n\n![Anzeige der Projektmitglieder](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097278/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097278487.png)\n\nGitLab-Benutzer(innen) können zu einem Projekt eingeladen werden und [bekommen eine Rolle zugewiesen](https://docs.gitlab.com/ee/user/permissions.html) (nur in englischer Sprache verfügbar), die bestimmt, was sie in dem Projekt tun können. Projekteigentümer(innen) können andere Benutzer(innen) als Betreuer(innen) mit Verwaltungsaufgaben betrauen. Diese können fast dieselben Aufgaben ausführen wie Projekteigentümer(innen) , abgesehen von Änderungen am Projekt, wie z. B. das Löschen, Archivieren oder Übertragen eines Projekts.\n\n![Bildschirm zum Einladen von Mitgliedern](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097278/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097278487.png)\n\n[Betreuer(innen)](https://docs.gitlab.com/ee/user/permissions.html#roles) (nur in englischer Sprache verfügbar) des Projekts können andere Mitglieder als Entwickler(innen) einladen. Diese haben dann Zugriff auf alle Funktionen zum Entwickeln, Erstellen und Bereitstellen von Software. Benutzer(innen), die keine Entwickler(innen) sind, aber Zugang zum Projektmanagement benötigen, können in einer [Planungsrolle](https://about.gitlab.com/de-de/blog/introducing-gitlabs-new-planner-role-for-agile-planning-teams/), als Reporter(innen) oder Gäste mit unterschiedlichen Berechtigungsstufen in das Projekt eingeladen werden. Mit diesen Rollen lässt sich mit [geschützten Branches](https://docs.gitlab.com/ee/user/project/repository/branches/protected.html) (nur in englischer Sprache verfügbar) auch festlegen, wer Änderungen an bestimmten Branches vornehmen darf.\n\nWenn du mit Auftragnehmer(innen) zusammenarbeitest oder deine Nutzung erfordert, dass die Benutzerberechtigungen verfallen können, kannst du ein Ablaufdatum festlegen, nach dem Benutzer(innen) den Zugriff auf das Projekt verlieren. Projektmitglieder können basierend auf der [Art ihrer Mitgliedschaft](https://docs.gitlab.com/ee/user/project/members/#membership-types) (nur in englischer Sprache verfügbar) auch als direkte oder indirekte Mitglieder identifiziert werden. Direkte Mitglieder werden direkt in das Projekt eingeladen, während indirekte Mitglieder oft aus einer [GitLab-Gruppe](https://docs.gitlab.com/ee/user/group/) (nur in englischer Sprache verfügbar), zu der ein Projekt gehört, übernommen werden.\n\nSehen wir uns nun die Gruppenmitgliedschaften an.\n\n## Gruppenmitgliedschaften\n\nGruppen in GitLab können eine oberste Ebene sein, die im Stammverzeichnis einer GitLab-Instanz erstellt wird, wie z. B. [gitlab.com/gitlab-org](http://gitlab.com/gitlab-org). Dies ist eine übergeordnete Gruppe, die zum Organisieren anderer Untergruppen wie [gitlab.com/gitlab-org/charts](http://gitlab.com/gitlab-org/charts) verwendet wird. Gruppen sind auch dann nützlich, wenn du nur ein Projekt hast.\n\nGruppen können für verschiedene Zwecke verwendet werden:\n\n- Organisation ähnlicher oder verwandter Projekte  \n- Organisation der Benutzer(innen) in Gruppen zur besseren Teamkoordination\n\nWenn du Gruppen zur Organisation von Benutzer(inne)n verwendest, kannst du Teams in Gruppen organisieren und [eine Gruppe zu einem Projekt einladen](https://docs.gitlab.com/ee/user/project/members/sharing_projects_groups.html) (nur in englischer Sprache verfügbar) und allen Mitgliedern des Teams die gleiche Rolle geben. Du kannst eine `dev`-Gruppe für die Entwickler(innen) des Teams haben, eine `pm`-Gruppe für die Projektmanager(innen) und eine `leads`-Gruppe für die Teamleiter(innen). Wenn du die Gruppen einlädst, kann `dev` die Rolle Entwickler(in), `pm` die Rolle Planer(in) und `leads` die Rolle Betreuer(in) zugewiesen werden.\n\n!]Bildschirm zum Einladen von Gruppen](https://res.cloudinary.com/about-gitlab-com/image/upload/v1752175686/Blog/ce7ulc2obua9zaz2zjsb.png)\n\nIn jeder Gruppe können Mitglieder hinzugefügt oder entfernt werden, ohne dass die Projektberechtigungen aktualisiert werden müssen. Das ist besonders nützlich, wenn dein Team auf mehrere Projekte angewachsen ist. Es gibt jedoch [bewährte Methoden](https://docs.gitlab.com/ee/user/project/members/sharing_projects_groups.html#setting-up-a-group-for-collaboration) (nur in englischer Sprache verfügbar) für die Verwendung von Gruppen für die Zusammenarbeit.\n\nEin weiterer hilfreicher Aspekt bei der Organisation von Benutzer(inne)n in Gruppen ist, dass du die gesamte Gruppe in Tickets, Merge Requests oder Kommentaren [erwähnen](https://docs.gitlab.com/ee/user/discussions/#mentions) (nur in englischer Sprache verfügbar) kannst. Das vereinfacht den Informationsaustausch mit dem gesamten Team.\n\n### Untergruppen erstellen\n\n[Untergruppen](https://docs.gitlab.com/ee/user/group/subgroups/) (nur in englischer Sprache verfügbar) können verwendet werden, um die Benutzer(innen) in einer Gruppe weiter zu unterteilen. Du kannst bis zu 20 ineinander verschachtelte Untergruppen hinzufügen. Benutzer(innen) in einer Untergruppe erben die Rechte aus der übergeordneten Gruppe. Wenn du jemandem in einer Untergruppe eine höhere Rolle zuweisen möchtest, als er/sie geerbt hat, musst du ihn/sie [in die Untergruppe mit der neuen höheren Rolle einladen](https://docs.gitlab.com/ee/user/group/subgroups/#override-ancestor-group-membership) (nur in englischer Sprache verfügbar). Hinweis: Du kannst ihm/ihr in der Untergruppe keine untergeordnete Rolle zuweisen.\n\n### Gruppen verwalten\n\nGruppeneigentümer(innen) haben mehrere Verwaltungsoptionen, um festzulegen, wie Benutzer(innen) in einer Gruppe funktionieren. Du kannst z. B. festlegen, wie eine Person den Zugang zu einer Gruppe anfordert, [Gruppenerwähnungen](https://docs.gitlab.com/ee/user/group/manage.html#disable-group-mentions) aktivieren/deaktivieren, den [Zugang einschränken](https://docs.gitlab.com/ee/user/group/manage.html#turn-on-restricted-access) oder [Benutzer(innen) moderieren](https://docs.gitlab.com/ee/user/group/moderate_users.html), um nur einige Optionen zu nennen. Eine interessante neue Funktion, die sich zum Zeitpunkt der Veröffentlichung dieses Artikels noch in der Entwicklung befindet, ist die [automatische Löschung von ruhenden Benutzer(innen)](https://docs.gitlab.com/ee/user/group/moderate_users.html#automatically-remove-dormant-members) nach einem Minimum von 90 Tagen und einem Maximum von fünf Jahren. Dies wird dazu beitragen, die Gruppen übersichtlich zu halten und die Freigabe von Lizenzplätzen besser zu verwalten. (Alle verlinkten Artikel in diesem Absatz sind nur in englischer Sprache verfügbar.)\n\n## Mehr erfahren\n\nDas Verwalten von Benutzer(inne)n in GitLab hängt von deinem Anwendungsfall ab. Wenn dein Unternehmen größer ist und fortgeschrittene Workflows und Benutzerverwaltung benötigt, bietet GitLab fortschrittlichere Möglichkeiten zur Verwaltung von [Unternehmensbenutzern](https://docs.gitlab.com/ee/user/enterprise_user/index.html) (nur in englischer Sprache verfügbar). Du kannst auch weitere Optionen zum [Verwalten deines Unternehmens](https://docs.gitlab.com/ee/topics/set_up_organization.html) (nur in englischer Sprache verfügbar) erkunden. Mit [GitLab Ultimate](https://about.gitlab.com/de-de/pricing/ultimate/) erhältst du mehr Granularität und weitere Compliance-Funktionen.\n\n> #### Möchtest du dein Lernen auf ein neues Niveau heben? [Registriere dich für die englischsprachigen Kurse der GitLab University](https://university.gitlab.com/). Du kannst auch sofort loslegen mit [einer kostenlosen Testversion von GitLab Ultimate](https://gitlab.com/-/trials/new?glm_content=default-saas-trial&glm_source=about.gitlab.com%2F).",[1035],"Abubakar Siddiq Ango","Benutzerverwaltung mit GitLab: Erste Schritte",[707,9,705,750,677],"Erfahre, wie du Benutzer(innen) mithilfe von Gruppen, Rollen und Berechtigungen verwalten kannst. Erkunde die Einrichtung einer sicheren Zusammenarbeit mit dem richtigen Projektzugang.",{"slug":1040,"featured":90,"template":682},"getting-started-with-gitlab-how-to-manage-users","content:de-de:blog:getting-started-with-gitlab-how-to-manage-users.yml","Getting Started With Gitlab How To Manage Users","de-de/blog/getting-started-with-gitlab-how-to-manage-users.yml","de-de/blog/getting-started-with-gitlab-how-to-manage-users",{"_path":1046,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1047,"content":1053,"config":1060,"_id":1062,"_type":13,"title":1063,"_source":15,"_file":1064,"_stem":1065,"_extension":18},"/de-de/blog/getting-started-with-gitlab-working-with-ci-cd-variables",{"title":1048,"description":1049,"ogTitle":1048,"ogDescription":1049,"noIndex":6,"ogImage":1050,"ogUrl":1051,"ogSiteName":695,"ogType":696,"canonicalUrls":1051,"schema":1052},"Erste Schritte mit GitLab: Arbeiten mit CI/CD-Variablen","Erfahre, was CI/CD-Variablen sind, warum sie in DevSecOps wichtig sind und wie du sie am besten einsetzt.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749659525/Blog/Hero%20Images/blog-getting-started-with-gitlab-banner-0497-option4-fy25.png","https://about.gitlab.com/blog/getting-started-with-gitlab-working-with-ci-cd-variables","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Erste Schritte mit GitLab: Arbeiten mit CI/CD-Variablen\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"GitLab Team\"}],\n        \"datePublished\": \"2025-05-27\",\n      }",{"title":1048,"description":1049,"authors":1054,"heroImage":1050,"date":1056,"body":1057,"category":677,"tags":1058,"updatedDate":1059},[1055],"GitLab Team","2025-05-27","*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.* \n\nIn einem früheren Artikel haben wir uns mit [GitLab CI/CD](https://about.gitlab.com/de-de/blog/getting-started-with-gitlab-understanding-ci-cd/) beschäftigt. Jetzt tauchen wir tiefer in die Welt der **CI/CD-Variablen** ein und erschließen ihr volles Potenzial.\n\n## Inhaltsverzeichnis\n\n- [Was sind CI/CD-Variablen?](#was-sind-cicd-variablen%3F)\n- [Warum sind CI/CD-Variablen wichtig?](#warum-sind-cicd-variablen-wichtig%3F)\n- [Geltungsbereiche von CI/CD-Variablen: Projekt, Gruppe und Instanz](#geltungsbereiche-von-cicd-variablen-projekt-gruppe-und-instanz)\n- [Definieren von CI/CD-Variablen](#definieren-von-cicd-variablen)\n- [Verwenden von CI/CD-Variablen](#verwenden-von-cicd-variablen)\n- [Vordefinierte CI/CD-Variablen](#vordefinierte-cicd-variablen)\n- [Bewährte Methoden](#bewährte-methoden)\n- [Entdecke die Leistungsfähigkeit von Variablen](#entdecke-die-leistungsfähigkeit-von-variablen)\n- [Reihe „Erste Schritte mit GitLab\"](#reihe-„erste-schritte-mit-gitlab“)\n\n### Was sind CI/CD-Variablen?\n\nCI/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 `.gitlab-ci.yml`-Datei verwenden kannst, um deine Pipelines anzupassen, vertrauliche Informationen sicher zu speichern und deine CI/CD-Konfiguration besser zu pflegen.\n\n### Warum sind CI/CD-Variablen wichtig?\n\nCI/CD-Variablen bieten zahlreiche Vorteile:\n\n* **Flexibilität** – Du kannst deine Pipelines leicht an verschiedene Umgebungen, Konfigurationen oder Bereitstellungsziele anpassen, ohne dein zentrales CI/CD-Skript zu ändern. \n* **Sicherheit** – Speichere vertrauliche Informationen wie API-Schlüssel, Passwörter und Token sicher und verhindere so, dass sie in deinem Code offengelegt werden.  \n* **Wartbarkeit** – Verwalte deine CI/CD-Konfiguration sauber und übersichtlich, indem du Werte in Variablen zentralisierst, was Aktualisierungen und Änderungen erleichtert. \n* **Wiederverwendbarkeit** – Definiere Variablen einmal und verwende sie in mehreren Projekten wieder, um die Konsistenz zu fördern und doppelte Arbeit zu vermeiden.\n\n### Geltungsbereiche von CI/CD-Variablen: Projekt, Gruppe und Instanz\n\nMit GitLab kannst du CI/CD-Variablen mit unterschiedlichen Geltungsbereichen definieren und so ihre Sichtbarkeit und Zugänglichkeit steuern:\n\n* **Variablen auf Projektebene** – Diese Variablen sind spezifisch für ein einzelnes Projekt und eignen sich ideal zum Speichern von projektspezifischen Einstellungen, wie zum Beispiel:\n  * Bereitstellungs-URLs: Definiere unterschiedliche URLs für Staging- und Produktivumgebungen. \n  * Datenbank-Zugangsdaten: Speichere Details zur Datenbankverbindung für Tests oder die Bereitstellung.  \n  * Feature-Flags: Aktiviere oder deaktiviere Funktionen in verschiedenen Phasen deiner Pipeline.  \n  * 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 `DPROD_DEPLOY_URL` und dem Wert `https://mywebapp.com`.  \n* **Variablen auf Gruppenebene** – 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.:\n\n  * 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.  \n  * Globale Konfigurationseinstellungen: Lege gemeinsame Konfigurationsparameter fest, die für alle Projekte in der Gruppe gelten.  \n  * 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 `DOCKER_HUB_API_KEY` und dem entsprechenden API-Schlüsselwert.  \n* **Variablen auf Instanzebene** – 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.:\n\n  * Standard-Token für die Registrierung von Runnern: Lege ein Standard-Token für die Registrierung neuer [Runner (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/runner/) fest.  \n  * Lizenzinformationen: Hier kannst du Lizenzschlüssel für GitLab-Funktionen oder Tools von Drittanbietern speichern.  \n  * Globale Umgebungseinstellungen: Lege Umgebungsvariablen fest, die für alle Projekte verfügbar sein sollen.  \n  * 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 `DEFAULT_DOCKER_IMAGE` und dem Wert `ubuntu:latest`.\n\n### Definieren von CI/CD-Variablen\n\nSo definierst du eine CI/CD-Variable:\n\n1. Klicke auf die Schaltflächen **Einstellungen > CI/CD** für dein Projekt, deine Gruppe oder deine Instanz.  \n2. Gehe zum Abschnitt **Variablen**.  \n3. Klicke auf **Variable hinzufügen**.  \n4. Gib den **Schlüssel** (z. B. `API_KEY`) und den **Wert** ein.  \n5. Aktiviere optional das Kontrollkästchen **Variable schützen**, 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.  \n6. Aktiviere optional das Kontrollkästchen **Variable maskieren**, um den Wert der Variable in den Job-Protokollen auszublenden und eine versehentliche Offenlegung zu verhindern.  \n7. Klicke auf **Variable speichern**.\n\n### Verwenden von CI/CD-Variablen\n\nUm eine CI/CD-Variable in deiner `.gitlab-ci.yml`-Datei zu verwenden, stellst du dem Variablennamen einfach `$` voran:\n\n```yaml\ndeploy_job:\n  script:\n    - echo \"Deploying to production...\"\n    - curl -H \"Authorization: Bearer $API_KEY\" https://api.example.com/deploy\n```\n\n### Vordefinierte CI/CD-Variablen\n\nGitLab stellt [vordefinierte CI/CD-Variablen (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/ci/variables/predefined_variables/) bereit, die du in deinen Pipelines verwenden kannst. Diese Variablen liefern Informationen über die aktuelle Pipeline, den Job, das Projekt und mehr.\n\nEinige häufig verwendete vordefinierte Variablen sind:\n\n* `$CI_COMMIT_SHA`: Der Commit-SHA der aktuellen Pipeline.  \n* `$CI_PROJECT_DIR`: Das Verzeichnis, in dem das Projekt geklont wird.  \n* `$CI_PIPELINE_ID`: Die ID der aktuellen Pipeline.  \n*`$CI_ENVIRONMENT_NAME`: Der Name der Umgebung, in der bereitgestellt wird (falls zutreffend).\n\n### Bewährte Methoden\n\n* Verwalte vertrauliche Variablen sicher: Verwende geschützte und maskierte Variablen für API-Schlüssel, Passwörter und andere vertrauliche Informationen. \n* Vermeide das Hardcoding von Werten: Verwende Variablen zum Speichern von Konfigurationswerten, um deine Pipelines flexibler und wartbarer zu machen.  \n* Organisiere deine Variablen: Verwende aussagekräftige Namen und gruppiere verwandte Variablen, um sie besser zu organisieren.  \n* Verwende den richtigen Geltungsbereich: Wähle den richtigen Geltungsbereich (Projekt, Gruppe oder Instanz) für deine Variablen aus, je nach Verwendungszweck und Sichtbarkeit.\n\n### Entdecke die Leistungsfähigkeit von Variablen\n\nCI/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.\n\nWir 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.\n\n> Lege jetzt los mit CI/CD-Variablen mit einer [kostenlosen Testversion von GitLab Ultimate mit Duo Enterprise](https://about.gitlab.com/de-de/free-trial/).\n\n## Reihe „Erste Schritte mit GitLab“\nLies weitere Artikel in unserer Serie „Erste Schritte mit GitLab“:\n\n- [Benutzerverwaltung](https://about.gitlab.com/de-de/blog/getting-started-with-gitlab-how-to-manage-users/)\n- [Projekte in GitLab importieren (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/getting-started-with-gitlab-how-to-import-your-projects-to-gitlab/)  \n- [Projektmanagement](https://about.gitlab.com/de-de/blog/getting-started-with-gitlab-mastering-project-management/)\n- [Automatisiere Agile-Workflows mit dem gem gitlab-triage](https://about.gitlab.com/de-de/blog/automating-agile-workflows-with-the-gitlab-triage-gem/)\n- [Grundlegendes zu CI/CD](https://about.gitlab.com/de-de/blog/getting-started-with-gitlab-understanding-ci-cd/)\n",[677,705,838,836,108,9],"2025-06-10",{"slug":1061,"featured":90,"template":682},"getting-started-with-gitlab-working-with-ci-cd-variables","content:de-de:blog:getting-started-with-gitlab-working-with-ci-cd-variables.yml","Getting Started With Gitlab Working With Ci Cd Variables","de-de/blog/getting-started-with-gitlab-working-with-ci-cd-variables.yml","de-de/blog/getting-started-with-gitlab-working-with-ci-cd-variables",{"_path":1067,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1068,"content":1072,"config":1080,"_id":1082,"_type":13,"title":1083,"_source":15,"_file":1084,"_stem":1085,"_extension":18},"/de-de/blog/gitlab-13-expanding-ai-orchestration-in-software-engineering",{"config":1069,"title":1070,"description":1071},{"noIndex":6},"GitLab 18.3: KI-Orchestrierung revolutioniert die Softwareentwicklung","So wird die Zusammenarbeit zwischen Mensch und KI durch verbesserte Flows, Enterprise Governance und nahtlose Tool-Integration transformiert.",{"title":1070,"description":1073,"authors":1074,"heroImage":1076,"date":1077,"body":1078,"category":703,"tags":1079},"So transformierst du das Zusammenspiel von Mensch und KI durch verbesserte Flows, Enterprise Governance und nahtlose Tool-Integration.",[1075],"Bill Staples","https://res.cloudinary.com/about-gitlab-com/image/upload/v1755711502/wuuadis1pza3zehqohcc.png","2025-08-21","GitLab ist heute eine umfassende DevSecOps-Plattform, die alle Phasen des Software-Lebenszyklus vereint. Auf dieser Grundlage entwickeln wir uns zur weltweit ersten KI-nativen Plattform für Software Engineering. Bei GitLab sind wir überzeugt: Die Zukunft der Softwareentwicklung liegt im reibungslosen Zusammenspiel von Mensch und KI. Wir bringen die besten KI-Funktionen zu allen GitLab-Nutzerinnen und -Nutzern.\n\nDiese Transformation erfolgt auf drei unterschiedlichen Ebenen, die weit über das hinausgehen, was andere KI-Entwicklungstools bieten:\n\n![KI-native Transformationsfolie, die das Folgende visualisiert](https://res.cloudinary.com/about-gitlab-com/image/upload/v1755762266/iwuugge3cxweiyvi0yjk.png)\n\n**Erstens sind wir ein System of Record.** Die einheitliche Datenplattform speichert die wertvollsten digitalen Assets. Dazu gehören Quellcode und geistiges Eigentum sowie eine Fülle unstrukturierter Daten, die Projektpläne, Bug-Backlogs, CI/CD-Konfigurationen, Deployment-Historien, Sicherheitsberichte und Compliance-Daten umfassen. Dies schafft einen Datenschatz an Kontextinformationen, der sicher in der GitLab-Umgebung verbleibt und für generische Agenten oder große Sprachmodelle unzugänglich ist.\n\n**Zweitens fungieren wir als Software-Control-Plane.** Wir orchestrieren die kritischsten Geschäftsprozesse über Git-Repositories, REST-APIs und Webhook-basierte Schnittstellen, die die End-to-End-Software-Lieferung antreiben. Viele Kunden betrachten dies als Tier-0-Abhängigkeit, auf die sich ihre geschäftskritischen Prozesse täglich verlassen.\n\n**Drittens bieten wir eine leistungsstarke Benutzererfahrung.** Wir liefern eine integrierte Oberfläche, die den kostspieligen Kontextwechsel eliminiert, der die meisten Entwicklungsteams verlangsamt. Mit vollständiger Lifecycle-Transparenz und Kollaborationstools in einer Plattform verlassen sich über 50 Millionen registrierte Nutzende und die riesige Community auf GitLab, um ihre Arbeit zu erledigen. Diese Expertise positioniert GitLab einzigartig, um eine intuitive Mensch-zu-KI-Zusammenarbeit zu ermöglichen, die die Teamproduktivität steigert und gleichzeitig die bewährten Workflows bewahrt.\n\n**Erweiterung der Plattform mit nativ integrierter KI auf allen Ebenen**\n\nDie [GitLab Duo Agent Platform](https://about.gitlab.com/de-de/gitlab-duo/agent-platform/) integriert und erweitert alle drei dieser Ebenen. Sie ist auf Erweiterbarkeit und Interoperabilität ausgelegt und ermöglicht es Kunden und Partnern, Lösungen zu entwickeln, die noch mehr Wert schaffen. Der offene Plattformansatz betont die nahtlose Konnektivität mit externen KI-Tools und -Systemen, während gleichzeitig eine tiefe Integration in den bestehenden Stack auf allen drei Ebenen gewährleistet wird.\n\n* Erstens erweitern wir die einheitliche Datenplattform um einen **Knowledge Graph**, der Code mit allen anderen unstrukturierten Daten indiziert und verknüpft, speziell optimiert für den agentischen Zugriff. KI lebt von Kontext, und wir glauben, dass dies nicht nur die Schlussfolgerungen und Inferenzen von Agenten beschleunigt, sondern auch kostengünstigere und qualitativ hochwertigere agentische Ergebnisse liefert.\n* Zweitens fügen wir der bestehenden Control Plane eine wichtige **Orchestration Layer** in drei verschiedenen Teilen hinzu: Agenten und Flows können sich als Abonnenten für GitLab SDLC-Events registrieren, wir bauen eine neue Orchestrierungs-Engine, die speziell entwickelte Multi-Agenten-Flows ermöglicht, und wir stellen GitLab-Tools, Agenten und Flows über MCP und Standardprotokolle für beispiellose Interoperabilität zur Verfügung.\n* Schließlich erweitern wir die **GitLab-Erfahrung**, um erstklassige Agenten und Agenten-Flows über den gesamten Software-Entwicklungslebenszyklus bereitzustellen. Sie können asynchrone Aufgaben an Agenten zuweisen, sie in Kommentaren mit @ erwähnen und benutzerdefinierte Agenten mit spezifischem Kontext für Ihre Workflows erstellen – aber noch wichtiger: GitLab liefert native Agenten für jede Entwicklungsphase und erschließt gleichzeitig ein reiches Ökosystem von Drittanbieter-Agenten. Dies schafft eine echte Mensch-zu-KI-Zusammenarbeit, bei der Agenten genauso natürlich zu bedienen sind wie menschliche Teammitglieder.\n\nSieh dir dieses Video an, um zu erfahren, was in 18.3 und darüber hinaus kommt, oder lies weiter.\n\n\u003Cdiv style=\"padding:75% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1111796316?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"GitLab_18.3 Release_081925_MP_v1\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n## Neu in GitLab 18.3\n\nMit 18.2 haben wir spezialisierte [KI-Agenten](https://about.gitlab.com/de-de/blog/gitlab-duo-agent-platform-public-beta/#agents-that-work-out-of-the-box:~:text=Agents%20that%20work%20out%20of%20the%20box) eingeführt, die Entwicklern über den gesamten Software-Entwicklungslebenszyklus hinweg zur Seite stehen, sowie unseren [Software Development Flow](\u003Chttps://about.gitlab.com/de-de/blog/gitlab-duo-agent-platform-public-beta/#agents-that-work-out-of-the-box:~:text=we%20are%20building%3A-,Software%20Development%20Flow,-(now%20in%20beta>) – eine leistungsstarke Funktion, die Nutzenden die Möglichkeit gibt, mehrere Agenten zu orchestrieren, um Code-Änderungen End-to-End zu planen, zu implementieren und zu testen.\n\nGitLab 18.3 führt erweiterte Integrationen und Interoperabilität, mehr Flows und verbesserte Kontextwahrnehmung über den gesamten Software-Entwicklungslebenszyklus ein.\n\n### Erweiterte Integrationen und Interoperabilität\n\nWir bieten umfassende KI-Erweiterbarkeit sowohl durch erstklassige GitLab-Agenten als auch durch ein reiches Ökosystem von Drittanbieter-Agenten, alle mit vollem Zugriff auf Projektkontext und -daten. Dieser Ansatz erhält native GitLab-Workflows und Governance und bietet gleichzeitig die Flexibilität, bevorzugte Tools durch hochintegrierte Orchestrierung zwischen diesen Agenten und der GitLab-Kernplattform zu wählen. Teams erhalten erweiterte KI-Funktionalität bei gleichzeitiger Beibehaltung wichtiger Integrations-, Überwachungs- und Benutzererfahrungsvorteile.\n\n* **MCP-Server - Universelle KI-Integration:** Der GitLab MCP-Server ([Model Context Protocol](https://about.gitlab.com/de-de/topics/ai/model-context-protocol/)) ermöglicht es KI-Systemen, sich sicher direkt in GitLab-Projekte und Entwicklungsprozesse zu integrieren. Diese standardisierte Schnittstelle eliminiert den Aufwand für benutzerdefinierte Integrationen und ermöglicht es KI-Tools – einschließlich [Cursor](https://docs.cursor.com/en/tools/mcp) –, intelligent innerhalb der bestehenden GitLab-Umgebung zu arbeiten. Siehe unsere [Dokumentation](https://docs.gitlab.com/user/gitlab_duo/model_context_protocol/mcp_server/) für eine vollständige Liste der in 18.3 enthaltenen Tools. **Dies ist erst der Anfang; weitere Tools sind für 18.4 geplant.**\n\n  **Hinweis:** Drittanbieter-Agenten sind GitLab Premium Beta-Funktionen und nur für GitLab Duo Enterprise-Kunden zur Evaluierung verfügbar.\n\n> *\"GitLab-Workflows direkt in Cursor zu bringen, ist ein entscheidender Schritt zur Reduzierung von Reibung für Entwickler. Durch die Minimierung des Kontextwechsels können Teams den Issue-Status überprüfen, Merge Requests einsehen und Pipeline-Ergebnisse überwachen, ohne jemals ihre Programmierumgebung zu verlassen. Diese Integration ist eine natürliche Ergänzung für unsere gemeinsamen Kunden, und wir freuen uns auf eine langfristige Partnerschaft mit GitLab, um die Entwicklerproduktivität weiter zu steigern.\"*\n>\n> \\- **Ricky Doar, VP of Field Engineering bei Cursor**\n>\n> *\"Der MCP-Server und die CLI-Agent-Unterstützung von GitLab schaffen leistungsstarke neue Wege für die Integration von Amazon Q in Entwicklungsworkflows. Amazon Q Developer kann sich jetzt direkt über die Remote-MCP-Schnittstelle von GitLab verbinden, während Teams Entwicklungsaufgaben delegieren können, indem sie Amazon Q CLI einfach in Issues und Merge Requests mit @ erwähnen. Die robusten Sicherheits- und Governance-Funktionen, die in diese Integrationen integriert sind, geben Unternehmen das Vertrauen, KI-Coding-Tools zu nutzen und gleichzeitig ihre Entwicklungsstandards zu bewahren. Die Partnerschaft mit GitLab zeigt das kontinuierliche Engagement von AWS, das KI-Ökosystem zu erweitern und intelligente Entwicklungstools überall dort zugänglich zu machen, wo Entwickler arbeiten.\"*\n>\n> \\- **Deepak Singh, Vice President of Developer Agents and Experiences bei AWS**\n\n* **CLI-Agent-Unterstützung für Claude Code, Codex, Amazon Q, Google Gemini und opencode (Bring Your Own Key):** 18.3 führt Integrationen ein, die es Teams ermöglichen, routinemäßige Entwicklungsarbeit zu delegieren, indem sie ihre Agenten direkt in Issues oder Merge Requests mit @ erwähnen. Wenn Entwickler diese KI-Assistenten erwähnen, lesen sie automatisch den umgebenden Kontext und Repository-Code und antworten dann auf den Kommentar des Nutzers entweder mit überprüfungsreifen Code-Änderungen oder Inline-Kommentaren. Diese Integrationen erfordern einen eigenen API-Schlüssel für die jeweiligen KI-Anbieter und halten alle Interaktionen nativ innerhalb der GitLab-Oberfläche, während gleichzeitig ordnungsgemäße Berechtigungen und Audit-Trails beibehalten werden.\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1111784124?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"Third Party Agents Flows Claude Code\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n> *\"Claude Code direkt in GitLab zu bringen, bringt KI-Unterstützung dorthin, wo Millionen von Entwicklern bereits täglich zusammenarbeiten und Code liefern. Die Möglichkeit, Claude direkt in Issues und Merge Requests zu erwähnen, beseitigt Reibung und behält gleichzeitig die Qualität durch menschliche Aufsicht und Überprüfungsprozesse bei. Dieses Update bringt die Fähigkeiten von Claude Code an mehr Orte, an denen Teams arbeiten, und macht KI zu einem natürlichen Teil ihres Entwickler-Workflows.\"*\n>\n> **\\- Cat Wu, Claude Code Product Lead, Anthropic**\n>\n> *\"Mit der neuen Agenten-Integration von GitLab in 18.3 können Sie opencode innerhalb Ihrer bestehenden Workflows verwenden. Sie können opencode in einem Issue oder Merge Request mit @erwähnen und es führt Ihren Agenten direkt in Ihrer CI-Pipeline aus. Diese Möglichkeit, opencode so zu konfigurieren und auszuführen, wie Sie es möchten, ist die Art von Integration, von der wir wissen, dass die Open-Source-Community sie wirklich schätzt.\"*\n>\n> **\\- Jay V., CEO, opencode**\n\n* **Agentic Chat-Unterstützung für Visual Studio IDE und GitLab UI für alle Premium- und Ultimate-Kunden verfügbar:** Mit 18.3 müssen Sie nicht mehr zwischen Tools wechseln, um auf die vollständigen Entwicklungslebenszyklus-Daten von GitLab zuzugreifen. Die erweiterten Integrationen bringen die volle Leistung von GitLab Duo sowohl in die GitLab-Benutzeroberfläche als auch in IDEs – die Unterstützung wird von JetBrains und VS Code auf Visual Studio erweitert. Dies hilft Entwicklern, im Flow zu bleiben und gleichzeitig auf reichhaltigen Projektkontext, Deployment-Historie und Team-Kollaborationsdaten direkt in ihrer bevorzugten Umgebung zuzugreifen.\n* **Erweiterte KI-Modell-Unterstützung:** GitLab Duo Self-Hosted unterstützt jetzt zusätzliche KI-Modelle und gibt Teams mehr Flexibilität in ihren KI-unterstützten Entwicklungsworkflows. Sie können jetzt Open-Source-OpenAI-GPT-Modelle (20B und 120B Parameter) über vLLM auf Ihrer Rechenzentrums-Hardware oder über Cloud-Services wie Azure OpenAI und AWS Bedrock in Ihrer privaten Cloud bereitstellen. Zusätzlich ist Anthropics Claude 4 auf AWS Bedrock verfügbar.\n\n### Neue automatisierte Entwicklungs-Flows\n\nGitLab Flows koordinieren mehrere KI-Agenten mit vordefinierten Anweisungen, um diese zeitaufwändigen, alltäglichen Aufgaben autonom zu erledigen, damit sich Entwickler auf die wirklich wichtige Arbeit konzentrieren können.\n\nGitLab 18.3 kommt mit zwei neuen Flows:\n\n* **Issue to MR Flow ermöglicht automatisierte Code-Generierung vom Konzept bis zur Fertigstellung in Minuten:** Dieser Flow konvertiert automatisch Issues in umsetzbare Merge Requests (MRs), indem Agenten koordiniert werden, um Anforderungen zu analysieren, umfassende Implementierungspläne vorzubereiten und produktionsreifen Code zu generieren, der zur Überprüfung bereit ist – und verwandelt Ideen in überprüfbare Implementierungen in Minuten, nicht Stunden.\n\n\u003Cdiv style=\"padding:75% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1111782058?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"Issue to MR\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n* **Convert CI File Flow für nahtlose Migrationsintelligenz:** Der Convert CI File Flow rationalisiert Migrationsworkflows, indem Agenten bestehende CI/CD-Konfigurationen analysieren und sie intelligent in das GitLab CI-Format mit vollständiger Pipeline-Kompatibilität konvertieren. Dies eliminiert den manuellen Aufwand und potenzielle Fehler beim Neuschreiben von CI-Konfigurationen von Grund auf und ermöglicht es Teams, ganze Deployment-Pipelines mit Vertrauen zu migrieren. 18.3 umfasst Unterstützung für Jenkins-Migrationen. Zusätzliche Unterstützung ist für zukünftige Versionen geplant.\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1111783724?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"Convert to CI Flow\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n### Intelligenter Code und Suche\n\nKI-Punktlösungen arbeiten typischerweise mit begrenzter Sichtbarkeit in isolierte Code-Schnipsel, aber der Knowledge Graph von GitLab bietet Agenten Umgebungskontext, um schnellere und intelligentere Antworten zu ermöglichen.\n\n* **Knowledge Graph für Echtzeit-Code-Intelligenz:** Mit 18.3 liefert der Knowledge Graph von GitLab jetzt Echtzeit-Code-Indizierung für schnellere Code-Suchen und liefert genauere und kontextbezogene Ergebnisse. Durch das Verständnis der Beziehungen zwischen Dateien, Abhängigkeiten und Entwicklungsmustern über die gesamte Codebasis hinweg sind die Agenten darauf ausgelegt, Einblicke zu liefern, die menschliche Entwickler Stunden kosten würden – **und dies ist nur der erste Schritt zur Erschließung der leistungsstarken Funktionen, die für den Knowledge Graph geplant sind.**\n\n### Enterprise Governance\n\nKI-Transparenz und organisatorische Kontrolle sind kritische Herausforderungen, die Teams davon abhalten können, KI-gestützte Entwicklungstools vollständig zu übernehmen, wobei [85% der Führungskräfte zustimmen, dass agentische KI beispiellose Sicherheitsherausforderungen schaffen wird](https://about.gitlab.com/de-de/software-innovation-report/).\n\nDiese neuen Funktionen in 18.3 helfen, Bedenken hinsichtlich Daten-Governance, Compliance-Anforderungen und dem Bedarf an Transparenz in KI-Entscheidungsprozessen zu adressieren, damit Organisationen KI innerhalb ihrer bestehenden Sicherheits- und Policy-Frameworks integrieren können.\n\n* **Agent Insights für Transparenz durch Intelligenz:** Das integrierte Agenten-Tracking bietet Einblick in die Entscheidungsprozesse von Agenten. Nutzende können Workflows optimieren und Best Practices durch transparentes Activity-Tracking befolgen.\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1111783244?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"Agent Insights\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\u003Cp>\u003C/p>\n\n* **GitLab Duo Code Review für Self-Hosted:** Dies bringt die Intelligenz von GitLab Duo zu Organisationen mit strengen Daten-Governance-Anforderungen, indem Teams sensiblen Code in kontrollierten Umgebungen behalten können.\n* **Hybrid-Modell-Konfigurationen für flexible KI-Bereitstellung:** GitLab Duo Self-Hosted-Kunden können jetzt Hybrid-Modell-Konfigurationen verwenden, die selbst gehostete KI-Modelle über ihr lokales KI-Gateway mit den Cloud-Modellen von GitLab über das KI-Gateway von GitLab kombinieren und so Zugriff auf verschiedene Funktionen ermöglichen.\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1111783569?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"Self Hosted Models Code Review\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\u003Cp>\u003C/p>\n\n* **Erweiterte Sicherheit mit OAuth-Unterstützung:** Der MCP-Server umfasst jetzt vollständige OAuth 2.0-Authentifizierungsunterstützung, die sichere Verbindungen zu geschützten Ressourcen und sensiblen Entwicklungsumgebungen ermöglicht. Diese Implementierung folgt dem Entwurf der OAuth-Spezifikation für MCP und behandelt Autorisierungsflows, Token-Verwaltung und dynamische Client-Registrierung.\n\n### Secure by Design-Plattform: Governance, die skaliert\n\nEchte Plattformsicherheit erfordert die konsistente Anwendung von Governance-Prinzipien über jede Ebene des Entwicklungslebenszyklus. Die gleichen Sicherheitsgrundlagen, die die KI-Adoption sicher machen – Least-Privilege-Zugriff, zentralisiertes Policy-Management, proaktive Überwachung und granulare Berechtigungen – müssen im gesamten SDLC eingebettet sein, um einen kohärenten Defense-in-Depth-Ansatz zu schaffen.\n\nGitLab 18.3 stärkt die grundlegenden Kontrollen, die zum Schutz der gesamten Software-Supply-Chain beitragen, mit diesen neuen Updates:\n\n* **Benutzerdefinierte Admin-Rolle:** Bietet granulare, zweckgebundene administrative Berechtigungen und ersetzt pauschalen Admin-Zugriff durch präzise Least-Privilege-Kontrollen. Anstatt pauschale administrative Privilegien zu gewähren, die Sicherheitsrisiken schaffen, können Organisationen jetzt spezialisierte Rollen erstellen, die auf spezifische Funktionen zugeschnitten sind – Plattform-Teams, die Runner und Monitoring verwalten, Support-Teams, die die Benutzerverwaltung handhaben, und Führungskräfte, die auf Dashboards und Nutzungsstatistiken zugreifen. Mit vollständigem Rollen-Lifecycle-Management über UI und API, Audit-Logging und automatisch generierter Dokumentation ermöglicht diese Funktion echte Least-Privilege-Administration bei gleichzeitiger Aufrechterhaltung der operativen Effizienz und Verbesserung der allgemeinen Instanzsicherheit.\n* **Compliance-Framework und Sicherheits-Policy-Management auf Instanzebene:** Organisationen können jetzt eine dedizierte Compliance-Gruppe bestimmen, die die Befugnis hat, standardisierte Frameworks und Sicherheitsrichtlinien direkt auf Top-Level-Gruppen anzuwenden und die Durchsetzung automatisch auf alle ihre Untergruppen und Projekte zu kaskadieren. Dieser zentralisierte Ansatz eliminiert den Compliance-Adoptionsblocker des fragmentierten Policy-Managements bei gleichzeitiger Beibehaltung der Gruppenautonomie für zusätzliche lokale Richtlinien.\n* **Erweiterte Verletzungsberichte:** Teams erhalten jetzt sofortige Benachrichtigungen, wenn nicht autorisierte Änderungen an MR-Genehmigungsregeln vorgenommen werden, Framework-Richtlinien keine ordnungsgemäßen Genehmigungen haben oder zeitbasierte Compliance-Kontrollen verletzt werden. Durch die direkte Verknüpfung von Verletzungen mit spezifischen Compliance-Framework-Kontrollen erhalten Teams umsetzbare Einblicke, die genau zeigen, welche Anforderung verletzt wurde, und verwandeln Compliance von einer reaktiven Checkbox-Übung in einen proaktiven, integrierten Teil des Entwicklungs- und Sicherheitsworkflows.\n* **Fein abgestimmte Berechtigungen für CI/CD-Job-Token:** Ersetzt breiten Token-Zugriff durch granulare, explizite Berechtigungen, die CI/CD-Jobs nur Zugriff auf die spezifischen API-Endpunkte gewähren, die sie tatsächlich benötigen. Anstatt Jobs pauschalen Zugriff auf Projektressourcen zu gewähren, können Teams jetzt präzise Berechtigungen für Deployments, Pakete, Releases, Umgebungen und andere kritische Ressourcen definieren, wodurch die Angriffsfläche und das Potenzial für Privilegieneskalation reduziert werden.\n* **AWS Secrets Manager-Integration:** Teams, die AWS Secrets Manager verwenden, können jetzt Secrets direkt in GitLab CI/CD-Jobs abrufen, was die Build- und Deploy-Prozesse vereinfacht. Secrets werden von einem GitLab Runner über OpenID Connect-protokollbasierte Authentifizierung abgerufen, maskiert, um Exposition in Job-Logs zu verhindern, und nach Gebrauch zerstört. Dieser Ansatz eliminiert die Notwendigkeit, Secrets in Variablen zu speichern, und integriert sich nahtlos in bestehende GitLab- und AWS-basierte Workflows. In enger Zusammenarbeit mit der Deutschen Bahn und dem AWS Secrets Manager-Team entwickelt, spiegelt diese Integration unser Engagement wider, Lösungen gemeinsam mit Kunden zu entwickeln, um reale Herausforderungen zu lösen.\n\n### Artifact Management: Sicherung der Software-Supply-Chain\n\nWenn Artefakte nicht ordnungsgemäß verwaltet werden, können kleine Änderungen große Konsequenzen haben. Veränderbare Pakete, überschriebene Container-Images und inkonsistente Regeln über Tools hinweg können Produktionsausfälle auslösen, Schwachstellen einführen und Compliance-Lücken schaffen. Für Enterprise DevSecOps ist sicheres, zentralisiertes Artifact Management unerlässlich, um die Software-Supply-Chain intakt zu halten.\n\n#### Enterprise-Grade-Artifact-Schutz in 18.3\n\nAufbauend auf den umfassenden Package-Protection-Funktionen fügt GitLab 18.3 wichtige neue Funktionen hinzu:\n\n* **Conan-Revisions-Unterstützung:** Neu in 18.3 bieten [Conan-Revisionen](https://docs.gitlab.com/user/packages/conan_2_repository/#conan-revisions) Paket-Unveränderlichkeit für C++-Entwickler. Wenn Änderungen an einem Paket vorgenommen werden, ohne seine Version zu ändern, berechnet Conan eindeutige Identifikatoren, um diese Änderungen zu verfolgen, wodurch Teams unveränderliche Pakete beibehalten können, während die Versionsklarheit erhalten bleibt.\n* **Erweiterte Container Registry-Sicherheit:** Nach der erfolgreichen Einführung von [unveränderlichen Container-Tags](https://docs.gitlab.com/user/packages/container_registry/immutable_container_tags/) in 18.2 sehen wir eine starke Unternehmensadoption. Sobald ein Tag erstellt wird, das einer unveränderlichen Regel entspricht, kann niemand – unabhängig von der Berechtigungsebene – dieses Container-Image ändern, wodurch unbeabsichtigte Änderungen an Produktionsabhängigkeiten verhindert werden.\n\nDiese Verbesserungen ergänzen die bestehenden Schutzfunktionen für npm, PyPI, Maven, NuGet, Helm-Charts und generische Pakete und ermöglichen es Plattform-Teams, konsistente Governance über ihre gesamte Software-Supply-Chain zu implementieren – eine Anforderung für Organisationen, die sichere interne Entwicklerplattformen aufbauen.\n\nIm Gegensatz zu eigenständigen Artifact-Lösungen eliminiert der integrierte Ansatz von GitLab den Kontextwechsel zwischen Tools und bietet gleichzeitig End-to-End-Nachverfolgbarkeit vom Code bis zur Bereitstellung, wodurch Plattform-Teams konsistente Governance über ihre gesamte Software-Delivery-Pipeline implementieren können.\n\n### Embedded Views: Echtzeit-Sichtbarkeit und Berichte\n\nDa GitLab-Projekte an Komplexität zunehmen, navigieren Teams zwischen Issues, Merge Requests, Epics und Meilensteinen, um die Sichtbarkeit des Arbeitsstatus aufrechtzuerhalten. Die Herausforderung liegt darin, diese Informationen effizient zu konsolidieren und gleichzeitig sicherzustellen, dass Teams Echtzeitzugriff auf den Projektfortschritt haben, ohne den Kontext zu wechseln oder ihren Flow zu unterbrechen.\n**Start der Echtzeit-Arbeitsstatussichtbarkeit in 18.3**\nDie [Embedded Views von GitLab 18.3, unterstützt durch die leistungsstarke GitLab Query Language](https://docs.gitlab.com/user/glql/#embedded-views) (GLQL), eliminieren den Kontextwechsel, indem sie Live-Projektdaten direkt in den Workflow bringen:\n\n* **Dynamische Ansichten:** Fügen Sie Live-GLQL-Abfragen in Markdown-Codeblöcken in Wiki-Seiten, Epics, Issues und Merge Requests ein, die sich automatisch mit aktuellen Projektzuständen aktualisieren, jedes Mal wenn Sie die Seite laden.\n* **Kontextuelle Personalisierung:** Ansichten passen sich automatisch mit Funktionen wie `currentUser()` und `today()` an, um relevante Informationen für den jeweiligen Betrachter anzuzeigen, ohne manuelle Konfiguration.\n* **Leistungsstarke Filterung:** Filtern Sie nach 25+ Feldern, einschließlich Assignee, Autor, Label, Meilenstein, Gesundheitsstatus und Erstellungsdatum.\n* **Anzeigeflexibilität:** Präsentieren Sie Daten als Tabellen, Listen oder nummerierte Listen mit anpassbarer Feldauswahl, Artikelbegrenzungen und Sortierreihenfolgen, um die Ansichten fokussiert und umsetzbar zu halten.\n\nIm Gegensatz zu fragmentierten Projektmanagement-Ansätzen wurden Embedded Views so konzipiert, dass sie die Workflow-Kontinuität beibehalten und gleichzeitig Echtzeit-Sichtbarkeit bieten, wodurch Teams fundierte Entscheidungen treffen können, ohne den Fokus zu verlieren oder zwischen mehreren Tools und Schnittstellen zu wechseln.\n\n> Erfahre mehr über die [neuesten Funktionen in GitLab 18.3](https://about.gitlab.com/releases/2025/08/21/gitlab-18-3-released/).\n\n## Jetzt starten\n\nGitLab 18.3 ist jetzt für GitLab Premium- und Ultimate-Nutzende auf GitLab.com und in selbstverwalteten Umgebungen verfügbar.\n\nGitLab Dedicated-Kunden wurden jetzt auf 18.2 aktualisiert und können die mit GitLab 18.3 veröffentlichten Funktionen nächsten Monat nutzen.\n\nBereit, die Zukunft des Software Engineering zu erleben? [Aktiviere Beta- und experimentelle Funktionen für GitLab Duo](https://docs.gitlab.com/user/gitlab_duo/turn_on_off/#turn-on-beta-and-experimental-features) und beginne die Zusammenarbeit mit KI-Agenten, die den vollständigen Entwicklungskontext verstehen.\n\nNeu bei GitLab? [Starte noch heute die kostenlose Testversion](https://gitlab.com/-/trials/new) und entdecke, warum die Zukunft des Software Engineering in der Zusammenarbeit zwischen Mensch und KI liegt, orchestriert durch die weltweit umfassendste DevSecOps-Plattform.\n\n\u003Cp>\u003Csmall>\u003Cem>Dieser Blogbeitrag enthält \"zukunftsgerichtete Aussagen\" im Sinne von Section 27A des Securities Act von 1933 in der geänderten Fassung und Section 21E des Securities Exchange Act von 1934. Obwohl wir glauben, dass die in den zukunftsgerichteten Aussagen in diesem Blogbeitrag zum Ausdruck gebrachten Erwartungen angemessen sind, unterliegen sie bekannten und unbekannten Risiken, Unsicherheiten, Annahmen und anderen Faktoren, die dazu führen können, dass die tatsächlichen Ergebnisse oder Resultate wesentlich von den zukünftigen Ergebnissen oder Resultaten abweichen, die in den zukunftsgerichteten Aussagen ausgedrückt oder impliziert werden.\u003C/em>\u003C/p>\n\u003Cp>\u003Cem>Weitere Informationen zu Risiken, Unsicherheiten und anderen Faktoren, die dazu führen könnten, dass die tatsächlichen Ergebnisse und Resultate wesentlich von denen abweichen, die in den zukunftsgerichteten Aussagen in diesem Blogbeitrag enthalten oder berücksichtigt werden, finden Sie unter der Überschrift \"Risikofaktoren\" und an anderen Stellen in den Einreichungen und Berichten, die wir bei der Securities and Exchange Commission einreichen. Wir übernehmen keine Verpflichtung, zukunftsgerichtete Aussagen zu aktualisieren oder zu revidieren oder über Ereignisse oder Umstände nach dem Datum dieses Blogbeitrags zu berichten oder das Eintreten unvorhergesehener Ereignisse widerzuspiegeln, außer wenn dies gesetzlich vorgeschrieben ist.\u003C/em>\u003C/small>\u003C/p>",[677,678,707,9,675],{"featured":90,"template":682,"slug":1081},"gitlab-13-expanding-ai-orchestration-in-software-engineering","content:de-de:blog:gitlab-13-expanding-ai-orchestration-in-software-engineering.yml","Gitlab 13 Expanding Ai Orchestration In Software Engineering","de-de/blog/gitlab-13-expanding-ai-orchestration-in-software-engineering.yml","de-de/blog/gitlab-13-expanding-ai-orchestration-in-software-engineering",{"_path":1087,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1088,"content":1092,"config":1100,"_id":1102,"_type":13,"title":1103,"_source":15,"_file":1104,"_stem":1105,"_extension":18},"/de-de/blog/gitlab-18-4-ai-native-development-with-automation-and-insight",{"config":1089,"title":1090,"description":1091},{"noIndex":6},"GitLab 18.4: KI-native Entwicklung mit Automatisierung","Mit GitLab 18.4 erstellst du eigene Agents, nutzt Knowledge Graph-Kontext und reparierst Pipelines automatisch.",{"title":1093,"description":1094,"authors":1095,"heroImage":1096,"date":1097,"body":1098,"category":703,"tags":1099},"GitLab 18.4: KI-native Entwicklung, voll automatisiert und transparent","Mit GitLab 18.4 erstellst du eigene Agents, nutzt Knowledge Graph-Kontext und reparierst Pipelines automatisch – damit Entwickler(innen) immer im Flow bleiben!",[1075],"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758541195/kig7sww6jyvxzmkmimbv.png","2025-09-23","Als Entwickler(in) weißt du: Moderne Entwicklung bedeutet mehr als nur Code schreiben – es geht um das Management von Änderungen über den gesamten Software-Entwicklungszyklus hinweg.\n\nMit [GitLab 18.3](https://about.gitlab.com/de-de/blog/gitlab-13-expanding-ai-orchestration-in-software-engineering/) haben wir das Fundament für echte Mensch-KI-Zusammenarbeit gelegt. Wir integrierten führende KI-Tools wie Claude Code, Codex CLI, Amazon Q CLI und Gemini CLI nativ in GitLab, lieferten unsere erste Vorschau des GitLab Model Context Protocol ([MCP](https://about.gitlab.com/topics/ai/model-context-protocol/))-Servers in Partnerschaft mit Cursor und veröffentlichten zwei neue Flows – Issue to MR und Convert CI File for Jenkins Flows – um Teams bei alltäglichen Herausforderungen zu unterstützen.\n\nMit [GitLab 18.4](https://about.gitlab.com/releases/2025/09/18/gitlab-18-4-released/) erweitern wir deine Möglichkeiten, eigene Agents zu erstellen und zu teilen, effektiver durch Agentic Chat zusammenzuarbeiten, Codebasen mit dem Knowledge Graph zu navigieren und Pipelines mit dem Fix Failed Pipelines Flow grün zu halten – während wir gleichzeitig mehr Sicherheit und Governance für deine KI-Nutzung bieten.\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1120293274?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"18.4 Release video placeholder\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n> Hast du Fragen zu den neuesten Features in GitLab 18.4? [Sei bei The Developer Show dabei](https://www.linkedin.com/events/q-a-code-exploringgitlab18-4and7373772262312906753/theater/) – live auf LinkedIn am 23. September um 10:00 Uhr PT (19:00 Uhr in Europa) oder kurz danach auf Abruf!\n\n## Gestalte deine Experience\n\n*Starte deinen Tag mit dem AI Catalog – einer Bibliothek spezialisierter Agents, die Prioritäten aufzeigen, Routinearbeit automatisieren und dich auf das Wesentliche fokussiert halten.*\n\n### AI Catalog als deine Bibliothek spezialisierter Agents\n\nMit GitLab 18.4 führen wir den GitLab Duo AI Catalog ein – eine zentrale Bibliothek, in der Teams maßgeschneiderte Agents erstellen, teilen und unternehmensweit nutzen können. Jedes Team hat seine eigene Arbeitsweise. Ein Custom Agent zu erstellen ist daher wie das Einarbeiten eines neuen Kollegen in die „richtige\" Arbeitsweise deiner Organisation.\n\nZum Beispiel kann ein Custom Product Planning Agent Bugs im spezifischen Format mit deinen Labeling-Standards erfassen, ein Technical Writer Agent kann prägnante Dokumentation nach deinen Konventionen verfassen, oder ein Security Agent stellt sicher, dass deine Sicherheits- und Compliance-Standards bei jedem MR eingehalten werden. Statt als isolierte Tools zu funktionieren, werden diese Agents Teil des natürlichen Arbeitsflusses in GitLab – sie beschleunigen Aufgaben ohne etablierte Prozesse zu stören.\n\n**Hinweis:** Diese Funktion ist derzeit nur auf GitLab.com verfügbar. Für Self-Managed-Kunden planen wir die Bereitstellung nächsten Monat mit Release 18.5.\n\n## Bleib im Flow\n\n*GitLab Duo Agentic Chat macht die Zusammenarbeit mit Agents nahtlos.*\n\n### Smarterer Agentic Chat für optimierte Zusammenarbeit mit Agents\n\nAls Herzstück der GitLab Duo Agent Platform bietet dir [Agentic Chat](https://docs.gitlab.com/user/gitlab_duo_chat/agentic_chat/) eine nahtlose Möglichkeit, mit KI-Agents zusammenzuarbeiten. Das neueste Update des Agentic Chat mit GitLab 18.4 verbessert das Chat-Erlebnis und erweitert die Verwaltung und Darstellung von Sessions.\n\n* **Chat mit Custom Agents**\n\n  Starten wir mit deinem neu erstellten Custom Agent. Einmal designt, kannst du diesen Agent sofort über Agentic Chat einsetzen. Du könntest deinen neuen Agent beispielsweise fragen: „Zeig mir meine Aufgaben für heute\", um mit deinen Prioritäten zu starten. Zusätzlich hast du jetzt die Möglichkeit, neue Unterhaltungen mit neuen Agents zu beginnen und vorherige Unterhaltungen fortzusetzen, ohne den Kontext zu verlieren.\n* **[Modellauswahl für Nutzer](https://docs.gitlab.com/user/gitlab_duo/model_selection/#select-a-model-to-use-in-gitlab-duo-agentic-chat)**\n\n  Mit früheren Releases konntest du Modelle auf Namespace-Ebene auswählen, aber mit 18.4 kannst du nun Modelle auf Nutzerebene für eine bestimmte Chat-Session wählen. Das ermächtigt dich, zu entscheiden, welches LLM für die jeweilige Aufgabe geeignet ist, oder mit verschiedenen LLMs zu experimentieren, um zu sehen, welches die beste Antwort für deine Aufgabe liefert.\n* **Verbesserte Formatierung und visuelles Design**\n\n  Wir hoffen, du liebst das neue visuelle Design für GitLab Duo Agentic Chat, einschließlich verbesserter Handhabung von Tool-Call-Genehmigungen für ein angenehmeres Erlebnis.\n* **Agent Sessions verfügbar über Agentic Chat**\n\n  Sessions werden zu einem zentralen Bestandteil des Agentic Chat-Erlebnisses. Jeder Agent-Run oder Flow erscheint nun in der Sessions-Übersicht, die über Agentic Chat verfügbar ist. In jeder Session siehst du detaillierte Informationen wie Job-Logs, Nutzerinformationen und Tool-Metadaten – das bietet wichtige Transparenz darüber, wie Agents in deinem Auftrag arbeiten.\n\n  **Hinweis:** Sessions in Agentic Chat ist nur auf GitLab.com verfügbar. Diese Verbesserung ist für Self-Managed-Kunden nächsten Monat im 18.5-Update geplant.\n\n## Erschließe deine Codebase\n\n*Bei Agents ist Kontext entscheidend. Mit Knowledge Graph gibst du deinen Agents mehr Kontext, damit sie schneller analysieren und dir bessere Ergebnisse liefern können.*\n\n### Neu: Der GitLab Knowledge Graph (Beta)\n\nDer [GitLab Knowledge Graph](https://gitlab-org.gitlab.io/rust/knowledge-graph/) in 18.4 transformiert, wie Entwickler und Agents komplexe Codebasen verstehen und navigieren. Der Knowledge Graph bietet eine vernetzte Karte deines gesamten Projekts und verknüpft Dateien, Routen und Referenzen über den Software-Entwicklungszyklus hinweg. Durch Tools wie Go-to-Definition, Codebase-Suche und Referenz-Tracking über In-Chat-Queries erhalten Entwickler die Möglichkeit, präzise Fragen zu stellen wie „Zeig mir alle Route-Dateien\" oder „Was ist noch von dieser Änderung betroffen?\"\n\nDieser tiefere Kontext hilft Teams, schneller und mit mehr Vertrauen zu arbeiten – egal ob es um das Onboarding neuer Mitwirkender geht, tiefgehende Recherche in einem Projekt oder die Untersuchung, wie eine Änderung abhängigen Code beeinflusst. Je mehr von deinem Ökosystem in GitLab lebt, desto mächtiger wird der Knowledge Graph und gibt sowohl Menschen als auch KI-Agents das Fundament, mit Genauigkeit, Geschwindigkeit und vollem Projektbewusstsein zu bauen. In zukünftigen Releases werden wir alle deine GitLab-Daten in den Knowledge Graph einbinden, einschließlich Plans, MRs, Sicherheitslücken und mehr.\n\nDieses Release des Knowledge Graph fokussiert sich auf lokale Code-Indexierung, bei der das `gkg` CLI deine Codebase in eine lebendige, einbettbare Graph-Datenbank für RAG verwandelt. Du kannst es mit einem einfachen Einzeiler-Script installieren, lokale Repositories parsen und über MCP verbinden, um deinen Workspace abzufragen.\n\nUnsere Vision für das Knowledge Graph-Projekt ist zweigeteilt: Wir bauen eine lebendige Community Edition, die Entwickler heute schon lokal ausführen können, die als Fundament für einen zukünftigen, vollständig integrierten Knowledge Graph Service innerhalb von GitLab.com und Self-Managed-Instanzen dienen wird.\n\n## Automatisiere deine Pipeline-Wartung\n\n*Behebe Pipeline-Fehler schneller und bleib im Flow mit dem Fix Failed Pipelines Flow.*\n\n### Fix Failed Pipelines Flow mit Business-Bewusstsein\n\nPipelines grün zu halten ist entscheidend für deine Entwicklungsgeschwindigkeit, aber traditionelle Ansätze konzentrieren sich nur auf technische Fehlersuche ohne Berücksichtigung der geschäftlichen Auswirkungen. Der **Fix Failed Pipelines Flow** adressiert diese Herausforderung, indem er technische Analyse mit strategischem Kontext kombiniert. Er kann beispielsweise automatisch priorisieren, eine fehlgeschlagene Deployment-Pipeline für einen kundenorientierten Service vor einem nächtlichen Test-Job zu reparieren oder Build-Probleme in einem hochpriorisierten Release-Branch anders zu kennzeichnen als in experimentellen Feature-Branches.\n\n* **Business-bewusste Fehlererkennung** überwacht Pipeline-Ausführungen und versteht dabei die Bedeutung verschiedener Workflows und Deployment-Ziele.\n* **Kontextuelle Ursachenanalyse** analysiert Fehlerprotokolle zusammen mit Geschäftsanforderungen, kürzlichen Änderungen und projektübergreifenden Abhängigkeiten, um die zugrunde liegenden Ursachen zu identifizieren.\n* **Strategische Fix-Priorisierung** generiert geeignete Fixes unter Berücksichtigung von geschäftlichen Auswirkungen, Deadlines und Prioritäten bei der Ressourcenzuweisung.\n* **Workflow-integrierte Lösung** erstellt automatisch Merge Requests mit Fixes, die ordnungsgemäße Review-Prozesse beibehalten und gleichzeitig geschäftlichen Kontext für Priorisierungsentscheidungen liefern.\n\nDieser Flow hält Pipelines grün und wahrt dabei die strategische Ausrichtung, sodass automatisierte Fixes Geschäftsziele unterstützen, anstatt nur technische Probleme isoliert zu lösen.\n\n## Personalisiere deine KI-Umgebung\n\n*Automatisierung funktioniert nur, wenn du den Modellen dahinter vertraust. Deshalb liefert 18.4 Governance-Features wie Modellauswahl und GitLab-verwaltete Schlüssel.*\n\n### GitLab Duo Modellauswahl zur Optimierung der Feature-Performance\n\nDie [Modellauswahl](https://docs.gitlab.com/user/gitlab_duo/model_selection/) ist jetzt allgemein verfügbar und gibt dir direkte Kontrolle darüber, welche Large Language Models ([LLMs](https://about.gitlab.com/blog/what-is-a-large-language-model-llm/)) GitLab Duo antreiben. Du und dein Team könnt die Modelle eurer Wahl auswählen, sie unternehmensweit anwenden oder pro Feature anpassen. Du kannst Standards setzen, um Konsistenz über Namespaces und Tools hinweg zu gewährleisten, mit Governance-, Compliance- und Sicherheitsanforderungen im Blick.\n\nFür Kunden, die GitLab Duo Self-Hosted nutzen, bietet die neu hinzugefügte Unterstützung für GPT OSS und GPT-5 zusätzliche Flexibilität für KI-gestützte Entwicklungs-Workflows.\n\n**Hinweis:** GitLab Duo Self-Hosted ist für GitLab.com-Kunden nicht verfügbar, und GPT-Modelle werden auf GitLab.com nicht unterstützt.\n\n## Schütze deinen sensiblen Kontext\n\n*Neben Governance kommt Datenschutz, der dir feingranulare Kontrolle darüber gibt, was KI sehen kann und was nicht.*\n\n### GitLab Duo Context Exclusion für granularen Datenschutz\n\nEs ist keine Überraschung – du brauchst granulare Kontrolle darüber, auf welche Informationen KI-Agents zugreifen können. **GitLab Duo Context Exclusion** in 18.4 bietet Einstellungen auf Projektebene, mit denen Teams bestimmte Dateien oder Dateipfade vom KI-Zugriff ausschließen können. Zu den Funktionen gehören:\n\n* **Datei-spezifische Ausschlüsse** zum Schutz sensibler Dateien wie Passwort-Konfigurationen, Secrets und proprietäre Algorithmen.\n* **Pfad-basierte Regeln** zur Erstellung von Ausschlussmustern basierend auf Verzeichnisstrukturen oder Dateinamenskonventionen.\n* **Flexible Konfiguration** zur Anwendung von Ausschlüssen auf Projektebene bei gleichzeitiger Aufrechterhaltung der Entwicklungs-Workflow-Effizienz.\n* **Audit-Sichtbarkeit** zur Verfolgung, welche Inhalte ausgeschlossen sind, um die Einhaltung von Daten-Governance-Richtlinien zu unterstützen.\n\nGitLab Duo Context Exclusion hilft dir, sensible Daten zu schützen, während du die Entwicklung mit agentischer KI beschleunigst.\n\n## Erweitere deine KI-Fähigkeiten mit neuen MCP-Tools\n\n*Erweiterte MCP-Tools erweitern diese Fähigkeiten noch weiter und verbinden deine GitLab-Umgebung mit einem breiteren Ökosystem intelligenter Agents.*\n\n### Neue Tools für GitLab MCP Server\n\nAufbauend auf dem in [18.3](https://about.gitlab.com/de-de/blog/gitlab-13-expanding-ai-orchestration-in-software-engineering/) eingeführten initialen MCP-Server fügt GitLab 18.4 weitere MCP-Tools hinzu – Funktionen, die definieren, wie MCP-Clients mit GitLab interagieren. Diese neuen Tools erweitern die Integrationsmöglichkeiten und ermöglichen sowohl First-Party- als auch Third-Party-KI-Agents, komplexere Aufgaben zu übernehmen, wie den Zugriff auf Projektdaten, die Durchführung von Code-Operationen oder die Suche über Repositories hinweg – alles unter Beachtung bestehender Sicherheits- und Berechtigungsmodelle. Eine vollständige Liste der MCP-Tools, einschließlich der neuen Ergänzungen in 18.4, findest du in unserer [MCP-Server-Dokumentation](https://docs.gitlab.com/user/gitlab_duo/model_context_protocol/mcp_server/).\n\n## Erlebe die Zukunft der intelligenten Software-Entwicklung\n\nMit der [GitLab Duo Agent Platform](https://about.gitlab.com/de-de/gitlab-duo/agent-platform/) können Ingenieure von der Arbeit an einzelnen Issues in sequenzieller Weise zu Multi-Thread-Zusammenarbeit mit asynchronen Agents übergehen, die wie Teamkollegen agieren, um Arbeit schneller zu erledigen. Wir bringen diese einzigartige Vision mit den Präferenzen unserer Kunden für Unabhängigkeit und Wahlfreiheit auf den Markt: Betreibe sie in deinen bevorzugten Cloud-Umgebungen mit den LLMs und KI-Tools, die für dich am besten funktionieren, innerhalb der von dir festgelegten Sicherheits- und Compliance-Leitplanken.\n\nAls integraler Bestandteil dieser Innovation ist GitLab 18.4 mehr als ein Software-Upgrade – es geht darum, das tägliche Erlebnis von Entwicklern reibungsloser, smarter und sicherer zu gestalten. Von wiederverwendbaren Agents bis zu business-bewussten Pipeline-Fixes ist jedes Feature darauf ausgelegt, Teams im Flow zu halten und gleichzeitig Geschwindigkeit, Sicherheit und Kontrolle auszubalancieren. Für einen tieferen Einblick, wie diese Funktionen in der Praxis zusammenkommen, schau dir unser Walkthrough-Video an.\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1120288083?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"A day in the life with GitLab Duo Agent Platform\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\u003Cp>\u003C/p>\n\nGitLab Premium- und Ultimate-Nutzer können diese Funktionen heute auf [GitLab.com](https://GitLab.com) und in Self-Managed-Umgebungen nutzen, mit Verfügbarkeit für [GitLab Dedicated](https://about.gitlab.com/dedicated/)-Kunden nächsten Monat.\n\n> **Aktiviere Beta- und experimentelle Features in GitLab Duo Agent Platform heute** und erlebe, wie Full-Context-KI die Art und Weise transformieren kann, wie deine Teams Software bauen. Neu bei GitLab? [Starte deine kostenlose Testversion](https://about.gitlab.com/free-trial/devsecops/) und entdecke, warum die Zukunft der Entwicklung KI-gestützt, sicher und durch die weltweit umfassendste DevSecOps-Plattform orchestriert ist.\n\n## Bleib auf dem neuesten Stand mit GitLab\n\nUm sicherzustellen, dass du die neuesten Features, Sicherheitsupdates und Performance-Verbesserungen erhältst, empfehlen wir, deine GitLab-Instanz aktuell zu halten. Die folgenden Ressourcen können dir bei der Planung und Durchführung deines Upgrades helfen:\n\n* [Upgrade Path Tool](https://gitlab-com.gitlab.io/support/toolbox/upgrade-path/) – gib deine aktuelle Version ein und sieh die exakten Upgrade-Schritte für deine Instanz\n* [Upgrade-Dokumentation](https://docs.gitlab.com/update/upgrade_paths/) – detaillierte Anleitungen für jede unterstützte Version, einschließlich Anforderungen, Schritt-für-Schritt-Anweisungen und Best Practices\n\nDurch regelmäßige Upgrades stellst du sicher, dass dein Team von den neuesten GitLab-Funktionen profitiert und sicher und unterstützt bleibt.\n\nFür Organisationen, die einen Hands-off-Ansatz wünschen, bietet sich [GitLabs Managed Maintenance Service](https://content.gitlab.com/viewer/d1fe944dddb06394e6187f0028f010ad#1) an. Mit Managed Maintenance bleibt dein Team auf Innovation fokussiert, während GitLab-Experten deine Self-Managed-Instanz zuverlässig aktualisiert, sicher und bereit für die Führung in DevSecOps halten. Frage deinen Account Manager nach weiteren Informationen.\n\n*Dieser Blogbeitrag enthält „zukunftsgerichtete Aussagen\" im Sinne von Section 27A des Securities Act von 1933 in der geänderten Fassung und Section 21E des Securities Exchange Act von 1934. Obwohl wir glauben, dass die in diesen Aussagen reflektierten Erwartungen angemessen sind, unterliegen sie bekannten und unbekannten Risiken, Unsicherheiten, Annahmen und anderen Faktoren, die dazu führen können, dass tatsächliche Ergebnisse oder Resultate wesentlich abweichen. Weitere Informationen zu diesen Risiken und anderen Faktoren findest du unter der Überschrift „Risk Factors\" in unseren Einreichungen bei der SEC. Wir übernehmen keine Verpflichtung, diese Aussagen nach dem Datum dieses Blogbeitrags zu aktualisieren oder zu überarbeiten, außer wenn gesetzlich erforderlich.*",[678,677,9,707],{"featured":90,"template":682,"slug":1101},"gitlab-18-4-ai-native-development-with-automation-and-insight","content:de-de:blog:gitlab-18-4-ai-native-development-with-automation-and-insight.yml","Gitlab 18 4 Ai Native Development With Automation And Insight","de-de/blog/gitlab-18-4-ai-native-development-with-automation-and-insight.yml","de-de/blog/gitlab-18-4-ai-native-development-with-automation-and-insight",{"_path":1107,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1108,"content":1111,"config":1119,"_id":1121,"_type":13,"title":1122,"_source":15,"_file":1123,"_stem":1124,"_extension":18},"/de-de/blog/gitlab-duo-agent-platform-public-beta",{"noIndex":6,"title":1109,"description":1110,"ogTitle":1109},"GitLab Duo Agent Platform jetzt in Public Beta","Entwicklerteams und KI-Agenten arbeiten erstmals Hand in Hand – parallel, intelligent, orchestriert.",{"tags":1112,"category":703,"date":1114,"heroImage":1115,"authors":1116,"description":1110,"title":1117,"body":1118},[678,677,9,1113],"news","2025-07-17","https://res.cloudinary.com/about-gitlab-com/image/upload/v1752678395/impw8no5tbskr6k2afgu.jpg",[1075],"GitLab Duo Agent Platform jetzt in Public Beta: KI-Orchestrierung der nächsten Generation","**Das ist die Zukunft der Software-Entwicklung.**\n\nBei GitLab [gestalten wir die Zukunft der Software-Entwicklung neu](https://about.gitlab.com/de-de/blog/gitlab-duo-agent-platform-what-is-next-for-intelligent-devsecops/) als Zusammenarbeit zwischen Menschen und KI. Entwickler(innen) konzentrieren sich auf die Lösung technischer, komplexer Probleme und treiben Innovationen voran, während KI-Agenten die routinemäßigen, sich wiederholenden Aufgaben übernehmen, die den Fortschritt verlangsamen. Entwickler(innen) sind frei, neue Ideen im Code zu deutlich geringeren Kosten zu erkunden, Bug-Backlogs gehören der Vergangenheit an, und die Nutzer(innen) der von dir erstellten Software genießen eine benutzerfreundlichere, zuverlässigere und sicherere Erfahrung. Das ist kein ferner Traum. Wir bauen diese Realität schon heute. Sie heißt GitLab Duo Agent Platform.\n\n## Was ist GitLab Duo Agent Platform?\n\nGitLab Duo Agent Platform ist unsere DevSecOps-Orchestrierungsplattform der nächsten Generation, welche entwickelt wurde, um die asynchrone Zusammenarbeit zwischen Entwickler(innen) und KI-Agenten zu ermöglichen. Sie wird deinen Entwicklungsworkflow von isolierten linearen Prozessen in eine dynamische Zusammenarbeit verwandeln, bei der spezialisierte KI-Agenten in jeder Phase des Software-Entwicklungslebenszyklus an deiner Seite und mit deinem Team arbeiten. Es wird so sein, als hättest du ein unbegrenztes Team von Kolleg(inn)en zur Verfügung.\n\nStell dir vor, du delegierst eine komplexe Refaktorierungsaufgabe an einen Software-Entwickler-Agenten, während gleichzeitig ein Sicherheitsanalyse-Agent nach Schwachstellen sucht und ein Deep-Research-Agent den Fortschritt über deine Repository-Historie hinweg analysiert. All dies geschieht parallel, nahtlos orchestriert innerhalb von GitLab.\n\nHeute kündigen wir die Einführung der [ersten Public Beta von GitLab Duo Agent Platform](https://about.gitlab.com/de-de/gitlab-duo/agent-platform/) für GitLab.com und selbstverwaltete GitLab Premium- und Ultimate-Kund(inn)en an. Dies ist nur die erste einer Reihe von Updates, die verbessern werden, wie Software geplant, erstellt, verifiziert und bereitgestellt wird, während wir menschlichen Einfallsreichtum durch intelligente Automatisierung verstärken.\n\nDiese erste Beta konzentriert sich auf die Freischaltung der IDE-Erfahrung über die GitLab VS Code-Erweiterung und das JetBrains IDEs-Plugin; nächsten Monat planen wir, die Duo Agent Platform-Erfahrung in die GitLab-Anwendung zu bringen und unsere IDE-Unterstützung zu erweitern. \n\nLass mich ein wenig mehr über unsere Vision für die Roadmap von heute bis zur allgemeinen Verfügbarkeit, die für später in diesem Jahr geplant ist, berichten. Details zur ersten Beta findest du unten.\n\nSchau dir dieses Video an oder lies weiter, um zu erfahren, was jetzt verfügbar ist und was demnächst kommen wird. Wenn du dann bereit bist, mit Duo Agent Platform zu arbeiten, [erfährst du hier, wie das mit der Public Beta geht](#get-started-now).\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1101993507?title=0&byline=0&portrait=0&badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"GitLab Agent Platform Beta Launch_071625_MP_v2\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n## GitLabs einzigartige Position als Orchestrierungsplattform\n\nGitLab steht im Mittelpunkt des Entwicklungslebenszyklus als System of Record für Engineering-Teams und orchestriert die gesamte Reise vom Konzept zur Produktion für über 50 Millionen registrierte Nutzer(innen), einschließlich der Hälfte der Fortune 500 über alle Geografien hinweg. Dies umfasst über 10.000 zahlende Kund(inn)en in allen Segmenten und Branchen, einschließlich öffentlicher Institutionen.\n\nDies gibt GitLab etwas, was kein Wettbewerber bieten kann: ein umfassendes Verständnis von allem, was es braucht, um Software zu liefern. Wir bringen deine Projektpläne, Code, Testläufe, Sicherheitsscans, Compliance-Prüfungen und CI/CD-Konfigurationen zusammen, um nicht nur dein Team zu unterstützen, sondern auch die Zusammenarbeit mit KI-Agenten zu orchestrieren, die du kontrollierst.\n\nAls intelligente, einheitliche DevSecOps-Plattform speichert GitLab den gesamten Kontext deiner Software-Engineering-Praxis an einem Ort. Wir werden diese einheitlichen Daten über unseren Knowledge Graph KI-Agenten zugänglich machen. Jeder Agent, den wir erstellen, hat automatischen Zugriff auf diesen SDLC-verbundenen Datensatz und bietet einen reichhaltigen Kontext, sodass Agenten fundierte Empfehlungen abgeben und Maßnahmen ergreifen können, die deinen organisatorischen Standards entsprechen.\n\n**Hier ist ein Beispiel für diesen Vorteil in Aktion.** Hast du jemals versucht herauszufinden, wie genau ein Projekt über Dutzende, wenn nicht Hunderte von Stories und Issues verläuft, die von allen beteiligten Entwickler(inne)n bearbeitet werden? Unser Deep Research Agent nutzt den GitLab Knowledge Graph und semantische Suchfunktionen, um dein Epic und alle damit verbundenen Issues zu durchsuchen, die zugehörige Codebasis und den umgebenden Kontext zu erkunden. Er korreliert schnell Informationen über deine Repositories, Merge Requests und Deployment-Historie hinweg. Dies liefert kritische Einblicke, die eigenständige Tools nicht bieten können und die menschliche Entwickler(innen) Stunden kosten würden, um sie zu entdecken.\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1101998114?title=0&byline=0&portrait=0&badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"Deep Research Demo_071625_MP_v1\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n## Unsere strategische Entwicklung von KI-Features zur Agenten-Orchestrierung\n\nGitLab Duo begann als Add-on, das generative KI zu Entwickler(inne)n über Duo Pro und Enterprise brachte. Mit GitLab 18.0 ist es jetzt in die Plattform integriert. Wir haben [Duo Agentic Chat](https://about.gitlab.com/de-de/blog/gitlab-duo-chat-gets-agentic-ai-makeover/) und Code Suggestions für alle Premium- und Ultimate-Nutzer(innen) freigeschaltet, und jetzt bieten wir sofortigen Zugang zu Duo Agent Platform.\n\nWir haben die Engineering-Investitionen erhöht und beschleunigen die Bereitstellung, wobei jeden Monat leistungsstarke neue KI-Features landen. Aber wir bauen nicht nur einen weiteren Coding-Assistenten. GitLab Duo wird zu einer Agenten-Orchestrierungsplattform, auf der du KI-Agenten erstellen, anpassen und bereitstellen kannst, die an deiner Seite arbeiten und problemlos mit anderen Systemen interoperieren, was die Produktivität dramatisch steigert.\n\n> **„GitLab Duo Agent Platform verbessert unseren Entwicklungsworkflow mit KI, die unsere Codebasis und unsere Organisation wirklich versteht. GitLab Duo KI-Agenten in unserem System of Record für Code, Tests, CI/CD und den gesamten Software-Entwicklungslebenszyklus eingebettet zu haben, steigert Produktivität, Geschwindigkeit und Effizienz. Die Agenten sind zu echten Mitarbeitern unserer Teams geworden, und ihre Fähigkeit, Absichten zu verstehen, Probleme zu zerlegen und Maßnahmen zu ergreifen, befreit unsere Entwickler(innen), sich den aufregenden, innovativen Arbeiten zu widmen, die sie lieben.\"** - Bal Kang, Engineering Platform Lead bei NatWest\n\n### Agenten, die sofort funktionieren\n\nWir führen Agenten ein, die vertraute Teamrollen widerspiegeln. Diese Agenten können in GitLab suchen, lesen, erstellen und vorhandene Artefakte ändern. Denk an diese als Agenten, mit denen du einzeln interagieren kannst, die auch als Bausteine fungieren, die du anpassen kannst, um deine eigenen Agenten zu erstellen. Wie deine Teammitglieder haben Agenten definierte Spezialisierungen, wie Softwareentwicklung, Testen oder technisches Schreiben. Als Spezialisten nutzen sie den richtigen Kontext und die richtigen Tools, um konsequent die gleichen Arten von Aufgaben zu erledigen, wo immer sie eingesetzt werden.\n\nHier sind einige der Agenten, die wir heute bauen:\n\n* **Chat-Agent (jetzt in Beta):** Nimmt Anfragen in natürlicher Sprache entgegen, um dem Nutzer Informationen und Kontext bereitzustellen. Kann allgemeine Entwicklungsaufgaben ausführen, wie das Lesen von Issues oder Code-Diffs. Als Beispiel kannst du Chat bitten, einen fehlgeschlagenen Job zu debuggen, indem du die Job-URL bereitstellst.\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1101953504?title=0&byline=0&portrait=0&badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"agentic-chat-in-web-ui-demo_Update V1\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\u003Cp>\u003C/p>\n\n* **Software-Entwickler-Agent (jetzt in Beta):** Arbeitet an zugewiesenen Elementen, indem er Code-Änderungen in virtuellen Entwicklungsumgebungen erstellt und Merge Requests zur Überprüfung öffnet.\n* **Produktplanungs-Agent:** Priorisiert Produkt-Backlogs, weist Arbeitselemente menschlichen und agentischen Teammitgliedern zu und liefert Projekt-Updates über festgelegte Zeiträume.\n* **Software-Test-Ingenieur-Agent:** Testet neue Code-Beiträge auf Bugs und validiert, ob gemeldete Probleme gelöst wurden.\n* **Code-Review-Agent:** Führt Code-Reviews nach Teamstandards durch, identifiziert Qualitäts- und Sicherheitsprobleme und kann Code mergen, wenn er bereit ist.\n* **Plattform-Ingenieur-Agent:** Überwacht GitLab-Deployments, einschließlich GitLab Runners, verfolgt die CI/CD-Pipeline-Gesundheit und meldet Performance-Probleme an menschliche Plattform-Engineering-Teams.\n* **Sicherheitsanalyse-Agent:** Findet Schwachstellen in Codebasen und bereitgestellten Anwendungen und implementiert Code- und Konfigurationsänderungen, um Sicherheitsschwächen zu beheben.\n* **Deployment-Ingenieur-Agent:** Stellt Updates in der Produktion bereit, überwacht ungewöhnliches Verhalten und macht Änderungen rückgängig, die sich auf die Anwendungsleistung oder -sicherheit auswirken.\n* **Deep-Research-Agent:** Führt umfassende, quellenübergreifende Analysen über dein gesamtes Entwicklungsökosystem durch.\n\nWas diese Agenten leistungsstark macht, ist ihr nativer Zugriff auf GitLabs umfassendes Toolkit. Heute haben wir über 25 Tools, von Issues und Epics bis zu Merge Requests und Dokumentation, mit mehr in Sicht. Im Gegensatz zu externen KI-Tools, die mit begrenztem Kontext arbeiten, arbeiten unsere Agenten als echte Teammitglieder mit vollständigen Plattformberechtigungen unter deiner Aufsicht.\n\nIn den kommenden Monaten wirst du auch in der Lage sein, diese Agenten zu modifizieren, um den Bedürfnissen deiner Organisation gerecht zu werden. Zum Beispiel wirst du spezifizieren können, dass ein Software-Test-Ingenieur-Agent Best Practices für ein bestimmtes Framework oder eine bestimmte Methodik befolgt, seine Spezialisierung vertieft und ihn zu einem noch wertvolleren Teammitglied macht.\n\n## Flows orchestrieren komplexe Agenten-Aufgaben\n\nZusätzlich zu einzelnen Agenten führen wir Agenten-Flows ein. Betrachte diese als komplexere Workflows, die mehrere Agenten mit vorgefertigten Anweisungen, Schritten und Aktionen für eine bestimmte Aufgabe umfassen können, die autonom ausgeführt werden kann.\n\nWährend du Flows für grundlegende Aufgaben erstellen kannst, die für Einzelpersonen üblich sind, brillieren sie wirklich, wenn sie auf komplexe, spezialisierte Aufgaben angewendet werden, die normalerweise Stunden an Koordination und Aufwand erfordern würden. Flows helfen dir, komplexe Aufgaben schneller zu erledigen und in vielen Fällen asynchron ohne menschliche Intervention.\n\nFlows haben spezifische Trigger für die Ausführung. Jeder Flow enthält eine Reihe von Schritten, und jeder Schritt hat detaillierte Anweisungen, die einem spezialisierten Agenten sagen, was zu tun ist. Dieser granulare Ansatz ermöglicht es dir, den Agenten im Flow präzise Anweisungen zu geben. Durch die Definition von Anweisungen mit mehr Details und die Einrichtung strukturierter Entscheidungspunkte können Flows helfen, die inhärente Variabilität in KI-Antworten zu lösen und gleichzeitig die Notwendigkeit zu eliminieren, wiederholt die gleichen Anforderungen zu spezifizieren, was konsistentere und vorhersagbarere Ergebnisse ohne Benutzerkonfiguration freischaltet.\n\nHier sind einige Beispiele für sofort einsatzbereite Flows, die wir bauen:\n\n**Software-Entwicklungs-Flow (jetzt in Beta):** Orchestriert mehrere Agenten, um Code-Änderungen End-to-End zu planen, zu implementieren und zu testen, und hilft dabei zu transformieren, wie Teams Features vom Konzept zur Produktion liefern.\n\n**Issue-to-MR-Flow:** Konvertiert automatisch Issues in umsetzbare Merge Requests, indem Agenten koordiniert werden, um Anforderungen zu analysieren, umfassende Implementierungspläne vorzubereiten und Code zu generieren.\n\n**CI-Datei-Konvertierungs-Flow:** Vereinfacht Migrations-Workflows, indem Agenten bestehende CI/CD-Konfigurationen analysieren und sie intelligent in das GitLab CI-Format mit vollständiger Pipeline-Kompatibilität konvertieren.\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1101941425?title=0&byline=0&portrait=0&badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"jenkins-to-gitlab-cicd-for-blog\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\u003Cp>\u003C/p>\n\n**Such- und Ersetzungs-Flow:** Entdeckt und transformiert Code-Muster über Codebasen hinweg, indem Projektstrukturen systematisch analysiert, Optimierungsmöglichkeiten identifiziert und präzise Ersetzungen ausgeführt werden.\n\n**Incident-Response- und Root-Cause-Analyse-Flow:** Orchestriert die Incident-Response durch Korrelation von Systemdaten, Koordination spezialisierter Agenten für die Root-Cause-Analyse und Ausführung genehmigter Abhilfemaßnahmen, während menschliche Stakeholder während des gesamten Lösungsprozesses informiert bleiben.\n\nHier verfolgt GitLab Duo Agent Platform einen wirklich einzigartigen Ansatz im Vergleich zu anderen KI-Lösungen. Wir geben dir nicht nur vorgefertigte Agenten. Wir geben dir auch die Möglichkeit, Agenten-Flows zu erstellen, anzupassen und zu teilen, die perfekt zu deinen individuellen und organisatorischen Bedürfnissen passen. Und mit Flows kannst du dann Agenten einen spezifischen Ausführungsplan für allgemeine und komplexe Aufgaben geben.\n\nWir glauben, dass dieser Ansatz leistungsstärker ist als spezialisierte Agenten zu bauen, wie es unsere Wettbewerber tun, denn jede Organisation hat unterschiedliche Workflows, Codierungsstandards, Sicherheitsanforderungen und Geschäftslogik. Generische KI-Tools können deinen spezifischen Kontext nicht verstehen, aber GitLab Duo Agent Platform wird so angepasst werden können, dass sie genau so funktioniert, wie dein Team arbeitet.\n\n## Warum Agenten und Agenten-Flows in GitLab Duo Agent Platform bauen?\n\n**Es geht schnell.** Du kannst Agenten und komplexe Agenten-Flows in Duo Agent Platform schnell und einfach mit einem schnellen, deklarativen Erweiterbarkeitsmodell und UI-Unterstützung erstellen.\n\n**Integrierte Rechenleistung.** Mit Duo Agent Platform musst du dich nicht mehr um den Aufwand kümmern, deine eigene Infrastruktur für Agenten aufzubauen: Rechenleistung, Netzwerk und Speicher sind alle integriert.\n\n**SDLC-Events.** Deine Agenten können automatisch bei gängigen Ereignissen aufgerufen werden: defekte Pipeline, fehlgeschlagenes Deployment, erstelltes Issue usw.\n\n**Sofortiger Zugriff.** Du kannst mit deinen Agenten überall in GitLab oder unserem IDE-Plugin interagieren: weise ihnen Issues zu, @erwähne sie in Kommentaren und chatte mit ihnen überall, wo Duo Chat verfügbar ist.\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1102029239?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"assigning an agent an issue\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script> \u003Cp>\u003C/p>\n\n**Unterstützung integrierter und benutzerdefinierter Modelle.** Deine Agenten haben automatischen Zugriff auf alle von uns unterstützten Modelle, und Nutzer(innen) können spezifische Modelle für spezifische Aufgaben auswählen. Wenn du Duo Agent Platform mit deinem eigenen selbst gehosteten Modell verbinden möchtest, kannst du das auch tun!\n\n**Model Context Protocol (MCP) Endpunkte.** Jeder Agent und Flow kann über native MCP-Endpunkte aufgerufen oder ausgelöst werden, sodass du dich von überall aus mit deinen Agenten und Flows verbinden und zusammenarbeiten kannst, einschließlich beliebter Tools wie Claude Code, Cursor, Copilot und Windsurf.\n\n**Observability und Sicherheit.** Schließlich bieten wir integrierte Observability und Nutzungs-Dashboards, damit du genau sehen kannst, wer, wo, was und wann Agenten in deinem Namen Aktionen durchgeführt haben.\n\n## Eine von der Community getriebene Zukunft\n\nCommunity-Beiträge haben lange Zeit GitLabs Innovation und Softwareentwicklung angetrieben. Wir freuen uns, mit unserer Community bei der Einführung des KI-Katalogs zusammenzuarbeiten. Der KI-Katalog ermöglicht es dir, Agenten und Flows innerhalb deiner Organisation und im gesamten GitLab-Ökosystem in unserer kommenden Beta zu erstellen und zu teilen.\n\nWir glauben, dass die wertvollsten KI-Anwendungen wahrscheinlich von dir, unserer Community, entstehen werden, dank deiner täglichen Anwendung von GitLab Duo Agent Platform zur Lösung zahlreicher realer Anwendungsfälle. Durch die Ermöglichung des nahtlosen Teilens von Agenten und Flows schaffen wir einen Netzwerkeffekt, bei dem jeder Beitrag die kollektive Intelligenz und den Wert der Plattform erhöht. Im Laufe der Zeit glauben wir, dass die wertvollsten Anwendungsfälle von Agent Platform aus unserer florierenden GitLab-Community kommen werden.\n\n![AI Catalog](https://res.cloudinary.com/about-gitlab-com/image/upload/v1752685501/awdwx08udwrxgvcpmssb.png \"AI Catalog\")\n\n## Heute verfügbar in GitLab Duo Agent Platform in Public Beta\n\nDie Public Beta von GitLab Duo Agent Platform ist jetzt für Premium- und Ultimate-Kund(inn)en mit diesen Funktionen verfügbar:\n\n**Software-Entwicklungs-Flow:** Unser erster Flow orchestriert Agenten beim Sammeln umfassenden Kontexts, beim Klären von Unklarheiten mit menschlichen Entwickler(inne)n und beim Ausführen strategischer Pläne, um präzise Änderungen an deiner Codebasis und deinem Repository vorzunehmen. Er nutzt dein gesamtes Projekt, einschließlich seiner Struktur, Codebasis und Historie, zusammen mit zusätzlichem Kontext wie GitLab-Issues oder Merge Requests, um die Produktivität der Entwickler(innen) zu steigern.\n\n**Neue verfügbare Agenten-Tools:** Agenten haben jetzt Zugriff auf mehrere Tools, um ihre Arbeit zu erledigen, darunter:\n\n* Dateisystem (Lesen, Erstellen, Bearbeiten, Dateien finden, Auflisten, Grep)\n* Befehlszeile ausführen*\n* Issues (Auflisten, Abrufen, Kommentare abrufen, Bearbeiten*, Erstellen*, Kommentare hinzufügen/aktualisieren*)\n* Epics (Abrufen, Kommentare abrufen)\n* MR (Abrufen, Kommentare abrufen, Diff abrufen, Erstellen, Aktualisieren)\n* Pipeline (Job-Logs, Pipeline-Fehler)\n* Projekt (Abrufen, Datei abrufen)\n* Commits (Abrufen, Auflisten, Kommentare abrufen, Diff abrufen)\n* Suche (Issue-Suche)\n* Secure (Schwachstellen auflisten)\n* Dokumentationssuche\n  *=Erfordert Benutzergenehmigung\n\n**GitLab Duo Agentic Chat in der IDE:** Duo Agentic Chat verwandelt die Chat-Erfahrung von einem passiven Q&A-Tool in einen aktiven Entwicklungspartner direkt in deiner IDE.\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1101953477?title=0&byline=0&portrait=0&badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"agentic-ai-launch-video_Updated V1\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n* **Iteratives Feedback und Chat-Verlauf:** Duo Agentic Chat unterstützt jetzt Chat-Verlauf und iteratives Feedback und verwandelt den Agenten in einen zustandsbehafteten, gesprächsfähigen Partner. Dies fördert Vertrauen und ermöglicht es Entwickler(inne)n, komplexere Aufgaben zu delegieren und korrigierende Anleitung zu bieten.\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1101743173?title=0&byline=0&portrait=0&badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"agentic-chat-history\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n* **Optimierte Delegation mit Slash-Befehlen:** Erweiterte, leistungsstärkere Slash-Befehle wie /explain, /tests und /include erstellen eine „Delegationssprache\" für schnelle und präzise Absichten. Der /include-Befehl ermöglicht die explizite Injektion von Kontext aus bestimmten Dateien, offenen Issues, Merge Requests oder Abhängigkeiten direkt in den Arbeitsspeicher des Agenten, macht den Agenten leistungsfähiger und lehrt Nutzer(innen), wie sie optimalen Kontext für qualitativ hochwertige Antworten bereitstellen.\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1101743187?title=0&byline=0&portrait=0&badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"include-agentic-chat-jc-voiceover\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n* **Personalisierung durch benutzerdefinierte Regeln:** Neue benutzerdefinierte Regeln ermöglichen es Entwickler(inne)n, das Agentenverhalten an individuelle und Teampräferenzen anzupassen, indem sie natürliche Sprache verwenden, zum Beispiel Entwicklungs-Styleguides. Dieser grundlegende Mechanismus formt die Persönlichkeit des Agenten zu einem personalisierten Assistenten und entwickelt sich zu spezialisierten Agenten basierend auf benutzerdefinierten Präferenzen und organisatorischen Richtlinien.\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1101743179?title=0&byline=0&portrait=0&badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"custom-rules-with-jc-voiceover\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n* **Unterstützung für GitLab Duo Agentic Chat in JetBrains IDE:** Um Entwickler(innen) dort zu treffen, wo sie arbeiten, haben wir die Unterstützung von Duo Agentic Chat auf die JetBrains-Familie von IDEs erweitert, einschließlich IntelliJ, PyCharm, GoLand und Webstorm. Dies ergänzt unsere bestehende Unterstützung für VS Code. Bestehende Nutzer(innen) erhalten automatisch agentische Funktionen, während neue Nutzer(innen) das Plugin vom JetBrains Marketplace installieren können.\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1101743193?title=0&byline=0&portrait=0&badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"jetbrains-support-jc-voiceover\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n* **MCP-Client-Unterstützung:** Duo Agentic Chat kann jetzt als MCP-Client fungieren und sich mit remote und lokal laufenden MCP-Servern verbinden.\n\nDiese Fähigkeit ermöglicht es dem Agenten, sich mit Systemen jenseits von GitLab wie Jira, ServiceNow und ZenDesk zu verbinden, um Kontext zu sammeln oder Aktionen durchzuführen. Jeder Service, der sich über MCP exponiert, kann jetzt Teil des Skillsets des Agenten werden. Der offizielle GitLab MCP-Server kommt bald!\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1101743202?title=0&byline=0&portrait=0&badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"McpDemo\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n* **GitLab Duo Agentic Chat in der GitLab Web-UI.** Duo Agentic Chat ist jetzt auch direkt in der GitLab Web-UI verfügbar. Dieser entscheidende Schritt entwickelt den Agenten von einem Coding-Assistenten zu einem echten DevSecOps-Agenten, da er Zugriff auf reichhaltigen Nicht-Code-Kontext erhält, wie Issues und Merge-Request-Diskussionen, was es ihm ermöglicht, das „Warum\" hinter der Arbeit zu verstehen. Über das Verständnis des Kontexts hinaus kann der Agent Änderungen direkt aus der Web-UI vornehmen, wie z.B. automatisch Issue-Status aktualisieren oder Merge-Request-Beschreibungen bearbeiten.\n\n## Bald verfügbar in GitLab Duo Agent Platform\n\nIn den kommenden Wochen werden wir neue Funktionen für Duo Agent Platform veröffentlichen, einschließlich weiterer sofort einsatzbereiter Agenten und Flows. Diese werden die Plattform in die GitLab-Erfahrung bringen, die du heute liebst, und noch größere Anpassung und Erweiterbarkeit ermöglichen, was die Produktivität für unsere Kund(inn)en verstärkt:\n\n![GitLab Duo Agent Platform public beta roadmap](https://res.cloudinary.com/about-gitlab-com/image/upload/v1752685275/hjbe9iiu2ydp9slibsc2.png \"GitLab Duo Agent Platform public beta roadmap\")\n\n* **Integrierte GitLab-Erfahrung:** Aufbauend auf den in 18.2 verfügbaren IDE-Erweiterungen erweitern wir Agenten und Flows innerhalb der GitLab-Plattform. Diese tiefere Integration wird die Möglichkeiten erweitern, wie du synchron und asynchron mit Agenten zusammenarbeiten kannst. Du wirst in der Lage sein, Issues direkt an Agenten zuzuweisen, sie in GitLab Duo Chat zu @erwähnen und sie nahtlos von überall in der Anwendung aufzurufen, während die MCP-Konnektivität von deinem bevorzugten Entwicklungstool beibehalten wird. Diese native Integration verwandelt Agenten in echte Entwicklungsteammitglieder, die in ganz GitLab zugänglich sind.\n* **Agenten-Observability:** Da Agenten autonomer werden, bauen wir umfassende Sichtbarkeit in ihre Aktivität auf, während sie durch Flows fortschreiten, was es dir ermöglicht, ihre Entscheidungsprozesse zu überwachen, Ausführungsschritte zu verfolgen und zu verstehen, wie sie deine Entwicklungsherausforderungen interpretieren und darauf reagieren. Diese Transparenz im Agentenverhalten schafft Vertrauen und Zuversicht, während es dir ermöglicht, Workflows zu optimieren, Engpässe zu identifizieren und sicherzustellen, dass Agenten genau wie beabsichtigt funktionieren.\n* **KI-Katalog:** In Anerkennung der Tatsache, dass großartige Lösungen aus Community-Innovation entstehen, werden wir bald die Public Beta unseres KI-Katalogs einführen - ein Marktplatz, der es dir ermöglicht, Duo Agent Platform mit spezialisierten Agenten und Flows zu erweitern, die von GitLab und im Laufe der Zeit von der breiteren Community stammen. Du wirst in der Lage sein, diese Lösungen schnell in GitLab bereitzustellen und dabei den Kontext über deine Projekte und Codebasis hinweg zu nutzen.\n* **Knowledge Graph:** Unter Nutzung von GitLabs einzigartigem Vorteil als System of Record für Quellcode und seinen umgebenden Kontext bauen wir einen umfassenden Knowledge Graph auf, der nicht nur Dateien und Abhängigkeiten über die Codebasis hinweg abbildet, sondern diese Karte auch für Nutzer(innen) navigierbar macht, während KI-Abfragezeiten beschleunigt und die Genauigkeit erhöht wird. Diese Grundlage ermöglicht es GitLab Duo-Agenten, Beziehungen über deine gesamte Entwicklungsumgebung hinweg schnell zu verstehen, von Code-Abhängigkeiten bis zu Deployment-Mustern, und ermöglicht schnellere und präzisere Antworten auf komplexe Fragen.\n\n![GitLab Duo Agent Platform Knowledge Graph](https://res.cloudinary.com/about-gitlab-com/image/upload/v1752685367/n0tvfgorchuhrronic3j.png \"GitLab Duo Agent Platform Knowledge Graph\")\n\n* **Agenten und Flows erstellen und bearbeiten:** Im Verständnis, dass jede Organisation einzigartige Workflows und Anforderungen hat, entwickeln wir leistungsstarke Funktionen zur Erstellung und Bearbeitung von Agenten und Flows, die eingeführt werden, wenn der KI-Katalog reift. Du wirst in der Lage sein, Agenten und Flows zu erstellen und zu modifizieren, damit sie genau so funktionieren, wie deine Organisation arbeitet, und eine tiefe Anpassung über Duo Agent Platform hinweg liefern, die qualitativ hochwertigere Ergebnisse und erhöhte Produktivität ermöglicht.\n\n![AI Catalog](https://res.cloudinary.com/about-gitlab-com/image/upload/v1752684938/fruwqcqvvrx8gmkz5u0v.png \"AI Catalog\")\n\n* **Offizieller GitLab MCP-Server:** In der Erkenntnis, dass Entwickler(innen) über mehrere Tools und Umgebungen hinweg arbeiten, bauen wir einen offiziellen GitLab MCP-Server, der es dir ermöglicht, über MCP auf alle deine Agenten und Flows zuzugreifen. Du wirst in der Lage sein, dich mit deinen Agenten und Flows von überall aus zu verbinden und zusammenzuarbeiten, wo MCP unterstützt wird, einschließlich beliebter Tools wie Claude Code, Cursor, Copilot und Windsurf, was eine nahtlose KI-Zusammenarbeit unabhängig von deiner bevorzugten Entwicklungsumgebung ermöglicht.\n* **GitLab Duo Agent Platform CLI:** Unsere kommende CLI ermöglicht es dir, Agenten aufzurufen und Flows auf der Befehlszeile auszulösen, wobei GitLabs reichhaltiger Kontext über den gesamten Software-Entwicklungslebenszyklus genutzt wird - von Code-Repositories und Merge Requests bis zu CI/CD-Pipelines und Issue-Tracking.\n\n## Jetzt loslegen\n\n* **GitLab Premium- und Ultimate-Kund(inn)en** in GitLab.com- und selbstverwalteten Umgebungen, die GitLab 18.2 verwenden, können Duo Agent Platform sofort nutzen (Beta- und experimentelle Funktionen für GitLab Duo [müssen aktiviert sein](https://docs.gitlab.com/user/gitlab_duo/turn_on_off/#turn-on-beta-and-experimental-features)).\n* Nutzer(innen) sollten die [VS Code-Erweiterung](https://marketplace.visualstudio.com/items?itemName=GitLab.gitlab-workflow) oder das [JetBrains IDEs-Plugin](https://plugins.jetbrains.com/plugin/22857-gitlab) herunterladen und unserem [Leitfaden zur Verwendung von GitLab Duo Agentic Chat](https://docs.gitlab.com/user/gitlab_duo_chat/agentic_chat/#use-agentic-chat) folgen, einschließlich der Duo Chat [Slash-Befehle](https://docs.gitlab.com/user/gitlab_duo_chat/examples/#gitlab-duo-chat-slash-commands).\n\n**Neu bei GitLab?** Jeder kann an unserer kommenden (englischsprachigen) [Technischen Demo teilnehmen, um GitLab Duo Agent Platform](https://page.gitlab.com/webcasts-jul16-gitlab-duo-agentic-ai-emea-amer.html) in Aktion zu sehen. Um GitLab Duo Agent Platform selbst praktisch zu erleben, melde dich noch heute für eine [kostenlose Testversion](https://gitlab.com/-/trials/new?glm_content=default-saas-trial&glm_source=about.gitlab.com%2Fsales%2F) an.\n\n\u003Csmall>*Dieser Blogbeitrag enthält „zukunftsgerichtete Aussagen\" im Sinne von Abschnitt 27A des Securities Act von 1933 in der geänderten Fassung und Abschnitt 21E des Securities Exchange Act von 1934. Obwohl wir glauben, dass die in den zukunftsgerichteten Aussagen in diesem Blogbeitrag zum Ausdruck gebrachten Erwartungen angemessen sind, unterliegen sie bekannten und unbekannten Risiken, Unsicherheiten, Annahmen und anderen Faktoren, die dazu führen können, dass die tatsächlichen Ergebnisse oder Resultate wesentlich von den in den zukunftsgerichteten Aussagen ausgedrückten oder implizierten zukünftigen Ergebnissen oder Resultaten abweichen.*\n\n*Weitere Informationen zu Risiken, Unsicherheiten und anderen Faktoren, die dazu führen könnten, dass die tatsächlichen Ergebnisse und Resultate wesentlich von den in den zukunftsgerichteten Aussagen in diesem Blogbeitrag enthaltenen oder betrachteten abweichen, finden sich unter der Überschrift „Risikofaktoren\" und an anderer Stelle in den Einreichungen und Berichten, die wir bei der Securities and Exchange Commission einreichen. Wir übernehmen keine Verpflichtung, zukunftsgerichtete Aussagen zu aktualisieren oder zu überarbeiten oder über Ereignisse oder Umstände nach dem Datum dieses Blogbeitrags zu berichten oder das Eintreten unvorhergesehener Ereignisse widerzuspiegeln, es sei denn, dies ist gesetzlich vorgeschrieben.*\u003C/small>",{"featured":90,"template":682,"slug":1120},"gitlab-duo-agent-platform-public-beta","content:de-de:blog:gitlab-duo-agent-platform-public-beta.yml","Gitlab Duo Agent Platform Public Beta","de-de/blog/gitlab-duo-agent-platform-public-beta.yml","de-de/blog/gitlab-duo-agent-platform-public-beta",{"_path":1126,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1127,"content":1133,"config":1142,"_id":1144,"_type":13,"title":1145,"_source":15,"_file":1146,"_stem":1147,"_extension":18},"/de-de/blog/gitlab-duo-chat-gets-agentic-ai-makeover",{"ogTitle":1128,"schema":1129,"ogImage":1130,"ogDescription":1131,"ogSiteName":695,"noIndex":6,"ogType":696,"ogUrl":1132,"title":1128,"canonicalUrls":1132,"description":1131},"GitLab Duo Chat: Der neue KI-Assistent erklärt","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"GitLab Duo Chat wird jetzt zum agentischen KI-Assistenten \",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Torsten Linz\"}],\n        \"datePublished\": \"2025-05-29\",\n      }\n                  ","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099203/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%2820%29_2bJGC5ZP3WheoqzlLT05C5_1750099203484.png","Wir zeigen dir, was sich hinter dem GitLab Duo Chat verbirgt. ✓ Hintergrund ✓ Funktionen ✓ Anwendung ✓ Demonstration ➤ GitLab Duo Chat entdecken!","https://about.gitlab.com/blog/gitlab-duo-chat-gets-agentic-ai-makeover",{"heroImage":1130,"body":1134,"authors":1135,"updatedDate":1137,"date":1138,"title":1139,"tags":1140,"description":1141,"category":703},"Generative KI-Chat-Assistenten sind in kurzer Zeit zum Standard in der\nSoftwareentwicklung geworden und helfen dabei, Code zu erstellen und zu\nverbessern. Stell dir nun vor, dein Chat-Assistent könnte die Artefakte\ndeines gesamten Entwicklungsprozesses und nicht nur deinen Code verstehen.\n\n\nWas 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?\n\n\n**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 [experimenteller Release (nur in englischer Sprache)](https://docs.gitlab.com/policy/development_stages_support/#experiment) verfügbar ist.** \n\n\nGitLab Duo Agentic Chat ist für alle GitLab.com-Benutzer(innen) mit der Workflow-Erweiterung von GitLab in VS Code verfügbar.\n\n\nMit 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:\n\n\n* **Autonom feststellen**, welche Informationen er braucht, um deine Fragen zu beantworten\n\n* **Eine Reihe von Vorgängen ausführen**, um diese Informationen aus verschiedenen Quellen zu sammeln\n\n* **Umfassende Antworten formulieren**, indem er Einblicke aus deinem gesamten Projekt kombiniert\n\n* **Dateien erstellen und bearbeiten**, um dir dabei zu helfen, Lösungen zu implementieren.\n\n\nDabei bleibt stets der Mensch als Entwickler(in) involviert.\n\n\nAgentic Chat basiert auf der Architektur von Duo Workflow, der derzeit in der [privaten Beta-Version verfügbar ist](https://about.gitlab.com/de-de/blog/gitlab-duo-workflow-enterprise-visibility-and-control-for-agentic-ai/). 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. \n\n\n**Anwendungsfälle für GitLab Duo Agentic Chat**\n\n\nHier findest du einige praktische und häufige Anwendungsfälle für Agentic Chat:\n\n\n* Arbeite dich schneller in neue Projekte ein, indem die KI dir hilft, mit einer neuen Codebase vertraut zu werden.\n\n* 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.\n\n* Wenn du Änderungen vornehmen möchtest, kann Agentic Chat die Implementierung übernehmen, indem er Dateien übergreifend über dein Projekt erstellt und bearbeitet.\n\n* 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.\n\n\n![Agentic Chat – Beispiel](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099210/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750099210429.png)\n\n\n\u003Ccenter>\u003Ci>Agentic Chat bearbeitet Code\u003C/i>\u003C/center>\n\n\n## Vom Lernen zum Bereitstellen: eine komplette Workflow-Demonstration in vier Schritten\n\n\nUm 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:\n\n\n\u003C!-- blank line -->\n\n\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/uG9-QLAJrrg?si=kaOhYylMIaWkIuG8j\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\n\u003C!-- blank line -->\n\n\n**Schritt 1: Das Projekt verstehen**\n\n\nAnstatt manuell die Dateien und die Dokumentation zu durchforsten, kannst du einfach folgenden Prompt in Agentic Chat eingeben:\n\n\n```unset\n\nI am new to this project. Could you read the project structure and explain it to me?\n\n```\n\n\n(Ich kenne dieses Projekt noch nicht. Lies dir bitte die Projektstruktur durch und erkläre sie mir.)\n\n\nAgentic Chat bietet dir dann wir folgt einen umfassenden Projektüberblick:\n\n\n* Er sieht sich die Verzeichnisstruktur an.\n\n* Er liest README-Dateien und die Dokumentation.\n\n* Er identifiziert wichtige Komponenten und Anwendungen.\n\n\n**Schritt 2: Deine zugewiesene Aufgabe verstehen**\n\n\nNun musst du deine jeweilige Aufgabe verstehen. Gib dazu den folgenden Prompt ein:\n\n\n```unset\n\nI have been assigned Issue 1119. Could you help me understand this task, specifically where do I need to apply the refactoring?\n\n```\n\n\n(Mir wurde das Ticket 1119 zugewiesen. Hilf mir bitte, diese Aufgabe zu verstehen. Wo genau muss ich das Refactoring durchführen?)\n\n\nAgentic Chat erklärt dir die Aufgabe und schlägt einen Refactoring-Ansatz vor, indem er wie folgt vorgeht:\n\n\n* Er ruft die Details des Tickets vom GitLab-Remote-Server ab und analysiert sie.\n\n* Er untersucht relevante Projektdateien.\n\n* Er identifiziert die spezifischen Orte, für die Änderungen nötig sind.\n\n\n**Schritt 3: Die Lösung implementieren**\n\n\nAnstatt die Arbeit manuell zu erledigen, kannst du folgende Frage stellen:\n\n\n```unset\n\nCould you make the edits for me? Please start with steps one, two, three.\n\n```\n\n\n(Kannst du die Bearbeitungen für mich vornehmen? Bitte beginne mit den Schritten eins, zwei und drei.)\n\n\nAgentic Chat geht dann so vor:\n\n\n* Er erstellt, wenn nötig, neue Verzeichnisse und Dateien.\n\n* Er extrahiert und refaktorisiert Code an mehreren Stellen.\n\n* Er stellt die Konsistenz übergreifend über alle geänderten Dateien sicher.\n\n* Er erstelle eine Übersicht über alle vorgenommenen Änderungen.\n\n\n**Schritt 4: Vollständigkeit überprüfen**\n\n\nNachdem nun abschließend dein Merge Request erstellt wurde, kannst du deine Arbeit überprüfen:\n\n\n```unset\n\nDoes my MR fully address Issue 1119?\n\n```\n\n\n(Löst mein MR das Ticket 1119 vollständig?)\n\n\nAgentic Chat bestätigt nun, dass alle Anforderungen erfüllt werden, indem er sowohl deinen Merge Request als auch das ursprüngliche Ticket analysiert.\n\n\n## Probiere es jetzt aus und teile dein Feedback\n\n\nGitLab 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 [Einrichtungsdokumentation (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/gitlab_duo_chat/agentic_chat/) findest du die Voraussetzungen und Konfigurationsschritte.\n\n\nDa 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. **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 [diesem Ticket](https://gitlab.com/gitlab-org/gitlab/-/issues/542198) mit uns.**\n\n\n## Wie geht es weiter?\n\n\nUnser 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.\n\n\n> Möchtest du autonome Entwicklungsunterstützung erleben, bist aber noch kein(e) GitLab-Kund(in)? Probiere Agentic Chat jetzt im Rahmen [einer kostenlosen Testversion von GitLab Ultimate mit Duo Enterprise](https://about.gitlab.com/de-de/free-trial/) aus und gestalte die Zukunft der KI-basierten Entwicklung mit. Folge diesen [Einrichtungsschritten für VS Code (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/gitlab_duo_chat/agentic_chat/#use-agentic-chat-in-vs-code).\n\n\n***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.***\n\n\n## Mehr erfahren\n\n\n* [GitLab Duo Workflow: Transparenz und Kontrolle für agentische KI auf Enterprise-Niveau](https://about.gitlab.com/de-de/blog/gitlab-duo-workflow-enterprise-visibility-and-control-for-agentic-ai/)\n\n* [Was ist agentische KI?](https://about.gitlab.com/de-de/topics/agentic-ai/)\n\n* [Leitfäden und Ressourcen zu agentischer KI (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/agentic-ai-guides-and-resources/)\n",[1136],"Torsten Linz","2025-06-04","2025-05-29","GitLab Duo Chat: Entdecke den neuen KI-Assistenten",[678,1113,9,707,677,705],"Unser neuer GitLab Duo Chat, der derzeit ein experimenteller Release ist, hilft Entwickler(inne)n, sich in Projekte einzuarbeiten, Aufgaben zu verstehen, Änderungen umzusetzen und mehr.",{"slug":1143,"featured":90,"template":682},"gitlab-duo-chat-gets-agentic-ai-makeover","content:de-de:blog:gitlab-duo-chat-gets-agentic-ai-makeover.yml","Gitlab Duo Chat Gets Agentic Ai Makeover","de-de/blog/gitlab-duo-chat-gets-agentic-ai-makeover.yml","de-de/blog/gitlab-duo-chat-gets-agentic-ai-makeover",{"_path":1149,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1150,"content":1156,"config":1163,"_id":1165,"_type":13,"title":1166,"_source":15,"_file":1167,"_stem":1168,"_extension":18},"/de-de/blog/gitlab-duo-enterprise-is-now-available",{"title":1151,"description":1152,"ogTitle":1151,"ogDescription":1152,"noIndex":6,"ogImage":1153,"ogUrl":1154,"ogSiteName":695,"ogType":696,"canonicalUrls":1154,"schema":1155},"GitLab Duo Enterprise ist jetzt verfügbar","Mit Gitlab Duo Enterprise haben Unternehmen jetzt einen durchgängigen KI-Partner für schnellere, sicherere Softwareentwicklung! Erfahre, wie GitLab Duo Enterprise den gesamten DevSecOps-Lebenszyklus unterstützt.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749665660/Blog/Hero%20Images/Untitled__1800_x_945_px_.png","https://about.gitlab.com/blog/gitlab-duo-enterprise-is-now-available","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"GitLab Duo Enterprise ist jetzt verfügbar\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"David DeSanto, Chief Product Officer, GitLab\"}],\n        \"datePublished\": \"2024-09-03\",\n      }\n                  ",{"title":1151,"description":1152,"authors":1157,"heroImage":1153,"date":1159,"body":1160,"category":703,"tags":1161,"updatedDate":1162},[1158],"David DeSanto, Chief Product Officer, GitLab","2024-09-03","[GitLab Duo Enterprise](https://about.gitlab.com/de-de/gitlab-duo/) ist der durchgängige KI-Partner, der für den gesamten Software-Entwicklungsprozess konzipiert wurde. Die leistungsstarke Suite aus KI-Tools steigert die Produktivität der Entwickler(innen), verbessert die Sicherheit, optimiert die Zusammenarbeit und beschleunigt deine DevSecOps-Prozesse.\n\nDie wichtigsten Funktionen auf einen Blick:\n- Intelligente Codeunterstützung in über 25 Programmiersprachen\n- KI-basierte Details und Lösungen zu Sicherheitslücken\n- Automatisierte Testgenerierung und Ursachenanalyse\n- Verbesserte Teamzusammenarbeit mit KI-gesteuerten Zusammenfassungen\n- ROI-Quantifizierung durch ein KI-Impact-Dashboard\n\n## Warum wir GitLab Duo Enterprise entwickelt haben \n\nUnternehmen, die versuchen, bessere Software schneller bereitzustellen und so einen höheren Nutzen für Kund(inn)en zu schaffen, stehen meist vor erheblichen Herausforderungen, die ihren Fortschritt verlangsamen. [Unsere Forschung](http://about.gitlab.com/de-de/developer-survey/2024/ai) zeigt, dass 95 % der Unternehmen KI gerade entweder evaluieren oder bereits im Lebenszyklus der Softwareentwicklung einsetzen. 55 % der Befragten gaben jedoch an, dass sie den Einsatz von KI für die Softwareentwicklung für zu riskant halten.\n\nDie Skepsis der Unternehmen basiert auf suboptimalen Erfahrungen in Zusammenhang mit der Produktivität der Entwickler(innen), steigenden Sicherheits- und Compliance-Anforderungen, ineffizienter Zusammenarbeit zwischen Teams und Schwierigkeiten bei der Bewertung des ROI von KI-Technologieinvestitionen. GitLab Duo Enterprise geht direkt auf diese Herausforderungen ein und ist ein sicherer, effizienter und leistungsstarker KI-Partner für deine Entwicklungsteams.\n\n**Sehen wir uns an, wie GitLab Duo Enterprise die Art und Weise verändern kann, wie dein Unternehmen Software entwickelt und bereitstellt.**\n\n## Steigere die Produktivität deiner Entwickler(innen) mit intelligenter Codeunterstützung\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1004252678?h=83f35171b6&badge=0&badge=0&amp?autoplay=1&loop=1&autopause=0&background=1&muted=1\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"Code Suggestions clip\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\u003Cp>\u003C/p>\n\nEine der Haupthürden in der Softwareentwicklung sind routinemäßige Programmieraufgaben, die sehr zeitaufwendig sind. Hier schafft Gitlab Duo Enterprise Abhilfe – denn mit den folgenden Tools erledigst du die wichtigsten Aufgaben jetzt deutlich schneller:\n\n- __Codevorschläge__ in mehr als 25 Programmiersprachen. Dieses KI-basierte Tool beschleunigt die Codeerstellung, verbessert die Codequalität und reduziert den Zeitaufwand für Boilerplate-Aufgaben.\n\nAber es geht nicht nur darum, neuen Code zu schreiben. \n\n- Die __Code-Erklärung__ von GitLab Duo Enterprise ermöglicht es Entwickler(inne)n, komplexen oder unbekannten Code schnell zu verstehen, während \n\n- __Code-Refactoring__ es Entwickler(inne)n ermöglicht, [bestehenden Code zu verbessern und zu modernisieren](https://about.gitlab.com/blog/refactor-code-into-modern-languages-with-ai-powered-gitlab-duo/). \n\n- __Testgenerierung__ automatisiert die Erstellung umfassender Unit-Tests. Das Ergebnis? Entwickler(innen) können sich auf hochwertige Aufgaben konzentrieren, die Innovationen vorantreiben und zu schnelleren Entwicklungszyklen und verbesserter Softwarequalität führen.\n\n> Erfahre, wie [das europäische Technologieunternehmen Cube](https://about.gitlab.com/de-de/customers/cube/) Codevorschläge, Testgenerierung und andere Funktionen von GitLab Duo einsetzt, um Geschwindigkeit und Effizienz zu verbessern. \n\n## Verbessere die Zusammenarbeit und Kommunikation im Team\n\nEine effektive Zusammenarbeit ist ausschlaggebend für eine erfolgreiche Softwareentwicklung. Allerdings stehen dem Erfolg im Team oft langwierige Diskussionen, komplexe Merge Requests und zeitaufwändige Code Reviews im Weg. GitLab Duo Enterprise geht mit seinen Zusammenfassungs- und Vorlagen-Tools auf diese Herausforderungen ein:\n- __Zusammenfassung von Diskussionen:__ Ermöglicht es Teammitgliedern, einen schnellen Überblick über die wichtigsten Punkte umfangreicher Konversationen in Tickets zu erhalten.\n- __Merge-Request-Zusammenfassungen:__ Verschafft allen Beteiligten einen klaren, prägnanten Überblick über die vorgeschlagenen Änderungen.\n- __Zusammenfassungen der Code Reviews:__ Optimiert den Review-Prozess, um bessere Übergaben zwischen Autor(inn)en und Prüfer(inne)n zu ermöglichen.\n\nDurch eine klarere Kommunikation und schnellere Entscheidungsfindung hilft GitLab Duo Enterprise Teams, effizienter zu arbeiten und schneller Ergebnisse zu liefern.\n\n## Optimiere die Problembehandlung und Fehlersuche\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1004252688?h=fc6c048bfd&badge=0&badge=0&amp?autoplay=1&loop=1&autopause=0&background=1&muted=1\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"Root Cause Analysis clip\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\u003Cp>\u003C/p>\n\nWenn Entwicklungspipelines fehlschlagen, können die Auswirkungen auf die Projektzeitpläne erheblich sein. Die Grundursachenanalyse von GitLab Duo Enterprise schafft hier entscheidende Abhilfe. Durch die automatische Analyse von Protokollen und detaillierte Erklärungen zu den Ausfällen sowie vorgeschlagenen potenziellen Fixes reduziert die Grundursachenanalyse die Zeit, die für die Problembehandlung aufgewendet wird, deutlich.\n\nDie Vorteile gehen über die reine Zeitersparnis hinaus. Mit [schnelleren Lösungen für CI/CD-Build-Probleme](https://about.gitlab.com/de-de/blog/developing-gitlab-duo-blending-ai-and-root-cause-analysis-to-fix-ci-cd/) können Teams die Dynamik aufrechterhalten, Ausfallzeiten reduzieren und letztendlich Softwareupdates häufiger und zuverlässiger bereitstellen.\n\n## Erhöhe die Sicherheit über den gesamten Entwicklungslebenszyklus\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1004252706?h=73e568b89c&badge=0&badge=0&amp?autoplay=1&loop=1&autopause=0&background=1&muted=1\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"Vulnerability Explanation and Resolution clip\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\u003Cp>\u003C/p>\n\nCybersicherheitsbedrohungen sind allgegenwärtig, daher ist robuste Anwendungssicherheit unerlässlich. GitLab Duo Enterprise reagiert auf diese Herausforderung mit den Funktionen __Erläuterung von Sicherheitslücken__ und __Behebung von Sicherheitslücken__. Diese KI-basierten Tools helfen [Entwickler(inne)n, Sicherheitslücken vollständig zu verstehen](https://about.gitlab.com/blog/developing-gitlab-duo-use-ai-to-remediate-security-vulnerabilities/), und generieren dann automatisch Merge Requests mit vorgeschlagenen Fixes.\n\n## Quantifiziere die KI-Auswirkungen für die strategische Entscheidungsfindung\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1004252663?h=d35106288b&badge=0&amp?autoplay=1&loop=1&autopause=0&background=1&muted=1\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"AI Impact Dashboard clip\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\u003Cp>\u003C/p>\n\nEs ist entscheidend, den ROI von Technologieinvestitionen zu demonstrieren. In GitLab Duo Enterprise ist dies direkt mit dem __KI-Impact-Dashboard__ möglich. Dieses Analysetool, das auf der Wertstromanalyse und DORA4-Metriken aufbaut, bietet übersichtliche Kennzahlen zu Verbesserungen der Bearbeitungszeit und einer höheren Häufigkeit der Bereitstellung. Dadurch können Unternehmen die greifbaren Vorteile der KI-Einführung in ihren Entwicklungsprozessen quantifizieren.\n\nDurch Einblicke in die Korrelation der KI-Nutzung mit wichtigen Produktivitätsmetriken ermöglicht das [KI-Impact-Dashboard](https://about.gitlab.com/de-de/blog/developing-gitlab-duo-ai-impact-analytics-dashboard-measures-the-roi-of-ai/) Führungskräften, datengesteuerte Entscheidungen über die Ressourcenzuweisung und strategische Technologieinvestitionen zu treffen.\n\n## Erlebe die Zukunft KI-gesteuerter DevSecOps\n\nNeben der Vorstellung von GitLab Duo Enterprise möchten wir auch darauf hinweisen, dass GitLab als Leader im ersten [Gartner® Magic Quadrant™ für KI-Programmierassistenten](https://about.gitlab.com/de-de/gartner-mq-ai-code-assistants/) ausgezeichnet wurde – und das freut uns wirklich sehr. Diese Auszeichnung unterstreicht, wie intensiv wir an KI-Lösungen arbeiten, die einen echten kommerziellen Mehrwert bieten.\n\nDie Zukunft der Softwareentwicklung ist da und wird von KI angetrieben. Wir helfen dir dabei, intelligente, skalierbare KI über den gesamten DevSecOps-Lebenszyklus hinweg zu integrieren, damit du deinen Kund(inn)en schneller Ergebnisse liefern kannst.\n\n> [Lege jetzt mit GitLab Duo Enterprise los und teste es kostenlos!](https://about.gitlab.com/solutions/gitlab-duo-pro/sales/?type=free-trial&toggle=gitlab-duo-pro)\n",[678,677,707,9,1113],"2024-09-23",{"slug":1164,"featured":90,"template":682},"gitlab-duo-enterprise-is-now-available","content:de-de:blog:gitlab-duo-enterprise-is-now-available.yml","Gitlab Duo Enterprise Is Now Available","de-de/blog/gitlab-duo-enterprise-is-now-available.yml","de-de/blog/gitlab-duo-enterprise-is-now-available",{"_path":1170,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1171,"content":1177,"config":1183,"_id":1185,"_type":13,"title":1186,"_source":15,"_file":1187,"_stem":1188,"_extension":18},"/de-de/blog/gitlab-duo-self-hosted-enterprise-ai-built-for-data-privacy",{"ogTitle":1172,"schema":1173,"ogImage":1174,"ogDescription":1175,"ogSiteName":695,"noIndex":6,"ogType":696,"ogUrl":1176,"title":1172,"canonicalUrls":1176,"description":1175},"GitLab Duo Self-Hosted: Enterprise-KI für mehr Datenschutz","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"GitLab Duo Self-Hosted: Enterprise-KI für mehr Datenschutz\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Susie Bitters\"},{\"@type\":\"Person\",\"name\":\"Aathira Nair\"}],\n        \"datePublished\": \"2025-02-27\",\n      }\n                  ","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097840/Blog/Hero%20Images/Blog/Hero%20Images/Self-Hosted%201800x945_1dL1II2ITh2PteObA9DBLD_1750097839679.png","Kund(inn)en in regulierten Branchen können GitLab Duo jetzt auf Self-Managed-Infrastruktur bereitstellen und so leistungsfähige generative KI nutzen, ohne dabei die Datenresidenz und Datenschutzbedenken über Bord werfen zu müssen.","https://about.gitlab.com/blog/gitlab-duo-self-hosted-enterprise-ai-built-for-data-privacy",{"title":1172,"description":1175,"authors":1178,"heroImage":1174,"date":1180,"body":1181,"category":703,"tags":1182},[946,1179],"Aathira Nair","2025-02-27","Wir freuen uns, dass GitLab Duo Self-Hosted für GitLab Duo Code Suggestions und GitLab Chat jetzt allgemein verfügbar ist. Als optionale Funktion für Self-Managed-Kund(inn)en mit einem Abonnement von GitLab Duo Enterprise unterstützt GitLab Duo Self-Hosted eine flexible Bereitstellung auf mehreren Plattformen, darunter auf lokaler Infrastruktur, in privaten Clouds und in sicheren Cloud-Umgebungen über AWS Bedrock und Azure OpenAI. Mit GitLab Duo Self-Hosted können Teams mit KI-Unterstützung innovativ sein und gleichzeitig die Kontrolle über sensible Daten und geistiges Eigentum behalten.Sicherheitsbedenken stellen ein großes Hindernis für die Einführung von KI in regulierten Branchen dar. \n\nIn unserer [globalen DevSecOps-Umfrage](http://about.gitlab.com/de-de/developer-survey/2024/ai) gab mehr als die Hälfte der Befragten an, dass die Einführung von KI in den Software-Entwicklungsprozess riskant sei. Mit [GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/) bieten wir Unternehmen nun eine Möglichkeit, sicherere Software dank in den gesamten Software-Entwicklungsprozess integrierte KI schneller bereitzustellen.GitLab Duo Self-Hosted weitet die verfügbaren KI-Funktionen von GitLab Duo auf Unternehmen mit strengen Datenschutzanforderungen aus und bietet sowohl bei der Auswahl der für die KI verwendeten großen Sprachmodelle (LLM) als auch bei den Bereitstellungsoptionen mehr Flexibilität. Zu den Erstanwender(inne)n von GitLab Duo Self-Hosted zählen Unternehmen im öffentlichen Bereich und in regulierten Branchen, z. B. im Bereich der Finanzdienstleistungen, im Automobilsektor und im Gesundheitswesen. Diese Unternehmen möchten KI als Wettbewerbsvorteil nutzen, indem sie KI-basierte Entwicklungstools in ihre Umgebungen integrieren und gleichzeitig Sicherheitsteams die Kontrolle bieten, die sie brauchen.Eine US-Regierungsbehörde berichtet: „Nachdem wir GitLab als Eckpfeiler unserer behördenweiten DevSecOps-Plattform ausgewählt hatten, entschieden wir uns dafür, GitLab Duo Self-Hosted zu verwenden, um die Funktionen unserer Software Factory weiter zu verbessern. Die Möglichkeit, GitLab Duo in Air-Gapped-Umgebungen einzusetzen, sowie die granulare Kontrolle über unsere Daten war für die Bereitstellung sicherer KI-basierter Funktionen von entscheidender Bedeutung. Dieser einheitliche Ansatz vereinfacht unseren Workflow und stärkt die Sicherheit, sodass wir mit KI eine höhere Produktivität erzielen und gleichzeitig die strengen Compliance-Anforderungen erfüllen können.“ \n\n![Modelle von GitLab Duo Self-Hosted](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097848/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750097848329.png)\n\n## Sichere KI-Bereitstellungen entwickeln\n\nMit GitLab Duo Self-Hosted können Funktionen von GitLab Duo genutzt werden, wobei eine kuratierte Auswahl an führenden KI-LLMs geboten wird, darunter von Anthropic, Mistral und OpenAI. Diese LLMs unterstützen GitLab derzeit:\n\n* Lokal: Mistral-Modelle mit der vLLM-Serving-Plattform  \n* AWS: Mistral und Anthropic Claude 3.5 Sonnet über AWS Bedrock  \n* Microsoft Azure: OpenAI-GPT-Modelle über Azure AI\n\nWir prüfen weitere Modelle, die in naher Zukunft unterstützt werden sollen. [Erfahre mehr über die von uns unterstützten LLMs.](https://docs.gitlab.com/ee/administration/self_hosted_models/supported_models_and_hardware_requirements.html#approved-llms)\n\nZu den Bereitstellungsoptionen von GitLab Duo Self-Hosted gehören lokale Installationen, die auf dem Open-Source-vLLM-Framework basieren, sowie Bereitstellungen in privaten Clouds über Dienste wie AWS Bedrock und Microsoft Azure AI. Diese Flexibilität hilft Unternehmen, KI-Lösungen zu nutzen, die ihren einzigartigen Sicherheits-, Compliance- und Performance-Anforderungen entsprechen.\n\n> **Von 18 auf 3 Monate: So beschleunigt die Deutsche Telekom ihre Releases mit GitLab** 13.000 Entwickler(innen) arbeiten effizienter zusammen und bringen Produkte 6x schneller auf den Markt – erfahre, wie GitLab Ultimate die DevSecOps-Transformation vorantreibt, Silos aufbricht und Sicherheit in den Entwicklungsprozess bringt. [Erfolgsstory lesen](https://about.gitlab.com/de-de/customers/deutsche-telekom/)\n\n## KI-/ML-Implementierung vereinfachen\n\nDie KI-Abstraktionsschicht von GitLab Duo standardisiert und vereinfacht die Integration des ausgewählten LLM in eine Funktion, wodurch die Implementierung von KI-/ML-Technologien vereinfacht wird. So können Unternehmen die Einführung von KI optimieren und das Entwicklererlebnis verbessern, ohne sich mit der Komplexität der Integration und Wartung mehrerer Tools auseinandersetzen zu müssen.\n\n![KI-basierte Funktionen von GitLab Duo Self-Hosted](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097848/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097848330.png)\n\n## Kontrolle über sensible Daten behalten\n\nDurch die Isolierung deiner GitLab-Instanz, deines KI-Gateways und der LLMs in deiner eigenen Umgebung oder dem Land deiner Wahl sorgst du mit GitLab Duo Self-Hosted dafür, dass sensible Daten und geistiges Eigentum innerhalb deines festgelegten Bereichs bleiben. Die granulare Kontrolle über die Datenlokalität ermöglicht es, strenge Vorschriften zur Datenresidenz einzuhalten und gleichzeitig KI-Funktionen in einer sicheren Umgebung zu nutzen. Egal, ob du GitLab Duo Self-Hosted in einer reinen Air-Gapped-Umgebung mit vLLM nutzt oder eine unterstützte private Cloud verwendest: Du kannst alle Aspekte der Bereitstellung kontrollieren, um den geografischen Standort der Komponenten einzubeziehen. Indem du nicht von externen APIs abhängig bist und volle Transparenz in alle Anfrage- und Antwortprotokolle hast, ermöglicht es GitLab Duo Self-Hosted sogar äußerst streng regulierten Unternehmen, KI-Funktionen mit gutem Gewissen zu nutzen und die strengsten Compliance-Vorgaben einzuhalten.\n\n**Beginne eine interaktive Tour durch GitLab Self-Hosted, indem du auf das folgende Bild klickst:**\n\n[![Screenshot von der Tour durch GitLab Duo Self-Hosted](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097848/Blog/Content%20Images/Blog/Content%20Images/Screenshot_2025-02-20_at_7.00.34_AM_aHR0cHM6_1750097848332.png)](https://gitlab.navattic.com/gitlab-duo-self-hosted)\n\n## Lege jetzt mit GitLab Duo Self-Hosted los\n\nWenn du bereit bist, deine KI-Reise voranzutreiben und gleichzeitig auf Sicherheit und Datenschutz zu achten, [wende dich an uns](https://about.gitlab.com/de-de/sales/), um GitLab Duo Self-Hosted jetzt in deiner Umgebung einzurichten.",[678,9,707,677,1113],{"slug":1184,"featured":90,"template":682},"gitlab-duo-self-hosted-enterprise-ai-built-for-data-privacy","content:de-de:blog:gitlab-duo-self-hosted-enterprise-ai-built-for-data-privacy.yml","Gitlab Duo Self Hosted Enterprise Ai Built For Data Privacy","de-de/blog/gitlab-duo-self-hosted-enterprise-ai-built-for-data-privacy.yml","de-de/blog/gitlab-duo-self-hosted-enterprise-ai-built-for-data-privacy",{"_path":1190,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1191,"content":1197,"config":1206,"_id":1208,"_type":13,"title":1209,"_source":15,"_file":1210,"_stem":1211,"_extension":18},"/de-de/blog/gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws",{"ogTitle":1192,"schema":1193,"ogImage":1194,"ogDescription":1195,"ogSiteName":695,"noIndex":6,"ogType":696,"ogUrl":1196,"title":1192,"canonicalUrls":1196,"description":1195},"GitLab Duo mit Amazon Q: Entdecke die neue KI-Lösung","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"GitLab Duo mit Amazon Q: Die für AWS optimierte agentische KI ist jetzt allgemein verfügbar\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Emilio Salvador\"}],\n        \"datePublished\": \"2025-04-17\",\n      }\n                  ","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749659604/Blog/Hero%20Images/Screenshot_2024-11-27_at_4.55.28_PM.png","Wir zeigen dir, welche Funktionen GitLab Duo mit Amazon Q bietet. ✓ Hintergrund ✓ Funktion ✓ Anleitung ✓ Video ➤ GitLab Duo mit Amazon Q entdecken!","https://about.gitlab.com/blog/gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws",{"heroImage":1194,"body":1198,"authors":1199,"updatedDate":1201,"date":1202,"title":1192,"tags":1203,"description":1205,"category":703},"Wir freuen uns, heute die allgemeine Verfügbarkeit von **[GitLab Duo mit Amazon Q](https://about.gitlab.com/de-de/partners/technology-partners/aws/)** bekannt zu geben. Damit wird AWS-Kund(inn)en eine [agentenbasierte KI](https://about.gitlab.com/de-de/topics/agentic-ai/) während des gesamten Software-Entwicklungsprozesses zur Verfügung gestellt.\n\nGitLab 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.\n\nDa 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.\n\n> 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. **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.** Wir sind gespannt, wie unser Team sich mit dieser Technologie auf Innovationen konzentrieren und unsere digitale Transformation beschleunigen kann.\n\n**Osmar Alonso, DevOps Engineer bei Volkswagen Digital Solutions**\n\n## Agentische KI für komplexe Kundenumgebungen\n\nDurch 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:\n\n__Einheitliche Entwicklererfahrung für optimierte Entwicklung__\n\nEntwickler(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.\n\n__Eine Lösung für den gesamten Software-Entwicklungsprozess__\n\nCodevorschlä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.\n\n__Sichere Entwicklung mit Leitlinien auf Unternehmensebene__\n\nEnd-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.\n\n## So kannst du GitLab Duo mit Amazon Q nutzen\n\nHier sind fünf Anfangsbeispiele, die wir uns vorgenommen haben, um Teams dabei zu helfen, mit agentenbasierter KI schneller sichere Software zu entwickeln:\n\n1. **Schnellere Entwicklung von Funktionen** - 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.  \n2. **Modernisieren von älteren Anwendungen** - 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.\n3. **Verbessern der Qualitätssicherung** - 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.  \n4. **Optimieren der Code Review** - 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.  \n5. **Beheben von Sicherheitslücken** - 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.\n\nSieh dir GitLab Duo mit Amazon Q in Aktion an:\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1075753390?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"Technical Demo: GitLab Duo with Amazon Q\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n#### Profitiere noch heute von den Vorteilen von GitLab Duo mit Amazon Q\nDie 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. \n\nBesuche uns auf einem bevorstehenden [AWS Summit in einer Stadt in deiner Nähe](https://about.gitlab.com/de-de/events/aws-summits/) oder [wende dich an deine*n GitLab-Vertreter*in](https://about.gitlab.com/de-de/partners/technology-partners/aws/), um mehr über GitLab Duo mit Amazon Q zu erfahren.",[1200],"Emilio Salvador","2025-05-26","2025-04-17",[678,707,1204,677,9,1113],"AWS","Die umfassende KI-basierte DevSecOps-Plattform mit den umfangreichsten Cloud-Computing-Funktionen beschleunigt Entwicklungszyklen, erhöht die Automatisierung und verbessert die Codequalität.",{"slug":1207,"featured":90,"template":682},"gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws","content:de-de:blog:gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws.yml","Gitlab Duo With Amazon Q Agentic Ai Optimized For Aws","de-de/blog/gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws.yml","de-de/blog/gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws",{"_path":1213,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1214,"content":1220,"config":1226,"_id":1228,"_type":13,"title":1229,"_source":15,"_file":1230,"_stem":1231,"_extension":18},"/de-de/blog/gitlab-duo-workflow-enterprise-visibility-and-control-for-agentic-ai",{"ogTitle":1215,"schema":1216,"ogImage":1217,"ogDescription":1218,"ogSiteName":695,"noIndex":6,"ogType":696,"ogUrl":1219,"title":1215,"canonicalUrls":1219,"description":1218},"GitLab Duo Workflow: Transparenz und Kontrolle für agentische KI auf Enterprise-Niveau","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"GitLab Duo Workflow: Transparenz und Kontrolle für agentische KI auf Enterprise-Niveau\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Pini Wietchner\"}],\n        \"datePublished\": \"2025-02-24\",\n      }\n                  ","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749660174/Blog/Hero%20Images/Workflow_1800x945.png","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.","https://about.gitlab.com/blog/gitlab-duo-workflow-enterprise-visibility-and-control-for-agentic-ai",{"heroImage":1217,"body":1221,"authors":1222,"updatedDate":1201,"date":1224,"title":1215,"tags":1225,"description":1218,"category":703},"Setze dich ab heute auf die Warteliste für die [private Beta-Version von GitLab Duo Workflow](https://about.gitlab.com/de-de/gitlab-duo/agent-platform/): **eine agentische KI, die auf der umfassendsten DevSecOps-Plattform basiert.** GitLab Duo Workflow ist der nächste Schritt unserer KI-Roadmap und wird Entwicklungsteams innerhalb der IDE bei allen Aufgaben unterstützen – von Bootstrapping von Projekten bis hin zu Bereitstellungsprozessen, von der Fehlersuche bis hin zur teamübergreifenden Koordination.\n\nDabei nutzt GitLab Duo Workflow die Struktur der GitLab-Plattform für Zusammenarbeit, kontinuierliche Integration, kontinuierliche Bereitstellung, Sicherheit und Compliance, um Unternehmen dabei zu helfen, ihren Entwicklungsprozess mit KI-Tools zu beschleunigen.\n\nVerwende GitLab Duo Workflow, um:   \n* [ein neues Entwicklungsprojekt zu starten](#from-slow-project-setup-to-a-running-start)  \n* [Code zu modernisieren](#from-legacy-code-to-modern-applications)  \n* [kontextbezogene Aufgaben durchzuführen](#from-context-switching-toflow-state) \n* [eine Dokumentation zu erstellen](#from-stale-docs-to-dynamic-knowledge)\n* [die Testabdeckung zu verbessern](#from-patchy-to-comprehensive-testing) \n* und mehr.\n\nDas ist aber erst der Anfang. Mit dem einheitlichen Datenspeicher von GitLab gilt: Je mehr du GitLab verwendest, desto mehr Kontext hat GitLab Duo Workflow zu deinem Code, deinen Konfigurationen, deinen erkannten Sicherheitsrisiken und deinen Bereitstellungspraktiken. Das Ergebnis ist eine immer leistungsfähigere Entwicklungserfahrung, die auf dein Unternehmen zugeschnitten ist.\n\n> **Von 18 auf 3 Monate: So beschleunigt die Deutsche Telekom ihre Releases mit GitLab** 13.000 Entwickler(innen) arbeiten effizienter zusammen und bringen Produkte 6x schneller auf den Markt – erfahre, wie GitLab Ultimate die DevSecOps-Transformation vorantreibt, Silos aufbricht und Sicherheit in den Entwicklungsprozess bringt. [Erfolgsstory lesen](https://about.gitlab.com/de-de/customers/deutsche-telekom/)\n\n## Das Versprechen und die Herausforderung von KI-Tools\n\nSoftware hat die Welt grundlegend verändert, aber nur ein winziger Bruchteil der Weltbevölkerung verfügt heute über die Fähigkeiten, Software zu entwickeln. Dennoch erreichen diese Entwickler(innen) Milliarden von Menschen mit Smartphones und Internetanschlüssen. Stellen Sie sich eine Welt vor, in der *mehr* Menschen produktionsreife Software entwickeln, sichern und bereitstellen können – es gäbe eine Explosion von Innovationen, da mehr Menschen Software entwickeln könnten, die Milliarden von Menschen beeinflusst. **[Agentische KI](https://about.gitlab.com/de-de/topics/agentic-ai/) wird dies ermöglichen.**\n\nKI-Tools verstehen den Kontext, kennen ganze Codebases und arbeiten aktiv an komplexen Softwareprojekten in den Bereichen Entwicklung, Sicherheit und Betrieb mit. Mit KI-Tools können Entwickler(innen) Software in einem Umfang entwickeln, der für Einzelpersonen oder sogar Teams bisher unvorstellbar war.\n\nDieser Trend wirft jedoch wichtige Fragen zu Transparenz, Kontrolle und den Auswirkungen von KI auf die Arbeit der Entwickler(innen) auf. Unternehmen müssen sicherstellen, dass KI die Fähigkeiten ihrer Entwickler(innen) verbessert und sie gleichzeitig den Überblick über ihren Entwicklungsprozess behalten. Der Schlüssel zum Erfolg liegt nicht nur in der Einführung von KI, sondern auch darin, sie so einzusetzen, dass sie die Entwickler(innen) unterstützt und gleichzeitig Sicherheit, Compliance und Governance gewährleistet.\n\n## Der Erfolg von KI hängt von deiner Plattform ab, nicht von dem Hinzufügen zusätzlicher Tools\n\nWenn du mit mehr Entwickler(inne)n, Code und potenziellen Sicherheitsrisiken arbeitest, bringen zusätzliche Tools für jede neue Herausforderung nur noch mehr Komplexität mit sich. Unsere jüngste [DevSecOps-Umfrage (nur in englischer Sprache verfügbar)](https://about.gitlab.com/the-source/platform/devops-teams-want-to-shake-off-diy-toolchains-a-platform-is-the-answer/) zeigt, wie ernst dieses Problem ist: DevSecOps-Teams jonglieren mit bis zu 14 verschiedenen Tools und verbringen bis zu 80 % ihrer Zeit mit Aufgaben, die nichts mit Programmierung zu tun haben. Damit KI wirklich effektiv sein kann, braucht sie außerdem hochwertige, einheitliche Daten. Das ist mit uneinheitlichen Tools schwer zu erreichen.\n\n**Die GitLab DevSecOps-Plattform in Kombination mit GitLab-KI-Tools** führt alles in einem einzigen Datenmodell zusammen, das Quellcode, Merge Requests, Epics, Benutzerkonten, Zugriffsrechte und vieles mehr umfasst. Die Tools, die wir entwickeln, nutzen den Kontext von Benutzer(inne)n und Projekten, um die Arbeitsweise von Teams zu standardisieren und die Aufgaben zu automatisieren, die nichts mit Programmierung zu tun haben und die Entwickler(innen) Zeit kosten, wie z. B. die Suche nach Sicherheitsproblemen und die Durchsetzung von Compliance-Regeln. Wenn KI direkt in die Plattform integriert wird, werden diese Funktionen noch leistungsfähiger. Dann werden KI-Tools zu Entwicklungspartnern, während du die Kontrolle darüber behältst, wie KI den Prozess verbessert.\n\n**Das ist keine ferne Zukunft, sondern das, was wir mit GitLab Duo Workflow schon jetzt entwickeln.**\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1059060959?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"GitLab Duo Workflow, the future of secure agentic AI software development\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>`\n\n## GitLab Duo Workflow: KI-Tools auf der umfassendsten DevSecOps-Plattform\n\nGitLab Duo Workflow nutzt die durchgängige DevSecOps-Plattform von GitLab, um Entwickler(inne)n dabei zu helfen, ihr volles Potenzial auszuschöpfen. Während KI-Programmierassistenten bei der Programmierung einzelner Teile des Codes helfen, versteht GitLab Duo Workflow deinen gesamten Entwicklungslebenszyklus und automatisiert Routineaufgaben, damit sich die Entwickler(innen) auf strategische Innovationen und kreative Problemlösungen konzentrieren können. Wir entwickeln GitLab Duo Workflow, um Teams zu unterstützen: \n\n### Von der langsamen Projekteinrichtung zum schnellen Start\n\nEntwickler(innen) verbringen wertvolle Zeit damit, neue Projekte zu konfigurieren, Abhängigkeiten zu verwalten und die grundlegende Infrastruktur einzurichten, anstatt neue Funktionen zu entwickeln. Mit GitLab Duo Workflow kannst du **das Bootstrapping von Projekten direkt in der IDE automatisieren** und von Anfang an die richtigen Konfigurationen bereitstellen. So kannst du dich schneller darauf konzentrieren, Innovationen zu entwickeln.\n\n### Vom Legacy-Code zu modernen Anwendungen\n\nBei der Modernisierung von Legacy-Code geht es nicht nur um die Aktualisierung der Syntax, sondern auch um das Verständnis von Abhängigkeiten, Tests, CI/CD-Pipelines und Dokumentation. GitLab Duo Workflow hilft dir bei der **Modernisierung deiner Codebase, indem es das Code-Refactoring übernimmt** – vom Code bis hin zu Tests.\n\n### Vom Kontextwechsel zum Flow State\n\nEntwickler(innen) wechseln ständig zwischen Tools, Dokumenten und Codebases, um Probleme zu lösen. GitLab Duo Workflow hilft bei der **Lösung von Aufgaben mit dem vollständigen Kontext deiner Codebase-bezogenen Probleme und Merge Requests**, damit die Entwickler(innen) in ihrem Flow bleiben können.\n\n### Von einer veralteten Dokumentation zu dynamischem Wissen\n\nDokumentation verliert schnell an Aktualität, was das Verständnis und die Wartung von Codebases erschwert. GitLab Duo Workflow **unterstützt Entwickler(innen) bei der Erstellung und Aktualisierung der Dokumentation**, einschließlich README-Dateien, Ablaufdiagrammen und Architekturdokumentation.\n\n### Von lückenhaften zu umfassenden Tests\n\nMit dem Wachstum von Codebases wird es immer schwieriger, eine umfassende Testabdeckung zu gewährleisten. GitLab Duo Workflow **kann Tests für ganze Abschnitte deiner Codebase erstellen** und dabei deine bestehende Testinfrastruktur einbinden, sodass du mit weniger Aufwand eine zuverlässigere Software erhältst.\n\n## Melde dich für die private Beta-Warteliste an\n\n[Melde dich für die Warteliste für die private Beta-Version von GitLab Duo Workflow an](https://about.gitlab.com/de-de/gitlab-duo/agent-platform/), um beim nächsten Schritt in unserer Vision für sichere agentische KI dabei zu sein – von der Projekteinrichtung bis hin zur Bereitstellung. Diese Tools basieren auf der DevSecOps-Plattform von GitLab und verstehen deinen gesamten Software-Lebenszyklus, während sie gleichzeitig die Sicherheit und Kontrolle aufrechterhalten, die Unternehmen benötigen.\n\n*Haftungsausschluss: Diese Seite enthält Informationen über zukünftige Produkte, Funktionen und Funktionalitäten. Diese Informationen dienen nur zu Informationszwecken. Bitte verlasse dich daher nicht auf die Informationen, wenn du etwas kaufen oder planen möchtest. Alle Inhalte können sich ändern oder verzögern, und die Entwicklung, die Veröffentlichung und der Zeitplan liegen im alleinigen Ermessen von GitLab Inc.*",[1223],"Pini Wietchner","2025-02-24",[707,678,9,677,1113,928],{"slug":1227,"featured":90,"template":682},"gitlab-duo-workflow-enterprise-visibility-and-control-for-agentic-ai","content:de-de:blog:gitlab-duo-workflow-enterprise-visibility-and-control-for-agentic-ai.yml","Gitlab Duo Workflow Enterprise Visibility And Control For Agentic Ai","de-de/blog/gitlab-duo-workflow-enterprise-visibility-and-control-for-agentic-ai.yml","de-de/blog/gitlab-duo-workflow-enterprise-visibility-and-control-for-agentic-ai",{"_path":1233,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1234,"content":1240,"config":1247,"_id":1249,"_type":13,"title":1250,"_source":15,"_file":1251,"_stem":1252,"_extension":18},"/de-de/blog/gitlab-for-agile-software-development",{"title":1235,"description":1236,"ogTitle":1235,"ogDescription":1236,"noIndex":6,"ogImage":1237,"ogUrl":1238,"ogSiteName":695,"ogType":696,"canonicalUrls":1238,"schema":1239},"So setzt du GitLab für die Agile-Softwareentwicklung ein","Wie Agile-Artefakte auf GitLab-Funktionen abgebildet werden und wie eine Agile-Iteration in GitLab aussieht.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097459/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%2821%29_2pdp2MNB7SoP4MhhiI1WIa_1750097459157.png","https://about.gitlab.com/blog/gitlab-for-agile-software-development","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"So setzt du GitLab für die Agile-Softwareentwicklung ein\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Victor Wu\"},{\"@type\":\"Person\",\"name\":\"Amanda Rueda\"}],\n        \"datePublished\": \"2018-03-05\",\n      }",{"title":1235,"description":1236,"authors":1241,"heroImage":1237,"date":1243,"body":1244,"category":751,"tags":1245,"updatedDate":1015},[1242,745],"Victor Wu","2018-03-05","Hast du dich jemals gefragt, ob GitLab die [Agile-Methode](https://about.gitlab.com/de-de/solutions/agile-delivery/) unterstützt? Wenn du die Verwendung von GitLab in Betracht ziehst, ist es möglicherweise nicht offensichtlich, wie die Funktionen der DevSecOps-Plattform mit Agile-Artefakten übereinstimmen. Daher haben wir sie für dich aufgeschlüsselt.\n\nAgile ist eine der wichtigsten und transformativsten Methoden, die in den letzten Jahrzehnten im Bereich des Software-Engineerings eingeführt wurde. Obwohl sich nicht alle auf die detaillierte Terminologie der Agile-Konzepte einigen können, hat sie sich dennoch deutlich positiv auf die Softwareentwicklungsteams ausgewirkt. Du kannst dank [Agile-Softwareentwicklung](https://about.gitlab.com/de-de/solutions/agile-delivery/) und der Bereitstellungsprozesse effizient kundenorientierte Produkte erstellen.\n\nGitLab ist so konzipiert, dass es flexibel genug ist, um sich an deine Softwareentwicklungsmethodik anzupassen, unabhängig davon, ob es sich um Agile handelt oder davon inspiriert ist. In diesem Beitrag zeigen wir eine einfache Zuordnung von Agile-Artefakten zu GitLab-Funktionen und erklären, wie Kund(inn)en erfolgreich leistungsstarke [Agile-Softwarebereitstellungsteams](https://about.gitlab.com/de-de/solutions/agile-delivery/) mit GitLab unterstützen.\n\n## Inhaltsverzeichnis\n\n- [Zuordnen von Agile-Artefakten zu GitLab-Funktionen](#zuordnen-von-agile-artefakten-zu-gitlab-funktionen)\n  - [Agile-Artefakt → GitLab-Funktion](#agile-artefakt--gitlab-funktion)\n- [Eine Agile-Iteration mit GitLab](#eine-agile-iteration-mit-gitlab)\n  - [User Storys → GitLab-Probleme](#user-storys--gitlab-probleme)\n  - [Aufgabe → Aufgaben](#aufgabe--aufgaben)\n  - [Epics → GitLab-Epics](#epics--gitlab-epics)\n  - [Produkt-Backlog → GitLab-Issue-Übersichten](#produkt-backlog--gitlab-issue-übersichten)\n  - [Sprints → GitLab-Iterationen](#sprints--gitlab-iterationen)\n  - [Punkte und Schätzungen → GitLab-Ticketgewichtung](#punkte-und-schätzungen--gitlab-ticketgewichtung)\n  - [Agile Board → GitLab-Issue-Übersichten](#agile-board--gitlab-issue-übersichten)\n  - [Team-Workload → GitLab-Issue-Übersicht](#team-workload--gitlab-issue-übersicht)\n  - [Abarbeitungen → GitLab-Abarbeitungen](#abarbeitungen--gitlab-abarbeitungen)\n- [Starte deine Agile-Reise mit GitLab](#starte-deine-agile-reise-mit-gitlab)\n\n## Zuordnen von Agile-Artefakten zu GitLab-Funktionen\n\n### Agile-Artefakt → GitLab-Funktion \n\n- User Story –> [Probleme](https://docs.gitlab.com/ee/user/project/issues/) \n- Aufgabe –> [Aufgaben](https://docs.gitlab.com/ee/user/tasks.html) \n- Epic –> [Epics](https://docs.gitlab.com/ee/user/group/epics/) \n- Punkte und Schätzung –> [Problemgewichtung](https://docs.gitlab.com/ee/user/project/issues/issue_weight.html) \n- Produkt-Backlog –> [Issue-Übersichten](https://docs.gitlab.com/ee/user/project/issue_board.html)\n- Sprint/Iteration –> [Iterationen](https://docs.gitlab.com/ee/user/group/iterations/) \n- Agile Board –> [Issue-Übersichten](https://docs.gitlab.com/ee/user/project/issue_board.html) \n- Team-Workload –> [Issue-Übersichten](https://docs.gitlab.com/ee/user/project/issue_board.html) \n- Abarbeitungsdiagramm –> [Abarbeitungsdiagramme](https://docs.gitlab.com/ee/user/project/milestones/burndown_and_burnup_charts.html)\n\n## Eine Agile-Iteration mit GitLab\n\n### User Storys → GitLab-Probleme\n\nIn der Agile-Softwareentwicklungsmethodik beginnt man oft mit einer User Story, die ein einzelnes Feature erfasst, um den Benutzer(inne)n einen Geschäftswert zu bieten. In GitLab dient ein [Ticket](https://docs.gitlab.com/ee/user/project/issues/) diesem Zweck mit Leichtigkeit. GitLab-Tickets sind für Agile-Teams unerlässlich und bieten eine effektive Methode zum Verwalten von Aufgaben und Projekten. Softwareentwickler(innen) können Tickets erstellen, zuweisen und nachverfolgen, um eine klare Verantwortlichkeit und Sichtbarkeit des Fortschritts zu gewährleisten. Tickets kommen mit robusten Metadaten wie Beauftragte(r), Iteration, Gewichtung und Labels, was die Aufgabenpriorisierung und das Workflow-Management während des gesamten Softwareentwicklungsprozesses verbessert. Darüber hinaus wird die Teamzusammenarbeit bei Tickets mit Diskussionsthreads, Anhängen und Echtzeit-Updates optimiert, um eine effektive Kommunikation und Teamarbeit zu ermöglichen.\n\n![Screenshot eines GitLab-Tickets](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097468/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097468371.png)\n\nDas GitLab-Ticket hat einen Titel und einen Beschreibungsbereich in der Mitte, in dem du alle Details wie den Geschäftswert und die relevanten Personas in einer User Story dokumentieren kannst. Die Seitenleiste rechts bietet die Integration mit anderen Agile-kompatiblen Funktionen wie dem übergeordneten Epic, zu dem das Ticket gehört, der Iteration, in der das Ticket bearbeitet werden soll, und der Gewichtung des Tickets, die den geschätzten Aufwand widerspiegelt.\n\n### Aufgabe → Aufgaben\n\nOft wird eine User Story weiter in einzelne Aufgaben unterteilt. GitLab-[Aufgaben](https://docs.gitlab.com/ee/user/tasks.html) rationalisieren das Projektmanagement, da Agile-Teams die Möglichkeit haben, User Storys in einzelne Arbeitsschritte aufzuteilen. Diese Funktion unterstützt das Agile-Framework, indem Softwareentwickler(innen) Aufgaben innerhalb ihrer Projekte erstellen, zuweisen und nachverfolgen können. Durch die direkte Integration des Aufgabenmanagements in GitLab können Teams einen zusammenhängenden Workflow aufrechterhalten, der sicherstellt, dass alle Projektaktivitäten der Softwareentwicklung einfach nachverfolgt und verwaltet werden können.\n\n[!Screenshot mit genauer Aufgabenverwaltung und Projektverfolgung mit GitLab](https://res.cloudinary.com/about-gitlab-com/image/upload/v1752175696/Blog/rd4jnbnddseykj7f9x4q.png)\n\nVerbessere den Nutzen für Benutzer(innen) mit einer präzisen Aufgabenverwaltung und Projektverfolgung mit GitLab. Die Aufgaben sind mit den gleichen Metadaten wie Tickets ausgestattet, einschließlich Beauftragte(r), Iteration, Gewichtung, Label, Zeiterfassung und Funktionen für die Zusammenarbeit. Dieser umfassende Funktionsumfang ermöglicht es Agile-Teams und Projektmanager(innen), Workloads effektiv zu verwalten, Aufgaben zu priorisieren und eine nahtlose Zusammenarbeit zwischen Softwareentwickler(inne)n zu gewährleisten.\n\n### Epics → GitLab-Epics\nAndererseits können Agile-Entwicklungsfachkräfte eine Abstraktion über den User Storys angeben, die oft als Epic bezeichnet wird und auf einen größeren Benutzerfluss hinweist, der aus mehreren Funktionen besteht. In GitLab enthält ein [Epic](https://docs.gitlab.com/ee/user/group/epics/) auch einen Titel und eine Beschreibung, ähnlich wie ein Ticket, aber du kannst mehrere untergeordnete Tickets daran anhängen, um diese Hierarchie anzuzeigen.\n\n![Screenshot von verschachtelten GitLab-Epics](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097469/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097468372.png)\n\nMit GitLab-Epics können Agile-Teams große Projekte effizient organisieren und verwalten, indem sie Epics bis zu neun Ebenen tief verschachteln. Diese hierarchische Struktur bietet einen klaren Überblick über die Roadmap des Projekts und hilft Softwareentwickler(inne)n und Projektmanager(inne)n, komplexe Initiativen in überschaubare Komponenten zu unterteilen. Durch die Verwendung von untergeordneten und [verknüpften Epics](https://docs.gitlab.com/ee/user/group/epics/linked_epics.html) können Teams den Fortschritt, die Abhängigkeiten und die Projektmeilensteine besser verfolgen, die Zusammenarbeit verbessern und eine kohärente Agile-Bereitstellung gewährleisten.\n\n### Produkt-Backlog → GitLab-Issue-Übersichten\n\nDie Produkt- oder Geschäftsinhaber(innen) erstellen diese User Storys in der Regel, um die Bedürfnisse des Unternehmens und der Kund(inn)en widerzuspiegeln. Sie werden in einem Produkt-Backlog nach Prioritäten sortiert, um die Dringlichkeit und die gewünschte Reihenfolge der Entwicklung festzuhalten. Die Eigentümer(innen) des Produkts kommunizieren mit den Stakeholdern, um die Prioritäten festzulegen, und verfeinern das Backlog ständig. In GitLab bietet eine [Issue-Übersicht](https://docs.gitlab.com/ee/user/project/issue_board.html), die mit Iterationen als Listen organisiert ist, ein Drag-and-Drop-Workflow-Erlebnis, mit dem du deinen Backlog mühelos priorisieren und Storys einem bevorstehenden Sprint zuweisen kannst.\n\n[Gif der GitLab Issue-Übersicht](https://res.cloudinary.com/about-gitlab-com/image/upload/v1752175706/Blog/s6jqjqgqgwaaqc1ywkkn.gif)\n\n### Sprints → GitLab-Iterationen\n\nEin Sprint stellt einen begrenzten Zeitraum dar, in dem die Arbeit abgeschlossen werden soll. Das kann eine Woche, ein paar Wochen oder vielleicht einen Monat oder mehr umfassen. Die Eigentümer(innen) des Produkts und das Entwicklungsteam treffen sich, um zu entscheiden, welche Arbeiten für den kommenden Sprint vorgesehen sind. Die Funktion [Iterationen](https://docs.gitlab.com/ee/user/group/iterations/) von GitLab unterstützt dies: Weise Iterationen ein Startdatum und ein Fälligkeitsdatum zu, um den Zeitraum der Iteration zu erfassen. Das Team fügt dann Tickets in den Sprint ein, indem es sie dieser bestimmten Iteration zuweist.\n\nDurch die Verwendung von Iterationen nutzt du die erweiterten Funktionen von GitLab für agiles Projektmanagement und bietest eine bessere Transparenz und Kontrolle über deine Agile-Planung und -Bereitstellung. \n\n### Punkte und Schätzungen → GitLab-Ticketgewichtung\n\nAuch in diesem Meeting werden User Storys kommuniziert und der technische Aufwand für jede User Story geschätzt. In GitLab haben Tickets eine [Gewichtung](https://docs.gitlab.com/ee/user/project/issues/issue_weight.html) – Attribute, die du verwenden würdest, um den geschätzten Aufwand anzugeben.\n\nIn dieser Besprechung (oder in den folgenden) werden die User Storys weiter aufgeschlüsselt und manchmal werden technische Pläne und die Architektur dokumentiert. In GitLab können diese Informationen im Ticket oder in der [Beschreibung der Merge Request](https://docs.gitlab.com/ee/user/project/merge_requests/) dokumentiert werden, da die Merge Request oft der Ort ist, an dem die technische Zusammenarbeit stattfindet.\n\nWährend des Sprints (GitLab-Iteration) holen die Mitglieder des Softwareentwicklungsteams User Storys ab, an denen sie nacheinander arbeiten können. In GitLab haben Tickets Beauftragte. Du würdest dich also einem Ticket [zuweisen](https://docs.gitlab.com/ee/user/project/issues/multiple_assignees_for_issues.html), um zu zeigen, dass du jetzt daran arbeitest. Wir empfehlen dir, [eine leere und mit dem Ticket verknüpfte Merge Request zu erstellen](https://docs.gitlab.com/ee/user/project/issues/), um sofort mit dem technischen Zusammenarbeitsprozess zu beginnen, noch bevor du eine einzige Codezeile erstellst.\n\n### Agile Board → GitLab-Issue-Übersichten\n\nWährend des gesamten Sprints durchlaufen die Tickets verschiedene Phasen, wie z. B. `Ready for dev`, `In dev`, `In QA`, `In review`, `Done`, abhängig vom Workflow in deiner jeweiligen Organisation. Normalerweise sind dies Spalten in einem Agile Board. In GitLab kannst du mit [Issue-Übersichten](https://docs.gitlab.com/ee/user/project/issue_board.html) deine Phasen definieren und Tickets durch sie bewegen. Das Team kann unter Beachtung der Iteration und anderer relevanter Attribute [die Übersicht konfigurieren](https://docs.gitlab.com/ee/user/project/issue_board.html#board-with-configuration). Während der täglichen Stand-ups betrachtet das Team das Board gemeinsam, um den Status des Sprints aus einer Workflow-Perspektive zu sehen.\n\n![Screenshot der GitLab-Issue-Übersicht](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097469/Blog/Content%20Images/Blog/Content%20Images/image7_aHR0cHM6_1750097468374.png)\n\nDie GitLab-Issue-Übersicht greift auch dynamisch auf Probleme zu, ähnlich wie die GitLab-Issue-Liste. Aber sie ermöglicht flexiblere Workflows. Du kannst individuelle Listen in der Übersicht einrichten, um die Phasen des Agile Boards widerzuspiegeln. Dein Team kann dann die User Storys steuern und verfolgen, während sie von z. B. „Bereit für die Entwicklung“ zu „Zur Produktion freigegeben“ wechseln.\n\n### Team-Workload → GitLab-Issue-Übersicht\n\nAgile Teams können ihre Workflows optimieren, indem sie Issue-Übersichten mit Listen erstellen, die den Verantwortlichen in GitLab zugeordnet sind. Mit dieser Funktion kannst du die Verteilung der Aufgaben unter den Teammitgliedern visualisieren und die agile Bereitstellung verbessern. Um es einzurichten, gehe zu deinem Projekt oder deiner Gruppe, erstelle eine neue Übersicht im Abschnitt „Boards“ und [füge Listen](https://docs.gitlab.com/ee/user/project/issue_board.html#create-a-new-list) für jede(n) Beauftragte(n) hinzu. Weise Teammitgliedern Tickets zu, und sie werden automatisch in den entsprechenden Listen angezeigt. Diese dynamische Ansicht ermöglicht eine ausgewogene Arbeitsbelastung und eine effektive Aufgabenverwaltung.\n\n![Screenshot der organisierten GitLab-Issue-Übersicht](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097469/Blog/Content%20Images/Blog/Content%20Images/WIP_limit_aHR0cHM6_1750097468376.gif)\n\nOrganisiere eine Issue-Übersicht nach beauftragter Person oder nach Team mithilfe von [Labels mit begrenztem Geltungsbereich]. Die Issue-Übersicht von GitLab ist unglaublich vielfältig und unterstützt Workflows über den gesamten Software-Entwicklungsprozess hinweg.\n\n### Abarbeitungen → GitLab-Abarbeitungen\n\nDas Entwicklungsteam möchte in Echtzeit wissen, ob es auf dem richtigen Weg ist, und die entstehenden Risiken mindern. GitLab bietet [Abarbeitungen](https://docs.gitlab.com/ee/user/project/milestones/burndown_and_burnup_charts.html), damit das Team die im aktuellen Sprint „abzuarbeitenden“ Aufgaben visualisieren kann, während sie abgeschlossen wird.\n\nGegen Ende des Sprints stellt das Entwicklungsteam die fertiggestellten Funktionen den verschiedenen Interessengruppen vor. Mit GitLab wird dieser Prozess mithilfe von [Review Apps](https://docs.gitlab.com/ee/ci/review_apps/index.html) vereinfacht, sodass auch Code, der noch nicht für die Produktion freigegeben ist, in verschiedenen Test-, Staging- oder UAT-Umgebungen vorgeführt werden kann. Review Apps und [CI/CD-Funktionen](https://docs.gitlab.com/ee/ci/) sind in die Merge Request selbst integriert.\n\nDie gleichen Tools sind auch für Entwickler(innen) und QA-Rollen nützlich, um die Softwarequalität zu sichern, sei es durch automatisierte Tests mit CI/CD oder durch manuelle Tests in einer Review-App-Umgebung.\n\n![Screenshot von GitLab-Abarbeitungen](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097469/Blog/Content%20Images/Blog/Content%20Images/image6_aHR0cHM6_1750097468378.png)\n\nDie GitLab-Abarbeitung ermöglicht es einem Team, die „abzuarbeitenden“ Aufgaben zu verfolgen, während sie in einem Sprint abgeschlossen werden. Auf diese Weise kannst du früher auf Risiken reagieren und dich anpassen. So kannst du Geschäfts-Stakeholder darüber informieren, dass bestimmte Funktionen voraussichtlich auf einen zukünftigen Sprint verschoben werden.\n\nTeam-Retrospektiven am Ende des Sprints können im [Wiki] von GitLab (https://docs.gitlab.com/ee/user/project/wiki/index.html) dokumentiert werden, sodass die gewonnenen Erkenntnisse und die Aktionspunkte im Laufe der Zeit nachverfolgt werden können. Während der eigentlichen Retrospektive kann sich das Team den [Iterationsbericht](https://docs.gitlab.com/ee/user/group/iterations/#iteration-report) ansehen, der die Abarbeitung und andere Statistiken des abgeschlossenen Sprints anzeigt.\n\n## Starte deine Agile-Reise mit GitLab\nBist du bereit, dein Agile-Projektmanagement zu verbessern? GitLab bietet eine umfassende Palette von Funktionen, die auf Agile-Teams, Softwareentwickler(innen) und Projektmanager(innen) zugeschnitten sind und eine nahtlose Zusammenarbeit und effiziente Workflows gewährleisten. Erkunde unsere Preisoptionen, starte eine kostenlose Testversion und erfahre, wie GitLab deine Agile-Bereitstellungsprozesse verändern kann.\n\n> [Erfahre mehr über die Agile Planung mit GitLab](https://about.gitlab.com/pricing/) und starte noch heute deine Reise!\n",[750,9,928,1246],"collaboration",{"slug":1248,"featured":6,"template":682},"gitlab-for-agile-software-development","content:de-de:blog:gitlab-for-agile-software-development.yml","Gitlab For Agile Software Development","de-de/blog/gitlab-for-agile-software-development.yml","de-de/blog/gitlab-for-agile-software-development",{"_path":1254,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1255,"content":1261,"config":1267,"_id":1269,"_type":13,"title":1270,"_source":15,"_file":1271,"_stem":1272,"_extension":18},"/de-de/blog/gitlab-premium-with-duo",{"title":1256,"description":1257,"ogTitle":1256,"ogDescription":1257,"noIndex":6,"ogImage":1258,"ogUrl":1259,"ogSiteName":695,"ogType":696,"canonicalUrls":1259,"schema":1260},"Künstliche Intelligenz für alle Kund(inn)en von GitLab Premium und Ultimate","GitLab Premium und Ultimate umfassen jetzt GitLab Duo für die Erstellung und das Verständnis von Code während des gesamten Lebenszyklus der Softwareentwicklung – und das ohne zusätzliche Kosten.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749660188/Blog/Hero%20Images/blog-premium-with-duo-cover-0756-fy26-v2-1800x945.png","https://about.gitlab.com/blog/gitlab-premium-with-duo","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Künstliche Intelligenz für alle Kund(inn)en von GitLab Premium und Ultimate\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"David DeSanto, Chief Product Officer, GitLab\"}],\n        \"datePublished\": \"2025-05-15\",\n      }\n                  ",{"title":1256,"description":1257,"authors":1262,"heroImage":1258,"date":1263,"body":1264,"category":677,"tags":1265,"updatedDate":1266},[1158],"2025-05-15","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.\n\n**Ab dieser Version enthalten GitLab Premium und Ultimate jetzt auch die grundlegenden KI-Funktionen von GitLab Duo – und das ohne zusätzliche Kosten.**\n\nAlle 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.\n\n## KI für jedes Entwicklungsteam\n\nKü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.\n\nIn den letzten Jahren haben wir [GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/) 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 [globale DevSecOps-Studie](https://about.gitlab.com/de-de/developer-survey/) 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. \n\nJetzt 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 **ohne zusätzliche Kosten** in Anspruch nehmen können.\n\nDurch 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.\n\n> **„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.“**\n>\n>- Andrei Nita, Chief Technology Officer bei McKenzie Intelligence Services\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1083723619?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"GitLab Premium with Duo Core\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n\u003Cbr>\u003C/br>\nKund(inn)en mit Premium- und Ultimate-Lizenz haben jetzt Zugriff auf die folgenden KI-basierten Funktionen:\n\n#### GitLab Duo Codevorschläge\n\n* Generierung vollständiger Funktionen und Codeblöcke aus Kommentaren  \n* Erhalten intelligenter Code-Vervollständigung während der Eingabe  \n* Unterstützung für mehr als 20 Programmiersprachen  \n* Verfügbar in den meisten gängigen IDEs\n\nIn dieser interaktiven Tour erfährst du mehr über GitLab Duo Codevorschläge (klicke auf das Bild, um die Tour zu starten).\n\n\u003Ca href=\"https://gitlab.navattic.com/code-suggestions\">\u003Cimg src=\"https://res.cloudinary.com/about-gitlab-com/image/upload/v1752175911/Blog/b5gdnls7jdyrpeyjby5j.png\" alt=\"GitLab Duo Code Suggestions cover image\">\u003C/a>\n\nWeitere Informationen findest du in unserer [Dokumentation zu Duo Codevorschläge (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/project/repository/code_suggestions/).\n\n#### GitLab Duo Chat\n\n* Erklärung von unbekanntem Code, um komplexe Funktionen zu verstehen  \n* Refaktorierung von vorhandenem Code, um Qualität und Wartbarkeit zu verbessern  \n* Generierung umfassender Testfälle, um Bugs früher zu erkennen  \n* Behebung von Codeproblemen direkt in deinem Workflow\n\n![Duo Chat – Erklärung des API-Endpunkts](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749673912/Blog/Content%20Images/Duo_Chat_-_gif_-_API_endpoint_explanation__3_.gif)\n\nWeitere Informationen findest du in unserer [Dokumentation zu Duo Chat (nur in englischer Sprache vefügbar)](https://docs.gitlab.com/user/gitlab_duo_chat/).\n\n> **„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.“**\n>\n>- Felix Kortmann, Chief Technology Officer, Ignite by FORVIA HELLA\n\n## Duo Enterprise jetzt für Kund(inn)en von GitLab Premium verfügbar\n\nAuf vielfachen Wunsch unserer Kund(inn)en könnt ihr jetzt auch mit [GitLab Premium](https://about.gitlab.com/de-de/pricing/premium/) 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:\n\n* [Root Cause Analysis (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/gitlab_duo/use_cases/#root-cause-analysis-use-cases) hilft bei der schnellen Behebung von CI/CD-Pipeline-Fehlern und sorgt dafür, dass deine CI/CD-Pipelines stabil bleiben.\n* [Code Review (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/project/merge_requests/duo_in_merge_requests/#have-gitlab-duo-review-your-code) ermöglicht eine schnellere Merge-Request-Review, indem Duo als Code-Prüfer genutzt wird.  \n* [Erweiterter Chat (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/gitlab_duo_chat/) fasst Unterhaltungen zusammen, hilft beim Verständnis von Codeänderungen und bietet erweiterte Konfigurationsunterstützung.  \n* [Self-Hosted (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/administration/gitlab_duo_self_hosted/) ermöglicht den Einsatz von Duo in Air-Gapped- und Offline-Umgebungen, indem genehmigte KI-Modelle für Duo gehostet werden.\n\nNeben 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 [haben wir mehr als hundert Funktionen und Verbesserungen bereitgestellt](https://gitlab.com/gitlab-org/gitlab/-/releases), darunter: \n\n* Der [**CI/CD-Katalog** (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/ci-cd-catalog-goes-ga-no-more-building-pipelines-from-scratch/) ermöglicht es Entwickler(inne)n, bereits vorhandene CI/CD-Komponenten und -Konfigurationen zu teilen, zu entdecken und wiederzuverwenden.  \n\n* Die [**Artefaktregistrierung** (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/packages/virtual_registry/) bietet Entwickler(inne)n sicheren Zugriff auf Artefakte und eine nahtlose Integration in CI/CD-Pipelines.  \n* [**Remote-Entwicklung** (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/project/remote_development/) ermöglicht es Entwickler(inne)n, in bedarfsgerechten,  \nCloud-basierten Entwicklungsumgebungen zu arbeiten.\n\n> [Erfahre mehr über die Funktionen von GitLab Premium (nur in englischer Sprache verfügbar).](https://about.gitlab.com/pricing/premium/#wp-premium-features)\n\n## GitLab Duo: KI, die Unternehmen dort unterstützt, wo sie arbeiten\n\nGitLab-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.\n\n![Hauptfunktionen in GitLab-Duo-Tarifen](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749673912/Blog/Content%20Images/Screenshot_2025-05-14_at_8.50.34_AM.png)\n\n## Wie bestehende Kund(inn)en von GitLab Ultimate und Premium in GitLab Duo einsteigen können\n\nAb 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.\n\nSo nutzt du GitLab Premium und Ultimate mit Duo: \n\n1. Stelle sicher, dass du GitLab Premium oder Ultimate hast. Wenn nicht, kannst du es kostenlos testen. \n\n2. Aktiviere GitLab Duo in deinen Organisationseinstellungen.\n\n3. Wenn du eine lokale IDE verwendest, installiere die entsprechende [Editor-Erweiterung (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/editor_extensions/#available-extensions) für GitLab. \n\n4. Verwende Codevorschläge und Duo Chat in deiner bevorzugten unterstützten lokalen IDE oder der GitLab Web IDE.\n\n**Hinweis:** Für Neukund(inn)en und Testversionen werden die KI-Funktionen von GitLab automatisch aktiviert.\n\n## KI-native Entwicklung erfordert eine DevSecOps-Plattform\n\nKI 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 – **was GitLab wichtiger denn je macht.** \n\nWir 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.\n\n> Wenn du mehr über GitLab Duo und die Möglichkeiten erfahren möchtest, wie es die Arbeit deines Teams verändern kann, [besuche unsere GitLab-Premium-Seite](https://about.gitlab.com/de-de/pricing/premium/). 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 [virtuellen Launch-Event für GitLab 18 (nur in englischer Sprache verfügbar)](https://about.gitlab.com/eighteen/), um mehr über die Zukunft der KI-nativen Softwareentwicklung zu erfahren.\n",[678,707,1113,9,677],"2025-05-20",{"slug":1268,"featured":90,"template":682},"gitlab-premium-with-duo","content:de-de:blog:gitlab-premium-with-duo.yml","Gitlab Premium With Duo","de-de/blog/gitlab-premium-with-duo.yml","de-de/blog/gitlab-premium-with-duo",{"_path":1274,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1275,"content":1281,"config":1286,"_id":1288,"_type":13,"title":1289,"_source":15,"_file":1290,"_stem":1291,"_extension":18},"/de-de/blog/guide-to-fulfilling-soc-2-security-requirements-with-gitlab",{"title":1276,"description":1277,"ogTitle":1276,"ogDescription":1277,"noIndex":6,"ogImage":1278,"ogUrl":1279,"ogSiteName":695,"ogType":986,"canonicalUrls":1279,"schema":1280},"GitLab-Leitfaden: SOC-2-Sicherheitsanforderungen erfüllen","Verstehe die Anwendungssicherheitsfunktionen der DevSecOps-Plattform von GitLab, die den Anforderungen von System and Organization Controls 2 entsprechen.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099576/Blog/Hero%20Images/Blog/Hero%20Images/AdobeStock_1172300481_IGPi3TS4VzFgcqhvEdBlR_1750099575518.jpg","https://about.gitlab.com/blog/guide-to-fulfilling-soc-2-security-requirements-with-gitlab","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"GitLab-Leitfaden: SOC-2-Sicherheitsanforderungen erfüllen\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Fernando Diaz\"}],\n        \"datePublished\": \"2025-01-22\",\n      }",{"title":1276,"description":1277,"authors":1282,"heroImage":1278,"date":1283,"body":1284,"category":675,"tags":1285},[991],"2025-01-22","Für Unternehmen, die mit vertraulichen Kundendaten arbeiten, ist es nicht nur ein bewährtes Vorgehen, die SOC 2 (System and Organization Controls 2) einzuhalten, sondern ist oft sogar eine Notwendigkeit. SOC 2 ist ein strenger Prüfungsstandard, der vom American Institute of Certified Public Accountants entwickelt wurde, mit dem Serviceunternehmen hinsichtlich ihrer Sicherheit, Verfügbarkeit, Prozessintegrität, Vertraulichkeit und ihres Datenschutzes bewertet werden.\n\n\n SOC 2 ist zwar rechtlich nicht bindend, wird aber zunehmend wichtig, unter anderem deswegen, weil Verstöße gegen den Standard immer wieder in den Nachrichten zu finden sind. Durch die Einhaltung der SOC-2-Vorgaben können Kund(inn)en Vertrauen zu Serviceunternehmen aufbauen, da sie sich sicher sein können, dass ihre Daten entsprechend sicher gespeichert werden und die Sicherheitsmaßnahmen von einer externen Stelle geprüft wurden.\n\n\nIn diesem Leitfaden sehen wir uns die Voraussetzungen für eine SOC-2-Compliance an und erläutern, wie GitLab deinem Unternehmen dabei hilft, die höchsten Standards für Anwendungssicherheit einzuhalten.\n\n\n## Welche Anforderungen werden von SOC 2 festgelegt?\n\n\nDer Compliance-Prozess umfasst ein Audit durch unabhängige Auditor(inn)en, die die Konzeption und betriebliche Effektivität der Sicherheitsmaßnahmen eines Unternehmens bewerten. Dieser Prozess kann sehr kostspielig sein, und viele Unternehmen sind nicht ausreichend auf ein Audit vorbereitet. Da der SOC-2-Auditprozess normalerweise rund ein Jahr dauert, ist es wichtig, bereits vor dem Audit effiziente Prozesse einzuführen.\n\n\nUm SOC-2-Compliance zu erreichen, muss ein Unternehmen die Anforderungen der Trust Services Criteria erfüllen:\n\n\n| Kriterium | Anforderungen |\n\n| :---- | :---- |\n\n| Sicherheit | - Implementierung von Kontrollen gegen unautorisierten Zugriff \u003Cbr> - Einführung von Vorgehensweisen zum Erkennen und Mindern von Risiken\u003Cbr> - Einrichtung von Systemen, um Sicherheitsvorfälle zu erkennen und zu beheben |\n\n| Verfügbarkeit | - Sicherstellung, dass Systeme wie vereinbart für den Betrieb zugänglich sind\u003Cbr> - Überwachung der aktuellen Nutzung und Kapazität \u003Cbr> - Identifizierung und Behebung von Umgebungsbedrohungen, die sich auf die Systemverfügbarkeit auswirken können |\n\n| Prozessintegrität | - Erfassung genauer Angaben zu Systemeingaben und -ausgaben \u003Cbr> - Implementierung von Verfahren, um Systemfehler schnell zu identifizieren und zu korrigieren \u003Cbr> - Festlegung von Prozessaktivitäten, um sicherzustellen, dass die Produkte und Dienstleistungen den Spezifikationen entsprechen |\n\n| Vertraulichkeit | - Identifizierung und Schutz vertraulicher Informationen \u003Cbr> - Einführung von Richtlinien für Datenaufbewahrungszeiträume \u003Cbr> - Implementierung von Sicherheitsmaßnahmen zur Zerstörung vertraulicher Daten nach Ablauf der Aufbewahrungsfrist |\n\n| Datenschutz | - Einholen von Zustimmung vor der Erfassung vertraulicher personenbezogener Daten \u003Cbr> - Offenlegung der Datenschutzrichtlinien in klarer, einfacher Sprache \u003Cbr> - Erfassung der Daten nur für rechtmäßige Zwecke und aus vertrauenswürdigen Quellen |\n\n\u003Cbr>\n\n\nBeachte, dass diese Anforderungen nicht einmalig zu erfüllen sind, sondern eher ein kontinuierlicher Prozess sind. Die Auditor(inn)en kontrollieren die Effektivität im Laufe der Zeit.\n\n\n## So erreichst du die Sicherheitsanforderungen und behältst sie bei\n\n\nGitLab bietet mehrere standardmäßige Funktionen, mit denen du sicherstellen kannst, dass deine SOC-2-Sicherheitsanforderungen erfüllt werden:\n\n\n| Sicherheitsanforderung | Relevante Funktion |\n\n| :---- | :--- |\n\n| Implementierung von Kontrollen gegen unautorisierten Zugriff | - Vertrauliche Tickets und Merge Requests \u003Cbr> - Benutzerdefinierte Rollen und granulare Berechtigungen \u003Cbr> - Sicherheitsrichtlinien \u003Cbr> - Verifizierte Commits \u003Cbr> - Signierte Container-Images \u003Cbr> - Code-Eigentümer(innen) \u003Cbr> - Geschützte Branches |\n\n| Einrichten von Systemen, um Sicherheitsvorfälle zu erkennen und zu beheben | - Sicherheitslücken-Scans \u003Cbr> - Merge-Request-Sicherheitswidget \u003Cbr> - Compliance-Center für Sicherheitslücken-Einblicke \u003Cbr> - Audit-Events \u003Cbr> - Abhängigkeitsliste für Sicherheitslückenbericht \u003Cbr> - KI: GitLab Duo Vulnerability Explanation \u003Cbr> - KI: GitLab Duo Vulnerability Resolution |\n\n| Einführung von Vorgehensweisen zum Erkennen und Mindern von Risiken | Alle oben genannten Tools können von Sicherheitsteams verwendet werden, um Prozesse dafür zu entwickeln, wie vorzugehen ist, wenn Sicherheitslücken erkannt werden und wie sie zu beheben sind. |\n\n\u003Cbr>\n\nSehen wir uns diese Abschnitte und die dazugehörigen Sicherheitsfunktionen für diese Anforderungen nun genauer an. Beachte, dass ein [GitLab-Ultimate-Abonnement](https://about.gitlab.com/de-de/free-trial/) und die richtigen Rollen und Berechtigungen nötig sind, um viele der aufgelisteten Funktionen nutzen zu können. Weitere Informationen findest du in der entsprechenden Dokumentation.\n\n\n## Implementiere Kontrollen zum Schutz vor unbefugtem Zugriff\n\n\nEs ist wichtig, robuste Zugriffskontrollen zu implementieren, um die Assets eines Unternehmens zu schützen, die rechtliche Compliance sicherzustellen, die betriebliche Kontinuität zu gewährleisten und das Vertrauen zu fördern. Mit GitLab kannst du Kontrollen implementieren, um das [Prinzip der geringsten Privilegien (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/the-ultimate-guide-to-least-privilege-access-with-gitlab/) zu befolgen und vor unbefugtem Zugriff zu schützen. Wir werden uns kurz folgende Themen ansehen:\n\n\n* [Sicherheitsrichtlinien](#security-policies)\n\n* [Benutzerdefinierte Rollen und granulare Berechtigungen](#custom-roles-and-granular-permissions)\n\n* [Schutz von Branches und Code-Eigentümer(innen)](#branch-protections-and-codeowners)\n\n* [Verifizierte Commits](#verified-commits)\n\n\n### Sicherheitsrichtlinien\n\n\nDie Sicherheitsrichtlinien von GitLab werden auch als Leitlinien bezeichnet und ermöglichen es Sicherheits- und Compliance-Teams, im gesamten Unternehmen konsistente Kontrollen einzuführen. Dies trägt dazu bei, Sicherheitsvorfälle zu vermeiden, die Compliance-Standards einzuhalten und Risiken zu reduzieren, indem bewährte Vorgehensweisen hinsichtlich der Sicherheit automatisch und im großen Maßstab erzwungen werden.\n\n\n![Merge-Request-Approvalrichtlinien in Aktion](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099597/Blog/Content%20Images/Blog/Content%20Images/merge_request_approval_policy_aHR0cHM6_1750099596925.png)\n\n\n\u003Ccenter>\u003Ci>Merge-Request-Approvalrichtlinien in Aktion\u003C/i>\u003C/center>\u003Cbr>\n\n\nDie folgenden Arten von Richtlinien sind verfügbar:\n\n\n* Scan-Ausführungsrichtlinie: Erzwinge Sicherheitsscans als Teil einer Pipeline oder nach einem festgelegten Zeitplan\n\n* Merge-Request-Approvalrichtlinie: Erzwinge Einstellungen und Approvalregeln auf Projektebene basierend auf den Scanergebnissen\n\n* Pipeline-Ausführungsrichtlinie: Erzwinge CI/CD-Jobs als Teil von Projekt-Pipelines\n\n* Sicherheitslücken-Managementrichtlinie: Automatisiere Workflows für das Sicherheitslücken-Management\n\n\nHier ist ein Beispiel, wie die Compliance mit einer Pipeline-Ausführungsrichtlinie sichergestellt werden kann:\n\n\n1. Erstelle ein Projekt, das mehrere Compliance-Jobs enthält. Ein Beispiel für einen Job kann die Überprüfung der Berechtigungen von bereitgestellten Dateien sein. Diese Jobs sollten so allgemein gehalten sein, dass sie auf mehrere Anwendungen angewendet werden können.\n\n2. Beschränke die Berechtigungen des Projekts auf Sicherheits-/Compliance-Beauftragte. Erlaube Entwickler(inne)n nicht, Jobs zu entfernen. Dies ermöglicht eine Aufgabentrennung.\n\n3. Füge die Compliance-Jobs gesammelt in die Projekte ein, in denen sie benötigt werden. Erzwinge, dass sie immer ausgeführt werden, aber erlaube Approvals durch die Teamleitung, um die Entwicklung nicht zu blockieren. Dadurch wird sichergestellt, dass Compliance-Jobs immer ausgeführt werden und nicht von Entwickler(inne)n entfernt werden können. So bleibt deine Umgebung konform.\n\n\n> ##### Erfahre in unserer [Dokumentation zu Sicherheitsrichtlinien (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/ee/user/application_security/policies/), wie du Sicherheitsrichtlinien erstellen kannst.\n\n\n### Benutzerdefinierte Rollen und granulare Berechtigungen\n\n\nMit benutzerdefinierten Berechtigungen in GitLab können Unternehmen verfeinerte Zugriffskontrollen entwickeln, die über die standardmäßigen, rollenbasierten Berechtigungen hinausgehen. Das hat unter anderem folgende Vorteile:\n\n\n* Genauere Zugriffskontrolle\n\n* Bessere Sicherheits-Compliance\n\n* Reduziertes Risiko für versehentlichen Zugriff\n\n* Optimierte Benutzerverwaltung\n\n* Support für komplexe Unternehmensstrukturen\n\n\n![Benutzerdefinierte Rollen in GitLab](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099597/Blog/Content%20Images/Blog/Content%20Images/custom_roles_aHR0cHM6_1750099596926.png)\n\n\n\u003Ccenter>\u003Ci>Rollen- und Berechtigungseinstellungen, einschließlich benutzerdefinierter Rollen\u003C/i>\u003C/center>\n\n\n> ##### Erfahre in unserer [Dokumentation zu benutzerdefinierten Rollen (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/ee/user/custom_roles.html), wie du benutzerdefinierte Rollen mit granularen Berechtigungen erstellst.\n\n\n### Schutz von Branches und Code-Eigentümer(innen)\n\n\nGitLab hilft dir mit zwei wichtigen Funktionen, noch besser zu kontrollieren, wer deinen Code ändern kann:\n\n* Mit Branch Protection kannst du Regeln festlegen, wer bestimmte Branches aktualisieren darf, z. B. dass Approvals vor dem Zusammenführen von Änderungen nötig sind.\n\n* Mit Code Ownership werden automatisch die richtigen Personen gefunden, die Codeänderungen überprüfen dürfen, indem Dateien mit ihren zugewiesenen Eigentümer(inne)n abgeglichen werden.\n\n\nZusammen tragen diese Funktionen dazu bei, dass dein Code sicher und hochwertig ist, indem garantiert wird, dass die richtigen Personen Änderungen überprüfen und genehmigen.\n\n\n![Geschützte Branches](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099597/Blog/Content%20Images/Blog/Content%20Images/protected_branches_aHR0cHM6_1750099596928.png)\n\n\n\u003Ccenter>\u003Ci>Einstellungen für geschützte Branches\u003C/i>\u003C/center>\n\n\n> ##### Erfahre in der Dokumentation (nur in englischer Sprache verfügbar) zu [geschützten Branches](https://docs.gitlab.com/ee/user/project/repository/branches/protected.html) und [Code-Eigentümer(inne)n](https://docs.gitlab.com/ee/user/project/codeowners/), wie du geschützte Branches sowie mit Code-Eigentümer(inne)n erstellst.\n\n\n### Verifizierte Commits\n\n\nWenn du deine Commits digital signierst, beweist du, dass sie wirklich von dir stammen und nicht von jemandem, der sich als dich ausgibt. Stell dir eine digitale Signatur wie einen einzigartigen Stempel vor, den nur du erstellen kannst. Wenn du deinen öffentlichen GPG-Schlüssel in GitLab hochlädst, kann dieser Stempel überprüft werden. Wenn der Stempel übereinstimmt, markiert GitLab deinen Commit als `Verified`. Du kannst dann Regeln einrichten, um nicht signierte Commits abzulehnen oder alle Commits von Benutzer(innen) zu blockieren, die ihre Identität nicht verifiziert haben.\n\n\n![Commit mit verifizierter Signatur](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099597/Blog/Content%20Images/Blog/Content%20Images/signed_commit_aHR0cHM6_1750099596929.png)\n\n\n\u003Ccenter>\u003Ci>Commit mit verifizierter Signatur\u003C/i>\u003C/center>\u003Cbr>\n\n\nCommits können mit folgenden Signaturen versehen werden:\n\n\n* SSH-Schlüssel\n\n* GPG-Schlüssel\n\n* Persönliches x.509-Zertifikat\n\n\n> ##### Weitere Informationen zu verifizierten Commits findest du in unserer [Dokumentation zu signierten Commits (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/ee/user/project/repository/signed_commits/).\n\n\n## Einrichtung von Systemen zur Erkennung und Behebung von Sicherheitsvorfällen\n\n\nUm eine robuste Sicherheitslage beizubehalten, ist es unerlässlich, Systeme einzurichten, die Sicherheitsvorfälle erkennen und beheben. So stellst du die Einhaltung von Vorschriften sicher, minimierst potenzielle Schäden und ermöglichst es deinem Unternehmen, effektiv auf die kontinuierliche Weiterentwicklung der Bedrohungslandschaft zu reagieren.\n\n\nGitLab bietet Sicherheitsscans und Sicherheitslückenverwaltung für den gesamten Anwendungslebenszyklus. Wir werden uns kurz folgende Aspekte ansehen:\n\n\n* [Sicherheitsscans und Sicherheitslückenverwaltung](#security-scanning-and-vulnerability-management)\n\n* [Software-Stückliste](#software-bill-of-materials)\n\n* [System-Audits und Reviews der Sicherheitslage](#system-auditing-and-security-posture-review)\n\n* [Übersicht über Compliance und Sicherheitslage](#compliance-and-security-posture-oversight)\n\n\n### Sicherheitsscans und Verwaltung von Sicherheitslücken\n\n\nGitLab bietet zahlreiche verschiedene Sicherheitsscanner für den gesamten Lebenszyklus deiner Anwendung:\n\n\n* Statische Anwendungssicherheitstests (SAST)\n\n* Dynamische Anwendungssicherheitstests (DAST)\n\n* Container-Scans\n\n* Abhängigkeitssuche\n\n* IaC-Scans (Infrastructure as Code)\n\n* Abdeckungsgesteuertes Fuzzing\n\n* Web-API-Fuzzing\n\n\n Diese Scanner können über Vorlagen zu deiner Pipeline hinzugefügt werden. Um beispielsweise SAST- und Abhängigkeitssuche-Jobs in der Testphase auszuführen, kannst du einfach den folgenden Code in deine .gitlab-ci.yml-Datei einfügen:\n\n\n```yaml\n\nstages:   - test\n\ninclude:   - template: Jobs/Dependency-Scanning.gitlab-ci.yml   - template: Jobs/SAST.gitlab-ci.yml   ```\n\n\nDiese Jobs können über Umgegungsvariablen und mit der GitLab-Job-Syntax vollständig angepasst werden. Sobald eine Pipeline gestartet wird, werden die Sicherheitsscanner ausgeführt und erkennen Sicherheitslücken im Diff zwischen dem aktuellen Branch und dem Zielbranch. Die Sicherheitslücke kann in einem Merge Request (MR) angezeigt werden, der eine detaillierte Übersicht bietet, bevor der Code mit dem Zielbranch zusammengeführt wird. Der MR zeigt die folgenden Informationen zur Sicherheitslücke an:\n\n\n* Beschreibung\n\n* Status\n\n* Schweregrad\n\n* Evidenz\n\n* Identifikatoren\n\n* URL (falls zutreffend)\n\n* Anfrage/Antwort (falls zutreffend)\n\n* Reproduktions-Asset (falls zutreffend)\n\n* Schulung (falls zutreffend)\n\n* Code-Flow (bei erweiterten SAST)\n\n\n![MR-Ansicht der eingeführten Sicherheitslücke](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099597/Blog/Content%20Images/Blog/Content%20Images/no_sql_injection_vulnerability_mr_view_aHR0cHM6_1750099596931.png)\n\n\n\u003Ccenter>\u003Ci>MR-Ansicht der eingeführten Sicherheitslücke\u003C/i>\u003C/center>\u003Cbr>\n\n\nEntwickler(innen) können diese Daten verwenden, um Sicherheitslücken zu beheben, ohne die Workflows des Sicherheitsteams zu verlangsamen. Sie können Sicherheitslücken mit einer Begründung auch verwerfen, um den Überprüfungsprozess zu beschleunigen, oder ein vertrauliches Ticket erstellen, um die Sicherheitslücke zu verfolgen.\n\n\nWenn der Code in einem MR mit dem Standard-Branch (normalerweise auf Produktionsebene) zusammengeführt wird, wird der Sicherheitslückenbericht mit den Ergebnissen des Sicherheitsscans gefüllt. Diese Ergebnisse können von Sicherheitsteams verwendet werden, um die in der Produktion gefundenen Sicherheitslücken zu verwalten und zu kategorisieren.\n\n\n![Sicherheitslückenbericht mit Batch-Status-Einstellung](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099597/Blog/Content%20Images/Blog/Content%20Images/vulnerability_report_aHR0cHM6_1750099596936.png)\n\n\n\u003Ccenter>\u003Ci>Sicherheitslückenbericht mit Batch-Status-Einstellung\u003C/i>\u003C/center>\u003Cbr>\n\n\nWenn du im Sicherheitslückenbericht auf eine Sicherheitslückenbeschreibung klickst, wird dir die Sicherheitslückenseite angezeigt, die die gleichen Sicherheitslückendaten wie der MR enthält, sodass bei der Bewertung der Auswirkungen und der Behebung der Sicherheitslücke nur eine einzige Quelle der Wahrheit gilt. Auf der Seite der Sicherheitslücke kannst du die KI-Funktionen von [GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/) nutzen, um dir die Sicherheitslücke erklären zu lassen und einen MR zur Behebung zu erstellen, wodurch die Zeit bis zur Lösung verkürzt wird.\n\n\n> ##### Weitere Informationen zu den in GitLab enthaltenen Sicherheitsscans und zum Umgang mit Sicherheitslücken findest du in unserer [Dokumentation zur Anwendungssicherheit (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/ee/user/application_security/).\n\n\n### Software-Stückliste\n\n\nGitLab kann eine detaillierte Liste von allen Komponenten erstellen, die deine Software verwendet – sozusagen eine „Zutatenliste“ für deinen Code. Diese Liste, die als Software-Stückliste ([SBOM](https://about.gitlab.com/de-de/blog/the-ultimate-guide-to-sboms/)) bezeichnet wird, zeigt dir den gesamten externen Code, von dem dein Projekt abhängig ist, einschließlich der Teile, die du direkt verwendest, und deren eigener Abhängigkeiten. Für jedes Element kannst du sehen, welche Version du verwendest, welche Lizenz es hat und ob es bekannte Sicherheitsprobleme gibt. So kannst du den Überblick über den Inhalt deiner Software behalten und potenzielle Risiken erkennen.\n\n\n![Liste der Abhängigkeiten auf Gruppenebene (SBOM)](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099597/Blog/Content%20Images/Blog/Content%20Images/sbom_aHR0cHM6_1750099596937.png)\n\n\n\u003Ccenter>\u003Ci>Liste der Abhängigkeiten auf Gruppenebene (SBOM)\u003C/i>\u003C/center>\n\n\n> ##### Erfahre in unserer [Dokumentation zur Liste der Abhängigkeiten (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/ee/user/application_security/dependency_list/), wie du auf die Liste der Abhängigkeiten zugreifen und sie verwenden kannst.\n\n\n### System-Audits und Überprüfung der Sicherheitslage\n\n\nGitLab verfolgt alles, was in deinem System passiert, z. B. wer wann welche Änderungen vorgenommen hat. Stell dir das wie eine Überwachungskamera für deinen Code vor. Diese Aufzeichnungen helfen dir:\n\n\n* verdächtige Aktivitäten zu erkennen\n\n* den regulatorischen Behörden zu zeigen, dass du die Regeln befolgst\n\n* zu erkennen, was passiert ist, wenn etwas schiefgelaufen ist\n\n* zu sehen, wie deine Teams GitLab verwenden\n\n\nAll diese Informationen werden an einem Ort gespeichert und können dadurch bei Bedarf einfach überprüft und angesehen werden. Du kannst zum Beispiel Audit Events verwenden, um Folgendes zu verfolgen:\n\n\n* Wer hat die Berechtigungsstufe bestimmter Benutzer(innen) für ein GitLab-Projekt geändert und wann?\n\n* Wer hat neue Benutzer(innen) hinzugefügt oder Benutzer(innen) entfernt und wann?\n\n\n![Audit Events auf Projektebene](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099597/Blog/Content%20Images/Blog/Content%20Images/audit_events_aHR0cHM6_1750099596938.png)\n\n\n\u003Ccenter>\u003Ci>Audit Events auf Projektebene\u003C/i>\u003C/center>\n\n\n> ##### Weitere Informationen zu Audit Events findest du in der [Dokumentation zu Audit Events (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/ee/user/compliance/audit_events.html).\n\n\n## Compliance und Überwachung der Sicherheitslage\n\n\nDas Sicherheits-Dashboard von GitLab fungiert als Kontrollraum, an dem alle deine Sicherheitsrisiken an einem Ort anzeigt werden. Anstatt verschiedene Sicherheitstools einzeln zu überprüfen, kannst du alle Ergebnisse zusammen auf einem Bildschirm sehen. So kannst du Sicherheitsprobleme in all deinen Projekten leicht erkennen und beheben.\n\n\n![Sicherheits-Dashboard auf Gruppenebene](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099597/Blog/Content%20Images/Blog/Content%20Images/security_dashboard_aHR0cHM6_1750099596939.png)\n\n\u003Ccenter>\u003Ci>Sicherheits-Dashboard auf Gruppenebene\u003C/i>\u003C/center>\n\n\n> ##### Weitere Informationen zu Sicherheits-Dashboards findest du in unserer [Dokumentation zum Sicherheits-Dashboard (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/ee/user/application_security/security_dashboard/).\n\n\n## Einführung von Verfahren zur Identifizierung und Minderung von Risiken\n\n\nSicherheitslücken durchlaufen einen bestimmten Lebenszyklus. Ein Teil des Prozesses kann beispielsweise darin bestehen, dass für jeden anfälligen Code, der mit geschützten Branches zusammengeführt werden soll, mittels der Sicherheitsrichtlinien festgelegt wird, dass ein Approval erforderlich ist. Dann kann festgelegt werden, dass in der Produktion entdeckter anfälliger Code priorisiert, bewertet, behoben und anschließend validiert werden muss:\n\n\n* Die Kriterien für die Priorisierung können sich nach dem Schweregrad der Sicherheitslücke richten, der von den GitLab-Scannern erkannt wird.\n\n* Die Bewertung kann anhand der von GitLab Duo Vulnerability Explanation bereitgestellten Details zur Ausnutzung erfolgen.\n\n* Sobald die Sicherheitslücke behoben ist, kann sie mit den integrierten Regressionstests und Scannern von GitLab validiert werden.\n\n\nAuch wenn die Anforderungen jedes Unternehmens unterschiedlich sind, können mit GitLab als Plattform Risiken schnell identifiziert und mit geringerem Risiko behoben werden, als bei der Nutzung unterschiedlicher Tools der Fall wäre.\n\n\n### Best Practices für die SOC-2-Compliance\n\n\n* Etabliere eine starke Sicherheitskultur: Fördere Sicherheitsbewusstsein und Verantwortlichkeit in deinem gesamten Unternehmen.\n\n* Dokumentiere alles: Führe eine gründliche Dokumentation der Richtlinien, Verfahren und Kontrollen.\n\n* Automatisiere, wo möglich: Verwende Automatisierungstools, um Compliance-Prozesse zu optimieren und Fehler zu reduzieren.\n\n* Kommuniziere effektiv: Halte die Stakeholder(innen) über deine Compliance-Bemühungen auf dem Laufenden.\n\n* Hol dir fachkundige Beratung: Überlege, mit qualifizierten Berater(inne)n zusammenzuarbeiten, die dich auf deinem Weg zur SOC-2-Konformität unterstützen.\n\n\nEs ist ein bedeutendes Vorhaben, SOC-2-Compliance zu erreichen, aber die Vorteile sind unbestreitbar. Indem du dein Engagement für Anwendungssicherheit und betriebliche Exzellenz zeigst, fassen deine Kund(inn)en Vertrauen zu dir, verbesserst du deinen Ruf und behältst einen Wettbewerbsvorteil auf dem Markt.\n\n\n## Weiterlesen\n\n\nSieh dir die folgenden Ressourcen an, um mehr über GitLab und darüber zu erfahren, wie wir dich auf deinem Weg zur SOCv2-Compliance unterstützen:\n\n\n* [GitLab Ultimate](https://about.gitlab.com/de-de/pricing/ultimate/)\n\n* [Sicherheits- und Compliance-Lösungen von GitLab](https://about.gitlab.com/de-de/solutions/security-compliance/)\n\n* [Dokumentation zur Anwendungssicherheit mit GitLab](https://docs.gitlab.com/ee/user/application_security/)\n\n* [Tutorial-Projekt für DevSecOps mit GitLab (nur in englischer Sprache verfügbar)](https://gitlab.com/gitlab-da/tutorials/security-and-governance/devsecops/simply-vulnerable-notes)\n",[705,675,707,9,677],{"slug":1287,"featured":90,"template":682},"guide-to-fulfilling-soc-2-security-requirements-with-gitlab","content:de-de:blog:guide-to-fulfilling-soc-2-security-requirements-with-gitlab.yml","Guide To Fulfilling Soc 2 Security Requirements With Gitlab","de-de/blog/guide-to-fulfilling-soc-2-security-requirements-with-gitlab.yml","de-de/blog/guide-to-fulfilling-soc-2-security-requirements-with-gitlab",{"_path":1293,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1294,"content":1300,"config":1308,"_id":1310,"_type":13,"title":1311,"_source":15,"_file":1312,"_stem":1313,"_extension":18},"/de-de/blog/how-gitlab-can-support-your-iso-compliance-journey",{"ogTitle":1295,"schema":1296,"ogImage":1297,"ogDescription":1298,"ogSiteName":695,"noIndex":6,"ogType":696,"ogUrl":1299,"title":1295,"canonicalUrls":1299,"description":1298},"So unterstützt dich GitLab bei deiner ISO-27001-Compliance","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"So unterstützt dich GitLab bei deiner ISO-27001-Compliance\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Joseph Longo\"}],\n        \"datePublished\": \"2023-09-06\",\n      }","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749662877/Blog/Hero%20Images/security-cover-new.png","GitLab ist dein strategischer Partner und hilft mit seinen Software-Sicherheitsfunktionen dabei, deine ISO-27001-Compliance sicherzustellen.","https://about.gitlab.com/blog/how-gitlab-can-support-your-iso-compliance-journey",{"heroImage":1297,"body":1301,"authors":1302,"updatedDate":1304,"date":1305,"title":1295,"tags":1306,"description":1298,"category":675},"\nAls eine durchgängige All-Inclusive-Plattform ist es mit GitLab einfach, deinen DevSecOps-Lebenszyklus zu verwalten. Dank der Plattform von GitLab können Entwickler(innen) schneller bessere Software entwickeln. Das ist aber nicht alles, denn GitLab geht über DevSecOps hinaus.\n\nIm Oktober 2022 veröffentlichte die Internationale Organisation für Normung die neueste Version der Norm ISO 27001. ISO/IEC 27001:2022 enthält mehrere Änderungen gegenüber der vorherigen Version, darunter die neuen Control Kategorien aus Anhang A, bei denen es um sicheres Programmieren und Konfigurationsmanagement geht.\n\nWir bei GitLab nutzen unsere Plattform, um viele Aspekte unseres Sicherheitskonformitätsprogramms zu unterstützen – ein Konzept, das wir intern [Dogfooding](https://about.gitlab.com/direction/dogfooding/) nennen. Eine Übersicht über den Nachweis der Einhaltung von Vorschriften und Sicherheit findest du in unserem [Trust Center](https://about.gitlab.com/security/).\n\nSehen wir uns nun die wichtigsten Funktionen an, die du bei deiner ISO-27001-Compliance nutzen kannst.\n\n## Organisatorische Controls\n\n| Control-ID | Control-Beschreibung |\n| ---- | ---- |\n| 5.3 Aufgabentrennung | Widersprüchliche Aufgaben und Verantwortungsbereiche sind zu trennen. |\n| 5.15 Zugriffskontrolle | Regeln zur Kontrolle des physischen und logischen Zugriffs auf Informationen und andere damit verbundene Vermögenswerte müssen auf der Grundlage der Geschäfts- und Informationssicherheitsanforderungen festgelegt und implementiert werden. |\n| 5.16 Identitätsmanagement | Der gesamte Lebenszyklus von Identitäten ist zu verwalten. |\n| 8.2 Privilegierte Zugriffsrechte | Die Vergabe und Nutzung von privilegierten Zugriffsrechten ist einzuschränken und zu verwalten.|\n| 8.4 Zugriff auf Quellcode | Der Lese- und Schreibzugriff auf Quellcode, Entwicklungstools und Softwarebibliotheken ist angemessen zu verwalten. |\n\nMit GitLab kannst du [Benutzer(inne)n eine Rolle zuweisen](https://docs.gitlab.com/ee/user/permissions.html), wenn du sie zu einem Projekt oder einer Gruppe hinzufügst. Die Rolle eines Benutzers/einer Benutzerin legt fest, was er/sie in deiner GitLab-Instanz ausführen kann. Folgende Rollen stehen für die Zuweisung zur Verfügung:\n* Gast (nur private und interne Projekte)\n* Reporter(in)\n* Entwickler(in)\n* Betreuer(in)\n* Eigentümer(in)\n* Minimaler Zugriff (nur für die Hauptgruppe verfügbar)\n\nMit den Rollen von GitLab kannst du die Berechtigungen eines Benutzers/einer Benutzerin gemäß dem [Prinzip der geringsten Privilegien](https://csrc.nist.gov/glossary/term/least_privilege) und deinen Geschäfts- und Informationssicherheitsanforderungen einschränken.\n\nAußerdem kannst du dank GitLab die Authentifizierungs- und Autorisierungsverantwortlichkeiten für deine GitLab-Instanz über [SAML-SSO-Integrationen](https://docs.gitlab.com/ee/user/group/saml_sso/) zentralisieren. GitLab lässt sich in eine Vielzahl von Identitätsanbietern integrieren, um die verschiedenen Technologie-Stacks unserer Kund(inn)en zu unterstützen. GitLab unterstützt auch das System für domänenübergreifendes Identitätsmanagement ([SCIM](https://docs.gitlab.com/ee/user/group/saml_sso/scim_setup.html)). Durch die SSO- und SCIM-Integrationen von GitLab kannst du den Lebenszyklus deiner Benutzeridentitäten sicher und effizient automatisieren.\n\n[SSO](https://docs.gitlab.com/ee/integration/saml.html) und [SCIM](https://docs.gitlab.com/ee/administration/settings/scim_setup.html) sind auch für selbstverwaltete Kund(inn)en von GitLab verfügbar.\n\n**Hinweis:** Die technologischen Controls 8.2 und 8.4 in Anhang 8 wurden aufgrund ihrer Nähe zu den organisatorischen Controls 5.3, 5.15 und 5.16 in die oben stehende Tabelle aufgenommen. Für die Anforderungen dieser Controls können die gleichen GitLab-Funktionen angewendet werden.\n{: .note}\n\n\u003Cbr>\n\n| Control-ID | Control-Beschreibung |\n| ---- | ---- |\n| 5.8 Informationssicherheit im Projektmanagement | Informationssicherheit ist in das Projektmanagement zu integrieren. |\n\nMit GitLab kannst du unsere [Planungstools](https://about.gitlab.com/features/?stage=plan) für dein Projektmanagement nutzen und so sicherstellen, dass die Informationssicherheit in allen Phasen eines Projektlebenszyklus eingehalten wird.\n\n- Mit der [Teamplanung](https://about.gitlab.com/features/?stage=plan#team_planning) von GitLab können Benutzer(innen) Projektarbeiten von der Idee bis zur Produktion organisieren, planen, abstimmen und nachverfolgen.\n\n- [Epics](https://docs.gitlab.com/ee/user/group/epics/), [Tickets](https://docs.gitlab.com/ee/user/project/issues/) und [Aufgaben](https://docs.gitlab.com/ee/user/tasks.html) können verwendet werden, um gemeinsam an Ideen zu arbeiten, Probleme zu lösen und Arbeiten mit deinem Informationssicherheitsteam zu planen. [Beschreibungsvorlagen](https://docs.gitlab.com/ee/user/project/description_templates.html) und [Checklisten](https://docs.gitlab.com/ee/user/markdown.html#task-lists) ermöglichen es den Benutzer(inne)n, konsistente Beschreibungen und Workflows für Tickets oder [Merge Requests](https://docs.gitlab.com/ee/user/project/merge_requests/index.html) einzuhalten. Mit diesen Vorlagen kann die Informationssicherheit konsistent in deinen Projektmanagement-Lebenszyklus integriert werden.\n\n- [Labels](https://docs.gitlab.com/ee/user/project/labels.html) ermöglichen es Benutzer(inne)n, Probleme so zu organisieren, wie sie es für richtig halten. Im Hinblick auf die Informationssicherheit können Label verwendet werden, um die Risikostufe eines Projekts zu identifizieren, die Phase eines Projekts anzugeben oder das Informationssicherheitsteam zu markieren, das für eine bestimmte Arbeit zuständig ist. [Labels mit begrenztem Geltungsbereich](https://docs.gitlab.com/ee/user/project/labels.html#scoped-labels) können verwendet werden, um Workflows weitere Logik hinzuzufügen. Sie verhindern nämlich, dass bestimmte Labels zusammen verwendet werden. Bei GitLab nutzen wir [Labels mit begrenztem Geltungsbereich](https://docs.gitlab.com/ee/user/project/labels.html#scoped-labels), um die Arbeit, die verschiedenen Teams zugewiesen ist, die Projektphase, in der sich die Arbeit befindet, und das Produkt oder den Funktionsumfang, der mit der Arbeit verbunden ist, zu identifizieren.\n\n![Labels mit begrenztem Geltungsbereich](https://about.gitlab.com/images/blogimages/2023-08-24-how-gitlab-can-support-your-iso-compliance-journey/scoped-labels.png)\n\nLabels mit begrenztem Geltungsbereich\n{: .note.text-center}\n\n- Mit [Gruppen-](https://docs.gitlab.com/ee/user/project/issue_board.html#group-issue-boards) und [Projekt-](https://about.gitlab.com/stages-devops-lifecycle/issueboard/)-Issue-Übersichten kannst du deine Arbeit noch besser organisieren und eine zentrale, zusammengefasste Ansicht für alle mit einer Gruppe oder einem Projekt verbundenen Arbeiten bieten.\n\n## Technologische Controls\n\n| Control-ID | Control-Beschreibung |\n| ---- | ---- |\n| 8.8 Management technischer Sicherheitslücken | Informationen über technische Sicherheitslücken der verwendeten Informationssysteme sind einzuholen, die Exposition des Unternehmens gegenüber solchen Sicherheitslücken ist zu bewerten und geeignete Maßnahmen sind zu ergreifen. |\n| 8.9 Konfigurationsmanagement | Konfigurationen von Hardware, Software, Diensten und Netzwerken, einschließlich Sicherheitskonfigurationen, müssen festgelegt, dokumentiert, implementiert, überwacht und überprüft werden. |\n| 8.25 Sicherer Entwicklungslebenszyklus | Regeln für die sichere Entwicklung von Software und Systemen müssen festgelegt und angewendet werden. |\n| 8.26 Anforderungen an die Anwendungssicherheit | Anforderungen an die Informationssicherheit müssen bei der Entwicklung oder dem Erwerb von Anwendungen identifiziert, spezifiziert und genehmigt werden. |\n| 8.27 Sichere Systemarchitektur und technische Grundsätze | Grundsätze für die Entwicklung sicherer Systeme müssen festgelegt, dokumentiert, gepflegt und bei allen Entwicklungsaktivitäten von Informationssystemen angewendet werden |\n\nMit GitLab kannst du deine Hardware- und Softwarekonfigurationen speichern, die Versionskontrolle verwalten, deine Konfigurationen über [Merge Requests](https://docs.gitlab.com/ee/user/project/merge_requests/index.html) aktualisieren und die [CI/CD-Pipelines](https://docs.gitlab.com/ee/ci/pipelines/) von GitLab nutzen, um diese Konfigurationen in deine Anwendungen und Infrastruktur zu übertragen. Mit GitLab können Unternehmen [GitOps](https://about.gitlab.com/topics/gitops/) über eine einzige Plattform implementieren.\n\nMit dem [Infrastructure-as-Code-Scanning](https://docs.gitlab.com/ee/user/application_security/iac_scanning/) von GitLab kannst du deine IaC-Konfigurationsdateien auf bekannte Sicherheitslücken scannen. Das IaC-Scanning von GitLab unterstützt eine Vielzahl von IaC-Konfigurationsdateien und -Sprachen, wodurch es an verschiedene Technologie-Stacks angepasst werden kann.\n\nFür Compliance-Profis ermöglicht GitLab die Implementierung von Automatisierung durch [Compliance-Frameworks](https://docs.gitlab.com/ee/user/group/compliance_frameworks.html) und [Compliance-Pipelines](https://docs.gitlab.com/ee/user/group/compliance_frameworks.html#compliance-pipelines). Dank dieser Funktionen können Benutzer(innen) kritische Projekte mit bestimmten Compliance-Anforderungen identifizieren und Konfigurationen über Pipelines an diese Projekte pushen. Sie ermöglichen eine konsistente Durchsetzung der Controls und unterstützen dadurch deine Sicherheitslage. Außerdem stellen sie sicher, dass die internen und externen Compliance-Anforderungen deines Unternehmens eingehalten werden.\n\nFür [Ultimate-Kund(inn)en](https://about.gitlab.com/pricing/ultimate/) bietet das [Compliance Center](https://docs.gitlab.com/ee/user/compliance/compliance_center/index.html) von GitLab eine zentrale Ansicht des Compliance-Zustands einer Gruppe, z. B. der verschiedenen Compliance Frameworks, die auf die Projekte in der Gruppe angewendet werden. Du kannst sogar sehen, wie gut du den [GitLab-Standard](https://docs.gitlab.com/ee/user/compliance/compliance_center/index.html#gitlab-standard) erfüllst.\n\n\u003Cbr>\n\n| Control-ID | Control-Beschreibung |\n| ---- | ---- |\n| 8.15 Protokollierung | Protokolle, die Aktivitäten, Ausnahmen, Fehler und andere relevante Ereignisse aufzeichnen, sind zu erstellen, zu speichern, zu schützen und zu analysieren. | \n| 8.16 Kontrolle von Überwachungsaktivitäten | Netzwerke, Systeme und Anwendungen müssen auf anomales Verhalten überwacht und geeignete Maßnahmen zur Bewertung potenzieller Informationssicherheitsvorfälle ergriffen werden. |\n\nMit GitLab kannst du [Audit-Ereignisse](https://docs.gitlab.com/ee/administration/audit_events.html) verwenden, um wichtige Ereignisse zu verfolgen, einschließlich der Frage, wer wann die entsprechende Aktion durchgeführt hat. Audit-Ereignisse decken ein breites Spektrum von Kategorien ab, darunter:\n* Gruppenverwaltung\n* Authentifizierung und Autorisierung\n* Benutzerverwaltung\n* Compliance und Sicherheit\n* CI/CD\n* GitLab-Runner\n\n![Audit-Ereignisse](https://about.gitlab.com/images/blogimages/2023-08-24-how-gitlab-can-support-your-iso-compliance-journey/example-of-an-audit-event.png)\n\nBeispiel für ein Audit-Ereignis\n{: .note.text-center}\n\nFür [Ultimate-Kund(inn)en](https://about.gitlab.com/pricing/ultimate/) kann das [Audit-Ereignis-Streaming](https://docs.gitlab.com/ee/administration/audit_event_streaming/index.html) aktiviert werden. Mit dem Audit-Ereignis-Streaming können Benutzer(innen) ein Streaming-Ziel für eine Gruppe oder Instanz der obersten Ebene festlegen, um alle Audit-Ereignisse über die Gruppe, Untergruppen und Projekte als strukturierte JSON-Datei zu erhalten.\n\n\u003Cbr>\n\n| Control-ID | Control-Beschreibung |\n| ---- | ---- |\n| 8.28 Sichere Programmierung | Bei der Softwareentwicklung sind die Prinzipien des sicheren Programmierens anzuwenden. |\n| 8.29 Sicherheitstests in Entwicklung und Akzeptanz | Sicherheitstestprozesse sind im Entwicklungslebenszyklus zu definieren und umzusetzen. | \n\nDu kannst die Funktionen in der [Sicherungsphase](https://about.gitlab.com/features/?stage=secure) von GitLab nutzen, um den Lebenszyklus deiner Softwareentwicklung zu verbessern und die Sicherheit deiner Produkte zu verbessern. Zu den Funktionen von GitLab in der Sicherungsphase gehören:\n* [Statische Anwendungssicherheitstests (SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)\n* [Dynamische Anwendungssicherheitstests (DAST)](https://docs.gitlab.com/ee/user/application_security/dast/)\n* [Codequalität](https://docs.gitlab.com/ee/ci/testing/code_quality.html)\n* [Container-Scanning](https://docs.gitlab.com/ee/user/application_security/container_scanning/)\n* [Abhängigkeitssuche](https://docs.gitlab.com/ee/user/application_security/dependency_scanning/)\n\nund vieles mehr!\n\n![Ergebnisse zur Codequalität](https://about.gitlab.com/images/blogimages/2023-08-24-how-gitlab-can-support-your-iso-compliance-journey/code-quality-findings.png)\n\nErgebnisse zur Codequalität\n{: .note.text-center}\n\nKompromittierte Geheimnisse sind einer der führenden Katalysatoren für Sicherheitsverletzungen. Die [Erkennung von Geheimnissen](https://docs.gitlab.com/ee/user/application_security/secret_detection/) von GitLab scannt dein Repository, um zu verhindern, dass deine Geheimnisse aufgedeckt werden.\n\nMit der [Richtlinien-Funktion](https://docs.gitlab.com/ee/user/application_security/policies/) von GitLab können Benutzer(innen) [Scanausführungs-](https://docs.gitlab.com/ee/user/application_security/policies/scan-execution-policies.html) und [Scanergebnis-Richtlinien](https://docs.gitlab.com/ee/user/application_security/policies/scan-result-policies.html) basierend auf konfigurierter Logik implementieren. Diese Richtlinien kombinieren die Scan-Funktionen in der [Sicherungsphase](https://about.gitlab.com/features/?stage=secure) mit [Freigaben für Merge Requests](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/), um die Compliance-Anforderungen weiter durchzusetzen.\n\nZusammen bilden die Sicherheitsfunktionen von GitLab die optimale Grundlage für einen sicheren Lebenszyklus der Softwareentwicklung und ermöglichen es dir, die Prinzipien des sicheren Programmierens sowie die Anforderungen deines Unternehmens einzuhalten.\n\n\u003Cbr>\n\n| Control-ID | Control-Beschreibung |\n| ---- | ----| \n| 8.32 Änderungsmanagement | Änderungen an Informationsverarbeitungseinrichtungen und Informationssystemen unterliegen den Änderungsmanagementverfahren. |\n\nGitLab bietet viele Funktionen, um ein umfassendes Änderungsmanagement zu unterstützen.\n\nMit der Quellcodeverwaltung von GitLab können Benutzer(innen) [geschützte Branches](https://docs.gitlab.com/ee/user/project/protected_branches.html) implementieren. Geschützte Branches ermöglichen es GitLab-Benutzer(inne)n, bestimmte Branches einzuschränken, die als kritisch für den Betrieb angesehen werden. Ein geschützter Branch steuert:\n* welche Benutzer(innen) in den Branch mergen können\n* welche Benutzer(innen) in den Branch pushen können\n* wenn Benutzer(innen) den Push in den Branch erzwingen können\n* ob Änderungen an Dateien, die in der CODEOWNERS-Datei aufgeführt sind, direkt in den Branch gepusht werden können\n* welche Benutzer(innen) den Schutz des Branches aufheben können\n\nDer [Standard-Branch](https://docs.gitlab.com/ee/user/project/repository/branches/default.html) in einem Repository wird automatisch als geschützter Branch gekennzeichnet.\n\n![Geschützte Branches](https://about.gitlab.com/images/blogimages/2023-08-24-how-gitlab-can-support-your-iso-compliance-journey/protected-branches-settings-within-gitlab.png)\n\nEinstellungen für geschützte Branches in GitLab\n{: .note.text-center}\n\nMerge Requests (MR) sind eine Kernkomponente des Softwareentwicklungszyklus. GitLab-Benutzer(innen) können ihre MRs so konfigurieren, dass sie erst freigegeben werden müssen, bevor sie zusammengeführt werden können. Mit MR-Genehmigungen können Benutzer(innen) die Mindestanzahl der erforderlichen Genehmigungen festlegen, bevor Arbeiten in ein Projekt zusammengeführt werden können. Einige Beispiele für Regeln, die du erstellen kannst, sind:\n* Benutzer(innen) mit bestimmten Berechtigungen können Arbeiten jederzeit genehmigen.\n* [Code-Eigentümer(innen)](https://docs.gitlab.com/ee/user/project/codeowners/index.html) können Arbeiten für Dateien genehmigen, die sie besitzen.\n* Benutzer(innen) mit bestimmten Berechtigungen können Arbeiten im Repository genehmigen, [auch wenn sie keine Merge-Rechte haben](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/rules.html#merge-request-approval-segregation-of-duties).\n* Benutzer(inne)n mit bestimmten Berechtigungen kann die Möglichkeit gewährt oder verweigert werden, [Genehmigungsregeln für eine bestimmte Merge Request zu überschreiben](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/rules.html#edit-or-override-merge-request-approval-rules).\n\nWie bereits erwähnt, können [Tickets](https://docs.gitlab.com/ee/user/project/issues/) und [Aufgaben](https://docs.gitlab.com/ee/user/tasks.html) verwendet werden, um Änderungsanfragen zu dokumentieren und zusammenzuarbeiten. [Beschreibungsvorlagen](https://docs.gitlab.com/ee/user/project/description_templates.html) ermöglichen es den Benutzer(inne)n, konsistente Beschreibungen für Tickets oder [MRs](https://docs.gitlab.com/ee/user/project/merge_requests/index.html) einzuhalten. Mit diesen Vorlagen kann ein konsistenter Ansatz verfolgt werden, um Änderungen in einer Weise anzufordern, die am besten zu deinem Unternehmen passt.\n\n> **Von 18 auf 3 Monate: So beschleunigt die Deutsche Telekom ihre Releases mit GitLab** 13.000 Entwickler(innen) arbeiten effizienter zusammen und bringen Produkte 6x schneller auf den Markt – erfahre, wie GitLab Ultimate die DevSecOps-Transformation vorantreibt, Silos aufbricht und Sicherheit in den Entwicklungsprozess bringt. [Erfolgsstory lesen](https://about.gitlab.com/de-de/customers/deutsche-telekom/)\n\n## Mehr erfahren\nAls umfassende DevSecOps-Plattform unterstützt GitLab ein breites Spektrum an Anforderungen. ISO hat in der Version 2022 der ISO-Norm zusätzliche Controls für sicheres Programmieren und Konfigurationsmanagement hinzugefügt. Dies zeigt, dass Zertifizierungsstellen insgesamt einen verstärkten Fokus auf die Softwaresicherheit legen. Als strategischer Partner kann GitLab dir dabei helfen, die ISO 27001 einzuhalten und schneller bessere Software zu entwickeln.\n\nWeitere Informationen zu diesen Funktionen findest du in unserer [Tutorial-Bibliothek](https://docs.gitlab.com/ee/tutorials/).",[1303],"Joseph Longo","2025-04-22","2023-09-06",[675,9,1307],"customers",{"slug":1309,"featured":6,"template":682},"how-gitlab-can-support-your-iso-compliance-journey","content:de-de:blog:how-gitlab-can-support-your-iso-compliance-journey.yml","How Gitlab Can Support Your Iso Compliance Journey","de-de/blog/how-gitlab-can-support-your-iso-compliance-journey.yml","de-de/blog/how-gitlab-can-support-your-iso-compliance-journey",{"_path":1315,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1316,"content":1319,"config":1328,"_id":1330,"_type":13,"title":1331,"_source":15,"_file":1332,"_stem":1333,"_extension":18},"/de-de/blog/how-gitlab-duo-agent-platform-transforms-dataops",{"title":1317,"description":1318},"Wie GitLab Duo Agent Platform DataOps transformiert","Erfahre, wie du manuelle Programmierung in voll automatisierte Generierung verwandelst – am Beispiel der dbt-Modellerstellung.",{"title":1320,"description":1321,"authors":1322,"heroImage":1324,"date":1325,"category":703,"tags":1326,"body":1327},"Wie du mit der GitLab Duo Agent Platform deine DataOps transformiert","So wird aus manueller Programmierung eine vollautomatische Generierung, erklärt am Beispiel der dbt-Modellerstellung.",[1323],"Dennis van Rooijen","blog/hero%20images/workflow_1800x945.png","2025-09-16",[677,705,9],"Die manuelle Erstellung von dbt-Modellen ist ein mühsamer Prozess, der\nStunden an Arbeitszeit verschlingt. Besonders wenn keine (größeren)\nGeschäftstransformationen vorgenommen werden, gehört diese Aufgabe nicht zu\nden attraktivsten Tätigkeiten eines Dateningenieurs.\n\n\nAber was wäre, wenn du diesen gesamten Prozess automatisieren könntest? In dieser Anleitung zeige ich dir genau, wie [GitLab Duo Agent Platform](https://about.gitlab.com/de-de/gitlab-duo/agent-platform/) umfassende dbt-Modelle in nur wenigen Minuten generiert – komplett mit ordnungsgemäßer Struktur, Tests und Dokumentation.\n\n\n## Was wir aufbauen\n\n\nUnser Marketing-Team möchte Werbeinvestitionen effektiv verwalten und optimieren. Eine der Werbeplattformen ist Reddit, daher extrahieren wir Daten von der Reddit Ads API in unsere unternehmensweite [Datenplattform](https://handbook.gitlab.com/handbook/enterprise-data/platform/) Snowflake. Bei GitLab haben wir drei Speicherebenen:\n\n\n1. `raw`-Ebene – erster Landepunkt für unverarbeitete Daten aus externen Quellen; noch nicht für geschäftliche Nutzung bereit\n\n2. `prep`-Ebene – erste Transformationsebene mit Quellmodellen; noch nicht für allgemeine geschäftliche Nutzung bereit\n\n3. `prod`-Ebene – final transformierte Daten, bereit für geschäftliche Nutzung und Tableau-Berichte\n\n\n![Diagramm der Speicherebenen](https://res.cloudinary.com/about-gitlab-com/image/upload/v1758030995/zo7vespktzfdtdtiauz7.png)\n\n\nFür diese Anleitung sind die Daten bereits durch unsere Extraktionslösung Fivetran in der raw-Ebene gelandet, und wir werden dbt-Modelle generieren, die die Daten von der `prep`-Ebene zur `prod`-Ebene verarbeiten.\n\n\nOhne eine einzige Zeile dbt-Code selbst schreiben zu müssen, werden wir am Ende der Anleitung Folgendes haben:\n\n\n* **Quellmodelle** in der prep-Ebene\n\n* **Workspace-Modelle** in der prod-Ebene\n\n* **Vollständige dbt-Konfigurationen** für alle 13 Tabellen (einschließlich 112 Spalten) im Reddit Ads-Datensatz\n\n* **Test-Abfragen** zur Validierung der Ergebnisse\n\n\nDer gesamte Prozess dauert weniger als 10 Minuten – im Vergleich zu den Stunden, die normalerweise dafür benötigt würden. Hier sind die zu befolgenden Schritte:\n\n\n## 1. Die Datenstruktur vorbereiten\n\n\nBevor GitLab Duo unsere Modelle generieren kann, muss es die vollständige Tabellenstruktur verstehen. Der Schlüssel liegt darin, eine Abfrage gegen Snowflakes Informationsschema auszuführen, da wir derzeit untersuchen, wie wir GitLab Duo über das Model Context Protocol ([MCP](https://about.gitlab.com/topics/ai/model-context-protocol/)) mit unserer Snowflake-Instanz verbinden können:\n\n\n```sql\n\nSELECT \n    table_name,\n    column_name,\n    data_type,\n    is_nullable,\n    CASE \n        WHEN is_nullable = 'NO' THEN 'PRIMARY_KEY'\n        ELSE NULL \n    END as key_type\nFROM raw.information_schema.columns\n\nWHERE table_schema = 'REDDIT_ADS'\n\nORDER BY table_name, ordinal_position;\n\n```\n\n\nDiese Abfrage erfasst:\n\n\n* Alle Tabellen- und Spaltennamen\n\n* Datentypen für die korrekte Modellstruktur\n\n* Nullable-Einschränkungen\n\n* Primärschlüssel-Identifikation (nicht-nullable Spalten in diesem Datensatz)\n\n\n**Profi-Tipp:** Im Reddit Ads-Datensatz dienen alle nicht-nullable Spalten als Primärschlüssel – ein Muster. Ich habe dies überprüft, indem ich Tabellen wie `ad_group` kontrollierte, die zwei nicht-nullable Spalten (`account_id` und `id`) hat, die beide als Primärschlüssel markiert sind. Die Ausführung dieser Abfrage lieferte 112 Zeilen Metadaten, die ich als CSV-Datei für die Modellgenerierung exportierte. Während dieser manuelle Schritt heute gut funktioniert, untersuchen wir eine direkte Integration von GitLab Duo mit unserer Datenplattform über MCP, um diesen Prozess vollständig zu automatisieren.\n\n\n## 2. GitLab Duo einrichten\n\n\nEs gibt zwei Möglichkeiten, mit [GitLab Duo](https://docs.gitlab.com/user/get_started/getting_started_gitlab_duo/) zu interagieren:\n\n\n1. **Web-UI-Chat-Funktion**\n\n2. **Visual Studio Code-Plugin**\n\n\nIch habe mich für das VS Code-Plugin entschieden, da ich die dbt-Modelle lokal ausführen kann, um sie zu testen.\n\n\n## 3. Den 'magischen' Prompt eingeben\n\n\nHier ist der exakte Prompt, den ich zur Generierung des gesamten dbt-Codes verwendet habe:\n\n\n```yaml\n\nCreate dbt models for all the tables in the file structure.csv.\n\n\nI want to have the source models created, with a filter that dedupes the data based on the primary key. Create these in a new folder reddit_ads.\n\nI want to have workspace models created and store these in the workspace_marketing schema.\n\n\nTake this MR as example: [I've referenced to previous source implementation]. Here is the same done for Source A, but now it needs to be done for Reddit Ads. \n\n\nPlease check the dbt style guide when creating the code: https://handbook.gitlab.com/handbook/enterprise-data/platform/dbt-guide/\n\n```\n\n\nSchlüsselelemente, die diesen Prompt effektiv machten:\n\n\n* **Klare Spezifikationen** für sowohl Quell- als auch Workspace-Modelle\n\n* **Referenzbeispiel** aus einem vorherigen ähnlichen Merge Request\n\n* **Style Guide-Referenz** zur Sicherstellung von Codequalität und Konsistenz\n\n* **Spezifisches Schema-Targeting** für ordnungsgemäße Organisation\n\n\n## 4. GitLab Duos Prozess\n\n\nNach dem Einreichen des Prompts machte sich GitLab Duo an die Arbeit. Der gesamte Generierungsprozess dauerte einige Minuten, während dessen GitLab Duo:\n\n\n1. **Die CSV-Eingabedatei las und analysierte**\n\n2. **Tabellenstrukturen aus den Metadaten untersuchte**\n\n3. **Unseren dbt-Style-Guide als Referenz für Coding-Standards nutzte**\n\n4. **Ähnliche Merge Requests berücksichtigte** für die korrekte Strukturierung\n\n5. **Quellmodelle für alle 13 Tabellen generierte**\n\n6. **Workspace-Modelle für alle 13 Tabellen erstellte**\n\n7. **Unterstützende dbt-Dateien generierte**:\n\n   * `sources.yml`-Konfiguration\n   * `schema.yml`-Dateien mit Tests und Dokumentation\n   * Aktualisierte `dbt_project.yml` mit Schema-Referenzen\n\n## Die Ergebnisse\n\n\nDie Ausgabe war bemerkenswert:\n\n\n* **1 modifizierte Datei:** dbt_project.yml (reddit_ads Schema-Konfiguration hinzugefügt)\n\n* **29 neue Dateien:**\n\n  * **26 dbt-Modelle** (13 Quell- + 13 Workspace-Modelle)\n  * **3 YAML-Dateien**\n* **Fast 900 Zeilen Code** automatisch generiert\n\n* **Integrierte Daten-Tests,** einschließlich Unique-Constraints auf Primärschlüssel-Spalten\n\n* **Generische Beschreibungen** für alle Modelle und Spalten\n\n* **Saubere Deduplizierungs-Logik** in Quellmodellen\n\n* **Saubere, konsistente Code-Struktur** gemäß dem GitLab dbt-Style-Guide\n\n\n```yaml\n\ntransform/snowflake-dbt/\n\n├── dbt_project.yml                                                    [MODIFIZIERT]\n\n└── models/\n    ├── sources/\n    │   └── reddit_ads/\n    │       ├── reddit_ads_ad_group_source.sql                        [NEU]\n    │       ├── reddit_ads_ad_source.sql                              [NEU]\n    │       ├── reddit_ads_business_account_source.sql                [NEU]\n    │       ├── reddit_ads_campaign_source.sql                        [NEU]\n    │       ├── reddit_ads_custom_audience_history_source.sql         [NEU]\n    │       ├── reddit_ads_geolocation_source.sql                     [NEU]\n    │       ├── reddit_ads_interest_source.sql                        [NEU]\n    │       ├── reddit_ads_targeting_community_source.sql             [NEU]\n    │       ├── reddit_ads_targeting_custom_audience_source.sql       [NEU]\n    │       ├── reddit_ads_targeting_device_source.sql                [NEU]\n    │       ├── reddit_ads_targeting_geolocation_source.sql           [NEU]\n    │       ├── reddit_ads_targeting_interest_source.sql              [NEU]\n    │       ├── reddit_ads_time_zone_source.sql                       [NEU]\n    │       ├── schema.yml                                            [NEU]\n    │       └── sources.yml                                           [NEU]\n    └── workspaces/\n        └── workspace_marketing/\n            └── reddit_ads/\n                ├── schema.yml                                        [NEU]\n                ├── wk_reddit_ads_ad.sql                              [NEU]\n                ├── wk_reddit_ads_ad_group.sql                        [NEU]\n                ├── wk_reddit_ads_business_account.sql                [NEU]\n                ├── wk_reddit_ads_campaign.sql                        [NEU]\n                ├── wk_reddit_ads_custom_audience_history.sql         [NEU]\n                ├── wk_reddit_ads_geolocation.sql                     [NEU]\n                ├── wk_reddit_ads_interest.sql                        [NEU]\n                ├── wk_reddit_ads_targeting_community.sql             [NEU]\n                ├── wk_reddit_ads_targeting_custom_audience.sql       [NEU]\n                ├── wk_reddit_ads_targeting_device.sql                [NEU]\n                ├── wk_reddit_ads_targeting_geolocation.sql           [NEU]\n                ├── wk_reddit_ads_targeting_interest.sql              [NEU]\n                └── wk_reddit_ads_time_zone.sql                       [NEU]\n```\n\n\n### Beispiel des generierten Codes\n\n\nHier ist ein Beispiel für die Qualität des generierten Codes. Für die `time_zone`-Tabelle erstellte GitLab Duo:\n\n\n**Prep-Ebene Quellmodell**\n\n\n```sql\n\nWITH source AS (\n  SELECT *\n  FROM {{ source('reddit_ads','time_zone') }}\n  QUALIFY ROW_NUMBER() OVER (PARTITION BY id ORDER BY _fivetran_synced DESC) = 1\n),\n\n\nrenamed AS (\n  SELECT\n    id::VARCHAR                               AS time_zone_id,\n    code::VARCHAR                             AS time_zone_code,\n    dst_offset::NUMBER                        AS time_zone_dst_offset,\n    is_dst_active::BOOLEAN                    AS is_time_zone_dst_active,\n    name::VARCHAR                             AS time_zone_name,\n    offset::NUMBER                            AS time_zone_offset,\n    _fivetran_synced::TIMESTAMP               AS fivetran_synced_at\n  FROM source\n)\n\n\nSELECT * FROM renamed\n\n```\n\n\n**Schema.yml**\n\n\n```yaml\n\nmodels:\n  - name: reddit_ads_time_zone_source\n    description: Zeitzonendaten aus dem Reddit Ads-System\n    columns:\n      - name: time_zone_id\n        description: Eindeutige Kennung für Zeitzoneneinträge\n        data_tests:\n          - unique\n          - not_null\n      - name: time_zone_code\n        description: Code für die Zeitzone\n      - name: time_zone_dst_offset\n        description: Sommerzeitverschiebung für die Zeitzone\n      - name: is_time_zone_dst_active\n        description: Flag, das angibt, ob Sommerzeit aktiv ist\n      - name: time_zone_name\n        description: Name der Zeitzone\n      - name: time_zone_offset\n        description: Verschiebung für die Zeitzone\n      - name: fivetran_synced_at\n        description: Zeitstempel, wann der Datensatz zuletzt von Fivetran synchronisiert wurde\n```\n\n\n**Source.yml**\n\n\n```yaml\n\nsources:\n  - name: reddit_ads\n    database: RAW\n    schema: reddit_ads\n    loaded_at_field: _fivetran_synced\n    loader: fivetran\n    description: Reddit Ads-Daten\n\n    quoting:\n      database: true\n      schema: false\n      identifier: false\n\n    tables:\n      - name: time_zone\n```\n\n\n**Workspace-Modell**\n\n\n```sql\n\nWITH source AS (\n  SELECT *\n  FROM {{ ref('reddit_ads_time_zone_source') }}\n)\n\n\nSELECT * FROM source\n\n```\n\n\n## 5. Qualitätsvalidierung\n\n\nNachdem der Code gut aussah, habe ich ihn zum MR gepusht und die [CI-Test-Pipeline](https://handbook.gitlab.com/handbook/enterprise-data/platform/ci-jobs/#build_changes) ausgeführt, um den Code zu testen und das Ergebnis zu validieren. Ich bat GitLab Duo, eine Validierungsabfrage zu erstellen:\n\n\n```yaml\n\nCreate a test query to test the row counts between the raw layer and the workspace layer. Keep in mind that we do deduplication, so we can compare both using distinct on the primary keys.\n\n```\n\n\nDie KI generierte eine umfassende Validierungsabfrage, die:\n\n\n* Zeilenanzahlen zwischen raw- und workspace-Ebenen verglich\n\n* Die Deduplizierungs-Logik berücksichtigte\n\n* Alle 13 Tabellen testete\n\n* Datenerhaltungsprozentsätze berechnete\n\n\n\u003Cdetails>\n\n\u003Csummary>Generierte SQL-Test-Abfrage\u003C/summary>\n\n\n```sql\n\n-- Reddit Ads Zeilenanzahl-Validierungstest\n\n-- Vergleicht eindeutige Zählungen zwischen RAW-Ebene und WORKSPACE_MARKETING-Ebene\n\n-- Berücksichtigt Deduplizierungs-Logik in Quellmodellen\n\n\nWITH raw_counts AS (\n  -- Tabellen mit einzelnem Primärschlüssel\n  SELECT 'ad' AS table_name, COUNT(DISTINCT id) AS raw_count\n  FROM RAW.REDDIT_ADS.AD\n  \n  UNION ALL\n  \n  SELECT 'business_account' AS table_name, COUNT(DISTINCT id) AS raw_count\n  FROM RAW.REDDIT_ADS.BUSINESS_ACCOUNT\n  \n  UNION ALL\n  \n  SELECT 'campaign' AS table_name, COUNT(DISTINCT id) AS raw_count\n  FROM RAW.REDDIT_ADS.CAMPAIGN\n  \n  UNION ALL\n  \n  SELECT 'custom_audience_history' AS table_name, COUNT(DISTINCT id) AS raw_count\n  FROM RAW.REDDIT_ADS.CUSTOM_AUDIENCE_HISTORY\n  \n  UNION ALL\n  \n  SELECT 'geolocation' AS table_name, COUNT(DISTINCT id) AS raw_count\n  FROM RAW.REDDIT_ADS.GEOLOCATION\n  \n  UNION ALL\n  \n  SELECT 'interest' AS table_name, COUNT(DISTINCT id) AS raw_count\n  FROM RAW.REDDIT_ADS.INTEREST\n  \n  UNION ALL\n  \n  SELECT 'time_zone' AS table_name, COUNT(DISTINCT id) AS raw_count\n  FROM RAW.REDDIT_ADS.TIME_ZONE\n  \n  -- Tabellen mit zusammengesetzten Primärschlüsseln\n  UNION ALL\n  \n  SELECT 'ad_group' AS table_name, COUNT(DISTINCT CONCAT(account_id, '|', id)) AS raw_count\n  FROM RAW.REDDIT_ADS.AD_GROUP\n  \n  UNION ALL\n  \n  SELECT 'targeting_community' AS table_name, COUNT(DISTINCT CONCAT(ad_group_id, '|', community_id)) AS raw_count\n  FROM RAW.REDDIT_ADS.TARGETING_COMMUNITY\n  \n  UNION ALL\n  \n  SELECT 'targeting_custom_audience' AS table_name, COUNT(DISTINCT CONCAT(ad_group_id, '|', custom_audience_id)) AS raw_count\n  FROM RAW.REDDIT_ADS.TARGETING_CUSTOM_AUDIENCE\n  \n  UNION ALL\n  \n  SELECT 'targeting_device' AS table_name, COUNT(DISTINCT _fivetran_id) AS raw_count\n  FROM RAW.REDDIT_ADS.TARGETING_DEVICE\n  \n  UNION ALL\n  \n  SELECT 'targeting_geolocation' AS table_name, COUNT(DISTINCT CONCAT(ad_group_id, '|', geolocation_id)) AS raw_count\n  FROM RAW.REDDIT_ADS.TARGETING_GEOLOCATION\n  \n  UNION ALL\n  \n  SELECT 'targeting_interest' AS table_name, COUNT(DISTINCT CONCAT(ad_group_id, '|', interest_id)) AS raw_count\n  FROM RAW.REDDIT_ADS.TARGETING_INTEREST\n),\n\n\nworkspace_counts AS (\n  -- Workspace-Ebene zählt unter Verwendung von Primärschlüsseln aus schema.yml\n  SELECT 'ad' AS table_name, COUNT(DISTINCT ad_id) AS workspace_count\n  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_AD\n  \n  UNION ALL\n  \n  SELECT 'business_account' AS table_name, COUNT(DISTINCT business_account_id) AS workspace_count\n  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_BUSINESS_ACCOUNT\n  \n  UNION ALL\n  \n  SELECT 'campaign' AS table_name, COUNT(DISTINCT campaign_id) AS workspace_count\n  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_CAMPAIGN\n  \n  UNION ALL\n  \n  SELECT 'custom_audience_history' AS table_name, COUNT(DISTINCT custom_audience_id) AS workspace_count\n  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_CUSTOM_AUDIENCE_HISTORY\n  \n  UNION ALL\n  \n  SELECT 'geolocation' AS table_name, COUNT(DISTINCT geolocation_id) AS workspace_count\n  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_GEOLOCATION\n  \n  UNION ALL\n  \n  SELECT 'interest' AS table_name, COUNT(DISTINCT interest_id) AS workspace_count\n  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_INTEREST\n  \n  UNION ALL\n  \n  SELECT 'time_zone' AS table_name, COUNT(DISTINCT time_zone_id) AS workspace_count\n  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_TIME_ZONE\n  \n  -- Tabellen mit zusammengesetzten Primärschlüsseln\n  UNION ALL\n  \n  SELECT 'ad_group' AS table_name, COUNT(DISTINCT CONCAT(ad_group_account_id, '|', ad_group_id)) AS workspace_count\n  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_AD_GROUP\n  \n  UNION ALL\n  \n  SELECT 'targeting_community' AS table_name, COUNT(DISTINCT CONCAT(targeting_community_ad_group_id, '|', targeting_community_id)) AS workspace_count\n  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_TARGETING_COMMUNITY\n  \n  UNION ALL\n  \n  SELECT 'targeting_custom_audience' AS table_name, COUNT(DISTINCT CONCAT(targeting_custom_audience_ad_group_id, '|', targeting_custom_audience_id)) AS workspace_count\n  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_TARGETING_CUSTOM_AUDIENCE\n  \n  UNION ALL\n  \n  SELECT 'targeting_device' AS table_name, COUNT(DISTINCT targeting_device_fivetran_id) AS workspace_count\n  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_TARGETING_DEVICE\n  \n  UNION ALL\n  \n  SELECT 'targeting_geolocation' AS table_name, COUNT(DISTINCT CONCAT(targeting_geolocation_ad_group_id, '|', targeting_geolocation_id)) AS workspace_count\n  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_TARGETING_GEOLOCATION\n  \n  UNION ALL\n  \n  SELECT 'targeting_interest' AS table_name, COUNT(DISTINCT CONCAT(targeting_interest_ad_group_id, '|', targeting_interest_id)) AS workspace_count\n  FROM REDDIT_DBT_MODEL_GENERATION_PROD.WORKSPACE_MARKETING.WK_REDDIT_ADS_TARGETING_INTEREST\n)\n\n\n-- Abschließender Vergleich mit Validierungsergebnissen\n\nSELECT \n  r.table_name,\n  r.raw_count,\n  w.workspace_count,\n  r.raw_count - w.workspace_count AS count_difference,\n  CASE \n    WHEN r.raw_count = w.workspace_count THEN '✅ BESTANDEN'\n    WHEN r.raw_count > w.workspace_count THEN '⚠️ RAW > WORKSPACE (Erwartet durch Deduplizierung)'\n    ELSE '❌ FEHLGESCHLAGEN - WORKSPACE > RAW (Unerwartet)'\n  END AS validation_status,\n  ROUND((w.workspace_count::FLOAT / r.raw_count::FLOAT) * 100, 2) AS data_retention_percentage\nFROM raw_counts r\n\nJOIN workspace_counts w ON r.table_name = w.table_name\n\nORDER BY r.table_name;\n\n```\n\n\n\u003C/details>\n\n\n![Tabelle mit Abfrageergebnissen](https://res.cloudinary.com/about-gitlab-com/image/upload/v1758030995/guicjhzwvrz3czwjs3xo.png)\n\n\nDie Ausführung dieser Abfrage zeigte:\n\n\n* **Null Unterschiede** in der Zeilenanzahl nach Deduplizierung\n\n* **100% Datenerhaltung** über alle Tabellen hinweg\n\n* **Alle Tests erfolgreich bestanden**\n\n\n## Das Fazit: Massive Zeitersparnis\n\n\n* **Traditioneller Ansatz:** 6-8 Stunden manuelles Programmieren, Testen und Debugging\n\n* **GitLab Duo-Ansatz:** 6-8 Minuten Generierung + Überprüfungszeit\n\n\nDies bedeutet eine 60-fache Verbesserung der Entwicklereffizienz (von 6-8 Stunden auf 6-8 Minuten) bei gleichbleibend hoher Codequalität.\n\n\n## Best Practices für den Erfolg\n\n\nBasierend auf dieser Erfahrung sind hier die wichtigsten Empfehlungen:\n\n\n### Bereite deine Metadaten vor\n\n\n* Extrahiere vollständige Tabellenstrukturen einschließlich Datentypen und Einschränkungen\n\n* Identifiziere Primärschlüssel und Beziehungen im Voraus\n\n* Exportiere saubere, gut formatierte CSV-Eingabedateien\n\n\n**Hinweis:** Durch die Verbindung von GitLab Duo über MCP mit deinen (Meta-)Daten könntest du diesen manuellen Schritt ausschließen.\n\n\n### Biete klaren Kontext\n\n\n* Referenziere nach Möglichkeit bestehende Beispiel-MRs\n\n* Spezifiziere deine Codierungsstandards und Style Guides\n\n* Sei explizit bei Ordnerstruktur und Namenskonventionen\n\n\n### Validiere gründlich\n\n\n* Erstelle immer Validierungsabfragen für die Datenintegrität\n\n* Teste lokal vor dem Mergen\n\n* Führe deine CI/CD-Pipeline aus, um Probleme zu erkennen\n\n\n### Nutze KI für Folgeaufgaben\n\n\n* Generiere Testabfragen automatisch\n\n* Erstelle Dokumentationsvorlagen\n\n* Baue Validierungsskripte\n\n\n## Was kommt als Nächstes\n\n\nDiese Demonstration zeigt, wie KI-gestützte Entwicklungstools wie GitLab Duo auch Data-Engineering-Workflows transformieren. Die Fähigkeit, Hunderte von Zeilen produktionsreifem Code in Minuten zu generieren – komplett mit Tests, Dokumentation und ordnungsgemäßer Struktur – stellt einen fundamentalen Wandel dar, wie wir an repetitive Entwicklungsaufgaben herangehen.\n\n\nIndem wir KI nutzen, um die repetitiven Aspekte der dbt-Modellerstellung zu bewältigen, können sich Dateningenieure auf Aktivitäten mit höherem Wert konzentrieren, wie Datenmodellierungsstrategie, Performance-Optimierung und Implementierung von Geschäftslogik.\n\n\n**Bereit, es selbst auszuprobieren?** Beginne mit einem kleinen Datensatz, bereite deine Metadaten sorgfältig vor und sieh zu, wie GitLab Duo Stunden an Arbeit in Minuten automatisierter Generierung verwandelt.\n\n\n> [Teste GitLab Duo Agent Platform noch heute.](https://about.gitlab.com/de-de/gitlab-duo/agent-platform/)\n\n\n## Weiterlesen\n\n\n* [GitLab 18.3: KI-Orchestrierung im Software Engineering erweitern](https://about.gitlab.com/de-de/blog/gitlab-13-expanding-ai-orchestration-in-software-engineering/)\n\n* [GitLab Duo Agent Platform Public Beta: Next-Gen KI-Orchestrierung und mehr](https://about.gitlab.com/de-de/blog/gitlab-duo-agent-platform-public-beta/)\n",{"slug":1329,"featured":90,"template":682},"how-gitlab-duo-agent-platform-transforms-dataops","content:de-de:blog:how-gitlab-duo-agent-platform-transforms-dataops.yml","How Gitlab Duo Agent Platform Transforms Dataops","de-de/blog/how-gitlab-duo-agent-platform-transforms-dataops.yml","de-de/blog/how-gitlab-duo-agent-platform-transforms-dataops",{"_path":1335,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1336,"content":1342,"config":1347,"_id":1349,"_type":13,"title":1350,"_source":15,"_file":1351,"_stem":1352,"_extension":18},"/de-de/blog/how-to-use-gitlabs-custom-compliance-frameworks-in-your-devsecops",{"title":1337,"description":1338,"ogTitle":1337,"ogDescription":1338,"noIndex":6,"ogImage":1339,"ogUrl":1340,"ogSiteName":695,"ogType":696,"canonicalUrls":1340,"schema":1341},"So verwendest du die benutzerdefinierten Compliance Frameworks von GitLab in deiner DevSecOps-Umgebung","Erfahre, wie sich regulatorische Anforderungen durch neue Frameworks zusammen mit mehr als 50 standardmäßigen Kontrollen von lästigen Checklisten in integrierte, automatisierte Workflow-Komponenten verwandeln.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097104/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%284%29_3LZkiDjHLjhqEkvOvBsVKp_1750097104092.png","https://about.gitlab.com/blog/how-to-use-gitlabs-custom-compliance-frameworks-in-your-devsecops","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"So verwendest du die benutzerdefinierten Compliance Frameworks von GitLab in deiner DevSecOps-Umgebung\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Fernando Diaz\"}],\n        \"datePublished\": \"2025-04-30\",\n      }",{"title":1337,"description":1338,"authors":1343,"heroImage":1339,"date":1344,"body":1345,"category":675,"tags":1346},[991],"2025-04-30","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 [benutzerdefinierten Compliance Frameworks (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/introducing-custom-compliance-frameworks-in-gitlab/) 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.\n\n## Was sind die benutzerdefinierten Compliance Frameworks von GitLab?\n\nMit 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.\n\nDie benutzerdefinierten Compliance Frameworks bieten folgende Vorteile:\n* Weniger manuelle Nachverfolgung  \n* Schnellere Bereitschaft für Audits  \n* Native Durchsetzung von Compliance-Kontrollen\n\n![Screenshot des Compliance Centers mit einer Liste der Frameworks](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097114254.png)\n\nIm 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:\n\n* Aufgabentrennung (z. B. mindestens zwei genehmigende Personen und ein(e) Autor(in) für einen Merge Request)   \n* Ausführung von Sicherheitsscannern (z. B. [SAST (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/application_security/sast/) und [Abhängigkeitssuche (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/application_security/dependency_scanning/)  \n* Authentifizierung/Genehmigung (z. B. keine öffentliche Projektsichtbarkeit und AuthSSO erforderlich)  \n* Anwendungskonfiguration (z. B. Statusprüfungen und Terraform erforderlich)\n\nDarüber hinaus kannst du externe Umgebungskontrollen über die GitLab-API konfigurieren, um den Status und die Details einer externen Umgebung zu überprüfen.\n\n## Entwickeln eines benutzerdefinierten Compliance Frameworks von Grund auf\n\nNachdem 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. \n\n**Hinweis:** Dazu ist ein GitLab-Ultimate-Abonnement erforderlich.\n\n\u003C!-- TODO: EMBED_YT_VIDEO -->\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/bSwwv5XeMdQ?si=unDwCltF4vTHT4mB\" title=\"Adhering to compliance requirements with built-in compliance controls\n\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n**Schritt 1: Definiere deine Compliance-Anforderungen**\n\nBevor du dein benutzerdefiniertes Framework erstellst, musst du zunächst deine Compliance-Anforderungen klar definieren:\n\n1. **Identifiziere die geltenden Vorschriften:** Bestimme, welche Vorschriften und Standards für dein Unternehmen gelten (z. B. DSGVO, PCI DSS und HIPAA). \n2. **Ordne die Anforderungen den Kontrollen zu:** Unterteile jede Vorschrift in konkrete umsetzbare Kontrollen.  \n3. **Priorisiere die Anforderungen:** Konzentriere dich auf die Bereiche mit hohem Risiko sowie die Anforderungen mit der größten Wirkung.\n\n**Schritt 2: Entwickle dein benutzerdefiniertes Compliance Framework**\n\nSo entwickelst du ein benutzerdefiniertes Compliance Framework in GitLab:\n\n1. Navigiere in deiner GitLab-Gruppe zum Abschnitt **Sichern > Compliance Center**.  \n2. Klicke auf die Schaltfläche **Neues Framework**.  \n3. Wähle **Leeres Framework erstellen** aus.\n\n![Bildschirm zum Erstellen eines benutzerdefinierten Compliance Frameworks](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image7_aHR0cHM6_1750097114255.png)\n\n4. Gib einen Namen, eine Beschreibung und eine Farbe für dein Framework ein.\n\n![Bildschirm „Neues Compliance Framework“](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image6_aHR0cHM6_1750097114257.png)\n\n5. Füge dem Framework eine Anforderung hinzu:  \n   a. Scrolle nach unten zum Tab **Anforderungen**.\n\n   b. Klicke auf die Schaltfläche **Neue Anforderung**.\n\n   c. Gib einen Namen und eine Beschreibung ein.\n   d. Wähle im Abschnitt **Kontrollen** **GitLab-Kontrolle auswählen** aus.  \n   e. Wähle eine Kontrolle aus der Liste aus (z. B. mindestens zwei Genehmigungen, SAST wird ausgeführt).  \n   f. Klicke auf die Schaltfläche **Anforderung erstellen**.\n\n![Schaltfläche „Neue Anforderung erstellen“](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097114258.png)\n\n6. Klicke auf die Schaltfläche **Framework erstellen**.\n\nDas 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 [importiert](http://TODO) werden.\n\n**Schritt 3: Wende das Framework auf Projekte an**\n\nSobald dein Framework erstellt wurde, gehst du wie folgt vor:\n1. Wähle im Compliance Center die Registerkarte **Projekte** aus.  \n2. **Suche** mit dem Suchfeld oder **filtere** die Ergebnisse.  \n3. Wähle die Projekte aus, auf die du dein Framework anwenden möchtest.  \n4. Klicke auf die Schaltfläche **Eine Massenaktion auswählen**.  \n5. Wähle **Frameworks auf ausgewählte Projekte anwenden** aus.  \n6. Klicke auf die Schaltfläche **Frameworks auswählen**.  \n7. Wähle deine Frameworks aus der Liste aus.  \n8. Klicke auf die Schaltfläche **Anwenden**.\n\n![Compliance-Center-Fenster mit Dropdown-Liste für das SOC-2-Framework](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image5_aHR0cHM6_1750097114260.png)\n\nDas Framework wird nun auf das Projekt angewendet, wodurch seine Anforderungen sichtbar und nachvollziehbar werden.\n\n**Schritt 4: Überwache die Compliance und erstelle dazu entsprechende Berichte**\n\nSobald dein Framework eingerichtet ist, kannst du Folgendes tun:\n\n1. Im **Compliance Center** kannst du den Compliance-Status über alle Projekte hinweg verfolgen, einschließlich Details und vorgeschlagener Korrekturen für fehlgeschlagene Kontrollen.\n2. Erstelle **Compliance-Berichte** für Audits und Stakeholder-Reviews.  \n3. Richte **Compliance-Alarme** ein, um die Stakeholder über mögliche Compliance-Probleme zu informieren. \n4. Überprüfe **Audit Events**, um einen Überblick über die Maßnahmen zu erhalten, die im Zusammenhang mit den Compliance-Einstellungen ergriffen wurden.\n\n![Bildschirm des Compliance Centers mit SOC-2-Test-Framework](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750097114263.png)\n\n## Praxisbeispiel: Implementierung eines SOC 2 Compliance Frameworks\n\nSystem 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 [Leitfaden zur Erfüllung der SOC-2-Sicherheitsanforderungen mit GitLab (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/guide-to-fulfilling-soc-2-security-requirements-with-gitlab/).\n\nSehen 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:\n\n* Implementierung von Kontrollen zum Schutz vor unbefugtem Zugriff  \n* Einrichtung von Verfahren zur Identifizierung und Minderung von Risiken  \n* Einrichtung von Systemen zur Erkennung von und zum Umgang mit sicherheitsrelevanten Vorfällen\n\n**Haftungsausschlussklausel:** 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.\n\nEin benutzerdefiniertes Compliance Framework für SOC 2 sieht bei Verwendung einiger standardmäßiger Kontrollen von GitLab wie folgt aus:\n\n* **Name:** SOC-2-Sicherheitsanforderungen  \n* **Beschreibung:** Ergänzt die Sicherheitsanforderungen für die Einhaltung des SOC-2-Frameworks \n* **Anforderungen:**  \n  * **Implementierung von Kontrollen zum Schutz vor unbefugtem Zugriff**  \n    * Aktivierung von Auth SSO\n    * Aktivierung des CI/CD-Job-Token-Bereichs\n    * MFA auf Organisationsebene erforderlich \n   * **Richte Verfahren zur Identifizierung und Minderung von Risiken ein**\n    * Mindestens zwei genehmigende Personen\n    * Autor(in) hat den Merge Request genehmigt \n    * Die Committer haben den Merge Request genehmigt  \n    * Standard-Branch ist geschützt  \n  * **Einrichtung von Systemen zur Erkennung von und zum Umgang mit sicherheitsrelevanten Vorfällen**  \n    * Abhängigkeitssuche wird ausgeführt    \n    * SAST wird ausgeführt  \n    * DAST wird ausgeführt\n\nWenn 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.\n\n## Implementiere Sicherheitsrichtlinien, um sicherzustellen, dass die Compliance-Anforderungen erfüllt werden\n\nObwohl 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. \n\nGitLab bietet verschiedene Sicherheitsrichtlinien (Dokumentation nur in englischer Sprache verfügbar):\n\n* [Scan-Ausführungsrichtlinie](https://docs.gitlab.com/user/application_security/policies/scan_execution_policies/): Erzwingt Sicherheitsscans, entweder als Teil der Pipeline oder nach einem festgelegten Zeitplan.  \n* [Merge-Request-Approvalrichtlinie](https://docs.gitlab.com/user/application_security/policies/merge_request_approval_policies/): Erzwingt Einstellungen auf Projektebene und Approvalregeln auf Basis der Ergebnisse des Scans.  \n* [Pipeline-Ausführungsrichtlinie](https://docs.gitlab.com/user/application_security/policies/pipeline_execution_policies/): Erzwingt CI/CD-Jobs als Teil von Projekt-Pipelines. \n* [Richtlinie zum Sicherheitslückenmanagement](https://docs.gitlab.com/user/application_security/policies/vulnerability_management_policy/): Behebt automatisch Sicherheitslücken, die im Standard-Branch nicht mehr erkannt werden.\n\nWir 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:\n\n1. Navigiere zu einem Projekt mit einem benutzerdefinierten Compliance Framework, das einen **SAST-Scan** erfordert. \n2. Wähle in der Seitenleiste **Sichern > Richtlinien** aus.  \n3. Klicke auf die Schaltfläche **Neue Richtlinie**.  \n4. Klicke unter **Scan-Ausführungsrichtlinien** auf die Schaltfläche **Richtlinie auswählen**. \n5. Gib den **Namen** und die **Beschreibung** ein. \n6. Wähle unter **Aktionen** **SAST** als auszuführenden Scan aus.\n\n![Aktionsbildschirm](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image8_aHR0cHM6_1750097114264.png)\n\n7. Wähle unter **Bedingungen** die Pipeline aus, die ausgelöst werden soll, wenn eine Pipeline für alle Branches ausgeführt wird.\n\n![Bildschirm „Bedingungen“](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097114265.png)\n\n8. Klicke auf die Schaltfläche **Mit einem Merge Request konfigurieren**.  \n9. In einem separaten Projekt wird nun ein MR erstellt, der alle Sicherheitsrichtlinien enthält, die für dieses Projekt gelten.\n10. Klicke auf die Schaltfläche **Zusammenführen**.\n\nJetzt 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.\n\n## 5 Best Practices, die du beachten solltest \n\nSo maximierst du den Wert benutzerdefinierter Compliance Frameworks:\n\n1. **Fang klein an:** Beginne mit einer kritischen Vorschrift oder einem Standard, bevor du sukzessive erweiterst.  \n2. **Beteilige die wichtigsten Stakeholder:** Beziehe die Compliance-, Sicherheits- und Entwicklungsteams in die Erstellung des Frameworks ein.  \n3. **Automatisiere, wo möglich:** Verwende GitLab CI/CD, um Compliance-Überprüfungen zu automatisieren.  \n4. **Sorge für eine gründliche Dokumentation:** Pflege eine klare Dokumentation darüber, wie dein Framework den gesetzlichen Anforderungen entspricht.  \n5. **Regelmäßige Überprüfungen:** Aktualisiere deine Frameworks, wenn sich die Vorschriften ändern oder neue Anforderungen entstehen.\n\n## Leg noch heute los\n\nDie 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.\n\nDurch 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.\n\nDa 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.\n\n> Melde dich für deine [kostenlose Testversion von GitLab Ultimate](https://about.gitlab.com/de-de/free-trial/) an, um die benutzerdefinierten Compliance Frameworks noch heute auszuprobieren.\n\n## Mehr erfahren \n\nIn diesen Ressourcen erfährst du mehr über benutzerdefinierte Compliance Frameworks und ihre Vorteile für dein Unternehmen:\n\n* [Dokumentation zu benutzerdefinierten Compliance Frameworks (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/compliance/compliance_center/compliance_status_report/)   \n* [Epic zu benutzerdefinierten Compliance Frameworks](https://gitlab.com/groups/gitlab-org/-/epics/13295)   \n* [Dokumentation der Sicherheitsrichtlinien (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/application_security/policies/)  \n* [Sicherheits- und Compliance-Lösungen von GitLab](https://about.gitlab.com/de-de/solutions/security-compliance/)",[675,705,707,9,677],{"slug":1348,"featured":90,"template":682},"how-to-use-gitlabs-custom-compliance-frameworks-in-your-devsecops","content:de-de:blog:how-to-use-gitlabs-custom-compliance-frameworks-in-your-devsecops.yml","How To Use Gitlabs Custom Compliance Frameworks In Your Devsecops","de-de/blog/how-to-use-gitlabs-custom-compliance-frameworks-in-your-devsecops.yml","de-de/blog/how-to-use-gitlabs-custom-compliance-frameworks-in-your-devsecops",{"_path":1354,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1355,"content":1361,"config":1368,"_id":1370,"_type":13,"title":1371,"_source":15,"_file":1372,"_stem":1373,"_extension":18},"/de-de/blog/introducing-gitlabs-new-planner-role-for-agile-planning-teams",{"ogTitle":1356,"schema":1357,"ogImage":1358,"ogDescription":1359,"ogSiteName":695,"noIndex":6,"ogType":696,"ogUrl":1360,"title":1356,"canonicalUrls":1360,"description":1359},"Neue Rolle \"Planer(in)\" für GitLab Agile-Teams eingeführt","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Jetzt neu in GitLab: die neue Rolle „Planer(in)“ für Teams im Bereich der Agile-Planung\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Amanda Rueda\"}],\n        \"datePublished\": \"2024-11-25\",\n      }","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749662488/Blog/Hero%20Images/blog-image-template-1800x945__3_.png","Erfahre, wie die neue Rolle „Planer(in)“ in GitLab Agile-Teams dabei hilft, Workflows mit maßgeschneidertem Zugriff über SaaS-, Dedicated- und Self-Managed-Lösungen zu planen.","https://about.gitlab.com/blog/introducing-gitlabs-new-planner-role-for-agile-planning-teams",{"heroImage":1358,"body":1362,"authors":1363,"updatedDate":1364,"date":1365,"title":1366,"tags":1367,"description":1359,"category":751},"GitLab hat eine neue Rolle auf der DevSecOps-Plattform eingeführt – Planer(in). Die Rolle als Planer(in) wurde im Rahmen der Strategie von GitLab, eine flexible, rollenbasierte Zugriffskontrolle zu bieten, entwickelt, was sich auch in der Veröffentlichung [benutzerdefinierter Rollen](https://docs.gitlab.com/ee/user/custom_roles.html) zeigt. Als Planer(in) können Entwicklungsteams und für die Planung zuständige Benutzer(innen) Zugang zu den Tools erhalten, die sie brauchen, um Agile-Workflows zu verwalten, ohne dabei zu viele Berechtigungen zu bekommen, die ein unnötiges Risiko darstellen. Indem der Zugriff auf die spezifischen Bedürfnisse der Benutzer(innen) zugeschnitten wird, stellt die Rolle als Planer(in) sicher, dass Teams produktiv bleiben und gleichzeitig die Sicherheit und Compliance wahren – ganz im Sinne des [Prinzips der geringsten Privilegien](https://about.gitlab.com/blog/the-ultimate-guide-to-least-privilege-access-with-gitlab/).\n\n## Warum wir die Rolle „Planer(in)“ entwickelt haben\n\nUnser Weg zu dieser neuen Rolle begann mit dem Feedback unserer Kund(inn)en und internen Teams. Wir haben immer wieder gehört, dass GitLab zwar umfassende Tools für die Planung und die Verwaltung von agilen Entwicklungszyklen hat, aber es eine spezifischere, rollenbasierte Zugriffskontrolle bräuchte. Produktmanager(innen), Projektleitung und andere Planungsrollen brauchen oft Zugriff auf Planungsfunktionen, jedoch nicht die kompletten Entwicklungsberechtigungen. Im Gegenteil: Es ist nicht gewünscht, dass sie breiten Zugriff haben, da dies ein Sicherheitsrisiko darstellt und das Fehlerpotenzial vergrößert, indem beispielsweise unabsichtliche Änderungen am Code oder an sensiblen Konfigurationen vorgenommen werden. Diese Wünsche haben wir uns zu Herzen genommen.\n\nDurch Befragungen von Benutzer(inne)n, Wettbewerbsanalyse und umfassende Forschungen haben wir den Wunsch nach einer Rolle validiert, die vollständigen Zugriff auf Planungstools bietet, aber gleichzeitig die Sicherheit wahrt, indem kein Zugriff auf Funktionen für Entwickler(innen) möglich ist.\n\n## Was hat die Rolle „Planer(in)“ zu bieten?\n\nPlaner(in) ist eine Rolle, die sich zwischen den bestehenden Rollen [„Gast“ und „Reporter(in)“](https://docs.gitlab.com/ee/user/permissions.html#roles) einordnet, aber speziell für jene entwickelt wurde, die Zugriff auf Planungs-Workflows brauchen.\n\nDas erwartet dich:\n\n* Zugriff auf wichtige Planungstools wie Epics, Roadmaps, Issue-Übersichten und [OKRs](https://docs.gitlab.com/ee/user/okrs.html) (*Für einige Funktionen ist eine GitLab-Premium- oder -Ultimate-Lizenz erforderlich*)\n* Verbesserte Sicherheit, indem der unnötige Zugriff auf sensible Entwicklungsfunktionen eingeschränkt wird\n* Die Rolle als Planer(in) kann zusammen mit dem Add-on GitLab Enterprise Agile Planning verwendet werden, wodurch Teams maßgeschneiderten Zugriff auf Planungstools erhalten, während gleichzeitig Sicherheit und Kontrolle gewahrt werden. (*Die Rolle als Planer(in) ist aber in allen Lizenzstufen verfügbar*).\n\nDie Rolle „Planer(in)“ ist in allen GitLab-Lösungen verfügbar, darunter SaaS, GitLab Dedicated und GitLab Self-Managed. So können alle Kund(inn)en von diesem maßgeschneiderten Zugriff profitieren.\nMit dieser Rolle können Teams Berechtigungen flexibel an Jobfunktionen zuweisen, was ein ausgewogenes Maß an Barrierefreiheit und Sicherheit ermöglicht.\n\n## So unterstützt die Rolle als Planer(in) Agile-Praktiken\n\nIn der [Agile-Softwareentwicklung](https://about.gitlab.com/de-de/blog/categories/agile-planning/) ist es entscheidend für die Effizienz von Workflows, dass jedes Teammitglied die richtigen Tools und Berechtigungen für seine Rolle zur Verfügung hat. Die Rolle als Planer(in) unterstützt dies, indem sie es den Mitgliedern des Planungsteams ermöglicht, an allen Planungsphasen des Software-Entwicklungsprozesses mitzuwirken, ohne dass die Gefahr besteht, unabsichtlich in Bereiche wie Entwicklung oder Bereitstellung zu gelangen.\n\nVon der Erstellung und Verwaltung von Epics bis hin zum Festlegen von Roadmaps: Mit der Rolle als Planer(in) haben Agile-Teams nun die Tools zur Verfügung, die sie brauchen, um abgestimmt und produktiv zu bleiben.\n\n## Kundenorientiertes Design\n\nWir haben diese Rolle nicht isoliert entwickelt. Wir haben unsere Community bei jedem Schritt in den Prozess eingebunden. Durch Umfragen, Interviews und Tests haben wir die Berechtigungen äußerst fein abgestimmt und so sichergestellt, dass sie den praktischen Anforderungen von Produkt- und Projektmanager(inne)n entsprechen.\n\nDiese Rolle greift auch die langjährige Mission von GitLab auf, eine Plattform für Agile-Teams auf Unternehmensebene zu sein – sie bietet Unternehmen nämlich die Flexibilität und Kontrolle, um Agile-Methoden in großem Umfang umzusetzen.\n\n## Feedback und Engagement der Community\n\nWir freuen uns über deine Beiträge und bitten dich, deine Erfahrungen mit der neuen Rolle „Planer(in)“ zu teilen. Dein Feedback ist unerlässlich, um dein GitLab-Erlebnis weiter zu verfeinern und zu verbessern. In unserem [Feedback-Ticket](https://gitlab.com/gitlab-org/gitlab/-/issues/503817) kannst du uns deine Gedanken und Vorschläge mitteilen.\n\n## Beginne jetzt mit der Planung – mit GitLab!\n\nDie Rolle als Planer(in) ist nur eine von vielen Möglichkeiten, wie GitLab es Softwareentwicklungsteams ermöglicht, effizient zu planen, zusammenzuarbeiten und zu liefern. Egal, ob du deine Produktmanagement-Workflows optimieren, die Zusammenarbeit deines Teams verbessern oder deine Agile-Praktiken abstimmen möchtest – GitLab hat das passende Tool, das dir zum Erfolg verhilft.\n\n> Möchtest du das volle Potenzial von GitLab erleben? [Melde dich für eine kostenlose Testversion von GitLab Ultimate an](https://about.gitlab.com/de-de/free-trial/) und plane dein nächstes Projekt mit der Rolle „Planer(in)“, die auf die individuellen Bedürfnisse deines Teams zugeschnitten ist.\n\n## Weiterlesen\n- [Beyond Devs: GitLab Enterprise Agile Planning add-on for all roles (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/gitlab-enterprise-agile-planning-add-on-for-all-roles/)\n- [How to use GitLab for Agile software development (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/gitlab-for-agile-software-development/)\n- [First look: The new Agile planning experience in GitLab (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/first-look-the-new-agile-planning-experience-in-gitlab/)",[745],"2024-12-03","2024-11-25","Jetzt neu in GitLab: die neue Rolle „Planer(in)“ für Teams im Bereich der Agile-Planung",[750,707,9,677],{"slug":1369,"featured":90,"template":682},"introducing-gitlabs-new-planner-role-for-agile-planning-teams","content:de-de:blog:introducing-gitlabs-new-planner-role-for-agile-planning-teams.yml","Introducing Gitlabs New Planner Role For Agile Planning Teams","de-de/blog/introducing-gitlabs-new-planner-role-for-agile-planning-teams.yml","de-de/blog/introducing-gitlabs-new-planner-role-for-agile-planning-teams",{"_path":1375,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1376,"content":1382,"config":1389,"_id":1391,"_type":13,"title":1392,"_source":15,"_file":1393,"_stem":1394,"_extension":18},"/de-de/blog/monitor-application-performance-with-distributed-tracing",{"title":1377,"description":1378,"ogTitle":1377,"ogDescription":1378,"noIndex":6,"ogImage":1379,"ogUrl":1380,"ogSiteName":695,"ogType":696,"canonicalUrls":1380,"schema":1381},"Application Performance Monitoring (APM) mit Distributed Tracing","Erfahre, wie Distributed Tracing die Fehlerbehebung bei Problemen mit der Application Performance unterstützt, indem es eine durchgängige Transparenz und eine nahtlose Zusammenarbeit innerhalb deines Unternehmens ermöglicht.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098000/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%288%29_5x6kH5vwjz8cwKgSBh1w11_1750098000511.png","https://about.gitlab.com/blog/monitor-application-performance-with-distributed-tracing","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Application Performance Monitoring (APM) mit Distributed Tracing\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Sacha Guyon\"}],\n        \"datePublished\": \"2024-06-13\",\n      }",{"title":1377,"description":1378,"authors":1383,"heroImage":1379,"date":1385,"body":1386,"category":677,"tags":1387,"updatedDate":1388},[1384],"Sacha Guyon","2024-06-13","Ausfallzeiten aufgrund von Anwendungsfehlern oder Performance-Problemen können für Unternehmen verheerende finanzielle Folgen haben. Laut Information einer [Umfrage der ITIC von 2022](https://itic-corp.com/server-and-application-by-the-numbers-understanding-the-nines/ \"Umfrage der ITIC von 2022\") kostet eine Stunde Ausfallzeit Unternehmen schätzungsweise 301.000 $ oder mehr. Diese Probleme sind häufig auf von Menschen vorgenommene Änderungen zurückzuführen, z. B. Code- oder Konfigurationsänderungen.\n\nUm Probleme schnell zu beheben, müssen Entwicklungs- und Betriebsteams Hand in Hand arbeiten, um die Ursache zu finden und das System zügig wiederherzustellen. Häufig nutzen sie jedoch unterschiedliche Tools, um ihre Anwendungen und Infrastruktur zu verwalten und zu überwachen. Das führt zu isolierten Daten, schlechter Kommunikation und einem unvollständigen Überblick – was die Lösung von Vorfällen verzögert.\n\nGitLab setzt genau hier an und vereint Softwarebereitstellung und Monitoring auf einer Plattform. Letztes Jahr haben wir [Error Tracking](https://docs.gitlab.com/ee/operations/error_tracking.html \"Error Tracking\") in [GitLab 16.0](https://about.gitlab.com/releases/2023/05/22/gitlab-16-0-released/#error-tracking-is-now-generally-available \"GitLab 16.0\") als feste Funktion integriert. Jetzt freuen wir uns, die [Beta-Version von Distributed Tracing](https://docs.gitlab.com/ee/operations/tracing \"Beta-Version von Distributed Tracing\") vorzustellen – der nächste große Schritt zu einem umfassenden Monitoring, das vollständig in die GitLab-DevSecOps-Plattform eingebettet ist.\n\n## Eine neue Ära der Effizienz: GitLab Observability\n\nGitLab Observability ermöglicht es Entwicklungs- und Operationsteams, Fehler, Traces, Protokolle und Metriken aus ihren Anwendungen und ihrer Infrastruktur zu visualisieren und zu analysieren. Durch die Integration des Application Performance Monitoring in bestehende Softwarebereitstellungs-Workflows werden Kontextwechsel minimiert und die Produktivität erhöht, sodass die Teams auf einer einheitlichen Plattform fokussiert zusammenarbeiten können.\n\nDarüber hinaus überbrückt GitLab Observability die Kluft zwischen Entwicklung und Betrieb, indem es Einblicke in die Application Performance in der Produktion gewährt. Dies verbessert die Transparenz, den Informationsaustausch und die Kommunikation zwischen den Teams. Folglich können sie Fehler und Leistungsprobleme, die durch neuen Code oder Konfigurationsänderungen entstehen, schneller und effektiver erkennen und beheben und so verhindern, dass diese Probleme zu größeren Vorfällen eskalieren, die sich negativ auf das Geschäft auswirken könnten.\n\n## Was ist Distributed Tracing?\n\nMit Distributed Tracing können Entwickler(innen) die Ursache von Leistungsproblemen bei Anwendungen und in der Architektur verteilter Systeme ermitteln. Ein Trace stellt eine einzelne Benutzeranfrage dar, die verschiedene Dienste und Systeme durchläuft. Die Entwickler(innen) sind in der Lage, den zeitlichen Ablauf der einzelnen Vorgänge und alle auftretenden Fehler zu analysieren.\n\nJede Protokollierung besteht aus einem oder mehreren Abschnitten, die einzelne Vorgänge oder Arbeitseinheiten darstellen. Spans enthalten Metadaten wie den Namen, Zeitstempel, Status und relevante Tags oder Protokolle. Durch die Untersuchung der Abhängigkeiten zwischen Spans können Entwickler(innen) den Request Flow verstehen, Performance-Engpässe erkennen und Probleme lokalisieren.\n\n### Distributed Tracing in Microservices\n\nDistributed Tracing ist besonders wertvoll für [Microservices-Strukturen](https://about.gitlab.com/de-de/topics/microservices/ \"Microservices-Strukturen\"), bei denen eine einzige Anfrage zahlreiche Serviceaufrufe in einem komplexen System nach sich ziehen kann. Tracing bietet Einblick in diese Interaktion und ermöglicht es den Teams, Probleme schnell zu diagnostizieren und zu beheben.\n\n![Nutzeranfrage beim Distributed Tracing, um Produktempfehlungen abzurufen](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098009/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750098009139.png)\n\nDieses Beispiel veranschaulicht, wie eine Nutzeranfrage verschiedene Dienste durchläuft, um Produktempfehlungen auf einer E-Commerce-Website abzurufen:\n- `User Action`: Dies zeigt die erste Aktion der Nutzer(innen) an, z. B. das Anklicken einer Schaltfläche zur Anforderung von Produktempfehlungen auf einer Produktseite.\n- `Web front-end`: Das Web-Frontend sendet eine Anfrage an den Empfehlungsdienst, um Produktempfehlungen abzurufen.\n- `Recommendation service`: Die Anfrage vom Web-Frontend wird vom Recommendation Service (dt. Empfehlungsservice) bearbeitet, der die Anfrage verarbeitet und eine Liste empfohlener Produkte erstellt.\n- `Catalog service`: Der Recommendation Service ruft den Servicekatalog auf, um Details zu den empfohlenen Produkten abzurufen. Ein Warnsymbol weist auf ein Problem oder eine Verzögerung in dieser Phase hin, z. B. eine zu langsame Rückmeldung oder einen Fehler beim Abrufen von Produktdetails.\n- `Database`: Der Catalog Service fragt die Datenbank ab, um die aktuellen Produktdaten abzurufen. Dieser Bereich zeigt die SQL-Abfrage in der Datenbank.\n\nDurch die Visualisierung dieses End-to-End-Trace können Entwickler(innen) Leistungsprobleme – hier ein Fehler im Servicekatalog – erkennen und Probleme im gesamten Distributionssystem schnell diagnostizieren und beheben.\n\n![Visualisierung des End-to-End-Trace in GitLab](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098009/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750098009140.png)\n\n## Wie funktioniert Distributed Tracing?\n\nIm Folgenden wird die Funktionsweise von Distributed Tracing Tools erläutert.\n\n### Sammeln von Daten aus beliebigen Anwendungen mit OpenTelemetry\n\nTraces und Spans können mit [OpenTelemetry](https://opentelemetry.io/docs/what-is-opentelemetry/ \"OpenTelemetry\") gesammelt werden, einem Open-Source-Framework für Beobachtungen, das eine breite Palette von SDKs und Bibliotheken für [die wichtigsten Programmiersprachen und Frameworks](https://opentelemetry.io/docs/languages/ \"die wichtigsten Programmiersprachen und Frameworks\") unterstützt. Dieses Framework bietet einen herstellerneutralen Ansatz für die Erfassung und den Export von Telemetriedaten, sodass Entwickler(innen) nicht an einen bestimmten Anbieter gebunden sind und die Tools auswählen können, die ihren Anforderungen am besten entsprechen.\n\nDas bedeutet, dass du, wenn du bereits OpenTelemetry mit einem anderen Anbieter verwendest, Daten an uns senden kannst, indem du einfach unseren Endpunkt zu deiner Konfigurationsdatei hinzufügst –so kannst du unsere Funktionen ohne Weiteres ausprobieren!\n\n![Daten aus verschiedenen Anwendungen werden über OpenTelemetry and GitLab Observability geschickt.](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098009/Blog/Content%20Images/Blog/Content%20Images/image5_aHR0cHM6_1750098009141.png)\n\n### Datenerfassung und -speicherung in großem Umfang mit schnellen Echtzeitabfragen\n\nBeobachtbarkeiterfordert die Speicherung und Abfrage riesiger Datenmengen bei gleichzeitiger Beibehaltung niedriger Latenzzeiten für Echtzeit-Analysen. Um diese Anforderungen zu erfüllen, haben wir eine horizontal skalierbare Langzeitspeicherlösung mit ClickHouse und [Kubernetes](https://about.gitlab.com/de-de/solutions/kubernetes/ \"Kubernetes\") entwickelt, die auf unserer Übernahme von Opstrace basiert. Diese [Open-Source-Plattform](https://gitlab.com/gitlab-org/opstrace/opstrace \"Open-Source-Plattform\") gewährleistet eine schnelle Abfrageleistung und Skalierbarkeit auf Unternehmensebene, während gleichzeitig die Kosten minimiert werden.\n\n### Traces mühelos untersuchen und analysieren\n\nEine fortschrittliche Benutzeroberfläche auf nativer Ebene ist entscheidend für eine effektive Datenanalyse. Wir haben eine solche Schnittstelle von Grund auf entwickelt. Der Trace Explorer ermöglicht es den Nutzer(innen), Traces zu untersuchen und die Leistung ihrer Anwendung zu verstehen:\n\n- __Erweiterte Filterung:__ Filtere nach Diensten, Vorgangsnamen, Status und Zeitspanne. Die automatische Vervollständigung vereinfacht die Abfrage.\n- __Fehlerhervorhebung:__ Fehlerbereiche in den Suchergebnissen werden einfach erkannt.\n- __RED-Metriken:__ Visualisiere die Anforderungsrate, die Fehlerrate und die durchschnittliche Dauer in einem Zeitseriendiagramm für jede Suche in Echtzeit.\n- __Timeline-Ansicht:__ Einzelne Traces werden als Wasserfalldiagramm dargestellt. So erhältst du einen vollständigen Überblick über eine Anfrage, die über verschiedene Dienste und Vorgänge verteilt ist.\n- __Historische Daten:__ Nutzer(innen) können bis zu 30 Tage in die Vergangenheit zurückreichende Daten abfragen.\n\n![Tracing Benutzeroberfläche für eine effektive Datenanalyse.](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098009/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750098009141.png)\n\n## Wie wir bei GitLab das Distributed Tracing einsetzen\n\n[Dogfooding](https://handbook.gitlab.com/handbook/values/#dogfooding \"Dogfooding\") ist ein zentraler Wert und eine wichtige Praxis bei GitLab. Wir haben bereits frühere Versionen von Distributed Tracing für unsere technischen und betrieblichen Anforderungen verwendet. Hier sind ein paar Anwendungsbeispiele aus unseren Teams:\n\n### 1. Beheben von Fehlern und Leistungsproblemen in GitLab Agent für Kubernetes\n\nDie [Environments-Gruppe](https://handbook.gitlab.com/handbook/engineering/development/ops/deploy/environments/ \"Environments-Gruppe\") hat Distributed Tracing verwendet, um Probleme mit dem [GitLab Agent für Kubernetes](https://gitlab.com/gitlab-org/cluster-integration/gitlab-agent \"GitLab Agent für Kubernetes\") zu beheben, z. B. Zeitüberschreitungen oder hohe Latenzzeiten. Die Ansichten „Trace List“ und „Trace Timeline“ bieten dem Team wertvolle Einsichten, mit denen sie derartige Probleme effizient lösen können. Diese Traces werden in den [entsprechenden GitLab Issues](https://gitlab.com/gitlab-org/cluster-integration/gitlab-agent/-/issues/386#note_1576431796 \"entsprechenden GitLab Issues\") geteilt und diskutiert, wo das Team dann gemeinsam an der Lösung arbeitet.\n\n*„Die Funktion Distributed Tracing ist von unschätzbarem Wert, wenn es darum geht, festzustellen, wo Latenzprobleme auftreten, sodass wir uns auf die eigentliche Ursache konzentrieren und diese schneller beheben können.“ - Mikhail, GitLab-Ingenieur*\n\n### 2. Optimierung der Dauer der GitLab-Build-Pipeline durch Ermittlung von Leistungsengpässen \n\nLangsame Deployments von GitLab-Quellcode können sich erheblich auf die Produktivität des gesamten Unternehmens sowie auf unsere Rechenleistung auswirken. In unserem Haupt-Repository werden jeden Monat [über 100.000 Pipelines](https://gitlab.com/gitlab-org/gitlab/-/pipelines/charts \"über 100.000 Pipelines\") ausgeführt. Wenn sich die Zeit für die Ausführung dieser Pipelines nur um eine Minute ändert, können dadurch mehr als 2.000 Stunden Arbeitszeit hinzukommen oder wegfallen. Das sind 87 zusätzliche Tage!\n\nUm die Ausführungszeit von Pipelines zu optimieren, verwenden die [Entwicklerteams der GitLab-Plattform](https://handbook.gitlab.com/handbook/engineering/infrastructure/ \"Entwicklerteams der GitLab-Plattform\") ein [speziell entwickeltes Tool](https://gitlab.com/gitlab-com/gl-infra/gitlab-pipeline-trace \"speziell entwickeltes Tool\"), das GitLab-Deployment-Pipelines in Traces umwandelt.\n\nDie Ansicht „Trace Timeline“ ermöglicht es den Teams, die detaillierte Ausführung komplexer Pipelines zu visualisieren und festzustellen, welche Aufträge Teil des kritischen Pfads sind und den gesamten Prozess verlangsamen. Durch die Identifizierung dieser Engpässe können sie die Auftragsausführung optimieren, indem sie z. B. dafür sorgen, dass der Auftrag schneller fehlschlägt oder mehr Aufträge parallel ausgeführt werden, um die Gesamteffizienz der Pipeline zu verbessern.\n\n![Trace Timeline und Details](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098009/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750098009143.gif)\n\nDas Skript ist frei verfügbar, sodass du es für deine eigenen Pipelines anpassen kannst.\n\n*„Der Einsatz von Distributed Tracing für unsere Deployment-Pipelines war ein echter Durchbruch. Es hat uns geholfen, Engpässe schnell zu erkennen und zu beseitigen, was unsere Bereitstellungszeiten erheblich verkürzt hat“ - Reuben, GitLab Engineer*\n\n## Was kommt als Nächstes?\nIn den nächsten Monaten werden wir unsere Beobachtbarkeits- und Monitoring-Funktionen mit den kommenden Versionen Metrics und Logging weiter ausbauen. Weitere Informationen findest du auf unserer Seite zu GitLabObservability.\n\n## Nimm an der privaten Beta teil\nMöchtest du Teil dieser aufregenden Entwicklung sein? Melde dich für die private Beta-Version an und probiere unsere Funktionen aus. Mit deinem Beitrag kannst du die Zukunft der Beobachtbarkeit in GitLab mitgestalten und sicherstellen, dass unsere Tools perfekt auf deine Bedürfnisse und Herausforderungen abgestimmt sind.\n",[884,9,1113,707,1246],"2024-10-23",{"slug":1390,"featured":90,"template":682},"monitor-application-performance-with-distributed-tracing","content:de-de:blog:monitor-application-performance-with-distributed-tracing.yml","Monitor Application Performance With Distributed Tracing","de-de/blog/monitor-application-performance-with-distributed-tracing.yml","de-de/blog/monitor-application-performance-with-distributed-tracing",{"_path":1396,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1397,"content":1403,"config":1408,"_id":1410,"_type":13,"title":1411,"_source":15,"_file":1412,"_stem":1413,"_extension":18},"/de-de/blog/quickly-resolve-broken-ci-cd-pipelines-with-ai",{"title":1398,"description":1399,"ogTitle":1398,"ogDescription":1399,"noIndex":6,"ogImage":1400,"ogUrl":1401,"ogSiteName":695,"ogType":696,"canonicalUrls":1401,"schema":1402},"Beschädigte CI/CD-Pipelines schnell entfernen – mit KI","Wenn deine CI/CD-Pipeline fehlschlägt, führt dies zu Verzögerungen, verminderter Produktivität und Stress. Mit der KI-basierten Root Cause Analysis kannst du Probleme nun rascher und intelligenter lösen.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097355/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%2811%29_78Dav6FR9EGjhebHWuBVan_1750097355230.png","https://about.gitlab.com/blog/quickly-resolve-broken-ci-cd-pipelines-with-ai","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Beschädigte CI/CD-Pipelines schnell entfernen – mit KI\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Itzik Gan Baruch\"}],\n        \"datePublished\": \"2024-12-03\",\n      }",{"title":1398,"description":1399,"authors":1404,"heroImage":1400,"date":1364,"body":1405,"category":703,"tags":1406,"updatedDate":1407},[672],"CI/CD-Pipelines sorgen dafür, dass die Softwareentwicklung effizient abläuft. Sie helfen Teams, Code schnell zu testen, zu erstellen und bereitzustellen. Wenn diese Pipelines jedoch fehlschlagen, verlangsamt sich alles – Fristen werden verpasst und die Entwickler(innen) sind frustriert, da sie die Fehler beheben und dafür sorgen müssen, dass die Projekte trotzdem im Zeitrahmen bleiben.\n\n![CI/CD-Pipeline mit mehreren fehlgeschlagenen Jobs](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097362/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097362772.png)\n\n\u003Ccenter>\u003Ci>CI/CD-Pipeline mit mehreren fehlgeschlagenen Jobs\u003C/i>\u003C/center>\u003Cbr>\u003C/br>\n\n**Warum schlagen Pipelines fehl?** Sehen wir uns das genauer an.\n\n## Gründe für Pipeline-Fehler\n\nEin Pipeline-Fehler tritt auf, wenn der automatisierte Workflow in deiner [CI/CD-Pipeline](https://about.gitlab.com/de-de/topics/ci-cd/cicd-pipeline/) – also in einer Reihe von Schritten, wie Erstellen, Testen und Bereitstellen von Code – nicht wie erwartet ausgeführt wird und mit einer Fehlermeldung endet. Dieser Fehler kann verhindern, dass der Code ordnungsgemäß erstellt, getestet oder bereitgestellt wird, was zu Verzögerungen bei der Softwarebereitstellung führen kann. Zudem ist eine Fehlerbehebung nötig.\n\nPipeline-Fehler können aus einer Vielzahl von Gründen auftreten. Einige häufige Ursachen sind:\n- Syntax-Fehler: Ein kleiner Fehler im Code, wie ein fehlendes Semikolon oder ein falscher Variablenname, kann dazu führen, dass die Pipeline fehlschlägt.\n- Fehlgeschlagene Tests: Unit- oder Integrationstests können aufgrund von fehlerhaftem Code, falschen Konfigurationen oder nicht übereinstimmenden Abhängigkeiten fehlschlagen.\n- Fehlkonfigurationen: Falsche Pipeline-Einstellungen oder Umgebungskonfigurationen können zu fehlgeschlagenen Builds oder Bereitstellungen führen.\n\nEs gibt auch komplexere Probleme, die das Ganze etwas komplizierter machen:\n- Probleme mit Infrastructure-as-Code [IaC](https://about.gitlab.com/de-de/topics/gitops/infrastructure-as-code/): Probleme bei der Bereitstellung der Cloud-Infrastruktur, wie Fehler in Terraform-Skripten oder CloudFormation-Vorlagen, können eine erfolgreiche Bereitstellung verhindern.\n- Kubernetes- und GitOps-Herausforderungen: Fehlkonfigurationen in [Kubernetes-Clustern (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/kubernetes-the-container-orchestration-solution/) oder Probleme mit [GitOps-Workflows](https://about.gitlab.com/de-de/topics/gitops/) (z. B. das Synchronisieren von Kubernetes-Status mit Git-Repositories) können zu Pipeline-Fehlern führen, die nur schwer zu diagnostizieren sind.\n- Lange, unübersichtliche Stack Traces: Wenn ein Fehler tief im System auftritt, können Stack Traces lang werden und somit schwer zu entziffern sein, insbesondere wenn sie mehrere Komponenten oder Dienste umfassen.\n\nDurch diese Herausforderungen wird die Fehlerbehebung schwieriger und zeitaufwändiger, da man sich oft durch komplexe Protokolle arbeiten, Konfigurationsdateien überprüfen und verschiedene Lösungen testen muss, um die Grundursache zu finden.\n\n## Die tatsächlichen Auswirkungen fehlgeschlagener Pipelines\n\nWenn eine Pipeline fehlschlägt, verzögert dies nicht nur die Bereitstellung, sondern sorgt auch für Stress und Frustration. Die Entwickler(innen) müssen ihre Arbeit unterbrechen und den Fehler beheben, was oft zu einer Kettenreaktion an Störungen führen kann. Dies macht es schwieriger, Fristen einzuhalten, und erhöht den Druck auf das gesamte Team. Aber warum ist die manuelle Fehlerbehebung so aufwendig?\n\n### Manuelle Fehlerbehebung \n\nDie Zeit, die benötigt wird, um eine defekte Pipeline zu beheben, variiert. Das hängt unter anderem von folgenden Faktoren ab:\n- Wie gut kennen die Entwickler(innen) das Projekt?\n- Wie erfahren sind sie mit ähnlichen Problemen?\n- Was sind ihre allgemeinen Problemlösungsfähigkeiten?\n\nDas manuelle Durchsuchen von Protokollen, um herauszufinden, was schief gelaufen ist, ist schwierig und mühsam. Protokolle können von überall herkommen, unter anderem von Anwendungsfehlern und Systemnachrichten, und sind oft unübersichtlich und schwierig zu interpretieren. Darüber hinaus müssen die Entwickler(innen) bei der Korrektur von Pipelines oft zwischen verschiedenen Aufgaben hin und her wechseln, wodurch der ganze Vorgang zeitaufwändiger wird.\n\nHier kommt [GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/) ins Spiel. GitLab Duo kann diesen unübersichtlichen Berg an Daten durchsuchen und Fehler viel schneller finden. So wird der Prozess vereinfacht, sodass du kein besonderen Kenntnisse brauchst, um herauszufinden, was falsch gelaufen ist. Mit KI kannst du deine Pipelines schneller, einfacher und mit weniger Stress reparieren.\n\n\u003Cimg src=\"https://res.cloudinary.com/about-gitlab-com/image/upload/v1752176104/Blog/zxvvu7p9vc3qpmwl32ya.png\" alt=\"broken pipeline\">\n\n\u003Cimg src=\"https://res.cloudinary.com/about-gitlab-com/image/upload/v1752176108/Blog/bpx6dqilfhltzboyp8k8.png\" alt=\"fix suggestions for broken pipelines\">\n\n## GitLab Duo Root Cause Analysis mit generativer KI\n\nWenn deine CI/CD-Pipeline fehlschlägt, musst du Fehler nicht mehr stundenlang manuell beheben. Dafür gibt es die [GitLab Duo Root Cause Analysis (RCA) (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/ee/user/gitlab_duo/#root-cause-analysis). Dieses KI-gestützte Tool identifiziert schnell die genaue Ursache des Fehlers und schlägt Korrekturen vor – direkt in der DevSecOps-Plattform. Egal, wie lang oder kompliziert deine Stack Traces sind: Die RCA analysiert alle Daten, schlüsselt sie auf und gibt dir klare, umsetzbare Einblicke.\n\n**Sie sagt dir genau, was den Fehler verursacht hat, schlägt Schritte zur Behebung hervor und nennt dir sogar die Dateien und Codezeilen, die bearbeitet werden müssen.** Damit das Ganze noch einfacher wird, schlägt sie Code-Korrekturen vor, damit alles wieder einwandfrei läuft. Dadurch wird die Fehlerbehebung viel schneller und unkomplizierter.\n\n\u003Cimg src=\"https://res.cloudinary.com/about-gitlab-com/image/upload/v1752176111/Blog/nmagby9hoksskogve53m.png\" alt=\"root cause of failure\">\n\n\u003Cimg src=\"https://res.cloudinary.com/about-gitlab-com/image/upload/v1752176115/Blog/dndis1cedwbmbnj33q3v.png\" alt=\"example fix\">\n\n## Halte das Gespräch mit Folgefragen am Laufen\n\nMit GitLab Duo RCA erhältst du nicht nur Antworten, sondern kannst auch Folgefragen stellen, um tiefer in das Problem einzutauchen. Möchtest du alternative Lösungen erkunden? Kein Problem. Du kannst [mehr Kontext (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/ee/user/gitlab_duo_chat/index.html#the-context-chat-is-aware-of) hinzufügen, indem du andere Dateien, Tickets oder Epics in deinem Repo verlinkst. Du könntest zum Beispiel deine Datei `.gitlab-ci.yml` in der IDE öffnen und den Chat fragen: „Based on this file, and the analyzed CI/CD pipeline, how would you propose to optimize the pipeline?“ \n\n## Datenschutz steht an erster Stelle – alles bleibt in GitLab\nEiner der wichtigsten Vorteile der GitLab Duo RCA ist, dass sie in GitLab sofort einsatzbereit ist. Du musst nicht das Tool wechseln oder nach externer Hilfe suchen. Außerdem bleiben deine [Protokolle und sensiblen Daten geschützt](https://about.gitlab.com/de-de/privacy/), denn du musst sie nicht an externe KI-Lösungen senden. RCA ist nahtlos in GitLab integriert und bietet wertvolle Einblicke, ohne gegen den Datenschutz zu verstoßen.\n\n![Beschädigte Pipeline – Bild 6](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097363/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097362773.png)\n\n## Starte noch heute\n\nMöchtest du sehen, wie KI deinen Entwicklungsprozess beschleunigen und ihn reibungsloser und schneller machen kann? Sieh dir unten unsere Produkt-Tour für GitLab Duo Enterprise an und entdecke, wie GitLab Duo mit seinen KI-basierten Informationen jede Phase deines Entwicklungsprozesses transformieren kann – von der Planung und der Programmierung bis hin zur Fehlerbehebung und Bereitstellung. Klicke auf das Bild unten, um die englischsprachige Tour zu starten!\n\n[![Tour durch GitLab Duo Enterprise](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097363/Blog/Content%20Images/Blog/Content%20Images/Screenshot_2024-12-02_at_12.41.10_PM_aHR0cHM6_1750097362774.png)](https://gitlab.navattic.com/duo-enterprise)\n\n> [Starte jetzt eine kostenlose Testversion von GitLab Duo!](https://about.gitlab.com/de-de/solutions/gitlab-duo-pro/sales/)",[678,707,705,9],"2025-02-18",{"slug":1409,"featured":6,"template":682},"quickly-resolve-broken-ci-cd-pipelines-with-ai","content:de-de:blog:quickly-resolve-broken-ci-cd-pipelines-with-ai.yml","Quickly Resolve Broken Ci Cd Pipelines With Ai","de-de/blog/quickly-resolve-broken-ci-cd-pipelines-with-ai.yml","de-de/blog/quickly-resolve-broken-ci-cd-pipelines-with-ai",{"_path":1415,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1416,"content":1422,"config":1428,"_id":1430,"_type":13,"title":1431,"_source":15,"_file":1432,"_stem":1433,"_extension":18},"/de-de/blog/safe-without-silos-in-gitlab",{"title":1417,"description":1418,"ogTitle":1417,"ogDescription":1418,"noIndex":6,"ogImage":1419,"ogUrl":1420,"ogSiteName":695,"ogType":696,"canonicalUrls":1420,"schema":1421},"SAFe ohne Silos in GitLab","Erfahre, wie du das Scaled Agile Framework den nativen Funktionen der DevSecOps-Plattform zuordnen kannst und welche Vorteile sich daraus ergeben.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097569/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%2811%29_2hcwWx49wQ7CHfvhhkVH6S_1750097569126.png","https://about.gitlab.com/blog/safe-without-silos-in-gitlab","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"SAFe ohne Silos in GitLab\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Amanda Rueda\"}],\n        \"datePublished\": \"2025-04-08\",\n      }",{"title":1417,"description":1418,"authors":1423,"heroImage":1419,"date":1424,"body":1425,"category":751,"tags":1426,"updatedDate":1427},[745],"2025-04-08","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.\n\nDiese 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.\n\nAuch wenn deine Entwicklungsteams [GitLab](https://about.gitlab.com/de-de/) 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.\n\n## Was ist SAFe?\n\nSAFe 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.\n\nSAFe 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.\n\n## SAFe-Terminologie in GitLab\n\nZunächst müssen wir festlegen, wie SAFe-Konzepte GitLab zugeordnet werden:\n\n| SAFe | GitLab |\n| :---- | :---- |\n| Epic | Top-Level-Epic |\n| Möglichkeit | Sub-Epic (Level 1) |\n| Funktion | Sub-Epic (Level 2) |\n| User Story | Issue |\n| Aufgabe | Aufgabe |\n| Team | Benutzerdefiniertes Feld/Label mit begrenztem Geltungsbereich |\n| Sprint | Iteration |\n| Programminkrement (PI) | Meilenstein |\n| Wertschöpfungskette | Top-Level-Gruppe |\n| Agile Release Train (ART) | Top-Level-Gruppe |\n\n\u003Cbr>\u003C/br>\n\nMit 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.\n\n## Unterstützung von SAFe-Zeremonien in GitLab\n\nNun zum vergnüglichen Teil – wie führst du deine SAFe-Zeremonien in GitLab durch? Gehen wir jede einzelne durch.\n\n### PI-Planen\n\nUm die teamübergreifende Abstimmung und das Abhängigkeitsmanagement zu erleichtern, die ein erfolgreiches PI-Planen ausmachen, bietet GitLab mehrere Möglichkeiten:\n\n* Verwende die [Roadmap](https://docs.gitlab.com/user/group/roadmap/)-Ansicht, um Funktionen team- und zeitübergreifend zu visualisieren.\n* Weise dem PI-[Meilenstein](https://docs.gitlab.com/user/project/milestones/) Funktionen zu.\n* Dokumentiere und visualisiere teamübergreifende [Abhängigkeiten]( https://docs.gitlab.com/user/project/issues/related_issues/#blocking-issues), sobald sie identifiziert wurden.\n\nGitLab 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.\n\n![Roadmap-Ansicht und Epic-Board](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097577/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097576746.gif)\n\n\u003Cbr>\u003C/br>\n\n![Roadmap-Ansicht mit Gantt-Diagramm](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097577/Blog/Content%20Images/Blog/Content%20Images/image5_aHR0cHM6_1750097576747.png)\n\n### Refinement\n\nAls 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. \n\nGitLab unterstützt Refinement-Sessions mit:\n\n* [Epic-Boards](https://docs.gitlab.com/user/group/epics/epic_boards/), die Funktionen nach Status gruppieren. \n* Der Möglichkeit, Story-Punkte direkt in der [Übersicht](https://docs.gitlab.com/user/group/epics/epic_boards/#view-count-of-issues-weight-and-progress-of-an-epic) anzuzeigen.  \n* Umfassenden [Drawer-Ansichten](https://docs.gitlab.com/user/group/epics/manage_epics/#open-epics-in-a-drawer), mit denen du mit Workitems interagieren kannst, ohne den Kontext zu verlieren.  \n* Der Möglichkeit, [untergeordnete Issues](https://docs.gitlab.com/user/group/epics/manage_epics/#add-an-issue-to-an-epic) direkt aus Epics zu erstellen und zu verknüpfen.\n\n![SAFe – Bild 3](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097577/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097576749.gif)\n\n### Sprint-Planung\n\nWenn es darum geht, herauszufinden, was dein Team im nächsten Sprint bewältigen kann, bietet GitLab dir:\n\n* [Issue-Übersichten](https://docs.gitlab.com/user/project/issue_board/), die einen umfassenden Überblick über deinen Backlog bieten.  \n* Eine [Gesamtgewichtung](https://docs.gitlab.com/user/project/issue_board/#sum-of-issue-weights) von User Storys, die direkt auf den Boards angezeigt werden.\n* Die Möglichkeit, Tickets einfach zwischen Iterationen zu verschieben. \n* Eine zusammenklappbare Ansicht, die das Verschieben von Storys zwischen Sprints vereinfacht.\n\nDas bedeutet, dass du alles an einem Ort aufbewahren und deine Planungsbesprechungen tatsächlich mit dem Planen verbringen kannst, anstatt zwischen den Tools zu wechseln.\n\n![Sprint-Planung mit GitLab](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097577/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750097576751.gif)\n\n*💡 In [diesem Tutorial zur Verwendung von GitLab für Scrum](https://docs.gitlab.com/tutorials/scrum_events/) erhältst du einen detaillierten Einblick in die Möglichkeiten von GitLab für Agile Planning und Sprint-Verfolgung.* \n\n### Tägliche Stand-up-Meetings\n\nDein 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:\n\n* Erstellen von [iterationsbezogenen](https://docs.gitlab.com/user/project/issue_board/#iteration-lists) Boards, die die Arbeit des aktuellen Sprints anzeigen.  \n* Die Anzeige von Story-Punkten/Gewichtungen direkt auf Karten. \n* Die Verwendung der [Drawer-Ansicht](https://docs.gitlab.com/user/project/issues/managing_issues/#open-issues-in-a-drawer), um auf Details zuzugreifen, ohne den Kontext zu verlassen.  \n* Die Hervorhebung gefährdeter Aufgaben durch den [Integritätsstatus](https://docs.gitlab.com/user/project/issues/managing_issues/#health-status)\n\n![Board für tägliche Stand-up-Meetings](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097577/Blog/Content%20Images/Blog/Content%20Images/image6_aHR0cHM6_1750097576755.png)\n\n### Sprint-Review\n\nMöchtest du wissen, wie sich dein Team im Laufe der Zeit entwickelt? GitLab bietet umfassende Metriken mit:\n\n* [Abarbeitungs- und Burnup-Diagrammen](https://docs.gitlab.com/user/group/iterations/#iteration-burndown-and-burnup-charts) für Iterationen  \n* Geschwindigkeitsverfolgung  \n* [Lead- und Zykluszeit](https://docs.gitlab.com/user/group/value_stream_analytics/#lifecycle-metrics)-Metriken  \n* Dashboards, die auf Teams ausgerichtet werden können\n\nDiese 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.\n\n![Abarbeitungs- und Burnup-Diagramme](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097577/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097576758.png)\n\n## 5 Gründe, warum eine einheitliche Plattform einen Vorteil bietet\n\nEs gibt viele Planungstools, die SAFe-Zeremonien handhaben können. Aber es gibt sehr gute Gründe, die für GitLab sprechen:\n\n1. **Kein Kontextwechsel mehr**: Planung, Programmierung, Testen und Sicherheit finden alle an einem Ort statt.  \n2. **Alles ist miteinander verbunden**: Du kannst die Arbeit vom großen Epic bis hinunter zum Code und zur Bereitstellung verfolgen.  \n3. **Alle sind auf dem gleichen Stand**: Entwickler(innen), Produktverantwortliche und Sicherheitsteams arbeiten alle mit demselben Tool zusammen.  \n4. **Vollständige Transparenz**: Stakeholder haben einen zentralen Ort, an dem sie nach Updates suchen können.  \n5. **Das Gesamtbild**: Du siehst Planungs- und Entwicklungsmetriken zusammen, damit du weißt, was wirklich vor sich geht.\n\nWenn 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.\n\n## Implementierungsgrundsätze\n\nIch habe mit Teams zusammengearbeitet, die von traditionellen SAFe-Tools zu GitLab wechselten. Dabei habe ich Folgendes gelernt: Konzentriere dich auf **das, was jede Zeremonie zu erreichen versucht**, und nicht auf die exakte Nachbildung deiner alten Tools.\n\nDie 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.\n\nDer 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.\n\n## Erste Schritte\n\nBereit, es auszuprobieren? So beginnst du mit der Implementierung von SAFe in GitLab:\n\n1. **Richte deine Struktur ein**: Erstelle Gruppen und Untergruppen, die [deiner Organisation entsprechen](https://about.gitlab.com/de-de/blog/best-practices-to-set-up-organizational-hierarchies-that-scale/).  \n2. **Definiere deine Aufgabenverteilung**: Entscheide, wie du [Epics](https://about.gitlab.com/de-de/blog/unlocking-agile-excellence-gitlab-epics-for-seamless-portfolio-management/), [Tickets](https://docs.gitlab.com/user/project/issues/managing_issues/) und [Aufgaben](https://docs.gitlab.com/user/tasks/) verwenden möchtest.  \n3. **Erstelle deine Iterationen**: Richte deinen [Sprint-Zeitplan](https://docs.gitlab.com/user/group/iterations/#create-an-iteration-cadence) ein.  \n4. **Füge deine Meilensteine hinzu**: [Meilensteine](https://docs.gitlab.com/user/project/milestones/#create-a-milestone) stellen deine Programmschritte in GitLab dar.  \n5. **Erstelle deine Boards**: Erstelle verschiedene Ansichten für verschiedene Zeremonien.  \n6. **Konventionen vereinbaren**: Dokumentiere, wie du Labels und benutzerdefinierte Felder verwendest.\n\nWenn 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.\n\n## Alles zusammenbringen\n\nGitLab 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.\n\nDas 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.\n\n> Bist du bereit zu erkennen, wie viel besser das Leben ohne diese Planungsinseln ist? [Starte noch heute deine kostenlose Testversion](https://about.gitlab.com/de-de/free-trial/) und erfahre aus erster Hand, wie GitLab deine SAFe-Implementierung verändern kann.\n\n* 💡 Wenn dir dieser Beitrag gefallen hat, lies auch den folgenden Beitrag dazu: [GitLab für die Agile-Softwareentwicklung](https://about.gitlab.com/de-de/blog/gitlab-for-agile-software-development/)*\n",[750,707,9,677,705],"2025-05-12",{"slug":1429,"featured":90,"template":682},"safe-without-silos-in-gitlab","content:de-de:blog:safe-without-silos-in-gitlab.yml","Safe Without Silos In Gitlab","de-de/blog/safe-without-silos-in-gitlab.yml","de-de/blog/safe-without-silos-in-gitlab",{"_path":1435,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1436,"content":1442,"config":1451,"_id":1453,"_type":13,"title":1454,"_source":15,"_file":1455,"_stem":1456,"_extension":18},"/de-de/blog/seamlessly-migrate-from-jira-to-gitlab-with-jira2lab-at-scale",{"ogTitle":1437,"schema":1438,"ogImage":1439,"ogDescription":1440,"ogSiteName":695,"noIndex":6,"ogType":696,"ogUrl":1441,"title":1437,"canonicalUrls":1441,"description":1440},"Jira zu GitLab Migration 2025: Kosten sparen & mehr Features","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Nahtlose Migration von Jira zu GitLab mit Jira2Lab im großen Maßstab\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Maximilien Belinga\"}],\n        \"datePublished\": \"2024-10-10\",\n      }","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749663129/Blog/Hero%20Images/blog-image-template-1800x945__28_.png","Atlassian erhöht Preise um bis zu 30 %. Erfahre, wie du mit GitLab mehr bekommst und dabei Geld sparst. Komplette Migrationsanleitung mit Jira2Lab.","https://about.gitlab.com/blog/seamlessly-migrate-from-jira-to-gitlab-with-jira2lab-at-scale",{"heroImage":1439,"body":1443,"authors":1444,"updatedDate":1446,"date":1447,"title":1448,"tags":1449,"description":1450,"category":751},"[Atlassian Server wurde Ende Februar eingestellt](https://about.gitlab.com/de-de/move-to-gitlab-from-atlassian/), sodass viele Kund(inn)en sich nach Alternativen wie Atlassian Cloud oder Atlassian Data Center umsehen. Viele Unternehmen, die bislang Atlassian Server genutzt haben, setzen jedoch vermehrt auf Lösungen im Bereich Agile Planning, die flexiblere, kosteneffizientere und robustere DevSecOps-Integrationen bieten. Außerdem müssen sie Herausforderungen hinsichtlich Datenvolumen, Anpassbarkeit, Benutzerabbildung, Leistung und Datenintegrität bei der Migration bewältigen. Hier kommt [Jira2Lab von GitLab](https://gitlab.com/gitlab-org/professional-services-automation/tools/migration/jira2lab) ins Spiel – diese nahtlose Lösung ermöglicht eine Migration von Jira zu GitLab im großen Maßstab und bietet gleichzeitig eine vollständige CI/CD-Integration.\n\n## Das Problem bei großen Jira-Migrationen\n\nDie Migration von Jira zu GitLab kann eine enorme Herausforderung sein, vor allem für Unternehmen mit komplexen Workflows und tausenden Tickets, die migriert werden müssen. Das sind die häufigsten Herausforderungen bei solchen Migrationen:\n\n- **Massive Datenmigration:** Wenn die Anzahl der Tickets, Anhänge, Kommentare und Projekte steigt, steigt auch die Schwierigkeit, diese ohne Leistungsprobleme oder Datenverluste zu migrieren.\n\n- **Benutzerdefinierte Felder und Workflows:** Jira-Instanzen enthalten oft benutzerdefinierte Workflows, Felder und Tickettypen, die keine direkte Entsprechung in GitLab haben. Diese Diskrepanzen sorgen bei der Migration für Schwierigkeiten, da bei bestehenden Tools oft eine manuelle Intervention nötig ist, um diese Elemente richtig zu übertragen.\n\n- **Mangel an einer vollständigen DevSecOps-Integration:** Viele Migrationstools schaffen zwar, Projektmanagementdaten zu migrieren, integrieren jedoch nicht die vollständigen DevSecOps-Funktionen von GitLab. Dadurch müssen Teams ihre [CI/CD-Pipelines](https://about.gitlab.com/de-de/topics/ci-cd/) und Managementsysteme der Versionskontrolle nach der Migration manuell konfigurieren.\n\n## Die Lösung: Jira2Lab\n\nJira2Lab wurde von Grund auf neu für die spezifischen Herausforderungen entwickelt, die eine Migration von Jira zu GitLab im großen Maßstab mit sich bringt. Es geht nicht nur darum, Daten zu verschieben, sondern Teams ohne Ausfallzeiten oder Datenverluste den nahtlosen Umstieg auf die leistungsstarke DevSecOps-Umgebung von GitLab zu ermöglichen.\n\n### Schlüsselfunktionen von Jira2Lab\n\n1. Effizienter Umgang mit Daten im großen Maßstab\u003Cbr>\nJira2Lab wurde dafür optimiert, tausende Tickets, Anhänge, Kommentare und benutzerdefinierte Projekte in mehreren Projekten ohne Leistungseinbußen zu bewältigen. Es lässt sich mühelos skalieren, um sogar Migrationen der größten Unternehmen zu meistern.\n\n2. Benutzerdefinierte Workflow- und Felder-Zuordnung\u003Cbr>\nEine der herausragenden Funktion von Jira2Lab ist die automatische Zuordnung von benutzerdefinierten Workflows und Feldern von Jira zu GitLab. Das Tool bietet eine flexible Mapping-Konfiguration, dank der keine manuelle Intervention beim Migrationsprozess nötig ist und die sicherstellt, dass alles reibungslos von Jira nach GitLab migriert wird.\n\n3. CI/CD-Pipeline-Integration\u003Cbr>\nJira2Lab migriert nicht nur Tickets und Projekte, sondern integriert sogar die komplette CI/CD-Pipeline von GitLab in den Migrationsprozess. Dadurch wird sichergestellt, dass die Entwicklungsteams sofort nach der Migration die DevSecOps-Funktionen von GitLab wie automatisierte Tests und Bereitstellungs-Pipelines nutzen können.\n\n4. Testmigrationen\u003Cbr>\nUnser Tool unterstützt Testmigrationen, damit Teams ihre Konfigurationen und Workflows vor der Skalierung testen können. Dadurch wird sichergestellt, dass Probleme frühzeitig erkannt werden, sodass es bei der richtigen Migration zu keinen Unterbrechungen und Ausfällen kommt.\n\n5. Echtzeit-Überwachung\u003Cbr>\nDas Tool bietet Echtzeit-Überwachung und -Protokolle während der Migration sowie vollständige Transparenz, um sicherzustellen, dass jeder Schritt korrekt und fehlerfrei ausgeführt wird.\n\n6. Anpassbar und flexibel\u003Cbr>\nAuch wenn deine Jira-Instanz einzigartige Konfigurationen oder Workflows hat, ist Jira2Lab flexibel genug, um die Migration an deine spezifischen Anforderungen anzupassen. So wird sichergestellt, dass bei der Übertragung nichts verloren geht.\n\n> **Von 18 auf 3 Monate: So beschleunigt die Deutsche Telekom ihre Releases mit GitLab** 13.000 Entwickler(innen) arbeiten effizienter zusammen und bringen Produkte 6x schneller auf den Markt – erfahre, wie GitLab Ultimate die DevSecOps-Transformation vorantreibt, Silos aufbricht und Sicherheit in den Entwicklungsprozess bringt. [Erfolgsstory lesen](https://about.gitlab.com/de-de/customers/deutsche-telekom/)\n\n### Jira und GitLab im Vergleich\n\nDie Migration von Jira zu GitLab hilft, Workflows zu konsolidieren und erweiterte Funktionen zu nutzen, die in GitLab nativ sind. Hier ist ein kurzer Vergleich der Kernfunktionen der beiden Plattformen:\n\n| **Funktion** | **Jira** | **GitLab** |\n|----------|------|--------|\n| Ticketverfolgung | Ja (stark anpassbar) | Ja (in DevSecOps integriert) |\n| Agile Boards | Ja (Kanban, Scrum) | Ja (Issue-Übersichten, Meilensteine) |\n| CI/CD | Nein (externe Tools erforderlich) | Ja (integrierte CI/CD) |\n| Versionskontrolle | Nein (GitHub/Bitbucket erforderlich) | Ja (nativer Git-Support) |\n| DevSecOps-Tools | Begrenzte Integrationen | Kompletter DevSecOps-Lebenszyklus |\n| **KI-Funktionen** | **Atlassian Intelligence (Premium/Enterprise)** | **GitLab Duo (alle Stufen verfügbar)** |\n| **KI-Kosten** | **Zusätzlich ab Premium-Plan** | **In GitLab Ultimate enthalten** |\n| **Sicherheitsscans** | **Über Marketplace-Apps** | **Nativ integriert (SAST, DAST, etc.)** |\n\n\nMit Jira2Lab stellen wir sicher, dass alle wichtigen Aspekte – von der Ticketverfolgung bis hin zu CI/CD-Pipelines – reibungslos migriert werden. Dabei wird der integrierte Ansatz von GitLab hinsichtlich Entwicklung und Betrieb vollständig genutzt.\n\n### Die wahren Kosten einer Jira-Implementierung\n\nWährend Jira auf den ersten Blick kostengünstig erscheinen mag, zeigt sich bei genauerer Betrachtung ein anderes Bild:\n\n**Versteckte Kosten bei Jira:**\n- Separate Lizenzen für Confluence (Dokumentation), Bitbucket (Code) und Bamboo (CI/CD)\n- Marketplace-Apps für grundlegende Funktionen (durchschnittlich 5-10 Apps pro Installation)\n- Atlassian Intelligence nur in teuren Premium/Enterprise-Plänen\n- Assets und Virtual Service Agent mit verbrauchsbasierter Abrechnung\n\n**GitLabs All-in-One-Vorteil:**\nMit GitLab erhalten Teams eine vollständige DevSecOps-Plattform ohne zusätzliche Lizenzkosten. Wiki, Code-Repository, CI/CD, Sicherheitsscans und KI-Funktionen sind bereits enthalten, was bei vergleichbarem Atlassian-Stack leicht das 2-3-fache kosten kann.\n\n### Warum jetzt der richtige Zeitpunkt für eine Migration ist\n\nAtlassian hat in den letzten 18 Monaten eine aggressive Preisstrategie verfolgt, die viele Unternehmen zum Umdenken bewegt:\n- **Oktober 2024**: Cloud-Preise stiegen um 5-20%, wobei größere Teams besonders betroffen waren\n- **Februar 2025**: Data Center-Preise erhöhten sich nochmals um 5-30%, mit besonders drastischen Anstiegen bei Jira Software\n- **Funktionsverlagerung**: Wichtige ITSM-Funktionen wie Incident-, Problem- und Change-Management wurden von Standard auf Premium/Enterprise verschoben\n\nDiese kontinuierlichen Preiserhöhungen machen GitLab zu einer wirtschaftlich attraktiven Alternative, die gleichzeitig einen vollständigen DevSecOps-Ansatz ohne zusätzliche Tool-Kosten bietet.\n\n## Die Migrationsmethodik \n\nJira2Lab folgt einer strukturierten, fünfphasigen Migrationsmethodik, die eine nahtlose Migration mit minimalen Unterbrechungen gewährleistet:\n\n### 1. Entdeckung und Planung\n\nWir beginnen damit, das Jira-Setup des Kunden bzw. der Kundin genau zu verstehen und alle erforderlichen benutzerdefinierten Workflows, Felder und Projekte zu identifizieren, die migriert werden müssen. In dieser Phase wird auch eine Lückenanalyse durchgeführt, um die Funktionen von Jira und GitLab zu vergleichen und den Migrationsprozess abzubilden.\n\n### 2. Einrichtung\nIn dieser Phase konfigurieren wir das Migrationstool und richten die erforderlichen Umgebungen für Jira und GitLab ein. Dabei überprüfen wir alle Berechtigungen und richten vor Beginn der Migration eine Sicherung der Jira-Daten ein.\n\n### 3. Testmigrationen\nVor der Migration des gesamten Datensatzes führen wir Testmigrationen für ausgewählte Projekte durch, um den Migrationsprozess, die Workflows und die Datenintegrität zu testen. So können wir Probleme früh im Prozess erkennen und lösen.\n\n### 4. Skalierte Migrationen\nNach der Validierung der Testmigration skalieren wir die Migration über alle Projekte hinweg, um minimale Ausfallzeiten und reibungslose Übergänge für die Entwicklungsteams zu gewährleisten.\n\n### 5. Abschluss und Unterstützung nach der Migration\nSobald die Migration abgeschlossen ist, bieten wir fortlaufenden Support, um sicherzustellen, dass alle Teams in GitLab voll einsatzfähig sind. In dieser Phase werden auch die Benutzer(innen) geschult und die Jira-Instanz bei Bedarf außer Betrieb genommen.\n\n## Fallstudie: Skalierung mit Jira2Lab\n\nIn einer kürzlich durchgeführten Migration stand ein großes Unternehmen vor der Herausforderung, über 20 000 Tickets in 50 Projekten von Jira zu GitLab zu migrieren. Das Projekt wies hochgradig benutzerdefinierte Workflows und Tausende von Kommentaren und Anhängen auf, die übertragen werden mussten.\n\nMit Jira2Lab konnten wir:\n\n- Alle Daten, einschließlich benutzerdefinierter Felder, ohne Datenverlust migrieren.\n- CI/CD-Pipelines in GitLab einrichten, damit Teams nach der Migration sofort weiterarbeiten konnten.\n- Eine Testmigration von zwei Projekten durchführen, die es uns ermöglichte, kleinere Workflow-Diskrepanzen zu identifizieren und zu beheben, bevor wir die Migration auf das gesamte Unternehmen skalierten.\n\nDas Ergebnis war ein nahtloser Übergang zu GitLab, bei dem der gesamte Prozess innerhalb der geplanten Zeit abgeschlossen wurde und es zu keinen signifikanten Ausfallzeiten kam.\n\n## Lege jetzt mit Jira2Lab los\n\nJira2Lab hebt sich auf dem Markt dadurch ab, dass es genau auf die Einschränkungen eingeht, die andere Migrationstools nicht bewältigen können. Es wurde speziell für große Migrationen entwickelt und kann den kompletten DevSecOps-Lebenszyklus von GitLab integrieren  – anders als die meisten anderen Tools, die nur Projektmanagementdaten migrieren können. Da das Tool benutzerdefinierte Workflows abbilden und CI/CD-Pipelines integrieren kann, ist es die perfekte Lösung für Unternehmen, die ihre Entwicklungs-Workflows verbessern und gleichzeitig zu GitLab migrieren möchten.\n\n> Bist du bereit, deine Entwicklungsprozesse mit GitLab zu skalieren? Sieh dir unseren [Katalog für professionelle Services](https://about.gitlab.com/services/catalog/) an, um zu erfahren, wie wir deinem Team bei einer effizienten und effektiven Migration helfen können. Kontaktiere uns über das Formular am Ende dieser Seite, um eine personalisierte Demo von Jira2Lab von GitLab zu erhalten.\n",[1445],"Maximilien Belinga","2025-06-24","2024-10-10","Von Jira zu GitLab wechseln: Der komplette Migrationsleitfaden 2025",[750,108,907,9,677],"Atlassians Preiserhöhungen treiben viele Teams zu Alternativen. Entdecke, warum GitLab die bessere Wahl für moderne DevSecOps-Teams ist - mit mehr Features, integrierten Sicherheitstools und transparenter Preisgestaltung. Inklusive Schritt-für-Schritt-Migration mit Jira2Lab.",{"slug":1452,"featured":90,"template":682},"seamlessly-migrate-from-jira-to-gitlab-with-jira2lab-at-scale","content:de-de:blog:seamlessly-migrate-from-jira-to-gitlab-with-jira2lab-at-scale.yml","Seamlessly Migrate From Jira To Gitlab With Jira2lab At Scale","de-de/blog/seamlessly-migrate-from-jira-to-gitlab-with-jira2lab-at-scale.yml","de-de/blog/seamlessly-migrate-from-jira-to-gitlab-with-jira2lab-at-scale",{"_path":1458,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1459,"content":1464,"config":1469,"_id":1471,"_type":13,"title":1472,"_source":15,"_file":1473,"_stem":1474,"_extension":18},"/de-de/blog/speed-up-code-reviews-let-ai-handle-the-feedback-implementation",{"title":1460,"description":1461,"ogTitle":1460,"ogDescription":1461,"noIndex":6,"ogImage":1194,"ogUrl":1462,"ogSiteName":695,"ogType":696,"canonicalUrls":1462,"schema":1463},"Code-Reviews beschleunigen: Lass KI die Feedback-Implementierung übernehmen","Entdecke, wie GitLab Duo mit Amazon Q die Implementierung von Code-Review-Feedback durch KI automatisiert und einen zeitaufwendigen manuellen Prozess in einen optimierten Workflow verwandelt.","https://about.gitlab.com/de-de/blog/speed-up-code-reviews-let-ai-handle-the-feedback-implementation","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Code-Reviews beschleunigen: Lass KI die Feedback-Implementierung übernehmen\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Cesar Saavedra\"}],\n        \"datePublished\": \"2025-06-10\",\n      }",{"title":1460,"description":1461,"authors":1465,"heroImage":1194,"date":1059,"body":1467,"category":703,"tags":1468},[1466],"Cesar Saavedra","Kennst du das Gefühl, wenn du gerade einen Merge Request eingereicht hast und die Code-Review-Kommentare eintrudeln? Ein Reviewer möchte die Labels aktualisiert haben, ein anderer fragt nach Side-by-Side-Layouts, jemand anderes fordert fette Formatierung, und vergiss nicht die Änderung der Button-Farbe. Bevor du dich versiehst, verbringst du Stunden mit der Implementierung von Feedback, das zwar wichtig ist, dich aber davon abhält, neue Features zu entwickeln. Es ist ein zeitaufwendiger Prozess, dem sich jede(r) Entwickler(in) stellen muss, aber es fühlt sich an, als sollte es einen besseren Weg geben.\n\nWas wäre, wenn du einen KI-Assistenten hättest, der Code-Review-Feedback versteht und die Änderungen automatisch für dich implementiert? Genau das bringt [GitLab Duo mit Amazon Q](https://about.gitlab.com/de-de/blog/gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws/) in deinen Entwicklungsworkflow. Diese nahtlose Integration kombiniert GitLabs umfassende DevSecOps-Plattform mit Amazon Qs fortgeschrittenen KI-Fähigkeiten und schafft einen intelligenten Assistenten, der Reviewer-Kommentare lesen und direkt in Code-Änderungen umwandeln kann. Anstatt jedes Feedback manuell zu bearbeiten, kannst du die KI die Implementierung übernehmen lassen, während du dich auf das große Ganze konzentrierst.\n\n## Wie GitLab Duo mit Amazon Q funktioniert\n\nWenn du einen Merge Request mit Reviewer-Kommentaren ansiehst, siehst du Feedback, das über deinen Code verteilt ist. Nehmen wir die Beispiele von vorhin: Vielleicht hast du eine Anfrage erhalten, hier ein Formular-Label zu aktualisieren, dort einen Vorschlag, Felder nebeneinander anzuzeigen, oder eine Notiz, bestimmten Text fett zu formatieren. Jeder Kommentar stellt eine Aufgabe dar, die du normalerweise manuell erledigen müsstest.\n\n![Feedback zu einem MR](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749673634/Blog/Content%20Images/1-show-comment.png)\n\nMit GitLab Duo mit Amazon Q kannst du einfach die `/q dev` Quick Action in einem Kommentar eingeben. Dies veranlasst Amazon Q, das gesamte Feedback zu analysieren und automatisch mit der Modifikation deines Codes zu beginnen. Der KI-Agent versteht den Kontext jedes Kommentars und implementiert die angeforderten Änderungen direkt in deiner Codebasis.\n\n![/q dev-Funktion veranlasst Amazon Q zur Analyse des Feedbacks](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749673634/Blog/Content%20Images/2-invoke-q-dev.png)\n\nSobald Amazon Q das Feedback verarbeitet hat, kannst du alle Updates im „Änderungen\"-Tab deines Merge Requests einsehen. Jede Modifikation ist klar sichtbar, sodass du überprüfen kannst, dass der KI-Agent jedes Feedback korrekt interpretiert und implementiert hat. Du kannst dann deine aktualisierte Anwendung ausführen, um zu bestätigen, dass alle Änderungen wie erwartet funktionieren – das Formular-Label ist aktualisiert, die Felder werden nebeneinander angezeigt, der Text ist fett, und ja, dieser Button ist jetzt blau.\n\nSieh dir den Code-Review-Feedback-Prozess in Aktion an:\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/31E9X9BrK5s?si=ThFywR34V3Bfj1Z-\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\nDie Verarbeitung von Code-Review-Feedback ist ein notwendiger, aber zeitintensiver Teil der Softwareentwicklung. GitLab Duo mit Amazon Q entwickelt diesen manuellen Prozess zu einem automatisierten Workflow weiter und reduziert drastisch die Zeit zwischen dem Erhalt von Feedback und der Implementierung von Änderungen. Indem du die KI diese routinemäßigen Modifikationen übernehmen lässt, bist du frei, dich auf das zu konzentrieren, was wirklich zählt – innovative Features zu entwickeln und komplexe Probleme zu lösen.\n\nMit GitLab Duo mit Amazon Q kannst du:\n- Stunden manueller Feedback-Implementierung eliminieren\n- Deine Code-Review-Zyklen beschleunigen\n- Konsistenz bei der Bearbeitung von Feedback gewährleisten\n- Kontextwechsel zwischen Review-Kommentaren und Code-Schreiben reduzieren\n- Features mit optimierten Bereitstellungszeiten schneller ausliefern\n\n> #### Um mehr über GitLab Duo mit Amazon Q zu erfahren, besuche uns bei einem kommenden [AWS Summit in einer Stadt in deiner Nähe](https://about.gitlab.com/de-de/events/aws-summits/) oder [wende dich an deinen GitLab-Vertreter](https://about.gitlab.com/de-de/partners/technology-partners/aws/#form).\n\n## GitLab Duo mit Amazon Q Ressourcen\n\n- [GitLab Duo mit Amazon Q: Agentische KI optimiert für AWS allgemein verfügbar](https://about.gitlab.com/de-de/blog/gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws/)\n- [GitLab und AWS Partnerseite](https://about.gitlab.com/de-de/partners/technology-partners/aws/)\n- [GitLab Duo mit Amazon Q Dokumentation](https://docs.gitlab.com/user/duo_amazon_q/)\n- [Was ist agentische KI?](https://about.gitlab.com/de-de/topics/agentic-ai/)\n- [Agentische KI-Leitfäden und Ressourcen](https://about.gitlab.com/de-de/blog/agentic-ai-guides-and-resources/)",[677,9,707,1204,927,705],{"slug":1470,"featured":90,"template":682},"speed-up-code-reviews-let-ai-handle-the-feedback-implementation","content:de-de:blog:speed-up-code-reviews-let-ai-handle-the-feedback-implementation.yml","Speed Up Code Reviews Let Ai Handle The Feedback Implementation","de-de/blog/speed-up-code-reviews-let-ai-handle-the-feedback-implementation.yml","de-de/blog/speed-up-code-reviews-let-ai-handle-the-feedback-implementation",{"_path":1476,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1477,"content":1483,"config":1489,"_id":1491,"_type":13,"title":1492,"_source":15,"_file":1493,"_stem":1494,"_extension":18},"/de-de/blog/the-ultimate-guide-to-token-management-at-gitlab",{"title":1478,"description":1479,"ogTitle":1478,"ogDescription":1479,"noIndex":6,"ogImage":1480,"ogUrl":1481,"ogSiteName":695,"ogType":696,"canonicalUrls":1481,"schema":1482},"Der ultimative Leitfaden für die Token-Verwaltung mit GitLab","Erfahre Schritt für Schritt, wie du Token identifizierst, verwaltest und schützt, um die Sicherheit in deinem gesamten Software-Entwicklungsprozess zu verbessern.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097408/Blog/Hero%20Images/Blog/Hero%20Images/AdobeStock_1097303277_6gTk7M1DNx0tFuovupVFB1_1750097407860.jpg","https://about.gitlab.com/blog/the-ultimate-guide-to-token-management-at-gitlab","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Der ultimative Leitfaden für die Token-Verwaltung mit GitLab\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Hakeem Abdul-Razak\"}],\n        \"datePublished\": \"2025-02-25\",\n      }",{"title":1478,"description":1479,"authors":1484,"heroImage":1480,"date":1486,"body":1487,"category":675,"tags":1488},[1485],"Hakeem Abdul-Razak","2025-02-25","Stell dir Folgendes vor: Du bist Entwickler(in) in einem aufstrebenden Technologieunternehmen, es ist 2 Uhr morgens und du erhältst einen dringenden Anruf. Eine wichtige Bereitstellungs-Pipeline ist fehlgeschlagen und dein Team versucht, den Grund herauszufinden. Nach stundenlangem Suchen stellst du fest, dass jemand einen persönlichen Zugriffs-Token widerrufen hat, der zu einem bzw. einer Entwickler(in) gehörte, der bzw. die schon seit Wochen nicht mehr für das Unternehmen arbeitet. Dieser Token war an mehrere Automatisierungsprozesse gekoppelt, sodass jetzt dein gesamtes System im Chaos versunken ist. Wie stellst du sicher, dass so etwas nicht nochmals passiert?\n\nFolge dieser Anleitung und erfahre Schritt für Schritt, wie du mit GitLab Token identifizieren, verwalten und schützen kannst. Dies ist eine praktische Ergänzung zur umfassenden [Token-Übersichtsdokumentation](https://docs.gitlab.com/ee/security/tokens) für GitLab-Administrator(inn)en, Entwickler(innen) und Sicherheitsteams, die eine robuste Token-Verwaltung in ihren Projekten benötigen.\n\nIn diesem Leitfaden geht es um folgende Themen:\n- [Wie wählst du den richtigen Token für den Job aus?](#how-to-select-the-right-token-for-the-job)\n- [Token-Arten](#token-types)\n- [Entdecke deine Token](#discovering-your-tokens)\n    - [Credentials Inventory](#credentials-inventory)\n- [Token im GitLab-UI und in der API verwalten](#managing-tokens-in-the-gitlab-ui-and-api)\n- [Rotation der Token und Verwaltung von Ablaufdaten](#token-rotation-and-expiration-management)\n- [Best Practices für die Token-Verwaltung](#token-management-best-practices)\n    - [Dienstkonten](#service-accounts)\n\n## Wie wählst du den richtigen Token für den Job aus?\n\nMit der Auswahl des richtigen Tokens garantierst du die für deinen Anwendungsfall optimale Sicherheit und Funktionsfähigkeit.\nToken können zur Authentifizierung von API-Anfragen, zur Automatisierung von CI/CD-Pipelines, zur Integration von externen Tools, zur Verwaltung von Bereitstellungen und Repositories und für vieles mehr verwendet werden.\n\n![Leitfaden für die Token-Verwaltung – Flussdiagramm für Token](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097435/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097434869.png)\n\nDer Einfachheit halber zeigt dieses Diagramm einen unkomplizierten Anwendungsfall, bei der nur ein(e) Benutzer(in) die Inhaberschaft hat. Weitere Informationen findest du in unsere Dokumentation zu Benutzerrollen und Berechtigungen in den einzelnen [Namensräumen](https://docs.gitlab.com/ee/user/permissions.html) (Benutzer(innen)/Gruppe) in deiner Instanz oder Hauptgruppe. Beispiele für Anwendungsfälle:\n\n- **Persönliche Zugriffs-Token** ([PAT](https://docs.gitlab.com/user/profile/personal_access_tokens/#personal-access-token-scopes)) können von Entwickler(innen) verwendet werden, wenn für eine(n) Benutzer(in) persönlicher Zugriff und persönliche Berechtigungen nötig sind. In diesem Fall folgen die Anmeldeinformationen dem Status und den Berechtigungen des Benutzers bzw. der Benutzerin, einschließlich der Entfernung des Zugriffs, wenn das Konto den Zugriff auf ein bestimmtes Projekt oder eine bestimmte Gruppe verliert (oder vollständig gesperrt wird).   \n- **Projekt-/Gruppenzugriffs-Token** ([PrAT](https://docs.gitlab.com/user/project/settings/project_access_tokens/#scopes-for-a-project-access-token)/[GrAT](https://docs.gitlab.com/user/group/settings/group_access_tokens/#scopes-for-a-group-access-token)) werden empfohlen, wenn der Zugriff auf Ressourcen in einem bestimmten Projekt oder einer bestimmten Gruppe eingeschränkt werden soll. Da diese PrAT/GrAT einem bestimmten Geltungsbereichen zugewiesen wurden, können alle auf die jeweils nötigen Ressourcen zugreifen.\n## Token-Arten\n\nUnten findest du eine Liste mit GitLab-Token und deren standardmäßigen Präfixen und Anwendungsfällen. Weitere Informationen findest du auf der [GitLab-Token-Übersichtsseite](https://docs.gitlab.com/ee/security/tokens/#available-scopes). \n\n| Token | Präfix | Beschreibung |\n| :---: | :---: | :---: |\n| Persönlicher Zugriffs-Token | glpat | Für den Zugriff auf benutzerspezifische Daten |\n| OAuth-2.0-Token |  gloas | Für die Integration mit externen Anwendungen über das OAuth2.0-Authentifizierungsprotokoll |\n| Imitations-Token | glpat | Für administrative Handlungen im Namen anderer Benutzer(innen) |\n| Projektzugriffs-Token | glpat | Für den Zugriff auf Daten eines bestimmten Projekts |\n| Gruppenzugriffs-Token | glpat | Für den Zugriff auf Daten einer bestimmten Gruppe |\n| Bereitstellungs-Token | gldt | Zum Klonen, Pushen und Pullen von Container-Registry-Images eines Projekts ohne Benutzer(in) und Passwort |\n| Bereitstellungsschlüssel | n.v. | Ermöglicht den Lese- oder Schreibzugriff auf deine Repositories |\n| Runner-Authentifizierungs-Token | glrt | Für die Authentifizierung von GitLab-Runners |\n| CI/CD-Job-Token  | glcbt | Für die Automatisierung von CI/CD-Prozessen |\n| Trigger-Token | glptt | Löst Pipelines manuell oder programmatisch aus |\n| Feed-Token | glft | Für die Authentifizierung des Zugriffs auf Paket-/RSS-Feeds |\n| Token für eingehende Mails  | glimt | Für die Verarbeitung eingehender E-Mails |\n| Token für GitLab Agent for Kubernetes | glagent | Für die Verwaltung von Kubernetes-Clustern über den GitLab Agent |\n| SCIM-Token | glsoat | Ermöglicht SCIM-Integrationen für die Benutzerbereitstellung |\n| Client-Token für Feature-Flags | glffct | Für programmatische Feature-Flags |\n| Webhook-Token | n.v. | Vom bzw. von der Benutzer(in) festgelegter geheimer Token, um Webhook-Payloads zu sichern und zu gewährleisten, dass Anfragen von GitLab stammen |\n\n## Entdecke deine Token\n\n### Credentials Inventory\n\nIn GitLab Ultimate können Administrator(inn)en (GitLab Self-Managed) und Eigentümer(innen) von Hauptgruppen eines Unternehmens (GitLab.com ab Version 17.5) die Zugangsdaten in ihrem Namensraum überwachen.\n\nDieses Inventar verfolgt Token-Details wie:\n\n* Token-Typ  \n  * Verfügbare Token auf [GitLab.com](https://docs.gitlab.com/ee/user/group/credentials_inventory.html)  \n  * Verfügbare Token auf [GitLab Self-Managed](https://docs.gitlab.com/ee/administration/credentials_inventory.html)  \n* Zugehörige Benutzerkonten  \n* Token-Geltungsbereiche sowie Erstellungs- und Ablaufdaten  \n* Zuletzt verwendete IP-Adressen des Tokens (ab GitLab 17.10)  \n* Token-Filterung basierend auf den oben genannten benutzerdefinierten Parametern  \n* Möglichkeit zum Widerrufen und Rotieren dieser Token\n\nEin gut gepflegtes Credentials Inventory hilft dabei, Token mit zu vielen Berechtigungen zu identifizieren, und gibt Aufschluss über Zugangsdaten, die möglicherweise rotiert werden müssen, um einen sicheren und effizienten Workflow zu gewährleisten.\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/A9ONfnwswd0?si=4VIEUgJaD4daj81b&start=105\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line ->\n\n#### Credentials Inventory API\n\nAls Ergänzung zur UI [entwickeln wir derzeit](https://gitlab.com/groups/gitlab-org/-/epics/16343) eine Credentials Inventory API über den neuen [Endpunkt /group/:id/manage](https://docs.gitlab.com/ee/api/members.html#list-all-members-of-a-group-or-project). Die unter diesem Endpunkt zugänglichen Zugangsdaten sind auf [Enterprise-Benutzer(innen)](https://docs.gitlab.com/ee/user/enterprise_user/) beschränkt und können vom bzw. von der Eigentümer(in) der Hauptgruppe eines Unternehmens abgerufen werden. Ein Beispiel für den zukünftigen API-Aufruf wäre:\n\n```console\ncurl --header \"PRIVATE-TOKEN: \u003Cpat>\" \"https://verified_domain.com/api/v4/groups/\u003Cgroup_id>/manage/personal_access_tokens\"           \n```\n### GitLab-API\n\nMit der GitLab-API kannst du Token in deinem Unternehmen programmgesteuert auflisten und verwalten. Wichtige authentifizierungsbezogene Endpunkte unterstützen [verschiedene Token-Typen](https://docs.gitlab.com/ee/api/rest/authentication.html)), darunter persönliche Token, Gruppen-Token, CI/CD-Token und mehr. Ein Beispiel für die Verwendung eines persönlichen Zugriffs-Tokens zum Auflisten aller sichtbaren Projekte in GitLab für authentifizierte Benutzer(innen) ist:\n\n\n```console\ncurl --header \"PRIVATE-TOKEN: \u003Cyour_access_token>\" \\\n     \"https://gitlab.example.com/api/v4/projects\"\n\n```\n\nIn diesem Video erfährst du, wie du API-Aufrufe an die GitLab-API sendest.\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/0LsMC3ZiXkA?si=vj871YH610jwQdFc\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line ->\n\n### Finde heraus, wo Token verwendet werden\n\nKund(inn)en können auf verschiedene Arten herausfinden, wo Token verwendet werden:\n* Unter **Benutzerprofil > [Zugriffstoken](https://docs.gitlab.com/ee/user/profile/personal_access_tokens.html#view-the-time-at-and-ips-where-a-token-was-last-used)**\n* Im Credentials Inventory\n* In Audit-Ereignissen\n* Über die API \n\nInformationen zur Token-Nutzung werden alle 10 Minuten für **last_used** und einmal pro Minute für **last_used_ip** aktualisiert. \n\nDie Möglichkeit, IP-Adressen anzuzeigen, wurde in GitLab 17.9 eingeführt und wird durch das Feature-Flag **:pat_ip** gesteuert. Befolge diese [Schritte, um herauszufinden, wann ein Token zuletzt verwendet wurde](https://docs.gitlab.com/ee/user/profile/personal_access_tokens.html#view-the-time-at-and-ips-where-a-token-was-last-used). Außerdem werden dir seine letzten fünf eindeutigen IP-Adressen angezeigt.\n\n![Leitfaden für Token-Verwaltung – Einstellungen für persönliche Zugriffs-Token](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097435/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097434870.png)\n\n## Token im GitLab-UI und in der API verwalten\nIn der folgenden Tabelle findest du Videos, in denen gezeigt wird, wie Token im UI erstellt werden und wie sie über die API genutzt werden können.\n\n| Token     | GitLab-UI    | GitLab-API    |\n| ---------- | ---------- | ---------- |\n| Persönlicher Zugriffs-Token \u000b | [Dokumentation](https://docs.gitlab.com/ee/user/profile/personal_access_tokens.html#create-a-personal-access-token) und [Video](https://youtu.be/v5Nj3Jy4vaI?t=3)  | [Dokumentation](https://docs.gitlab.com/ee/api/personal_access_tokens.html) und [Video](https://youtu.be/v5Nj3Jy4vaI?t=43)  |\n| Gruppenzugriffs-Token | [Dokumentation](https://docs.gitlab.com/ee/user/group/settings/group_access_tokens.html#group-access-tokens) und [Video](https://youtu.be/v5Nj3Jy4vaI?t=120)  | [Dokumentation](https://docs.gitlab.com/ee/api/group_access_tokens.html) und [Video](https://youtu.be/v5Nj3Jy4vaI?t=157)  |\n| Projektzugriffs-Token | [Dokumentation](https://docs.gitlab.com/ee/user/project/settings/project_access_tokens.html#project-access-tokens) und [Video](https://youtu.be/v5Nj3Jy4vaI?t=254)  | [Dokumentation](https://docs.gitlab.com/ee/api/project_access_tokens.html) und [Video](https://youtu.be/v5Nj3Jy4vaI?t=285)  |\n\n## Rotation der Tokens und Verwaltung von Ablaufdaten\n\nIndem du Token rotierst und strikte Richtlinien für Ablaufdaten einführst, reduzierst du das Komprimittierungsrisiko und stellst die Einhaltung von Sicherheitsstandards sicher. Regelmäßige Rotation und erzwungene Abläufe verhindern, dass veraltete Zugangsdaten zu Sicherheitslücken werden.\n\nBisher wurden abgelaufene Gruppen- und Projektzugriffs-Token nach Ablauf automatisch gelöscht, was die Überwachung und Sicherheitsüberprüfung schwieriger machte, da keine Aufzeichnungen zu inaktiven Token vorlagen. Um dieses Problem zu beheben, wurde eine [neue Funktion](https://gitlab.com/gitlab-org/gitlab/-/issues/462217) eingeführt, um Aufzeichnungen zu inaktiven Gruppen- und Projektzugriffs-Token 30 Tage, nachdem sie inaktiv wurden, im UI aufzubewahren. Diese Verbesserung soll es den Teams ermöglichen, die Verwendung, den Ablauf und den Widerruf von Token zu verfolgen, um die Compliance und Überwachung zu verbessern.\n\nUm die Rotation von Token und die Verwaltung von Ablaufdaten proaktiv zu gestalten, kannst du Folgendes tun:\n\n* Rotiere deine Token aktiv über die UI oder die API. Wenn du die API verwendest, achte auf den Sicherheitsmechanismus, mit dem [wiederverwendete Token automatisch erkannt werden](https://docs.gitlab.com/ee/api/personal_access_tokens.html#automatic-reuse-detection).\n* Lege eine instanzweite [maximale Geltungsdauer](https://docs.gitlab.com/ee/administration/settings/account_and_limit_settings.html#limit-the-lifetime-of-access-tokens) für Zugriffs-Token fest.\n\n### API für die Rotation von Token\n\nBis GitLab 17.7 mussten Kund(inn)en Zugriffs-Token programmgesteuert mit der API rotieren. Die entsprechende Funktion ist jetzt im UI verfügbar. Sieh dir das Video in der folgenden Tabelle an oder lies dir die [Dokumentation](https://docs.gitlab.com/ee/user/project/settings/project_access_tokens.html#use-the-ui) durch.\n\n### Codeausschnitte für die Rotation von Token\n\nIn der folgenden Tabelle findest du Videos, in denen die Rotation von GitLab-Token erläutert wird. \n\n| Token | Voraussetzungen | GitLab-UI | GitLab-API |\n| :---: | :---: | ----- | ----- |\n| Persönliches Zugriffs-Token | Geltungsbereich: API  | [Dokumentation](https://docs.gitlab.com/ee/user/profile/personal_access_tokens.html#create-a-personal-access-token) und [Video](https://youtu.be/v5Nj3Jy4vaI?t=76)  | [Dokumentation](https://docs.gitlab.com/ee/api/personal_access_tokens.html#rotate-a-personal-access-token) und [Video](https://youtu.be/v5Nj3Jy4vaI?t=92)  |\n| Gruppenzugriffs-Token | Geltungsbereich: API und Rolle(n): Eigentümer(in) | [Dokumentation](https://docs.gitlab.com/ee/user/group/settings/group_access_tokens.html#create-a-group-access-token-using-ui) und [Video](https://youtu.be/v5Nj3Jy4vaI?t=203)  | [Dokumentation](https://docs.gitlab.com/ee/api/group_access_tokens.html) und [Video](https://youtu.be/v5Nj3Jy4vaI?t=214)  |\n| Projektzugriffs-Token | Geltungsbereich: API und Rolle(n): Eigentümer(in), Betreuer(in) | [Dokumentation](https://docs.gitlab.com/ee/user/project/settings/project_access_tokens.html#create-a-project-access-token) und [Video](https://youtu.be/v5Nj3Jy4vaI?t=335)  | [Dokumentation](https://docs.gitlab.com/ee/api/project_access_tokens.html) und [Video](https://youtu.be/v5Nj3Jy4vaI?t=349)  |\n\n## Best Practices für die Token-Verwaltung\n\n### Prinzip des geringsten Privilegs\n\nMindere Risiken, indem du Berechtigungen für Token wirklich nur für die jeweiligen unbedingt nötigen Aufgaben zuweist. Auf diese Weise kannst du Fehlerquellen in deinen Systemen proaktiv vorhersagen und beheben. Beachte dazu Folgendes:\n\n* Wähle den richtigen Token für den richtigen Job aus. Infos dazu findest du im Flussdiagramm.  \n* Weise beim Erstellen eines Tokens nur die erforderlichen Geltungsbereiche zu. Verwende beispielsweise schreibgeschützte Geltungsbereiche für Token mit Aufgaben für Auditor(innen). Siehe [Rollen](https://docs.gitlab.com/ee/user/permissions.html#roles).  \n* Vermeide es, Administratorrechte zu gewähren, wenn sie nicht unbedingt nötig sind.\n* Erzwinge eine instanzweite Standard-Token-[Lebensdauer](https://docs.gitlab.com/ee/administration/settings/account_and_limit_settings.html#set-a-lifetime-1).\n* Überprüfe und auditiere Token-Berechtigungen regelmäßig, um sicherzustellen, dass sie den aktuellen Anforderungen deines Unternehmens entsprechen.  \n* Widerrufe Token, sobald die Aufgabe abgeschlossen ist.\n\n### Service-Konten\n\n[Dienstkonten](https://docs.gitlab.com/ee/user/profile/service_accounts.html) stellen sicher, dass Token an nicht-menschliche Entitäten gebunden sind. Dadurch werden sie von einzelnen Benutzerkonten getrennt und die Abhängigkeit von bestimmten Benutzer(inne)n wird verringert. Anstatt persönliche Konten zu verwenden, um Token für die Automatisierung zu generieren, solltest du Dienstkonten mit eingeschränktem Geltungsbereich erstellen. Zu den Vorteilen gehören:\n\n* Verwendung von Dienstkonto-Token in CI/CD-Pipelines, um Störungen durch Änderungen des Benutzerkontos zu vermeiden  \n* Programmgesteuerte Automatisierung von Rotationsprozessen, da persönliche Konten nicht betroffen sind\n* Klarere Überwachung und Prüfung der von Dienstkonten durchgeführten Aktionen  \n* Dienstkonten [ohne Ablaufdatum](https://docs.gitlab.com/ee/user/profile/personal_access_tokens.html#create-a-service-account-personal-access-token-with-no-expiry-date)\n* Verbraucht keinen [Lizenzplatz](https://docs.gitlab.com/user/profile/service_accounts/#create-a-service-account)\n\nGitLab plant die Veröffentlichung einer neuen [Benutzeroberfläche für Dienstkonten](https://gitlab.com/groups/gitlab-org/-/epics/9965) als Gegenstück zur [API-basierten Erstellung](https://docs.gitlab.com/ee/api/user_service_accounts.html#create-a-service-account-user), wodurch die Verwaltung von Dienstkonten und der damit verbundenen Token vereinfacht werden soll. In der folgenden Demo wird die programmgesteuerte Verwendung von Dienstkonten erläutert.\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/oZvjg0SCsqY?si=cj-0LjfeonLGXv9u\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line ->\n\n### Sicherheitslücken-Tools\n\nNutze die integrierten Sicherheitstools von GitLab, um Sicherheitslücken, die durch die Nutzung von Token entstehen, zu identifizieren und zu beheben. Für eine maximale Abdeckung wird empfohlen, alle Tools gemeinsam zu verwenden.\n\n* [Erkennung von Geheimnissen](https://docs.gitlab.com/ee/user/application_security/secret_detection/): Scannt dein Repository nach fest codierten Geheimnissen wie API-Token, Passwörtern und anderen vertraulichen Informationen. Sieh dir die [Liste der erkannten Geheimnisse](https://docs.gitlab.com/ee/user/application_security/secret_detection/detected_secrets.html) an.\n* [Statische Anwendungssicherheitstests (SAST)](https://docs.gitlab.com/ee/user/application_security/sast/): Analysiert deinen Quellcode auf Sicherheitslücken und [stellt unter anderem Berichte mit UI-Ergebnissen in Merge Requests bereit](https://docs.gitlab.com/ee/user/application_security/sast/#features).\n* [Abhängigkeitssuche](https://docs.gitlab.com/ee/user/application_security/dependency_scanning/): Stellt sicher, dass in deinem Projekt verwendete Bibliotheken von Drittanbietern keine Sicherheitslücken hinsichtlich ihrer Token aufweisen.\n\n### Audit-Protokolle und Überwachung\n\nPflege den Zustand von Token, indem du regelmäßig Audit-Protokolle und die Token-Nutzung auf Instanz- und/oder Gruppenebene überprüfst.\n\n* [Audit Events](https://docs.gitlab.com/ee/user/compliance/audit_events.html): Protokolliere Audit Events in GitLab, um Aktivitäten im Zusammenhang mit Token zu verfolgen, z. B. Erstellung, Verwendung, Löschung und ungewöhnliche API-Aufrufe (nicht zulässige Parameter in Protokollen und konsistente Auslöser des Rate Limiters). \n* [IP-Allowlisting](https://docs.gitlab.com/ee/administration/reporting/ip_addr_restrictions.html#configure-ip-address-restrictions): Verhindert, dass böswillige Benutzer(innen) ihre Aktivitäten hinter mehreren IP-Adressen verbergen.\n* [Alarme](https://docs.gitlab.com/ee/operations/incident_management/alerts.html): Richte Alarme für ungewöhnliche Aktivitäten ein (lösen z. B. Paging für Bereitschaftsrotationen aus oder verwende es, um Vorfälle zu erstellen).\n* [Credentials Inventory](https://docs.gitlab.com/ee/administration/credentials_inventory.html): Erhalte vollständige Kontrolle über alle verfügbaren Zugriffs-Token sowie die Möglichkeit, diese bei Bedarf zu widerrufen.\n* [Benachrichtigungen](https://docs.gitlab.com/ee/user/profile/notifications.html): Bearbeite proaktiv alle Ablaufbenachrichtigungen für Token (Gruppen-, Projekt- und persönliche Token), die du per E-Mail erhältst. Aufgrund der Nachfrage unserer Kund(inn)en wurde diese Funktion kürzlich um 30-Tage- und 60-Tage-Benachrichtigungen erweitert (die Standardeinstellung ist 7 Tage).   \n* [Webhooks](https://docs.gitlab.com/ee/user/project/integrations/webhooks.html#create-a-webhook): Zugriffs-Token-Webhooks können für Gruppen und Projekte konfiguriert werden, um Ereignisse sieben Tage vor Ablauf von Token auszulösen. Diese Funktion wurde kürzlich auch um 30-Tage- und 60-Tage-Benachrichtigungen hinter dem Feature-Flag **:extended_expiry_webhook_execution_setting** erweitert (standardmäßig deaktiviert).\n\n## Was kommt als Nächstes?\n\nAngesichts des großen Token-Katalogs von GitLab gibt es laufende [Pläne](https://gitlab.com/gitlab-org/gitlab/-/issues/502630) für eine Konsolidierung mit Schwerpunkt auf der Lebensdauer, detaillierten Geltungsbereichen, konsistenter Verwaltung und Nutzung. Derzeit priorisieren wir hinsichtlich der Token-Funktionen ein umfassendes UI für Dienstkonten, zusätzliche Arten von Zugangsdaten im Credentials Inventory sowie ein verbessertes Auditing für Token und Dienstkonten.\n\n> Melde dich für eine [kostenlose Testversion von GitLab Ultimate](https://about.gitlab.com/free-trial/) an, um die Token-Verwaltung zu nutzen.",[705,675,707,9,677],{"slug":1490,"featured":90,"template":682},"the-ultimate-guide-to-token-management-at-gitlab","content:de-de:blog:the-ultimate-guide-to-token-management-at-gitlab.yml","The Ultimate Guide To Token Management At Gitlab","de-de/blog/the-ultimate-guide-to-token-management-at-gitlab.yml","de-de/blog/the-ultimate-guide-to-token-management-at-gitlab",{"_path":1496,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1497,"content":1503,"config":1509,"_id":1511,"_type":13,"title":1512,"_source":15,"_file":1513,"_stem":1514,"_extension":18},"/de-de/blog/top-10-gitlab-workflow-hacks-you-need-to-know",{"title":1498,"description":1499,"ogTitle":1498,"ogDescription":1499,"noIndex":6,"ogImage":1500,"ogUrl":1501,"ogSiteName":695,"ogType":696,"canonicalUrls":1501,"schema":1502},"Die Top 10 GitLab-Workflow-Hacks, die du kennen musst","Eine Produktmanagerin von GitLab nennt ihre Lieblingstricks, um schnell und effizient durch die GitLab DevSecOps-Plattform zu navigieren und die Zusammenarbeit im Team zu fördern.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099361/Blog/Hero%20Images/Blog/Hero%20Images/lightvisibility_lightvisibility.png_1750099361252.png","https://about.gitlab.com/blog/top-10-gitlab-workflow-hacks-you-need-to-know","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Die Top 10 GitLab-Workflow-Hacks, die du kennen musst\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Amanda Rueda\"}],\n        \"datePublished\": \"2024-04-09\",\n      }\n                  ",{"title":1498,"description":1499,"authors":1504,"heroImage":1500,"date":1505,"body":1506,"category":1507,"tags":1508},[745],"2024-04-09","In der Welt der Softwareentwicklung geht es bei der Effizienz nicht nur um Schnelligkeit, sondern auch um intelligente Navigation. Als Produktmanagerin von GitLab weiß ich, wie wichtig Effizienz bei der Arbeit mit der DevSecOps-Plattform ist. Dies sind meine 10 Lieblingsfunktionen von GitLab. Vielleicht sind das genau die Workflow-Hacks, von denen du noch gar nicht wusstest, dass du sie brauchst.\n\nMit diesen Geheimtipps kannst du die Produktivität und Zusammenarbeit in deinem Team auf eine neue Stufe heben.\n\n## 1. Kommentare auflösen\n\nNicht nur für Merge Requests! Das Auflösen von Kommentaren zu Tickets sorgt für Ordnung und vereinfacht die Aufgabenverwaltung erheblich. Es ist besonders praktisch, um Feedback effizient zu verwalten.\n\n> **Warum liebe ich es?** Das Auflösen von Kommentaren sorgt nicht nur für Ordnung in einem Ticket, sondern ist auch eine gute Möglichkeit, Aufgaben zu verwalten.\n> \n> **Anwendungsfall.** Das Auflösen von Kommentaren ist ein großartiges Tool für Tickets, zu denen du Feedback sammelst. Du kannst auf das Feedback reagieren und einen Link bereitstellen, den Kommentar auflösen und mit dem nächsten fortfahren.\n> \n> __[Anleitung](https://docs.gitlab.com/ee/user/discussions/#resolve-a-thread)__\n\n![Beispiel für das Auflösen von Kommentaren – Bild 1](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099376/Blog/Content%20Images/Blog/Content%20Images/image5_aHR0cHM6_1750099376147.gif)\n\n\u003Cp>\u003C/p>\n\n## 2. Interne Kommentare\n\nSprich direkt mit deinem Team, ohne externe Zuhörer(innen). Diskutiere privat innerhalb eines Tickets oder eines Merge Requests. Dabei sind die Kommentare nur für deine Teammitglieder sichtbar. Es ist die perfekte Balance zwischen Transparenz und Vertraulichkeit.\n\n> **Warum liebe ich es?** Es schafft ein Gleichgewicht zwischen Vertraulichkeit und Transparenz und hält gleichzeitig die breitere Diskussion für die Gemeinschaft offen.\n> \n> **Anwendungsfall.** Wenn du eine Produkteinführung koordinierst, kann dein Marketingteam interne Kommentare nutzen, um Nachrichten und Strategien zu diskutieren und zu verfeinern. So bleiben deine Diskussionen an einem zentralen Ort und sind im Entwurfsmodus für das Team leicht zugänglich.\n> \n> **[Anleitung](https://docs.gitlab.com/ee/user/discussions/#add-an-internal-note)**\n\n![Beispiel für interne Kommentare](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099376/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750099376148.png)\n\n\u003Cp>\u003C/p>\n\n## 3. Und/oder in Filtern\n\nBei der Suche nach Datensätzen auf einer Listenseite kannst du mit Hilfe von Und/oder-Filtern das Durcheinander durchdringen und schnell und effizient genau das finden, wonach du suchst.\n\n> **Warum liebe ich es?** Es ist perfekt, um genau das zu finden, was du suchst, und um effiziente und optimierte Workflows zu ermöglichen.\n> \n> **Anwendungsfall.** Suche nach Funktionstickets zu einer bestimmten Initiative, die bestimmten Gruppen zugeordnet sind.\n>\n> __[Anleitung](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#filter-with-the-or-operator)__\n\n![Beispiel des Und/oder-Filters](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099376/Blog/Content%20Images/Blog/Content%20Images/and_or__1__aHR0cHM6_1750099376152.gif)\n\n\u003Cp>\u003C/p>\n\n## 4. Automatisches Erweitern von URLs\n\nWenn du ein „+“ oder „+s“ an das Ende einer GitLab-URL anhängst, wird sie zu einem informativen Code-Schnipsel, mit dem du den Fortschritt teilen kannst, ohne dass deine Teammitglieder die Seite verlassen müssen.\n\n> **Warum liebe ich es?** Es ist wie ein Röntgenblick für URLs – du siehst die wichtigen Dinge auf einen Blick, ohne zu klicken!\n> \n> **Anwendungsfall.** Du möchtest in Kommentaren Fortschritte teilen? Füge einfach ein „+s“ zum Link hinzu und schon sind alle auf dem gleichen Stand.\n> \n> __[Anleitung](https://docs.gitlab.com/ee/user/markdown.html#show-the-issue-merge-request-or-epic-title-in-the-reference)__\n\n![Beispiel für das automatische Erweitern von URLs](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099376/Blog/Content%20Images/Blog/Content%20Images/image7_aHR0cHM6_1750099376154.gif)\n\n\u003Cp>\u003C/p>\n\n## 5. Schnellzugriff\n\nMit einfachen Textbefehlen kannst du über den Schnellzugriff Aufgaben wie die Zuweisung von Benutzer(inne)n, das Hinzufügen von Bezeichnungen und vieles mehr direkt aus dem Beschreibungs- oder Kommentarfeld heraus erledigen. Das spart Klicks und Zeit.\n\n> **Warum liebe ich es?** Es spart Klicks und Zeit.\n> \n> **Anwendungsfall.** Beim Erstellen eines neuen Tickets verwende ich den Schnellzugriff, um automatisch Labels und einen Meilenstein hinzuzufügen und beim Speichern des Datensatzes eine Verbindung mit dem Epic herzustellen.\n> \n> __[Anleitung](https://docs.gitlab.com/ee/user/project/quick_actions.html)__\n\n![Beispiel für eine Schnellzugriff-Aktion](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099376/Blog/Content%20Images/Blog/Content%20Images/image6_aHR0cHM6_1750099376156.gif)\n\n\u003Cp>\u003C/p>\n\n## 6. Stapelbearbeitung \n\nFüge Labels hinzu, ändere Beauftragte oder aktualisiere Meilensteine für mehrere Probleme auf einmal. Diese Funktion macht potenziell mühsame Aktualisierungen zum Kinderspiel und ermöglicht schnelle Anpassungen für zahlreiche Tickets.\n\n> **Warum liebe ich es?** Weil es lästige Updates zu schnellen Updates macht!\n> \n> **Anwendungsfall.** Du willst die Tickets des gesamten Sprints mit dem Label „Review erforderlich“ kennzeichnen? Verwende einfach einen Filter, wähle alle aus und füge die Labels für alle hinzu – kinderleicht.\n> \n> __[Anleitung](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#bulk-edit-issues-from-a-project)__\n\n![Beispiel für die Stapelbearbeitung](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099376/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750099376157.gif)\n\n\u003Cp>\u003C/p>\n\n## 7. Epic-Bahnen\n\nGruppiere Tickets in deinem Board in Epics, um den Fortschritt visuell zu verfolgen und zu diskutieren. So kannst du deine Arbeit bei Besprechungen oder Standups besser einordnen.\n\n> **Warum liebe ich es?** Du kannst den Kontext der Arbeit leicht nachvollziehen, während du dir das Board ansiehst.\n> \n> **Anwendungsfall.** Durch die Gruppierung nach Epics kannst du deine Arbeit bei Standup-Reviews leicht mit der übergeordneten Initiative verknüpfen.\n> \n> __[Anleitung](https://docs.gitlab.com/ee/user/project/issue_board.html#group-issues-in-swimlanes)__\n\n![Beispiel für Epic-Bahnen](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099376/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750099376158.gif)\n\n\u003Cp>\u003C/p>\n\n## 8. Wiki-Diagramme \n\nVeranschauliche Ideen und Workflows direkt auf deinen Wikiseiten mit einfach zu erstellenden Diagrammen. Diese Funktion unterstützt das visuelle Lernen und vereinfacht komplexe Konzepte.\n\n> **Warum liebe ich es?** Es ist unglaublich benutzerfreundlich und flexibel.\n> \n> **Anwendungsfall.** Wenn du den Workflow einer neuen Funktion skizzierst, zeichnest du ihn direkt in die Wiki-Seite ein, damit er für alle im Team verständlich ist.\n> \n> __[Anleitung](https://docs.gitlab.com/ee/administration/integration/diagrams_net.html)__\n\n![Beispiel für Wiki-Diagramme](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099376/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750099376159.gif)\n\n\u003Cp>\u003C/p>\n\n## 9. Tabellenerstellung\n\nKein Ärger mehr mit Markdown für die Tabellenerstellung. Mit dem Rich-Text-Editor kannst du mühelos Tabellen einfügen und formatieren, wodurch die Dokumentation übersichtlicher und strukturierter wird.\n\n> **Warum liebe ich es?** Es macht die Erstellung von Tabellen zum Kinderspiel und sorgt für saubere und strukturierte Aktualisierungen mit nur wenigen Klicks.\n> \n> **Anwendungsfall.** Stellst du eine Sprint-Retro zusammen? Füge schnell eine Tabelle ein, um Feedback, Maßnahmen und Eigentümer(innen) zu organisieren, damit der Review-Prozess für alle reibungsloser abläuft.\n> \n> __[Anleitung](https://docs.gitlab.com/ee/user/rich_text_editor.html#tables)__ \n\n![Beispiel für die Tabellenerstellung](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099376/Blog/Content%20Images/Blog/Content%20Images/image8_aHR0cHM6_1750099376160.gif)\n\n\u003Cp>\u003C/p>\n\n## 10. Einbetten von Videos und GIFs\n\nVerbessere die Beschreibungen oder Kommentare deiner Tickets und Epics mit eingebetteten GIFs und YouTube-Videos, um deiner Kommunikation eine dynamische Ebene zu verleihen.\n\n> **Warum liebe ich es?** Manchmal sagt ein GIF oder ein Video mehr als tausend Worte.\n> \n> **Anwendungsfall.** Du versuchst, einen Fehler in der Benutzeroberfläche zu erklären? Bette ein YouTube-Video ein, in dem du die vorgeschlagene Funktionsverbesserung kurz vorstellst.\n\n![Beispiel für die Einbettung von Videos und GIFs](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099376/Blog/Content%20Images/Blog/Content%20Images/gif__1__aHR0cHM6_1750099376161.gif)\n\n\u003Cp>\u003C/p>\n\n## Erkunde diese Funktionen\n\nDiese Funktionen sind nur die Spitze des Eisbergs im umfassenden Toolkit von GitLab, das für mehr Effizienz und eine bessere Zusammenarbeit sorgt. Auch wenn sie nicht ausreichend genutzt werden, können sie erhebliche Auswirkungen auf deinen Workflow haben. Du solltest diese Funktionen weiter erkunden und in deine tägliche Routine integrieren. \n\n> Willst du deinen DevSecOps-Workflow mit GitLab verbessern? [Teste GitLab Ultimate 30 Tage lang kostenlos](https://gitlab.com/-/trial_registrations/new).\n","devsecops",[705,707,9,928],{"slug":1510,"featured":6,"template":682},"top-10-gitlab-workflow-hacks-you-need-to-know","content:de-de:blog:top-10-gitlab-workflow-hacks-you-need-to-know.yml","Top 10 Gitlab Workflow Hacks You Need To Know","de-de/blog/top-10-gitlab-workflow-hacks-you-need-to-know.yml","de-de/blog/top-10-gitlab-workflow-hacks-you-need-to-know",{"_path":1516,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1517,"content":1523,"config":1528,"_id":1530,"_type":13,"title":1531,"_source":15,"_file":1532,"_stem":1533,"_extension":18},"/de-de/blog/unveiling-a-new-epic-experience-for-improved-agile-planning",{"title":1518,"description":1519,"ogTitle":1518,"ogDescription":1519,"noIndex":6,"ogImage":1520,"ogUrl":1521,"ogSiteName":695,"ogType":696,"canonicalUrls":1521,"schema":1522},"Wir stellen euch die neue Epic-Erfahrung für verbessertes Agile Planning vor","Ein Update für GitLab Epics, mit dem die Planung verbessert wird und deine Workflows optimiert werden durch nahtlose Migration, die ein besseres Projektmanagement ermöglicht.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749660011/Blog/Hero%20Images/blog-image-template-1800x945__21_.png","https://about.gitlab.com/blog/unveiling-a-new-epic-experience-for-improved-agile-planning","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Wir stellen euch die neue Epic-Erfahrung für verbessertes Agile Planning vor\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Amanda Rueda\"}],\n        \"datePublished\": \"2024-07-03\",\n      }",{"title":1518,"description":1519,"authors":1524,"heroImage":1520,"date":1525,"body":1526,"category":751,"tags":1527,"updatedDate":1304},[745],"2024-07-03","Auf unserem kontinuierlichen Weg zu besserem Agile Planning in GitLab haben wir [kürzlich einen neuen Look vorgestellt](https://about.gitlab.com/blog/first-look-the-new-agile-planning-experience-in-gitlab/) (englischsprachiger Artikel). Dieses Update ist ein wichtiger Schritt hin zu einem vereinheitlichten, flexiblen Planungstool, das an deine Bedürfnisse angepasst ist. In diesem Artikel sehen wir uns einen entscheidenden Teil der Initiative an: die neue Epic-Erfahrung. \n\nDu erfährst mehr über die demnächst verfügbaren Funktionen von Epics und die Motivation hinter diesen Änderungen, die deine Projektmanagement-Möglichkeiten erweitern sollen.\n\n## Warum die neue Epic-Erfahrung?\n\n### Reaktion auf Feedback von Benutzer(innen)\nIm Rahmen unserer Mission, ein umfassendes Erlebnis für Agile Planning zu bieten, haben wir uns euer Feedback genau angehört. Benutzer(innen) haben von Schwierigkeiten mit der aktuellen Epic-Implementierung berichtet, wie zum Beispiel inkonsistente Funktionen zwischen Epics und Tickets sowie fehlende Flexibilität für unterschiedliche Workflows. Einige Probleme betrafen Workflow-Tools, wie zum Beispiel fehlende Beauftragte bei Epics, sowie fehlende wiederverwendbare Vorlagen. Die neue Epic-Erfahrung soll diese Probleme beheben und das Agile Planning intuitiver und effizienter machen.\n\n### Vereinheitlichtes Workitem-Framework\nUm diese Probleme zu beheben, haben wir ein vereinheitlichtes Workitem-Framework eingeführt. Diese neue Architektur garantiert Konsistenz übergreifend über alle Planungsobjekte – Epics, Tickets und Aufgaben – und vereinfacht so das Benutzererlebnis, während gleichzeitig die Funktionalität verbessert wird. Durch die Konsolidierung des zugrundeliegenden Codes können wir neue Funktionen und Verbesserungen schneller bereitstellen und ermöglichen so einen reibungsloseren, zuverlässigeren Planungsprozess.\n\n> Erfahre mehr darüber, [was dich mit Agile Planning von GitLab erwartet](https://about.gitlab.com/blog/first-look-the-new-agile-planning-experience-in-gitlab/) (englischsprachiger Artikel).\n\n## Hauptfunktionen der neuen Epic-Erfahrung\n\n### Erweiterte Detailseite\nEine der gravierendsten Änderungen ist die überarbeitete Epic-Detailseite. Das neue Design überzeugt durch eine klarere, intuitivere Oberfläche, mit denen du deine Epics einfacher verwalten und nachverfolgen kannst.\n\nDas sind einige der wichtigsten neuen Funktionen:\n* **Beauftragte** - weise Teammitgliedern Epics zu und verbessere so die Verantwortlichkeit und den Überblick.\n* **Integritätsprobleme** - bewerte den Status deiner Epics rasch mit den neuen Zustandsindikatoren.\n* **Zeiterfassung** - ermögliche einen transparenten Überblick über die aufgewendete Zeit und stelle sicher, dass Ressourcen in den Projekten effizient eingesetzt werden.\n* **Verlauf** - sieh dir den gesamten Verlauf des Epics an.\n* **Kurzbeschreibung** - sieh dir Beschreibungen von langen Workitems einfach an, ohne ewig scrollen zu müssen. Beschreibungen werden standardmäßig abgeschnitten und können über den Link „Mehr anzeigen“ als Volltext angezeigt werden. Dadurch wird dein Workflow optimiert, denn nun kannst du Beschreibungen rasch überfliegen und nur bei Bedarf den gesamten Text anzeigen. So vermeidest du unnötigen Text und die Lesbarkeit wird verbessert.\n* **Benutzerdefinierte Farbe** - passe die Farbe von Epics, die in der Roadmap angesehen werden, an, indem du benutzerdefinierte Farben festlegst. Du kannst dabei HEX- oder RGB-Codes nutzen oder aus einer erweiterten, vordefinierten Palette wählen.\n\n![Screenshot der neuen Epic-Erfahrung](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674437/Blog/Content%20Images/Screenshot_2024-07-10_at_4.22.45_p.m..png)\n\n### Konsistenz über Planungsobjekte hinweg\nDie neue Epic-Erfahrung gleicht sehr der neuen Ticket-Erfahrung, die demnächst verfügbar sein wird (Achtung, Spoiler!) sowie den Aufgaben. So erwartet die Benutzer(innen) ein nahtloses, kohärentes Erlebnis. Durch diese Konsistenz können Workflows optimiert und die Lernkurve für neue Benutzer(innen) abgeflacht werden.\n\n### Zusätzliche Funktionen\nWir planen, iterativ spannende neue Funktionen hinzuzufügen, die deine Planung verbessern. Unser Ziel ist es, dir die Möglichkeit zu geben, Planungsprozesse mit GitLab so anzupassen, dass sie perfekt zu den einzigartigen Anforderungen deines Unternehmens passen. Sobald wir die neue Epic-Erfahrung veröffentlicht haben, kannst du dich mit jeder Release auf weitere Funktionen freuen! Und davon gibt es viele – hier ist ein kleiner Auszug unserer Favoriten:\n- [Vorlagen](https://gitlab.com/gitlab-org/gitlab/-/issues/428690)\n- [Benutzerdefinierte Felder](https://gitlab.com/groups/gitlab-org/-/epics/235)\n- [Konfigurierbare Status](https://gitlab.com/groups/gitlab-org/-/epics/5099)\n- [Epics auf Projektebene](https://gitlab.com/gitlab-org/gitlab/-/issues/31840)\n- [Klonen](https://gitlab.com/gitlab-org/gitlab/-/issues/339768)\n- [Verschieben in eine andere Gruppe/ein anderes Projekt](https://gitlab.com/gitlab-org/gitlab/-/issues/339766)\n- [Meilensteine](https://gitlab.com/groups/gitlab-org/-/epics/329)\n\n## Erwartungen an die Migration\nWir wissen, dass Änderungen disruptiv sein können. Daher haben wir die Migration zur neuen Epic-Erfahrung so nahtlos wie möglich gemacht. Alle vorhandenen Epic-Daten, APIs und URLs werden weiterhin wie erwartet funktionieren. Benutzer(innen) müssen für den Umstieg nichts tun. Unsere Self-Managed-Kund(inn)en können sich eine Vorschau des neuen Erlebnisses schon vor der allgemeinen Verfügbarkeit [hier](https://docs.gitlab.com/ee/user/group/epics/epic_work_items.html) in einer Testumgebung ansehen.\n\n## Feedback und Engagement der Community\nWir schätzen eure Beiträge und ermutigen euch, eure Erfahrungen mit der neuen Epic-Erfahrung zu teilen. Euer Feedback ist unerlässlich, um unsere Tools weiter zu verbessern. In unserem [Feedback-Ticket](https://gitlab.com/gitlab-org/gitlab/-/issues/463598) könnt ihr uns eure Gedanken und Vorschläge mitteilen.\n\n## Wie geht es weiter?\nDie neue Epic-Erfahrung in GitLab ist ein bedeutender Schritt für das Agile Planning. Mit erweiterten Funktionen, verbesserter Konsistenz und einem benutzerzentrierten Ansatz sind wir überzeugt, dass diese Änderungen deine Projektmanagementprozesse signifikant verbessern werden. Probier die neuen Funktionen aus und teile uns mit, was dir gefällt. Bleib auf dem Laufenden, denn wir arbeiten weiter an Innovationen und Verbesserungen.\n\n> [Setze ein Lesezeichen auf diese Seite](https://about.gitlab.com/de-de/blog/categories/agile-planning/), um über unsere Neuigkeiten zum Agile Planning auf dem Laufenden zu bleiben.",[750,707,9,677,928],{"slug":1529,"featured":6,"template":682},"unveiling-a-new-epic-experience-for-improved-agile-planning","content:de-de:blog:unveiling-a-new-epic-experience-for-improved-agile-planning.yml","Unveiling A New Epic Experience For Improved Agile Planning","de-de/blog/unveiling-a-new-epic-experience-for-improved-agile-planning.yml","de-de/blog/unveiling-a-new-epic-experience-for-improved-agile-planning",{"_path":1535,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1536,"content":1542,"config":1548,"_id":1550,"_type":13,"title":1551,"_source":15,"_file":1552,"_stem":1553,"_extension":18},"/de-de/blog/use-gitlab-duo-workflow-to-improve-application-quality-assurance",{"title":1537,"description":1538,"ogTitle":1537,"ogDescription":1538,"noIndex":6,"ogImage":1539,"ogUrl":1540,"ogSiteName":695,"ogType":696,"canonicalUrls":1540,"schema":1541},"Verbesserte Qualitätssicherung von Anwendungen mit GitLab Duo Workflow","Erfahre, wie du mithilfe von agentischer KI Unit-Tests zu einer Java-Anwendung hinzufügst (Video-Tutorial inklusive).","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097617/Blog/Hero%20Images/Blog/Hero%20Images/Workflow%201800x945_2gQoQIbY9NvjLFpXtsxtXy_1750097616649.png","https://about.gitlab.com/blog/use-gitlab-duo-workflow-to-improve-application-quality-assurance","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Verbesserte Qualitätssicherung von Anwendungen mit GitLab Duo Workflow\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Cesar Saavedra\"}],\n        \"datePublished\": \"2025-04-10\",\n      }\n                  ",{"title":1537,"description":1538,"authors":1543,"heroImage":1539,"date":1544,"body":1545,"category":703,"tags":1546,"updatedDate":1547},[1466],"2025-04-10","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. [GitLab Duo Workflow](https://about.gitlab.com/de-de/gitlab-duo/agent-platform/), 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 [Java-Beispielprojekts](https://gitlab.com/gitlab-da/playground/csaavedra/gdw/prodmgr-gdw), wie das geht.\n\n> Der GitLab Duo Workflow befindet sich derzeit in der privaten Beta-Phase. Trag dich in die [Warteliste](https://about.gitlab.com/de-de/gitlab-duo/agent-platform/) ein, um zu erfahren, was du mit KI-Tools, die deinen gesamten SDLC verstehen, alles machen kannst.\n\n## Öffne dein Projekt in VS Code\n\n1. Ö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.\n\n2. (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:\n\n![Datei, die die Java-Klasse definiert, für die du mit GitLab Duo Workflow Unit-Tests erstellen möchtest](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097627/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097627482.png)\n\n**Hinweis:** Wir gehen davon aus, dass du die Erweiterung von GitLab Duo Workflow in VS Code bereits aktiviert hast. Wenn nicht, lies dir die [Einrichtungsdokumentation](https://docs.gitlab.com/user/duo_workflow/#use-workflow-in-vs-code) durch (nur in englischer Sprache verfügbar).\n\n3. Starte GitLab Duo Workflow, indem du die Befehlspalette von VS Code öffnest [Strg + Umschalt + P], „GitLab Duo Workflow“ eingibst und **GitLab: Duo Workflow anzeigen** auswählst. Es erscheint eine Registerkarte, die wie folgt aussieht:\n\n![Starten von GitLab Duo Workflow mit VS Code](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097628/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097627483.png)\n\n4. 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:\n\n```unset\nCreate unit tests for class defined in the Product.java file and store the unit tests in its own file titled ProductTest.java\n```\n\n(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“.)\n\n![Eingabe eines Prompts in GitLab Duo Workflow](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097628/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750097627484.png)\n\n5. Klick in GitLab Duo Workflow auf die Schaltfläche **Start**. 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:\n\n![Von GitLab Duo Workflow generierte Analyse und Plan](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097627/Blog/Content%20Images/Blog/Content%20Images/image8_aHR0cHM6_1750097627486.png)\n\n6. Sieh dir die Analyse und den Plan an und klick unten im Fenster auf **Plan genehmigen**, wenn du damit einverstanden bist.\n\n7. GitLab Duo Workflow beginnt mit der Ausführung des genehmigten Plans und nimmt die entsprechenden Änderungen an deinem Projekt vor.\n\n8. Sobald die Ausführung des Plans abgeschlossen ist, siehst du im Projekt ein neues Verzeichnis `src/test/java/csaa/jspring/ProductManager` mit einer neuen Datei mit dem Namen `ProductTest.java`, die alle Unit-Tests für die Klasse `Product.java` enthält.\n\n![Neues Verzeichnis im Projekt mit einem neuen Dateinamen „ProductTest.java“](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097628/Blog/Content%20Images/Blog/Content%20Images/image7_aHR0cHM6_1750097627488.png)\n\n9. Navigiere zu der neu erstellten Datei `ProductTest.java`. Du wirst sehen, dass einige Importanweisungen rot unterstrichen sind, was auf Importfehler hinweist:\n\n![„ProductTest.java“ enthält Importanweisungen und Fehleranzeigen in Rot](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097628/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097627489.png)\n\nGitLab Duo Workflow soll das für uns beheben.\n\n**Hinweis:** Wir hätten GitLab Duo Workflow auch in unserem ersten Prompt bitten können, die Datei `pom.xml` entsprechend zu aktualisieren. Da wir das aber nicht gemacht haben, beheben wir diese Fehler in einem neuen Workflow.\n\n## Starten von GitLab Duo Workflow, um Fehler im generierten Code zu beheben\n\n10. Starte einen neuen Workflow, indem du unten im Analysefenster auf der rechten Seite deines Bildschirms auf die Schaltfläche **Neuer Workflow** klickst.\n\n![Schaltfläche „Neuer Workflow“](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097628/Blog/Content%20Images/Blog/Content%20Images/image6_aHR0cHM6_1750097627491.png)\n\n11. Gib im Textbereich für den Prompt Folgendes ein:\n\n```unset\nThe file ProductTest.java has an error “The import org.junit cannot be resolved”. Please fix it\n```\n\n(Die Datei „ProductTest.java“ hat einen Fehler: „Der Import org.junit kann nicht aufgelöst werden“. Bitte behebe diesen Fehler.)\n\n12. Nachdem du den vorgeschlagenen Plan genehmigt hast, startet GitLab Duo Workflow seine Analyse, indem es die aktuelle `pom.xml`-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 `ProductTest.java` gelesen, um alle Abhängigkeitsfehler zu beheben.\n\n![GitLab Duo Workflow führt eine Analyse durch, indem es die Datei „pom.xml“ liest.](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097627/Blog/Content%20Images/Blog/Content%20Images/image5_aHR0cHM6_1750097627492.png)\n\n## Sieh dir das Tutorial an\n\nDurch 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.\n\nWenn du sehen möchtest, wie das oben Beschriebene in der Praxis funktioniert, sieh dir das folgende Video an:\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/Tuj7TgqY81Q?si=RReuL1pUsLafvAzs\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line ->\n\n> Trag dich in die [Warteliste für die private Beta-Version von GitLab Duo Workflow](https://about.gitlab.com/de-de/gitlab-duo/agent-platform/) ein, um zu sehen, was du mit KI-Tools machen kannst, die deinen gesamten SDLC verstehen.\n\n## Mehr über GitLab Duo Workflow und agentische KI\n\n- [GitLab Duo Workflow: Transparenz und Kontrolle für agentische KI auf Enterprise-Niveau](https://about.gitlab.com/de-de/blog/gitlab-duo-workflow-enterprise-visibility-and-control-for-agentic-ai/)\n- [Dokumentation für GitLab Duo Workflow (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/duo_workflow/)\n- [GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/)\n- [Agentische KI: Entwicklerpotenzial in großem Maßstab freisetzen (The Source) (nur in englischer Sprache verfügbar)](https://about.gitlab.com/the-source/ai/agentic-ai-unlocking-developer-potential-at-scale/)\n",[678,707,705,677,9],"2025-05-01",{"slug":1549,"featured":6,"template":682},"use-gitlab-duo-workflow-to-improve-application-quality-assurance","content:de-de:blog:use-gitlab-duo-workflow-to-improve-application-quality-assurance.yml","Use Gitlab Duo Workflow To Improve Application Quality Assurance","de-de/blog/use-gitlab-duo-workflow-to-improve-application-quality-assurance.yml","de-de/blog/use-gitlab-duo-workflow-to-improve-application-quality-assurance",{"_path":1555,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1556,"content":1560,"config":1568,"_id":1570,"_type":13,"title":1571,"_source":15,"_file":1572,"_stem":1573,"_extension":18},"/de-de/blog/vibe-coding-with-gitlab-duo-agent-platform-issue-to-mr-flow",{"config":1557,"title":1558,"description":1559},{"noIndex":6},"Vibe Coding mit GitLab Duo Agent Platform: 'Issue to MR' Flow","Mit unserem neuesten Flow kommst du in Minuten von der Idee zum Code.",{"heroImage":1561,"body":1562,"authors":1563,"updatedDate":1564,"date":789,"title":1565,"tags":1566,"description":1567,"category":703},"https://res.cloudinary.com/about-gitlab-com/image/upload/f_auto,q_auto,c_lfill/v1749662465/Blog/Hero%20Images/GitLab_Duo_Workflow_Unified_Data_Store__1_.png","[GitLab Duo Agent Platform](https://about.gitlab.com/de-de/gitlab-duo/agent-platform/) (jetzt in der Beta verfügbar) bietet ein Framework für KI-Agenten zur Interaktion mit GitLab-Ressourcen wie Issues und Merge Requests und ermöglicht komplexe, mehrstufige Aufgaben vom Konzept bis zur Fertigstellung. Agent Platform bietet dialogorientierte ([Agentic Chat](https://about.gitlab.com/de-de/blog/gitlab-duo-chat-gets-agentic-ai-makeover/)) und automatisierte ([Agent Flows](https://about.gitlab.com/de-de/blog/gitlab-13-expanding-ai-orchestration-in-software-engineering/)) Erfahrungen zur Unterstützung bei der Code-Generierung, Modernisierung, Behebung von Sicherheitslücken und Projektanalyse – alles mit Enterprise-Grade-Sicherheit und anpassbaren Kontrollen.\n\n\"Issue to MR\" ist ein Agent Flow, der die Umwandlung eines klar definierten Issues in einen Draft Merge Request (MR) vereinfacht. Der Flow analysiert die Beschreibung und Anforderungen eines Issues, öffnet einen Draft MR, der mit dem Issue verknüpft ist, erstellt einen Entwicklungsplan und schlägt eine Implementierung vor – direkt aus der GitLab-Oberfläche.\n\n## Die Herausforderung für Entwickler\n\nProduktanpassungen wie das Umgestalten eines UI-Layouts, das Anpassen der Komponentengröße oder kleine Workflow-Änderungen sollten nicht stundenlange Einrichtungsarbeiten erfordern. Doch Entwickler finden sich in einem frustrierenden Kreislauf wieder: Sie durchsuchen Codebasen nach den richtigen Dateien, erstellen Branches, fügen verstreute Änderungen über mehrere Komponenten zusammen und navigieren durch komplexe Review-Prozesse. Und das alles, bevor sie überhaupt sehen können, ob ihre Lösung funktioniert. Der Entwicklungsaufwand verwandelt einfache Iterationen in zeitaufwändige Aufgaben, verlangsamt Feedback-Schleifen und lässt kleine Produktverbesserungen wie große Projekte erscheinen.\n\n## Wie der Issue to MR Flow eine Anwendungsaktualisierung beschleunigt\n\nDu musst zuerst diese Voraussetzungen erfüllen, bevor du den Issue to MR Flow nutzen kannst.\n\nVoraussetzungen:\n\n* Ein bestehendes Issue mit klaren Anforderungen und Akzeptanz-Kriterien. Dies hilft GitLab Duo Agent Platform besser zu verstehen, was du erreichen möchtest, und verbessert die Qualität deiner Ausgabe.\n* Projektzugriff mit mindestens Developer-Berechtigungen, da der Flow Änderungen am Quellcode deines Projekts vornimmt.\n* GitLab Duo Agent Platform für deine Gruppe oder dein Projekt aktiviert, mit erlaubten Flows. Gehe dazu in deinem Projekt zu **Einstellungen > Allgemein > GitLab Duo > Flow-Ausführung erlauben** und aktiviere es. GitLab ist bestrebt, Sicherheitsvorkehrungen zu bieten, daher erfordern Agentic-AI-Funktionen das Aktivieren dieser Schalter, um sensible Projekte zu schützen und sicherzustellen, dass nur die gewünschten Projekte für GitLab Duo Agent Platform zugänglich sind.\n\nSobald du alle oben genannten Voraussetzungen erfüllt hast, kannst du diese Schritte befolgen, um den Issue to MR Flow zu nutzen:\n\n1. Erstelle ein Projekt-Issue, das beschreibt, was GitLab Duo Agent Platform für dich erreichen soll. Gib so viele Details wie möglich in der Issue-Beschreibung an. Falls das Issue bereits existiert, öffne es über **Plan > Issues** und klicke auf das Issue, das die gewünschte Aktualisierung beschreibt. Drücke dich so präzise wie möglich aus.\n2. Klicke unter der Issue-Überschrift auf **Generate MR with Duo**, um den Flow zu starten.\n3. Wenn du den Fortschritt der Agenten bei der Implementierung deines Issues verfolgen möchtest, gehe zu **Automate > Agent sessions**, um das Live-Session-Log zu sehen, während Agenten planen und Änderungen vorschlagen.\n4. Wenn die Pipeline abgeschlossen ist, erscheint ein Link zum MR in der Issue-Aktivität. Öffne ihn, um die Zusammenfassung und dateibasierte Änderungen zu überprüfen.\n5. Wenn du die von GitLab Duo Agent Platform vorgeschlagenen Aktualisierungen lokal validieren möchtest, kannst du den Branch auf deinen Laptop ziehen, deine App erstellen und ausführen und überprüfen, ob die Aktualisierung wie erwartet funktioniert. Falls nötig, nimm Änderungen im MR vor und fahre mit dem normalen Review fort.\n6. Wenn du mit allen vorgeschlagenen Anwendungsaktualisierungen zufrieden bist, merge den MR in den Main Branch.\n\n## Warum der Issue to MR Flow gut für Anwendungsänderungen funktioniert\n\nDer Issue to MR Flow schlägt Code-Änderungen vor und aktualisiert den MR direkt, sodass du weniger Zeit mit der Dateisuche verbringst und nur das Ergebnis bewerten und überprüfen musst. Zusätzlich wird der MR automatisch mit dem ursprünglichen Issue verknüpft, was den Kontext für Reviewer und Stakeholder klar hält. Schließlich kannst du die Agent-Session überwachen, um zu verstehen, was bei jedem Schritt passiert.\n\n## Vorteile von GitLab Duo Agent Platform\n\nGitLab Duo Agent Platform ist [eine agentische Orchestrierungsschicht](https://about.gitlab.com/de-de/blog/gitlab-duo-agent-platform-public-beta/), die **vollständigen Projektkontext** mitbringt, einschließlich Planung, Codierung, Erstellung, Sicherung, Bereitstellung und Überwachung, sodass Agenten im gesamten Software-Entwicklungslebenszyklus (SDLC) helfen können, nicht nur bei der Code-Bearbeitung.\n\n* Einheitliches Datenmodell: GitLab Duo Agents arbeiten mit GitLabs einheitlichen SDLC-Daten und ermöglichen qualitativ hochwertigere Entscheidungen und Zusammenarbeit bei Aufgaben – auch bei nicht codebezogenen.\n* Sicherheit und Compliance sind integriert: GitLab Duo Agents laufen innerhalb von Enterprise-Sicherheitsvorkehrungen und sind auch in stark regulierten oder Offline-/Air-Gap-Umgebungen nutzbar.\n* Interoperabilität und Erweiterbarkeit: Orchestriere Flows über Anbieter und Tools hinweg; verbinde externe Daten über [MCP](https://about.gitlab.com/topics/ai/model-context-protocol/)/A2A für reicheren Kontext.\n* Skaliere die Zusammenarbeit: GitLab Duo Agents arbeiten in der GitLab-UI und IDEs und ermöglichen Viele-zu-Viele-Mensch-Agent-Zusammenarbeit.\n* Auffindbar und teilbar: Finde und teile Agents und Flows in einem zentralisierten AI-Katalog.\n\n## Probiere den Issue to MR Flow noch heute aus\n\nFür Anwendungsaktualisierungen, wie eine kleine UI-Anpassung, hilft dir der Issue to MR Flow, schnell von einem klaren Issue zu einem überprüfbaren MR zu gelangen, mit Fortschritt, den du überwachen kannst, und Änderungen, die du validieren und über deinen Standardworkflow mergen kannst. Er bewahrt den Kontext, reduziert Übergaben und lässt dein Team sich auf Qualität statt auf Routinearbeit konzentrieren.\n\nSieh dir den Issue to MR Flow in Aktion an:\n\n\u003C!-- blank line -->\n\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/BrrMHN4gXF4?si=J7beTgWOLxvS4hOw\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n> Probiere den Issue to MR Flow auf GitLab Duo Agent Platform jetzt mit einer [kostenlosen Testversion von GitLab Ultimate mit Duo Enterprise](https://about.gitlab.com/de-de/free-trial/) aus.",[1466],"2025-09-08","Vibe Coding mit GitLab Duo Agent Platform: Issue to MR",[678,677,9,705],"So aktualisierst du deine Anwendung mit unserem neuesten Flow in wenigen Minuten. ",{"featured":90,"template":682,"slug":1569},"vibe-coding-with-gitlab-duo-agent-platform-issue-to-mr-flow","content:de-de:blog:vibe-coding-with-gitlab-duo-agent-platform-issue-to-mr-flow.yml","Vibe Coding With Gitlab Duo Agent Platform Issue To Mr Flow","de-de/blog/vibe-coding-with-gitlab-duo-agent-platform-issue-to-mr-flow.yml","de-de/blog/vibe-coding-with-gitlab-duo-agent-platform-issue-to-mr-flow",{"_path":1575,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1576,"content":1582,"config":1589,"_id":1591,"_type":13,"title":1592,"_source":15,"_file":1593,"_stem":1594,"_extension":18},"/de-de/blog/what-are-the-benefits-of-a-microservices-architecture",{"title":1577,"description":1578,"ogTitle":1577,"ogDescription":1578,"noIndex":6,"ogImage":1579,"ogUrl":1580,"ogSiteName":695,"ogType":696,"canonicalUrls":1580,"schema":1581},"Microservices-Architektur: Definition und Vorteile","Entdecke die Welt der Microservices-Architektur: Funktionsweise, Vorteile & Unterschiede zu traditionellen Architekturen für flexible & effiziente Anwendungen.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749662898/Blog/Hero%20Images/microservices-explosion.jpg","https://about.gitlab.com/blog/what-are-the-benefits-of-a-microservices-architecture","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Microservices-Architektur: Definition und Vorteile\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"GitLab\"}],\n        \"datePublished\": \"2022-09-29\",\n      }",{"title":1577,"description":1578,"authors":1583,"heroImage":1579,"date":1585,"body":1586,"category":1507,"tags":1587,"updatedDate":746},[1584],"GitLab","2022-09-29","In der modernen Softwareentwicklung sind Microservices zu einem beliebten Architekturansatz geworden, um die Effizienz und Flexibilität von Anwendungen zu verbessern. \n\nIn diesem Artikel erfährst du alles über die Funktionsweise, Vorteile und Unterschiede zu anderen Architekturen. \n\n## Was sind Microservices?\n\n[Microservices](https://about.gitlab.com/topics/microservices/) sind eine Softwarearchitektur, bei der eine Anwendung in eine Reihe kleiner, unabhängiger Dienste unterteilt wird. Jeder dieser Dienste ist eigenständig, erfüllt eine spezifische Funktion und kommuniziert mit anderen Diensten über klar definierte Schnittstellen, häufig über APIs (Application Programming Interfaces). Im Gegensatz zur monolithischen Architektur, bei der die gesamte Anwendung als ein einziges, großes System entwickelt und bereitgestellt wird, ermöglichen Microservices eine modulare und flexible Entwicklung.\n\n### Microservices: Beispiel\n\nIn einer E-Commerce-Anwendung könnte der Bestellservice eine Anfrage erhalten, der Produktservice die Verfügbarkeit prüfen, der Zahlungsservice die Zahlung verarbeiten und der Benachrichtigungsservice eine Bestellbestätigung senden. Jeder dieser Schritte wird von einem eigenen Microservice ausgeführt.\n\n## Wie funktionieren Microservices und was sind die Vorteile?\n\nEs gibt zahlreiche Microservices-Vorteile, die sowohl Entwickler(innen) als auch Unternehmen ansprechen. Durch die Zerlegung einer Anwendung in kleinere, unabhängige Dienste können Entwickler(innen) effizienter arbeiten und schneller auf Marktanforderungen reagieren. Diese Flexibilität und Skalierbarkeit führen zu einer verbesserten Leistung und Ausfallsicherheit. \n\u003Ch3>1. Verbesserte Skalierbarkeit\u003C/h3>\nDa jeder Microservice unabhängig arbeitet, können Cloud-Microservices einfacher hinzugefügt, entfernt, aktualisiert oder skaliert werden. Entwickler(innen) können diese Aufgaben durchführen, ohne andere Microservices im System zu beeinträchtigen. Unternehmen haben die Möglichkeit, jeden Microservice nach Bedarf zu skalieren. Beispielsweise kann ein bestimmter Microservice, der während saisonaler Einkaufsspitzen eine erhöhte Nachfrage erfährt, effizient mit zusätzlichen Ressourcen ausgestattet werden. Sinkt die Nachfrage nach der Saison, kann der Microservice wieder heruntergefahren werden, sodass die freigewordenen Ressourcen oder Rechenkapazitäten anderweitig genutzt werden können.\n\n### 2. Verbesserte Fehlerisolierung\n\nBei einer monolithischen Architektur führt ein Fehler in einem Teil der Struktur dazu, dass alle Komponenten zusammenbrechen. Im Gegensatz dazu ist es bei einer Microservices-Architektur viel unwahrscheinlicher, dass der Ausfall eines Dienstes andere Teile der Anwendung beeinträchtigt, da jeder Microservice unabhängig läuft. Unternehmen sollten jedoch vorsichtig sein, da große Datenmengen in bestimmten Situationen immer noch problematisch sein können.\n\nDer Vorteil der Microservice-Architektur liegt darin, dass Entwickler(innen) Funktionen implementieren können, die Kaskadenausfälle verhindern. Zudem gibt es verschiedene [Tools von GitLab](https://handbook.gitlab.com/handbook/tools-and-tips/) und anderen Anbietern, die die Fehlertoleranz von Microservices erhöhen und somit die Ausfallsicherheit der Infrastruktur verbessern.\n\n### 3. Programmsprache und Technologieunabhängigkeit\n\nEine Microservice-Anwendung kann in jeder beliebigen Programmiersprache entwickelt werden, sodass die Entwickler(innen)teams die für ihre Arbeit am besten geeignete Sprache wählen können. Diese sprachunabhängige Flexibilität von Microservices-Architekturen ermöglicht es den Entwickler(innen), ihre vorhandenen Fähigkeiten optimal zu nutzen, ohne eine neue Programmiersprache erlernen zu müssen. Sie können somit effizienter arbeiten. Ein weiterer Vorteil von Cloud-basierten Microservices ist, dass Entwickler(innen) von jedem internetfähigen Gerät aus auf die Anwendung zugreifen können, unabhängig von der verwendeten Plattform.\n\n### 4. Einfachere Bereitstellung\n\nMit einer Microservices-Architektur können Teams unabhängige Anwendungen bereitstellen, ohne andere Dienste im System zu beeinträchtigen. Diese Fähigkeit, einer der Hauptvorteile von Microservices, ermöglicht es Entwickler(innen), neue Module hinzuzufügen, ohne die gesamte Systemstruktur umgestalten zu müssen. Unternehmen können dadurch effizient und flexibel neue Funktionen nach Bedarf integrieren.\n\n### 5. Wiederverwendbarkeit in verschiedenen Geschäftsbereichen\n\nEinige Microservice-Anwendungen können innerhalb eines Unternehmens mehrfach genutzt werden. Beispielsweise kann eine Website, die verschiedene Bereiche mit jeweils einer Anmelde- oder Zahlungsoption enthält, dieselbe Microservice-Anwendung für jede dieser Instanzen verwenden.\n\n### 6. Schnellere Markteinführung\n\nDie Entwickler(innen) können diese neuen „Mikroservices\" in die Architektur integrieren, ohne Konflikte mit anderem Code oder Ausfälle von Diensten befürchten zu müssen, die die gesamte Website beeinträchtigen könnten. Entwicklungsteams, die an verschiedenen Microservices arbeiten, müssen nicht auf die Fertigstellung der Arbeiten anderer Teams warten. Unternehmen können neue Funktionen schnell entwickeln und bereitstellen sowie ältere Komponenten aktualisieren, sobald neue Technologien die Weiterentwicklung ermöglichen.\n\n### 7. Möglichkeit zum Experimentieren\n\nDie Entscheidung, mit Experimenten fortzufahren, ist bei einer Microservices-Architektur wesentlich einfacher.\n\nNeue Funktionen können leicht eingeführt werden, da jeder Dienst unabhängig von den anderen arbeitet. Falls eine neue Funktion den Kunden nicht zusagt oder die geschäftlichen Vorteile nicht klar sind, kann sie problemlos zurückgenommen werden, ohne den restlichen Betrieb zu beeinträchtigen.\n\nWird eine neue Funktion von Kunden gewünscht, ermöglicht eine Microservices-Architektur die Einführung innerhalb von Wochen statt Monaten oder Jahren.\n\n### 8. Verbesserte Datensicherheit\n\nWenn die Komponenten der Computersystemarchitektur in kleinere Teile zerlegt werden, sind sensible Daten besser vor Eindringlingen aus anderen Bereichen geschützt. Obwohl es Verbindungen zwischen allen Mikrodiensten gibt, können Entwickler(innen) sichere APIs verwenden, um die Dienste zu verknüpfen. Sichere APIs gewährleisten, dass Daten nur für speziell autorisierte Benutzer, Anwendungen und Server zugänglich sind. Für Unternehmen, die mit sensiblen Daten wie Gesundheits- oder Finanzinformationen umgehen, wird die Einhaltung von Datensicherheitsstandards wie [HIPAA](https://www.hhs.gov/hipaa/index.html) im Gesundheitswesen oder der [europäischen DSGVO](https://dsgvo-gesetz.de/) durch diese Architektur vereinfacht.\n### 9. Flexibilität durch Outsourcing\n\nEs kann für ein Unternehmen notwendig sein, bestimmte Funktionen an Dritte auszulagern. Bei einer monolithischen Architektur sind viele Unternehmen besorgt über den Schutz ihres geistigen Eigentums. Eine Microservices-Architektur ermöglicht es jedoch, spezifische Bereiche nur für Partner zu segmentieren, ohne dass Kerndienste offengelegt werden.\n\n### 10. Optimierung der Teamarbeit\nWenn du dir überlegst, wie groß die Teams sein sollen, die du für jeden Microservice einsetzt, solltest du die sogenannte Zwei-Pizza-Regel beachten. Sie wurde erstmals von Amazon, dem Pionier der Microservices, formuliert und besagt, dass Entwicklungsteams so klein sein sollten, dass sie mit zwei Pizzen satt werden. Experten erklären, dass diese Richtlinie die Arbeitseffizienz verbessert, es den Unternehmen ermöglicht, ihre Ziele schneller zu erreichen, die Verwaltung der Teams erleichtert, einen stärkeren Fokus innerhalb der Gruppe schafft und zu qualitativ hochwertigeren Produkten führt.\n\n### 11. Bei Entwickler(innen) beliebt\n\nZuletzt ist einer der Microservices-Benefits auch, dass Entwickler(innen)(innen) die Microservices-Architektur attraktiv finden und Unternehmen bessere Chancen haben, hochkarätige Talente für die Entwicklung von Microservices-Anwendungen zu gewinnen. Microservices nutzen die neuesten technischen Verfahren und Entwickler(innen)werkzeuge. Dies ist ein wesentlicher Vorteil für Unternehmen, die Spezialist(innen) anziehen möchten.\n\n## Microservices: Nachteile\n\nTrotz der zahlreichen Vorteile für jedes Unternehmen gibt es auch einige Nachteile von Microservices, die vor der Einführung berücksichtigt werden sollten.\n\n### 1. Vorabkosten sind bei Microservices höher\n\nCloud-Microservices bieten langfristig Kosteneinsparungen, bringen jedoch auch Nachteile mit sich, wie etwa die hohen Anfangskosten für die Bereitstellung. Ein Unternehmen muss über eine ausreichende Hosting-Infrastruktur mit Sicherheits- und Wartungsunterstützung verfügen. Zudem ist es entscheidend, qualifizierte Teams zu haben, die alle Dienste verwalten können.\n### 2. Schnittstellenkontrolle ist entscheidend\n\nDa jeder Microservice eine eigene API besitzt, sind alle Anwendungen, die diesen Service nutzen, von Änderungen der API betroffen, wenn diese nicht abwärtskompatibel sind. Große Unternehmen, die eine Microservices-Architektur verwenden, haben oft Hunderte oder sogar Tausende von APIs. Die Kontrolle und Verwaltung dieser Schnittstellen ist entscheidend für den Betrieb des Unternehmens und kann somit einen Nachteil der Microservices-Architektur darstellen.\n\n### 3. Komplexität der anderen Art\n\nDie Fehlersuche kann bei einer Microservices-Architektur eine größere Herausforderung darstellen. Jeder Microservice hat seinen eigenen Satz von Protokollen. Das bereitet ein wenig Kopfzerbrechen, wenn es darum geht, die Quelle eines Problems im Code zu finden.\n\n### 4. Integrationsprüfung\n\nUnit-Tests sind bei einer Microservices-Architektur einfacher durchzuführen. Integrationstests hingegen nicht. Da die Architektur jeden Microservice verteilt, können die Entwickler(innen) das gesamte System nicht direkt von ihren Rechnern aus testen.\n\n## Unterschiede zwischen Serviceorientierte Architektur vs. Microservices\n\nWenn du im Bereich Cloud Computing arbeitest, kennst du wahrscheinlich die Debatte zwischen serviceorientierter Architektur (SOA) und Microservices. Beide Architekturen ähneln sich, da sie Cloud Computing für agile Entwicklung nutzen und große monolithische Komponenten in kleinere, handlichere Einheiten zerlegen.\n\nDer Hauptunterschied liegt im Umfang: SOA ist ein unternehmensweiter Ansatz für die Entwicklung von Softwarekomponenten, während Microservices eigenständige Anwendungen erstellen, die eine bestimmte Funktion erfüllen. Dieser Cloud-native Ansatz macht Microservices skalierbarer, flexibler und widerstandsfähiger.\n\nErfahre im Folgenden, wie du mit einer [Microservices-Architektur](https://about.gitlab.com/blog/get-started-with-microservices-architecture/) beginnen kannst.\n",[1588,1588,9],"DevOps",{"slug":1590,"featured":90,"template":682},"what-are-the-benefits-of-a-microservices-architecture","content:de-de:blog:what-are-the-benefits-of-a-microservices-architecture.yml","What Are The Benefits Of A Microservices Architecture","de-de/blog/what-are-the-benefits-of-a-microservices-architecture.yml","de-de/blog/what-are-the-benefits-of-a-microservices-architecture",{"_path":1596,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1597,"content":1601,"config":1610,"_id":1612,"_type":13,"title":1613,"_source":15,"_file":1614,"_stem":1615,"_extension":18},"/de-de/blog/why-enterprise-independence-matters-more-than-ever-in-devsecops",{"config":1598,"title":1599,"description":1600},{"noIndex":6},"Warum Unabhängigkeit in DevSecOps wichtiger ist denn je","Führungskräfte hinterfragen die Kontrolle ihrer Entwicklungsinfrastruktur. GitLabs Unabhängigkeit ist relevanter denn je.\n",{"title":1599,"description":1602,"authors":1603,"date":1605,"body":1606,"category":703,"tags":1607,"heroImage":1609},"Unternehmen hinterfragen, wer ihre Entwicklungsinfrastruktur wirklich kontrolliert. Deshalb gilt: GitLabs Unabhängigkeit ist relevanter denn je.\n",[1604],"Robin Schulman","2025-09-02","Seit über einem Jahrzehnt setzt sich GitLab für Transparenz, Unabhängigkeit und die Priorisierung von Entwickler(inne)n ein. Heute ist das wichtiger denn je, während sich die Branche weiterentwickelt. Unternehmensführungen stellen kritische Fragen: Wer kontrolliert letztendlich die Entwicklungsinfrastruktur? Wie wird der Code in KI-Systemen verwendet? Was passiert, wenn sich Anbieter-Prioritäten von kritischen Anforderungen wegbewegen?\n\nLetzten Monat [kündigten wir GitLab 18.3 an](https://about.gitlab.com/de-de/blog/gitlab-13-expanding-ai-orchestration-in-software-engineering/), die neueste Version unserer KI-nativen DevSecOps-Plattform. Agent Insights, Teil der GitLab Duo Agent Platform, bietet Einblicke in die Entscheidungsprozesse der Agenten. Erweiterte KI-Modellunterstützung bedeutet keine Anbieterabhängigkeit. Verbesserte Governance-Kontrollen ermöglichen Compliance über mehrere Rechtsräume hinweg.\n\nDas sind nicht nur Funktionen. Es sind Beispiele für Transparenz, Unabhängigkeit und den entwicklerorientierten Ansatz, der GitLab definiert. So setzt sich diese Strategie in der Praxis um.\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1115249475?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"Who is GitLab_Robin_090225_FINAL\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n## KI-Transparenz über den gesamten DevSecOps-Lebenszyklus\n\n**Bei GitLab adressiert unser jahrzehntelanges Engagement für Transparenz diese Bedenken direkt.** Da künstliche Intelligenz zunehmend in Entwicklungs-Workflows integriert wird, sind Organisationen zu Recht besorgt darüber, wie Code und Daten für KI-Training verwendet werden.\n\nDas GitLab [KI-Transparenzzentrum](https://about.gitlab.com/de-de/ai-transparency-center/), im April 2024 gestartet, bietet eine klare Dokumentation unserer Datenverarbeitungspraktiken, Datenschutzmaßnahmen und ethischen KI-Prinzipien. Im Gegensatz zu Plattformen, die KI-Funktionen mit unklaren Datennutzungsrichtlinien betreiben, priorisiert GitLab Transparenz, damit Kund(inn)en [genau verstehen, wie Daten verarbeitet werden](https://docs.gitlab.com/user/gitlab_duo/data_usage/), gespeichert und geschützt werden – ohne Training mit diesen Daten.\n\nUnser Ansatz erstreckt sich auf Modellflexibilität und Anbieterunabhängigkeit. Während einige Plattformen Kund(inn)en an einzelne Large Language Model (LLM)-Anbieter binden und damit zusätzliche Anbieterabhängigkeiten und potenzielle Single Points of Failure schaffen, werden GitLabs KI-Funktionen von verschiedenen Modellen unterstützt. Dieser Ansatz ermöglicht es uns, eine breite Palette von Anwendungsfällen zu unterstützen und bietet Kund(inn)en die Flexibilität, sich an strategischen Prioritäten auszurichten.\n\nBei der Weiterentwicklung der GitLab Duo Agent Platform bleiben wir auf Datenkontrolle fokussiert und behalten umfassende Human-in-the-Loop-Kontrollen bei. Und GitLab Duo Self-Hosted bietet vollständige Datensouveränität mit luftdichten Bereitstellungsoptionen, Zero-Day-Datenaufbewahrungsrichtlinien und der Möglichkeit, alle KI-Anfragen innerhalb der eigenen Infrastruktur zu verarbeiten.\n\nSeit Mai 2024 pflegen wir auch einen [KI-Kontinuitätsplan](https://handbook.gitlab.com/de-de/handbook/product/ai/continuity-plan/) mit einem branchenführenden Versprechen: die Fähigkeit, innerhalb von 30 Tagen ein neues Modell zu evaluieren und zu wechseln, falls ein Anbieter seine Praktiken bezüglich Kundendaten ändert. Dieser proaktive Ansatz zum KI-Anbieter-Risikomanagement spiegelt unser Engagement für Kundenkontrolle wider.\n\n## Wahlfreiheit bei Bereitstellung und Cloud-Anbieter\n\n**Organisationen sollten wählen können, wie und wo die DevSecOps-Umgebung bereitgestellt wird.** GitLab bietet echte Bereitstellungsflexibilität. Organisationen können zwischen On-Premises-Installationen, Multi-Tenant-SaaS oder GitLab Dedicated wählen, unserer vollständig verwalteten Single-Tenant-SaaS-Lösung, ohne auf Funktionalität zu verzichten oder künstlichen Einschränkungen ausgesetzt zu sein, die auf Ökosystem-Lock-in abzielen. GitLab ist auch Cloud-neutral, sodass Kund(inn)en den Cloud-Anbieter nutzen können, der am besten zu Geschäftsanforderungen und Umgebung passt.\n\nDiese Flexibilität erweist sich als unschätzbar wertvoll bei der Navigation durch komplexe rechtliche Anforderungen und regulatorische Herausforderungen. Wenn neue Datenlokalisierungsgesetze entstehen – wie wir es in der Europäischen Union und anderen Regionen gesehen haben – können Organisationen, die GitLab nutzen, ihre Bereitstellungsstrategien schnell anpassen, ohne durch Ökosystemabhängigkeiten eingeschränkt zu sein.\n\nAus Beschaffungs- und Risikomanagement-Perspektive bietet Plattformunabhängigkeit auch entscheidende Verhandlungsmacht bei Vertragsverhandlungen. Organisationen werden nicht in restriktive Lizenzvereinbarungen gezwungen, die Anbieterinteressen über Kundenbedürfnisse stellen. Diese Unabhängigkeit wird besonders kritisch, da Unternehmen wachsamer werden, wer ihren KI-Stack kontrolliert.\n\n## Sicherheit und Compliance: Eingebaut und immer Priorität\n\n**Sicherheit und Compliance sind jetzt genauso wichtig wie Entwicklungsfunktionen und sollten in die Plattform eingebaut sein, nicht nachträglich hinzugefügt.** GitLabs Single-Platform-Ansatz bietet erhebliche Vorteile gegenüber fragmentierten Plattformen, die auf Drittanbieter-Add-Ins angewiesen sind, um grundlegende Sicherheits- und Governance-Funktionen zu erreichen. Dieser architektonische Unterschied hat erhebliche Auswirkungen auf mögliche rechtliche Risiken, operative Effizienz und regulatorische Compliance. Jedes zusätzliche Tool in der Kette stellt einen weiteren potenziellen Fehlerquellen dar, weitere Geschäftsbedingungen, die verhandelt werden müssen, und eine weitere Risikoquelle.\n\nGitLab bietet umfassende eingebaute Sicherheits- und Compliance-Funktionen, einschließlich kundenspezifischer Compliance-Frameworks, dynamischem Application Security Testing (DAST), API-Fuzz-Testing, Coverage-Guided Fuzzing und Infrastructure-as-Code-Testing. Diese Funktionen sind nativ in die Plattform integriert und bieten konsistente Richtliniendurchsetzung und reduzieren die Compliance-Komplexität und zusätzlichen Kosten, die mit der Verwaltung mehrerer Drittanbieter-Tools verbunden sind.\n\nUnser [Compliance-Center](https://docs.gitlab.com/user/compliance/compliance_center/) bietet einen zentralen Ort für Teams, um ihre Compliance-Standards, Compliance-Berichte, Verstöße und Compliance-Frameworks für ihre Gruppe zu verwalten. Dieser einheitliche Ansatz für das Compliance-Management ist besonders wertvoll für Organisationen in stark regulierten Branchen, in denen Audit-Trails und Compliance-Dokumentation kritisch sind.\n\n## Nähe zur Open-Source-Community\n\n**Die besten Tools werden von den Menschen geprägt, die sie nutzen.** Unser Engagement für Open Source und die Zusammenarbeit mit unserer Community ist seit unserer Gründung Kern von GitLab. Beispielsweise ist unser [Co-Create-Programm](https://about.gitlab.com/community/co-create/) eine kollaborative Initiative, die es Kund(inn)en ermöglicht, direkt mit GitLab-Ingenieur(inn)en zusammenzuarbeiten, um Funktionen, Fixes und Verbesserungen zur GitLab-Plattform beizutragen.\n\nUnser Transparenzwert bleibt grundlegend für unser Geschäft. Ein Beispiel dafür ist unser [offener Issue-Tracker](https://gitlab.com/groups/gitlab-org/-/issues), in dem Kund(inn)en unseren Fortschritt verfolgen und direkt mit dem GitLab-Team in Diskussionen über Verbesserungsmöglichkeiten unseres Produkts eintreten können. Wir haben kürzlich unsere [Healthy Backlog Initiative](https://about.gitlab.com/de-de/blog/inside-gitlabs-healthy-backlog-initiative/) gestartet, um Kund(inn)en noch größere Einblicke in unsere Planung zu geben und ihr Feedback an Stellen mit der größten Wirkung zu lenken.\n\nUnser Ansatz ermöglicht es Organisationen, zu Open-Source-Innovation beizutragen und davon zu profitieren, während sie die Governance, Audit-Trails und Sicherheitskontrollen beibehalten, die für regulierte Umgebungen erforderlich sind.\n\n## Daten-Governance: Die Daten, die Kontrolle\n\n**Vollständige Kontrolle über Daten und deren Verarbeitung bleibt erhalten.** Daten-Governance ist zu einem immer kritischeren Faktor bei Unternehmensentscheidungen geworden, angetrieben durch ein komplexes Netz nationaler und regionaler Datenschutzgesetze und wachsende Bedenken über die Kontrolle sensibler geistiger Eigentumsrechte – wie Quellcode, Kundeneinblicke, strategische Initiativen und Wettbewerbsinformationen.\n\nMit GitLab kann verwaltet werden, wer Zugang zu KI-gestützten Funktionen innerhalb der Plattform hat, was über einfache Zugriffskontrollen hinausgeht und Verschlüsselungsstandards und Audit-Funktionen umfasst, die auf regulatorische Frameworks ausgerichtet sind. Außerdem werden Code und Daten von Kund(inn)en niemals zum Training von KI-Modellen verwendet.\n\n## Die Wahl ist klar\n\nGitLab führt weiterhin bei KI-nativer DevSecOps-Plattform-Innovation – unsere jüngste [18.3-Version](https://about.gitlab.com/de-de/blog/gitlab-13-expanding-ai-orchestration-in-software-engineering/) zeigt dies – während wir den Unabhängigkeits- und Transparenzverpflichtungen treu bleiben, die uns immer geleitet haben.\n\nKund(inn)en haben eine Wahl und sie ist klar: Kontrolle behalten vs. Anbieterabhängigkeit; Transparenz vs. Unsicherheit; Engagement für Innovation vs. Launen des größeren Ökosystems.\n\nGitLab bietet die Grundlage für nachhaltige digitale Transformation, die Innovation mit Unabhängigkeit ausbalanciert und dabei hilft, Geschäftswert für Kund(inn)en zu erzielen.\n\n[GitLab Ultimate mit GitLab Duo heute kostenlos testen.](https://about.gitlab.com/de-de/free-trial/)",[678,907,677,9,1608],"open source","https://res.cloudinary.com/about-gitlab-com/image/upload/v1756500636/wmey6kqzzuhirk88w2de.png",{"featured":90,"template":682,"slug":1611},"why-enterprise-independence-matters-more-than-ever-in-devsecops","content:de-de:blog:why-enterprise-independence-matters-more-than-ever-in-devsecops.yml","Why Enterprise Independence Matters More Than Ever In Devsecops","de-de/blog/why-enterprise-independence-matters-more-than-ever-in-devsecops.yml","de-de/blog/why-enterprise-independence-matters-more-than-ever-in-devsecops",{"_path":1617,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":1618,"content":1624,"config":1629,"_id":1631,"_type":13,"title":1632,"_source":15,"_file":1633,"_stem":1634,"_extension":18},"/de-de/blog/10-best-practices-for-using-ai-powered-gitlab-duo-chat",{"title":1619,"description":1620,"ogTitle":1619,"ogDescription":1620,"noIndex":6,"ogImage":1621,"ogUrl":1622,"ogSiteName":695,"ogType":696,"canonicalUrls":1622,"schema":1623},"10 Best Practices für den Einsatz des KI-basierten GitLab Duo Chat","Tipps zur Integration von GitLab Duo Chat in deine KI-basierten DevSecOps-Workflows. Dazu gibt's Ratschläge für präzisere Chat-Prompts.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097639/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%281%29_77JeTV9gAmbXM0224acirV_1750097638765.png","https://about.gitlab.com/blog/10-best-practices-for-using-ai-powered-gitlab-duo-chat","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"10 Best Practices für den Einsatz des KI-basierten GitLab Duo Chat\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Michael Friedrich\"}],\n        \"datePublished\": \"2024-04-02\",\n      }\n                  ",{"title":1619,"description":1620,"authors":1625,"heroImage":1621,"date":1626,"body":1627,"category":703,"tags":1628,"updatedDate":1304},[903],"2024-04-02","Mit einer KI ins Gespräch zu kommen, kann eine Herausforderung sein. Mit welcher Frage fängt man am besten an? Wie formuliert man seine Frage am besten? Wie viel Kontext ist erforderlich? Wird das Gespräch die besten und effizientesten Ergebnisse liefern?\n\nIn diesem Tutorial stellen wir 10 Tipps und Best Practices zur Integration von GitLab Duo Chat in deine KI-basierten DevSecOps-Workflows vor und präzisieren deine Prompts, damit du die besten Ergebnisse erzielen kannst.\n\n[GitLab Duo Chat öffnen und im Vordergrund behalten](#gitlab-duo-chat-öffnen-und-im-vordergrund- behalten)\n\n[10 Best Practices zur Verwendung von GitLab Duo Chat](#10-best-practices-zur-verwendung-von-gitlab-duo-chat)\n\n1. [Führe ein Gespräch](#1.-führe-ein-gespräch)\n2. [Präzisiere den Prompt für mehr Effizienz](#2.-präzisiere-den-prompt-für-mehr-effizienz)\n3. [Beachte Prompt-Muster](#3.-beachte-prompt-muster)\n4. [Setze auf eine kontextarme Kommunikation](#4.-setze-auf-eine-kontextarme-kommunikation)\n5. [Wiederhole dich](#5.-wiederhole-dich)\n6. [Sei geduldig](#6.-sei-geduldig)\n7. [Verwerfe alles und fang von vorn an](#7.-verwerfe-alles-und-fang-von-vorn-an)\n8. [Steigere in der IDE mit Slash-Befehlen deine Effizienz](#8.-steigere-in-der-ide-mit-slash-befehlen-deine-effizienz)\n9. [Präzisiere den Prompt für Slash-Befehle](#9.-präzisiere-den-prompt-für-slash-befehle)\n10. [Werde bei den Slash-Befehlen kreativ](#10.-werde-bei-den-slash-befehlen-kreativ)\n\nBonusinhalte:\n- [Shortcuts](#shortcuts)\n- [Unterhaltsame Übungen](#unterhaltsame-übungen)\n- [Weitere Informationen](#weitere-informationen)\n\n## GitLab Duo Chat öffnen und im Vordergrund behalten\n\n[GitLab Duo Chat](https://docs.gitlab.com/ee/user/gitlab_duo_chat.html) ist in der GitLab-UI, Web IDE und unterstützten Programmier-IDEs, z. B. VS Code, verfügbar. \n\nIn VS Code kannst du GitLab Duo Chat über die Side Bar auf der linken Seite öffnen. Du kannst das Symbol auch per Drag & Drop in den rechten Bereich ziehen. So kann der Chat geöffnet bleiben, während du deinen Code schreibst und durch den Dateibaum navigierst, Git-Aktionen durchführst usw. Um den Anzeigeort des Chats zurückzusetzen, öffnest du einfach die Befehlspalette (durch Drücken der Tastenkombination `Command+Umschalt+P` (bei macOS) oder `Strg+Umschalt+P` (bei Windows/Linux) und gibst dann `View: Reset View Locations` (Ansicht: Anzeigeorte zurücksetzen) ein. Im folgenden kurzen Video erfährst du, wie es geht.\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/foZpUvWPRJQ\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\nDie Web IDE und VS Code teilen sich das gleiche Framework – mit derselben Methode lassen sich in der Web IDE effizientere Workflows umsetzen.\n\n![Chat in der Web IDE](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097645344.png)\n\n## 10 Best Practices für die Verwendung von GitLab Duo Chat\n\n### 1. Führe ein Gespräch\n\nChats sind Gespräche, keine Suchformulare.\n\nUm das Eis zu brechen, kannst du mit Suchbegriffen beginnen, die denen einer Suchmaschine ähneln, und dann mit der Antwort und Ausgabe experimentieren. Beginnen wir in diesem Beispiel mit einem C#-Projekt und unseren Best Practices. \n\n> c# start project best practices (Best Practices für den Beginn eines C#-Projekts)\n\n![Chat-Prompt „c# start project best practices“ und die Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097646/Blog/Content%20Images/Blog/Content%20Images/image11_aHR0cHM6_1750097645345.png)\n\nDie Antwort ist hilfreich, um C# besser zu verstehen, gibt aber nicht sofort den Anstoß für Best Practices. Deshalb sollten wir im gleichen Zusammenhang eine gezieltere Frage stellen. \n\n> Please show the project structure for the C# project. (Bitte zeige die Projektstruktur für das C#-Projekt an.)\n\n![Chat-Prompt „Please show the project structure for the C# project.“ und die Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image9_aHR0cHM6_1750097645346.png)\n\nDiese Antwort ist hilfreich. Wir fahren mit einer Git-Frage fort und verwenden dabei dieselbe Fragenstruktur: eine direkte Anfrage für eine Anzeige.\n\n> Show an example for a .gitignore for C#. (Zeige ein Beispiel für .gitignore für C# an.)\n\n![Chat-Prompt für „Show an example for a .gitignore for C#.“ und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image25_aHR0cHM6_1750097645347.png)\n\nBleib bei CI/CD und frage, wie man das C#-Projekt erstellen kann.\n\n> Show a GitLab CI/CD configuration for building the C# project. (Zeige eine GitLab-CI/CD-Konfiguration zum Erstellen des C#-Projekts an.)\n\n![Chat-Prompt für „Show a GitLab CI/CD configuration for building the C# project.“ und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image16_aHR0cHM6_1750097645349.png)\n\nIn diesem Beispiel hat uns Chat dazu ermutigt, bestimmte Änderungen anzufordern. Wir wollen das .NET SDK 8.0 anstelle von 6.0 verwenden.\n\n> In the above example, please use the .NET SDK 8.0 image. (Verwende im obigen Beispiel bitte das .NET SDK 8.0 Image.)\n\n![Chat-Prompt für „In the above example, please use the .NET SDK 8.0 image“ und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image32_aHR0cHM6_1750097645350.png)\n\nDie CI/CD-Konfiguration verwendet die .NET-CLI. Vielleicht können wir das auch für effizientere Befehle verwenden, um die Projekt- und Teststruktur zu erstellen? \n\n> Explain how to create projects and test structure on the CLI. (Erkläre, wie Projekte und Teststrukturen in der CLI erstellt werden.)\n\n![Chat-Prompt für „Explain how to create projects and test structure on the CLI.“ und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image14_aHR0cHM6_1750097645351.png)\n\nNatürlich könnten wir diese Befehle im Terminal ausführen, aber geht das auch in VS Code? Fragen wir doch Chat.\n\n> Explain how to open a new terminal in VS Code. (Erkläre, wie man ein neues Terminal in VS Code öffnet.)\n\n![Chat-Prompt für „Explain how to open a new terminal in VS Code.“ und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image5_aHR0cHM6_1750097645351.png)\n\n### 2. Präzisiere den Prompt für mehr Effizienz\n\nStell dir vor, GitLab Duo Chat wäre ein Mensch, und arbeite mit ihm in Form von vollständigen Sätzen, die so viel Kontext zu deinen Gedanken und Fragen wie möglich enthalten. \n\nErfahrene Benutzer(innen) von Suchmaschinen kennen diesen Ansatz vielleicht von der Abfrage von Inhalten: Erstelle die Frage, ergänze sie um weitere Begriffe, um den inhaltlichen Umfang zu präzisieren, und starte eine neue Suche, nachdem du bereits viele Registerkarten geöffnet hast. \n\nBei der Verwendung einer Suchmaschine hättest du wahrscheinlich schnell vier bis fünf verschiedene Suchfenster geöffnet. \n\n```markdown\nc# start project best practices\nc# .gitignore\nc# gitlab cicd \nc# gitlab security scanning \nc# solutions and projects, application and tests\n``` \n\nDu kannst diese Strategie auch in einem Chat anwenden. Du musst jedoch mehr Kontext hinzufügen, damit es zu einem Gespräch wird. Mit GitLab Duo Chat kannst du mehrere Fragen in ein und derselben Gesprächsanfrage stellen. Beispiel: Du willst mit einem neuen C#-Projekt beginnen, Best Practices anwenden, eine `.gitignore`-Datei hinzufügen und CI/CD und Sicherheitsscans konfigurieren, genau wie in der Suche oben. In Chat kannst du die Fragen zu einer Anfrage kombinieren.\n\n> How can I get started creating an empty C# console application in VS Code? Please show a .gitignore and .gitlab-ci.yml configuration with steps for C#, and add security scanning for GitLab. Explain how solutions and projects in C# work, and how to add a test project on the CLI. (Wie kann ich mit der Entwicklung einer leeren C#-Konsolenanwendung in VS Code beginnen? Bitte zeige eine .gitignore- und .gitlab-ci.yml-Konfiguration mit Schritten für C# an und füge Sicherheitsscans für GitLab hinzu. Erkläre, wie Lösungen und Projekte in C# funktionieren und wie man ein Testprojekt in der CLI hinzufügt.)\n\n![Chat-Prompt für mehr Kontext und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image37_aHR0cHM6_1750097645352.png)\n\nIn dieser Antwort schlägt der Chat vor, bei Folgefragen im Gespräch nach konkreten Konfigurationsbeispielen zu fragen. Asynchrones Üben: Erstelle Folgefragen. Du kannst `C#` als Kontext in derselben Chat-Sitzung weglassen.\n\n> Please show an example for a .gitignore. Please show a CI/CD configuration. Include the SAST template. (Bitte zeige ein Beispiel für .gitignore. Bitte zeige eine CI/CD-Konfiguration. Füge die SAST-Vorlage hinzu.)\n\n### 3. Beachte Prompt-Muster \n\nFolge dem Muster: `Problembeschreibung, bitte um Hilfe, erstelle zusätzliche Anfragen`. Es fällt einem bei der ersten Frage vielleicht nicht gleich alles ein – beginne mit `Problembeschreibung, bitte um Hilfe`, wenn du zu Beginn noch ratlos bist. \n\n> I need to fulfill compliance requirements. How can I get started with Codeowners and approval rules? (Ich muss die Compliance-Anforderungen erfüllen. Wie kann ich mit Codeowners und Approvalregeln beginnen?)\n\n![Chat-Prompt für den Einstieg in Codeowners und Approvalregeln und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image19_aHR0cHM6_1750097645352.png)\n\nDie Antwort ist hilfreich, aber offensichtlich generisch. Vielleicht möchtest du an dieser Stelle spezifische Hilfe für dein Team-Setup erhalten. \n\n> Please show an example for Codeowners with different teams: backend, frontend, release managers. (Bitte zeige ein Beispiel für Codeowners mit verschiedenen Teams: Backend, Frontend, Release Manager.)\n\n![Chat-Prompt zur Anzeige eines Beispiels für Codeowners mit verschiedenen Teams: Backend, Frontend, Release Manager und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image31_aHR0cHM6_1750097645353.png)\n\nAlternativ kannst du deine aktuelle Situation beschreiben und um Unterstützung bitten. Wenn man dem STAR-Modell (Situation, Aufgabe, Aktion, Ergebnisse) folgt, kann es sich ein wenig wie ein Gespräch anfühlen. \n\n> I have a Kubernetes cluster integrated in GitLab. Please generate a Yaml configuration for a Kubernetes service deployment. Explain how GitOps works as a second step. How to verify the results? (Ich habe ein Kubernetes-Cluster in GitLab integriert. Bitte generiere eine Yaml-Konfiguration für eine Kubernetes-Dienstbereitstellung. Erkläre als zweiten Schritt, wie GitOps funktioniert. Wie verifiziere ich die Ergebnisse?\n\n![Chat-Prompt mit mehreren Fragen und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image27_aHR0cHM6_1750097645354.png)\n\n### 4. Setze auf eine kontextarme Kommunikation \n\nGib so viel Kontext an, wie für eine Antwort erforderlich ist. In manchen Fällen bietet der bisherige Verlauf oder der geöffnete Quellcode nicht diesen hilfreichen Kontext. Um Fragen effizienter zu gestalten, kannst du ein Muster von [kontextarmer Kommunikation](https://handbook.gitlab.com/handbook/company/culture/all-remote/effective-communication/#understanding-low-context-communication) (nur in englischer Sprache verfügbar) anwenden, das in der All-Remote-Kommunikation im Rahmen von GitLab verwendet wird.\n\nDie folgende Frage hat nicht genügend Kontext in einem C++-Projekt bereitgestellt.\n\n> Should I use virtual override instead of just override? (Sollte ich eine virtuelle Überschreibung anstelle einer einfachen Überschreibung verwenden?)\n\n![Chat-Prompt zur Frage nach der Verwendung einer virtuellen Überschreibung anstelle einer einfachen Überschreibung und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image34_aHR0cHM6_1750097645354.png)\n\nVersuche stattdessen, mehr Kontext hinzuzufügen:\n\n> When implementing a pure virtual function in an inherited class, should I use virtual function override, or just function override? Context is C++. (Sollte ich bei der Implementierung einer reinen virtuellen Funktion in einer geerbten Klasse eine virtuelle Funktionsüberschreibung oder nur eine einfache Funktionsüberschreibung nutzen? Der Kontext ist C++.) \n\n![Chat-Prompt mit mehr Details und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image36_aHR0cHM6_1750097645355.png)\n\nDas Beispiel findest du auch im englischsprachigen Video [GitLab Duo Coffee Chat: Refactor C++ functions into OOP classes for abstract database handling (GitLab Duo Coffee Chat: C++-Funktionen in OOP-Klassen umwandeln für abstrakte Datenbankverwaltung)](https://youtu.be/Z9EJh0J9358?t=2190). \n\n### 5. Wiederhole dich\n\nDie KI ist nicht berechenbar. In manchen Fällen kann es sein, dass sie nicht mit den erwarteten Ergebnissen antwortet oder keine Quellcode-Beispiele oder Konfigurations-Schnipsel erzeugt, weil sie keinen Kontext hatte. Du solltest die Frage wiederholen und die Anforderungen verfeinern.\n\nIm folgenden Beispiel möchten wir eine C#-Anwendung erstellen. Beim ersten Versuch haben wir den Anwendungstyp nicht angegeben – C# kann verwendet werden, um Konsolen-/Terminal-, aber auch UI-Anwendungen zu erstellen. Wir bekommen außerdem keinen leeren Beispiel-Quellcode als Antwort. Der zweite, wiederholte Prompt fügt zwei weitere Wörter hinzu: `console` und `empty`. \n\n> How can I get started creating an C# application in VS Code? (Wie kann ich mit dem Erstellen einer C#-Anwendung in VS Code beginnen?)\n> \n> How can I get started creating an empty C# console application in VS Code? (Wie kann ich mit dem Erstellen einer leeren C#-Konsolenanwendung in VS Code beginnen?)\n\nDie Ergebnisse im Prompt unterscheiden sich. Die erste Antwort ist für den Anfang hilfreich, da man den Anweisungen im VS-Code-Fenster folgen kann, aber sie sagt uns nicht, wo sich der Quellcode befindet und wie man ihn ändert. Durch den zweiten, verfeinerten Prompt wird die Antwort modifiziert und bietet jetzt Anweisungen, wie man die Standardvorlage mit „Hallo Welt”-Code überschreibt.\n\n![Chat-Prompts mit wiederholtem Prompt mit Modifikationen und Antworten](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image28_aHR0cHM6_1750097645355.png)\n\nDu kannst auch Wiederholungs- und Verfeinerungsstrategien miteinander kombinieren und Chat auffordern, ein Beispiel für Anwendungscode und Tests anzuzeigen.\n\n> How can I get started creating an empty C# console application in VS Code? Please show an example for application and tests. (Wie kann ich mit dem Erstellen einer leeren C#-Konsolenanwendung in VS Code beginnen? Bitte zeige ein Beispiel für die Anwendung und Tests.)\n\n![Chat-Prompt, der ein Beispiel für die Anwendung und Tests anfordert und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097645356.png)\n\n#### Wiederhole dich nach allgemeinen Fragen \n\nGitLab Duo Chat kann bei allgemeinen technischen Fragen möglicherweise nicht weiterhelfen. Im folgenden Szenario wollte ich einen Vorschlag für Java-Build-Tools und ein Framework erhalten, was jedoch nicht funktioniert hat. Es gibt viele mögliche Antworten: Maven, Gradle usw. als Build-Tools und [über 100 Java-Frameworks](https://en.wikipedia.org/wiki/List_of_Java_frameworks) (nur in englischer Sprache verfügbar), die vom Technologie-Stack und den jeweiligen Anforderungen abhängen.\n\n![Chat-Prompt für die Frage nach Java-Build-Tools und einem Framework und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097645356.png)\n\nNehmen wir einmal an, wir wollen uns auf eine Kundenumgebung mit [Java Spring Boot](https://spring.io/projects/spring-boot) konzentrieren. \n\n> I want to create a Java Spring Boot application. Please explain the project structure and show a hello world example. (Ich möchte eine Java Spring Boot-Anwendung entwickeln. Bitte erkläre die Projektstruktur und zeige ein Hallo-Welt-Beispiel.)\n\n![Chat-Prompt, der mehr anfordert, einschließlich eines Hallo-Welt-Beispiels und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image26_aHR0cHM6_1750097645357.png)\n\nDies allein liefert bereits hervorragende Ergebnisse. Wiederhole den Prompt als asynchrone Übung und frage, wie man die Anwendung bereitstellt, wobei du bei jedem Schritt weitere Verfeinerungen ergänzt. Alternativ kannst du ein Folgegespräch daraus machen.\n\n> I want to create a Java Spring Boot application. Please explain the project structure and show a hello world example. Show how to build and deploy the application in CI/CD. (Ich möchte eine Java Spring Boot-Anwendung entwickeln. Bitte erkläre die Projektstruktur und zeige ein Hallo-Welt-Beispiel. Zeige, wie man die Anwendung in CI/CD erstellt und bereitstellt.)\n> \n> I want to create a Java Spring Boot application. Please explain the project structure and show a hello world example. Show how to build and deploy the application in CI/CD, using container images. (Ich möchte eine Java Spring Boot-Anwendung entwickeln. Bitte erkläre die Projektstruktur und zeige ein Hallo-Welt-Beispiel. Zeige, wie man die Anwendung in CI/CD mit Container-Images erstellet und bereitstellt.)\n> \n> I want to create a Java Spring Boot application. Please explain the project structure and show a hello world example. Show how to build and deploy the application in CI/CD, using container images. Use Kubernetes and GitOps in GitLab. (Ich möchte eine Java Spring Boot-Anwendung entwickeln. Bitte erkläre die Projektstruktur und zeige ein Hallo-Welt-Beispiel. Zeige, wie man die Anwendung in CI/CD mit Container-Images erstellet und bereitstellt. Verwende Kubernetes und GitOps in GitLab.)\n\n### 6. Sei geduldig\n\nEinzelne Wörter oder kurze Sätze führen möglicherweise nicht zu den gewünschten Ergebnissen, [wie in diesem englischsprachigen Videobeispiel gezeigt wird](https://youtu.be/JketELxLNEw?t=1220). Manchmal kann GitLab Duo Chat anhand der verfügbaren Daten eine Einschätzung treffen, besteht aber bisweilen auch darauf, dass mehr Kontext bereitgestellt wird.\n\nBeispiel: `labels` entspricht dem Inhalt der GitLab-Dokumentation.\n\n![Chat-Prompt zu Labels und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image12_aHR0cHM6_1750097645357.png)\n\nPräzisiere die Frage im Hinblick auf die Problembeschreibungen und weitere Spezifizierungen für die Verwendung in der Ticketübersicht.\n\n> Explain labels in GitLab. Provide an example for efficient usage with issue boards. (Erkläre Labels in GitLab. Gib ein Beispiel für die effiziente Verwendung in Ticketübersichten.)\n\n![Chat-Prompt mit der Frage nach einem Beispiel und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image21_aHR0cHM6_1750097645358.png)\n\nOder verwende eine Problembeschreibung, gefolgt von einer Frage, und bitte um weitere Beispiele.\n\n> I don't know how to use labels in GitLab. Please provide examples, and how to use them for filters in different views. Explain these views with examples. (Ich weiß nicht, wie man Labels in GitLab verwendet. Bitte gib Beispiele an und wie man sie für Filter in verschiedenen Ansichten verwendet. Erkläre diese Ansichten mit Beispielen.)\n\n![Chat-Prompt mit Problembeschreibung und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image10_aHR0cHM6_1750097645358.png)\n\nVermeide ferner `Ja/Nein`-Fragen und ergänze stattdessen einen spezifischen Kontext.\n\n> Can you help me fix performance regressions? (Kannst du mir helfen, Leistungseinbrüche zu beheben?)\n\n![Chat-Prompt mit der Bitte um Hilfe bei der Behebung von Leistungseinbrüchen und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image18_aHR0cHM6_1750097645359.png)\n\nGib stattdessen den Kontext des Leistungseinbruchs an, einschließlich der Programmiersprachen, Frameworks, des Technologie-Stacks und der Umgebungen. Im folgenden Beispiel wird eine etwas ältere Umgebung verwendet, die auch heute noch korrekt sein kann.\n\n> My PHP application encounters performance regressions using PHP 5.6 and MySQL 5.5. Please explain potential root causes, and how to address them. The app is deployed on Linux VMs. (Meine PHP-Anwendung stößt mit PHP 5.6 und MySQL 5.5 auf Leistungseinbrüche. Bitte erkläre mögliche Grundursachen und wie ich sie beheben kann. Die App wird auf Linux-VMs bereitgestellt.)\n\n![Chat-Prompt mit mehr Details und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image24_aHR0cHM6_1750097645360.png)\n\n### 7. Verwerfe alles und fang von vorn an\n\nManchmal zeigt der Chat-Verlauf eine andere Lernkurve und liefert den falschen Kontext für Folgefragen. Oder du hast spezifische Fragen gestellt, bei denen GitLab Duo Chat keine Antworten geben kann. Da generative KI nicht vorhersehbar ist, kann es auch sein, dass sie nicht in der Lage ist, bestimmte Beispiele zu geben, aber glaubt in einer zukünftigen Antwort, dass sie diese doch genannt hat (beobachtet in der Beta von Chat). Die zugrunde liegenden großen Sprachmodelle oder LLMs bestehen manchmal darauf, eine bestimmte Antwort in einer Endlosschleife auszugeben.\n\n> How can I get started creating an empty C# console application in VS Code? Please show a .gitignore and .gitlab-ci.yml configuration with steps for C#, and add security scanning for GitLab. Explain how solutions and projects in C# work, and how to add a test project on the CLI. (Wie kann ich mit dem Erstellen einer leeren C#-Konsolenanwendung in VS Code beginnen? Bitte zeige eine .gitignore- und .gitlab-ci.yml-Konfiguration mit Schritten für C# an und füge Sicherheitsscans für GitLab hinzu. Erkläre, wie Lösungen und Projekte in C# funktionieren und wie man ein Testprojekt über die CLI hinzufügt.)\n\nNachdem ich die obige Frage mit einer Beispielkonfiguration gestellt hatte, wollte ich den Umfang der Frage eingrenzen, um eine zielgerichtete Antwort zu erhalten. Dies hat nicht wie erwartet funktioniert, da Chat den Chat-Verlauf in diesem Kontext kennt und sich daher auf frühere Antworten bezieht.\n\n> How can I get started creating an empty C# console application in VS Code? Please show a .gitignore and .gitlab-ci.yml configuration with steps for C#. (Wie kann ich mit dem Erstellen einer leeren C#-Konsolenanwendung in VS Code beginnen? Bitte zeige eine .gitignore- und .gitlab-ci.yml-Konfiguration mit Schritten für C# an.)\n\n![Chat-Prompt mit der Frage nach Konfigurationsbeispielen und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image23_aHR0cHM6_1750097645360.png)\n\nUm Chat in einen neuen Kontext zu zwingen, verwendest du den Befehl `/reset` als Slash-Befehl, um die Sitzung zurückzusetzen, und wiederholst die Frage, um bessere Ergebnisse zu erzielen. Du kannst auch `/clean` oder `/clear` verwenden, um alle Nachrichten in diesem Gespräch zu löschen.\n\n### 8. Steigere in der IDE mit Slash-Befehlen deine Effizienz \n\n#### Code erklären\n\n- F: Generierter Code? Bestehender Code? Legacy-Code?\n- A: Verwende den [Slash-Befehl `/explain` in der IDE](https://docs.gitlab.com/ee/user/gitlab_duo_chat.html#explain-code-in-the-ide) (nur in englischer Sprache verfügbar).\n- A2: Präzisiere den Prompt mit gezielteren Antworten, zum Beispiel: `/explain focus on potential shortcomings or bugs` (/explain mit Fokus auf mögliche Fehler oder Bugs).\n\n![Chat-Prompt mit Slash-Befehl /explain](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/gitlab_duo_chat_slash_commands_explain_01_aHR0cHM6_1750097645361.png).\n\n![Chat-Prompt mit präzisiertem Prompt](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image6_aHR0cHM6_1750097645361.png)\n\n#### Code refaktorisieren \n\n- F: Unlesbarer Code? Langer Spaghetti-Code? Keinerlei Testabdeckung?\n- A: Verwende den Slash-Befehl [`/refactor` in der IDE](https://docs.gitlab.com/ee/user/gitlab_duo_chat.html#refactor-code-in-the-ide) (nur in englischer Sprache verfügbar).\n- A2: Präzisiere den Prompt für gezieltere Aktionen, zum Beispiel mit objektorientierten Mustern: `/refactor into object-oriented classes with methods and attributes` (/refactor in objektorientierte Klassen mit Methoden und Attributen).\n\n![Chat-Prompt mit Slash-Befehl /refactor](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image35_aHR0cHM6_1750097645362.png)\n\n![Chat-Prompt mit präzisiertem Prompt](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image30_aHR0cHM6_1750097645362.png)\n\n#### Tests generieren\n\n- F: Testbarer Code, aber das Schreiben von Tests dauert zu lange?\n- A: Verwende den Slash-Befehl [`/tests` in der IDE](https://docs.gitlab.com/ee/user/gitlab_duo_chat.html#write-tests-in-the-ide) (nur in englischer Sprache verfügbar).\n- A2: Präzisiere den Prompt für bestimmte Test-Frameworks oder Testziele. Du kannst mit dem Prompt auch anweisen, dass der Fokus auf der Refaktorierung liegen soll, und dann Tests zu generieren: `/tests focus on refactoring the code into functions, and generate tests` (/tests mit Fokus auf das Refaktorieren des Codes in Funktionen und das Erstellen von Tests).\n\n![Chat-Prompt mit Slash-Befehl /tests](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image29_aHR0cHM6_1750097645363.png)\n\n![Chat-Prompt mit präzisiertem Prompt](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750097645363.png)\n\nWeitere praktische Beispiele für vollständige Entwicklungsworkflows befinden sich in der Dokumentation [GitLab-Duo-Beispiele](https://docs.gitlab.com/ee/user/gitlab_duo_examples.html) (nur in englischer Sprache verfügbar).\n\n### 9. Präzisiere den Prompt für Slash-Befehle \n\nIn diesem Blogbeitrag findest du viele Tipps für verfeinerte Prompts. Sie gehören zu den Zutaten für eine bessere KI-basierte Workflow-Effizienz. Slash-Befehle sind nichts anderes und ermöglichen bessere Ergebnisse in GitLab Duo Chat.\n\nEin Kunde hat kürzlich gefragt: „Kann ich mit Codeerläuterungen mit `/explain` Kommentare im Code erstellen?“ Die Antwort lautet: Nein. Aber du kannst den Chat-Prompt verwenden, um Folgefragen zu stellen und eine Zusammenfassung in einem Code-Kommentarformat anzufordern. Dafür ist der Kontext der Sprache erforderlich. \n\nDas folgende Beispiel für den [Code für einen HTTP-Client in C++, der die Curl-Bibliothek verwendet](https://gitlab.com/gitlab-da/use-cases/ai/ai-workflows/gitlab-duo-prompts/-/blob/5cc9bdd65ee8ee16c548bea0402c18f8209d4d06/chat/slash-commands/c++/cli.cpp) benötigt eine ausführlichere Dokumentation. Du kannst den `/explain`-Prompt verfeinern, wenn du präzisiertere Anweisungen gibst, um den Code zu erklären, indem du Codekommentare hinzufügst, und diese anschließend kopierst und in den Editor einfügst.\n\n> /explain add documentation, rewrite the code snippet (/explain Füge Dokumentation hinzu, ändere die Code-Schnipsel)\n\n![Chat-Prompt zum Hinzufügen der Dokumentation und zum Umschreiben von Code-Schnipeln und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image13_aHR0cHM6_1750097645363.png)\n\nAlternativ kannst du Chat über einen verfeinerten Prompt mit `/refactor` auffordern, den Quellcode zu refaktorisieren, und fehlende Code-Kommentare zu generieren.\n\n> /refactor add code comments and documentation (/refactor Füge Code-Kommentare und eine Dokumentation hinzu)\n\n![Chat-Prompt für die Refaktorisierung von Quellcode und Generierung von Code-Kommentaren](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image15_aHR0cHM6_1750097645364.png)\n\n### 10. Werde bei den Slash-Befehlen kreativ\n\nWenn der Chat-Prompt keine Antwort auf eine Frage zum Quellcode oder zur Programmiersprache kennt, kannst du dir die Slash-Befehle `/explain`, `/refactor` und `/tests` näher ansehen und prüfen, wie hilfreich sie in dem Kontext wären.\n\nIm folgenden Beispiel wird eine SQL-Abfragezeichenfolge in C++ in einer einzelnen Zeile erstellt. Um die Lesbarkeit zu verbessern und in Zukunft weitere Datenbankspalten hinzuzufügen, kann es hilfreich sein, die Formatierung in einen mehrzeiligen String zu ändern.\n\n> std::string sql = \"CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, email TEXT NOT NULL)\";\n\nDu kannst GitLab Duo Chat zum Beispiel mit der folgenden Frage darum bitten:\n\n> How to create a string in C++ using multiple lines? (Wie erstelle ich einen String in C++ mit mehreren Zeilen?)\n\nChat kann mit einer Erklärung und einem optionalen Quellcode-Beispiel antworten. In diesem Zusammenhang könnte es die Frage so interpretieren, dass ein C++-String-Wert mit mehreren Zeilen erstellt wird, zum Beispiel mit dem Zeichen `\\n`, das einer Variablen zugewiesen ist. \n\nDie Anforderung ist allerdings, nur den geschriebenen Code und die Zuweisung der Variablenwerte in mehreren Zeilen zu formatieren. Der String-Wert selbst benötigt keine mehrzeilige String-Darstellung.\n\nEs gibt eine Alternative für zusätzlichen Kontext in VS Code und der Web IDE: Wähle den betreffenden Quellcode aus, klicke mit der rechten Maustaste und navigiere zu `GitLab Duo Chat > Refaktorisieren`. Das öffnet den Chat-Prompt und löst sofort die Code-Aufgabe `/refactor` aus.\n\nAllerdings kann es sein, dass die Code-Aufgabe nicht die erwarteten Ergebnisse hervorbringt. Das Refaktorisieren einer einzeiligen SQL-Zeichenfolge kann in vielerlei Hinsicht Bedeutung haben: Verwendung mehrerer Zeilen für die Lesbarkeit, Erstellung von Konstanten usw.\n\nMit Code-Aufgaben kannst du den Prompt verfeinern. Du kannst nach dem Befehl `/refactor` mehr Text hinzufügen und GitLab Duo Chat anweisen, einen bestimmten Code-Typ, Algorithmus oder ein Entwurfsmuster zu verwenden. \n\nVersuchen wir es noch einmal: Wähle den Quellcode aus, gehe zurück zu Chat und gib den folgenden Prompt ein, gefolgt von der `Eingabetaste`.\n\n> /refactor into a multi-line written string. Show different approaches for all C++ standards. (/refactor in einen mehrzeilig geschriebenen String. Zeige verschiedene Ansätze für alle C++-Standards.)\n\n![Chat-Prompt für die Refaktorisierung in einen mehrzeilig geschriebenen String und Antwort](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image17_aHR0cHM6_1750097645364.png)\n\n**Tipp:** Du kannst GitLab Duo Code Suggestions verwenden, um den Quellcode nach dem Refaktorisieren noch weiter zu optimieren, oder alternative Verfeinerungen des `/refactor`-Prompts nutzen.\n\n>/refactor into a multi-line written string, show different approaches (/refactor in einen mehrzeilig geschriebenen String. Zeige verschiedene Ansätze)\n>\n> /refactor into multi-line string, not using raw string literals (/refactor in einen mehrzeiligen String ohne Verwendung von rohen String-Literalen)\n>\n> /refactor into a multi-line written string. Make the table name parametrizable (/refactor in einen mehrzeilig geschriebenen String. Der Name der Tabelle muss parametrisierbar sein.)\n\nEin alternativer Ansatz mit dem Typ `stringstream` wird im [MR-Diff](https://gitlab.com/gitlab-da/use-cases/ai/gitlab-duo-coffee-chat/gitlab-duo-coffee-chat-2024-01-23/-/commit/7ea233138aed46d77e6ce0d930dd8e10560134eb#4ce01e4c84d4b62df8eed159c2db3768ad4ef8bf_33_35) dieses englischsprachigen Videos gezeigt: [GitLab Duo Coffee Chat: Refactor C++ functions into OOP classes for abstract database handling (GitLab Duo Coffee Chat: C++-Funktionen in OOP-Klassen umwandeln für abstrakte Datenbankverwaltung)](https://www.youtube.com/watch?v=Z9EJh0J9358).\n\n#### Sicherheitslücken erläutern\n\nDiese Methode funktioniert möglicherweise nicht in jedem Fall, aber über den Slash-Befehl `/explain` kann auch nach der Erläuterung von Sicherheitslücken gefragt werden. In diesem Beispiel enthält der [C-Code](https://gitlab.com/gitlab-da/use-cases/ai/ai-workflows/gitlab-duo-prompts/-/blob/5a5f293dfbfac7222ca4013d8f9ce9b462e4cd3a/chat/slash-commands/c/vuln.c) mehrere Sicherheitslücken für strcpy()-Pufferüberläufe, global überschreibbare Dateiberechtigungen, Race-Condition-Angriffe und mehr.\n\n> /explain why this code has multiple vulnerabilities (/explain warum weit dieser Code mehrere Sicherheitslücken auf)\n\n![Chat-Prompt über mehrere Sicherheitslücken des Codes](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image20_aHR0cHM6_1750097645365.png)\n\n#### C-Code in Rust refaktorisieren\n\nRust bietet Speichersicherheit. Mit dem Befehl `/refactor into Rust` kannst du Duo Chat dazu auffordern, den anfälligen [C-Code](https://gitlab.com/gitlab-da/use-cases/ai/ai-workflows/gitlab-duo-prompts/-/blob/5a5f293dfbfac7222ca4013d8f9ce9b462e4cd3a/chat/slash-commands/c/vuln.c) in Rust zu refaktorisieren. Übe mit präzisierteren Prompts, um bessere Ergebnisse zu erzielen.\n\n> /refactor into Rust and use high level libraries (/refactor in Rust und verwende High-Level-Bibliotheken)\n\n![Chat-Prompt](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image8_aHR0cHM6_1750097645366.png)\n\n### Shortcuts \n\nProbiere diese Shortcuts in deiner Umgebung aus und übe asynchron mithilfe von GitLab Duo Chat.\n\n1. Prüfe anfälligen Code aus CVEs und frage mit `/explain why is this code vulnerable` (/explain warum ist dieser Code anfällig) was er tut und wie er korrigiert werden kann. \n**Tipp:** Importiere Open-Source-Projekte in GitLab, um die Vorteile der Code-Erläuterung von GitLab Duo Chat zu nutzen.\n2. Versuche, den Code in neue Programmiersprachen zu refaktorisieren. Dies ist bei Legacy-Code-Migrationsplänen hilfreich.\n3. Du kannst auch versuchen, die Jenkins-Konfiguration in GitLab CI/CD zu refaktorisieren, indem du den Slash-Befehl `/refactor into GitLab CI/CD configuration` (/refactor in die GitLab CI/CD-Konfiguration) verwendest. \n\n### Unterhaltsame Übungen \n\nVersuche Chat dazu zu bringen, sich wie Clippy zu verhalten.\n![Chat-Prompt](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image22_aHR0cHM6_1750097645366.png)\n\nFrage nach der Mission von GitLab: „Jede(r) kann etwas beitragen.”\n\n![Chat-Prompt](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097645/Blog/Content%20Images/Blog/Content%20Images/image33_aHR0cHM6_1750097645367.png)\n\n### Weitere Informationen\n\nEs gibt viele verschiedene Umgebungen und Herausforderungen. Wir haben die [Dokumentation von GitLab Duo Chat](https://docs.gitlab.com/ee/user/gitlab_duo_chat.html) mit weiteren praktischen Beispielen aktualisiert und einen neuen Abschnitt [GitLab-Duo-Beispiele](https://docs.gitlab.com/ee/user/gitlab_duo_examples.html) (Dokumentation nur in englischer Sprache verfügbar) mit detaillierten Einblicken in KI-basierte DevSecOps-Workflows, einschließlich Chat, hinzugefügt.\n\nDas Erlernen von GitLab Duo funktioniert am besten durch spielerische Herausforderungen und echten Produktionscode. Die neue Lernreihe GitLab Duo Coffee Chat wird sehr bald fortgesetzt. Bis dahin kannst du dir die englischsprachigen Aufnahmen in [dieser YouTube-Playlist](https://www.youtube.com/playlist?list=PL05JrBw4t0Kp5uj_JgQiSvHw1jQu0mSVZ) ansehen. Wenn du Kunde oder Kundin von GitLab bist und an einem GitLab Duo Coffee Chat teilnehmen möchtest, um gemeinsam zu lernen, dann melde dich in [diesem Planungs-Epic](https://gitlab.com/groups/gitlab-com/marketing/developer-relations/-/epics/476). \n\n> Möchtest du mit GitLab Duo Chat loslegen? [Starte noch heute deine kostenlose Testversion](https://about.gitlab.com/de-de/solutions/gitlab-duo-pro/sales/).\n",[678,705,707,9],{"slug":1630,"featured":90,"template":682},"10-best-practices-for-using-ai-powered-gitlab-duo-chat","content:de-de:blog:10-best-practices-for-using-ai-powered-gitlab-duo-chat.yml","10 Best Practices For Using Ai Powered Gitlab Duo Chat","de-de/blog/10-best-practices-for-using-ai-powered-gitlab-duo-chat.yml","de-de/blog/10-best-practices-for-using-ai-powered-gitlab-duo-chat",6,[664,688,715,734,758,778,799,821,847],1759347907726]