[{"data":1,"prerenderedAt":770},["ShallowReactive",2],{"/en-us/blog/tags/inside-gitlab/":3,"navigation-de-de":20,"banner-de-de":441,"footer-de-de":454,"inside GitLab-tag-page-de-de":664},{"_path":4,"_dir":5,"_draft":6,"_partial":6,"_locale":7,"content":8,"config":11,"_id":13,"_type":14,"title":15,"_source":16,"_file":17,"_stem":18,"_extension":19},"/en-us/blog/tags/inside-gitlab","tags",false,"",{"tag":9,"tagSlug":10},"inside GitLab","inside-gitlab",{"template":12},"BlogTag","content:en-us:blog:tags:inside-gitlab.yml","yaml","Inside Gitlab","content","en-us/blog/tags/inside-gitlab.yml","en-us/blog/tags/inside-gitlab","yml",{"_path":21,"_dir":22,"_draft":6,"_partial":6,"_locale":7,"data":23,"_id":437,"_type":14,"title":438,"_source":16,"_file":439,"_stem":440,"_extension":19},"/shared/de-de/main-navigation","de-de",{"logo":24,"freeTrial":29,"sales":34,"login":39,"items":44,"search":378,"minimal":414,"duo":428},{"config":25},{"href":26,"dataGaName":27,"dataGaLocation":28},"/de-de/","gitlab logo","header",{"text":30,"config":31},"Kostenlose Testversion anfordern",{"href":32,"dataGaName":33,"dataGaLocation":28},"https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com&glm_content=default-saas-trial/","free trial",{"text":35,"config":36},"Vertrieb kontaktieren",{"href":37,"dataGaName":38,"dataGaLocation":28},"/de-de/sales/","sales",{"text":40,"config":41},"Anmelden",{"href":42,"dataGaName":43,"dataGaLocation":28},"https://gitlab.com/users/sign_in/","sign in",[45,89,188,193,299,359],{"text":46,"config":47,"cards":49,"footer":72},"Plattform",{"dataNavLevelOne":48},"platform",[50,56,64],{"title":46,"description":51,"link":52},"Die umfassendste KI-basierte DevSecOps-Plattform",{"text":53,"config":54},"Erkunde unsere Plattform",{"href":55,"dataGaName":48,"dataGaLocation":28},"/de-de/platform/",{"title":57,"description":58,"link":59},"GitLab Duo (KI)","Entwickle Software schneller mit KI in jeder Phase der Entwicklung",{"text":60,"config":61},"Lerne GitLab Duo kennen",{"href":62,"dataGaName":63,"dataGaLocation":28},"/de-de/gitlab-duo/","gitlab duo ai",{"title":65,"description":66,"link":67},"Gründe, die für GitLab sprechen","10 Gründe, warum Unternehmen sich für GitLab entscheiden",{"text":68,"config":69},"Mehr erfahren",{"href":70,"dataGaName":71,"dataGaLocation":28},"/de-de/why-gitlab/","why gitlab",{"title":73,"items":74},"Erste Schritte mit",[75,80,85],{"text":76,"config":77},"Platform Engineering",{"href":78,"dataGaName":79,"dataGaLocation":28},"/de-de/solutions/platform-engineering/","platform engineering",{"text":81,"config":82},"Entwicklererfahrung",{"href":83,"dataGaName":84,"dataGaLocation":28},"/de-de/developer-experience/","Developer experience",{"text":86,"config":87},"MLOps",{"href":88,"dataGaName":86,"dataGaLocation":28},"/de-de/topics/devops/the-role-of-ai-in-devops/",{"text":90,"left":91,"config":92,"link":94,"lists":98,"footer":170},"Produkt",true,{"dataNavLevelOne":93},"solutions",{"text":95,"config":96},"Alle Lösungen anzeigen",{"href":97,"dataGaName":93,"dataGaLocation":28},"/de-de/solutions/",[99,125,148],{"title":100,"description":101,"link":102,"items":107},"Automatisierung","CI/CD und Automatisierung zur Beschleunigung der Bereitstellung",{"config":103},{"icon":104,"href":105,"dataGaName":106,"dataGaLocation":28},"AutomatedCodeAlt","/de-de/solutions/delivery-automation/","automated software delivery",[108,112,116,121],{"text":109,"config":110},"CI/CD",{"href":111,"dataGaLocation":28,"dataGaName":109},"/de-de/solutions/continuous-integration/",{"text":113,"config":114},"KI-unterstützte Entwicklung",{"href":62,"dataGaLocation":28,"dataGaName":115},"AI assisted development",{"text":117,"config":118},"Quellcodeverwaltung",{"href":119,"dataGaLocation":28,"dataGaName":120},"/de-de/solutions/source-code-management/","Source Code Management",{"text":122,"config":123},"Automatisierte Softwarebereitstellung",{"href":105,"dataGaLocation":28,"dataGaName":124},"Automated software delivery",{"title":126,"description":127,"link":128,"items":133},"Sicherheit","Entwickle schneller, ohne die Sicherheit zu gefährden",{"config":129},{"href":130,"dataGaName":131,"dataGaLocation":28,"icon":132},"/de-de/solutions/security-compliance/","security and compliance","ShieldCheckLight",[134,139,144],{"text":135,"config":136},"Application Security Testing",{"href":137,"dataGaName":138,"dataGaLocation":28},"/solutions/application-security-testing/","Application security testing",{"text":140,"config":141},"Schutz der Software-Lieferkette",{"href":142,"dataGaLocation":28,"dataGaName":143},"/de-de/solutions/supply-chain/","Software supply chain security",{"text":145,"config":146},"Software Compliance",{"href":147,"dataGaName":145,"dataGaLocation":28},"/solutions/software-compliance/",{"title":149,"link":150,"items":155},"Bewertung",{"config":151},{"icon":152,"href":153,"dataGaName":154,"dataGaLocation":28},"DigitalTransformation","/de-de/solutions/visibility-measurement/","visibility and measurement",[156,160,165],{"text":157,"config":158},"Sichtbarkeit und Bewertung",{"href":153,"dataGaLocation":28,"dataGaName":159},"Visibility and Measurement",{"text":161,"config":162},"Wertstrommanagement",{"href":163,"dataGaLocation":28,"dataGaName":164},"/de-de/solutions/value-stream-management/","Value Stream Management",{"text":166,"config":167},"Analysen und Einblicke",{"href":168,"dataGaLocation":28,"dataGaName":169},"/de-de/solutions/analytics-and-insights/","Analytics and insights",{"title":171,"items":172},"GitLab für",[173,178,183],{"text":174,"config":175},"Enterprise",{"href":176,"dataGaLocation":28,"dataGaName":177},"/de-de/enterprise/","enterprise",{"text":179,"config":180},"Kleinunternehmen",{"href":181,"dataGaLocation":28,"dataGaName":182},"/de-de/small-business/","small business",{"text":184,"config":185},"den öffentlichen Sektor",{"href":186,"dataGaLocation":28,"dataGaName":187},"/de-de/solutions/public-sector/","public sector",{"text":189,"config":190},"Preise",{"href":191,"dataGaName":192,"dataGaLocation":28,"dataNavLevelOne":192},"/de-de/pricing/","pricing",{"text":194,"config":195,"link":197,"lists":201,"feature":286},"Ressourcen",{"dataNavLevelOne":196},"resources",{"text":198,"config":199},"Alle Ressourcen anzeigen",{"href":200,"dataGaName":196,"dataGaLocation":28},"/de-de/resources/",[202,235,258],{"title":203,"items":204},"Erste Schritte",[205,210,215,220,225,230],{"text":206,"config":207},"Installieren",{"href":208,"dataGaName":209,"dataGaLocation":28},"/de-de/install/","install",{"text":211,"config":212},"Kurzanleitungen",{"href":213,"dataGaName":214,"dataGaLocation":28},"/de-de/get-started/","quick setup checklists",{"text":216,"config":217},"Lernen",{"href":218,"dataGaLocation":28,"dataGaName":219},"https://university.gitlab.com/","learn",{"text":221,"config":222},"Produktdokumentation",{"href":223,"dataGaName":224,"dataGaLocation":28},"https://docs.gitlab.com/","product documentation",{"text":226,"config":227},"Best-Practice-Videos",{"href":228,"dataGaName":229,"dataGaLocation":28},"/de-de/getting-started-videos/","best practice videos",{"text":231,"config":232},"Integrationen",{"href":233,"dataGaName":234,"dataGaLocation":28},"/de-de/integrations/","integrations",{"title":236,"items":237},"Entdecken",[238,243,248,253],{"text":239,"config":240},"Kundenerfolge",{"href":241,"dataGaName":242,"dataGaLocation":28},"/de-de/customers/","customer success stories",{"text":244,"config":245},"Blog",{"href":246,"dataGaName":247,"dataGaLocation":28},"/de-de/blog/","blog",{"text":249,"config":250},"Remote",{"href":251,"dataGaName":252,"dataGaLocation":28},"https://handbook.gitlab.com/handbook/company/culture/all-remote/","remote",{"text":254,"config":255},"TeamOps",{"href":256,"dataGaName":257,"dataGaLocation":28},"/de-de/teamops/","teamops",{"title":259,"items":260},"Vernetzen",[261,266,271,276,281],{"text":262,"config":263},"GitLab-Services",{"href":264,"dataGaName":265,"dataGaLocation":28},"/de-de/services/","services",{"text":267,"config":268},"Community",{"href":269,"dataGaName":270,"dataGaLocation":28},"/community/","community",{"text":272,"config":273},"Forum",{"href":274,"dataGaName":275,"dataGaLocation":28},"https://forum.gitlab.com/","forum",{"text":277,"config":278},"Veranstaltungen",{"href":279,"dataGaName":280,"dataGaLocation":28},"/events/","events",{"text":282,"config":283},"Partner",{"href":284,"dataGaName":285,"dataGaLocation":28},"/de-de/partners/","partners",{"backgroundColor":287,"textColor":288,"text":289,"image":290,"link":294},"#2f2a6b","#fff","Perspektiven für die Softwareentwicklung der Zukunft",{"altText":291,"config":292},"the source promo card",{"src":293},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758208064/dzl0dbift9xdizyelkk4.svg",{"text":295,"config":296},"Lies die News",{"href":297,"dataGaName":298,"dataGaLocation":28},"/de-de/the-source/","the source",{"text":300,"config":301,"lists":303},"Unternehmen",{"dataNavLevelOne":302},"company",[304],{"items":305},[306,311,317,319,324,329,334,339,344,349,354],{"text":307,"config":308},"Über",{"href":309,"dataGaName":310,"dataGaLocation":28},"/de-de/company/","about",{"text":312,"config":313,"footerGa":316},"Karriere",{"href":314,"dataGaName":315,"dataGaLocation":28},"/jobs/","jobs",{"dataGaName":315},{"text":277,"config":318},{"href":279,"dataGaName":280,"dataGaLocation":28},{"text":320,"config":321},"Geschäftsführung",{"href":322,"dataGaName":323,"dataGaLocation":28},"/company/team/e-group/","leadership",{"text":325,"config":326},"Team",{"href":327,"dataGaName":328,"dataGaLocation":28},"/company/team/","team",{"text":330,"config":331},"Handbuch",{"href":332,"dataGaName":333,"dataGaLocation":28},"https://handbook.gitlab.com/","handbook",{"text":335,"config":336},"Investor Relations",{"href":337,"dataGaName":338,"dataGaLocation":28},"https://ir.gitlab.com/","investor relations",{"text":340,"config":341},"Trust Center",{"href":342,"dataGaName":343,"dataGaLocation":28},"/de-de/security/","trust center",{"text":345,"config":346},"AI Transparency Center",{"href":347,"dataGaName":348,"dataGaLocation":28},"/de-de/ai-transparency-center/","ai transparency center",{"text":350,"config":351},"Newsletter",{"href":352,"dataGaName":353,"dataGaLocation":28},"/company/contact/","newsletter",{"text":355,"config":356},"Presse",{"href":357,"dataGaName":358,"dataGaLocation":28},"/press/","press",{"text":360,"config":361,"lists":362},"Kontakt",{"dataNavLevelOne":302},[363],{"items":364},[365,368,373],{"text":35,"config":366},{"href":37,"dataGaName":367,"dataGaLocation":28},"talk to sales",{"text":369,"config":370},"Support",{"href":371,"dataGaName":372,"dataGaLocation":28},"/support/","get help",{"text":374,"config":375},"Kundenportal",{"href":376,"dataGaName":377,"dataGaLocation":28},"https://customers.gitlab.com/customers/sign_in/","customer portal",{"close":379,"login":380,"suggestions":387},"Schließen",{"text":381,"link":382},"Um Repositories und Projekte zu durchsuchen, melde dich an bei",{"text":383,"config":384},"gitlab.com",{"href":42,"dataGaName":385,"dataGaLocation":386},"search login","search",{"text":388,"default":389},"Vorschläge",[390,393,398,400,405,410],{"text":57,"config":391},{"href":62,"dataGaName":392,"dataGaLocation":386},"GitLab Duo (AI)",{"text":394,"config":395},"Code Suggestions (KI)",{"href":396,"dataGaName":397,"dataGaLocation":386},"/de-de/solutions/code-suggestions/","Code Suggestions (AI)",{"text":109,"config":399},{"href":111,"dataGaName":109,"dataGaLocation":386},{"text":401,"config":402},"GitLab auf AWS",{"href":403,"dataGaName":404,"dataGaLocation":386},"/de-de/partners/technology-partners/aws/","GitLab on AWS",{"text":406,"config":407},"GitLab auf Google Cloud",{"href":408,"dataGaName":409,"dataGaLocation":386},"/de-de/partners/technology-partners/google-cloud-platform/","GitLab on Google Cloud",{"text":411,"config":412},"Warum GitLab?",{"href":70,"dataGaName":413,"dataGaLocation":386},"Why GitLab?",{"freeTrial":415,"mobileIcon":420,"desktopIcon":425},{"text":416,"config":417},"Kostenlos testen",{"href":418,"dataGaName":33,"dataGaLocation":419},"https://gitlab.com/-/trials/new/","nav",{"altText":421,"config":422},"GitLab-Symbol",{"src":423,"dataGaName":424,"dataGaLocation":419},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758203874/jypbw1jx72aexsoohd7x.svg","gitlab icon",{"altText":421,"config":426},{"src":427,"dataGaName":424,"dataGaLocation":419},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758203875/gs4c8p8opsgvflgkswz9.svg",{"freeTrial":429,"mobileIcon":433,"desktopIcon":435},{"text":430,"config":431},"Erfahre mehr über GitLab Duo",{"href":62,"dataGaName":432,"dataGaLocation":419},"gitlab duo",{"altText":421,"config":434},{"src":423,"dataGaName":424,"dataGaLocation":419},{"altText":421,"config":436},{"src":427,"dataGaName":424,"dataGaLocation":419},"content:shared:de-de:main-navigation.yml","Main Navigation","shared/de-de/main-navigation.yml","shared/de-de/main-navigation",{"_path":442,"_dir":22,"_draft":6,"_partial":6,"_locale":7,"title":443,"button":444,"config":449,"_id":451,"_type":14,"_source":16,"_file":452,"_stem":453,"_extension":19},"/shared/de-de/banner","GitLab Duo Agent Platform ist jetzt in öffentlicher Beta!",{"text":445,"config":446},"Beta testen",{"href":447,"dataGaName":448,"dataGaLocation":28},"/de-de/gitlab-duo/agent-platform/","duo banner",{"layout":450},"release","content:shared:de-de:banner.yml","shared/de-de/banner.yml","shared/de-de/banner",{"_path":455,"_dir":22,"_draft":6,"_partial":6,"_locale":7,"data":456,"_id":660,"_type":14,"title":661,"_source":16,"_file":662,"_stem":663,"_extension":19},"/shared/de-de/main-footer",{"text":457,"source":458,"edit":464,"contribute":469,"config":474,"items":479,"minimal":652},"Git ist eine Marke von Software Freedom Conservancy und unsere Verwendung von „GitLab“ erfolgt unter Lizenz.",{"text":459,"config":460},"Quelltext der Seite anzeigen",{"href":461,"dataGaName":462,"dataGaLocation":463},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/","page source","footer",{"text":465,"config":466},"Diese Seite bearbeiten",{"href":467,"dataGaName":468,"dataGaLocation":463},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/content/","web ide",{"text":470,"config":471},"Beteilige dich",{"href":472,"dataGaName":473,"dataGaLocation":463},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/CONTRIBUTING.md/","please contribute",{"twitter":475,"facebook":476,"youtube":477,"linkedin":478},"https://x.com/gitlab","https://www.facebook.com/gitlab","https://www.youtube.com/channel/UCnMGQ8QHMAnVIsI3xJrihhg","https://www.linkedin.com/company/gitlab-com",[480,503,558,588,622],{"title":46,"links":481,"subMenu":486},[482],{"text":483,"config":484},"DevSecOps-Plattform",{"href":55,"dataGaName":485,"dataGaLocation":463},"devsecops platform",[487],{"title":189,"links":488},[489,493,498],{"text":490,"config":491},"Tarife anzeigen",{"href":191,"dataGaName":492,"dataGaLocation":463},"view plans",{"text":494,"config":495},"Vorteile von Premium",{"href":496,"dataGaName":497,"dataGaLocation":463},"/de-de/pricing/premium/","why premium",{"text":499,"config":500},"Vorteile von Ultimate",{"href":501,"dataGaName":502,"dataGaLocation":463},"/de-de/pricing/ultimate/","why ultimate",{"title":504,"links":505},"Lösungen",[506,511,514,516,521,526,530,533,536,541,543,545,548,553],{"text":507,"config":508},"Digitale Transformation",{"href":509,"dataGaName":510,"dataGaLocation":463},"/de-de/topics/digital-transformation/","digital transformation",{"text":512,"config":513},"Sicherheit und Compliance",{"href":137,"dataGaName":138,"dataGaLocation":463},{"text":122,"config":515},{"href":105,"dataGaName":106,"dataGaLocation":463},{"text":517,"config":518},"Agile Entwicklung",{"href":519,"dataGaName":520,"dataGaLocation":463},"/de-de/solutions/agile-delivery/","agile delivery",{"text":522,"config":523},"Cloud-Transformation",{"href":524,"dataGaName":525,"dataGaLocation":463},"/de-de/topics/cloud-native/","cloud transformation",{"text":527,"config":528},"SCM",{"href":119,"dataGaName":529,"dataGaLocation":463},"source code management",{"text":109,"config":531},{"href":111,"dataGaName":532,"dataGaLocation":463},"continuous integration & delivery",{"text":161,"config":534},{"href":163,"dataGaName":535,"dataGaLocation":463},"value stream management",{"text":537,"config":538},"GitOps",{"href":539,"dataGaName":540,"dataGaLocation":463},"/de-de/solutions/gitops/","gitops",{"text":174,"config":542},{"href":176,"dataGaName":177,"dataGaLocation":463},{"text":179,"config":544},{"href":181,"dataGaName":182,"dataGaLocation":463},{"text":546,"config":547},"Öffentlicher Sektor",{"href":186,"dataGaName":187,"dataGaLocation":463},{"text":549,"config":550},"Bildungswesen",{"href":551,"dataGaName":552,"dataGaLocation":463},"/de-de/solutions/education/","education",{"text":554,"config":555},"Finanzdienstleistungen",{"href":556,"dataGaName":557,"dataGaLocation":463},"/de-de/solutions/finance/","financial services",{"title":194,"links":559},[560,562,564,566,569,571,574,576,578,580,582,584,586],{"text":206,"config":561},{"href":208,"dataGaName":209,"dataGaLocation":463},{"text":211,"config":563},{"href":213,"dataGaName":214,"dataGaLocation":463},{"text":216,"config":565},{"href":218,"dataGaName":219,"dataGaLocation":463},{"text":221,"config":567},{"href":223,"dataGaName":568,"dataGaLocation":463},"docs",{"text":244,"config":570},{"href":246,"dataGaName":247,"dataGaLocation":463},{"text":239,"config":572},{"href":573,"dataGaName":242,"dataGaLocation":463},"/customers/",{"text":249,"config":575},{"href":251,"dataGaName":252,"dataGaLocation":463},{"text":262,"config":577},{"href":264,"dataGaName":265,"dataGaLocation":463},{"text":254,"config":579},{"href":256,"dataGaName":257,"dataGaLocation":463},{"text":267,"config":581},{"href":269,"dataGaName":270,"dataGaLocation":463},{"text":272,"config":583},{"href":274,"dataGaName":275,"dataGaLocation":463},{"text":277,"config":585},{"href":279,"dataGaName":280,"dataGaLocation":463},{"text":282,"config":587},{"href":284,"dataGaName":285,"dataGaLocation":463},{"title":300,"links":589},[590,592,594,596,598,600,602,606,611,613,615,617],{"text":307,"config":591},{"href":309,"dataGaName":302,"dataGaLocation":463},{"text":312,"config":593},{"href":314,"dataGaName":315,"dataGaLocation":463},{"text":320,"config":595},{"href":322,"dataGaName":323,"dataGaLocation":463},{"text":325,"config":597},{"href":327,"dataGaName":328,"dataGaLocation":463},{"text":330,"config":599},{"href":332,"dataGaName":333,"dataGaLocation":463},{"text":335,"config":601},{"href":337,"dataGaName":338,"dataGaLocation":463},{"text":603,"config":604},"Sustainability",{"href":605,"dataGaName":603,"dataGaLocation":463},"/sustainability/",{"text":607,"config":608},"Vielfalt, Inklusion und Zugehörigkeit",{"href":609,"dataGaName":610,"dataGaLocation":463},"/diversity-inclusion-belonging/","Diversity, inclusion and belonging",{"text":340,"config":612},{"href":342,"dataGaName":343,"dataGaLocation":463},{"text":350,"config":614},{"href":352,"dataGaName":353,"dataGaLocation":463},{"text":355,"config":616},{"href":357,"dataGaName":358,"dataGaLocation":463},{"text":618,"config":619},"Transparenzerklärung zu moderner Sklaverei",{"href":620,"dataGaName":621,"dataGaLocation":463},"https://handbook.gitlab.com/handbook/legal/modern-slavery-act-transparency-statement/","modern slavery transparency statement",{"title":623,"links":624},"Nimm Kontakt auf",[625,628,630,632,637,642,647],{"text":626,"config":627},"Sprich mit einem Experten/einer Expertin",{"href":37,"dataGaName":38,"dataGaLocation":463},{"text":369,"config":629},{"href":371,"dataGaName":372,"dataGaLocation":463},{"text":374,"config":631},{"href":376,"dataGaName":377,"dataGaLocation":463},{"text":633,"config":634},"Status",{"href":635,"dataGaName":636,"dataGaLocation":463},"https://status.gitlab.com/","status",{"text":638,"config":639},"Nutzungsbedingungen",{"href":640,"dataGaName":641,"dataGaLocation":463},"/terms/","terms of use",{"text":643,"config":644},"Datenschutzerklärung",{"href":645,"dataGaName":646,"dataGaLocation":463},"/de-de/privacy/","privacy statement",{"text":648,"config":649},"Cookie-Einstellungen",{"dataGaName":650,"dataGaLocation":463,"id":651,"isOneTrustButton":91},"cookie preferences","ot-sdk-btn",{"items":653},[654,656,658],{"text":638,"config":655},{"href":640,"dataGaName":641,"dataGaLocation":463},{"text":643,"config":657},{"href":645,"dataGaName":646,"dataGaLocation":463},{"text":648,"config":659},{"dataGaName":650,"dataGaLocation":463,"id":651,"isOneTrustButton":91},"content:shared:de-de:main-footer.yml","Main Footer","shared/de-de/main-footer.yml","shared/de-de/main-footer",{"allPosts":665,"featuredPost":742,"totalPagesCount":768,"initialPosts":769},[666,695,721],{"_path":667,"_dir":247,"_draft":6,"_partial":6,"_locale":7,"seo":668,"content":676,"config":688,"_id":691,"_type":14,"title":692,"_source":16,"_file":693,"_stem":694,"_extension":19},"/de-de/blog/developing-gitlab-duo-how-we-validate-and-test-ai-models-at-scale",{"ogTitle":669,"schema":670,"ogImage":671,"ogDescription":672,"ogSiteName":673,"noIndex":6,"ogType":674,"ogUrl":675,"title":669,"canonicalUrls":675,"description":672},"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","article","https://about.gitlab.com/blog/developing-gitlab-duo-how-we-validate-and-test-ai-models-at-scale",{"title":677,"description":672,"authors":678,"heroImage":671,"date":680,"body":681,"category":682,"tags":683},"Entwicklung von GitLab Duo: Wie wir KI-Modelle im großen Maßstab validieren und testen",[679],"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>","ai-ml",[684,685,686,687,9],"AI/ML","DevSecOps","DevSecOps platform","features",{"slug":689,"featured":91,"template":690},"developing-gitlab-duo-how-we-validate-and-test-ai-models-at-scale","BlogPost","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":696,"_dir":247,"_draft":6,"_partial":6,"_locale":7,"seo":697,"content":703,"config":715,"_id":717,"_type":14,"title":718,"_source":16,"_file":719,"_stem":720,"_extension":19},"/de-de/blog/five-fast-facts-about-docs-as-code-at-gitlab",{"title":698,"description":699,"ogTitle":698,"ogDescription":699,"noIndex":6,"ogImage":700,"ogUrl":701,"ogSiteName":673,"ogType":674,"canonicalUrls":701,"schema":702},"5 Funktionen, die Docs-as-Code in GitLab technischen Redaktionsteams bietet","Technische Redaktionsteams können GitLab als zentrale Plattform für die Dokumentation nutzen und dabei einen Docs-as-Code-Workflow anwenden. Durch diesen Workflow lassen sich Dokumentationen planen, erstellen, prüfen, bearbeiten und veröffentlichen. Dies ermöglicht es auch kleinen Teams, eine große Menge an Inhalten zu produzieren.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749660257/Blog/Hero%20Images/pen.jpg","https://about.gitlab.com/blog/five-fast-facts-about-docs-as-code-at-gitlab","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"5 Funktionen, die Docs-as-Code in GitLab technischen Redaktionsteams bietet\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Suzanne Selhorn\"},{\"@type\":\"Person\",\"name\":\"Susan Tacker\"},{\"@type\":\"Person\",\"name\":\"Diana Logan\"}],\n        \"datePublished\": \"2022-10-12\",\n      }",{"title":698,"description":699,"authors":704,"heroImage":700,"date":708,"body":709,"category":710,"tags":711,"updatedDate":714},[705,706,707],"Suzanne Selhorn","Susan Tacker","Diana Logan","2022-10-12","In diesem Artikel erfährst du, von welchen fünf Funktionen technische Redaktionsteams profitieren, wenn sie Docs-as-Code in GitLab nutzen.\n\n## Was ist Docs-as-Code?\n\nDocs-as-Code oder auch Documentation-as-Code ist eine Methode zur Erstellung und Veröffentlichung von Produktdokumentationen. Dabei kommen die gleichen Tools und Prozesse wie bei der Softwareentwicklung zum Einsatz. Die Dokumentationsdateien werden zusammen mit dem Quellcode in einem Versionskontroll-Repository abgelegt.\n\nMöchtest du wissen, ob dein Unternehmen einen Docs-as-Code-Workflow in GitLab einführen könnte? Dann lies weiter, um fünf kurze Fakten zu erfahren, wie unser Team dies umsetzt.\n\n## Funktion 1: GitLab zur Planung von Aktualisierungen der Dokumentationsinhalte\n\nProduktmanager(innen), UX-Designer(innen), Entwickler(innen) und Qualitätssicherungs-Teams arbeiten gemeinsam daran, die Arbeit an neuen Funktionen bei GitLab zu planen und umzusetzen. Dieser kollaborative Ansatz stellt sicher, dass alle Aspekte der Produktentwicklung berücksichtigt werden und alle Beteiligten auf dem gleichen Stand sind.\n\nBei der Planung von Veröffentlichungen kommen in Unternehmen häufig verschiedene Tools zum Einsatz. So werden beispielsweise Kanban-Boards genutzt, um den Workflow visuell darzustellen und zu organisieren. Zusätzlich werden Issues in einem Drittanbieter-Tool erstellt und verwaltet, um Aufgaben zu verfolgen und den Fortschritt zu dokumentieren.\n\nBei GitLab werden Epics und Issues als nützliche Tools zur Planung der Arbeit verwendet. Epics ermöglichen, größere Projekte in kleinere Aufgaben zu unterteilen. Issues helfen dabei, spezifische Aufgaben und Anforderungen zu definieren. Issue-Boards ermöglichen die Verfolgung des Fortschritts in Echtzeit und bieten eine übersichtliche Darstellung des Projektstatus. Dabei ist Transparenz ein zentraler Aspekt dieses Prozesses. Alle Informationen, einschließlich der Diskussionen über die Planung und Umsetzung, sind für alle Teammitglieder zugänglich. \n\nDies fördert eine offene Kommunikation und Zusammenarbeit. Zudem haben technische Redaktionsteams so jederzeit Einblick in den aktuellen Stand der Entwicklung und können ihre Dokumentationsarbeiten entsprechend anpassen und aktualisieren. Diese Transparenz erleichtert es, Änderungen und Updates in der Dokumentation zeitnah und präzise zu integrieren.\n\n![Ansicht des Workspace Plannings](https://about.gitlab.com/images/blogimages/planning_issue.png)\n\nBei größeren Projekten werden diese in GitLab verfolgt. Änderungen werden direkt in GitLab vorgenommen und die entsprechenden Issues dort als erledigt markiert. Kommt nach einem Jahr die Frage auf, warum eine bestimmte Änderung vorgenommen wurde, ist diese genau in GitLab nachvollziehbar. Es kann problemlos geprüft werden, wer die Änderung durchgeführt hat und aus welchem Grund.\n\nWenn in deinem Unternehmen viele verschiedene Tools verwendet werden, stelle dir vor, wie es wäre, alles an einem Ort zu haben, anstatt beispielsweise in separaten Docs-as-Code-Tools zu arbeiten. Dies würde den Prozess schneller und effizienter gestalten. Die Zeit, die normalerweise damit verbracht wird, E-Mails, Websites und Slack zu durchsuchen, um verlorene Diskussionen zu finden, wird so eingespart. Alles Notwendige findest du in GitLab.\n\nFür diejenigen, die ihr Wiki lieben und nicht darauf verzichten möchten, bietet GitLab auch eine Wiki-Funktion an.\n\n## Funktion 2: Feedback zu Dokumenten\n\nWenn du schon länger als Autor(in) arbeitest, weißt du, wie mühsam es sein kann, jemanden zu finden, der die Kapazität hat, deine Arbeit zu überprüfen.\n\nBei GitLab schreiben die Entwickler(innen) den ersten Entwurf der Inhalte für alle neuen Funktionen. Diese Inhalte werden im selben Repository wie ihr Code gespeichert. Die Entwickler(innen) weisen den Inhaltsentwurf den Autor(inn)en zu, die ihn daraufhin überprüfen, Vorschläge hinzufügen und ihre Ideen und Änderungen an die Entwickler(innen) zurückschicken.\n\nAuch die Autor(inn)en öffnen Merge Requests (MRs) für inhaltliche Änderungen. Unabhängig davon, wer den MR öffnet, haben alle Teammitglieder die Möglichkeit, die Arbeit des jeweils anderen zu kommentieren.\n\nIn einem Merge Request ist es ganz einfach, die Schaltfläche „Vorschlag“ auszuwählen. Du kannst eine oder mehrere Zeilen kommentieren, Änderungen oder Bearbeitungen vorschlagen. Die Person, die den Merge Request erstellt hat, kann die Änderung direkt übernehmen oder einen alternativen Vorschlag machen, über den dann noch einmal gesprochen werden kann. Wenn du andere zur Diskussion einladen möchtest, erstellst du einfach einen neuen Kommentar und fügst dort die Namen der jeweiligen Personen ein. Sie sehen deinen Kommentar dann als Aufgabe in GitLab. Diese Vorgehensweise fördert die Transparenz und Inklusion in Teams.\n\n![Ansicht eines Änderungsverlaufs in GitLab](https://about.gitlab.com/images/blogimages/suggestion.png)\n\nDa der Inhalt des Dokuments in Markdown vorliegt, was reinem Text ähnelt, ist es einfach, die Unterschiede zwischen den Dateiversionen zu erkennen und zu sehen, wer welche Änderungen vorgenommen hat.\n\nVielleicht hast du schon mal in Teams gearbeitet, in denen Überprüfungen in PDFs, Word-Dokumenten oder Google-Dokumenten mit Kommentaren durchgeführt wurden. Wenn du stattdessen diesen Workflow ausprobierst, wirst du sehen, wie viel effizienter der Prozess ist. Es werden keine veralteten Versionen von Dokumenten weitergegeben, und niemand nimmt Aktualisierungen vor, die versehentlich die Kommentare eines anderen löschen.\n\nUnd wenn jemand wissen möchte, warum eine bestimmte Änderung vorgenommen wurde, kann er ganz einfach die Historie der Seite aufrufen und dort sogar sehen, wer für eine bestimmte Zeile verantwortlich ist.\n\n![Ansicht der Merge-Request-Historie, um zu sehen, wer welche Änderungen vorgenommen hat.](https://about.gitlab.com/images/blogimages/blame.png)\n\nDu musst keine Versionen eines PDF-Dokuments speichern und nicht mühsam versuchen, herauszufinden, wer welche Änderung vorgeschlagen hat – inGitLab wird alles ganz genau dokumentiert.\n\n## Funktion 3: Vorschau des Dokumentinhalts\n\nGitLab bietet Tools, um den Inhalt der Dokumentseite lokal zu generieren, aber du kannst auch eine Vorschau der Dokumentseite direkt aus einem Merge Request heraus teilen. Wenn du eine Idee testen und sie jemandem zeigen möchtest, öffnest du ein Merge Request, generierst eine sogenannte „Review App“ und die geänderte Dokumentseite ist dann unter einer öffentlich zugänglichen URL verfügbar.\n\nDeine Änderungen sind sichtbar, und du kannst sie überarbeiten oder in der aktuellen Form übertragen.\n\n![Ansicht des Buttons, um in einem Merge Request festgehaltene Idee einer anderen Person anzuschauen](https://about.gitlab.com/images/blogimages/view_app.png)\n\n## Funktion 4: Testen inhaltlicher Änderungen\n\nVielleicht verwendest du das Tool eines Drittanbieters, um die Links in deinen Dokumenten zu testen oder um Rechtschreib- und Grammatikregeln zu überprüfen.\n\nWir nutzen ebenfalls Tools von Drittanbietern (Nanoc für Links, Vale für Rechtschreibung und Grammatik), ebenso wie alles andere können auch diese Tools in GitLab und in den Arbeitsablauf der Autor(inn)en integriert werden.\n\nDie jeweilige Autor(in) hat unsere Documentation-as-Code-Tools lokal installiert und kann alles, vom Lesemodus des Dokuments bis zu Korrekturen für Passiv- und Aktivformulierungen, auf dem lokalen Rechner einsehen. Für die Beteiligten, die nicht über diese Werkzeuge verfügen, führen wir bei jeder Übergabe eine Version unserer Tests in einer Pipeline aus. Eine Pipeline ist eine automatisierte Abfolge von Prozessen, die sicherstellt, dass der Code oder die Dokumentation korrekt getestet und validiert wird, bevor sie weitergegeben oder veröffentlicht wird.\n\n![Ausführung von Tests in der Pipeline](https://about.gitlab.com/images/blogimages/lint_error_2.png)\n\nWenn du Entwickler(in) bist und dich nicht für eine Schreibexpert(in) hältst, kann es passieren, dass dein Merge Request aufgrund einer wichtigen Grammatik- oder Branding-Regel in der Pipeline scheitert. \n\nEs gibt eine Liste mit vielen definierten Regeln, die verschiedene Wichtigkeitsstufen haben. Neben einem [Styleguide](https://docs.gitlab.com/ee/development/documentation/styleguide/ \"Styleguide\") und einer [Wortliste](https://docs.gitlab.com/ee/development/documentation/styleguide/word_list.html \"Wortliste\") führen wir auch Tests durch, um sicherzustellen, dass unsere Inhalte den festgelegten Regeln entsprechen.\n\n## Funktion 5: Integration von HTML-Ausgabe und Hosten des Outputs auf GitLab Pages\n\nBei GitLab nutzen wir die CI/CD-Pipeline dann, um die Markdown-Inhalte in HTML zu kompilieren. Anschließend werden sie auf GitLab Pages auf der Website [docs.gitlab.com](https://docs.gitlab.com/ \"GitLab Docs\") gehostet.\n\n![Pipeline-Übersicht](https://about.gitlab.com/images/blogimages/pipeline2.png)\n\nDa die Ausgabe durch eine Pipeline generiert wird, können die Dokumentseiten jederzeit aktualisiert werden. Während das Produkt einmal im Monat veröffentlicht wird, wird die Dokumentation stündlich aktualisiert. Das bedeutet, dass docs.gitlab.com immer die aktuellsten verfügbaren Inhalte enthält, manchmal sogar Informationen vor der offiziellen Veröffentlichung. Da die Planung der Entwicklung und die Implementierung in der Regel öffentlich zugänglich sind, ist die Vorankündigung von Funktionen kein Problem.\n\n## Docs-as-Code für einen besseren Workflow für technische Redakteure\n\nWie du siehst, bietet der Docs-as-Code-Workflow aus vielen Gründen Vorteile. Die Umstellung auf ein einziges Tool für alle Dokumentationsanforderungen kann eine Herausforderung sein, aber GitLab unterstützt den gesamten Autoren-Workflow, unabhängig davon, wer die Inhalte schreibt. \n\nErfahre mehr über das technische Schreiben von Docs-as-Code bei GitLab:\nWenn du mehr über das Mitwirken an unserer Open-Source-Dokumentation erfahren möchtest, schau dir die Anleitung [„Wie man die Dokumente aktualisiert”](https://docs.gitlab.com/ee/development/documentation/workflow.html#how-to-update-the-docs \"Wie man die Dokumente aktualisiert\") an. \n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/ZlabtdA-gZE\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n","insights",[712,713,9],"careers","contributors","2024-10-03",{"slug":716,"featured":6,"template":690},"five-fast-facts-about-docs-as-code-at-gitlab","content:de-de:blog:five-fast-facts-about-docs-as-code-at-gitlab.yml","Five Fast Facts About Docs As Code At Gitlab","de-de/blog/five-fast-facts-about-docs-as-code-at-gitlab.yml","de-de/blog/five-fast-facts-about-docs-as-code-at-gitlab",{"_path":722,"_dir":247,"_draft":6,"_partial":6,"_locale":7,"seo":723,"content":727,"config":736,"_id":738,"_type":14,"title":739,"_source":16,"_file":740,"_stem":741,"_extension":19},"/de-de/blog/how-to-transform-compliance-observation-management-with-gitlab",{"config":724,"title":725,"description":726},{"noIndex":6},"Wie du das Compliance-Beobachtungsmanagement mit GitLab transformierst","Erfahre, wie das Security-Compliance-Team von GitLab das Beobachtungsmanagement mithilfe der DevSecOps-Plattform verbessert hat und dabei Transparenz, Zusammenarbeit und Verantwortlichkeit gesteigert hat.",{"title":728,"description":726,"authors":729,"heroImage":731,"date":732,"body":733,"category":734,"tags":735},"Wie du das Management von Compliance-Beobachtungen mit GitLab transformierst",[730],"Madeline Lake","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749675154/Blog/Hero%20Images/blog-image-template-1800x945__8_.png","2025-07-24","Eine Beobachtung ist ein Compliance-Befund oder eine Schwachstelle, die während der Kontrollüberwachung identifiziert wird. Im Wesentlichen handelt es sich um eine Lücke zwischen Soll und Ist deiner Sicherheitskontrollen. Beobachtungen entstehen aus drei Hauptquellen: Designmängel, bei denen die Kontrolle nicht ordnungsgemäß strukturiert ist. Probleme mit der Betriebseffektivität, bei denen die Kontrolle existiert, aber nicht wie vorgesehen funktioniert. Oder Beweislücken, bei denen erforderliche Dokumentation fehlt.\n\nDiese Beobachtungen entstehen aus unserem vierteljährlichen Kontrollüberwachungsprozess. Dabei bewerten wir systematisch die Effektivität von Sicherheitskontrollen für unsere Zertifizierungen (SOC 2, ISO 27001 usw.). Zusätzlich können Beobachtungen aus externen Audits durch unabhängige Prüfer(innen) resultieren.\n\nBeobachtungsmanagement ist der Prozess, mit dem wir diese Beobachtungen von der Identifizierung über die Behebung bis zum Abschluss verwalten. In diesem Artikel erfährst du, wie das GitLab-Sicherheitsteam die DevSecOps-Plattform nutzt, um Beobachtungen zu verwalten und zu beheben, und welche Effizienzsteigerungen wir dadurch erzielt haben.\n\n## Der GitLab-Beobachtungslebenszyklus: Von der Identifizierung zur Lösung\n\nDer Lebenszyklus einer Beobachtung umfasst den gesamten Prozess von der ersten Identifizierung durch Compliance-Ingenieur(innen) bis zur abgeschlossenen Behebung durch Behebungsverantwortliche. Dieser Lebenszyklus ermöglicht transparente Echtzeit-Statusberichte, die für alle Beteiligten leichter zu verstehen und zu verfolgen sind.\n\nHier sind die Phasen des Beobachtungslebenszyklus:\n\n**1. Identifizierung**\n\n* Compliance-Ingenieur(innen) identifizieren potenzielle Beobachtungen während der vierteljährlichen Überwachung.  \n* Eine erste Validierung erfolgt, um zu bestätigen, dass der Befund eine echte Kontrolllücke darstellt.  \n* Die detaillierte Dokumentation beginnt sofort in einem GitLab-Issue.  \n* Die Grundursache der Beobachtung wird ermittelt und ein Behebungsplan zur Behebung der Grundursache wird erstellt.\n\n**2. Validierung**\n\n* Das Issue wird dem/der entsprechenden Behebungsverantwortlichen zugewiesen (normalerweise eine Teamleitung oder Abteilungsleiter(in)).  \n* Der/die Behebungsverantwortliche überprüft und bestätigt, dass er/sie die Verantwortung versteht und akzeptiert.  \n* Der Behebungsplan wird bei Bedarf gemeinsam überprüft, priorisiert und aktualisiert.\n\n**3. In Bearbeitung**\n\n* Die aktive Behebungsarbeit beginnt mit klaren Meilensteinen und Fristen.  \n* Regelmäßige Updates werden über GitLab-Kommentare und Statusänderungen bereitgestellt.  \n* Die Zusammenarbeit erfolgt transparent, sodass alle Beteiligten den Fortschritt sehen können.\n\n**4. Behoben**\n\n* Der/die Behebungsverantwortliche markiert die Arbeit als abgeschlossen und stellt Nachweise zur Verfügung.  \n* Das Issue geht zur Compliance-Überprüfung zur Validierung über.\n\n**5. Lösung**\n\n* Compliance-Ingenieur(innen) verifizieren, dass die Abschlusskriterien erfüllt sind.  \n* Das Issue wird mit finaler Dokumentation geschlossen.  \n* Erkenntnisse werden für zukünftige Prävention erfasst.\n\n**Alternative Pfade** behandeln blockierte Arbeiten, Risikoakzeptanzentscheidungen und stagnierende Behebungsbemühungen mit entsprechenden Eskalations-Workflows.\n![Beispiel eines Beobachtungslebenszyklus](https://res.cloudinary.com/about-gitlab-com/image/upload/v1753301753/pbvheikwpivuvhzd5ith.png)\n\n\u003Ccenter>\u003Ci>Beispiel eines Beobachtungslebenszyklus\u003C/i>\u003C/center>\n\n## Die Macht der Transparenz in GitLab\n\nEffektives Management von Compliance-Befunden sollte keine Detektivarbeit erfordern. Grundlegende Informationen wie Eigentümerschaft, Status oder Priorität sollten sofort ersichtlich sein. Dennoch erleben die meisten Organisationen folgendes Szenario: Compliance-Teams jagen Updates hinterher. Operative Teams kennen ihre Verantwortlichkeiten nicht. Die Führungsebene hat keine Sichtbarkeit auf tatsächliche Risiken – bis zur Audit-Saison.\n\nDas Security-Compliance-Team bei GitLab stand vor genau diesen Problemen. Unser Team nutzte zunächst ein dediziertes GRC-Tool als zentrale Datenquelle für ausstehende Befunde. Doch wichtige Stakeholder hatten keine Sichtbarkeit. Das Ergebnis: Nur minimale Behebungen fanden statt. Das Team verbrachte seine Zeit mit administrativen Aufgaben, anstatt Behebungsbemühungen zu leiten.\n\nUnsere Lösung: Wir verlagerten das Management direkt in GitLab-Issues innerhalb eines dedizierten Projekts. Dieser Ansatz verwandelt Compliance-Befunde in sichtbare, umsetzbare Arbeitselemente. Sie integrieren sich natürlich in Entwicklungs- und Betriebs-Workflows. Jeder Stakeholder kann sehen, was Aufmerksamkeit benötigt. Teams können bei Behebungsplänen zusammenarbeiten und den Fortschritt in Echtzeit verfolgen.\n\n### Intelligente Organisation durch Labels und Issue Boards\n\nGitLab ermöglicht es Teams, Beobachtungs-Issues in mehrere Organisationsansichten zu kategorisieren. Das Security-Compliance-Team verwendet Folgendes zur Kategorisierung von Beobachtungen:\n\n* **Workflow:** `~workflow::identified`, `~workflow::validated`, `~workflow::in progress`, `~workflow::remediated`  \n* **Abteilung:** `~dept::engineering`, `~dept::security`, `~dept::product`   \n* **Risikoschwere:** `~risk::critical`, `~risk::high`, `~risk::medium`, `~risk::low`  \n* **System:** `~system::gitlab`, `~system::gcp`, `~system::hr-systems`   \n* **Programm:** `~program::soc2`, `~program::iso`, `~program::fedramp` , `~program::pci`\n\nDiese Labels werden dann genutzt, um Issue Boards zu erstellen:\n\n* **Workflow-Boards** visualisieren die Phasen des Beobachtungslebenszyklus.  \n* **Abteilungs-Boards** zeigen die Behebungsarbeitslast jedes Teams.  \n* **Risikobasierte Boards** priorisieren kritische Befunde, die sofortige Aufmerksamkeit erfordern.  \n* **System-Boards** visualisieren Beobachtungen nach System.  \n* **Programm-Boards** verfolgen die zertifizierungsspezifische Beobachtungslösung.\n\nLabels ermöglichen leistungsstarke Filter- und Berichtsfunktionen und unterstützen gleichzeitig automatisierte Workflows durch unsere Triage-Bot-Richtlinien. Weitere Details zu unserer Automatisierungsstrategie findest du im Abschnitt Automatisierung.\n\n## Automatisierung: Intelligenter arbeiten, nicht härter\n\nDie Verwaltung von Dutzenden von Befunden über mehrere Zertifizierungen hinweg erfordert intelligente Automatisierung. Das Security-Compliance-Team nutzt den Triage-Bot – ein Open-Source-Projekt, das in GitLab gehostet wird. Das Triage-Bot-Gem ermöglicht es Projektmanager(inne)n, Issues automatisch zu triagieren. Die Triagierung basiert auf definierten Richtlinien in GitLab-Projekten oder -Gruppen.\n\nInnerhalb des Beobachtungsmanagement-Projekts haben wir Richtlinien geschrieben, um sicherzustellen, dass jedes Issue eine(n) Zugewiesene(n) hat, jedes Issue erforderliche Labels hat, Issues alle 30 Tage aktualisiert werden und blockierte und stagnierende Issues alle 90 Tage angestupst werden. Zusätzlich wird wöchentlich ein Zusammenfassungs-Issue erstellt, um alle Issues zusammenzufassen, die nicht unseren definierten Richtlinien entsprechen. Dies ermöglicht es Teammitgliedern, Issues effizient zu überwachen und weniger Zeit für administrative Aufgaben aufzuwenden.\n\n## Erfolgsmessung: Schlüsselmetriken und Berichterstattung\n\nGitLabs Roh-Issue-Daten lassen sich in umsetzbare Erkenntnisse umwandeln. Organisationen können aussagekräftige Insights aus verschiedenen Datenquellen extrahieren: Issue-Erstellungsdatum, Abschlussdatum, letztes Update und Labels. Die folgenden Metriken bieten einen umfassenden Überblick über die Effektivität deines Compliance-Managements:\n\n**Analyse der Lösungseffizienz:** Durchschnittliche Zeit von der Identifizierung bis zur Lösung nach Abteilung und Schweregrad.\n\nVerfolge Issue-Erstellungs- versus Abschlussdaten über Abteilungen und Schweregrade hinweg. Das identifiziert Engpässe und misst die Leistung gegen SLAs. So erkennst du, welche Teams bei schnellen Reaktionen hervorragend sind. Und welche zusätzliche Ressourcen oder Prozessverbesserungen benötigen.\n\n**Echtzeit-Risikobewertung:** Aktuelles Risikoprofil basierend auf offenen kritischen und hochriskanten Befunden.\n\nNutze Risikostufen-Labels für dynamische Visualisierungen der aktuellen Risikoexposition. Das bietet der Führungsebene sofortiges Verständnis: Welche kritischen Befunde erfordern dringend Aufmerksamkeit.\n\n**Strategische Ressourcenzuweisung:** Risikoverteilung auf Abteilungsebene für gezielte Verbesserungen.\n\nIdentifiziere, welche Abteilungen für Befunde mit dem höchsten Risiko verantwortlich sind. So priorisierst du Ressourcen, Aufsicht und Projekte richtig. Dieser datengesteuerte Ansatz fokussiert Verbesserungen dort, wo sie maximale Wirkung haben.\n\n**Überwachung der Compliance-Bereitschaft:** Zertifizierungsspezifische Beobachtungszahlen und Lösungsraten\n\nNutze Zertifizierungs-Labels, um die Audit-Bereitschaft zu bewerten und den Fortschritt bei Compliance-Zielen zu verfolgen. Diese Metrik bietet eine Frühwarnung vor potenziellen Zertifizierungsrisiken und validiert Behebungsbemühungen.\n\n**Verantwortlichkeitsverfolgung:** Überfällige Behebungen\n\nÜberwache die SLA-Einhaltung, um sicherzustellen, dass Beobachtungen rechtzeitig Aufmerksamkeit erhalten. Diese Metrik hebt systemische Verzögerungen hervor und ermöglicht proaktive Intervention, bevor kleine Probleme zu großen Problemen werden.\n\n**Engagement-Gesundheitsprüfung:** Beobachtungsaktualität\n\nVerfolge die jüngste Aktivität (Updates innerhalb von 30 Tagen), um sicherzustellen, dass Beobachtungen aktiv verwaltet und nicht vergessen werden. Diese Metrik identifiziert stagnierende Issues, die möglicherweise eine Eskalation oder Neuzuweisung erfordern.\n\n## Fortgeschrittene Strategien: Beobachtungsmanagement weiter vorantreiben\n\nHier ist, was du tun kannst, um die Wirkung des Beobachtungsmanagements in deiner Organisation zu vertiefen.\n\n**Integration mit Sicherheitstools**\n\nModernes Beobachtungsmanagement geht über manuelle Verfolgung hinaus, indem es sich mit deiner bestehenden Sicherheitsinfrastruktur verbindet. Organisationen können Schwachstellenscanner und Sicherheitsüberwachungstools konfigurieren, um automatisch Beobachtungs-Issues zu generieren, wodurch manuelle Dateneingabe eliminiert und umfassende Abdeckung sichergestellt wird.\n\n**Prädiktive Analytik anwenden**\n\nModernes Compliance-Management geht über manuelle Verfolgung hinaus. Es verbindet sich mit deiner bestehenden Sicherheitsinfrastruktur. Organisationen können Schwachstellenscanner und Sicherheitsüberwachungstools konfigurieren. Diese generieren automatisch Issues für Compliance-Befunde. Das eliminiert manuelle Dateneingabe und stellt umfassende Abdeckung sicher..\n\n**Anpassung für Stakeholder**\n\nEffektives Beobachtungsmanagement erkennt an, dass verschiedene Rollen unterschiedliche Perspektiven auf dieselben Daten erfordern. Rollenbasierte Dashboards liefern maßgeschneiderte Ansichten für Führungskräfte, die hochrangige Risikozusammenfassungen suchen, Abteilungsleiter(innen), die die Teamleistung verfolgen, und einzelne Mitwirkende, die ihre zugewiesenen Beobachtungen verwalten. Automatisierte Berichtssysteme können konfiguriert werden, um verschiedenen Zielgruppenbedürfnissen und Kommunikationspräferenzen zu entsprechen, von detaillierten technischen Berichten bis zu Executive Briefings. Self-Service-Analysefähigkeiten befähigen Stakeholder, Ad-hoc-Analysen durchzuführen und benutzerdefinierte Erkenntnisse zu generieren, ohne technisches Fachwissen oder Support zu benötigen.\n\n## Von bloßer Compliance zu operativer Exzellenz\n\nGitLabs Ansatz zum Compliance-Management stellt mehr als einen Toolwechsel dar. Es ist eine grundlegende Verschiebung: von reaktiver Compliance zu proaktiver Risikominderung. Das Aufbrechen von Silos zwischen Compliance-Teams und operativen Stakeholdern bringt beispiellose Transparenz. Gleichzeitig verbessern sich die Behebungsergebnisse dramatisch.\n\nDie Ergebnisse sind messbar: Schnellere Lösungen durch transparente Verantwortlichkeit. Aktive Stakeholder-Zusammenarbeit statt widerwilliger Teilnahme. Kontinuierliche Audit-Bereitschaft statt periodischer Hektik. Automatisierte Workflows befreien Compliance-Fachleute für strategische Arbeit. Reichhaltige Daten ermöglichen prädiktive Analysen. Der Fokus verschiebt sich von reaktiver Brandbekämpfung zu proaktiver Prävention.\n\nAm wichtigsten ist, dass dieser Ansatz Compliance von einer Last zu einem strategischen Befähiger erhebt. Wenn Beobachtungen zu sichtbaren, verfolgbaren Arbeitselementen werden, die in operative Workflows integriert sind, entwickeln Organisationen eine stärkere Sicherheitskultur und dauerhafte Verbesserungen, die über jeden einzelnen Audit-Zyklus hinausgehen. Das Ergebnis ist nicht nur regulatorische Compliance. Es ist organisatorische Resilienz und Wettbewerbsvorteil durch überlegenes Risikomanagement.\n\n> Möchtest du mehr über GitLabs Sicherheits-Compliance-Praktiken erfahren? Schau dir unser [Security Compliance Handbook](https://handbook.gitlab.com/handbook/security/security-assurance/security-compliance/) für weitere Einblicke und Implementierungsanleitungen an.","security",[734,9],{"featured":6,"template":690,"slug":737},"how-to-transform-compliance-observation-management-with-gitlab","content:de-de:blog:how-to-transform-compliance-observation-management-with-gitlab.yml","How To Transform Compliance Observation Management With Gitlab","de-de/blog/how-to-transform-compliance-observation-management-with-gitlab.yml","de-de/blog/how-to-transform-compliance-observation-management-with-gitlab",{"_path":743,"_dir":247,"_draft":6,"_partial":6,"_locale":7,"seo":744,"content":750,"config":762,"_id":764,"_type":14,"title":765,"_source":16,"_file":766,"_stem":767,"_extension":19},"/de-de/blog/demystifying-ci-cd-variables",{"ogTitle":745,"schema":746,"ogImage":747,"ogDescription":748,"ogSiteName":673,"noIndex":6,"ogType":674,"ogUrl":749,"title":745,"canonicalUrls":749,"description":748},"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":747,"body":751,"authors":752,"updatedDate":754,"date":755,"title":745,"tags":756,"description":760,"category":761},"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",[753],"Veethika Mishra","2025-01-28","2021-04-09",[757,687,9,758,109,759],"CD","CI","tutorial","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":763,"featured":6,"template":690},"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",1,[666,695,721],1758326276897]