[{"data":1,"prerenderedAt":816},["ShallowReactive",2],{"/en-us/blog/tags/testing/":3,"navigation-de-de":19,"banner-de-de":440,"footer-de-de":453,"testing-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/testing","tags",false,"",{"tag":9,"tagSlug":9},"testing",{"template":11},"BlogTag","content:en-us:blog:tags:testing.yml","yaml","Testing","content","en-us/blog/tags/testing.yml","en-us/blog/tags/testing","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":795,"totalPagesCount":814,"initialPosts":815},[664,691,711,731,752,772],{"_path":665,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":666,"content":674,"config":684,"_id":687,"_type":13,"title":688,"_source":15,"_file":689,"_stem":690,"_extension":18},"/de-de/blog/automating-with-gitlab-duo-part-2-complex-testing",{"title":667,"description":668,"ogTitle":667,"ogDescription":668,"noIndex":6,"ogImage":669,"ogUrl":670,"ogSiteName":671,"ogType":672,"canonicalUrls":670,"schema":673},"Automatisierung mit GitLab Duo, Teil 2: Komplexes Testen","Hier erfährst du, wie das GitLab-Team mit Hilfe der KI-Funktionen von GitLab Duo komplexere Testsituationen bewältigt und dabei auch sicherstellt, dass die Code-Tests den Standards entsprechen.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099243/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%284%29_3LZkiDjHLjhqEkvOvBsVKp_1750099243011.png","https://about.gitlab.com/blog/automating-with-gitlab-duo-part-2-complex-testing","https://about.gitlab.com","article","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Automatisierung mit GitLab Duo, Teil 2: Komplexes Testen\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Byron Boots\"}],\n        \"datePublished\": \"2024-12-10\",\n      }\n                  ",{"title":667,"description":668,"authors":675,"heroImage":669,"date":677,"body":678,"category":679,"tags":680,"updatedDate":683},[676],"Byron Boots","2024-12-10","Im ersten Teil unserer dreiteiligen Serie über die [Testerstellung mit GitLab Duo](https://about.gitlab.com/de-de/blog/automating-with-gitlab-duo-part-1-generating-tests/) ging es darum, wie man Code-Tests automatisieren kann. Jetzt werden wir die Erfahrungen teilen, die wir beim Einsatz von KI für die Testgenerierung gemacht haben.\n\n## Herausforderungen und wie wir sie gemeistert haben\n\nInsgesamt waren wir mit den Ergebnissen zufrieden, die wir mit [GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/) bei der Testgenerierung für unseren Code erzielt haben. Wie bei jeder Sprachgenerierung waren in einigen Fällen kleinere Anpassungen erforderlich, z. B. die Korrektur von Importpfaden oder die Bearbeitung von Inhalten in Datensätzen. Bei den komplexeren Fällen mussten wir berücksichtigen, dass KI-Lösungen oft der Kontext fehlt. Hier erfährst du, wie wir die komplexeren Testsituationen mit GitLab Duo gemeistert haben.\n\n### Aktualisieren bestehender Testfälle\n\nWie so oft bei der Entwicklung eines Softwareprodukts stießen wir auf Fälle, in denen wir bestehende Tests aktualisieren mussten. Anstatt eine komplette Testsuite für ein häufiges Problem manuell anzupassen, nutzten wir die Fähigkeiten des GitLab-Duo-Chat-Fensters in VS Code voll aus. Um beispielsweise Tests zu überarbeiten, nutzten wir den Chat-Prompt „Please update the provided tests to use unittest rather than pytest“ („Aktualisiere die bereitgestellten Tests so, dass sie unittest und nicht pytest verwenden“) und fügten dann die Tests ein, die GitLab Duo aktualisieren sollte.\n\n![Automatisierte Testgenerierung](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099252/Blog/Content%20Images/Blog/Content%20Images/image5_aHR0cHM6_1750099252303.png)\n\n\u003Cbr>\u003C/br>\n\n![Chat-Prompt zur Verwendung von unittest anstelle von pytest](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099252/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750099252304.png)\n\n**Hinweis:** Wir haben die Empfehlungen von GitLab Duo kopiert und in unseren Code eingefügt.\n\n### Erstellen von Tests für Legacy-Code\n\nDas Erstellen von Tests für älteren Code, von dem wir wussten, dass er funktioniert, war eine weitere Herausforderung. In solchen Fällen war es sinnvoll, neben den fehlgeschlagenen Tests auch Fehlerschnipsel bereitzustellen und GitLab Duo zu bitten, neue Tests zu erstellen. Wir haben die Fehler aus dem Terminalfenster in den Chat kopiert und mit der Aufforderung „Please explain and fix this failing test“ („Erkläre und behebe diesen fehlgeschlagenen Test“) oder ähnlichen Prompts eine Zusammenfassung der Probleme mit dem Test ausgeben lassen sowie einen neuen Test erstellt, der das Problem behebt. Wir mussten feststellen, dass dies manchmal mehrere Überarbeitungsrunden erforderte, wenn neue Testfehler auftraten. Die Effizienz von GitLab Duo bei der Erstellung verschiedener überarbeiteter Lösungen war jedoch schnell und wirkte sich positiv auf die Effizienz des Teams und der Entwickler(innen) aus.\n\n### Herausforderungen mit komplexem oder abstraktem Code\n\nIn anderen Fällen führte die Modularisierung oder die Komplexität unseres Codes zu Abweichungen bei den Ergebnissen von GitLab Duo. Bei der Erstellung von Tests erzeugte GitLab Duo beispielsweise manchmal eine Reihe bestandener und fehlgeschlagener Tests, was auf unterschiedliche Testansätze zurückzuführen war (z. B. die Verwendung von Simulationen und die Objekte, die simuliert wurden). Wir gaben GitLab Duo ein eigenes Beispiel für einen bestandenen Test und forderten es auf, die einzelnen Tests nacheinander so zu ändern, dass sie dem Stil der bestandenen Tests entsprechen, um die Konsistenz zu wahren. Außerdem stellten wir GitLab Duo eine Datei mit funktionierenden Tests für ein ähnliches Objekt oder eine ähnliche Aufgabe zur Verfügung, damit es die Struktur nachbilden konnte.\n\n### Sicherstellen, dass der generierte Code unseren Standards entspricht\n\nWährend der Entwicklung eines Python-Moduls generierte GitLab Duo viele Tests mit Simulationen, die oft überarbeitet werden mussten, insbesondere im Hinblick auf die Standardisierung der Namensgebung. In solchen Fällen konnten wir GitLab Duo Chat nutzen, um die Tests zu überarbeiten und Anweisungen zu geben, welche Testkomponenten zu aktualisieren waren. GitLab Duo zu diesen Änderungen aufzufordern, war wesentlich schneller als die Überarbeitung einzelner Tests, wie wir es zuvor getan hatten.\n\n### Nicht abgedeckte Testfälle\n\nGitLab Duo erstellte Tests für zusätzliche Testfälle, die das Team zuvor nicht berücksichtigt hatte, und erhöhte so die Abdeckung. So konnten wir dank GitLab Duo diese Grenzfälle schnell und effizient angehen und die Testabdeckung erweitern, was für unser Team einen wichtigen Mehrwert darstellt, um schneller ein robustes Produkt zu entwickeln.\n\n## Was wir gelernt haben\n\nDie folgenden Erkenntnisse waren wichtig für unseren Erfolg mit GitLab Duo:\n\n* **Schnell und effizient für eine schnelle Entwicklung und Iteration –** Die Rolle von GitLab Duo bei der Erstellung von automatisierten Tests war für unser Team ein wichtiger Beschleuniger bei der Entwicklung und ermöglichte es uns, schneller und mit größerem Vertrauen in unsere Änderungen zu arbeiten.\n* **Es ist wichtig, geeignete Prompts zu verwenden –** Bei der Verwendung von GitLab Duo für unseren Anwendungsfall sind wir auf ein wichtiges Thema für die Optimierung des Machine Learning gestoßen: das Prompt-Engineering. Manchmal mussten wir nur wenige Schlüsselwörter in unserer Frage ändern, um die ideale Antwort zu generieren.\n* **Wir müssen die zugrunde liegenden Frameworks und den Code verstehen –** Bei jeglichem KI-generierten Code, der in ein Produkt einfließt, selbst wenn es sich nur um Tests handelt, ist es wichtig, dass wir verstehen, wie der Code funktioniert, damit wir ihn angemessen debuggen und Änderungen beantragen können.\n* **Wir müssen den gewünschten Endzustand und die Standards kennen –** Ähnlich wie bei der Einhaltung von Programmierstandards für die Formatierung und die Verwendung von Bibliotheken bei der Entwicklung ohne KI ist es wichtig, die Übersicht darüber zu behalten, wie die beabsichtigten Ergebnisse aussehen sollen und welche Standards beim Einsatz von KI eingehalten werden müssen. GitLab Duo braucht den Kontext, um Code-Standards zu verstehen. Deshalb ist es wichtig, dass die Teammitglieder, die GitLab Duo nutzen, die Ergebnisse angemessen überwachen, um sicherzustellen, dass die Qualität und andere Erwartungen erfüllt werden.\n* **GitLab Duo ist kein Ersatz für alle Tests –** Auch wenn wir GitLab Duo in großem Umfang für die Erstellung automatisierter Tests nutzen, ersetzt es nicht unsere anderen Tests und die menschliche Aufsicht. Funktionale Tests, Integrationstests und andere Tests haben nach wie vor einen wichtigen Platz im Qualitätssicherungsprozess und im gesamten Software-Entwicklungsprozess.\n\nIn unserem nächsten 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.","ai-ml",[681,9,682],"AI/ML","DevSecOps platform","2025-01-14",{"slug":685,"featured":6,"template":686},"automating-with-gitlab-duo-part-2-complex-testing","BlogPost","content:de-de:blog:automating-with-gitlab-duo-part-2-complex-testing.yml","Automating With Gitlab Duo Part 2 Complex Testing","de-de/blog/automating-with-gitlab-duo-part-2-complex-testing.yml","de-de/blog/automating-with-gitlab-duo-part-2-complex-testing",{"_path":692,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":693,"content":699,"config":705,"_id":707,"_type":13,"title":708,"_source":15,"_file":709,"_stem":710,"_extension":18},"/de-de/blog/automating-with-gitlab-duo-part-3-validating-testing",{"title":694,"description":695,"ogTitle":694,"ogDescription":695,"noIndex":6,"ogImage":696,"ogUrl":697,"ogSiteName":671,"ogType":672,"canonicalUrls":697,"schema":698},"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":694,"description":695,"authors":700,"heroImage":696,"date":701,"body":702,"category":679,"tags":703},[676],"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",[681,9,682,704],"features",{"slug":706,"featured":6,"template":686},"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":712,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":713,"config":716,"content":718,"_id":727,"_type":13,"title":728,"_source":15,"_file":729,"_stem":730,"_extension":18},"/de-de/blog/comprehensive-guide-to-gitlab-dast",{"title":714,"description":715},"Systematische Anwendungssicherheit mit GitLab DAST: Compliance-Framework für deutsche Unternehmen","Wie Dynamic Application Security Testing (DAST) deutschen Unternehmen bei der systematischen Implementierung von Sicherheits-Governance und Compliance-Automation hilft.",{"slug":717,"featured":90,"template":686},"comprehensive-guide-to-gitlab-dast",{"title":714,"description":715,"authors":719,"heroImage":721,"date":722,"category":723,"tags":724,"body":726},[720],"Fernando Diaz","https://res.cloudinary.com/about-gitlab-com/image/upload/v1756122536/akivvcnafog9c4dhhzkp.png","2025-09-17","security",[723,725,9],"tutorial","Moderne Unternehmen nutzen webbasierte Plattformen für Kundeninteraktionen, Finanztransaktionen und Geschäftsprozesse. Die digitale Transformation erweitert die Angriffsfläche dramatisch - Webanwendungen werden zu Hauptzielen für Cyberkriminelle.\n\nStatic Code Analysis erkennt nur Schwachstellen im Quellcode. Runtime-Sicherheitsprobleme bleiben verborgen, wenn Anwendungen mit realen Umgebungen, Drittanbieter-Services und Benutzer-Workflows interagieren. Dynamic Application Security Testing ([DAST](https://docs.gitlab.com/user/application_security/dast/)) schließt diese Lücke. GitLab DAST automatisiert Penetrationstests in CI/CD-Pipelines und validiert Sicherheit kontinuierlich ohne Workflow-Unterbrechung.\n\n## Warum DAST für deutsche Unternehmen?\n\nDAST testet Anwendungen in ihrer Betriebsumgebung und identifiziert Schwachstellen, die statische Analysen übersehen. GitLab DAST integriert sich in Shift-Left Security-Workflows und stärkt Compliance und Risikomanagement.\n\n### Runtime-Schwachstellen-Erkennung\n\nDAST identifiziert Sicherheitsschwachstellen in laufenden Anwendungen. DAST-Scanner interagieren mit Live-Anwendungen wie externe Angreifer und decken Probleme auf wie:\n\n- **Authentifizierungs- und Session-Fehler**, die unbefugten Zugang ermöglichen\n- **Schwachstellen bei der Eingabevalidierung**, einschließlich SQL-Injection, Cross-Site-Scripting (XSS) und Command-Injection\n- **Konfigurationsschwächen** in Webservern, Datenbanken und Anwendungs-Frameworks\n- **Fehler in der Geschäftslogik** aus Benutzerinteraktionen\n- **API-Sicherheitsprobleme**, einschließlich unsachgemäßer Authentifizierung, Autorisierung und Datenexposition\n\nDAST ergänzt andere Sicherheitstest-Ansätze für umfassende Anwendungssicherheits-Abdeckung. In Kombination mit Static Application Security Testing ([SAST](https://docs.gitlab.com/user/application_security/sast/)), Software Composition Analysis ([SCA](https://docs.gitlab.com/user/application_security/dependency_scanning/)), manuellen Penetrationstests und [vielen anderen Scanner-Typen](https://about.gitlab.com/solutions/application-security-testing/) füllt DAST kritische Lücken in der Sicherheitsvalidierung:\n\n- **Externe Testperspektive**, die reale Angriffsszenarien nachahmt\n- **Umgebungsspezifische Tests**, die Sicherheit in tatsächlichen Produktionsumgebungen validieren\n- **Drittanbieter-Komponenten-Tests**, einschließlich APIs, Bibliotheken und externe Services\n- **Konfigurationsvalidierung** über den gesamten Anwendungsstack hinweg\n\n### Nahtlose Shift-Left Security Integration\n\nGitLab DAST integriert sich in CI/CD-Pipelines und identifiziert Sicherheitsprobleme früh im Entwicklungszyklus. Dieser Shift-Left-Ansatz bietet Vorteile:\n\n- **Kostensenkung** – Schwachstellen während der Entwicklung zu beheben kostet 10 bis 100 Mal weniger als Korrekturen in der Produktion.\n- **Schnellere Markteinführung** – Tests eliminieren Engpässe durch manuelle Security-Reviews.\n- **Entwickler-Stärkung** – Sofortiges Feedback baut Sicherheitsbewusstsein auf.\n\n### Compliance und Risikomanagement\n\nRegulierungsrahmen und Industriestandards fordern regelmäßige Sicherheitstests von Webanwendungen. DAST erfüllt Compliance-Anforderungen für Standards wie:\n\n- **PCI DSS** für Anwendungen, die Zahlungskartensdaten verarbeiten\n- **SOC 2** Sicherheitskontrollen für Service-Organisationen\n- **ISO 27001** Informationssicherheits-Management-Anforderungen\n\nGitLab DAST automatisiert Tests konsistent und wiederholbar. Auditoren vertrauen den Ergebnissen, während Berichte die nötige Dokumentation für Compliance-Validierung liefern.\n\n## DAST implementieren\n\nVor der Implementierung von GitLab DAST stellen Sie sicher, dass Ihre Umgebung folgende Anforderungen erfüllt:\n\n- **GitLab Version und Ultimate-Abonnement** – DAST ist in [GitLab Ultimate](https://about.gitlab.com/pricing/ultimate/) verfügbar und benötigt GitLab 13.4 oder später für volle Funktionalität; jedoch wird die [neueste Version](https://about.gitlab.com/releases/categories/releases/) empfohlen.\n- **Anwendungszugänglichkeit** – Ihre Anwendung muss über HTTP/HTTPS mit einer öffentlich erreichbaren URL oder innerhalb des Netzwerks Ihres GitLab Runners zugänglich sein.\n- **Authentifizierung-Setup** – Falls Ihre Anwendung Authentifizierung erfordert, bereiten Sie Test-Credentials vor oder konfigurieren Sie Authentifizierungs-Bypass-Mechanismen für Sicherheitstests.\n\n### Systematische DAST-Integration: Drei Konfigurationsebenen\n\n**Grundkonfiguration für sofortigen Start:**\nDie einfachste DAST-Integration erfolgt durch Template-Einbindung in Ihre [`.gitlab-ci.yml`](https://docs.gitlab.com/ci/#step-1-create-a-gitlab-ciyml-file) Datei:\n\n```yaml\ninclude:\n  - template: DAST.gitlab-ci.yml\n\nvariables:\n  DAST_WEBSITE: \"https://your-application.example.com\"\n```\n\nDiese Basiskonfiguration wird:\n- Einen DAST-Scan gegen Ihre spezifizierte Website ausführen\n- Einen Sicherheitsbericht in GitLabs Security Dashboard generieren\n- Die Pipeline fehlschlagen lassen, falls hochschwere Schwachstellen erkannt werden\n- Scan-Ergebnisse als Pipeline-Artefakte speichern\n\n**Systematische Pipeline-Integration:**\nFür umfassende CI/CD-Vorteile können Sie zuerst die Anwendung deployen und DAST so konfigurieren, dass es nur nach erfolgtem Deployment läuft:\n\n```yaml\nstages:\n  - build\n  - deploy\n  - dast\n\ninclude:\n  - template: Security/DAST.gitlab-ci.yml\n\n# Konfiguriert DAST für aktive Scans auf Nicht-Main-Branches und passive Scans auf Main-Branch\ndast:\n  stage: dast\n  rules:\n    - if: $CI_COMMIT_REF_NAME == $CI_DEFAULT_BRANCH\n      variables:\n        DAST_FULL_SCAN: \"false\"\n    - if: $CI_COMMIT_REF_NAME != $CI_DEFAULT_BRANCH\n      variables:\n        DAST_FULL_SCAN: \"true\"\n  dependencies:\n    - deploy\n```\n\n### Passive vs. Active Scanning verstehen\n\nGitLab DAST verwendet zwei unterschiedliche Scanning-Methodologien (passiv und aktiv), die jeweils verschiedene Sicherheitstest-Bedürfnisse erfüllen.\n\n**Passive Scans** analysieren Server-Antworten ohne das Senden potenziell schädlicher Anfragen:\n- Untersuchen HTTP-Headers, Cookies und Antwortinhalte auf Sicherheits-Fehlkonfigurationen\n- Identifizieren Information-Disclosure-Schwachstellen wie exponierte Server-Versionen\n- Erkennen fehlende Sicherheits-Headers (CSP, HSTS, X-Frame-Options)\n- Analysieren SSL/TLS-Konfiguration und Zertifikatsprobleme\n\n**Active Scans** senden gestaltete Anfragen, die Schwachstellen auslösen sollen:\n- Testen auf Injection-Schwachstellen (SQL-Injection, XSS, Command-Injection)\n- Versuchen Authentifizierungs- und Autorisierungs-Fehler auszunutzen\n- Validieren Input-Sanitization und Output-Encoding\n- Testen auf Business-Logic-Schwachstellen\n\n**Hinweis:** Der DAST-Scanner ist standardmäßig auf passiv eingestellt.\n\n### Authentifizierungs-Konfiguration\n\n**Enterprise-Authentifizierung für vollständige Abdeckung:**\nDAST benötigt Authentifizierungs-Konfiguration für umfassende Sicherheitsabdeckung:\n\n```yaml\nvariables:\n  DAST_AUTH_USERNAME: \"admin@tanuki.local\"\n  DAST_AUTH_PASSWORD: \"admin123\"\n  DAST_AUTH_USERNAME_FIELD: \"css:input[id=email]\"\n  DAST_AUTH_PASSWORD_FIELD: \"css:input[id=password]\"\n  DAST_AUTH_SUBMIT_FIELD: \"css:button[id=loginButton]\"\n  DAST_AUTH_REPORT: \"true\"\n  DAST_REQUEST_COOKIES: \"welcomebanner_status:dismiss\"\n```\n\nVerfügbare Authentifizierungs-Optionen:\n- Einstufige Login-Formulare\n- Mehrstufige Login-Formulare\n- Authentifizierung zu URLs außerhalb des Zielbereichs\n\n## Ergebnisse in Merge Requests anzeigen\n\nGitLabs DAST integriert Sicherheits-Scanning nahtlos in Ihren Entwicklungsworkflow durch direkte Anzeige der Ergebnisse in Merge Requests. Diese umfassen umfassende Schwachstellen-Daten, die Entwicklern helfen, Sicherheitsprobleme vor der Integration zu identifizieren und zu beheben.\n\n### Schwachstellen-Details\n* Schwachstellen-Name und -Typ (z.B. SQL-Injection, XSS, CSRF)\n* Schweregrad (Critical, High, Medium, Low, Info)\n* CVSS-Score wenn anwendbar\n* Common Weakness Enumeration (CWE) Identifier\n* Vertrauensniveau des Befunds\n\n### Standort-Informationen\n* URL/Endpoint, wo die Schwachstelle erkannt wurde\n* Verwendete HTTP-Methode (GET, POST, etc.)\n* Request/Response-Details der verwundbaren Interaktion\n* Parameter-Namen, die verwundbar sind\n* Nachweis der Schwachstelle\n\n## Systematische Schwachstellen-Governance\n\nSchwachstellen im Default-Branch verwalten Sie über den GitLab Vulnerability Report - ein zentralisiertes Dashboard, das alle Sicherheitsbefunde über Ihr Projekt oder Organisation zeigt. Diese Ansicht sammelt alle Sicherheitstest-Ergebnisse und bietet Filter- und Sortier-Funktionen, um Behebungsmaßnahmen zu priorisieren.\n\nDie Vulnerability-Seite bietet umfassende Schwachstellen-Daten. Von hier aus können Sie Schwachstellen durch Status-Zuweisung triagieren:\n\n* Needs triage (Standard)\n* Confirmed\n* Dismissed (Acceptable risk, False positive, Mitigating control, Used in tests, Not applicable)\n* Resolved\n\nWenn ein Schwachstellen-Status geändert wird, enthält das Audit-Log eine Notiz darüber, wer es geändert hat, wann es geändert wurde und den Grund für die Änderung. Dieses umfassende System ermöglicht Sicherheitsteams effiziente Priorisierung, Tracking und Management von Schwachstellen während ihres gesamten Lebenszyklus.\n\n## On-Demand und geplante DAST-Scans\n\nGitLab bietet flexible Scanning-Optionen über Standard-CI/CD-Pipeline-Integration hinaus durch On-Demand und geplante DAST-Scans. On-Demand-Scans ermöglichen Sicherheitsteams und Entwicklern, DAST-Tests manuell bei Bedarf zu initiieren, ohne auf Code-Änderungen oder Pipeline-Trigger zu warten.\n\nOn-Demand-Scans können mit benutzerdefinierten Parametern, Ziel-URLs und Scanning-Profilen konfiguriert werden. Geplante DAST-Scans bieten automatisierte, zeitbasierte Sicherheitstests unabhängig vom Entwicklungsworkflow.\n\n## DAST in Compliance-Workflows\n\nGitLabs Security-Policy-Framework ermöglicht Organisationen die Durchsetzung konsistenter Sicherheitsstandards über alle Projekte hinweg. Sicherheitsrichtlinien ermöglichen zentrale Governance von DAST-Scanning-Anforderungen.\n\n**Scan/Pipeline Execution Policies** können konfiguriert werden, um DAST-Scans automatisch basierend auf spezifischen Bedingungen auszulösen. **Merge Request Approval Policies** bieten eine zusätzliche Sicherheits-Governance-Ebene durch erzwungene menschliche Review für Code-Änderungen, die Sicherheit beeinträchtigen könnten.\n\nFür Compliance bietet GitLab [Security Inventory](https://docs.gitlab.com/user/application_security/security_inventory/) und [Compliance Center](https://docs.gitlab.com/user/compliance/compliance_center/), die Ihnen ermöglichen zu überwachen, ob DAST in Ihrer Umgebung läuft und wo es erforderlich ist.\n\n## Zusammenfassung\n\nGitLab DAST stellt eine mächtige Lösung für die Integration dynamischer Sicherheitstests in moderne Entwicklungsworkflows dar. Durch DAST-Implementierung in Ihrer CI/CD-Pipeline gewinnt Ihr Team die Fähigkeit, Runtime-Schwachstellen automatisch zu erkennen, Compliance mit Sicherheitsstandards aufrechtzuerhalten und sicherere Anwendungen ohne Geschwindigkeitseinbußen zu erstellen.\n\nDer Schlüssel zur erfolgreichen DAST-Implementierung liegt darin, mit Grundkonfiguration zu beginnen und schrittweise zu sophistizierteren Scanning-Profilen entsprechend Ihrer Sicherheits-Reife zu expandieren. Beginnen Sie mit einfachem Website-Scanning, fügen Sie dann progressiv Authentifizierung, Custom Exclusions und erweiterte Berichte hinzu.\n\nDenken Sie daran, dass DAST am effektivsten ist, wenn es mit anderen Sicherheitstest-Ansätzen kombiniert wird. Verwenden Sie es neben statischer Analyse, Dependency-Scanning und manuellen Security-Reviews für eine umfassende Sicherheitstest-Strategie.\n\n> **Für detaillierte Implementierungsschritte, Authentifizierungs-Konfiguration und technische Setup-Anleitungen siehe den [umfassenden englischen Implementierungsguide](https://about.gitlab.com/blog/comprehensive-guide-to-gitlab-dast/).**\n","content:de-de:blog:comprehensive-guide-to-gitlab-dast.yml","Comprehensive Guide To Gitlab Dast","de-de/blog/comprehensive-guide-to-gitlab-dast.yml","de-de/blog/comprehensive-guide-to-gitlab-dast",{"_path":732,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":733,"content":736,"config":746,"_id":748,"_type":13,"title":749,"_source":15,"_file":750,"_stem":751,"_extension":18},"/de-de/blog/enhance-application-quality-with-ai-powered-test-generation",{"noIndex":6,"title":734,"description":735},"Anwendungsqualität mit KI-gestützter Testgenerierung verbessern","Erfahre, wie GitLab Duo mit Amazon Q den QA-Prozess durch automatische Generierung umfassender Unit-Tests verbessert.",{"title":734,"description":735,"authors":737,"heroImage":739,"date":740,"body":741,"category":679,"tags":742},[738],"Cesar Saavedra","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749659604/Blog/Hero%20Images/Screenshot_2024-11-27_at_4.55.28_PM.png","2025-07-03","Du weißt, wie entscheidend die Anwendungsqualität für deine Kund(inn)en und deinen Ruf ist. Allerdings kann es sich wie ein ständiger Kampf anfühlen, diese Qualität durch umfassende Tests sicherzustellen. Du hast es mit zeitaufwendigen manuellen Prozessen zu tun, inkonsistenter Testabdeckung im Team und diesen lästigen Problemen, die irgendwie durchrutschen. Es ist frustrierend, wenn deine Bewertung sinkt, weil die Qualitätssicherung eher zu einem Engpass als zu einem Schutzschild wird.\n\nHier kann [GitLab Duo mit Amazon Q](https://about.gitlab.com/de-de/blog/gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws/), das agentische KI im gesamten Softwareentwicklungslebenszyklus für AWS-Kund(inn)en bereitstellt, deinen QA-Prozess transformieren. Diese KI-gestützte Funktion kann automatisch umfassende Unit-Tests für deinen Code generieren und deinen Qualitätssicherungs-Workflow dramatisch beschleunigen. Anstatt Stunden damit zu verbringen, Tests manuell zu schreiben, kannst du die KI deinen Code analysieren und Tests erstellen lassen, die optimale Abdeckung und konsistente Qualität über deine gesamte Anwendung hinweg gewährleisten.\n\n## Wie GitLab Duo mit Amazon Q funktioniert\n\nWie funktioniert das also? Lass uns gemeinsam durch den Prozess gehen.\nWenn du an einem neuen Feature arbeitest, beginnst du damit, die Java-Klasse auszuwählen, die du über einen Merge Request zu deinem Projekt hinzugefügt hast. Du navigierst einfach zu deinem Merge Request und klickst auf den Tab „Änderungen\", um den neuen Code zu sehen, den du hinzugefügt hast.\n\nAls Nächstes rufst du Amazon Q auf, indem du einen Quick-Action-Befehl eingibst. Alles, was du tun musst, ist `/q test` in das Issue-Kommentarfeld einzugeben. So einfach ist das – nur ein Schrägstrich, der Buchstabe „q\" und das Wort „test\".\n\nSobald du Enter drückst, wird Amazon Q aktiv. Es analysiert deinen ausgewählten Code und versteht dessen Struktur, Logik und Zweck. Die KI untersucht deine Klassenmethoden, Abhängigkeiten und potenzielle Randfälle, um zu bestimmen, welche Tests benötigt werden.\n\nInnerhalb weniger Augenblicke generiert Amazon Q eine umfassende Unit-Test-Abdeckung für deine neue Klasse. Es erstellt Tests, die nicht nur den Happy Path abdecken, sondern auch Randfälle und Fehlerbedingungen, die du möglicherweise übersehen hättest. Die generierten Tests folgen den bestehenden Mustern und Konventionen deines Projekts und stellen sicher, dass sie sich nahtlos in deine Codebasis integrieren.\n\n## Warum GitLab Duo mit Amazon Q verwenden?\n\nHier ist das Fazit: Du hast mit einer kritischen Herausforderung begonnen – hochwertige Anwendungen zu pflegen und dabei mit Zeitbeschränkungen und inkonsistenten Testpraktiken umzugehen. GitLab Duo mit Amazon Q löst dies, indem es den Testgenerierungsprozess automatisiert und optimale Code-Abdeckung sowie konsistente Teststandards gewährleistet. Das Ergebnis? Probleme werden vor der Bereitstellung erkannt, deine Anwendungen behalten ihre Qualität und du kannst Software schneller entwickeln, ohne die Zuverlässigkeit zu opfern.\n\nHauptvorteile dieser Funktion:\n\n* Reduziert die Zeit für das Schreiben von Unit-Tests erheblich\n* Gewährleistet umfassende Testabdeckung über deine gesamte Codebasis\n* Hält konsistente Testqualität über alle Teammitglieder hinweg aufrecht\n* Erkennt Probleme, bevor sie die Produktion erreichen\n* Beschleunigt deine gesamte Entwicklungsgeschwindigkeit\n\nBereit, diese bahnbrechende Funktion in Aktion zu sehen? Sieh dir an, wie GitLab Duo mit Amazon Q deinen Qualitätssicherungsprozess transformieren kann:\n\n\u003C!-- blank line -->\n\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/pxlYJVcHY28?si=MhIz6lnHxc6kFhlL\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n## Starte noch heute mit GitLab Duo mit Amazon Q\n\nMöchtest du mehr über GitLab Duo mit Amazon Q erfahren? Besuche die [GitLab und AWS Partnerseite](https://about.gitlab.com/de-de/partners/technology-partners/aws/) für detaillierte Informationen.\n\n## Agentische KI-Ressourcen\n- [Agentische KI-Leitfäden und Ressourcen](https://about.gitlab.com/de-de/blog/agentic-ai-guides-and-resources/)\n- [Was ist agentische KI?](https://about.gitlab.com/de-de/topics/agentic-ai/)\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 Duo mit Amazon Q Dokumentation](https://docs.gitlab.com/user/duo_amazon_q/)",[681,743,9,744,725,745],"product","DevSecOps","AWS",{"featured":90,"template":686,"slug":747},"enhance-application-quality-with-ai-powered-test-generation","content:de-de:blog:enhance-application-quality-with-ai-powered-test-generation.yml","Enhance Application Quality With Ai Powered Test Generation","de-de/blog/enhance-application-quality-with-ai-powered-test-generation.yml","de-de/blog/enhance-application-quality-with-ai-powered-test-generation",{"_path":753,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":754,"content":760,"config":766,"_id":768,"_type":13,"title":769,"_source":15,"_file":770,"_stem":771,"_extension":18},"/de-de/blog/how-to-integrate-custom-security-scanners-into-gitlab",{"title":755,"description":756,"ogTitle":755,"ogDescription":756,"noIndex":6,"ogImage":757,"ogUrl":758,"ogSiteName":671,"ogType":672,"canonicalUrls":758,"schema":759},"So integrierst du benutzerdefinierte Sicherheitsscanner in GitLab","Erfahre, wie du die DevSecOps-Plattform erweiterst, indem du benutzerdefinierte Sicherheitsscanner in deine Workflows einfügst (einschließlich Tutorial).","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097082/Blog/Hero%20Images/Blog/Hero%20Images/securitycheck_securitycheck.png_1750097081856.png","https://about.gitlab.com/blog/how-to-integrate-custom-security-scanners-into-gitlab","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"So integrierst du benutzerdefinierte Sicherheitsscanner in GitLab\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Fernando Diaz\"}],\n        \"datePublished\": \"2024-02-27\",\n      }",{"title":755,"description":756,"authors":761,"heroImage":757,"date":762,"body":763,"category":723,"tags":764,"updatedDate":765},[720],"2024-02-27","GitLab, die umfassendste DevSecOps-Plattform, bietet alles, was du zum Planen, Verwalten, Erstellen, Bereitstellen, Sichern, Steuern und Überwachen deiner Anwendungen brauchst. Dennoch gibt es Fälle, in denen du GitLab mit Tools von Drittanbietern oder eigenen Tools erweitern möchtest. Du musst zum Beispiel von separaten Lösungen auf eine DevSecOps-Plattform migrieren, Tools von Drittanbietern evaluieren oder eigene oder selbst entwickelte Lösungen in GitLab integrieren.\n\n## Folgende Themen werden hier behandelt\n\n- [Erweiterbarkeit der DevSecOps-Plattform von GitLab](#erweiterbarkeit-der-devsecops-plattform-von-gitlab)\n- [Die GitLab-Sicherheitsscanner-Integration](#die-gitlab-sicherheitsscanner-integration)\n - [Sicherheitswidget für Merge Requests](#sicherheitswidget-für-merge-requests)\n - [Pipeline-Sicherheitsbereich](#pipeline-sicherheitsbereich)\n - [Sicherheitslückenbericht](#sicherheitslückenbericht)\n - [Sicherheitslückenseiten](#sicherheitslückenseiten)\n - [Sicherheitsdashboard](#sicherheitsdashboard)\n - [Merge-Request-Approvalrichtlinien-Integration](#merge-request-approvalrichtlinien-integration)\n- [Tutorial: Integration von benutzerdefinierten Sicherheitsscannern](#tutorial-integration-von-benutzerdefinierten-sicherheitsscannern)\n - [Erstellen eines benutzerdefinierten Sicherheitsscanners](#erstellen-eines-benutzerdefinierten-sicherheitsscanners)\n - [Integrieren eines benutzerdefinierten Sicherheitsscanners in GitLab](#integrieren-eines-benutzerdefinierten-sicherheitsscanners-in-gitlab)\n- [Mehr erfahren](#mehr-erfahren)\n\n## Erweiterbarkeit der DevSecOps-Plattform von GitLab\n\nGitLab kann auf viele Arten erweitert werden, um erweiterte Funktionen zu unterstützen, die dein Unternehmen benötigt. Einige gängige Beispiele für diese Integrationen sind:\n\n- externe Anwendungsintegrationen wie Jenkins und Slack\n- externe Integrationen zur Ticketverfolgung wie Bugzilla und Jira\n- externe Integrationen von Authentifizierungsanbietern wie LDAP und SAML\n- externe Integrationen von Sicherheitsscannern wie Fortify und Checkmarx\n- die Möglichkeit, auf durchgesickerte Geheimnisse zu reagieren wie AWS- und GCP-Zugriffsschlüssel\n\nAlle verfügbaren Integrationen findest du in der [Dokumentation zur Integration mit GitLab (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/ee/integration/). (Hinweis: Es sind nicht alle Integrationen in der Dokumentation aufgeführt.)\n\n## Die GitLab-Sicherheitsscanner-Integration\n\n[Sicherheitsscanner von Drittanbietern](https://docs.gitlab.com/ee/integration/#security-improvements) oder [benutzerdefinierte Sicherheitsscanner](https://gitlab.com/gitlab-de/tutorials/security-and-governance/custom-scanner-integration) können in GitLab integriert werden, um das Widget für Merge Requests, den Pipeline-Sicherheitsbereich, den Sicherheitslückenbericht, die Sicherheitslückenseiten, das Sicherheitsdashboard und die Merge-Request-Approvalrichtlinien zu füllen. Sehen wir uns die einzelnen Integrationen an.\n\n### Sicherheitswidget für Merge Requests\n\nEin Merge Request enthält ein Sicherheitswidget, das eine Zusammenfassung der neu entdeckten Sicherheitslücken anzeigt.\n\n![Integration von Sicherheitsscannern – Bild 1](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097089/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750097088837.png)\n\n\u003Ccenter>\u003Ci>Sicherheitswidget für Merge Requests\u003C/i>\u003C/center>\n\u003Cp>\u003C/p>\n\nWenn du auf eine Sicherheitslücke klickst, wird ein Popup-Fenster angezeigt, das folgende Informationen enthält:\n- Status\n- Beschreibung\n- Projekt\n- Datei\n- Bezeichner\n- Schweregrad\n- Tool\n- Scanner-Anbieter\n\n![Integration von Sicherheitsscannern – Bild 2](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097089/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097088838.png)\n\n\u003Ccenter>\u003Ci>Sicherheitslücken mit Details, die behoben werden können\u003C/i>\u003C/center>\n\n\u003Cp>\u003C/p> \n\nBei diesen Sicherheitslücken kann auch reagiert werden, d. h., du kannst sie entweder ignorieren oder ein vertrauliches Ticket dafür erstellen.\n\nDie Ergebnisse eines benutzerdefinierten Scanners können in das Sicherheitswidget eingefügt werden. Die Daten zu den Sicherheitslücken werden aus dem JSON-Schema, das der Scanner ausgibt, zusammengesetzt.\n\n### Pipeline-Sicherheitsbereich\n\nAlle aktivierten Sicherheitsanalysatoren werden in der Pipeline ausgeführt und geben ihre Ergebnisse als Artefakte aus. Diese Artefakte werden verarbeitet, unter anderem durch Deduplizierung, und die Ergebnisse werden auf der Registerkarte „Pipelinesicherheit“ aufgelistet. Von hier aus kannst du auch die resultierenden JSON-Dateien herunterladen.\n\n![Integration von Sicherheitsscannern – Bild 3](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097089/Blog/Content%20Images/Blog/Content%20Images/image11_aHR0cHM6_1750097088840.png)\n\n\u003Ccenter>\u003Ci>Registerkarte „Pipelinesicherheit“\u003C/i>\u003C/center>\n\u003Cp>\u003C/p>\n\nDie Ergebnisse eines benutzerdefinierten Scanners können in die Registerkarte „Pipelinesicherheit“ eingefügt werden. Die Spalten werden anhand des JSON-Schemas, das der Scanner ausgibt, ausgefüllt.\n\n### Sicherheitslückenbericht\n\nDer Sicherheitslückenbericht enthält Informationen zu Sicherheitslücken aus Scans des default-Branch, einschließlich:\n\n- der Gesamtanzahl der Sicherheitslücken pro Schweregrad\n- Filtern für gängige Attribute für Sicherheitslücken\n- Details zu jeder Sicherheitslücke in einer Tabelle\n\n![Integration von Sicherheitsscannern – Bild 4](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097089/Blog/Content%20Images/Blog/Content%20Images/image8_aHR0cHM6_1750097088842.png)\n\n\u003Ccenter>\u003Ci>Sicherheitslückenbericht\u003C/i>\u003C/center>\n\u003Cp>\u003C/p>\n\nDie Ergebnisse eines benutzerdefinierten Scanners für den default-Branch können für den Sicherheitslückenbericht verwendet werden.\n\n### Sicherheitslückenseiten\n\nWenn du im Sicherheitslückenbericht auf eine Sicherheitslücke klickst, gelangst du zur Sicherheitslückenseite. Für jede Sicherheitslücke in einem Projekt gibt es eine Seite, auf der du Details findest, z. B:\n\n- Beschreibung\n- Wann sie erkannt wurde\n- Aktueller Status\n- Wo sie erkannt wurde\n- Verfügbare Aktionen\n- Verknüpfte Tickets\n- Aktionsprotokoll\n- Lösungen\n- Bezeichner\n- Training\n\nDu kannst die Daten auf der Seite mit den Sicherheitslücken nutzen, um eine entdeckte Sicherheitslücke einzugrenzen und sie zu beheben.\n\n![Integration von Sicherheitsscannern – Bild 5](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097089/Blog/Content%20Images/Blog/Content%20Images/image5_aHR0cHM6_1750097088844.png)\n\n\u003Ccenter>\u003Ci>Sicherheitslückenseite für Sicherheitslücken, bei denen Geheimnisse erkannt wurden\u003C/i>\u003C/center>\n\u003Cp>\u003C/p>\n\nDie Ergebnisse eines benutzerdefinierten Scanners können in die Sicherheitslückenseite eingefügt werden. Die Daten zu den Sicherheitslücken werden aus dem JSON-Schema, das der Scanner ausgibt, zusammengesetzt.\n\n### Sicherheitsdashboard\n\nSicherheitsdashboards werden verwendet, um den Sicherheitsstatus deiner Anwendungen zu bewerten. GitLab stellt dir eine Sammlung von Metriken, Bewertungen und Diagrammen für die Sicherheitslücken zur Verfügung, die von den Sicherheitsscannern in deinem Projekt entdeckt wurden. Das Sicherheitsdashboard liefert Daten wie:\n\n- Trends bei Sicherheitslücken über einen Zeitraum von 30, 60 oder 90 Tagen für alle Projekte in einer Gruppe\n- Eine Bewertung in Buchstaben für jedes Projekt, basierend auf dem Schweregrad der Sicherheitslücke\n- Die Gesamtzahl der in den letzten 365 Tagen entdeckten Sicherheitslücken und deren Schweregrad\n\n![Integration von Sicherheitsscannern – Bild 6](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097089/Blog/Content%20Images/Blog/Content%20Images/image7_aHR0cHM6_1750097088846.png)\n\n\u003Ccenter>\u003Ci>Sicherheitsdashboard auf Gruppenebene\u003C/i>\u003C/center>\n\u003Cp>\u003C/p>\n\nIm Sicherheitsdashboard auf Gruppenebene kannst du auf ein Projekt klicken, um auf das spezifische Sicherheitsdashboard zuzugreifen. So erhältst du die 365-Tage-Ansicht.\n\n![Integration von Sicherheitsscannern – Bild 7](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097089/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097088847.png)\n\n\u003Ccenter>\u003Ci>Sicherheitsdashboard auf Projektebene\u003C/i>\u003C/center>\n\u003Cp>\u003C/p>\n\n### Merge-Request-Approvalrichtlinien-Integration\n\nMerge-Request-Approvalrichtlinien werden verwendet, um eine Genehmigung auf der Grundlage der Ergebnisse eines oder mehrerer Sicherheitsscanaufträge zu verlangen. Dies kann verhindern, dass unsicherer Code in die Produktion übernommen wird. Merge-Request-Approvalrichtlinien werden nach der vollständigen Ausführung eines CI-Scanauftrags ausgewertet, wobei die Richtlinien auf der Grundlage der Job-Artefaktberichte, die in der abgeschlossenen Pipeline veröffentlicht werden, bewertet werden.\n\nDu kannst beispielsweise eine Richtlinie für Merge-Request-Approvalrichtlinien erstellen, die die Genehmigung von Projektbetreuer(inne)n erfordert, wenn ein Scanner zur Erkennung von Geheimnissen Sicherheitslücken findet. Das geht so:\n\n1. Wähle in der linken Seitenleiste **Suchen oder aufrufen** aus und suche nach dem Projekt, dem du eine Richtlinie hinzufügen möchtest.\n2. Gehe in der linken Seitenleiste des Projekts zu **Sicherheit > Richtlinien**.\n3. Wähle **Neue Richtlinie** aus.\n4. Wähle im Abschnitt **Merge-Request-Approvalrichtlinien** **Richtlinie auswählen** aus.\n5. Fülle die Felder aus:\n- Name: der Name der Richtlinie\n- Beschreibung: die Beschreibung der Richtlinie\n- Richtlinienstatus: ob sie aktiviert ist oder nicht\n- Regeln: die Bedingungen, die erfüllt sein müssen, damit eine Aktion (Approval erforderlich) ausgeführt wird\n\n![Integration von Sicherheitsscannern – Bild 8](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097089/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097088849.png)\n\u003Ccenter>\u003Ci>Regeln für Merge-Request-Approvalrichtlinien\u003C/i>\u003C/center>\n\u003Cp>\u003C/p>\n\n- Aktionen: die Aktion, die ausgeführt werden soll, wenn die Bedingungen in den Regeln (definierte Schwachstellen/erkannte Lizenzen) erfüllt sind\n\n![Integration von Sicherheitsscannern – Bild 9](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097089/Blog/Content%20Images/Blog/Content%20Images/image9_aHR0cHM6_1750097088850.png)\n\n\u003Ccenter>\u003Ci>Aktionen für Merge-Request-Approvalrichtlinien\u003C/i>\u003C/center>\n\u003Cp>\u003C/p>\n\n- Überschreiben von Projekt-Approvaleinstellungen: Wenn diese Option ausgewählt ist, überschreiben die folgenden Optionen die Projekteinstellungen. Dies wirkt sich jedoch nur auf die in der Richtlinie ausgewählten Branches aus.\n\n![Integration von Sicherheitsscannern – Bild 11](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097089/Blog/Content%20Images/Blog/Content%20Images/image6_aHR0cHM6_1750097088851.png)\n\n \u003Ccenter>\u003Ci>Einstellungen für Merge-Request-Approvalrichtlinien\u003C/i>\u003C/center>\n \u003Cp>\u003C/p>\n\n6. Klicke auf die Schaltfläche „Mit einem Merge Request konfigurieren“.\n\nSobald die Merge-Request-Approvalrichtlinie zusammengeführt wurde, wird die definierte Aktion ausgelöst, wenn du einen Merge Request erstellst und die in den Regeln definierten Kriterien erfüllt sind. In diesem Fall ist mindestens die Zustimmung einer Person erforderlich, bevor der Code zusammengeführt werden kann.\n\n![Integrierter Sicherheitsscanner – Bild 10](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097089/Blog/Content%20Images/Blog/Content%20Images/image10_aHR0cHM6_1750097088852.png)\n\n\u003Ccenter>\u003Ci>Merge Request aufgrund erkannter Sicherheitslücken blockiert\u003C/i>\u003C/center>\n\u003Cp>\u003C/p>\n\nDie Ergebnisse eines benutzerdefinierten Scanners können vollständig in die Merge-Request-Approvalrichtlinien integriert werden. Wenn der benutzerdefinierte Scanner eine Sicherheitslücke entdeckt, ist ein Approval erforderlich, bevor der Code zusammengeführt werden kann. Der Scanner, den du in einer Merge-Request-Approvalrichtlinie auswählst, muss das entsprechende JSON-Schema verwenden.\n\n## Tutorial: Integration von benutzerdefinierten Sicherheitsscannern\n\nJetzt kommen wir zum spannenden Teil: der Integration eines benutzerdefinierten Sicherheitsscanners. In diesem Tutorial lernst du, wie du einen benutzerdefinierten Sicherheitsscanner erstellst und wie du ihn in GitLab integrierst. Wir werden die folgenden Projekte nutzen:\n\n- [Fern Pattern Scanner](https://gitlab.com/gitlab-de/tutorials/security-and-governance/custom-scanner-integration/fern-pattern-scanner): Er durchsucht deine Dateien nach bestimmten Mustern wie Passwörtern, privaten Schlüsseln und Sozialversicherungsnummern.\n– [Secret List](https://gitlab.com/gitlab-de/tutorials/security-and-governance/custom-scanner-integration/secret-list): Enthält eine Liste von Benutzerpasswörtern, Clients und Schlüsseln. Dieses Projekt wird verwendet, um zu zeigen, wie ein benutzerdefinierter Sicherheitsscanner in GitLab integriert werden kann.\n\nIm folgenden Video kannst du dir ansehen, wie die Anwendung erstellt wurde und wie sie im Detail verwendet wird:\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/timMbl5SP-w?si=R2DKtZ5MmBR1rQFL\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n### Erstellen eines benutzerdefinierten Sicherheitsscanners\n\nJetzt erstellen wir einen benutzerdefinierten Scanner, der in GitLab integriert werden kann. Bevor ein benutzerdefinierter Scanner vollständig in GitLab integriert werden kann, muss der Scanner:\n- Ein Verzeichnis nach definierten Mustern scannen\n- Eine JSON-Datei nach dem entsprechenden Schema ausgeben\n- Containerisiert und zugänglich sein\n- Eine Vorlage bereitstellen, damit er in einem anderen Projekt ausgeführt werden kann\n\nWenn der [Fern Pattern Scanner](https://gitlab.com/gitlab-de/tutorials/security-and-governance/custom-scanner-integration/fern-pattern-scanner) in einem Projekt mit der bereitgestellten Vorlage ausgeführt wird, führt er die folgenden Schritte aus:\n1. Er lädt einen Satz von Regeln, die Muster (Regex) definieren, die erkannt werden sollen.\n- Die Regeln können konfiguriert werden, um den sich ändernden Anforderungen deines Unternehmens gerecht zu werden.\n2. Er scannt Dateien auf definierte Muster.\n3. Er gibt einen JSON-Bericht aus, der dem Schema zur Erkennung von Geheimnissen folgt.\n- In diesem Projekt werden Go-Vorlagen verwendet, um eine JSON-Datei zu erstellen.\n- Stelle sicher, dass du das entsprechende Schema verwendest, je nachdem, wonach dein Scanner sucht.\n\nSobald der JSON-Bericht als Artefakt in GitLab geladen wurde, werden das Merge-Request-Widget, der Sicherheitslückenbericht, die Sicherheitslückenseiten, die Merge-Request-Approvalrichtlinien und die Sicherheitsdashboards wie oben definiert befüllt.\n\n### Integrieren eines benutzerdefinierten Sicherheitsscanners in GitLab\n\nSobald du deinen benutzerdefinierten Scanner erstellt hast, der alle Anforderungen für die Integration erfüllt, kannst du ihn in GitLab ausführen.\n\nDas Ausführen eines benutzerdefinierten Scanners ist so einfach wie das Hinzufügen einer Vorlage. Wir können sehen, wie die Vorlage für den Fern Pattern Scanner geladen wird, indem wir uns die Datei `.gitlab-ci.yml` im Projekt [Secret List](https://gitlab.com/gitlab-da/tutorials/security-and-governance/custom-scanner-integration/secret-list) ansehen.\n\n1. Erstelle eine [.gitlab-ci.yml-Datei (Anleitung nur in englischer Sprache verfügbar)](https://docs.gitlab.com/ee/ci/quick_start/#create-a-gitlab-ciyml-file) in dem Projekt, in dem du den Scanner ausführen möchtest.\n2. Füge die [Vorlage für einen benutzerdefinierten Scanner](https://docs.gitlab.com/ee/ci/yaml/includes.html) hinzu.\n    - Du solltest die Vorlage auch mit Umgebungsvariablen konfigurieren können.\n3. Committe die Datei in den Main-Branch.\n\nSobald die Datei übergeben wurde, kannst du sehen, dass der benutzerdefinierte Scanner in deiner Pipeline ausgeführt wird. Sobald die Pipeline abgeschlossen ist, befüllt der Scanner alle oben im Abschnitt [Die GitLab-Sicherheitsscanner-Integration](#gitlab-security-scanner-integration) definierten Bereiche.\n\n## Mehr erfahren\n\nIn diesen englischsprachigen Ressourcen erfährst du mehr über GitLab und die anderen Möglichkeiten, wie du deine DevSecOps-Plattform erweitern kannst:\n\n- [GitLab-Integration für Sicherheitsscanner](https://docs.gitlab.com/ee/development/integrations/secure.html)\n- [GitLab-Partnerintegrationen](https://docs.gitlab.com/ee/integration/)\n- [Gruppe für benutzerdefinierte Sicherheitsscanner-Projekte](https://gitlab.com/gitlab-de/tutorials/security-and-governance/custom-scanner-integration)\n- [Automatische Reaktion auf die Veröffentlichung von Geheimnissen](https://docs.gitlab.com/ee/user/application_security/secret_detection/automatic_response.html)\n",[725,723,9,682],"2025-06-10",{"slug":767,"featured":90,"template":686},"how-to-integrate-custom-security-scanners-into-gitlab","content:de-de:blog:how-to-integrate-custom-security-scanners-into-gitlab.yml","How To Integrate Custom Security Scanners Into Gitlab","de-de/blog/how-to-integrate-custom-security-scanners-into-gitlab.yml","de-de/blog/how-to-integrate-custom-security-scanners-into-gitlab",{"_path":773,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":774,"content":780,"config":789,"_id":791,"_type":13,"title":792,"_source":15,"_file":793,"_stem":794,"_extension":18},"/de-de/blog/migration-guide-github-advanced-security-to-gitlab-ultimate",{"ogTitle":775,"schema":776,"ogImage":777,"ogDescription":778,"ogSiteName":671,"noIndex":6,"ogType":672,"ogUrl":779,"title":775,"canonicalUrls":779,"description":778},"GitLab Ultimate vs GitHub Security: Vergleich & Migration","\n                        {\n        \"@context\": \"https://schema.org\",\n        \"@type\": \"Article\",\n        \"headline\": \"Migrationsleitfaden: GitHub Advanced Security zu GitLab Ultimate\",\n        \"author\": [{\"@type\":\"Person\",\"name\":\"Fernando Diaz\"}],\n        \"datePublished\": \"2024-05-01\",\n      }\n                  ","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749666187/Blog/Hero%20Images/blog-image-template-1800x945__6_.png","GitLab Ultimate vs GitHub Security 2025: Vergleiche Features, Preise und Vorteile. Plus Schritt-für-Schritt-Anleitung für deine erfolgreiche Migration.","https://about.gitlab.com/blog/migration-guide-github-advanced-security-to-gitlab-ultimate",{"heroImage":777,"body":781,"authors":782,"updatedDate":783,"date":784,"title":785,"tags":786,"description":788,"category":723},"GitLab ist die umfassendste KI-gestützte DevSecOps-Plattform. Unternehmen\nkönnen mit dieser Plattform für den gesamten Lebenszyklus der\nSoftwareentwicklung (SDLC) sicherere Software schneller bereitstellen. \n\n\nGitHub bietet eine Advanced Security-Erweiterung, die zusätzliche Sicherheitsfunktionen in GitHub ermöglicht. Es fehlen jedoch die Tiefe und Breite der Sicherheitsfunktionen, die GitLab nativ bereitstellt. \n\n\nUnternehmen, die auf GitLab Ultimate migrieren möchten, um ihre Sicherheit in allen Bereichen des SDLC zu verbessern, können diesen Leitfaden verwenden, um die beiden Angebote zu vergleichen. Er kann auch als Tutorial für den Wechsel zur GitLab-Plattform genutzt werden.\n\n\n**Hinweis**: Dieser Artikel wurde zuletzt im Juni 2025 aktualisiert, um die neuesten Änderungen in GitHubs Produktstrategie zu berücksichtigen.\n\n\nIn diesem Artikel findest du folgende Kapitel:\n\n\n– [Ein Vergleich zwischen GitLab Ultimate und GitHub Advanced Security](#a-comparison-between-gitlab-ultimate-and-github-advanced-security)\n\n– [So migrierst du ein GitHub-Repository zu GitLab](#how-to-migrate-a-github-repository-to-gitlab)\n\n– [So migrierst du Feature für Feature von GitHub Advanced Security zu GitLab Ultimate](#how-to-migrate-feature-by-feature)\n\n– [Eine Einführung in die zusätzlichen Sicherheitsfunktionen von GitLab Ultimate](#additional-gitlab-ultimate-security-features)\n\n\n## Ein Vergleich zwischen GitLab Ultimate und GitHub Advanced Security\n\n\n[GitLab Ultimate](https://about.gitlab.com/pricing/ultimate/) ist die höchste Abonnementstufe von GitLab für Unternehmen, die sichere Software schneller bereitstellen möchten. GitHub Advanced Security ist eine Erweiterung für GitHub Enterprise und ermöglicht zusätzliche Sicherheitsfunktionen.\n\n\n\\### Ähnlichkeiten zwischen GitLab Ultimate und GitHub Advanced Security\n\n\nGitLab Ultimate und GitHub Advanced Security bieten:\n\n– Statische Anwendungssicherheitstests ([SAST](https://docs.gitlab.com/ee/user/application_security/sast/)), Geheimnis- und Abhängigkeitssuche\n\n– kontextbezogene Intelligenz von Sicherheitslücken und Lösungsberatung \n\n– eine Liste von Abhängigkeiten oder Software-Stückliste ([SBOM](https://about.gitlab.com/blog/the-ultimate-guide-to-sboms/))\n\n– Sicherheitsmetriken und -einblicke\n\n\n### Unterschiede zwischen GitLab Ultimate und GitHub Advanced Security\n\n\nWährend sich GitHubs Sicherheitstools verbessert haben (mit Push Protection, die 2024 Millionen von Secrets blockiert hat), bietet GitLab Ultimate weiterhin eine tiefere DevSecOps-Integration mit Funktionen, die in GitHubs eigenständigen Produkten nicht verfügbar sind:\n\n\n* [Compliance-Frameworks und Audit-Management](https://docs.gitlab.com/ee/user/compliance/compliance_center/)\n\n* [Sicherheits-Dashboard](https://docs.gitlab.com/ee/user/application_security/security_dashboard/) über gesamte Gruppen/Organisationen\n\n* Native [DAST](https://docs.gitlab.com/ee/user/application_security/dast/) und [API-Fuzzing](https://docs.gitlab.com/ee/user/application_security/api_fuzzing/)\n\n* Integrierter Workflow für [Schwachstellenmanagement](https://docs.gitlab.com/ee/user/application_security/vulnerability_report/)\n\n* [Benutzerdefinierte Sicherheitsrichtlinien](https://docs.gitlab.com/ee/user/application_security/policies/) mit [granularen Kontrollen](https://docs.gitlab.com/ee/user/custom_roles.html)\n\n\nDiese integrierten Funktionen bedeuten, dass Teams weniger Zeit mit dem Wechsel zwischen Tools verbringen und mehr Zeit für die Sicherung ihrer Anwendungen haben.\n\n\nGitLab Ultimate bietet auch zusätzliche Sicherheits- und Konformitätsfunktionen, Portfolio- und Wertschöpfungskettenmanagement, Unterstützung bei Live-Upgrades und mehr. Weitere Informationen zu diesen zusätzlichen Funktionen findest du in der [GitLab Ultimate-Dokumentation](https://about.gitlab.com/pricing/ultimate/).RetryClaude can make mistakes. Please double-check responses.\n\n\n### Wichtige Änderungen bei GitHub Advanced Security (2025)\n\n\nSeit April 2025 hat GitHub Advanced Security in zwei separate Produkte aufgeteilt: Secret Protection (19$/Monat pro aktivem Committer) und Code Security (30$/Monat pro aktivem Committer). Obwohl dieser modulare Ansatz kosteneffektiv erscheinen mag, benötigen Organisationen in der Regel beide Produkte für umfassende Sicherheitsabdeckung, was zu 49$/Monat pro aktivem Committer führt - wodurch GitLab Ultimates einheitlicher Ansatz für Teams, die vollständige Sicherheitsfunktionen benötigen, potenziell wirtschaftlicher ist.\n\n\nGitHub bietet diese Sicherheitsprodukte nun auch Team-Plan-Kunden ohne Enterprise-Abonnement an. GitLabs integrierte DevSecOps-Plattform bedeutet jedoch, dass Sicherheitsfunktionen vom ersten Tag an nahtlos mit CI/CD, Projektmanagement und anderen Tools zusammenarbeiten - ohne zusätzliche Käufe oder Integrationen. Diese native Integration führt oft zu schnellerer Implementierung und besseren Sicherheitsergebnissen.\n\n\n## So migrierst du ein GitHub-Repository zu GitLab\n\n\nGitLab bietet einen integrierten Importer, mit dem du deine GitHub-Projekte entweder von GitHub.com oder GitHub Enterprise nach GitLab importieren kannst. Mit dem Importer kannst du nicht nur das GitHub-Repository nach GitLab migrieren, sondern auch verschiedene andere Objekte, einschließlich Tickets, Beteiligte (Mitglieder) und Pull Requests. Eine vollständige Liste der migrierbaren Daten findest du in der [Dokumentation zum Import von Daten von GitHub](https://docs.gitlab.com/ee/user/project/import/github.html#imported-data). Die Migration wird wie folgt durchgeführt:\n\n1. Wähle oben in der linken Menüleiste **Neu erstellen (+)** aus.\n\n2. Wähle im Abschnitt **In GitLab** **Neues Projekt/Repository**aus.\n\n3. Wähle  **Projekt importieren**  aus.\n\n\n![Projektauswahl importieren](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/1-Import-Project.png)\n\n\n4. Wähle die Schaltfläche **GitHub** aus.\n       – Wenn du GitLab Self-Managed verwendest, musst du [den GitHub-Importer aktivieren](https://docs.gitlab.com/ee/administration/settings/import_and_export_settings.html#configure-allowed-import-sources).\n       – Beachte, dass andere Importer auf dieselbe Weise initiiert werden können.\n   5. Jetzt kannst du einen der folgenden Schritte ausführen:\n       – Autorisiere dich mit GitHub Oauth, indem du **Mit GitHub autorisieren** auswählst.\n       – Verwende einen persönlichen GitHub-Zugriffstoken:\n          – Gehe zu \u003Chttps://github.com/settings/tokens/new>.\n          – Gib im Feld **Hinweis** eine Token-Beschreibung ein.\n          – Wähle den **Repo**-Geltungsbereich aus.\n          – Um Beteiligte zu importieren, wähle optional den Geltungsbereich **read:org** aus.\n          – Wähle die Schaltfläche **Token generieren** aus.\n          – Füge auf der GitLab-Importseite im Feld „Persönlicher Zugriffstoken“ den persönlichen GitHub-Zugriffstoken ein.\n5. Wähle die Schaltfläche **Authentifizieren** aus.\n\n6. Wähle die Elemente aus, die du migrieren möchtest.\n\n7. Wähle die Projekte aus, die du migrieren möchtest, und wohin du sie migrieren möchtest.\n\n8. Wähle die Schaltfläche **Importieren** aus.\n\n\nDein importiertes Projekt sollte sich nun in deinem Arbeitsbereich befinden. Weitere Informationen über die Migration von GitHub zu GitLab findest du in diesem Video:\n\n\n\u003C!-- blank line -->\n\n\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/0Id5oMl1Kqs?si=HEpZVy94cpfPfAky\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\n\u003C!-- blank line -->\n\n\nDu kannst die Migration auch mit einem [persönlichen GitHub-Zugriffstoken](https://docs.gitlab.com/ee/user/project/import/github.html#use-a-github-personal-access-token) oder der [GitLab REST API(https://docs.gitlab.com/ee/user/project/import/github.html#use-the-api) durchführen. Der Importer ermöglicht auch den Import aus anderen Quellen wie Bitbucket oder Gitea. Weitere Informationen findest du in der [Importer-Dokumentation](https://docs.gitlab.com/ee/user/project/import/).\n\n\n\\## So migrierst du Funktion für Funktion\n\n\nIm Folgenden erfährst du, wie du die einzelnen Funktionen von GitHub Advanced Security in GitLab Ultimate nutzen kannst. Du benötigst eine [GitLab Ultimate-Lizenz](https://about.gitlab.com/pricing/ultimate/), um fortzufahren. GitLab bietet eine [kostenlose Testversion](https://about.gitlab.com/free-trial/devsecops/), um dir den Einstieg zu erleichtern.\n\n\n### Scannen von Code\n\n\nMit dem Scannen von Code bietet GitLab kontextbezogene Intelligenz von Sicherheitslücken und Ratschläge für statischen Quellcode. Das Gleiche kannst du in GitLab erreichen, indem du [SAST](https://docs.gitlab.com/ee/user/application_security/sast/) aktivierst. GitLab SAST-Scanner decken ein breiteres Spektrum an Programmiersprachen und Frameworks ab als [CodeQL](https://docs.github.com/en/code-security/code-scanning/introduction-to-code-scanning/about-code-scanning-with-codeql#about-codeql) von GitHub.\n\n\nUm das Scannen von Code in GitLab zu aktivieren, kannst du einfach die [SAST-Vorlage](https://docs.gitlab.com/ee/user/application_security/sast/#configure-sast-in-your-cicd-yaml) zu deiner ‚.gitlab-ci.yml‘ hinzufügen:\n\n\n```yaml\n\ninclude:\n  - template: Jobs/SAST.gitlab-ci.yml\n```\n\n\nSobald die Vorlage hinzugefügt wurde, erkennt SAST automatisch jedes Mal, wenn neuer Code eingecheckt wird, die [Programmiersprachen](https://docs.gitlab.com/ee/user/application_security/sast/#supported-languages-and-frameworks), die in deinem Projekt verwendet werden. Es scannt dann den Quellcode nach bekannten Schwachstellen.\n\n\n**Hinweis:** Sicherheitsscanner können deinem Projekt auch mithilfe der \\[Sicherheitskonfiguration] von GitLab (https://docs.gitlab.com/ee/user/application_security/configuration/) hinzugefügt werden. Diese kann automatisch einen Merge Request erstellen, um deine Pipeline zu aktualisieren. Weitere Informationen findest du in der [Dokumentation zum Konfigurieren von SAST mithilfe der UI](https://docs.gitlab.com/ee/user/application_security/sast/#configure-sast-by-using-the-ui).\n\n\nDie SAST-Ergebnisse zwischen dem Feature-Branch und der Zielbranch werden im Merge-Request-Widget angezeigt. Das Merge Request-Widget zeigt SAST-Ergebnisse und -Auflösungen an, die durch die Änderungen im Merge Request eingeführt wurden.\n\n\n![Sicherheits-Scanning in Merge Request](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/2-SAST-MR-View.png)\n\n\nJede Sicherheitslücke zeigt Daten an, die bei der Behebung helfen, einschließlich detaillierter Beschreibung, Schweregrad, Standort und Lösungsinformationen:\n\n\n![SAST-Sicherheitslückendetails](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/3-SAST-MR-View-Detailed.png)\n\n\nDu kannst Maßnahmen gegen diese Sicherheitslücken ergreifen:\n\n\n– **Sicherheitslücke ignorieren**: Ermöglicht es Entwickler(inne)n, die Sicherheitslücke mit einem Kommentar zu ignorieren. Dies unterstützt das Sicherheitsteam bei der Durchführung einer Review.\n\n– **Ticket erstellen**: Ermöglicht das Erstellen eines Tickets, um eine Sicherheitslücke zu verfolgen, die eine zusätzliche Überwachung erfordert.\n\n\nDiese Änderungen sind auch inline sichtbar, wenn du innerhalb des Merge Request zur Ansicht **Änderungen** wechselst.\n\n\n![SAST-Änderungsansicht für Sicherheitslücken](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/4-SAST-MR-View-Changes.png)\n\n\n#### Anpassen von SAST-Scannern\n\n\nMit GitLab kannst du eine SAST-Jobdefinition überschreiben und Eigenschaften wie Variablen, Abhängigkeiten oder Regeln ändern. Dazu musst du einen Job mit demselben Namen erstellen, wie der SAST-Job, den du überschreiben willst. Platziere dann diesen neuen Job nach dem Einfügen der Vorlage und gib alle zusätzlichen Schlüssel darunter an.\n\n\nEin Beispiel ist die folgende Konfiguration:\n\n– überschreibt die Version, die der ‚semgrep-sast‘-Scanner verwendet\n\n– führt ein Skript aus, um Module aus privaten Projekten abzurufen, bevor ‚gosec-sast‘ ausgeführt wird \n\n– konfiguriert alle Scanner so, dass sie in einer maximalen Tiefe von 10 suchen\n\n\n```yaml\n\ninclude:\n  - template: Jobs/SAST.gitlab-ci.yml\n\nvariables:\n  SEARCH_MAX_DEPTH: 10\n\nsemgrep-sast:\n  variables:\n    SAST_ANALYZER_IMAGE_TAG: \"3.7\"\n\ngosec-sast:\n  before_script:\n    - |\n      cat \u003C\u003CEOF > ~/.netrc\n      machine gitlab.com\n      login $CI_DEPLOY_USER\n      password $CI_DEPLOY_PASSWORD\n      EOF\n```\n\n\n**Hinweis:** Die verfügbaren SAST-Jobs findest du in der [Vorlage ‚SAST.gitlab-ci.yml‘](https://gitlab.com/gitlab-org/gitlab/-/blob/master/lib/gitlab/ci/templates/Jobs/SAST.gitlab-ci.yml). Konfigurationen findest du in der [Dokumentation für verfügbare SAST CI/CD Variablen](https://docs.gitlab.com/ee/user/application_security/sast/#available-cicd-variables).\n\n\n#### Anpassen von SAST-Regelsätzen\n\n\nFür jeden SAST-Analysator verarbeitet GitLab den Code und verwendet dann Regeln, um mögliche Schwachstellen im Quellcode zu finden. Diese Regeln bestimmen, welche Arten von Schwachstellen der Scanner meldet.\n\n\n– Für Semgrep-basierte SAST-Scanner erstellt, pflegt und unterstützt GitLab die verwendeten Regeln. Es kombiniert die Open-Source-Engine Semgrep, von GitLab verwaltete Erkennungsregeln und die proprietäre Technologie von GitLab für das Verfolgen von Sicherheitslücken und die Erkennung von falschen positiven Ergebnissen.\n\n– Für andere SAST-Analysatoren werden die Regeln in den Upstream-Projekten für jeden Scanner definiert.\n\n\nDu kannst das Verhalten der SAST-Scanner anpassen, indem du eine Regelsatz-Konfigurationsdatei im gescannten Repository definierst:\n\n– Vordefinierte Regeln deaktivieren (für alle Analysatoren verfügbar)\n\n– Vordefinierte Regeln überschreiben (für alle Analysatoren verfügbar)\n\n– Vordefinierte Regeln ersetzen, indem du eine benutzerdefinierte Konfiguration mithilfe von Passthroughs synthetisierst\n\n\nWeitere Informationen und Beispiele zum Konfigurieren von SAST-Regeln findest du in den [SAST-Regeln](https://docs.gitlab.com/ee/user/application_security/sast/rules.html) und in der [Dokumentation zum Anpassen von Regelsätzen](https://docs.gitlab.com/ee/user/application_security/sast/customize_rulesets.html).\n\n\n### Geheimnissuche\n\n\nDas GitHub-Feature Geheimnissuche findet, blockiert und widerruft durchgesickerte Geheimnisse. Das Gleiche kannst du in GitLab erreichen, indem du die Funktion [Erkennung von Geheimnissen](https://docs.gitlab.com/ee/user/application_security/secret_detection/) aktivierst.\n\n\nUm die Erkennung von Geheimnissen in GitLab zu aktivieren, kannst du einfach die folgende Vorlage zu deiner ‚.gitlab-ci.yml‘ hinzufügen:\n\n\n```yaml\n\ninclude:\n  - template: Jobs/Secret-Detection.gitlab-ci.yml\n```\n\n\nSobald die Vorlage hinzugefügt wurde, scannt der Geheimnisscanner jedes Mal, wenn neuer Code eingecheckt wird (oder eine Pipeline ausgeführt wird), den Quellcode auf bekannte Geheimnisse. Je nach Situation scannt die Erkennung von Geheimnissen für Pipelines verschiedene Aspekte deines Codes. Für alle Methoden außer dem „Standard-Branch“ scannt die Erkennung von Geheimnissen für Pipelines Commits, nicht den Arbeitsbaum. Weitere Informationen zur Geheimnissuche findest du in der [Dokumentation zur Erkennung von Geheimnissen](https://docs.gitlab.com/ee/user/application_security/secret_detection/pipeline/#coverage).\n\n\nWenn du einen Merge Request erstellst, scannt die Funktion Erkennung von Geheimnissen jeden Commit, der im Quellbranch vorgenommen wurde. Genau wie in SAST liefert jede erkannte Sicherheitslücke die folgenden Informationen (z. B. Standort) und Bezeichner, um den Behebungsprozess zu unterstützen:\n\n\n![Sicherheitslückendetails für die Erkennung von Geheimnissen](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/5-Secret-Detection-MR-Detailed.png)\n\n\nÄhnlich wie bei SAST kannst du Maßnahmen gegen diese Sicherheitslücken direkt aus der Merge Request heraus ergreifen, einschließlich des Ignorierens von Sicherheitslücken und des Erstellens von Tickets.\n\n\n#### Anpassen von Jobs der Erkennung von Geheimnissen\n\n\nMit GitLab kannst du eine Jobdefinition der Erkennung von Geheimnissen überschreiben, sodass du Eigenschaften wie Variablen, Abhängigkeiten oder Regeln ändern kannst. Dazu musst du einen Job mit demselben Namen erstellen, wie der Job zur Erkennung von Geheimnissen, den du überschreiben willst. Platziere dann diesen neuen Job nach dem Einfügen der Vorlage und gib alle zusätzlichen Schlüssel darunter an. Ein Beispiel ist die folgende Konfiguration:\n\n\n– überschreibt die Phase, auf der der Job zur Erkennung von Geheimnissen ausgeführt wird, zu  ‚security‘\n\n– ermöglicht Verlaufsscans\n\n– ändert die Analysatorversion für Geheimnisse auf 4.5\n\n\n```yaml\n\ninclude:\n  - template: Jobs/Secret-Detection.gitlab-ci.yml\n\nsecret_detection:\n  stage: security\n  variables:\n    SECRET_DETECTION_HISTORIC_SCAN: \"true\"\n    SECRETS_ANALYZER_VERSION: \"4.5\"\n```\n\n\n**Hinweis:** Die verfügbaren Jobs zur Erkennung von Geheimnissen findest du in der [Vorlage SAST.gitlab-ci.yml](https://gitlab.com/gitlab-org/gitlab/-/blob/master/lib/gitlab/ci/templates/Jobs/Secret-Detection.gitlab-ci.yml). Verfügbare Konfigurationen findest du in der [Dokumentation zu verfügbaren CI/CD-Variablen der Erkennung von Geheimnissen](https://docs.gitlab.com/ee/user/application_security/secret_detection/pipeline/#customizing-analyzer-settings).\n\n\n#### Anpassen von Regeln für die Erkennung von Geheimnissen\n\n\nMit dem Analysator für die Erkennung von Geheimnissen kannst du anzupassen, welche Geheimnisse in der GitLab-UI gemeldet werden. Die folgenden Anpassungsoptionen können einzeln oder in Kombination verwendet werden:\n\n\n– vordefinierte Regeln deaktivieren\n\n– vordefinierte Regeln überschreiben\n\n– eine benutzerdefinierte Konfiguration synthetisieren\n\n– eine Remote-Konfigurationsdatei spezifizieren\n\n\nWenn du zum Beispiel die Datei ‚.gitlab/secret-detection-ruleset.toml‘ im Stammverzeichnis deines Projekts erstellst, wird das Standard-GitLeaks-Paket erweitert, sodass Testtoken von der Erkennung ausgeschlossen werden:\n\n\n```yaml\n\n### extended-gitleaks-config.toml\n\ntitle = \"extension of gitlab's default gitleaks config\"\n\n\n[extend]\n\n### Extends default packaged path\n\npath = \"/gitleaks.toml\"\n\n\n[allowlist]\n  description = \"allow list of test tokens to ignore in detection\"\n  regexTarget = \"match\"\n  regexes = [\n    '''glpat-1234567890abcdefghij''',\n  ]\n```\n\n\nWeitere Informationen zum Überschreiben der vordefinierten Analysatorregeln findest du in der [Dokumentation zur Erkennung von Geheimnissen](https://docs.gitlab.com/ee/user/application_security/secret_detection/pipeline/#override-predefined-analyzer-rules).\n\n\n#### Automatische Reaktion auf durchgesickerte Geheimnisse\n\n\nDie Funktion zur Erkennung von Geheimnissen von GitLab reagiert automatisch, wenn sie bestimmte Arten von durchgesickerten Geheimnissen findet. Automatische Antworten können:\n\n– das Geheimnis automatisch widerrufen\n\n– den Partner, der das Geheimnis ausgestellt hat, benachrichtigen; der Partner kann dann das Geheimnis widerrufen, seine(n) Eigentümer(in) benachrichtigen oder sich auf andere Weise vor Missbrauch schützen\n\n\nGitLab kann Partner auch benachrichtigen, wenn von ihnen ausgestellte Anmeldeinformationen in öffentlichen Repositorys auf GitLab.com durchgesickert sind. Wenn du ein Cloud- oder SaaS-Produkt betreibst und diese Benachrichtigungen erhalten möchtest, kannst du eine Partner-API implementieren, die von der GitLab Token Revocation API aufgerufen wird.\n\n\nWeitere Informationen findest du in der [Dokumentation zu automatischen Antworten für durchgesickerte Geheimnisse](https://docs.gitlab.com/ee/user/application_security/secret_detection/automatic_response.html).\n\n\n### Sicherheit der Lieferkette\n\n\nMit GitHub kannst du Software-Lieferketten mit automatisierten Sicherheits- und Versionsaktualisierungen und SBOMs mit einem Klick sichern, verwalten und Berichte darüber erstellen. GitLab kann deine Sicherheitsbedürfnisse in der Lieferkette mithilfe der Funktionen der Abhängigkeitssuche und der Liste der Abhängigkeiten (SBOM) erfüllen.\n\n\nUm das Scannen von Abhängigkeiten in GitLab zu aktivieren, kannst du einfach die folgende Vorlage zu deiner ‚.gitlab-ci.yml‘ hinzufügen:\n\n\n```yaml\n\ninclude:\n  - template: Jobs/Dependency-Scanning.gitlab-ci.yml\n```\n\n\nSobald die Vorlage hinzugefügt wurde erkennt die Abhängigkeitssuche jedes Mal, wenn neuer Code eingecheckt wird, automatisch die [Paketmanager](https://docs.gitlab.com/ee/user/application_security/dependency_scanning/#supported-languages-and-package-managers), die in deinem Projekt verwendet werden. Sie scannt dann die verwendeten Abhängigkeiten auf bekannte Schwachstellen.\n\n\nDie Ergebnisse der Abhängigkeitssuche zwischen dem Feature-Branch und dem Zielbranch werden im Merge-Request-Widget angezeigt. Das Merge-Request-Widget zeigt die Ergebnisse der Abhängigkeitssuche, die durch die Änderungen im Merge Request eingeführt wurden, und schlägt Lösungen vor. Innerhalb eines Merge Request werden für jede Sicherheitslücke relevante Informationen angezeigt, die bei der Behebung hilfreich sind, wie Bezeichner, Beweise und Lösungen:\n\n\n![Sicherheitslückendetails der Abhängigkeitssuche](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/6-Dependency-Scanner-MR-View-Detailed.png)\n\n\nÄhnlich wie bei SAST und der Erkennung von Geheimnissen kannst du Maßnahmen gegen diese Sicherheitslücken direkt aus dem Merge Request heraus ergreifen. Dazu gehören das Ignorieren von Sicherheitslücken und das Erstellen von Tickets.\n\n\n#### Konfigurieren der Abhängigkeitssuche\n\n\nUm eine Jobdefinition zu überschreiben (z. B. um Eigenschaften wie Variablen oder Abhängigkeiten zu ändern), erstellst du einen neuen Job mit dem gleichen Namen wie den, den du überschreiben willst. Platziere dann diesen neuen Job nach dem Einfügen der Vorlage und gib alle zusätzlichen Schlüssel darunter an. Ein Beispiel ist der folgende Code:\n\n\n– deaktiviert die automatische Behebung anfälliger Abhängigkeiten\n\n– erfordert einen Build-Job, der vor der Abhängigkeitssuche abgeschlossen werden muss\n\n\n```yaml\n\ninclude:\n  - template: Jobs/Dependency-Scanning.gitlab-ci.yml\n\ngemnasium-dependency_scanning:\n  variables:\n    DS_REMEDIATE: \"false\"\n  dependencies: [\"build\"]\n```\n\n\nWeitere Informationen zur Konfiguration der Abhängigkeitssuche findest du in der [Dokumentation zum Anpassen des Verhaltens des Analysators](https://docs.gitlab.com/ee/user/application_security/dependency_scanning/#customizing-analyzer-behavior).\n\n\n#### Das Generieren eines SBOM\n\n\nGitLab bietet eine Liste der Abhängigkeiten (Dependency List, SBOM), mit der du die Abhängigkeiten deines Projekts oder deiner Gruppe sowie wichtige Details zu diesen Abhängigkeiten, einschließlich ihrer bekannten Sicherheitslücken, überprüfen kannst. Diese Liste ist eine Ansammlung von Abhängigkeiten in deinem Projekt, einschließlich bestehender und neuer Resultate. Die Liste der Abhängigkeiten wird generiert, nachdem die Abhängigkeitssuche erfolgreich auf dem [Standard-Branch](https://docs.gitlab.com/ee/user/project/repository/branches/default.html) ausgeführt wurde. So greifst du auf die Liste der Abhängigkeiten zu:\n\n\n1. Wähle in der linken Seitenleiste **Suchen oder aufrufen** aus und suche nach deinem Projekt.\n\n2. Wähle **Sicher > Liste der Abhängigkeiten** aus.\n\n\n![Liste der Abhängigkeiten (SBOM)](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/7-Dependency-List.png)\n\n\nHier findest du die folgenden Informationen zu deinen Abhängigkeiten:\n\n\n| Feld                     | Beschreibung                                                                                                                                                                                                                                                                                                                                                                             |\n\n| ------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n\n| Komponente               | Name und Version der Abhängigkeit.                                                                                                                                                                                                                                                                                                                                                       |\n\n| Paketerstellungs-Manager | Der Paketerstellungs-Manager, mit dem die Abhängigkeit installiert wurde.                                                                                                                                                                                                                                                                                                                |\n\n| Standort                 | Bei Systemabhängigkeiten wird das gescannte Image aufgelistet. Bei Anwendungsabhängigkeiten wird hier ein Link zu der für den Paketerstellungs-Manager spezifischen Lock-Datei in deinem Projekt angezeigt, in der die Abhängigkeit deklariert ist. Hier wird auch der Abhängigkeitspfad zu einer übergeordneten Abhängigkeit angegeben, falls diese vorhanden ist und unterstützt wird. |\n\n| Lizenz                   | Links zu den Softwarelizenzen der Abhängigen. Ein Warnhinweis, der die Anzahl der in der Abhängigkeit erkannten Sicherheitslücken enthält.                                                                                                                                                                                                                                               |\n\n| Projekte                 | Link zum Projekt mit der Abhängigkeit. Wenn mehrere Projekte die gleiche Abhängigkeit haben, wird die Gesamtzahl der Projekte angezeigt. So öffnest du ein Projekt mit dieser Abhängigkeit: Wähle die Projektnummer aus, suche dann nach dem Namen und wähle ihn aus. Die Projektsuche wird nur bei Gruppen unterstützt, die maximal 600 Einträge in ihrer Gruppenhierarchie haben.      |\n\n\n\u003Cp>\u003C/p>\n\n\nWeitere Informationen findest du in der [Dokumentation zur Liste der Abhängigkeiten](https://docs.gitlab.com/ee/user/application_security/dependency_list/).\n\n\n### Sicherheits- und Konformitätsverwaltung\n\n\nMit GitHub Advanced Security kannst du Sicherheitsmetriken und -einblicke anzeigen und das Sicherheitsrisiko von Code bewerten. Wir sehen uns jetzt an, wie man das gleiche mit GitLab Ultimate macht.\n\n\n#### Anzeigen von Sicherheitsmetriken und -einblicken\n\n\nGitLab bietet [Sicherheits-Dashboards](https://docs.gitlab.com/ee/user/application_security/security_dashboard/), mit denen du den Sicherheitsstatus deiner Anwendungen bewerten kannst. Diese Dashboards zeigen eine Sammlung von Metriken, Bewertungen und Diagrammen für die von den Sicherheitsscannern in deinem Projekt erkannten Sicherheitslücken:\n\n\n– Sicherheitslückentrends über einen Zeitraum von 30, 60 oder 90 Tagen für alle Projekte in einer Gruppe\n\n– eine Einstufung für jedes Projekt nach der Schwere der Sicherheitslücke\n\n– die Gesamtzahl der in den letzten 365 Tagen entdeckten Sicherheitslücken, einschließlich ihres Schweregrads\n\n\nSo greifst du auf das Sicherheits-Dashboard zu:\n\n\n1. Wähle in der linken Menüleiste **Suchen oder aufrufen** und suche nach deinem Projekt oder deiner Gruppe.\n\n2. Wähle auf dem seitlichen Tab das Dashboard **Sicher > Sicherheit** aus.\n\n3. Filtere und suche nach dem, was du brauchst.\n\n\nDie Gruppenansicht zeigt deine Sicherheitslage für alle Projekte in deiner Gruppe an:\n\n\n![Dashboard Gruppensicherheit](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/8-SD-Group.png)\n\n\nDie Projektansicht zeigt deine Sicherheitslage nur für das Projekt an:\n\n\n![Dashboard Projektsicherheit](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/9-SD-Project.png)\n\n\n#### Beurteile das Sicherheitsrisiko des Codes\n\n\nGitLab Ultimate verfügt über einen [Sicherheitslückenbericht](https://docs.gitlab.com/ee/user/application_security/vulnerability_report/), der Informationen über Sicherheitslücken aus Scans des Standard-Branchs enthält. Er enthält kumulative Ergebnisse aller erfolgreichen Jobs, unabhängig davon, ob die Pipeline erfolgreich war. Der Sicherheitslückenbericht enthält auf allen Ebenen:\n\n\n– Die Gesamtanzahl der Sicherheitslücken pro Schweregrad\n\n– Filter für gängige Attribute für Sicherheitslücken\n\n– Details zu jeder Sicherheitslücke, dargestellt in einem tabellarischen Layout\n\n\n![Sicherheitslückenbericht](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/10-Vulnerability-Report.png)\n\n\nWenn du auf eine Sicherheitslücke klickst, gelangst du zur [Seite der Sicherheitslücke](https://docs.gitlab.com/ee/user/application_security/vulnerabilities/), die Details zu der Sicherheitslücke enthält, wie z. B. eine Beschreibung, den Ort, die Bezeichner und mehr. Nachfolgend findest du ein Beispiel für die Seite einer SQL Injection-Sicherheitslücke, die von unserem SAST-Scanner erkannt wurde:\n\n\n![Seite einer SQL Injection-Sicherheitslücke](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/11-Vulnerability-Page-1.png)\n\n\nAuf dieser Seite kann das Sicherheitsteam zusammenarbeiten, indem es [den Status einer Sicherheitslücke](https://docs.gitlab.com/ee/user/application_security/vulnerabilities/#change-the-status-of-a-vulnerability) zusammen mit einer Begründung ändert und [Tickets erstellt, um Änderungen besser verfolgen zu können](https://docs.gitlab.com/ee/user/application_security/vulnerabilities/#create-a-gitlab-issue-for-a-vulnerability).\n\n\nAuf der Seite der Sicherheitslücke kannst du auch [GitLab Duo](https://about.gitlab.com/gitlab-duo/), unsere KI-gestützte Suite von Funktionen, nutzen. Es kann dir die Sicherheitslücke erklären und [automatisch einen Merge Request für die Behebung der Sicherheitslücke erstellen](https://docs.gitlab.com/ee/user/application_security/vulnerabilities/#vulnerability-resolution).\n\nDie \\[Erklärung der Sicherheitslücke] von GitLab Duo (https://docs.gitlab.com/ee/user/application_security/vulnerabilities/#vulnerability-explanation) verwendet ein umfangreiches Sprachmodell, um:\n\n\n– Die Sicherheitslücke zusammenzufassen\n\n– Entwickler(inne)n und Sicherheitsanalyst(inn)en zu helfen, die Sicherheitslücke zu verstehen und wie sie ausgenutzt und behoben werden kann,\n\n– Eine vorgeschlagene Abhilfemaßnahme vorzuschlagen\n\n\n![Erklärung einer SQL Injection von der GitLab Duo-KI](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/13-Explain-Vulnerability.png)\n\n\n## Zusätzliche GitLab Ultimate-Sicherheitsfunktionen\n\n\nGitLab Ultimate enthält viele weitere Sicherheitsfunktionen, die in GitHub Advanced Security nicht vorhanden sind. Einige Beispiele für diese zusätzlichen Sicherheitsfunktionen sind: zusätzliche Sicherheitsscanner für den gesamten Lebenszyklus der Softwareentwicklung (SDLC), granulare Sicherheitsleitlinien und benutzerdefinierte Berechtigungen.\n\n\n### Sicherheitsscanner für den gesamten SDLC\n\n\nUnser Portfolio an Sicherheitsscannern erstreckt sich über den kompletten SDLC.\n\n\n| Name des Scanners                                                                                                   | Scans                                            | Gescannte Sprachen/Dateien                            |\n\n| ------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------ | ----------------------------------------------------- |\n\n| [Statische Anwendungssicherheitstests (SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)           | Statischer Quellcode                             | C/C++, Java, Python, Go, JavaScript, C# und weitere   |\n\n| [Dynamische Anwendungssicherheitstests (DAST)](https://docs.gitlab.com/ee/user/application_security/dast/)          | Ausgeführte Webanwendung, Live-API               | Sprachunabhängig                                      |\n\n| [Scannen von Infrastructure as Code (IaC)](https://docs.gitlab.com/ee/user/application_security/iac_scanning/)      | IaC-Dateien                                      | Terraform, AWS Cloud Formation, Ansible, und weitere  |\n\n| [Container-Scanning](https://docs.gitlab.com/ee/user/application_security/container_scanning/)                      | Statische und ausgeführte Container-Images       | Dockerfile                                            |\n\n| [Abhängigkeitssuche und Lizenz-Scanning](https://docs.gitlab.com/ee/user/application_security/dependency_scanning/) | Anwendungsabhängigkeiten                         | Requirements.txt, Yarn, Gradle, Npm und weitere       |\n\n| [Web-API-Fuzz-Testing](https://docs.gitlab.com/ee/user/application_security/api_fuzzing/)                           | Sendet zufällige/falsche Daten an die Web-API    | OpenAPI, GraphQL, HAR, Postman Collection             |\n\n| [Abdeckungsgesteuertes Fuzz-Testing](https://docs.gitlab.com/ee/user/application_security/coverage_fuzzing/)        | Sendet zufällige/fehlerhafte Daten an Funktionen | C/C++, Go, Swift, Python, Rust, Java, JavaScript, AFL |\n\n\n\u003Cp>\u003C/p>\n\n\nGitLab ermöglicht auch die Integration von [Drittanbieter-Scannern](https://about.gitlab.com/blog/integrate-external-security-scanners-into-your-devsecops-workflow/) und [benutzerdefinierten Scannern](https://about.gitlab.com/blog/how-to-integrate-custom-security-scanners-into-gitlab/) in die Plattform. Nach der Integration werden die Scannerergebnisse automatisch an verschiedenen Stellen in GitLab angezeigt, z. B. in der Pipeline-Ansicht, im Merge-Request-Widget und im Sicherheits-Dashboard. Weitere Informationen findest du in der [Dokumentation zur Integration von Sicherheitsscannern](https://docs.gitlab.com/ee/development/integrations/secure.html).\n\n\n### Granulare Sicherheits- und Konformitätsrichtlinien\n\n\nMit den Richtlinien in GitLab können Sicherheits- und Konformitätsteams [Kontrollen weltweit in ihrem Unternehmen durchsetzen](https://about.gitlab.com/blog/meet-regulatory-standards-with-gitlab/). Sicherheitsteams können Folgendes sicherstellen:\n\n\n– Sicherheitsscanner werden in den Pipelines des Entwicklungsteams mit der richtigen Konfiguration durchgesetzt.\n\n– Alle Scan-Jobs werden ohne Änderungen oder Modifikationen ausgeführt.\n\n– Ordnungsgemäße Genehmigungen für Merge Requests werden auf der Grundlage der Ergebnisse dieser Befunde erteilt.\n\n\n![Sicherheitsrichtlinien für Merge Requests](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/14-MR-Policy.png)\n\n\nKonformitätsteams können zentral mehrere Genehmigende für alle Merge Requests erzwingen und sicherstellen, dass verschiedene Einstellungen für Projekte im Rahmen der organisatorischen Anforderungen aktiviert sind, z. B. die Aktivierung oder Sperrung von Merge Requests und Repository-Einstellungen. Weitere Informationen findest du in der [GitLab-Sicherheitsrichtlinie](https://docs.gitlab.com/ee/user/application_security/policies/).\n\n\n### Benutzerdefinierte Rollen und granulare Berechtigungen\n\n\n[GitLab Ultimate bietet benutzerdefinierte Rollen](https://about.gitlab.com/blog/how-to-tailor-gitlab-access-with-custom-roles/), mit denen ein Unternehmen Benutzerrollen mit genau den Privilegien und Berechtigungen erstellen kann, die für die Bedürfnisse dieses Unternehmen erforderlich sind.\n\n\nZum Beispiel könnte ein(e) Benutzer(in) eine „Security Auditor“-Rolle mit Berechtigungen zum Anzeigen von Sicherheitslücken im System erstellen, mit der aber kein Quellcode angezeigt oder Änderungen im Repository vorgenommen werden kann. Dieser granulare Satz von Berechtigungen ermöglicht eine klar definierte Aufgabentrennung.\n\n\n![Benutzerdefinierte Rollenerstellung](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/15-Custom-Roles.png)\n\n\nWeitere Informationen findest du in den Dokumentationen zu [benutzerdefinierten Rollen](https://docs.gitlab.com/ee/user/custom_roles.html) und [verfügbaren granularen Berechtigungen](https://docs.gitlab.com/ee/user/custom_roles/abilities.html).\n\n\n### Konformitäts-Center\n\n\nDas Konformitäts-Center ist der zentrale Ort für Konformitätsteams, um die Konformitätsstandards, die Berichterstattung über Verstöße und die Konformitätsframeworks für ihre Gruppe zu verwalten. Das Konformitäts-Center umfasst Folgendes:\n\n\n– Das [Dashboard zur Einhaltung von Konformitätsstandards](https://docs.gitlab.com/ee/user/compliance/compliance_center/compliance_standards_adherence_dashboard.html) listet den Status der Einhaltung von Projekten auf, die dem GitLab-Standard entsprechen.\n\n– Der [Bericht über Konformitätsverstöße](https://docs.gitlab.com/ee/user/compliance/compliance_center/compliance_violations_report.html) zeigt eine allgemeine Ansicht der Merge-Request-Aktivität für alle Projekte in der Gruppe.\n\n– Der [Bericht über Konformitätsframeworks](https://docs.gitlab.com/ee/user/compliance/compliance_center/compliance_frameworks_report.html) zeigt alle Konformitätsframeworks einer Gruppe.\n\n– Der [Bericht über Konformitätsprojekte](https://docs.gitlab.com/ee/user/compliance/compliance_center/compliance_projects_report.html) zeigt die Konformitätsframeworks, die auf Projekte einer Gruppe angewendet werden.\n\n\n![Konformitäts-Center](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674404/Blog/Content%20Images/16-Compliance-Center.png)\n\n\nMit diesen Dashboards kannst du sicherstellen, dass die Aufgabentrennung eingehalten wird, um die Konformität in deinem Unternehmen zu optimieren. Weitere Informationen findest du in der [Konformitäts-Center-Dokumentation](https://docs.gitlab.com/ee/user/compliance/compliance_center/).\n\n\n## Weiterlesen\n\n\nDieser Artikel behandelt nur einen Teil des breiten Spektrums an Sicherheitsfunktionen, die GitLab Ultimate bietet. Schau dir diese Ressourcen an, um mehr darüber zu erfahren, wie GitLab Ultimate dazu beitragen kann, die Sicherheit deines Unternehmens und die Effizienz deiner Entwickler(innen) zu verbessern:\n\n\n– [Was spricht für GitLab Ultimate?\n\n](https://about.gitlab.com/pricing/ultimate/)\n\n– [Tutorial: Erste Schritte mit DevSecOps](https://gitlab-da.gitlab.io/tutorials/security-and-governance/devsecops/simply-vulnerable-notes/)\n\n– [Beispielprojekt: Erste Schritte mit DevSecOps](https://gitlab.com/gitlab-da/tutorials/security-and-governance/devsecops/simply-vulnerable-notes)\n\n– [Dokumentation: Importiere dein Projekt von GitHub in GitLab](https://docs.gitlab.com/ee/user/project/import/github.html)\n\n– [Dokumentation: Migration von GitHub Actions](https://docs.gitlab.com/ee/ci/migration/github_actions.html)\n\n– [Tutorial: Erstelle deine erste GitLab CI/CD-Pipeline und führe sie aus](https://docs.gitlab.com/ee/ci/quick_start/)\n\n– [Tutorial: Erstelle eine komplexe Pipeline](https://docs.gitlab.com/ee/ci/quick_start/tutorial.html)\n\n– [CI/CD-YAML-Syntaxreferenz](https://docs.gitlab.com/ee/ci/yaml/)\n",[720],"2025-06-24","2024-05-01","GitLab Ultimate vs. GitHub Security: Der vollständige Vergleich und Migrationsleitfaden 2025",[725,787,723,682,9],"zero trust","GitHub hat Advanced Security in zwei teure Einzelprodukte aufgeteilt. Entdecke, wie GitLab Ultimate mehr bietet und spare dabei Geld. Inklusive vollständiger Migrationsanleitung und aktuellem Feature-Vergleich 2025.",{"slug":790,"featured":90,"template":686},"migration-guide-github-advanced-security-to-gitlab-ultimate","content:de-de:blog:migration-guide-github-advanced-security-to-gitlab-ultimate.yml","Migration Guide Github Advanced Security To Gitlab Ultimate","de-de/blog/migration-guide-github-advanced-security-to-gitlab-ultimate.yml","de-de/blog/migration-guide-github-advanced-security-to-gitlab-ultimate",{"_path":796,"_dir":246,"_draft":6,"_partial":6,"_locale":7,"seo":797,"content":803,"config":808,"_id":810,"_type":13,"title":811,"_source":15,"_file":812,"_stem":813,"_extension":18},"/de-de/blog/automating-with-gitlab-duo-part-1-generating-tests",{"title":798,"description":799,"ogTitle":798,"ogDescription":799,"noIndex":6,"ogImage":800,"ogUrl":801,"ogSiteName":671,"ogType":672,"canonicalUrls":801,"schema":802},"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","\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":798,"description":799,"authors":804,"heroImage":800,"date":805,"body":806,"category":679,"tags":807,"updatedDate":683},[676],"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",[681,725,9,682,704],{"slug":809,"featured":6,"template":686},"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",1,[664,691,711,731,752,772],1759347937527]