[{"data":1,"prerenderedAt":1203},["ShallowReactive",2],{"/de-de/blog/":3,"navigation-de-de":21,"banner-de-de":440,"footer-de-de":453,"blogCategories-de-de":663,"relatedBlogPosts-de-de":781,"maineFeaturedPost-de-de":1160,"recentFeaturedPosts-de-de":1165,"recentPosts-de-de":1181},{"_path":4,"_dir":5,"_draft":6,"_partial":6,"_locale":7,"seo":8,"content":11,"config":13,"_id":15,"_type":16,"title":7,"_source":17,"_file":18,"_stem":19,"_extension":20},"/de-de/blog","de-de",false,"",{"title":9,"description":10},"Blog","Tutorials, product information, expert insights, and more from GitLab to help DevSecOps teams build, test, and deploy secure software faster.",{"title":12},"GitLab Blog",{"template":14},"BlogHome","content:de-de:blog:index.yml","yaml","content","de-de/blog/index.yml","de-de/blog/index","yml",{"_path":22,"_dir":5,"_draft":6,"_partial":6,"_locale":7,"data":23,"_id":436,"_type":16,"title":437,"_source":17,"_file":438,"_stem":439,"_extension":20},"/shared/de-de/main-navigation",{"logo":24,"freeTrial":29,"sales":34,"login":39,"items":44,"search":377,"minimal":413,"duo":427},{"config":25},{"href":26,"dataGaName":27,"dataGaLocation":28},"/de-de/","gitlab logo","header",{"text":30,"config":31},"Kostenlose Testversion anfordern",{"href":32,"dataGaName":33,"dataGaLocation":28},"https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com&glm_content=default-saas-trial/","free trial",{"text":35,"config":36},"Vertrieb kontaktieren",{"href":37,"dataGaName":38,"dataGaLocation":28},"/de-de/sales/","sales",{"text":40,"config":41},"Anmelden",{"href":42,"dataGaName":43,"dataGaLocation":28},"https://gitlab.com/users/sign_in/","sign in",[45,89,188,193,298,358],{"text":46,"config":47,"cards":49,"footer":72},"Plattform",{"dataNavLevelOne":48},"platform",[50,56,64],{"title":46,"description":51,"link":52},"Die umfassendste KI-basierte DevSecOps-Plattform",{"text":53,"config":54},"Erkunde unsere Plattform",{"href":55,"dataGaName":48,"dataGaLocation":28},"/de-de/platform/",{"title":57,"description":58,"link":59},"GitLab Duo (KI)","Entwickle Software schneller mit KI in jeder Phase der Entwicklung",{"text":60,"config":61},"Lerne GitLab Duo kennen",{"href":62,"dataGaName":63,"dataGaLocation":28},"/de-de/gitlab-duo/","gitlab duo ai",{"title":65,"description":66,"link":67},"Gründe, die für GitLab sprechen","10 Gründe, warum Unternehmen sich für GitLab entscheiden",{"text":68,"config":69},"Mehr erfahren",{"href":70,"dataGaName":71,"dataGaLocation":28},"/de-de/why-gitlab/","why gitlab",{"title":73,"items":74},"Erste Schritte mit",[75,80,85],{"text":76,"config":77},"Platform Engineering",{"href":78,"dataGaName":79,"dataGaLocation":28},"/de-de/solutions/platform-engineering/","platform engineering",{"text":81,"config":82},"Entwicklererfahrung",{"href":83,"dataGaName":84,"dataGaLocation":28},"/de-de/developer-experience/","Developer experience",{"text":86,"config":87},"MLOps",{"href":88,"dataGaName":86,"dataGaLocation":28},"/de-de/topics/devops/the-role-of-ai-in-devops/",{"text":90,"left":91,"config":92,"link":94,"lists":98,"footer":170},"Produkt",true,{"dataNavLevelOne":93},"solutions",{"text":95,"config":96},"Alle Lösungen anzeigen",{"href":97,"dataGaName":93,"dataGaLocation":28},"/de-de/solutions/",[99,125,148],{"title":100,"description":101,"link":102,"items":107},"Automatisierung","CI/CD und Automatisierung zur Beschleunigung der Bereitstellung",{"config":103},{"icon":104,"href":105,"dataGaName":106,"dataGaLocation":28},"AutomatedCodeAlt","/de-de/solutions/delivery-automation/","automated software delivery",[108,112,116,121],{"text":109,"config":110},"CI/CD",{"href":111,"dataGaLocation":28,"dataGaName":109},"/de-de/solutions/continuous-integration/",{"text":113,"config":114},"KI-unterstützte Entwicklung",{"href":62,"dataGaLocation":28,"dataGaName":115},"AI assisted development",{"text":117,"config":118},"Quellcodeverwaltung",{"href":119,"dataGaLocation":28,"dataGaName":120},"/de-de/solutions/source-code-management/","Source Code Management",{"text":122,"config":123},"Automatisierte Softwarebereitstellung",{"href":105,"dataGaLocation":28,"dataGaName":124},"Automated software delivery",{"title":126,"description":127,"link":128,"items":133},"Sicherheit","Entwickle schneller, ohne die Sicherheit zu gefährden",{"config":129},{"href":130,"dataGaName":131,"dataGaLocation":28,"icon":132},"/de-de/solutions/security-compliance/","security and compliance","ShieldCheckLight",[134,138,143],{"text":135,"config":136},"Sicherheit und Compliance",{"href":130,"dataGaLocation":28,"dataGaName":137},"Security & Compliance",{"text":139,"config":140},"Schutz der Software-Lieferkette",{"href":141,"dataGaLocation":28,"dataGaName":142},"/de-de/solutions/supply-chain/","Software supply chain security",{"text":144,"config":145},"Compliance und Governance",{"href":146,"dataGaLocation":28,"dataGaName":147},"/de-de/solutions/continuous-software-compliance/","Compliance and governance",{"title":149,"link":150,"items":155},"Bewertung",{"config":151},{"icon":152,"href":153,"dataGaName":154,"dataGaLocation":28},"DigitalTransformation","/de-de/solutions/visibility-measurement/","visibility and measurement",[156,160,165],{"text":157,"config":158},"Sichtbarkeit und Bewertung",{"href":153,"dataGaLocation":28,"dataGaName":159},"Visibility and Measurement",{"text":161,"config":162},"Wertstrommanagement",{"href":163,"dataGaLocation":28,"dataGaName":164},"/de-de/solutions/value-stream-management/","Value Stream Management",{"text":166,"config":167},"Analysen und Einblicke",{"href":168,"dataGaLocation":28,"dataGaName":169},"/de-de/solutions/analytics-and-insights/","Analytics and insights",{"title":171,"items":172},"GitLab für",[173,178,183],{"text":174,"config":175},"Enterprise",{"href":176,"dataGaLocation":28,"dataGaName":177},"/de-de/enterprise/","enterprise",{"text":179,"config":180},"Kleinunternehmen",{"href":181,"dataGaLocation":28,"dataGaName":182},"/de-de/small-business/","small business",{"text":184,"config":185},"den öffentlichen Sektor",{"href":186,"dataGaLocation":28,"dataGaName":187},"/de-de/solutions/public-sector/","public sector",{"text":189,"config":190},"Preise",{"href":191,"dataGaName":192,"dataGaLocation":28,"dataNavLevelOne":192},"/de-de/pricing/","pricing",{"text":194,"config":195,"link":197,"lists":201,"feature":285},"Ressourcen",{"dataNavLevelOne":196},"resources",{"text":198,"config":199},"Alle Ressourcen anzeigen",{"href":200,"dataGaName":196,"dataGaLocation":28},"/de-de/resources/",[202,235,257],{"title":203,"items":204},"Erste Schritte",[205,210,215,220,225,230],{"text":206,"config":207},"Installieren",{"href":208,"dataGaName":209,"dataGaLocation":28},"/de-de/install/","install",{"text":211,"config":212},"Kurzanleitungen",{"href":213,"dataGaName":214,"dataGaLocation":28},"/de-de/get-started/","quick setup checklists",{"text":216,"config":217},"Lernen",{"href":218,"dataGaLocation":28,"dataGaName":219},"https://university.gitlab.com/","learn",{"text":221,"config":222},"Produktdokumentation",{"href":223,"dataGaName":224,"dataGaLocation":28},"https://docs.gitlab.com/","product documentation",{"text":226,"config":227},"Best-Practice-Videos",{"href":228,"dataGaName":229,"dataGaLocation":28},"/de-de/getting-started-videos/","best practice videos",{"text":231,"config":232},"Integrationen",{"href":233,"dataGaName":234,"dataGaLocation":28},"/de-de/integrations/","integrations",{"title":236,"items":237},"Entdecken",[238,243,247,252],{"text":239,"config":240},"Kundenerfolge",{"href":241,"dataGaName":242,"dataGaLocation":28},"/customers/","customer success stories",{"text":9,"config":244},{"href":245,"dataGaName":246,"dataGaLocation":28},"/de-de/blog/","blog",{"text":248,"config":249},"Remote",{"href":250,"dataGaName":251,"dataGaLocation":28},"https://handbook.gitlab.com/handbook/company/culture/all-remote/","remote",{"text":253,"config":254},"TeamOps",{"href":255,"dataGaName":256,"dataGaLocation":28},"/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":28},"/de-de/services/","services",{"text":266,"config":267},"Community",{"href":268,"dataGaName":269,"dataGaLocation":28},"/community/","community",{"text":271,"config":272},"Forum",{"href":273,"dataGaName":274,"dataGaLocation":28},"https://forum.gitlab.com/","forum",{"text":276,"config":277},"Veranstaltungen",{"href":278,"dataGaName":279,"dataGaLocation":28},"/events/","events",{"text":281,"config":282},"Partner",{"href":283,"dataGaName":284,"dataGaLocation":28},"/de-de/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},"/images/navigation/the-source-promo-card.svg",{"text":294,"config":295},"Lies die News",{"href":296,"dataGaName":297,"dataGaLocation":28},"/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":28},"/de-de/company/","about",{"text":311,"config":312,"footerGa":315},"Karriere",{"href":313,"dataGaName":314,"dataGaLocation":28},"/jobs/","jobs",{"dataGaName":314},{"text":276,"config":317},{"href":278,"dataGaName":279,"dataGaLocation":28},{"text":319,"config":320},"Geschäftsführung",{"href":321,"dataGaName":322,"dataGaLocation":28},"/company/team/e-group/","leadership",{"text":324,"config":325},"Team",{"href":326,"dataGaName":327,"dataGaLocation":28},"/company/team/","team",{"text":329,"config":330},"Handbuch",{"href":331,"dataGaName":332,"dataGaLocation":28},"https://handbook.gitlab.com/","handbook",{"text":334,"config":335},"Investor Relations",{"href":336,"dataGaName":337,"dataGaLocation":28},"https://ir.gitlab.com/","investor relations",{"text":339,"config":340},"Trust Center",{"href":341,"dataGaName":342,"dataGaLocation":28},"/de-de/security/","trust center",{"text":344,"config":345},"AI Transparency Center",{"href":346,"dataGaName":347,"dataGaLocation":28},"/de-de/ai-transparency-center/","ai transparency center",{"text":349,"config":350},"Newsletter",{"href":351,"dataGaName":352,"dataGaLocation":28},"/company/contact/","newsletter",{"text":354,"config":355},"Presse",{"href":356,"dataGaName":357,"dataGaLocation":28},"/press/","press",{"text":359,"config":360,"lists":361},"Kontakt",{"dataNavLevelOne":301},[362],{"items":363},[364,367,372],{"text":35,"config":365},{"href":37,"dataGaName":366,"dataGaLocation":28},"talk to sales",{"text":368,"config":369},"Support",{"href":370,"dataGaName":371,"dataGaLocation":28},"/support/","get help",{"text":373,"config":374},"Kundenportal",{"href":375,"dataGaName":376,"dataGaLocation":28},"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":42,"dataGaName":384,"dataGaLocation":385},"search login","search",{"text":387,"default":388},"Vorschläge",[389,392,397,399,404,409],{"text":57,"config":390},{"href":62,"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":109,"config":398},{"href":111,"dataGaName":109,"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":70,"dataGaName":412,"dataGaLocation":385},"Why GitLab?",{"freeTrial":414,"mobileIcon":419,"desktopIcon":424},{"text":415,"config":416},"Kostenlos testen",{"href":417,"dataGaName":33,"dataGaLocation":418},"https://gitlab.com/-/trials/new/","nav",{"altText":420,"config":421},"GitLab-Symbol",{"src":422,"dataGaName":423,"dataGaLocation":418},"/images/brand/gitlab-logo-tanuki.svg","gitlab icon",{"altText":420,"config":425},{"src":426,"dataGaName":423,"dataGaLocation":418},"/images/brand/gitlab-logo-type.svg",{"freeTrial":428,"mobileIcon":432,"desktopIcon":434},{"text":429,"config":430},"Erfahre mehr über GitLab Duo",{"href":62,"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":5,"_draft":6,"_partial":6,"_locale":7,"title":442,"titleMobile":442,"button":443,"config":448,"_id":450,"_type":16,"_source":17,"_file":451,"_stem":452,"_extension":20},"/shared/de-de/banner","GitLab 18 und der nächste Schritt im Bereich der intelligenten DevSecOps. Sei am 24. Juni dabei.",{"text":444,"config":445},"Jetzt registrieren",{"href":446,"dataGaName":447,"dataGaLocation":28},"/de-de/eighteen/","gitlab 18 banner",{"layout":449},"release","content:shared:de-de:banner.yml","shared/de-de/banner.yml","shared/de-de/banner",{"_path":454,"_dir":5,"_draft":6,"_partial":6,"_locale":7,"data":455,"_id":659,"_type":16,"title":660,"_source":17,"_file":661,"_stem":662,"_extension":20},"/shared/de-de/main-footer",{"text":456,"source":457,"edit":463,"contribute":468,"config":473,"items":478,"minimal":651},"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,621],{"title":46,"links":480,"subMenu":485},[481],{"text":482,"config":483},"DevSecOps-Plattform",{"href":55,"dataGaName":484,"dataGaLocation":462},"devsecops platform",[486],{"title":189,"links":487},[488,492,497],{"text":489,"config":490},"Tarife anzeigen",{"href":191,"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/solutions/digital-transformation/","digital transformation",{"text":135,"config":511},{"href":130,"dataGaName":512,"dataGaLocation":462},"security & compliance",{"text":122,"config":514},{"href":105,"dataGaName":106,"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/solutions/cloud-native/","cloud transformation",{"text":526,"config":527},"SCM",{"href":119,"dataGaName":528,"dataGaLocation":462},"source code management",{"text":109,"config":530},{"href":111,"dataGaName":531,"dataGaLocation":462},"continuous integration & delivery",{"text":161,"config":533},{"href":163,"dataGaName":534,"dataGaLocation":462},"value stream management",{"text":536,"config":537},"GitOps",{"href":538,"dataGaName":539,"dataGaLocation":462},"/de-de/solutions/gitops/","gitops",{"text":174,"config":541},{"href":176,"dataGaName":177,"dataGaLocation":462},{"text":179,"config":543},{"href":181,"dataGaName":182,"dataGaLocation":462},{"text":545,"config":546},"Öffentlicher Sektor",{"href":186,"dataGaName":187,"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":194,"links":558},[559,561,563,565,568,570,572,574,576,578,580,582,584],{"text":206,"config":560},{"href":208,"dataGaName":209,"dataGaLocation":462},{"text":211,"config":562},{"href":213,"dataGaName":214,"dataGaLocation":462},{"text":216,"config":564},{"href":218,"dataGaName":219,"dataGaLocation":462},{"text":221,"config":566},{"href":223,"dataGaName":567,"dataGaLocation":462},"docs",{"text":9,"config":569},{"href":245,"dataGaName":246,"dataGaLocation":462},{"text":239,"config":571},{"href":241,"dataGaName":242,"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,605,610,612,614,616],{"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},"Umwelt, Soziales und Governance",{"href":603,"dataGaName":604,"dataGaLocation":462},"/de-de/environmental-social-governance/","environmental, social and governance",{"text":606,"config":607},"Vielfalt, Inklusion und Zugehörigkeit",{"href":608,"dataGaName":609,"dataGaLocation":462},"/diversity-inclusion-belonging/","Diversity, inclusion and belonging",{"text":339,"config":611},{"href":341,"dataGaName":342,"dataGaLocation":462},{"text":349,"config":613},{"href":351,"dataGaName":352,"dataGaLocation":462},{"text":354,"config":615},{"href":356,"dataGaName":357,"dataGaLocation":462},{"text":617,"config":618},"Transparenzerklärung zu moderner Sklaverei",{"href":619,"dataGaName":620,"dataGaLocation":462},"https://handbook.gitlab.com/handbook/legal/modern-slavery-act-transparency-statement/","modern slavery transparency statement",{"title":622,"links":623},"Nimm Kontakt auf",[624,627,629,631,636,641,646],{"text":625,"config":626},"Sprich mit einem Experten/einer Expertin",{"href":37,"dataGaName":38,"dataGaLocation":462},{"text":368,"config":628},{"href":370,"dataGaName":371,"dataGaLocation":462},{"text":373,"config":630},{"href":375,"dataGaName":376,"dataGaLocation":462},{"text":632,"config":633},"Status",{"href":634,"dataGaName":635,"dataGaLocation":462},"https://status.gitlab.com/","status",{"text":637,"config":638},"Nutzungsbedingungen",{"href":639,"dataGaName":640,"dataGaLocation":462},"/terms/","terms of use",{"text":642,"config":643},"Datenschutzerklärung",{"href":644,"dataGaName":645,"dataGaLocation":462},"/privacy/","privacy statement",{"text":647,"config":648},"Cookie-Einstellungen",{"dataGaName":649,"dataGaLocation":462,"id":650,"isOneTrustButton":91},"cookie preferences","ot-sdk-btn",{"items":652},[653,655,657],{"text":637,"config":654},{"href":639,"dataGaName":640,"dataGaLocation":462},{"text":642,"config":656},{"href":644,"dataGaName":645,"dataGaLocation":462},{"text":647,"config":658},{"dataGaName":649,"dataGaLocation":462,"id":650,"isOneTrustButton":91},"content:shared:de-de:main-footer.yml","Main Footer","shared/de-de/main-footer.yml","shared/de-de/main-footer",[664,677,689,701,713,725,736,748,759,770],{"_path":665,"_dir":666,"_draft":6,"_partial":6,"_locale":7,"seo":667,"content":670,"config":671,"_id":674,"_type":16,"title":668,"_source":17,"_file":675,"_stem":676,"_extension":20},"/de-de/blog/categories/agile-planning","categories",{"title":668,"description":669},"Agile Planning","Browse articles related to Agile Planning on the GitLab Blog",{"name":668},{"template":672,"slug":673,"hide":6},"BlogCategory","agile-planning","content:de-de:blog:categories:agile-planning.yml","de-de/blog/categories/agile-planning.yml","de-de/blog/categories/agile-planning",{"_path":678,"_dir":666,"_draft":6,"_partial":6,"_locale":7,"seo":679,"content":682,"config":683,"_id":685,"_type":16,"title":686,"_source":17,"_file":687,"_stem":688,"_extension":20},"/de-de/blog/categories/ai-ml",{"title":680,"description":681},"KI/ML","Browse articles related to KI/ML on the GitLab Blog",{"name":680},{"template":672,"slug":684,"hide":6},"ai-ml","content:de-de:blog:categories:ai-ml.yml","Ai Ml","de-de/blog/categories/ai-ml.yml","de-de/blog/categories/ai-ml",{"_path":690,"_dir":666,"_draft":6,"_partial":6,"_locale":7,"seo":691,"content":694,"config":695,"_id":697,"_type":16,"title":698,"_source":17,"_file":699,"_stem":700,"_extension":20},"/de-de/blog/categories/bulletin-board",{"title":692,"description":693},"Ankündigungen","Browse articles related to Ankündigungen on the GitLab Blog",{"name":692},{"template":672,"slug":696,"hide":6},"bulletin-board","content:de-de:blog:categories:bulletin-board.yml","Bulletin Board","de-de/blog/categories/bulletin-board.yml","de-de/blog/categories/bulletin-board",{"_path":702,"_dir":666,"_draft":6,"_partial":6,"_locale":7,"seo":703,"content":706,"config":707,"_id":709,"_type":16,"title":710,"_source":17,"_file":711,"_stem":712,"_extension":20},"/de-de/blog/categories/customer-stories",{"title":704,"description":705},"Kundenstories","Browse articles related to Kundenstories on the GitLab Blog",{"name":704},{"template":672,"slug":708,"hide":6},"customer-stories","content:de-de:blog:categories:customer-stories.yml","Customer Stories","de-de/blog/categories/customer-stories.yml","de-de/blog/categories/customer-stories",{"_path":714,"_dir":666,"_draft":6,"_partial":6,"_locale":7,"seo":715,"content":718,"config":719,"_id":721,"_type":16,"title":722,"_source":17,"_file":723,"_stem":724,"_extension":20},"/de-de/blog/categories/devsecops",{"title":716,"description":717},"DevSecOps","Browse articles related to DevSecOps on the GitLab Blog",{"name":716},{"template":672,"slug":720,"hide":6},"devsecops","content:de-de:blog:categories:devsecops.yml","Devsecops","de-de/blog/categories/devsecops.yml","de-de/blog/categories/devsecops",{"_path":726,"_dir":666,"_draft":6,"_partial":6,"_locale":7,"seo":727,"content":730,"config":731,"_id":733,"_type":16,"title":728,"_source":17,"_file":734,"_stem":735,"_extension":20},"/de-de/blog/categories/engineering",{"title":728,"description":729},"Engineering","Browse articles related to Engineering on the GitLab Blog",{"name":728},{"template":672,"slug":732,"hide":6},"engineering","content:de-de:blog:categories:engineering.yml","de-de/blog/categories/engineering.yml","de-de/blog/categories/engineering",{"_path":737,"_dir":666,"_draft":6,"_partial":6,"_locale":7,"seo":738,"content":741,"config":742,"_id":744,"_type":16,"title":745,"_source":17,"_file":746,"_stem":747,"_extension":20},"/de-de/blog/categories/news",{"title":739,"description":740},"Neuheiten","Browse articles related to Neuheiten on the GitLab Blog",{"name":739},{"template":672,"slug":743,"hide":6},"news","content:de-de:blog:categories:news.yml","News","de-de/blog/categories/news.yml","de-de/blog/categories/news",{"_path":749,"_dir":666,"_draft":6,"_partial":6,"_locale":7,"seo":750,"content":753,"config":754,"_id":756,"_type":16,"title":751,"_source":17,"_file":757,"_stem":758,"_extension":20},"/de-de/blog/categories/open-source",{"title":751,"description":752},"Open Source","Browse articles related to Open Source on the GitLab Blog",{"name":751},{"template":672,"slug":755,"hide":6},"open-source","content:de-de:blog:categories:open-source.yml","de-de/blog/categories/open-source.yml","de-de/blog/categories/open-source",{"_path":760,"_dir":666,"_draft":6,"_partial":6,"_locale":7,"seo":761,"content":763,"config":764,"_id":766,"_type":16,"title":767,"_source":17,"_file":768,"_stem":769,"_extension":20},"/de-de/blog/categories/product",{"title":90,"description":762},"Browse articles related to Produkt on the GitLab Blog",{"name":90},{"template":672,"slug":765,"hide":6},"product","content:de-de:blog:categories:product.yml","Product","de-de/blog/categories/product.yml","de-de/blog/categories/product",{"_path":771,"_dir":666,"_draft":6,"_partial":6,"_locale":7,"seo":772,"content":774,"config":775,"_id":777,"_type":16,"title":778,"_source":17,"_file":779,"_stem":780,"_extension":20},"/de-de/blog/categories/security",{"title":126,"description":773},"Browse articles related to Sicherheit on the GitLab Blog",{"name":126},{"template":672,"slug":776,"hide":6},"security","content:de-de:blog:categories:security.yml","Security","de-de/blog/categories/security.yml","de-de/blog/categories/security",[782,826,868,883,930,969,1006,1047,1082,1122],{"category":668,"slug":673,"posts":783},[784,798,814],{"content":785,"config":795},{"title":786,"description":787,"authors":788,"heroImage":790,"date":791,"body":792,"category":673,"tags":793,"updatedDate":791},"So schreibst du eine User Story in Scrum","Der große User-Story-Guide für Scrum: Beispiele, Aufbau, Akzeptanzkriterien, Formulierung. Jetzt hier klicken und durchlesen!",[789],"GitLab Germany Team","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749661979/Blog/Hero%20Images/scrum-project-management.jpg","2025-05-20","Die User Story ist ein sehr einfaches Konzept. Trotzdem hat sie die Projektplanung entscheidend verändert \\- und das, obwohl User Stories zum Beispiel in [Scrum](https://about.gitlab.com/de-de/blog/scrum-project-management-how-it-works/) nicht einmal vorkommen. \n\nGerade weil User Storys für die Teamarbeit so wichtig sind, stellen sie eine Herausforderung dar. Diskussionen um die richtige Formulierung einer User Story in Scrum oder ihre korrekte Bearbeitung in [Kanban](https://about.gitlab.com/de-de/blog/what-is-kanban/) können wertvolle Zeit verbrauchen. So empfinden viele das Konzept eher als undeutlich, aufwändig und belastend. \n\nWir glauben fest daran, dass eine tiefe Verinnerlichung von User Storys - gerade in der [agilen Methode](https://about.gitlab.com/de-de/solutions/agile-delivery/) - dich wirklich voranbringen kann. In diesem Artikel werden wir deshalb so praxisnah wie möglich demonstrieren, wie du sie nutzen kannst, um zu besseren Entscheidungen, Prozessen und Produkten zu gelangen.\n\n## Inhaltsverzeichnis\n\n- [Was ist eine User Story?](#was-ist-eine-user-story%3F)\n- [Warum sollte ich mit User Stories arbeiten?](#warum-sollte-ich-mit-user-stories-arbeiten%3F)\n- [Kann ich auch ohne User Stories auskommen?](#kann-ich-auch-ohne-user-stories-auskommen%3F)\n- [Welche Rolle spielen User Stories in Agile?](#welche-rolle-spielen-user-stories-in-agile%3F)\n- [User Stories in Scrum](#user-stories-in-scrum)\n- [Wie schreibe ich eine gute User Story?](#wie-schreibe-ich-eine-gute-user-story%3F)\n  - [Das 3C-Modell](#das-3c-modell)\n  - [INVEST](#invest)\n- [Scrum User Story: Aufbau und Beispiel](#scrum-user-story-aufbau-und-beispiel)\n  - [User-Story-Beispiel Schritt 1: 5 Whys](#user-story-beispiel-schritt-1-5-whys)\n  - [User-Story-Beispiel Schritt 2: Connextra-Template](#user-story-beispiel-schritt-2-connextra-template)\n  - [User-Story-Beispiel Schritt 3: Akzeptanzkriterien](#user-story-beispiel-schritt-3-akzeptanzkriterien)\n  - [Das Gherkin-Format](#das-gherkin-format)\n- [Agile Schätzung](#agile-schatzung)\n- [Story Points: Aufwand vs. Arbeitszeit](#story-points-aufwand-vs-arbeitszeit)\n- [Story Points in der Schätzung](#story-points-in-der-schatzung)\n  - [Planning Poker](#planning-poker)\n  - [Affinity Mapping](#affinity-mapping)\n- [Wer schreibt User Stories?](#wer-schreibt-user-stories%3F)\n\nWir werden dabei definieren, was User Stories sind, über das Schreiben und den Aufbau einer User Story informieren, Beispiele geben und dir zeigen, was eine gute User Story ausmacht. Doch fangen wir mit einer grundlegenden Frage an:\n\n## Was ist eine User Story?\n\nManche bezeichnen eine User Story schlicht als die kleinste Einheit (oder auch als ein „[Werkzeug](https://t2informatik.de/wissen-kompakt/user-story/)”) der agilen Methode. Andere, darunter auch die [Agile Scrum Group](https://scrumguide.de/user-story/), als eine „Beschreibung dessen, was ein Benutzer (User) will.” \n\nAus diesen Definitionsversuchen wird deutlich: **Eine User Story ist eigentlich gar keine „Geschichte”. Sie stellt vielmehr einen Ansatz dar, dein Produkt so zu verändern, dass es aus der Sicht der Kund(innen) ein neues, besseres Erlebnis bietet.** \n\nInnerhalb einer User Story ist ein neues Feature somit nur dann eine Verbesserung, wenn es Anwender(innen) einen ganz bestimmten, erfahrbaren Nutzen bietet. Eine Software zu „optimieren”, ohne nach diesem Nutzen zu fragen, wird dabei als nicht zielführend betrachtet. \n\nGute User Stories zu schreiben, bedeutet, dich in der Entwicklung von Kund(innen) leiten zu lassen und auf ihre Bedürfnisse und Wünsche hinzuarbeiten. Es bedeutet, den Fokus auf Features hinter dir zu lassen und dich in Richtung einer Betrachtungweise zu bewegen, bei der echte Wertschöpfung in den Mittelpunkt gestellt wird. \n\nDennoch wurde der Begriff „Story”, wie Jeff Patton, einer der geistigen Väter der modernen User Story betont hat, mit Bedacht gewählt. Wir werden darauf später noch genauer eingehen. \n\n## Warum sollte ich mit User Stories arbeiten?\n\nDiese Frage stellt sich in einigen Teams wohl so manche(r). Denn in der Praxis nimmt sich die Arbeit mit User Stories nicht immer einfach aus. Dennoch lohnt sich die investierte Mühe zweifelsohne. Denn das Konzept der User Story mag auf dem Papier fast schon banal anmuten. In Wahrheit steckt dahinter eine entscheidende Neuausrichtung der Entwicklungsarbeit:\n\n* User Stories legen den Fokus voll und ganz auf die Anwender(innen) \\- also auf diejenigen, die das Produkt nutzen, bewerten und bezahlen.   \n* Sie verlagern den Schwerpunkt von „objektiven” Features auf das „subjektive” Erlebnis, mit diesen Features zu arbeiten. Hier kommt der „Story-Gedanke” zum Tragen: Wie wertvoll dein Produkt aus Sicht der Kund(innen) ist, hängt von der Geschichte ab, die sich User(innen) darüber bilden.   \n* Damit kombinieren diese Stories beide Sichten auf ein Produkt: Die technisch-funktionale sowie die narrativ-emotionale.   \n* Weil User Stories die Betonung auf den Nutzen legen, der für Kund(innen) entsteht, sind sie in ihrer Umsetzung nicht starr festgelegt. Das Ziel ist nicht die Anwendung, sondern die Vorstellung von einer besseren Erfahrung. Der Weg zu dieser Erfahrung lässt sich auf viele verschiedene Weisen erreichen.   \n* User Storys sind Teil eines kontinuierlichen Verbesserungsprozesses wie der [automatisierten Softwarebereitstellung](https://about.gitlab.com/de-de/solutions/delivery-automation/), mit vielen sofort testbaren Zwischenstufen (*minimal viable product*, das kleinste realisierbare Produkt). Dieser Prozess endet theoretisch mit einem Produkt, das aus Sicht der Kund(innen) nicht mehr optimiert werden kann (und welches somit in der Praxis niemals erreicht werden wird). \n\nIn der Regel helfen User Stories auch dabei, sinnvolle Prioritäten zu setzen, die praxisnah und in einem angemessenen Zeitrahmen realisierbar sind. \n\n## Kann ich auch ohne User Stories auskommen? \n\nUser Stories haben sich fest etabliert. Dennoch kommen auch heute noch viele Teams ohne sie aus. Sogar Firmen, die sich eigentlich fest der agilen Methode verschrieben haben, nutzen sie nicht zwangsläufig. \n\nTrotzdem kann man behaupten: Wer wirklich agil arbeiten will, wird zumindest mit Instrumenten und Konzepten arbeiten, die den User Stories sehr nahe kommen. Wie wir im nächsten Abschnitt zeigen werden, bauen beide auf demselben Ansatz auf und sind eng miteinander verflochten.\n\nAndersherum gilt auch: Nicht jedes Team, das auf User Stories setzt, hat die Philosophie voll verinnerlicht. Nur allzu leicht wird eine User Story zu einem einfachen „Requirement” \\- einer Auflistung gewünschter Funktionalitäten, bei der oftmals der Nutzen für Kund(innen) vergessen wird. \n\n## Welche Rolle spielen User Stories in Agile? \n\nAus dem Gesagten wird ersichtlich, warum User Stories in der agilen Entwicklung auf einen fruchtbaren Nährboden gestoßen sind. Beide legen den Fokus auf ständige Verbesserungen, Teamarbeit einschließlich einer engen Zusammenarbeit mit Kund(innen), und die Orientierung der Ergebnisse an klaren Bewertungskriterien. \n\nUser Stories fügen sich nahtlos in eine agile Organisation ein: \n\n* Idealerweise kann eine User Story innerhalb eines einzigen Sprints abgearbeitet werden.   \n* User Stories werden im Team festgelegt, besprochen und umgesetzt.  \n* Ein klar definiertes Bewertungssystem liefert die Daten, die benötigt werden, um ein Projekt abzuschließen.\n\nWillst du User Stories in deinem Team nutzen? Wenn du mit Kanban arbeitest, brauchst du für deine Projektarbeit nichts zu verändern. Du kannst weiterhin mit deinen To-do-Listen arbeiten, richtest die Ziele aber nunmehr auf die Perspektive von Kund(innen) aus. \n\n## User Stories in Scrum\n\nWie gezeigt, sind User Stories sehr eng mit der agilen Methode verbunden. Und Scrum ist eine der zentralen Konzepte zur Umsetzung der agilen Methode. So erscheint es als selbstverständlich, dass User Stories auch in Scrum Anwendung finden.\n\nInteressanterweise aber werden sie im [Scrum User Guide](https://scrumguides.org/docs/scrumguide/v2020/2020-Scrum-Guide-German.pdf) nicht erwähnt. Stattdessen thematisiert dieser lediglich den „Product Backlog”, also\n\n*„alle Features, Funktionalitäten, Verbesserungen und Fehlerbehebungen, die das Produkt in Zukunft verändern sollen. Ein Product Backlog Item enthält eine Beschreibung, eine Reihenfolge, Schätzung und Bewertung als Attribute.” \\[Übersetzung aus dem Englischen\\]*\n\nAus dem gerade Erwähnten dürfen keine falschen Schlussfolgerungen gezogen werden. \n\nUser Stories sind nicht die einzige Möglichkeit, mit Scrum kundenorientiert zu arbeiten. Trotzdem haben sie in Scrum ganz gewiss ihren Platz\\! Vielmehr möchte sich der Scrum-Guide nur nicht eindeutig auf ihre Verwendung festlegen und Scrum-Mastern maximale Freiheit einräumen.\n\n## Wie schreibe ich eine gute User Story?\n\nDiese Frage stellt sich zu Beginn nahezu jedes neuen Sprints. Wenn User Stories intuitiv erfassbar und ihre Vorteile offensichtlich sind und wenn das Konzept an sich einfach zu erklären ist \\- warum fällt es dann schwer, es in die Praxis umzusetzen?\n\nWenn du dich mit dieser Frage beschäftigst, mache dir deswegen keine Vorwürfe. User Storys gibt es als methodische Idee bereits seit fast 30 Jahren. Innerhalb dieser Zeit hat es immer wieder Bemühungen gegeben, die Umsetzung zu vereinfachen \\- ein eindeutiges Indiz, dass sie nicht einfach ist. \n\nEine gute User Story hat bestimmte Qualitätskriterien. Diese werden wir uns im nächsten Abschnitt ansehen. Trotzdem glauben wir, dass es möglich ist, auf einer etwas allgemeineren Ebene zu erklären, was eine gute User Story ausmacht:\n\nDamit eine User Story wirklich Nutzen für Kund(innen) generiert, muss sie ihrer Erlebniswelt so nahe wie möglich kommen. Deshalb werden viele der besten User Storys de facto von den Anwender(innen) verfasst \\- sei es nach einem intensiven Gespräch oder weil der Kontakt so eng ist, dass du sehr genau abschätzen kannst, was diese sich wünschen. \n\nDas zweite wichtige Kriterium ist, diesen Nutzen so lebendig wie möglich darzustellen. Wir haben zu Anfang erwähnt, dass eine User Story keine Geschichte ist. Wenn wir sie zu Papier bringen, dann solltest du sie dir sehr plastisch vorstellen können: *So dreidimensional wie ein kleiner Film, der vor dem geistigen Auge abläuft, so kurz gefasst wir ein Haiku.* Dabei kannst du die Zufriedenheit bei Anwender(innen) förmlich spüren. \n\nAuf einer formalen Ebene können das 3C-Modell und die INVEST-Methode weitere Hinweise liefern. In den folgenden beiden Abschnitten gehen wir genauer auf sie ein.\n\n### Das 3C-Modell\n\nDas 3C-Modell entstand bereits früh in der User-Story-Geschichte. Es stammt noch aus einer Zeit, in der die Stories noch wortwörtlich „zu Papier” gebracht wurden. Für eine gute Story sollten in diesem Rahmenwerk folgende drei Punkte erfüllt sein:\n\n1. **C**ard: Die User Story sollte so knapp bemessen sein, dass sie auf eine Karteikarte passt, jedoch ausführlich genug, dass sie diese Karte komplett ausfüllt.   \n2. **C**onversation: Die User Story definiert einen Wunsch und Nutzen der Kund(innen). Die Bewertung und Umsetzung dieser Story erfolgt in enger Zusammenarbeit zwischen allen Teammitgliedern und Kund(innen). Intensive Gespräche sind dabei ein zentraler Bestandteil.  \n3. **C**onfirmation: Es muss eine objektivierbare Möglichkeit bestehen, festzustellen, wann das Ziel erreicht ist. \n\nDas 3C-Modell ist angenehm knapp und bringt zur Geltung, was eine gute Story von einer weniger überzeugenden unterscheidet. Gleichzeitig liefert es wenig praktische Hilfe dabei, eine solche User Story zu schreiben.\n\n### INVEST\n\nAuch bei dem Akronym INVEST handelt es sich um einen Katalog von Anforderungen an gutes User-Story-Schreiben. Es gibt Überschneidungen mit 3C, aber auch eigenständige Punkte.\n\nSehen wir uns die sechs Anforderungen von INVEST einzeln an:\n\n1. **I**ndependent: Jede User Story sollte einen eigenständigen Wunsch von Kund(innen) abbilden. Sie sollte nicht von der Umsetzung anderer Wünsche abhängen.   \n2. **N**egotiable: Die Bedürfnisse der Kund(innen) stehen immer im Vordergrund. Aber eine User Story lebt auch vom regen Austausch zwischen verschiedenen Abteilungen und Teams. Wichtiger als ein starres Festhalten an einmal gewählten Formulierungen ist ein ständiges Aushandeln und Neuverhandeln der Ziele sowie der Methoden zu ihrer Umsetzung.   \n3. **V**aluable: Eine gute User Story muss einen echten, spürbaren Nutzen für Kunden liefern.  \n4. **E**stimate: Manche User Storys werden sich schnell und problemlos lösen lassen. Andere sind komplex. Damit für die praktische Arbeit ausreichend Mitarbeiter(innen) mit dem erforderlichen Wissen zur Verfügung gestellt werden, bedarf es einer möglichst genauen Aufwandseinschätzung.  \n5. **S**mall: Eine User Story sollte in einem Sprint beendet werden können. Sobald du mit einem signifikant höheren Aufwand rechnest, solltest du die Story aufteilen oder von Anfang an als Epic planen.  \n6. **T**estable: Zur Bewertung einer User Story solltest du Abnahmekriterien festlegen können. Diese erlauben es dir, später zu bestimmen, ob du das zu Anfang gesteckte Ziel erreicht hast. Mit diesen Akzeptanzkriterien beschäftigen wir uns gleich.\n\nWie du aus dieser Übersicht erkennen kannst, beziehen sich die über das 3C-Modell hinausgehenden Punkte von INVEST vor allem auf die Arbeit in Scrum. Aus diesem Grund ergibt INVEST Sinn für alle Scrum-Master, die sich intensiver mit User Stories auseinandersetzen wollen.\n\n## Scrum User Story: Aufbau und Beispiel\n\nGehen wir nun zu dem Punkt über, der in nahezu allen Artikeln und Übersichten zum Thema fehlt: Einem praktischen Beispiel für eine User Story in Scrum und wie du sie so schreiben kannst, dass sie zu einem wünschenswerten Ergebnis führt. Wir werden in diesem Artikel nicht näher auf ein Epic-Beispiel (lange User Story) eingehen. Denn auch, wenn die Zyklen sich hier über mehrere Sprints erstrecken, bleibt das Grundprinzip identisch. \n\nNehmen wir an, du hast aus Gesprächen mit Kund(innen) ermittelt, dass diese nicht zufrieden mit der Updatefunktion deines Produkts sind. Immer wieder werden sie während der Arbeit von Update-Meldungen gestört und die Durchführung der Updates beeinträchtigt zudem die Rechenkapazität. Sie würden gerne komfortabel bestimmen können, wann Updates installiert werden sollen oder sich gegen bestimmte Updates entscheiden.  \n\nWie verläuft nun der Weg von diesem ersten Wunsch der Kund(innen) hin zum neuen Feature, beziehungsweise zum Befriedigen des Wunsches der Kund(innen)? \n\n### User-Story-Beispiel Schritt 1: 5 Whys\n\nDas Konzept der User Story fußt auf der Schöpfung von Nutzen. Deshalb sollte das genaue Definieren dieses Nutzens höchste Priorität genießen. Wenn du den Nutzen nicht richtig erfasst, wird es deinem Team auch nicht gelingen, die zentrale emotionale Komponente des Prozesses \\- die „Story” \\- zufriedenstellend umzusetzen. \n\nHilfe bietet hier die 5-Why-Technik. \n\nFange damit an, was du erreichen möchtest: ein Update-Prozess, der von Kund(innen) nicht mehr als Belästigung empfunden wird, sondern als Unterstützung und Optimierung. Anschließend stelle dir selbst die Aufgabe, fünf gute Gründe zu finden, warum diese Story einen Nutzen stiftet.\n\nFür diese User Story wäre zum Beispiel aus der Sicht von Kund(innen) denkbar:\n\n* Damit ich bei voller Rechenleistung weiterarbeiten kann.  \n* Damit ich zunächst sicherstellen kann, dass genug Speicherplatz zur Verfügung steht.   \n* Damit ich die Entscheidung über Updates dann treffe, wenn ich mich damit auch wirklich auseinandersetzen kann und möchte.   \n* Damit ich gezielt nur die Updates auswählen kann, die ich brauche.   \n* Damit ich weiß, welche neuen Updates installiert wurden und immer auf dem neuesten Stand bleibe.\n\nJe mehr Details du hier erarbeiten kannst, umso deutlicher wird es für das Team als Ganzes (und manchmal sogar für die Kund(innen) selbst), worin genau die „Story” besteht.\n\n### User-Story-Beispiel Schritt 2: Connextra-Template\n\nWir haben es bereits erwähnt: User Stories sind eher wie Haikus als Geschichten. Und genau wie Haikus hilft es, bei der Formulierung einer User Story einem mehr oder weniger strengen Format zu folgen.   \n\nRachel Davis von der Firma Connextra stellte fest, dass viele Mitarbeiter(innen) mit dem Schreiben einer guten User Story überfordert waren. Die inhärente Freiheit des Konzepts erwies sich als ein Problem. Wie so oft bot eine gezielte Limitierung der Optionen eine passende Lösung.\n\nDavis schlug den folgenden User-Story-Aufbau vor:\n\n*Als \\[Rolle\\] möchte ich \\[Story\\], damit ich \\[Grund\\]*\n\nDas bedeutet in unserem User-Story-Beispiel:\n\n*Als Kundin möchte ich in Ruhe mit der Software arbeiten können, ohne von Updates unterbrochen zu werden. Ich möchte aber auch immer darüber informiert sein, was für Updates genau neu installiert werden und mich gegebenenfalls gegen sie entscheiden. Der Grund ist, dass ich es vorziehe, immer die Kontrolle über die Software zu behalten und immer auf dem neuesten Stand zu sein.* \n\nDies ist leider nicht, wie das Template in der Praxis üblicherweise benutzt wird. Oftmals setzen viele Teams statt einer emotional gelebten „Story” einfach eine rein technische Funktionalität ein. \n\nDabei geht genau der wichtigste Teil verloren. Bei User Stories geht es um eine alternative Möglichkeit, mit dem Produkt zu arbeiten \\- nicht um eine neue Methode, die Arbeit aufzuteilen. Wenn du so vorgehst, nutzt du zwar formal einen passenden User-Story-Aufbau, arbeitest aber mit alten Methoden. \n\nDas Connextra-Template verführt dazu, zu Mustern zurückzukehren, die du hinter dir lassen solltest. Wer es aber in seiner ursprünglichen Form verwendet, kann sehr großen Nutzen daraus ziehen. \n\n### User-Story-Beispiel Schritt 3: Akzeptanzkriterien\n\nJede gute Geschichte hat einen Anfang und ein Ende. Ohne das letzte Kapitel und ein zufriedenstellendes Finale wird selbst ein spannender Anfang und ein packender Mittelteil mit einer Enttäuschung enden. \n\nAus diesem Grund solltest du unbedingt gleich zu Anfang Akzeptanzkriterien für deine User Story festlegen. Diese setzen einen Rahmen dafür, wann eine User Story als beendet („done”) betrachtet werden kann. Zusammen mit dem vierten Schritt, dem Abschätzen, verankern sie User Stories fest im agilen Framework. \n\nDie Agile Scrum Group meint [zum Thema Akzeptanzkriterien](https://agilescrumgroup.de/akzeptanzkriterien/): \n\n*„Akzeptanzkriterien geben einer User Story Details, sodass Sie wissen, wann eine User Story fertig ist. Akzeptanzkriterien entstehen aus Gesprächen zwischen dem Product Owner, den Stakeholdern und den Entwicklern, wenn Sie nach dem Scrum Framework arbeiten.”*\n\nEs empfiehlt sich bei dem Festlegen der Akzeptanzkriterien folgendes zu beachten:\n\n* 4-8 Akzeptanzkriterien pro User Story erscheinen den meisten Experten als eine sinnvolle Menge.  \n* Suche nach objektiven Kriterien, insofern dies innerhalb der subjektiven Grenzen einer User Story möglich ist. Umso präziser sich feststellen lässt, ob ein Kriterium erfüllt wurde, um so besser.  \n* Entscheidend bei User Storys ist die „Story”, die sich Kund(innen) wünschen, nicht, wie diese umgesetzt wird oder welche Features sie beinhaltet. Lege deshalb genau fest, „was” du erreichen möchtest \\- und überlasse das „wie” der Teamarbeit.\n\nWie sehen Akzeptanzkriterien in der Praxis aus? Es gibt hier verschiedene Ansätze. Das beste Beispiel ist das sogenannte Gherkin-Format.\n\n### Das Gherkin-Format\n\nEbenso wie das Connextra-Template für den User-Story-Aufbau packt das Gherkin-Format die Formulierung von Akzeptanzkriterien für diese User Stories in ein fixes Format. Das erleichtert die Arbeit ungemein. \n\nDas Format sieht folgendermaßen aus:\n\n*Gegeben \\\u003CVoraussetzung\\>*  \n*wenn \\\u003CEreignis\\>*  \n*dann \\\u003CErgebnis\\>*\n\nSo kann für viele potenzielle Fälle ein Szenario entworfen werden. Ein hervorragendes User-Story-Beispiel findet sich in einem ausführlichen [PDF-Leitfaden des Bundesinnenministeriums](https://www.digitale-verwaltung.de/SharedDocs/downloads/Webs/DV/DE/servicehandbuch.pdf?__blob=publicationFile&v=3): Hier möchten Anwender(innen) ein „Passbild hochladen\", damit ihre „Antragsdaten vollständig sind”: \n\n*„Szenario: Bilddatei hochladen*  \n*Gegeben ist, dass der Nutzende angemeldet ist und sich auf dem entsprechenden Formular befindet,*  \n*Wenn der Nutzende eine ausgewählte Datei hochlädt und es sich um eine Bilddatei handelt,*  \n*dann wird sie übernommen und dem Nutzenden als hochgeladen angezeigt und die Biometrie-Prüfung*  \n*wird angestoßen.*\n\n*Szenario: Falsches Format hochladen*  \n*Gegeben ist, dass der Nutzende angemeldet ist und sich auf dem entsprechenden Formular befindet,*  \n*Wenn der Nutzende eine ausgewählte Datei hochlädt und es keine Bilddatei ist,*  \n*dann wird sie nicht übernommen und es wird ein Fehler angezeigt.”*\n\n## Agile Schätzung\n\nDie Welt der Softwareentwicklung ist nicht linear. Aufgaben werden nicht bequem der Reihe nach abgearbeitet. In der Regel gilt es, mit einer limitierten Menge an Arbeitszeit die von dir und deinem Team definierten User Stories gleichzeitig oder zeitversetzt umzusetzen. Das stellt die Planung vor anspruchsvolle Aufgaben. \n\nDas Ziel der User-Story-Organisation besteht darin, zu verstehen, wie viel Aufwand jede einzelne Story erfordert. Je genauer du dies weißt, desto genauer wirst du in der Lage sein, die zu erledigenden Aufgaben auf die bestehenden Kapazitäten zu verteilen. Je gröber dein Verständnis, umso höher das Risiko, dass User Stories gar nicht oder nicht in der erforderlichen Qualität erledigt werden. \n\nDieses Risiko kann das Überleben des Unternehmens gefährden. Aus diesem Grund nimmt die agile Schätzung \\- also die Schätzung des Aufwands deiner User Stories \\- eine zentrale Rolle ein. \n\nDu könntest nun meinen, dass es dafür eine einfache Lösung gibt: Du weist schlicht jeder User Story eine geschätzte Bearbeitungsdauer zu und verteilst die Arbeit anschließend so, dass sie innerhalb der geplanten Sprints erledigt werden kann. \n\nIn der Praxis haben sich andere Ansätze als effektiver erwiesen. \n\n## Story Points: Aufwand vs. Arbeitszeit\n\nZeit ist relativ. Was für das Universum als Ganzes gilt, hat auch in der Softwareentwicklung Bestand. Arbeitszeit präziseeinzuschätzen hängt von einer Vielzahl von Faktoren ab und kann sich sogar für erfahrene Personalplaner als äußerst schwierig erweisen. Gerade bei schnellen und zugleich zeitintensiven Branchen können selbst kleine Abweichungen massive Folgewirkungen haben und den gesamten Zeitplan durcheinander bringen.\n\nAus unserer Sicht sind zwei Punkte verantwortlich dafür, dass Zeit in der Planung kein idealer Bewertungsmaßstab ist:\n\n* Die Komplexitäten verschiedener User Stories können sehr weit auseinanderklaffen. Das bedeutet nicht unbedingt, dass komplexe Aufgaben mehr Zeit benötigen. Möglicherweise erfordern sie lediglich, dass sich erfahrene, hochqualifizierte oder auf dieses Thema geschulte Teammitglieder um ihre Bearbeitung kümmern müssen.   \n* Der Aufwand einer Aufgabe hängt ebenfalls von sehr unterschiedlichen Faktoren ab. Manche User Stories müssen ausgiebig im Team diskutiert werden, andere erfordern viel Zeit, um realisiert zu werden, obwohl sie keineswegs „schwierig” sind. Andere können nur in ständiger Rücksprache mit Kund(innen) umgesetzt werden. All das beeinflusst die Arbeitszeit, teilweise auf eine Art und Weise, die nur schwer vorherzusehen ist.\n\nAus diesem Grund hat sich eine andere Einheit zur Einschätzung herauskristallisiert: Story Points. Dabei handelt es sich um ein Maß, das den Aufwand einer User Story auf eine nicht direkt mit der erforderlichen Zeit verbundene Weise zu bestimmen versucht: Je mehr Story Points eine User Story erfordert, umso höher der Aufwand. \n\n## Story Points in der Schätzung\n\nStory Points sind Aufwandspunkte. Sie können in erfahrenen Teams zu sehr genauen Schätzungen führen. Trotzdem stehen sie niemals für absolute Werte und sind im Gesamtkontext aller aktuell anstehenden User Storys zu sehen. \n\nDie beliebtesten Konzepte basieren nahezu alle grob auf der Fibonacci-Folge. In dieser Sequenz entsteht die jeweils nächste Zahl aus der Summe der beiden vorangegangenen. Die ersten 13 Einträge dieser Folge sind demzufolge:\n\n0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144\n\nIn der User-Story-Planung werden diese Zahlen ein wenig geglättet. So entsteht zum Beispiel die folgende Kette:\n\n0, 1, 2, 3, 4, 5, 8, 13, 20, 30, 50, 100\n\nWir haben auch Konzepte gefunden, in der zwischen 0 und 1 noch ein 0,5 eingefügt und statt einer 50 eine 40 gewählt wurde. Das aber sind Feinheiten, die das Konzept als solches nicht wesentlich  tangieren. \n\nAnschließend weist das Team den User Stories einen dieser Zahlenwerte zu. Daraus entsteht eine Reihenfolge der Stories nach Aufwand. Die folgenden Methoden zur Zuweisung von Story Points sind üblich:\n\n### Planning Poker\n\nBeim Planning Poker weisen die Teammitglieder jeder User Story auf einer verdeckt gehaltenen Karte, je nach dem geschätzten Aufwand, Story Points zwischen 0 und 100 zu. Anschließend werden die Karten offen auf den Tisch gelegt und nach Zahl der Story Points auf Stapel verteilt. \n\nDer Stapel mit den meisten Karten ist der „Sieger” und die User Story erhält die damit verbundene Zahl an Punkten, beispielsweise 20\\. \n\nDas Planning Poker ist eine elegante Methode der Aufwandsschätzung, die letzten Endes aber natürlich einer simplen Abstimmung gleichkommt. \n\nDas Konzept der Planung durch T-Shirtgrößen, was sich ebenfalls oft in einschlägigen Artikeln findet, ist aus unserer Sicht keine eigenständige Methode, sondern eine modifizierte Variante des Pokers. Gleiches gilt für das „Bucket System” (ein Eimer, in den die Karten geschmissen werden) oder das „Dot Voting” (mit kleinen Klebepunkten). \n\n### Affinity Mapping\n\nDas Affinity Mapping ist eine der wenigen Alternativen zum Planning Poker. Es besteht aus zwei Phasen:\n\n1. Zunächst gruppieren alle Teammitglieder gemeinschaftlich die Aufgaben, die einen ähnlichen Komplexitätsgrad aufweisen. Die Einteilung erfolgt durch Diskussion innerhalb des Teams.  \n2. Anschließend werden den User Stories innerhalb der Gruppe, entweder durch weitere Gespräche oder Methoden wie Planning Poker, Story Points zugewiesen. So entsteht eine Reihenfolge, bei der die aufwandsintensiven Stories ganz oben, die vermutlich weniger anspruchsvollen weiter unten stehen. \n\n## Wer schreibt User Stories?\n\nIn der Vergangenheit wurde die Planung und Aufgabenzuweisung üblicherweise von einer zentralen Instanz oder einer verantwortlichen Person vorgenommen. Bis heute hat sich diese Arbeitsverteilung in vielen Unternehmen gehalten. Sogar Scrum, ein teamorientiertes Konzept innerhalb der teamorientierten Agile-Management-Philosophie, arbeitet bis heute mit einem Scrum-Master.\n\nDas Schreiben von User Stories unterscheidet sich hier deutlich. Zwar wird die erste Version der User Story oftmals noch von einem erfahrenen Teammitglied verfasst, beispielsweise nach einem ausführlichen Austausch mit Kund(innen). Hier schließt sich direkt die Phase der „Verhandlungen” an, also des Austauschs zwischen allen Beteiligten. \n\nSomit werden User Stories zwar noch sehr oft von Einzelnen vorbereitet, geschrieben werden sie aber von der Gruppe. \n\nGenau das macht sie auch zu einem so großartigen Tool. Denn wie jeder Autor weiß, ist eine Geschichte nur dann gut, wenn man sich mit ihr identifizieren kann. \n\n*Willst Du mehr dazu wissen, wie Deine persönliche User Story in Scrum zum Erfolg wird? Dann empfehlen wir Dir unseren Leitfaden zur [Verwendung von Scrum in GitLab](https://docs.gitlab.com/ee/tutorials/scrum_events/). Oder informiere Dich dazu, warum GitLab ganz allgemein die führende [DevSecOps-Plattform](https://about.gitlab.com/de-de/platform/) ist.*",[794],"agile",{"slug":796,"featured":6,"template":797},"how-to-write-a-user-story-in-scrum","BlogPost",{"content":799,"config":812},{"title":800,"description":801,"authors":802,"heroImage":804,"date":805,"body":806,"category":673,"tags":807,"updatedDate":811},"SAFe ohne Silos in GitLab","Erfahre, wie du das Scaled Agile Framework den nativen Funktionen der DevSecOps-Plattform zuordnen kannst und welche Vorteile sich daraus ergeben.",[803],"Amanda Rueda","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097569/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%2811%29_2hcwWx49wQ7CHfvhhkVH6S_1750097569126.png","2025-04-08","Was passiert eigentlich, wenn dein Unternehmen das Scaled Agile Framework (SAFe) einführt, um auf Unternehmensebene zu skalieren? Du hast mehrere Teams, die an komplexen Produkten arbeiten, und benötigst eine Möglichkeit, diese Arbeit zu koordinieren. Aber hier ist ein häufiges Problem: Deine Planung erfolgt in einem Tool, während deine eigentliche Entwicklungsarbeit ganz woanders stattfindet.\n\nDiese Trennung schafft überall Probleme: Entwickler(innen) springen ständig zwischen Systemen hin und her. Produktmanager(innen) haben Schwierigkeiten, sich ein genaues Bild vom Fortschritt zu machen. Und jeder verschwendet Zeit damit, Informationen manuell von einem Ort zum anderen zu kopieren. Es ist genau diese Art von fehlendem Zusammenhang, die SAFe beseitigen soll.\n\nAuch wenn deine Entwicklungsteams [GitLab](https://about.gitlab.com/de-de/) möglicherweise bereits für die Quellcodeverwaltung, CI/CD und Sicherheit verwenden, fragst du dich vielleicht, ob GitLab auch deine Planungsanforderungen innerhalb des SAFe-Frameworks unterstützen kann. Die gute Nachricht ist, dass die agilen Projektmanagementfunktionen von GitLab SAFe umfassend unterstützen. In diesem Artikel erfährst du, wie GitLab SAFe-Konzepte und -Zeremonien abbildet, und das alles innerhalb derselben DevSecOps-Plattform, die deine Softwareentwickler(innen) bereits kennen und lieben.\n\n## Was ist SAFe?\n\nSAFe oder das Scaled Agile Framework ist eine Möglichkeit, agile Prinzipien in große Unternehmen zu bringen, ohne an Geschwindigkeit, Ausrichtung oder Kundenorientierung einzubüßen. Es nimmt das iterative und flexible Teamwork-Modell kleiner Teams auf und wendet diese Prinzipien in großen Unternehmen mit mehreren Teams, Roadmaps und Stakeholdern an. Dies bringt die Organisation in Einklang, da jedes Planen und Ausführen im Einklang erfolgt. SAFe hilft Produktmanager(inne)n, die Strategie mit der Umsetzung zu verbinden, sodass du nicht nur schnell, sondern auch die richtigen Dinge lieferst, unterstützt durch klare Prioritäten und teamübergreifende Abstimmung.\n\nSAFe reduziert Silos, fördert die Zusammenarbeit und hilft Teams, sich auf Kundenergebnisse zu konzentrieren, nicht nur auf Aufgaben. Wenn es in GitLab integriert ist, passiert etwas scheinbar Magisches: Sichtbarkeit, Nachvollziehbarkeit und Lieferung befinden sich alle an einem Ort.\n\n## SAFe-Terminologie in GitLab\n\nZunächst müssen wir festlegen, wie SAFe-Konzepte GitLab zugeordnet werden:\n\n| SAFe | GitLab |\n| :---- | :---- |\n| Epic | Top-Level-Epic |\n| Möglichkeit | Sub-Epic (Level 1) |\n| Funktion | Sub-Epic (Level 2) |\n| User Story | Issue |\n| Aufgabe | Aufgabe |\n| Team | Benutzerdefiniertes Feld/Label mit begrenztem Geltungsbereich |\n| Sprint | Iteration |\n| Programminkrement (PI) | Meilenstein |\n| Wertschöpfungskette | Top-Level-Gruppe |\n| Agile Release Train (ART) | Top-Level-Gruppe |\n\n\u003Cbr>\u003C/br>\n\nMit dieser Zuordnung als Leitfaden kannst du GitLab so einrichten, dass es deine SAFe-Implementierung widerspiegelt. Mit der Gruppenstruktur kannst du dich um deine Wertschöpfungsketten und ARTs herum organisieren, während die Workitem-Hierarchie (mit bis zu sieben Ebenen verschachtelter Epics!) dir die nötige Tiefe für komplexe Produktportfolios bietet. Unabhängig davon, ob du auf Portfolioebene (mit Top-Level-Gruppen), auf Programmebene (mit Untergruppen) oder auf Teamebene (mit Projekten) arbeitest, passt die Organisationsstruktur von GitLab perfekt zur SAFe-Hierarchie.\n\n## Unterstützung von SAFe-Zeremonien in GitLab\n\nNun zum vergnüglichen Teil – wie führst du deine SAFe-Zeremonien in GitLab durch? Gehen wir jede einzelne durch.\n\n### PI-Planen\n\nUm die teamübergreifende Abstimmung und das Abhängigkeitsmanagement zu erleichtern, die ein erfolgreiches PI-Planen ausmachen, bietet GitLab mehrere Möglichkeiten:\n\n* Verwende die [Roadmap](https://docs.gitlab.com/user/group/roadmap/)-Ansicht, um Funktionen team- und zeitübergreifend zu visualisieren.\n* Weise dem PI-[Meilenstein](https://docs.gitlab.com/user/project/milestones/) Funktionen zu.\n* Dokumentiere und visualisiere teamübergreifende [Abhängigkeiten]( https://docs.gitlab.com/user/project/issues/related_issues/#blocking-issues), sobald sie identifiziert wurden.\n\nGitLab bietet dir Flexibilität beim PI-Planen sowohl über die Epic-Boards (die so konfiguriert werden können, dass sie Teamzuweisungen anzeigen) als auch über die Roadmap-Ansicht (die Funktionen im Zeitverlauf wie ein Gantt-Diagramm anzeigt). Du kannst während deiner Planungs-Sessions zwischen diesen Ansichten wechseln, je nachdem, ob du dich auf die Zeitachse oder die Teamorganisation konzentrierst.\n\n![Roadmap-Ansicht und Epic-Board](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097577/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097576746.gif)\n\n\u003Cbr>\u003C/br>\n\n![Roadmap-Ansicht mit Gantt-Diagramm](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097577/Blog/Content%20Images/Blog/Content%20Images/image5_aHR0cHM6_1750097576747.png)\n\n### Refinement\n\nAls Produktmanager(in) bedeutet das Durchführen effektiver Refinement-Sessions, dass du einen klaren Überblick über deinen Funktionen-Backlog hast. Du kannst deine Refinement-Session direkt in GitLab durchführen. Du musst nicht mehr während der Besprechung ein Tool aktualisieren und anschließend ein anderes Tool aktualisieren. \n\nGitLab unterstützt Refinement-Sessions mit:\n\n* [Epic-Boards](https://docs.gitlab.com/user/group/epics/epic_boards/), die Funktionen nach Status gruppieren. \n* Der Möglichkeit, Story-Punkte direkt in der [Übersicht](https://docs.gitlab.com/user/group/epics/epic_boards/#view-count-of-issues-weight-and-progress-of-an-epic) anzuzeigen.  \n* Umfassenden [Drawer-Ansichten](https://docs.gitlab.com/user/group/epics/manage_epics/#open-epics-in-a-drawer), mit denen du mit Workitems interagieren kannst, ohne den Kontext zu verlieren.  \n* Der Möglichkeit, [untergeordnete Issues](https://docs.gitlab.com/user/group/epics/manage_epics/#add-an-issue-to-an-epic) direkt aus Epics zu erstellen und zu verknüpfen.\n\n![SAFe – Bild 3](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097577/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097576749.gif)\n\n### Sprint-Planung\n\nWenn es darum geht, herauszufinden, was dein Team im nächsten Sprint bewältigen kann, bietet GitLab dir:\n\n* [Issue-Übersichten](https://docs.gitlab.com/user/project/issue_board/), die einen umfassenden Überblick über deinen Backlog bieten.  \n* Eine [Gesamtgewichtung](https://docs.gitlab.com/user/project/issue_board/#sum-of-issue-weights) von User Storys, die direkt auf den Boards angezeigt werden.\n* Die Möglichkeit, Tickets einfach zwischen Iterationen zu verschieben. \n* Eine zusammenklappbare Ansicht, die das Verschieben von Storys zwischen Sprints vereinfacht.\n\nDas bedeutet, dass du alles an einem Ort aufbewahren und deine Planungsbesprechungen tatsächlich mit dem Planen verbringen kannst, anstatt zwischen den Tools zu wechseln.\n\n![Sprint-Planung mit GitLab](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097577/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750097576751.gif)\n\n*💡 In [diesem Tutorial zur Verwendung von GitLab für Scrum](https://docs.gitlab.com/tutorials/scrum_events/) erhältst du einen detaillierten Einblick in die Möglichkeiten von GitLab für Agile Planning und Sprint-Verfolgung.* \n\n### Tägliche Stand-up-Meetings\n\nDein Team kann sich während der täglichen Stand-up-Meetings um das Board versammeln und sehen, woran alle arbeiten, wo es Probleme gibt und was zur Überprüfung bereit ist – alles in einer einzigen Ansicht. Für die täglichen Stand-up-Meetings deines Entwicklungsteams bietet GitLab dir folgende Möglichkeiten:\n\n* Erstellen von [iterationsbezogenen](https://docs.gitlab.com/user/project/issue_board/#iteration-lists) Boards, die die Arbeit des aktuellen Sprints anzeigen.  \n* Die Anzeige von Story-Punkten/Gewichtungen direkt auf Karten. \n* Die Verwendung der [Drawer-Ansicht](https://docs.gitlab.com/user/project/issues/managing_issues/#open-issues-in-a-drawer), um auf Details zuzugreifen, ohne den Kontext zu verlassen.  \n* Die Hervorhebung gefährdeter Aufgaben durch den [Integritätsstatus](https://docs.gitlab.com/user/project/issues/managing_issues/#health-status)\n\n![Board für tägliche Stand-up-Meetings](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097577/Blog/Content%20Images/Blog/Content%20Images/image6_aHR0cHM6_1750097576755.png)\n\n### Sprint-Review\n\nMöchtest du wissen, wie sich dein Team im Laufe der Zeit entwickelt? GitLab bietet umfassende Metriken mit:\n\n* [Abarbeitungs- und Burnup-Diagrammen](https://docs.gitlab.com/user/group/iterations/#iteration-burndown-and-burnup-charts) für Iterationen  \n* Geschwindigkeitsverfolgung  \n* [Lead- und Zykluszeit](https://docs.gitlab.com/user/group/value_stream_analytics/#lifecycle-metrics)-Metriken  \n* Dashboards, die auf Teams ausgerichtet werden können\n\nDiese Metriken helfen dir zu verstehen, ob dein Team schneller wird, wo es stecken bleibt und worüber du vielleicht in deiner nächsten Retrospektive sprechen möchtest.\n\n![Abarbeitungs- und Burnup-Diagramme](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097577/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097576758.png)\n\n## 5 Gründe, warum eine einheitliche Plattform einen Vorteil bietet\n\nEs gibt viele Planungstools, die SAFe-Zeremonien handhaben können. Aber es gibt sehr gute Gründe, die für GitLab sprechen:\n\n1. **Kein Kontextwechsel mehr**: Planung, Programmierung, Testen und Sicherheit finden alle an einem Ort statt.  \n2. **Alles ist miteinander verbunden**: Du kannst die Arbeit vom großen Epic bis hinunter zum Code und zur Bereitstellung verfolgen.  \n3. **Alle sind auf dem gleichen Stand**: Entwickler(innen), Produktverantwortliche und Sicherheitsteams arbeiten alle mit demselben Tool zusammen.  \n4. **Vollständige Transparenz**: Stakeholder haben einen zentralen Ort, an dem sie nach Updates suchen können.  \n5. **Das Gesamtbild**: Du siehst Planungs- und Entwicklungsmetriken zusammen, damit du weißt, was wirklich vor sich geht.\n\nWenn deine Entwicklungsteams GitLab bereits schätzen, warum sollten sie dann für das Planen zu einem anderen Tool wechseln oder komplexe, zusammengeschusterte Integrationen erstellen? Wenn du deine SAFe-Planung in GitLab integrierst, wird die Arbeit für alle Beteiligten erheblich vereinfacht.\n\n## Implementierungsgrundsätze\n\nIch habe mit Teams zusammengearbeitet, die von traditionellen SAFe-Tools zu GitLab wechselten. Dabei habe ich Folgendes gelernt: Konzentriere dich auf **das, was jede Zeremonie zu erreichen versucht**, und nicht auf die exakte Nachbildung deiner alten Tools.\n\nDie Teams, die GitLab optimal nutzen, sind diejenigen, die die nativen Funktionen nutzen, anstatt dagegen anzukämpfen. Ja, es erfordert einige Vorarbeit, um herauszufinden, wie du deine SAFe-Konzepte abbilden und deine Workflows einrichten kannst. Aber wenn das einmal erledigt ist, wirst du feststellen, dass deine Prozesse tatsächlich einfacher und nicht komplexer werden.\n\nDer Schlüssel liegt in der Definition von Konventionen, die jeder befolgt. Welche Labels stehen für was? Wie wirst du Teams verfolgen? Was gehört in ein Epic und was in ein Ticket? Mit ein wenig Vorarbeit bei diesen Entscheidungen erhältst du ein intuitives System, das den gesamten Koordinationsaufwand zwischen verschiedenen Tools eliminiert.\n\n## Erste Schritte\n\nBereit, es auszuprobieren? So beginnst du mit der Implementierung von SAFe in GitLab:\n\n1. **Richte deine Struktur ein**: Erstelle Gruppen und Untergruppen, die [deiner Organisation entsprechen](https://about.gitlab.com/de-de/blog/best-practices-to-set-up-organizational-hierarchies-that-scale/).  \n2. **Definiere deine Aufgabenverteilung**: Entscheide, wie du [Epics](https://about.gitlab.com/de-de/blog/unlocking-agile-excellence-gitlab-epics-for-seamless-portfolio-management/), [Tickets](https://docs.gitlab.com/user/project/issues/managing_issues/) und [Aufgaben](https://docs.gitlab.com/user/tasks/) verwenden möchtest.  \n3. **Erstelle deine Iterationen**: Richte deinen [Sprint-Zeitplan](https://docs.gitlab.com/user/group/iterations/#create-an-iteration-cadence) ein.  \n4. **Füge deine Meilensteine hinzu**: [Meilensteine](https://docs.gitlab.com/user/project/milestones/#create-a-milestone) stellen deine Programmschritte in GitLab dar.  \n5. **Erstelle deine Boards**: Erstelle verschiedene Ansichten für verschiedene Zeremonien.  \n6. **Konventionen vereinbaren**: Dokumentiere, wie du Labels und benutzerdefinierte Felder verwendest.\n\nWenn du dir im Voraus die Zeit nimmst, diese Entscheidungen zu überdenken, ersparst du dir später viele Kopfschmerzen. Und denke daran, dass du es nicht am ersten Tag perfekt machen musst – du kannst jederzeit Anpassungen vornehmen, während du dazulernst.\n\n## Alles zusammenbringen\n\nGitLab bietet dir eine solide Grundlage für die Ausführung von SAFe, insbesondere wenn deine Entwicklungsteams bereits von GitLab begeistert sind. Wenn du Planung und Entwicklung in einem einzigen Tool vereinst, eliminierst du lästige Übergaben, erleichterst die Zusammenarbeit und beschleunigst den gesamten Prozess.\n\nDas Schöne an den Planungstools von GitLab ist, dass sie flexibel genug sind, um sich an deine spezifischen SAFe-Anforderungen anzupassen. Du bist nicht an starre Arbeitsabläufe gebunden, sondern kannst deinen Ansatz weiterentwickeln, wenn deine Teams erfahrener werden und sich deine Bedürfnisse ändern.\n\n> Bist du bereit zu erkennen, wie viel besser das Leben ohne diese Planungsinseln ist? [Starte noch heute deine kostenlose Testversion](https://about.gitlab.com/de-de/free-trial/) und erfahre aus erster Hand, wie GitLab deine SAFe-Implementierung verändern kann.\n\n* 💡 Wenn dir dieser Beitrag gefallen hat, lies auch den folgenden Beitrag dazu: [GitLab für die Agile-Softwareentwicklung](https://about.gitlab.com/de-de/blog/gitlab-for-agile-software-development/)*\n",[794,808,809,765,810],"DevSecOps platform","features","tutorial","2025-05-12",{"slug":813,"featured":91,"template":797},"safe-without-silos-in-gitlab",{"content":815,"config":824},{"title":816,"description":817,"authors":818,"heroImage":819,"date":820,"body":821,"category":673,"tags":822,"updatedDate":820},"Wie OKRs deine Software-Entwicklung voranbringen","Die weltweit größten Unternehmen vertrauen auf OKR. Hier bekommst du den besten Einstieg im Netz.",[789],"https://res.cloudinary.com/about-gitlab-com/image/upload/v1749663217/Blog/Hero%20Images/AdobeStock_790549874.jpg","2025-04-02","# Wie OKRs deine Softwareentwicklung voranbringen\n\nObjectives & Key Results – Ziele und Schlüsselergebnisse. Das klingt zunächst einmal recht einfach. Und nahezu alle, die mit OKRs arbeiten, können bestätigen, dass die Methode denkbar unkompliziert ist.\n\nDennoch wurden einige der wertvollsten Unternehmen der Gegenwart auf dieser rasch erlernbaren Methode aufgebaut. Von Google über Intel bis hin zu Apple – OKRs haben die Welt der Planung und Organisation im Sturm erobert.\n\nIn der Softwareentwicklung lassen sich OKRs organisch in agiles Management und in die unterschiedlichsten Strukturen einbinden. OKR ist ein Managementansatz, der schnell und ohne hohen finanziellen Aufwand umgesetzt werden kann. Das macht ihn geradezu ideal für kleine und mittelständische Unternehmen.\n\nIn diesem Artikel zeigen wir dir, wie du OKRs für das Formulieren und Erreichen deiner Entwicklungsziele einsetzen kannst und was es dabei zu beachten und zu vermeiden gilt.\n\n## Was sind OKRs?  \n\nOKR ist ein Ansatz, der das Erreichen qualitativer betrieblicher Ziele an empirisch messbare Ergebnisse bindet.  \n\nDer Begriff beinhaltet zwei Teile:\n\n**Objectives** – hierbei handelt es sich um die zu erreichenden Ziele.\n\n**Key Results** – dies sind die Kennziffern, mit denen du überprüfen kannst, ob das Ziel erreicht wurde.\n\nWenn du mit OKR arbeitest, setzt du dir somit klare, am Kundennutzen ausgerichtete Ziele, und prüfst während ihrer Umsetzung kontinuierlich und anhand eindeutig quantifizierbarer Werte, ob du Fortschritte machst.\n\n## OKR-Methode: Ein Beispiel  \n\nWie sieht dieser Prozess beispielsweise in der Entwicklungspraxis aus?\n\nNehmen wir an, aus Feedback-E-Mails sei hervorgegangen, dass deine international aktiven Kunden nicht zufrieden sind mit der Funktionalität deiner Buchhaltungssoftware. Du möchtest deswegen ein neues Feature entwickeln, das internationalen Geschäften automatisch die korrekten und erforderlichen Informationen, Vorlagen und Umsatzsteuereinstellungen bereitstellt. Nutzer(innen) brauchen nur noch das Land einzustellen und die Software kümmert sich um die korrekte Abwicklung.\n\nAls Ziel gibst du deinem Team vor, die Software so zu erweitern, dass sie euren bestehenden Kunden die Rechnungsstellung und Buchung grenzüberschreitender Transaktionen spürbar erleichtert.\n\nFolgende Key Results sollen den Erfolg des Projekts ermitteln:\n\nDie Anzahl der Beschwerde-E-Mails zu diesem Thema soll auf Null reduziert werden.\nDas Rating der Software auf Bewertungsportalen soll um mindestens 0,5/5 Punkte gesteigert werden.\n\nDie Aktion soll zu mindestens 500 Neukunden führen.\n\nDieses Beispiel macht klar, wie einfach OKRs umzusetzen sind. Und auch, wenn solche OKR-Beispiele trivial klingen mögen - in der betrieblichen Praxis ist es das keineswegs.\n\n## Fokus: Warum OKRs ein Gamechanger sind\n\nAuch, wenn OKRs keine revolutionäre neue Methode darstellen, so bieten sie doch eine neue Weise, über Management zu denken.\n\nDank OKRs können Ziele zum einen nicht mehr von Ergebnissen getrennt werden.\n\nDas Formulieren von Zielen bringt dein Unternehmen nur dann nach vorne, wenn du sie überprüfen kannst. Und die Arbeit an einem Projekt war nur dann erfolgreich, wenn du nachweisen kannst, dass die angestrebten Ziele erreicht wurden.\n\nZweitens legt OKRs großen Wert auf objektivierbare Ergebnisse. Gerade in Unternehmen, die noch mit traditionellen Top-Down-Hierarchien arbeiten, liegt es oftmals im Ermessen der oberen Managementebenen, die Ergebnisse aufgrund „heuristischer” Verfahren oder schlicht persönlicher Einschätzung zu beurteilen. Das führt zu Verzerrungen und Fehleinschätzungen.\n\nDie Key Results in OKRs hingegen sind unzweideutig. Entweder ein Schlüsselergebnis wurde erreicht oder nicht.\n\nOKRs bieten ein einfaches System mit einer komplexen Wirkung. Es reduziert den gesamten Planungsprozess auf nur zwei Komponenten. Gerade innerhalb einer zunehmend komplexen Wirtschaft ist das ein deutlicher Vorteil gegenüber anderen Ansätzen.\n\nDieses Prinzip wird oft auch unter dem Punkt „Fokus” zusammengefasst, also der scharfen Ausrichtung ihrer Planung auf klar umrissene Ziele und Ergebnisse. Fokus ist eine der fünf sogenannten “Superkräfte” der OKRs.\n\n## Warum OKRs Outcome statt Output betonen\n\nDer Unterschied zwischen Outcome und Output scheint rein semantischer Natur zu sein. In OKRs jedoch trennen die beiden Begriffe Welten.\n\nEinfach gesagt ist ein Output eine Leistung, die du für deinen/deine Kunden(in) erbringst. Das kann beispielsweise ein neues Software-Feature sein. Ein Outcome orientiert sich darüber hinaus noch dafür, welchen Nutzen dieses Feature dem/der Kunden(in) konkret bietet.\n\nOKRs sollten immer so formuliert werden, dass sie den Outcome in den Mittelpunkt stellen. Das bedeutet zugleich, dass sich Milestones – Meilensteine in der Produktentwicklung – in diesem Rahmen nicht eignen, da sie in der Regel Output-orientiert sind.\n\nOKRs sind keine Aufgabenliste, die du abarbeitest. Sie orientieren sich stets daran, dem/der Kunden(in) größtmöglichen Nutzen zu bieten.\n\n## Es gibt drei verschiedene Arten von Objectives\n\nEin weiterer wichtiger Aspekt, der die OKR-Methode deutlich interessanter macht, als sie auf den ersten Blick erscheinen mag, ist die Unterteilung der Ziele in drei Typen: Committed, Aspirational und Learning.\n\n**Committed Objectives** sind Ziele, für deren Umsetzung du dich fest verbürgst. Es gibt hier keinen Spielraum: Es gilt, ein Objective umzusetzen und entweder es wird zu 100 % umgesetzt oder gar nicht.\n\n**Aspirational Objectives**, auch gelegentlich als „Stretch objectives” bezeichnet, gehen einen Schritt weiter. Diese Ziele haben den Charakter von Idealen oder, um ein beliebtes Wort zu gebrauchen, „Visionen”. Sie stehen für Ansprüche, die du an dich und dein Unternehmen stellst, aber vielleicht zu diesem Zeitpunkt noch nicht erfüllen kannst.\n\n**Learning Objectives** kommen immer dann zum Tragen, wenn es vor allem darum geht, mit der Arbeit an bestimmten Zielen den eigenen Horizont zu erweitern oder mehr Daten zu sammeln, um die eigentlichen Ziele klarer erfassen zu können.\n\n## Die besondere Bedeutung von Stretch Goals\n\nMan kann OKRs auch ohne Stretch Goals einsetzen. Dennoch sind es gerade diese ambitionierten Ziele, die diese Managementmethode so beliebt gemacht haben. Der durchschlagende Erfolg, den OKRs in den frühen Jahren von Google und bei Intel verzeichneten und der beide Unternehmen gegenüber der Konkurrenz entscheidend nach vorne gebracht hat, beruht zu einem wesentlichen Teil auf ihnen.\n\nAuch aus diesem Grund ist „Stretching” einer der Kernaspekte der OKR-Methode und eine der fünf OKR-Superkräfte.\n\nStretch Objectives sind nicht erreichbar. Aber genau wie ein Muskel nur wachsen kann, wenn er immer wieder über seine aktuelle Belastbarkeit hinaus beansprucht wird, kann auch eine Organisation nur Fortschritte machen, wenn sie ihre Grenzen erforscht. Aspirational Goals sind der Baustein der OKR-Methode, der genau dies anstrebt.\n\nDas besondere: Stretch Objectives sind keine langfristigen Leitbilder, sondern sie sind durchaus praktisch angelegt. Sie können sowohl auf niedriger als auch auf hoher Hierarchieebene Anwendung finden und stehen neben „Committed Objectives”, die zu 100 % erfüllt werden sollen.\n\nDie Idee dahinter: Auch, wenn du vielleicht nur 70 % eines epischen Ziels erreichst – und im eigentlichen Sinne an deiner Aufgabe gescheitert bist, kann das, was am Ende dabei herausgekommen ist, dennoch bemerkenswert sein.  \n\n## Google Chrome: Stretching in der Praxis\n\nDie Energien, die beim Stretching freigesetzt werden, sind in der Praxis oftmals erstaunlich. Eines der meistzitierten Beispiele für OKRs  ist, wie Google den Markt für Webbrowser mit Chrome geradezu überrollte.\n\nDas erklärte Ziel (Objective) des Unternehmens lautete 2006, den besten Browser der Welt zu entwickeln. Als Key Result wählte man schlicht die globalen Nutzerzahlen: Man wollte nach Abschluss des ersten Jahres nach Einführung von Chrome die Zahl von 20 Millionen Usern erreichen.\n\nDieses Ziel verfehlte der mit der Leitung des Projekts beauftragte Sundar Pichai deutlich – es waren nur 10 Millionen. Statt den Kopf hängen zu lassen, betrachtete er das Ergebnis aus der Perspektive des Stretchings: 10 Millionen User aus dem Stand heraus war eine geradezu astronomisch hohe Zahl und belegte, dass man auf dem besten Weg war.\n\nNiemand wollte den Erfolg mehr als Pichai, der laut einem Business-Insider-Portrait zu Sundar Pichai sogar maßgeblich daran beteiligt war, die Google-Gründer von dem Chrome-Projekt zu überzeugen. Und so gab er für das nächste Jahr das Key Result von 50 Millionen vor. Es wurden 37 Millionen. Im letzten Jahr der Offensive schließlich lautete die Vorgabe 100 Millionen Benutzer. Diese überbot Pindar sogar um 11 Millionen. 2011 hatte Chrome den langjährigen Marktführer, Microsofts Internet Explorer, überholt und war zum meistgenutzten Browser geworden. Eine schöne Übersicht zu dieser Erfolgs-Story gibt es bei Digitalcoach.\n\nHieraus wird ersichtlich, dass Stretching, wenn es konsequent und auf das richtige Produkt angewandt wird, ein enormer Motivations-Booster sein kann.\n\nWie fügen sich diese Prinzipien zu einem kohärenten Framework zusammen? Durch Alignment, Commitment und Tracking.\n\n## Alignment: Alle machen mit\n\nDas OKR-Framework ist auf eine natürliche Art und Weise mit dem Agile-Framework verbunden. Ein wesentlicher Punkt ist, dass Objectives and Key Results Teil der Arbeitsorganisation auf jeder Ebene deines Unternehmens werden müssen.\n\nDas bedeutet, dass die oberen Ebenen OKRs nach unten delegieren, aber untere Ebenen auch OKRs nach oben weiterleiten. Es findet ein ständiger Austausch statt. Anstatt sich nur darauf zu konzentrieren, starr Ziele umzusetzen, wird den Teams viel Spielraum zur Entfaltung gewährt.\n\nSich aktiv an der OKR-Planung und den Rückmeldungsschleifen zu beteiligen, ist ein integraler Teil der Philosophie.\n\nMan bezeichnet diesen Prozess auch als “Alignment”, also die kontinuierliche Ausrichtung und Abstimmung zwischen verschiedenen Teams und Hierarchien. Daten fließen stets sowohl von unten nach oben und von oben nach unten und auf einer horizontalen Ebene in alle Richtungen.\n\nOKRs verschmelzen zudem Planung und Ausführung und überbrücken damit eine der traditionell größten Lücken in der Planerfüllung.\n\n## Commitment: Motivation\n\nEng verbunden mit dem Alignment ist das Commitment, also der Wunsch, dass sich alle Mitarbeiter(innen) einer Organisation voll und ganz mit einem Ziel identifizieren und sich dessen Erreichung verschreiben. Je mehr es für den/die Einzelnen(e) erkennbar wird, wie er/sie zum Erreichen beiträgt, desto höher wird seine/ihre Motivation sein, produktiv dazu beizutragen.\n\nEs war dieser Aspekt in Kombination mit einer flachen Hierarchie, der OKRs bei Intel und Google so effektiv machte. Von Anfang an war allen Beteiligten klar, dass man in einem Boot saß und dass jeder(e) seinen/ihren Beitrag leisten konnte.\n\nAlignment und Commitment sind zwei weitere Superkräfte des OKR. Sie werden ganz unmittelbar durch das Tracking unterstützt.\n\n## Tracking: Ergebnisse fassbar machen\n\nTracking bezeichnet den praktischen Prozess der Erfassung der Key Results.  Erst durch Tracking wird die OKR-Planung agil und aus einer Reihe von Vorgaben ein System zur Zielerreichung. Wegen dieser zentralen Rolle ist Tracking die letzte der fünf Superkräfte der OKRs.\n\nOKRs sind aufgrund der ständigen Kontrolle und des Fokus auf Objektivierbarkeit eng mit der agilen Methodologie verbunden. Ziele werden ständig auf ihre Erreichbarkeit hin getestet und gegebenenfalls neu formuliert.\n\nSolange die Key Results sinnvoll gesetzt sind, sollte das Tracking nicht kompliziert sein. Komplexer und umstrittener gestaltet sich hingegen die Frage, wie die Ergebnisse anschließend bewertet werden sollen.\n\nEigentlich geben OKRs vor, dass Ziele zu 100 % erreicht werden sollen. Für manche Unternehmen aber ist dieses Denken, so nützlich es sich in der Praxis oftmals auch erweist, zu Schwarzweiß. Sie bevorzugen es, innerhalb eines Systems zu arbeiten, bei dem Ergebnisse abgestuft bewertet werden, so dass auch ein Nichterreichen nicht sofort als ein „Scheitern” eingestuft werden muss.\n\nGrading ist die Antwort auf diesen Wunsch.\n\n## Was ist Grading in OKRs? \n\nBeim Grading werden die Key Results entweder prozentual oder mit farblichen oder symbolischen Abstufungen bewertet, die es ermöglichen, das weitere Vorgehen genauer zu bestimmen.\n\nWar der angesetzte Zeitraum zu kurz? Das Ziel zu hoch gesteckt? Oder konnte das Ziel zu diesem Zeitpunkt grundsätzlich nicht erreicht werden? Diese Fragen werden im Grading beantwortet, um anschließend neue OKRs zu setzen.\n\nAuch bei Stretch Objectives kann Grading zur Anwendung kommen. Waren die 10 Millionen Chrome-Nutzer nach Ende des ersten Geschäftsjahres ein Triumph trotz Zielverfehlung - oder eben doch ein Misserfolg? Grading kann helfen, hier zu zufriedenstellenden Einschätzungen zu gelangen.\n\n## OKRs: Eine Vorlage\n\nUm mit OKRs zu arbeiten, brauchst du keinen Kurs zu belegen. Die Methode ist so intuitiv, dass du im Grunde genommen sofort damit anfangen kannst.\n\nDas Festlegen von OKR-Zielen wird den Meisten dabei noch recht leicht von der Hand gehen.\n\nEs hilft, als OKR Vorlage folgende Formulierung zu wählen:\n\n**„Wir werden [Ziel], gemessen in [Schlüsselergebnisse]”**\n\nDas mutet noch etwas abstrakt an. Anhand eines OKR-Beispiels wird dir aber recht schnell klar werden, wie so ein Satz konkret aussehen kann. Erinner dich daran, wie wir vorher beschrieben haben, wie Google den Chrome-Browser zum meistbenutzten der Welt machte. Sundair Pindai gab damals schlicht das folgende Objective aus:\n\n„Wir werden Chrome zum besten Browser machen ...”\n\nUnd das dazugehörige Key Result:\n\n„... gemessen an 20 Millionen Nutzern.”\n\n### Sind alle OKR-Ziele Stretch Objectives?\n\nGanz gewiss muss nicht bei jedem Objective gestretcht werden. Man kann sogar mit Recht behaupten, dass zu viel Stretching im wahrsten Sinne des Wortes die Organisation auf die Zerreißprobe stellen kann.\n\nWohl aber empfiehlt es sich, die OKR-Ziele so zu setzen, dass sie nicht „alltäglich” sind. Sie sollen eine Herausforderung darstellen und Zweifel an ihrer Erreichbarkeit immer gegeben sein.\n\nDiese Spannung ist ein wichtiger Aspekt dabei, dass OKRs Innovation und Motivation in deinem Unternehmen erhöhen. Sie fördern ein gesundes, mitarbeitergetriebenes Wachstum.\n\n## OKRs tracken\n\nAus diesem Beispiel geht hervor, dass die Key Results die eigentliche Herausforderung darstellen. Um beim Chrome-Beispiel zu bleiben: Dass die Nutzerzahlen wirklich der Maßstab für Qualität sind („der beste Browser”), ist nicht direkt ersichtlich.\n\nIm Zweifelsfall ergibt es Sinn, sich für solche unmittelbar fassbaren und einfach zu trackenden Werte zu entscheiden. Wenn sich auf dem Weg zum Ziel bessere Key Results offenbaren, ist es einfacher, diese anzupassen, als das ursprüngliche Ziel aufzugeben.\n\nSicher spielte für Sundar Pinchai eine Rolle, dass die Google-Geschäftsleitung nach seiner Überzeugungsarbeit den Browser-Krieg zur Chefsache gemacht und den „Sieg” zu einer strategischen Priorität erklärt hatte.\n\nDas eigentlich Entscheidende aber ist, dass Key Results auf Erfahrungswerten aufbauen und von den Teammitgliedern gesetzt werden, die eine kompetente Aussage über ihre Erreichbarkeit (oder Nichterreichbarkeit) machen können. Nur, wer die Key Results auf Daten aufbaut, kann erwarten, dass die Ergebnisse den Key Results entsprechen.\n\n## Wer ist für die Umsetzung der OKRs verantwortlich?\n\nBei Objectives and Key Results sind alle Teams sowohl für sich als auch kollektiv verantwortlich für das Erreichen oder Verfehlen der Ziele. Eine strenge „Kontrollinstanz” würde dem intrinsischen Charakter widersprechen.\n\nDennoch empfiehlt es sich, eine oder sogar zwei Personen in deiner Organisation damit zu beauftragen, den OKR-Prozess am Laufen und auf Kurs zu halten und gegebenenfalls sanft gegenzusteuern oder mit den Teams an allgemeinen Verbesserungen zu arbeiten.\n\nDies ist die Aufgabe des/der OKR Masters, gelegentlich auch „OKR Champion\" oder „OKR Coach\" genannt.\n\nDie Agile Heroes definieren in ihrem Artikel zum Thema OKR Master den/die OKR Master als „die Person im Unternehmen, die die Mitarbeiter(innen) dabei unterstützt, OKR bestmöglich zu verstehen und umzusetzen.”\n\nOKR Master sind in der Regel vor allem an der Erarbeitung und Kommunikation der OKRs beteiligt. Sie stoßen den Prozess an, halten sich aber danach zumeist eher im Hintergrund. Im Idealfall scheiden sie kurz nach Beginn des Projekts aus dem aktiven OKR-Prozess aus.\n\nGelegentlich wird noch der/die OKR-Botschafter(in) unterschieden (OKR Ambassador), die üblicherweise mit dem/der Teammanager(in) zusammenfällt. Sein/ihre Aufgabe besteht in der Koordination und Begleitung der praktischen Arbeit, der Beantwortung von Fragen und der Erstellung der abschließenden Auswertung. \n\n## Wie OKRs eine Eigendynamik entwickeln\n\nObjectives and Key Results ist keine Methode, die deiner derzeitigen Organisation gewaltsam übergestülpt wird. Sie ist auch kein Gegenmodell zu KPIs. Während KPIs sich auf die Leistungsbewertung konzentrieren, setzen OKRs einen Schritt vorher, bei der Zielsetzung selbst, an.\n\nDas Besondere an OKRs besteht darin, dass die Vorteile sich selbst verstärken und sich so zunehmend auf das gesamte Unternehmen und alle Prozesse auswirken:\n\nWeil OKRs Teams zu mehr Eigenengagement zwingen, entwickeln diese wiederum die Kompetenzen, um aus Eigeninitiative heraus selbst Ziele vorzuschlagen und umzusetzen.\nWeil OKRs die Zusammenarbeit zwischen Teams erfordern, stärken sie den inneren Zusammenhalt der Organisation. Dies wiederum erleichtert die zukünftige Zusammenarbeit.\nEine höhere intrinsische Arbeitsmotivation erlaubt die Umsetzung komplexerer, anspruchsvollerer OKR-Ziele, die wiederum eine höhere Motivation und Zufriedenheit bieten.\nWenn Tracking konsequent nur als Maßstab zur Zielerreichung genutzt wird und nicht zur Leistungsbeurteilung, spornt es alle Mitarbeiter(innen) zu vollem Einsatz an.\nTracking kann auch offenbaren, wo Optimierungsbedarf besteht, was wiederum die Arbeit mit OKRs erleichtert.\nErfolgreich absolvierte Objectives oder auch annähernd erreichte Stretch Objectives können als Erfolg aller Mitarbeiter eines Projekts, nicht nur der unmittelbar Verantwortlichen, gefeiert werden.\n\n## OKRs: FAQs\n\n### Sind OKRs Teil des agilen Managements?\n\nObjectives and Key Results sind auf jeden Fall eng mit den Prinzipien agilen Managements verbunden.\n\nHierfür spricht unter anderem, dass OKRs stets objektiv messbar sein müssen und bei dieser Methode großer Wert auf Feedback-Schleifen, regelmäßige Meetings und Teamarbeit gelegt wird.\n\nAus diesem Grund finden OKRs in ähnlichen Branchen und Unternehmen Anwendung wie agiles Management – unter anderem auch im IT-Bereich sowie in der Softwareentwicklung.\n\n### Kann ich OKRs mit Gitlab nutzen?\n\nBei GitLab sind wir von den Konzepten und Erfolgen von OKRs überzeugt. Deswegen arbeiten wir daran, dass du mit OKRs auch in GitLab arbeiten kannst.\n\nDas Projekt befindet sich aktuell noch in einer experimentellen Phase, ist aber durchaus praktisch anwendbar.\n\nMehr Informationen dazu findest du in unserem ausführlichen Artikel zu GitLab und OKRs (Englisch), in dem wir alle Schritte zur Umsetzung genau erklären.\n\n### Sind OKR dasselbe wie Management by Objectives?\n\nZwischen OKR und MBO (Management by Objectives) besteht ein enger Zusammenhang. Historisch sind Objectives & Key Results, wie die ähnliche Begrifflichkeit bereits nahelegt, aus MBO hervorgegangen.\n\nSo kann man Objectives and Key Results als Erweiterung und Neuausrichtung des in den 1950ern entwickelten Management by Objectives betrachten. Während MBO den Prozess genau vorgibt, tendenziell in langen Zyklen denkt, Outputs vorgibt und streng von einer Top-Down-Hierarchie ausgeht, fordert und fördert der OKR-Prozess kürzere Zyklen, Outcome statt Output und die Nutzung sowohl von Top-Down- als auch Bottom-Up-Flüssen.\n\nKurz gesagt: OKR ist die Umsetzung von MBO in einem Agile-Management-Framework.\n\n### Ist für die Einführung von OKRs ein Training erforderlich?\n\nEs wird gelegentlich gefordert, dass die Einführung von OKRs in einem Unternehmen über einen Sponsor und unter Begleitung von Trainern stattfindet.\n\nWir meinen: Tatsächlich empfiehlt sich die Unterstützung des OKR-Prozesses durch eine erfahrene Coaching-Persönlichkeit. Dies sollte sich aber nicht auf die Ersteinführung beschränken.\n\nEin OKR-Coach – auch OKR Master genannt – kann genau diese Aspekte begleiten und dazu beitragen, dass die verschiedenen Hierarchieebenen aufeinander abgestimmt werden und die Kommunikation der OKRs im Unternehmen stets offen, transparent und frei funktioniert.\n\nEin separates Training kann unter Umständen hilfreich sein, aber auch den Eindruck erwecken, dass OKRs ein komplexes Regelwerk beinhalten – was definitiv nicht der Fall ist.\n\n### Wie verhalten sich Objectives and Key Results zu Scrum oder Kanban?\n\nOKRs bilden eine Brücke zwischen verschiedenen agilen Management-Methoden.\n\nKPIs sind grundlegende, quantifizierbare Werte, welche ein Unternehmen selbst vorgibt. OKRs verbinden dieses Denken mit der praktischen Zielsetzungsebene und der Ausführung.\n\nAgile Führung mit OKRs kann sehr unkompliziert in einem Kanban-Board dargestellt werden. Weil Scrum selbst deutlich spezialisierter ist als Kanban, fallen die Unterschiede hier größer aus.\n\nWie die Computerwoche bemerkt, wird Scrum „meist in der Produktentwicklung eingesetzt, OKR dagegen findet überwiegend im gesamten Unternehmen Anwendung, die Produktentwicklung eingeschlossen.” Vielleicht gerade deswegen ergänzen sich die beiden geradezu optimal:\n\n„Zur Umsetzung von Zielen bedarf es mit rasch verändernden Anforderungen und Rahmenbedingungen einer iterativen und agilen Vorgehensweise. Hier kommt Scrum (oder ggf. Kanban) ins Spiel und ergänzt damit OKR ideal. Scrum (bzw. Kanban) unterstützt die operative Ausführung der Aufgaben, hilft bei der iterativen Umsetzung von Projekten und Aufgaben und trägt damit zum Fortschritt der Key Results bei.”\n\n### Erfordern OKRs eine ausführliche Dokumentation?\n\nNein. Viele Unternehmen verlangen, dass im Rahmen von Objectives and Key Results ausführlich der gesamte Prozess beobachtet wird und am Ende eines jeden Zyklus die Ergebnisse in einem Report zusammengefasst und analysiert werden.\n\nDies steht aber eher im Widerspruch zu der agilen Philosophie hinter dem Konzept.\n\nRichtig ist vielmehr: OKRs legen großen Wert auf Empirismus und Daten – aber nur die Daten, die zu Anfang als Key Results definiert wurden. Alles, was darüber hinausgeht, macht den OKR-Prozess weniger effizient und sollte deswegen auf ein Minimum beschränkt werden.\n\n### Sollen die Objectives bei OKRs gar nicht erreicht werden?\n\nDies ist ein durchaus beliebtes Missverständnis. Tatsächlich meinen viele, OKRs gäben vor, dass die Ziele so formuliert und die Key Results so gesetzt würden, dass sie innerhalb eines Zyklus überhaupt nicht erreicht werden könnten.\n\nEs stimmt, dass Objectives and Key Results Stretching als Motivationsmittel und ganz generell Zielvorgaben empfehlen, die über das zu Erwartende hinausgehen. Die meisten OKR-Ziele aber sind „lediglich” committed und sollen sehr wohl erfüllt werden – und zwar zu 100 %.\n\nStretching ist keine Anleitung dazu, das Unmögliche zu fordern, sondern ein Instrument, alle Mitarbeiter(innen) zu Höchstleistungen zu inspirieren und sich anschließend auch dann an dem Geleisteten zu erfreuen, wenn das Ziel knapp verfehlt wurde.\n\nDies betont erneut, wie wichtig es ist, dass die Key Results auf praktischen Erfahrungen beruhen und kein theoretisches Konstrukt bleiben.\n",[823],"collaboration",{"slug":825,"featured":6,"template":797},"what-are-okrs",{"category":680,"slug":684,"posts":827},[828,842,854],{"content":829,"config":840},{"title":830,"description":831,"authors":832,"heroImage":834,"date":835,"body":836,"category":684,"tags":837,"updatedDate":839},"GitLab Duo Chat wird jetzt zum agentischen KI-Assistenten ","Unser neuer GitLab Duo Chat, der derzeit ein experimenteller Release ist, hilft Entwickler(inne)n, sich in Projekte einzuarbeiten, Aufgaben zu verstehen, Änderungen umzusetzen und mehr.",[833],"Torsten Linz","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099203/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%2820%29_2bJGC5ZP3WheoqzlLT05C5_1750099203484.png","2025-05-29","Generative KI-Chat-Assistenten sind in kurzer Zeit zum Standard in der Softwareentwicklung geworden und helfen dabei, Code zu erstellen und zu verbessern. Stell dir nun vor, dein Chat-Assistent könnte die Artefakte deines gesamten Entwicklungsprozesses und nicht nur deinen Code verstehen.\n\nWas wäre, wenn dieser Chat-Assistent dir hilft, Tickets und Projektdokumentationen zu bearbeiten, bevor er dich beim Programmieren unterstützt, und auf CI/CD-Pipelines und Merge Requests zugreifen könnte, um dich bei der ordnungsgemäßen Durchführung von Programmieraufgaben zu begleiten?\n\n**Lerne die nächste Generation von GitLab Duo Chat kennen – GitLab Duo Agentic Chat, eine bedeutende Weiterentwicklung in der KI-nativen Entwicklungsunterstützung und die neueste Ergänzung unserer Plattform, die jetzt als [experimenteller Release (nur in englischer Sprache)](https://docs.gitlab.com/policy/development_stages_support/#experiment) verfügbar ist.** \n\nGitLab Duo Agentic Chat ist für alle GitLab.com-Benutzer(innen) mit der Workflow-Erweiterung von GitLab in VS Code verfügbar.\n\nMit Agentic Chat ist der Chat nicht mehr bloß eine herkömmliche dialogorientierte KI, sondern wird zum Chat-Assistenten, der in deinem Namen selbst handelt und komplexe Probleme in einzelne Aufgaben unterteilt, die er lösen kann. Anstatt einfach nur Fragen mit deinem angegebenen Kontext zu beantworten, kann Agentic Chat:\n\n* **Autonom feststellen**, welche Informationen er braucht, um deine Fragen zu beantworten\n* **Eine Reihe von Vorgängen ausführen**, um diese Informationen aus verschiedenen Quellen zu sammeln\n* **Umfassende Antworten formulieren**, indem er Einblicke aus deinem gesamten Projekt kombiniert\n* **Dateien erstellen und bearbeiten**, um dir dabei zu helfen, Lösungen zu implementieren.\n\nDabei bleibt stets der Mensch als Entwickler(in) involviert.\n\nAgentic Chat basiert auf der Architektur von Duo Workflow, der derzeit in der [privaten Beta-Version verfügbar ist](https://about.gitlab.com/de-de/blog/gitlab-duo-workflow-enterprise-visibility-and-control-for-agentic-ai/). Die Architektur besteht aus Agenten und Tools, die bestimmte Aufgaben übernehmen, z. B. den richtigen Kontext für eine bestimmte Frage finden oder Dateien bearbeiten. \n\n**Anwendungsfälle für GitLab Duo Agentic Chat**\n\nHier findest du einige praktische und häufige Anwendungsfälle für Agentic Chat:\n\n* Arbeite dich schneller in neue Projekte ein, indem die KI dir hilft, mit einer neuen Codebase vertraut zu werden.\n\n* Lege sofort mit der zugewiesenen Arbeit los, auch wenn Ticketbeschreibungen unklar sind. Agentic Chat kann dir nämlich helfen, die Lücke zwischen Anforderungen und bestehenden Implementierungen zu überbrücken.\n\n* Wenn du Änderungen vornehmen möchtest, kann Agentic Chat die Implementierung übernehmen, indem er Dateien übergreifend über dein Projekt erstellt und bearbeitet.\n\n* Wenn ein Release ansteht, kann dir Agentic Chat helfen, zu überprüfen, ob deine Lösung die ursprünglichen Anforderungen auch tatsächlich erfüllt, indem er deinen Merge Request anhand des ursprünglichen Tickets oder der ursprünglichen Aufgabe überprüft.\n\n![Agentic Chat – Beispiel](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099210/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750099210429.png)\n\n\u003Ccenter>\u003Ci>Agentic Chat bearbeitet Code\u003C/i>\u003C/center>\n\n## Vom Lernen zum Bereitstellen: eine komplette Workflow-Demonstration in vier Schritten\n\nUm dir zu zeigen, wie Agentic Chat das Entwicklererlebnis transformiert, sehen wir uns ein echtes Szenario unserer Entwicklungsteams an. Stell dir vor, du bist ein neues Teammitglied und hast ein Ticket zugewiesen bekommen, weißt aber nichts über die Codebase. Sieh dir diese Videodemonstration an:\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/uG9-QLAJrrg?si=kaOhYylMIaWkIuG8j\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n**Schritt 1: Das Projekt verstehen**\n\nAnstatt manuell die Dateien und die Dokumentation zu durchforsten, kannst du einfach folgenden Prompt in Agentic Chat eingeben:\n\n```unset\nI am new to this project. Could you read the project structure and explain it to me?\n```\n(Ich kenne dieses Projekt noch nicht. Lies dir bitte die Projektstruktur durch und erkläre sie mir.)\n\nAgentic Chat bietet dir dann wir folgt einen umfassenden Projektüberblick:\n- Er sieht sich die Verzeichnisstruktur an.\n- Er liest README-Dateien und die Dokumentation.\n- Er identifiziert wichtige Komponenten und Anwendungen.\n\n**Schritt 2: Deine zugewiesene Aufgabe verstehen**\n\nNun musst du deine jeweilige Aufgabe verstehen. Gib dazu den folgenden Prompt ein:\n\n```unset\nI have been assigned Issue 1119. Could you help me understand this task, specifically where do I need to apply the refactoring?\n```\n(Mir wurde das Ticket 1119 zugewiesen. Hilf mir bitte, diese Aufgabe zu verstehen. Wo genau muss ich das Refactoring durchführen?)\n\nAgentic Chat erklärt dir die Aufgabe und schlägt einen Refactoring-Ansatz vor, indem er wie folgt vorgeht:\n- Er ruft die Details des Tickets vom GitLab-Remote-Server ab und analysiert sie.\n- Er untersucht relevante Projektdateien.\n- Er identifiziert die spezifischen Orte, für die Änderungen nötig sind.\n\n**Schritt 3: Die Lösung implementieren**\n\nAnstatt die Arbeit manuell zu erledigen, kannst du folgende Frage stellen:\n\n```unset\nCould you make the edits for me? Please start with steps one, two, three.\n```\n(Kannst du die Bearbeitungen für mich vornehmen? Bitte beginne mit den Schritten eins, zwei und drei.)\n\nAgentic Chat geht dann so vor:\n- Er erstellt, wenn nötig, neue Verzeichnisse und Dateien.\n- Er extrahiert und refaktorisiert Code an mehreren Stellen.\n- Er stellt die Konsistenz übergreifend über alle geänderten Dateien sicher.\n- Er erstelle eine Übersicht über alle vorgenommenen Änderungen.\n\n**Schritt 4: Vollständigkeit überprüfen**\n\nNachdem nun abschließend dein Merge Request erstellt wurde, kannst du deine Arbeit überprüfen:\n\n```unset\nDoes my MR fully address Issue 1119?\n```\n\n(Löst mein MR das Ticket 1119 vollständig?)\n\nAgentic Chat bestätigt nun, dass alle Anforderungen erfüllt werden, indem er sowohl deinen Merge Request als auch das ursprüngliche Ticket analysiert.\n\n## Probiere es jetzt aus und teile dein Feedback\n\nGitLab Duo Agentic Chat ist derzeit als experimentelle Funktion in VS Code für Benutzer(innen) von GitLab Duo Pro und GitLab Duo Enterprise verfügbar. In unserer [Einrichtungsdokumentation (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/gitlab_duo_chat/agentic_chat/) findest du die Voraussetzungen und Konfigurationsschritte.\n\nDa Agentic Chat derzeit nur eine experimentelle Funktion ist, hat er einige bekannte Einschränkungen, an denen wir derzeit aktiv arbeiten. Dazu gehören langsamere Reaktionszeiten aufgrund mehrerer API-Aufrufe, eine eher schlüsselwortbasierte als semantische Suche und eine eingeschränkte Unterstützung für neue lokale Ordner oder Nicht-GitLab-Projekte. **Dein Feedback ist wichtig, damit wir die Verbesserungen priorisieren und Agentic Chat bald allgemein verfügbar machen können. Teile daher bitte deine Erfahrungen in [diesem Ticket](https://gitlab.com/gitlab-org/gitlab/-/issues/542198) mit uns.**\n\n## Wie geht es weiter?\n\nUnser Hauptaugenmerk liegt darauf, Agentic Chat zu verbessern und allgemein verfügbar zu machen. In der Zwischenzeit arbeiten wir daran, die Reaktionszeiten zu verbessern und Funktionen hinzuzufügen, die GitLab Duo Chat derzeit bietet, wie z. B. die Verwendung von selbst gehosteten Modellen oder die Unterstützung von JetBrains und Visual Studio zusätzlich zu VS Code. Sobald wir Duo Chat auf diese neue Architektur umgestellt haben, planen wir außerdem, Agentic Chat in die Chat-Funktion der GitLab-Webanwendung zu integrieren. Zudem sind viele weitere Funktionen geplant, wie z. B. die Bearbeitung von GitLab-Artefakten, die Unterstützung von Kontexten aus benutzerdefinierten Model-Context-Protocol- oder MCP-Servern und Befehle, die im Terminal ausgeführt werden können.\n\n> Möchtest du autonome Entwicklungsunterstützung erleben, bist aber noch kein(e) GitLab-Kund(in)? Probiere Agentic Chat jetzt im Rahmen [einer kostenlosen 60-tägigen Testversion von GitLab Ultimate mit Duo Enterprise](https://about.gitlab.com/de-de/free-trial/) aus und gestalte die Zukunft der KI-basierten Entwicklung mit. Folge diesen [Einrichtungsschritten für VS Code (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/gitlab_duo_chat/agentic_chat/#use-agentic-chat-in-vs-code).\n\n***Haftungsausschlussklausel: Dieser Blog enthält Informationen zu kommenden Produkten, Funktionen und Funktionalitäten. Bitte beachte, dass die Informationen in diesem Blogbeitrag nur zu Informationszwecken dienen. Bitte verlasse dich nicht auf diese Informationen, wenn du etwas kaufen oder planen möchtest. Wie bei allen Projekten können sich die in diesem Blog und auf den verlinkten Seiten genannten Punkte ändern oder verzögern. Die Entwicklung, Freigabe und der Zeitplan von Produkten, Funktionen oder Funktionalitäten liegen im alleinigen Ermessen von GitLab.***\n\n## Mehr erfahren\n\n- [GitLab Duo Workflow: Transparenz und Kontrolle für agentische KI auf Enterprise-Niveau](https://about.gitlab.com/de-de/blog/gitlab-duo-workflow-enterprise-visibility-and-control-for-agentic-ai/)\n- [Was ist agentische KI?](https://about.gitlab.com/de-de/topics/agentic-ai/)\n- [Leitfäden und Ressourcen zu agentischer KI (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/agentic-ai-guides-and-resources/)\n",[838,743,809,808,765,810],"AI/ML","2025-06-04",{"slug":841,"featured":91,"template":797},"gitlab-duo-chat-gets-agentic-ai-makeover",{"content":843,"config":853},{"heroImage":844,"body":845,"authors":846,"updatedDate":848,"date":849,"title":850,"tags":851,"description":852,"category":684},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1749658912/Blog/Hero%20Images/blog-image-template-1800x945__20_.png","## Inhaltsverzeichnis\n- [Definition von agentischer KI](#definition-von-agentischer-ki)\n- [Einblicke in die agentische KI](#einblicke-in-die-agentische-ki)\n- [Best Practices für die Implementierung von agentischer KI](#best-practices-für-die-implementierung-von-agentischer-ki)\n- [Das bietet GitLab im Bereich agentische KI](#das-bietet-gitlab-im-bereich-agentische-ki)\n - [GitLab Duo mit Amazon Q](#gitlab-duo-mit-amazon-q)\n - [GitLab Duo Workflow](#gitlab-duo-workflow)\n- [Mehr erfahren mit GitLab University (nur in englischer Sprache verfügbar)](#mehr-erfahren-mit-gitlab-university-(nur-in-englischer-sprache-verfügbar))\n- [Weitere Ressourcen zum Bereich KI](#weitere-ressourcen-zum-bereich-ki)\n\n## Definition von agentischer KI\n\nAgentische KI ist eine Form der künstlichen Intelligenz, die fortschrittliche Sprachmodelle und linguistische Datenverarbeitung nutzt, um eigenständig zu handeln. Im Gegensatz zu herkömmlichen generativen KI-Tools, bei denen ständige menschliche Anweisung nötig ist, können diese Systeme Anfragen verstehen, Entscheidungen treffen und mehrstufige Pläne ausführen, um Ziele zu erreichen. Sie bewältigen komplexe Aufgaben, indem sie sie in umsetzbare Schritte unterteilen, und setzen adaptives Lernen ein, um ihren Ansatz zu verändern, wenn sie auf Schwierigkeiten treffen.\n\n[Erfahre mehr über agentische KI](https://about.gitlab.com/de-de/topics/agentic-ai/)\n\n## Einblicke in die agentische KI\n\n- [Neue Trends in der agentischen KI, die die Softwareentwicklung verändern (nur in englischer Sprache verfügbar)](https://about.gitlab.com/the-source/ai/emerging-agentic-ai-trends-reshaping-software-development/): Erfahre, wie agentische KI die Entwicklung von isolierter Programmierung in intelligente Workflows verwandelt, die die Produktivität steigern und gleichzeitig die Sicherheit gewährleisten.\n- [Agentische KI: Entwicklungspotenzial im großen Stil](https://about.gitlab.com/de-de/the-source/ai/agentic-ai-unlocking-developer-potential-at-scale/): Entdecke, wie agentische KI die Softwareentwicklung verändert und über die Code-Vervollständigung hinausgeht, um KI-Partner zu schaffen, die komplexe Aufgaben proaktiv angehen.\n- [Agentische KI, Self-Hosted Models und mehr: KI-Trends im Jahr 2025](https://about.gitlab.com/de-de/the-source/ai/ai-trends-for-2025-agentic-ai-self-hosted-models-and-more/): Entdecke die wichtigsten KI-Trends im Bereich der Softwareentwicklung – von der lokalen Bereitstellung von Modellen bis hin zu intelligenten, adaptiven KI-Tools.\n- [Wie agentische KI das Potenzial von Platform Engineering freisetzt (nur in englischer Sprache verfügbar)](https://about.gitlab.com/the-source/ai/how-agentic-ai-unlocks-platform-engineering-potential/): Erfahre, wie agentische KI Platform Engineering verbessert, indem sie komplexe Workflows automatisiert und die Standardisierung vorantreibt.\n\n## Best Practices für die Implementierung von agentischer KI\n\n- [Implementierung effektiver Leitlinien für KI-Agenten (nur in englischer Sprache verfügbar)](https://about.gitlab.com/the-source/ai/implementing-effective-guardrails-for-ai-agents/): Entdecke die wichtigsten Sicherheitsleitlinien für KI-Tools in DevSecOps, von Compliance-Kontrollen über den Schutz der Infrastruktur bis hin zur Benutzerzugriffsverwaltung.\n\n## Das bietet GitLab im Bereich agentische KI\n\n### GitLab Duo mit Amazon Q\n\n- [GitLab Duo mit Amazon Q: Die für AWS optimierte agentische KI ist jetzt allgemein verfügbar](https://about.gitlab.com/de-de/blog/gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws/): Die umfassende KI-basierte DevSecOps-Plattform mit den umfangreichsten Cloud-Computing-Funktionen beschleunigt Entwicklungszyklen, erhöht die Automatisierung und verbessert die Codequalität.\n- [DevSecOps + agentische KI: Jetzt für GitLab Self-Managed Ultimate auf AWS (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/devsecops-agentic-ai-now-on-gitlab-self-managed-ultimate-on-aws/): Verwende KI-basierte Agents, die für DevSecOps optimiert sind, in deiner Instanz von AWS GitLab Self-Managed Ultimate. Profitiere von den Vorteilen von GitLab Duo und Amazon Q in deinem Unternehmen.\n- [GitLab Duo mit Amazon Q – Partnerseite](https://about.gitlab.com/de-de/partners/technology-partners/aws/)\n\nSieh dir GitLab Duo mit Amazon Q in Aktion an:\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1075753390?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"Technical Demo: GitLab Duo with Amazon Q\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n#### Geführte Tour\n\nKlicke auf das Bild, um eine englischsprachige Tour durch GitLab Duo mit Amazon Q zu starten:\n\n[![GitLab Duo mit Amazon Q – interaktive Tour](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749673568/Blog/Content%20Images/Screenshot_2025-05-07_at_7.24.45_AM.png)](https://gitlab.navattic.com/duo-with-q)\n\n#### GitLab Duo mit Amazon Q – Tutorial\n\n- [GitLab Duo + Amazon Q: Ideen in wenigen Minuten in Code umwandeln (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/gitlab-duo-amazon-q-transform-ideas-into-code-in-minutes/): Die neue Integration „GitLab Duo mit Amazon Q“ analysiert deine Ticketbeschreibungen und generiert automatisch vollständige, funktionierende Code-Lösungen. So werden deine Entwicklungsworkflows beschleunigt.\n\n### GitLab Duo Workflow\n\n- [GitLab Duo Workflow](https://about.gitlab.com/de-de/gitlab-duo/workflow/): Die Zukunft der sicheren Entwicklung von agentischer KI-Software\n- [GitLab Duo Workflow: Transparenz und Kontrolle für agentische KI auf Enterprise-Niveau](https://about.gitlab.com/de-de/blog/gitlab-duo-workflow-enterprise-visibility-and-control-for-agentic-ai/): Sichere, autonome, kontextbewusste KI-Tools übernehmen komplexe Aufgaben und geben Entwickler(inne)n die Möglichkeit, innovative Software schneller zu entwickeln. Die private Beta-Warteliste ist jetzt geöffnet.\n- [GitLab Duo Workflow](https://about.gitlab.com/de-de/gitlab-duo/workflow/)\n- [Dokumentation für GitLab Duo Workflow (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/duo_workflow/)\n\nSieh dir GitLab Duo Workflow in Aktion an:\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/eN2Sd5UNc0g?si=C9HibBJ3QDDHADq2\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n### Geführte Tour\n\nKlicke auf das Bild unten, um die englischsprachige Tour durch GitLab Duo Workflow zu starten:\n\n[![GitLab Duo Workflow – geführte Tour](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749673569/Blog/Content%20Images/Screenshot_2025-05-07_at_7.29.57_AM.png)](https://gitlab.navattic.com/duo-workflow)\n\n#### Tutorials und Anwendungsfälle für GitLab Duo Workflow\n\n- [Refactoring von JavaScript zu TypeScript mit GitLab Duo Workflow (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/refactoring-javascript-to-typescript-with-gitlab-duo-workflow/)\n\n- [Automatisierung mühsamer Programmieraufgaben mit GitLab Duo Workflow (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/automate-tedious-coding-tasks-with-gitlab-duo-workflow/): Erfahre, wie agentische KI den Zeitaufwand für sich wiederholende Aufgaben reduzieren kann, damit du dich auf die Entwicklung innovativer Lösungen und die Bereitstellung der nächsten großen Innovation konzentrieren kannst.\n\n- [Verbesserte Qualitätssicherung von Anwendungen mit GitLab Duo Workflow](https://about.gitlab.com/de-de/blog/use-gitlab-duo-workflow-to-improve-application-quality-assurance/): Erfahre, wie du mithilfe von agentischer KI Unit-Tests zu einer Java-Anwendung hinzufügst (Video-Tutorial inklusive).\n\n- [Komplexe Herausforderungen mit GitLab Duo Workflow lösen (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/solving-complex-challenges-with-gitlab-duo-workflow/): Erfahre, wie ein Mitglied des GitLab-Management-Teams für Kundenerfolge agentische KI für die Lösung realer Probleme einsetzt, einschließlich der Bewältigung von Helm-Chart-Limits in der Paket-Registry.\n\n## Mehr erfahren mit GitLab University (nur in englischer Sprache verfügbar)\n\n- [Kurs „Erste Schritte mit GitLab Duo“](https://university.gitlab.com/pages/ai)\n- [GitLab Duo Enterprise Learning Path](https://university.gitlab.com/learning-paths/gitlab-duo-enterprise-learning-path)\n\n## Weitere Ressourcen zum Bereich KI\n\n- [Globaler DevSecOps-Bericht 2024: Navigation durch die KI-Entwicklung in DevSecOps](https://about.gitlab.com/de-de/developer-survey/2024/ai/)\n- [Die Rolle der KI bei DevOps](https://about.gitlab.com/de-de/topics/devops/the-role-of-ai-in-devops/)\n- [Die neuesten KI-/ML-Artikel von GitLab](https://about.gitlab.com/de-de/blog/categories/ai-ml/)\n- [GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/)",[847],"GitLab","2025-06-18","2025-05-07","Leitfäden und Ressourcen zu agentischer KI",[838,808,810],"Hier erfährst du alles, was du über agentische KI wissen musst, wie sie funktioniert, warum sie deine DevSecOps-Umgebung aufwertet und welche bewährten Methoden es für die Implementierung gibt.",{"featured":91,"template":797},{"content":855,"config":866},{"title":856,"description":857,"authors":858,"heroImage":860,"date":861,"body":862,"category":684,"tags":863,"updatedDate":865},"GitLab Duo mit Amazon Q: In wenigen Minuten wird aus einer Idee der passende Code","Die neue Integration von GitLab Duo mit Amazon Q analysiert deine Tickets und erstellt automatisch funktionierende Codelösungen, wodurch deine Workflows beschleunigt werden.",[859],"Cesar Saavedra","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097127/Blog/Hero%20Images/Blog/Hero%20Images/Screenshot%202024-11-27%20at%204.55.28%E2%80%AFPM_4VVz6DgGBOvbGY8BUmd068_1750097126673.png","2025-04-28","Hast du schon einmal Tage oder sogar Wochen damit verbracht, aus einem komplexen Problem einen funktionierenden Code zu machen? Wer hat das nicht? Man beginnt mit einer vernünftigen Idee und klaren Anforderungen, aber der Weg vom anfänglichen Konzept hin zu bereitstellbarem Code kann frustrierend lang sein. Deine Produktivität wird durch Implementierungsdetails gebremst und Projekte, die schnell vorankommen sollten, ziehen sich in die Länge.\n\nHier kommt die [agentische KI](https://about.gitlab.com/de-de/topics/agentic-ai/) mit all ihrer Power ins Spiel. [GitLab Duo mit Amazon Q](https://about.gitlab.com/de-de/blog/gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws/) kombiniert die umfassende KI-basierte DevSecOps-Plattform mit den umfangreichsten Cloud-Computing-Funktionen, um deinen Anwendungsentwicklungsprozess innerhalb deines vertrauten GitLab-Workflows drastisch zu beschleunigen. Indem sie deinen Weg von der Idee bis zur Bereitstellung optimiert, kann diese leistungsstarke Integration Implementierungslösungen ausschließlich anhand deiner Ticketbeschreibungen vorschlagen – so wird ein Vorgang, der früher Tage dauerte, in wenigen Minuten erledigt.\n\n## So funktioniert’s: vom Ticket zum funktionierenden Code\n\nSehen wir uns an, wie die agentische KI-Funktion in der Praxis funktioniert. Stell dir vor, du bist Entwickler(in) und sollst eine Anwendung für einen Hypothekenrechner erstellen. So hilft dir GitLab Duo mit Amazon Q dabei:\n\n1. **Erstelle ein Ticket mit detaillierten Anforderungen:** Erstelle zunächst ein Standard-[GitLab-Ticket](https://docs.gitlab.com/user/project/issues/). In der Beschreibung gibst du eine umfassende Liste der Anforderungen an, die deine Anwendung erfüllen muss. Dies bildet die Grundlage für deine Lösung.\n\n2. **Rufe Amazon Q mit einem Schnellzugriff auf:** Sobald dein Ticket erstellt ist, fügst du einfach einen Kommentar mit dem Schnellzugriff „/q dev“ hinzu, um Amazon Q aufzurufen. Jetzt wird es magisch. \n\n3. **Lass die KI deine Implementierung generieren:** GitLab Duo mit Amazon Q analysiert deine Ticketbeschreibung und den Kontext deines Quellcodes und generiert dann autonom Code, der alle angegebenen Anforderungen erfüllt. Und das ist noch nicht alles – es überträgt diese Änderungen sogar in einen Merge Request, der dann von dir überprüft werden kann.\n\n![Screenshot des Aktivitäts-Pop-ups von GitLab Duo mit Amazon Q](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097156/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097156018.png)\n\n4. **Überprüfe die generierte Anwendung**: Gehe nun zum Merge Request, um den generierten Code zu überprüfen. Sieh dir hier an, ob alle deine Anforderungen erfüllt wurden, und nimm bei Bedarf Anpassungen vor.\n\n5. **Teste die vorgeschlagene Anwendung**: Überprüfe abschließend, ob die Anwendung erfolgreich ausgeführt wird. Mit minimalem Aufwand hast du jetzt einen funktionierenden Code, der deine festgelegten Anforderungen erfüllt.\n\n## Transformiere deinen Entwicklungsprozess\n\nGitLab Duo mit Amazon Q transformiert diesen Prozess vollständig, indem es durch intelligente Automatisierung die Zeit, die für komplexe Entwicklungsaufgaben aufgewendet werden muss, signifikant senkt. Durch den Einsatz von agentischer KI kannst du deinen Weg von der Idee bis zur Bereitstellung verkürzen und gibst Entwicklungsteams so die Möglichkeit, sich auf strategischere Aufgaben zu konzentrieren.\n\nMit GitLab Duo und Amazon Q entwickelst du Software schneller, effizienter und mit geringerem manuellem Programmieraufwand. Diese Integration hilft dir:\n\n* **Wertvolle Entwicklungszeit zu sparen**, indem Implementierungen automatisiert werden und die jeweiligen Anforderungen berücksichtigt werden\n* **Konsistent zu bleiben**, wenn du Code übergreifend über Projekte generierst\n* **Die kognitive Belastung zu reduzieren**, die auftritt, wenn Anforderungen in funktionierenden Code umgewandelt werden sollen\n* **Deine Bereitstellungszyklen zu beschleunigen**, indem Engstellen bei der Implementierung eliminiert werden\n* **Dich auf deine Expertise zu konzentrieren** und Code zu überprüfen und zu optimieren, anstatt dich mit Boilerplate-Code herumschlagen zu müssen.\n\nBist du bereit, GitLab Duo mit Amazon Q in Aktion zu erleben? In unserem Demo-Video erfährst du, wie du deinen Entwicklungsworkflow jetzt transformieren kannst.\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/jxxzNst3jpo?si=j_LQdZhUnwqoQEst\" title=\"GitLab Duo with Amazon Q demo video for dev workflow\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n> Besuche uns auf einem der bevorstehenden [AWS Summits in einer Stadt in deiner Nähe](https://about.gitlab.com/de-de/events/aws-summits/) oder [wende dich an deine(n) GitLab-Vertreter(in)](https://about.gitlab.com/de-de/partners/technology-partners/aws/#form), um mehr über GitLab Duo mit Amazon Q zu erfahren.\n\n## Ressourcen zu GitLab Duo mit Amazon Q\n\n- [GitLab Duo mit Amazon Q: Die für AWS optimierte agentische KI ist jetzt allgemein verfügbar](https://about.gitlab.com/de-de/blog/gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws/)\n- [GitLab und AWS – Partnerseite](https://about.gitlab.com/de-de/partners/technology-partners/aws/)\n- [Dokumentation zu GitLab Duo mit Amazon Q (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/duo_amazon_q/)",[838,864,810,808,765,234],"AWS","2025-06-06",{"slug":867,"featured":91,"template":797},"gitlab-duo-amazon-q-transform-ideas-into-code-in-minutes",{"category":692,"slug":696,"posts":869},[870],{"content":871,"config":881},{"title":872,"description":873,"authors":874,"heroImage":876,"date":877,"body":878,"category":696,"tags":879,"updatedDate":880},"Welche Auswirkungen die Ratenbegrenzungen für Docker Hub auf GitLab CI/CD haben","Erfahre, wie sich die bevorstehenden Ratenbegrenzungen für Pulls von Docker Hub auf GitLab-Pipelines auswirken und was du tun kannst, um Störungen zu vermeiden.",[875],"Tim Rizzi","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749662488/Blog/Hero%20Images/blog-image-template-1800x945__3_.png","2025-03-24","Am 1. April 2025 hat Docker neue [Ratenbegrenzungen für Pulls](https://docs.docker.com/docker-hub/usage/) für Docker Hub eingeführt, die sich erheblich auf CI/CD-Pipelines in der gesamten Branche auswirken können, einschließlich derer, die auf GitLab ausgeführt werden. Die gravierendste Änderung ist die Begrenzung auf 10 Pulls pro Stunde für nicht angemeldete Benutzer(innen).\n\n## Was ändert sich?\n\nAb dem 1. April 2025 hat Docker die folgenden Ratenbegrenzungen für Pulls durchgesetzt:\n\n| Benutzertyp | Ratenbegrenzung für Pulls pro Stunde | Anzahl der öffentlichen Repositories | Anzahl der privaten Repositories |\n|-----------|--------------------------|-------------------------------|--------------------------------|\n| Business, Team, Pro (authentifiziert) | Unbegrenzt (angemessene Nutzung) | Unbegrenzt | Unbegrenzt |\n| Persönlich (authentifiziert) | 100 | Unbegrenzt | Maximal 1 |\n| Nicht angemeldete Benutzer(innen) | 10 pro IPv4-Adresse oder IPv6/64-Subnetz | Nicht zutreffend | Nicht zutreffend |\n\n\u003Cp>\u003C/p>\nDies ist besonders wichtig, weil:\n\n* Der Abhängigkeits-Proxy von GitLab pullt derzeit als nicht angemeldeter Benutzer von Docker Hub.\n* Die meisten CI/CD-Pipelines, die den Abhängigkeits-Proxy nicht verwenden, pullen als nicht angemeldete Benutzer direkt von Docker Hub.\n* Auf gehosteten Runnern für GitLab.com kann es vorkommen, dass sich mehrere Benutzer(innen) die gleiche IP-Adresse oder das gleiche Subnetz teilen. Somit unterliegen sie gemeinsam dieser Begrenzung.\n\n## Wie sich dies auf GitLab-Benutzer(innen) auswirkt\n\n**Auswirkungen auf direkte Pulls von Docker Hub**\n\nWenn deine CI/CD-Pipelines Images direkt und ohne Authentifizierung von Docker Hub pullen, ist die Anzahl auf 10 Pulls pro Stunde und IP-Adresse begrenzt. Bei Pipelines, die häufig oder projektübergreifend mit derselben Runner-Infrastruktur ausgeführt werden, wird dieser Grenzwert schnell erreicht und es kommt zu Pipeline-Fehlern.\n\n**Auswirkungen auf den Abhängigkeits-Proxy von GitLab**\n\nMit dem Abhängigkeits-Proxy von GitLab kannst du Docker-Images in GitLab zwischenspeichern, um Pipelines zu beschleunigen und externe Abhängigkeiten zu reduzieren. Die aktuelle Implementierung pullt allerdings als nicht angemeldeter Benutzer von Docker Hub. Das bedeutet, dass auch hier der Grenzwert von 10 Pulls pro Stunde gilt.\n\n**Auswirkungen auf gehostete Runner**\n\nGehostete Runner auf GitLab.com verwenden den [Pull-Through-Cache von Google Cloud](https://cloud.google.com/artifact-registry/docs/pull-cached-dockerhub-images?hl=de). Dieser spiegelt häufig gepullte Images, sodass Ratenbegrenzungen vermieden werden. Images von Jobs, die in deiner `.gitlab-ci.yml`-Datei als `image:` oder `services:` definiert sind, sind von Ratenbegrenzungen nicht betroffen.\n\nEtwas schwieriger wird es, wenn Images innerhalb der Runner-Umgebung gepullt werden. Der häufigste Anwendungsfall für das Pullen von Images während der Laufzeit eines Runners ist die Erstellung eines Images mit Docker-in-Docker oder Kaniko. In diesem Szenario wird das in deiner `Dockerfile` definierte Docker-Hub-Image direkt aus dem Docker Hub gepullt und ist wahrscheinlich von den Ratenbegrenzungen betroffen.\n\n## Wie GitLab reagiert\n\nWir arbeiten aktiv an Lösungen, um diese Herausforderungen zu bewältigen:\n\n* **Authentifizierung des Abhängigkeits-Proxy:** Wir haben die Unterstützung für die Docker-Hub-Authentifizierung im [GitLab-Abhängigkeits-Proxy](https://gitlab.com/gitlab-org/gitlab/-/issues/331741) hinzugefügt. Dadurch kann der Abhängigkeits-Proxy Images als angemeldeter Benutzer von Docker Hub pullen, wodurch die Grenzwerte erheblich erhöht werden.\n* **Aktualisierung der Dokumentation:** Wir haben unsere [Dokumentation (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/packages/dependency_proxy/#configure-credentials) aktualisiert. Sie stellt jetzt eine klare Anleitung zur Konfiguration der Pipeline-Authentifizierung für Docker Hub zur Verfügung.\n* **Vorbereitung der internen Infrastruktur:** Wir bereiten unsere interne Infrastruktur vor, um die Auswirkungen auf gehostete Runner für GitLab.com zu minimieren.\n\n## So kannst du dich vorbereiten\n\n**Option 1: Konfiguriere die Docker-Hub-Authentifizierung in deinen Pipelines**\n\nFür Pipelines, die direkt von Docker Hub pullen, kannst du die Authentifizierung so konfigurieren, dass deine Ratenbegrenzung auf 100 Pulls pro Stunde erhöht wird (mit einem kostenpflichtigen Docker-Hub-Abo ist sie sogar unbegrenzt).\n\nFüge die Docker-Hub-Anmeldedaten zu den CI/CD-Variablen deines Projekts oder deiner Gruppe hinzu (nicht in deiner `.gitlab-ci.yml`-Datei). Ausführliche Anweisungen zur korrekten Einrichtung der CI/CD-Variable `DOCKER_AUTH_CONFIG` findest du in unserer [Dokumentation zur Verwendung von Docker-Images (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/ci/docker/using_docker_images/#use-statically-defined-credentials).\n\n**Option 2: Verwende die GitLab-Container-Registry**\n\nDu kannst deine häufig verwendeten Docker-Images in deine [GitLab-Container-Registry (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/packages/container_registry/) übertragen. So musst du während der CI/CD-Ausführung nicht mehr von Docker Hub pullen:\n\n1. Pulle das Image von Docker Hub.\n2. Kennzeichne es für deine GitLab-Container-Registry.\n3. Pushe es in deine GitLab-Container-Registry.\n4. Aktualisiere deine Pipelines, dass sie das Image von der GitLab-Container-Registry abrufen.\n\n```\ndocker pull busybox:latest\ndocker tag busybox:latest $CI_REGISTRY_IMAGE/busybox:latest\ndocker push $CI_REGISTRY_IMAGE/busybox:latest\n```\n\nIn deiner `.gitlab-ci.yml`-Datei fügst du dann folgende Zeile hinzu:\n\n`image: $CI_REGISTRY_IMAGE/busybox:latest`\n\n**Option 3: Verwende den GitLab-Abhängigkeits-Proxy**\n\nMit dem Abhängigkeits-Proxy von GitLab kannst du Docker-Images zwischenspeichern und übertragen. Dies reduziert externe Abhängigkeiten und somit Probleme mit der Ratenbegrenzung.\n\nAktuelle Authentifizierungsoptionen:\n* GitLab 17.10: Konfiguriere die Docker-Hub-Authentifizierung für den Abhängigkeits-Proxy mit der [GraphQL API (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/packages/dependency_proxy/#configure-credentials-using-the-graphql-api)\n* GitLab 17.11: Verwende die neue UI-basierte Konfiguration in den Einstellungen deiner Gruppe (bereits auf GitLab.com verfügbar)\n\nSobald die Authentifizierung ordnungsgemäß konfiguriert ist, kannst du Folgendes tun:\n\n1. Konfiguriere die Docker-Hub-Anmeldeinformationen in den Einstellungen des Abhängigkeits-Proxys deiner Gruppe:\n  - Für GitLab 17.11+ (oder die aktuelle Version von GitLab.com): Navigiere zu den Einstellungen deiner Gruppe > Pakete und Registries > Abhängigkeits-Proxy.\n  - Für GitLab 17.10: Verwende die GraphQL-API, um die Authentifizierung zu konfigurieren.\n2. Aktualisiere deine Pipelines, sodass sie die Dependency-Proxy-URLs in deiner CI/CD-Konfiguration verwenden:\n`image: ${CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX}/busybox:latest`\n\n**Option 4: Überlege dir, ein kostenpflichtiges Docker-Hub-Abonnement abzuschließen**\n\nUnternehmen, die Docker Hub intensiv nutzen, ist das Upgrade auf ein kostenpflichtiges Docker-Abonnement (Team oder Business) möglicherweise die einfachste Lösung, da es unbegrenzt viele Pulls ermöglicht.\n\n## Best Practices zur Reduzierung der Auswirkungen der Docker-Hub-Ratenbegrenzung\n\nUnabhängig davon, welche Option du wählst, helfen dir diese Best Practices dabei, die Auswirkungen der Docker-Hub-Ratenbegrenzung zu minimieren:\n\n* Verwende eindeutige Image-Tags anstelle von `latest`, um unnötige Pulls zu vermeiden.\n* Konsolidiere deine Docker-Dateien, sodass sie projektübergreifend dieselben Basis-Images verwenden.\n* Plane weniger kritische Pipelines so, dass sie außerhalb der Stoßzeiten ausgeführt werden.\n* Verwende Caching effektiv, um zu vermeiden, dass dieselben Images wiederholt gepullt werden.\n\n**Hinweis:** Gemäß der [Dokumentation](https://docs.docker.com/docker-hub/usage/pulls/#pull-definition) von Docker Hub wird der Counter für die Anzahl der Pulls erhöht, wenn das Image-Manifest gepullt wird, und nicht basierend auf der Image-Größe oder der Anzahl der Ebenen.\n\n## Zeitplan und nächste Schritte\n\n**Jetzt**\n  * Implementiere die Authentifizierung für direkte Pulls von Docker Hub.\n  * Als Benutzer(in) von GitLab.com kannst du die Docker-Hub-Authentifizierung für den Abhängigkeits-Proxy bereits konfigurieren, indem du entweder:\n    * die GraphQL-API oder\n    * die Benutzeroberfläche in den Gruppeneinstellungen verwendest\n  * Benutzer(innen) von GitLab Self-Managed 17.10 können die Abhängigkeits-Proxy-Authentifizierung über die GraphQL-API konfigurieren.\n\n**1. April 2025**\n  * Die Ratenbegrenzungen für Docker Hub treten in Kraft.\n\n**17. April 2025**\n  * GitLab 17.11 wird mit UI-basierter Unterstützung für die Authentifizierung des Abhängigkeits-Proxy für Self-Managed-Instanzen veröffentlicht. \n\nDu solltest rechtzeitig vor Ablauf der Frist am 1. April Maßnahmen ergreifen, um unerwartete Pipeline-Fehler zu vermeiden. Für die meisten Benutzer(innen) ist die Konfiguration des Abhängigkeits-Proxys mit der Docker-Hub-Authentifizierung die effizienteste Langzeitlösung.\n\n> Hast du Fragen oder benötigst du Hilfe bei der Implementierung? Sieh dir [dieses Ticket an](https://gitlab.com/gitlab-org/gitlab/-/issues/526605), wo unser Team aktiv Unterstützung bietet.",[109,743,808],"2025-04-21",{"slug":882,"featured":91,"template":797},"prepare-now-docker-hub-rate-limits-will-impact-gitlab-ci-cd",{"category":704,"slug":708,"posts":884},[885,901,915],{"content":886,"config":899},{"title":887,"description":888,"authors":889,"heroImage":891,"date":892,"body":893,"category":708,"tags":894,"updatedDate":898},"Das Co-Create-Programm: Wie Kund(inn)en zusammenarbeiten, um GitLab zu entwickeln","Erfahre, wie Unternehmen wie Thales, Scania und Kitware mit GitLab-Entwickler(inne)n zusammenarbeiten, um sinnvolle Funktionen beizusteuern, von denen die gesamte Community profitiert.",[890],"Fatima Sarah Khalid","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749659756/Blog/Hero%20Images/REFERENCE_-_display_preview_for_blog_images.png","2025-01-30","Im vergangenen Jahr haben über 800 Community-Mitglieder mehr als 3 000 Beiträge zu GitLab geleistet. Darunter sind auch Teammitglieder aus globalen Unternehmen wie Thales und Scania, die im Rahmen des [Co-Create-Programms (nur in englischer Sprache verfügbar)](https://about.gitlab.com/community/co-create/) die Zukunft von GitLab mitgestalten. Bei diesem Programm arbeiten Kund(inn)en direkt mit GitLab-Entwickler(inne)n zusammen, um sinnvolle Funktionen zur Plattform beizutragen.\n\nDurch Workshops, Paarprogrammierungssitzungen und kontinuierlichen Support erhalten die Programmteilnehmenden praktische Erfahrungen mit der Architektur und der Codebase von GitLab, während sie Probleme lösen oder bestehende Funktionen verbessern.\n\n„Unsere Erfahrungen mit dem Co-Create-Programm waren unglaublich“, erklärt Sébastien Lejeune, Open-Source-Beauftragter bei Thales. „Es hat nur zwei Monate gedauert, bis wir unseren Beitrag mit einem GitLab Contributor Success Engineer besprochen haben und er in die GitLab-Release aufgenommen wurde.“\n\nIn diesem Beitrag zeigen wir, wie Kund(inn)en das Co-Create-Programm genutzt haben, um ihre Ideen in Code zu verwandeln und dabei zu lernen und mitzuwirken.\n\n## Die Co-Create-Erfahrung\n[Das GitLab Development Kit (GDK) (Dokumentation nur in englischer Sprache verfügbar)](https://gitlab.com/gitlab-org/gitlab-development-kit) hilft Mitwirkenden, mit der Entwicklung von GitLab zu beginnen. „Mein Rat für neue Mitwirkende lautet, dass man mit dem GDK nichts kaputt machen kann“, sagt Hook. „Wenn du eine Änderung vornimmst und sie nicht funktioniert, kannst du sie rückgängig machen oder von vorne beginnen. Das Schöne am GDK ist, dass man tüfteln, testen und lernen kann, ohne sich Gedanken über die Umgebung machen zu müssen.“\n\nJedes Unternehmen, das am Co-Create-Programm teilnimmt, erhält während seiner gesamten Beitragsphase Unterstützung:\n\n- __Technischer Onboarding-Workshop __: Eine spezielle Sitzung, um das GitLab Development Kit einzurichten und die Architektur von GitLab zu verstehen\n- __Persönlicher Engineering-Support__: Kontakt zu GitLab-Entwickler(inne)n für Paarprogrammierung und technische Beratung\n- __Vertiefende Einblicke in die Architektur__: Spezialisierte Sitzungen zu bestimmten GitLab-Komponenten, die für das Thema, zu dem das Unternehmen beiträgt, relevant sind\n- __Code-Review-Support__: Detailliertes Feedback und Anleitung für den Merge-Request-Prozess\n- __Regelmäßige Rückmeldungen__: Laufende Zusammenarbeit, um den Fortschritt zu sichern und Herausforderungen zu bewältigen\n\nDiese Struktur sorgt dafür, dass Teams unabhängig von ihrer Erfahrung mit der Codebase von GitLab oder der Programmiersprache Ruby/Go effektiv mitarbeiten können. John Parent von Kitware erklärt: „Wenn du GitLab noch nie gesehen oder damit gearbeitet hast, siehst du dich mit einer ausgeklügelten Architektur und so viel Code in verschiedenen Projekten konfrontiert. Mithilfe des Co-Create-Programms lässt sich das, was wochenlange interne Schulungen erfordern würde, in einen gezielten Crashkurs umwandeln.“\n\nDas Ergebnis ist ein Programm, das nicht nur dabei hilft, neue Funktionen zu entwickeln, sondern auch dauerhafte Beziehungen zwischen GitLab und seiner Benutzer-Community aufzubauen. „Für unsere Entwickler(innen) ist es inspirierend zu sehen, mit welcher Leidenschaft unsere Kund(inn)en an GitLab mitarbeiten und es gemeinsam weiterentwickeln“, sagt Shekhar Patnaik, Principal Engineer bei GitLab. Die Kund(inn)en erleben den „GitLab-Weg“ und die Entwickler(innen) sehen, wie sie die Zukunft von GitLab mitgestalten.“\n\n## Verbesserung der Projekt-Benutzeroberfläche mit Thales\nAls Thales Verbesserungsmöglichkeiten für die leere Projektoberfläche von GitLab erkannte, reichten sie nicht nur eine Feature-Anfrage ein, sondern entwickelten die Lösung gleich selbst. Ihre Beiträge konzentrierten sich auf die Vereinfachung der Einrichtung neuer Projekte, indem sie die SSH-/HTTPS-Konfiguration mit einer Registerkarten-Oberfläche vereinfachten und eine Kopier-/Einfügefunktion für die Code-Schnipsel hinzufügten. Diese Änderungen hatten einen erheblichen Einfluss auf den Workflow der Entwickler(innen).\n\nDas Team hat aber nicht nur die Benutzeroberfläche verbessert. Quentin Michaud, PhD Fellow für Cloud Applications on the Edge bei Thales, trug zur Verbesserung des GitLab Development Kit (GDK) bei. Als Paketbetreuer für Arch Linux hat Michaud mit seinem Fachwissen die Dokumentation des GDK verbessert und die Containerisierung unterstützt, um zukünftigen Mitwirkenden den Einstieg zu erleichtern.\n\n„Meine Erfahrung mit Open Source half mir bei der Problembehebung der GDK-Unterstützung für Linux-Distributionen“, sagt Michaud. „Während ich die Dokumentation zur Paketversionierung verbesserte, sah ich, dass das Contributor-Success-Team von GitLab ebenfalls daran arbeitete, GDK in einem Container einzurichten. Zu sehen, wie unsere Bemühungen zusammenlaufen, war ein großartiger Moment für mich – er zeigte, wie Open-Source-Zusammenarbeit zu besseren Lösungen führen kann.“\n\nDie positive Erfahrung für das Thales-Team bedeutet, dass Lejeune das Co-Create-Programm jetzt als „ein überzeugendes Beispiel dafür nutzt, unseren Manager(inne)n die Rentabilität von Beiträgen zu Open-Source-Software zu zeigen.“\n\n## Verbesserung der Paketunterstützung mit Scania\nAls Scania erweiterte Paketunterstützung in GitLab benötigte, sah das Unternehmen die Möglichkeit, selbst dazu beizutragen und sie zu entwickeln.\n\n„Wir sind langjährige GitLab-Benutzer(innen) und fördern Open Source aktiv in unserem Unternehmen. Das Co-Create-Programm bot uns eine sinnvolle Möglichkeit, direkt zu Open Source beizutragen“, sagt Puttaraju Venugopal Hassan, Solution Architect bei Scania.\n\nDas Team begann mit kleineren Änderungen, um sich mit der Codebase und dem Review-Prozess vertraut zu machen, und ging dann zu größeren Funktionen über. „Einer der lohnendsten Aspekte des Co-Create-Programms war es, auf den gesamten Prozess zurückzublicken und zu sehen, wie weit wir gekommen sind“, sagt Océane Legrand, Softwareentwicklerin bei Scania. „Wir haben mit der Erkundung und kleineren Änderungen angefangen, aber mit der Zeit haben wir größere Aufgaben übernommen. Es ist toll, diese Entwicklung zu sehen.“\n\nZu den Beiträgen von Scania gehören Fehlerkorrekturen für die Paket-Registry und Bemühungen, die Conan-Paket-Registry zu verbessern, um sie der allgemeinen Verfügbarkeit (GA) näher zu bringen und gleichzeitig die Unterstützung für Conan Version 2 zu implementieren. Ihre Arbeit und die Zusammenarbeit mit GitLab zeigt, wie das Co-Create-Programm die Funktionen der Paket-Registry von GitLab erheblich verbessern kann.\n\n„Unsere Erfahrungen mit dem Co-Create-Programm waren von Anfang an sehr gut organisiert. Wir hatten Schulungen, die uns durch alles führten, was wir für unseren Beitrag brauchten. In Einzelgesprächen mit jemandem aus dem Entwicklungsteam von GitLab erhielten wir außerdem einen detaillierten Einblick in die Paketarchitektur von GitLab, was den Beitragsprozess deutlich vereinfachte“, sagt Juan Pablo Gonzalez, Softwareentwickler bei Scania.\n\nDas Programm wirkt sich nicht nur auf die Programmierung aus – Teilnehmende erwerben durch ihre Beiträge auch wertvolle Fähigkeiten. Bei der Veröffentlichung von GitLab 17.8 wurden sowohl [Legrand als auch Gonzalez als GitLab MVPs (nur in englischer Sprache verfügbar)](https://about.gitlab.com/releases/2025/01/16/gitlab-17-8-released/#mvp) ausgezeichnet. Legrand sprach darüber, wie sich ihre Arbeit im Open-Source-Bereich sowohl auf GitLab als auch auf Scania auswirkt und wie sie und ihr Team neue Fähigkeiten erwerben: „Durch die Mitarbeit im Co-Create-Programm habe ich neue Fähigkeiten erworben, z. B. Erfahrungen mit Ruby und Hintergrundmigrationen. Als mein Team bei Scania während eines Upgrades mit einem Problem konfrontiert wurde, konnte ich bei der Problembehebung helfen, weil ich das Problem bereits aus dem Co-Create-Programm kannte.“\n\n## Optimierung der Authentifizierung für High-Performance-Computing mit Kitware\nKitware brachte sein Fachwissen aus der Zusammenarbeit mit nationalen Laboratorien ein, um das Authentifizierungsframework von GitLab zu verbessern. Kitware unterstützte den OAuth2 Flow zur Erteilung von Geräteautorisierungen in GitLab und implementierte neue Datenbanktabellen, Controller, Ansichten und Dokumentationen. Dieser Beitrag erweitert die Authentifizierungsoptionen von GitLab und macht es vielseitiger für Geräte ohne Browser oder mit begrenzten Eingabemöglichkeiten.\n\n„Das Co-Create-Programm ist der effizienteste und effektivste Weg, um als Externe(r) zu GitLab beizutragen“, sagt John Parent, Entwicklungsingenieur bei Kitware. „Durch die Pairing-Sitzungen mit den Entwickler(inne)n haben wir bessere Implementierungen gefunden, die wir im Alleingang vielleicht übersehen hätten.“\n\nAls langjähriger Mitwirkender im Open-Source-Bereich schätzt Kitware besonders den Entwicklungsansatz von GitLab. „Ich bin davon ausgegangen, dass GitLab bei seiner Größe nicht auf vorgefertigte Lösungen zurückgreifen würde, aber es war großartig zu sehen, dass sie eine Ruby-Abhängigkeit eingebaut haben, anstatt eine eigene Lösung zu entwickeln“, sagt Parent. „Da ich aus der C++-Welt komme, wo Paketmanager selten sind, war es erfrischend zu sehen, wie einfach dieser Ansatz sein kann.“\n\n## Gemeinsam besser entwickeln: Vorteile des Co-Create-Programms\nDas Co-Create-Programm schafft Werte für beide Seiten. „Das Programm überbrückt die Kluft zwischen uns als GitLab-Entwickler(innen) und unseren Kund(inn)en“, erklärt Imre Farkas, Staff Backend Engineer bei GitLab. „Während der Zusammenarbeit erfahren wir, welche Herausforderungen sie tagtäglich haben, auf welche Teile von GitLab sie sich verlassen und wo Verbesserungen möglich sind. Es ist toll zu sehen, mit welcher Begeisterung sie sich an der Entwicklung von GitLab beteiligen.“\n\nDieser kollaborative Ansatz beschleunigt auch die Entwicklung von GitLab. Shekhar Patnaik, leitender Ingenieur bei GitLab, bemerkt dazu: „Durch das Co-Create-Programm helfen uns unsere Kund(inn)en, unsere Roadmap voranzutreiben. Ihre Beiträge ermöglichen es uns, wichtige Funktionen schneller bereitzustellen, wovon unsere gesamte Nutzerbasis profitiert. Wenn wir das Programm erweitern, haben wir das Potenzial, die Entwicklung unserer wichtigsten Funktionen zu beschleunigen, indem wir mit den Menschen zusammenarbeiten, die sich auf sie verlassen.“\n\n## Erste Schritte mit dem Co-Create-Programm\nBist du bereit, deine Feature-Anfragen in die Realität umzusetzen? Ganz gleich, ob du wie Thales die Benutzeroberfläche von GitLab verbessern, wie Scania die Paketunterstützung verbessern oder wie Kitware die Authentifizierung optimieren möchtest – das Co-Create-Programm heißt alle Unternehmen willkommen, die die Zukunft von GitLab aktiv mitgestalten und gleichzeitig wertvolle Open-Source-Erfahrungen sammeln möchten.\n\nEin(e) GitLab-Vertreter(in) kann dir sagen, wie du am Co-Create-Programm teilnehmen kannst. Weitere Informationen findest du auch auf der [Seite des Co-Create-Programms](https://about.gitlab.com/community/co-create/).\n",[895,896,897],"contributors","open source","customers","2025-02-07",{"slug":900,"featured":91,"template":797},"the-co-create-program-how-customers-are-collaborating-to-build-gitlab",{"content":902,"config":913},{"title":903,"description":904,"authors":905,"heroImage":907,"date":908,"body":909,"category":708,"tags":910,"updatedDate":912},"Wie Indeed seine CI-Plattform mit GitLab transformiert hat","Die weltweit führende Jobbörse migrierte Tausende von Projekten zu GitLab CI und konnte so die Produktivität steigern und die Kosten senken. Hier erfährst du, welche Vorteile das Unternehmen umsetzen und damit einen Anstieg der täglichen Pipelines um 79 % erzielen konnte.",[906],"Carl Myers","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099351/Blog/Hero%20Images/Blog/Hero%20Images/Indeed-blog-cover-image-2_4AgA1DkWLtHwBlFGvMffbC_1750099350771.png","2024-08-27","***Anmerkung der Redaktion: Von Zeit zu Zeit laden wir Mitglieder unserer Kunden-Community ein, einen Beitrag für den GitLab-Blog zu verfassen. Danke an Carl Myers, CI-Plattform-Manager bei Indeed, dass du uns von deinen Erfahrungen mit GitLab berichtest.***\n\nHier bei Indeed ist es unsere Mission, Menschen dabei zu helfen, einen Job zu finden. Indeed ist die weltweit [führende Job-Website](https://www.indeed.com/about?isid=press_us&ikw=press_us_press%2Freleases%2Faward-winning-actress-viola-davis-to-keynote-indeed-futureworks-2023_textlink_https%3A%2F%2Fwww.indeed.com%2Fabout) mit mehr als 350 Millionen Besucher(inne)n pro Monat.\n\nFür die Engineering-Plattformteams von Indeed gilt ein etwas anderes Motto: „Wir helfen den Menschen dabei, Menschen zu helfen, einen Job zu finden.“ Als Teil einer datengesteuerten Engineering-Kultur, die gute zwei Jahrzehnte immer die Jobsuchenden in den Vordergrund gestellt hat, sind wir dafür verantwortlich, die Tools zu entwickeln, mit denen dies nicht nur möglich ist, sondern die die Entwickler(innen) auch darin unterstützen, tagtäglich gute Ergebnisse für die Jobsuchenden zu liefern.\n\nMit der kontinuierlichen Integration von GitLab konnte das nur 11 Personen umfassende CI-Plattformteam von Indeed effektiv Tausende von Benutzer(inne)n im gesamten Unternehmen unterstützen. Weitere Vorteile, die Indeed durch den Umstieg auf GitLab CI erreichen konnte:\n- 79 % Anstieg der täglichen Pipelines\n- 10–20 % niedrigere CI-Hardware-Kosten\n- Gesunkener Supportaufwand\n\n## Weiterentwicklung unserer CI-Plattform: von Jenkins zu einer skalierbaren Lösung\n\nWie viele große Technologieunternehmen haben wir unsere CI-Plattform mit dem Wachstum des Unternehmens organisch aufgebaut und nutzten dabei die damals verfügbaren Open-Source- sowie branchenüblichen Lösungen. 2007, als Indeed weniger als 20 Entwickler(innen) hatte, verwendeten wir Hudson, den direkten Vorgänger von Jenkins.\n\nHeute, nach fast zwei Jahrzehnten des Wachstums, haben wir Tausende von Entwickler(inne)n. Als neue Technologien verfügbar wurden, nahmen wir schrittweise Veränderungen vor und wechselten um 2011 herum zu Jenkins. Dank einer weiteren Verbesserung konnten wir die meisten unserer Workloads mithilfe von [AWS EC2](https://aws.amazon.com/ec2/) auf dynamischen Worker Nodes in der Cloud umstellen. Mit dem Eintritt in das Kubernetes-Zeitalter stieß die Systemarchitektur jedoch an ihre Grenzen.\n\nDie Architektur von Jenkins wurde nicht mit Blick auf die Cloud entwickelt. Jenkins funktioniert mit einem „Controller“-Knoten, einem Single Point of Failure, der wichtige Teile einer Pipeline ausführt und bestimmte Schritte an Worker Nodes (die bis zu einem gewissen Grad horizontal skaliert werden können) auslagert. Controller sind auch eine manuelle Skalierungsachse.\n\nWenn man zu viele Jobs für einen Controller hat, muss man sie manuell auf mehrere Controller verteilen. CloudBees bietet Möglichkeiten, dies zu mindern, etwa durch das CloudBees Jenkins Operations Center, in dem man seine Controllerkonstellation zentral verwalten kann. Die Ausführung von Controllern in einer Kubernetes-Umgebung bleibt jedoch eine Herausforderung, da jeder Controller ein anfälliger Single Point of Failure ist. Aktivitäten wie Node-Rollouts oder Hardwareausfälle verursachen Ausfallzeiten.\n\nNeben den technischen Einschränkungen, die Jenkins mit sich bringt, hatte unsere CI-Plattform auch mehrere Probleme, die wir selbst verursacht hatten. Zum Beispiel haben wir die Jenkins-DSL Groovy verwendet, um in jedem Repository Jobs aus Code zu erstellen. Dies führte dazu, dass jedes Projekt seine eigene, kopierte und eingefügte Job-Pipeline hatte, was zu Hunderten von Versionen führte, die schwer zu warten und aktualisieren waren. Obwohle die Engineering-Kultur von Indeed auf Flexibilität Wert legt und es den Teams erlaubt, in separaten Repositories zu arbeiten, wurde diese Flexibilität zu einer Belastung, als Teams zu viel Zeit damit verbrachten, sich um regelmäßige Wartungsanfragen zu kümmern.\n\nAls wir unser Technical Debt erkannten, setzten wir auf das [Golden-Path-Muster](https://tag-app-delivery.cncf.io/whitepapers/platforms/), das Flexibilität bietet und gleichzeitig eine Standardroute vorgibt, um Updates zu vereinfachen und konsistente Praktiken in den Projekten zu fördern.\n\nDas CI-Plattformteam bei Indeed ist nicht sehr groß. Unser Team aus rund 11 Entwickler(inne)n unterstützt Tausende von Benutzer(inne)n, bearbeitet Supportanfragen, führt Updates und Wartungen durch und ermöglicht einen ständig verfügbaren Support für unser globales Unternehmen.\n\nDa unser Team nicht nur unsere GitLab-Instanz unterstützt, sondern die gesamte CI-Plattform einschließlich des Artefakt-Servers, unseres gemeinsamen Build-Codes und zahlreicher anderer, individueller Komponenten unserer Plattform, hatten wir alle Hände voll zu tun. Wir brauchten einen Plan, der uns half, unsere Herausforderungen zu meistern und gleichzeitig unsere vorhandenen Ressourcen so effizient wie möglich zu nutzen.\n\n## Umstieg auf GitLab CI\n\nNach einem sorgfältigen Design-Review mit den wichtigsten Stakeholdern entschieden wir, das gesamte Unternehmen von Jenkins zu GitLab CI zu migrieren. Die Hauptgründe für die Entscheidung für GitLab CI waren:\n- Wir haben GitLab bereits für die Quellcodeverwaltung verwendet.\n- GitLab ist eine Komplettlösung, die alles bietet, was wir für CI benötigen.\n- GitLab CI wurde für Skalierbarkeit und die Cloud entwickelt.\n- GitLab CI ermöglicht es uns, Vorlagen zu schreiben, die andere Vorlagen erweitern, was mit unserer Golden-Path-Strategie kompatibel ist.\n- GitLab ist Open-Source-Software und das GitLab-Team hat uns bei der Bereitstellung von Fehlerkorrekturen immer unterstützt, was uns zusätzliche Flexibilität und Sicherheit gibt.\n\nAls wir offiziell ankündigten, dass die GitLab-CI-Plattform für Benutzer(innen) allgemein verfügbar sein würde, erfolgten bereits 23 % aller Builds in GitLab CI mit einer Kombination von „Grassroots“-Bemühungen und Early Adopters.\n\nDie Herausforderung der Migration lag jedoch in der großen Streuung. Aufgrund der großen Anzahl an benutzerdefinierten Builds in Jenkins hätte ein automatisiertes Migrationstools für die meisten Teams nicht funktioniert. Die meisten Vorteile des neuen Systems kamen erst zum Tragen, als das alte System auf dem Nullstand war. Nur dann konnten wir die Hardware ausschalten und die CloudBees-Lizenzgebühr sparen.\n\n## Funktionsgleichheit und die Vorteile eines Neustarts\n\nObwohl wir bei Indeed viele verschiedene Technologien unterstützen, sind die drei am häufigsten verwendeten Sprachen Java, Python und JavaScript. Mit diesen Programmiersprachen werden Bibliotheken, Bereitstellungen (Webservices oder Anwendungen) und Cron-Jobs (ein Prozess, der in regelmäßigen Abständen abläuft, z. B. um einen Datensatz in unserem Data Lake aufzubauen) erstellt. Jedes davon bildete eine Matrix an Projekttypen (Java Library, Python Cronjob, JavaScript Webapp usw.), für die wir ein Grundgerüst in Jenkins hatten. Daher mussten wir für jeden dieser Projekttypen eine Golden-Path-Vorlage in GitLab CI erstellen.\n\nDie meisten Benutzer(innen) können diese empfohlenen Pfade ohne Änderungen nutzen, aber für jene, die eine Anpassung brauchen, ist der Golden Path trotzdem ein wichtiger Ausgangspunkt, der ihnen ermöglicht, nur das Nötige zu ändern und trotzdem in Zukunft von zentralisierten Vorlagenaktualisierungen zu profitieren.\n\nWir haben schnell gemerkt, dass die meisten Benutzer(innen), auch jene mit Anpassungen, gern den Golden Path nehmen bzw. ihn zumindest ausprobieren. Wenn sie ihre Anpassungen vermissen, können sie sie immer noch später hinzufügen. Das war ein überraschendes Ergebnis! Wir dachten, dass die Teams, die in signifikante Anpassungen investiert hatten, diese nur widerstrebend aufgeben würden, doch in der Mehrheit der Fälle waren sie den Teams nach der Umstellung egal. Dadurch konnten wir viele Projekte sehr schnell migrieren. Wir konnten einfach den Golden Path (eine kleine, etwa 6 Zeilen lange Datei mit Includes) in ihre Projekte einfügen und sie konnten sie von dort aus nutzen.\n\n## InnerSource als Retter in der Not\n\nDas CI-Plattformteam hat auch eine Richtlinie eingeführt, die besagt, dass externe Beiträge Vorrang haben. So werden alle im Unternehmen zur Teilnahme ermutigt. Dies wird manchmal als InnerSource bezeichnet. Wir haben Tests und Dokumentationen geschrieben, um externe Beiträge – Beiträge von außerhalb unseres unmittelbaren Teams – zu ermöglichen, damit Teams, die Anpassungen schreiben wollten, sie stattdessen in den Golden Path hinter einer Feature-Flag einfügen können. So konnten sie ihre Arbeit mit anderen teilen und sicherstellen, dass wir sie im weiteren Verlauf des Projekts nicht beschädigen (denn sie wurde Teil unserer Codebase, nicht ihrer eigenen). \n\nDies hatte auch den Vorteil, dass manche Teams, die auf eine benötigte Funktion warten mussten, selbst an dieser Funktion arbeiten konnten. Wir konnten sagen: „Wir planen, die Funktion in ein paar Wochen zu implementieren. Wenn ihr sie eher braucht, dürft ihr gerne daran mitarbeitet.“ Am Ende wurden viele Kernfunktionen, die für die Gleichschaltung nötig waren, auf diese Weise schneller und besser entwickelt, als es für unser Team alleine möglich gewesen wäre. Ohne dieses Modell wäre die Migration nicht erfolgreich gewesen.\n\n## Vor dem Zeitplan und unter dem Budget\n\nUnsere CloudBees-Lizenz lief am 1. April 2024 aus. Dies gab uns ein ambitioniertes Ziel für die vollständige Migration vor. Dies war besonders ehrgeizig, wenn man bedenkt, dass zu dieser Zeit 80 % aller Builds (60 % aller Projekte) noch Jenkins für ihre CI verwendeten. Dies bedeutete, dass über 2.000 [Jenkins-Dateien](https://www.jenkins.io/doc/book/pipeline/jenkinsfile/) noch umgeschrieben oder durch unsere Golden-Path-Vorlagen ersetzt werden mussten.\n\nUm dieses Ziel zu erreichen, stellten wir Dokumentationen und Beispiele zur Verfügung, implementierten Funktionen, wo dies möglich war, und halfen unseren Benutzer(inne)n, Funktionen beizutragen, wo sie konnten.\n\nWir haben regelmäßige Bürozeiten eingeführt, zu denen jeder kommen und Fragen stellen oder unsere Hilfe bei der Migration in Anspruch nehmen konnte. Außerdem haben wir Supportfragen zur Migration vor fast allem anderen priorisiert. Unsere Teammitglieder wurden zu GitLab-CI-Profis und teilten dieses Wissen innerhalb des Teams und im gesamten Unternehmen.\n\nEine automatische Migration war bei den meisten Projekten nicht möglich, aber wir fanden heraus, dass sie für eine kleine Untergruppe an Projekten funktionierte, in denen es wenig Anpassungen gab. Wir erstellten eine Sourcegraph-Stapeländerungskampagne, um Merge Requests für die Migration von hunderten Projekten einzureichen und forderten unsere Benutzer(innen) auf, diese MRs anzunehmen.\n\nWir zogen Erfolgsgeschichten unserer Benutzer(innen) heran und weit verbreitet. Als die Benutzer(innen) neue Funktionen zu unseren Golden Paths beisteuerten, warben wir damit, dass diese Funktionen bei der Migration auf GitLab CI „kostenlos enthalten“ sind. Einige Beispiele sind integrierte Sicherheits -und Compliance-Scans, Slack-Benachrichtigungen für CI-Builds und Integrationen in andere interne Systeme.\n\nWir haben auch eine Kampagne aggressiver „Scream Tests“ durchgeführt. Wir haben Jenkins-Jobs, die schon eine Weile nicht mehr ausgeführt wurden oder schon länger nicht mehr erfolgreich waren, automatisch deaktiviert und teilten den Benutzer(inne)n mit, dass sie diese Jobs wieder aktivieren konnten, wenn sie sie nochmals brauchen würden. So konnten wir auf einfache Weise feststellen, welche Jobs wirklich gebraucht wurden. Wir hatten Tausende von Jobs, die seit unserer letzten CI-Migration (von Jenkins zu Jenkins) nicht ein einziges Mal ausgeführt worden waren. Dies zeigte uns, dass wir fast alle davon sicher ignorieren konnten.\n\nIm Januar 2024 gaben wir unsere Benutzer(inne)n einen Anstoß, indem wir ankündigten, dass alle Jenkins-Controller schreibgeschützt werden (keine Builds), es sei denn, es wird ausdrücklich eine Ausnahme angefordert. Wir hatten viel bessere Informationen zum Eigentum von Controllern und sie entsprachen im Allgemeinen unserer Unternehmensstruktur, also war es sinnvoll, sich auf Controller und nicht auf Jobs zu konzentrieren. Die Liste der Controller war auch viel überschaubarer als die Liste der Jobs.\n\nUm eine Ausnahme zu erhalten, baten wir unsere Benutzer(innen), ihre Controller in einer Tabelle zu suchen und ihre Kontaktinformationen daneben zu schreiben. Dadurch erhielten wir eine sichere, aktuelle Liste der Stakeholder, die wir auf dem Endspurt nachverfolgen konnten. Außerdem konnten uns die Benutzer(innen) dadurch deutlich mitteilen, welche Jobs sie unbedingt brauchten. Zu Spitzenzeiten hatten wir etwa 400 Controller; im Januar hatten wir 220, aber nur 54 Controller benötigten Ausnahmen (einige von ihnen gehörten uns, um unsere Tests und Canary Tests durchzuführen).\n\n![Indeed – Anzahl der Jenkins-Controller](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750099357/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750099357392.png)\n\nWir hatten eine überschaubare Liste von etwa 50 Teams, die wir unter unseren Teammitgliedern aufteilten, und begannen, Kontakt aufzunehmen, um herauszufinden, wie jedes Team bei der Migration vorankam. Im Januar und Februar stellten wir fest, dass einige Teams planten, ihre Migration ohne unsere Hilfe vor dem 28. Februar abzuschließen. Andere planten wiederum, ihre Projekte vorher einzustellen, und eine sehr kleine Anzahl war sehr besorgt, dass sie es nicht schaffen würden.\n\nWir konnten mit dieser kleineren Gruppe von Teams zusammenarbeiten und ihnen einen maßgeschneiderten Service bieten. Wir erklärten ihnen, dass wir zwar nicht über das nötige Fachwissen verfügten, um die Migration für sie durchzuführen, dass wir aber mit Fachleuten aus ihrem Team zusammenarbeiten konnten. Für einige Projekte schrieben wir und sie überprüften; für andere schrieben sie und wir überprüften. Am Ende hat sich unsere ganze Arbeit ausgezahlt und wir haben Jenkins genau an dem Tag ausgeschaltet, den wir 8 Monate zuvor angekündigt hatten.\n\n## Die Ergebnisse: verbesserte CI-Effizienz und Benutzerzufriedenheit\n\nAuf dem Höhepunkt führte unsere Jenkins CI-Plattform über 14.000 Pipelines pro Tag aus und bediente Tausende Projekte. Heute führt unsere GitLab-CI-Plattform schon einmal über 40.000 Pipelines an einem einzigen Tag aus und regelmäßig über 25.000 pro Tag. Die inkrementellen Kosten für jeden Job jeder Pipeline sind ähnlich wie bei Jenkins, aber ohne den Aufwand für die Hardware zum Ausführen der Controller. Darüber hinaus dienten diese Controller als Single Points of Failure und Skalierungsbegrenzer, die uns zwangen, unsere Plattform künstlich in Segmente zu unterteilen. Ein direkter Vergleich ist immer schwierig, aber wir haben festgestellt, dass die Kosten für unsere CI-Hardware ohne diesem Overhead um 10–20 % niedriger sind. Außerdem ist der Supportaufwand für GitLab CI niedriger, da sich die Anwendung automatisch in der Cloud skaliert, über Verfügbarkeitszonen ausfallsicher ist und für die Vorlagensprache eine hervorragende Dokumentation öffentlich verfügbar ist.\n\nEin ebenso wichtiger Vorteil ist, dass wir jetzt über 70 % Annahmerate unserer Golden Paths erreicht haben. Das bedeutet, dass wir eine Verbesserung umsetzen konnten, von der über 5.000 Projekte bei Indeed sofort ohne weitere Maßnahmen profitieren können. So konnten wir einige Jobs zu kostengünstigeren ARM64-Instanzen verschieben, die Build-Images der Benutzer(innen) einfacher auf dem neuesten Stand halten und unsere Möglichkeiten zur Kosteneinsparung besser verwalten. Am wichtigsten ist aber, dass unsere Benutzer(innen) mit der neuen Plattform zufriedener sind.\n\n__Über den Autor:__\n*Carl Myers lebt in Sacramento, Kalifornien, und ist Manager des CI-Plattformteams bei Indeed. Carl hat seine fast zwei Jahrzehnte lange Berufslaufbahn damit verbracht, interne Tools und Entwicklerplattformen zu entwickeln, die Entwickler(innen) in großen und kleinen Unternehmen begeistern und befähigen.*\n\n**Danksagungen:**\n*Diese Migration wäre ohne die unermüdlichen Bemühungen von Tron Nedelea, Eddie Huang, Vivek Nynaru, Carlos Gonzalez, Lane Van Elderen und dem Rest des CI-Plattformteams nicht möglich gewesen. Unser Teams ist besonders dankbar für die Führung von Deepak Bitragunta. Unser Dank geht auch an Irina Tyree für ihre Unterstützung bei diesem langen Projekt, für die Bereitstellung von Ressourcen und die unternehmensweite Abstimmung. Abschließend möchten wir uns bei allen bei Indeed bedanken, die Code, Feedback und Fehlerberichte beigetragen sowie bei der Migration von Projekten geholfen haben.*\n\n**Dies ist eine überarbeitete Version des Artikels [Wie Indeed seine CI-Plattform durch Gitlab CI ersetzt hat](https://engineering.indeedblog.com/blog/2024/08/indeed-gitlab-ci-migration/), der ursprünglich auf dem Indeed-Engineering-Blog veröffentlicht wurde.**",[897,109,911,808],"user stories","2024-10-31",{"slug":914,"featured":91,"template":797},"how-indeed-transformed-its-ci-platform-with-gitlab",{"content":916,"config":928},{"title":917,"description":918,"authors":919,"heroImage":921,"date":922,"body":923,"category":708,"tags":924,"updatedDate":927},"Southwest möchte mit seinen Entwickler(inne)n abheben","Erfahre, wie die DevOps-Teams der Fluglinie dank GitLab Probleme viel einfacher erkennen und beheben können.",[920],"Sharon Gaudin","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749665272/Blog/Hero%20Images/AdobeStock_380312133.jpg","2024-01-30","Southwest Airlines Co. ist bestrebt, die Arbeit seiner Entwickler(innen) zu leichter zu machen.\n\nDie IT-Führungskräfte der weltweit größten Billigfluglinie arbeiten daran, zeitaufwändige und sich wiederholende Aufgaben aus den Workflows der Entwickler(innen) zu eliminieren, damit diese mehr Zeit haben, sich auf größere Projekte zu konzentrieren.\n\n„Das schaffen wir, indem wir Hürden für sie aus dem Weg räumen“, erklärt Jim Dayton, Vice President und CISO bei Southwest Airlines. „Ich bin fest davon überzeugt, dass die Leute in der Softwareentwicklung arbeiten wollen, weil sie die Kreativität lieben. Sie lieben es, Probleme zu lösen. Dabei dürfen wir ihnen nicht im Weg stehen und müssen die Dinge, die sie behindern, aus dem Weg räumen.“\n\nDas möchte Dayton unter anderem mit der Plattform von GitLab erreichen.\n\nDayton hat bei einem Event der [DevSecOps World Tour von GitLab](https://about.gitlab.com/events/devsecops-world-tour/) in Dallas auf der Bühne in einem Interview über die Bestrebungen von Southwest gesprochen, sich um seine Entwickler(innen) zu kümmern und ihre Arbeit zu würdigen. Ein Teil seines Vortrags war ein Gespräch mit Reshmi Krishna, Director für Enterprise Solutions Architecture bei GitLab, in dem er mit ihm darüber sprach, welche Vorteile künstliche Intelligenz seinen Teams bieten könnte.\n\nDer Southwest-Manager sprach darüber, in seinem Unternehmen vermehrt auf einen DevOps-Ansatz bei der Anwendungsentwicklung zu setzen und fügte hinzu, dass den Entwickler(inne)n mehr Self-Service-Möglichkeiten und Wissensmanagement-Prozesse geboten werden sollten. „Wir wollen, dass Entwickler(innen) schnell ein Problem nachschlagen und eine Lösung finden können. Außerdem sollte Kontextwechsel reduziert werden“, sagte er. „Wir müssen sehen können, was wir von ihnen verlangen und was sie daran hindert, produktiv zu sein.“\n\nDayton merkte an, dass Southwest, das seit 2019 mit GitLab zusammenarbeitet, sich darauf konzentriert, seine Software-Entwicklungsprozesse konsistenter zu machen. Zum Teil bedeutet das, Code in ein gemeinsames GitLab-Repository zu verschieben. Wenn Teams wissen, wo sich ihr Code befindet, können sie Metriken einfacher bewerten und sich darauf konzentrieren, Code wiederzuverwenden und dadurch effizienter zu werden.\n\n„Wir sind auch dabei, unsere Enterprise-Pipelines fertigzustellen, und wir sind bereit, mit der Migration der Teams zu beginnen“, sagte Dayton. „Wir arbeiten intensiv mit vielen verschiedenen Anwendungsentwicklungsteams zusammen, um zu verstehen, was sie in den Pipelines benötigen, die wir aufbauen, und wir bereiten uns darauf vor, Teams auf sie zu migrieren. Ich denke, wir werden bis Ende des Jahres ziemlich nah dran sein.“\n\n### Das Versprechen der KI\n\nEine der Möglichkeiten, wie sich Entwickler(innen) auf größere und innovativere Aufgaben konzentrieren können, ist der Einsatz künstlicher Intelligenz, so Dayton.\n\nGenerative KI, ob in Form von Erklärungen zu Sicherheitslücken, Codevorschlägen oder Code-Vervollständigung, kann Arbeitsabläufe im gesamten Software-Entwicklungsprozess signifikant beeinflussen. Der Einsatz von KI-Tools, die direkt in eine Plattform integriert sind, kann die Sicherheit erhöhen und den Zeitaufwand für Code Reviews und Anwendungsentwicklung verringern.\n\nDayton freut sich bereits darauf, die Entwicklung und Bereitstellung mithilfe von KI-Funktionen zu beschleunigen und zu erleichtern.\n\n„Wir wollen alltägliche Aufgaben und die Bürokratie für unsere Entwickler(innen) so weit wie möglich aus dem Weg räumen“, erklärt Dayton und fügt hinzu, dass es rund um das Thema KI zwar einen riesigen Hype, aber auch großes Potenzial gebe. „Mit der KI könnten wir das schaffen. Ein gutes Beispiel ist meiner Meinung nach, wenn die KI eine Lösung für eine Sicherheitslücke bietet, die gerade entdeckt wurde, oder wenn sie uns sagen kann, was ein Teil des Codes tut. Womit wird er integriert? Auf welche Daten wird zugegriffen und warum? Sag mir zum Beispiel im Klartext, dass dieser bestimmte Code für 20 % der Vorfälle in dieser Anwendung im letzten Jahr verantwortlich war. Hier kann KI meiner Meinung nach helfen.“Dayton erläutert auch, dass er nicht glaubt, dass KI die Entwickler(innen) ersetzen wird. Stattdessen sollte sie ihnen die Arbeit erleichtern. KI kann in der Welt nach COVID außerdem dazu beitragen, die remote arbeitenden Entwickler(innen) zu verbinden.\n\n„Eines der coolen Dinge, die in der Roadmap [von GitLab] enthalten sind, sind vorgeschlagene Prüfer(innen)“, sagte er. „Das hilft bei Code Reviews, bei denen man früher einfach quer durch den Raum oder über die nächste Trennwand rief: ‚Hey, kann sich jemand meinen Code ansehen?‘ Das ist jetzt nicht mehr so einfach. KI kann Personen vorschlagen, die schon einmal in diesem Code gearbeitet haben, die Vorfälle in diesem Code gelöst haben und so etwas machen. Wie wichtig wird das für den Review-Prozess sein? Ich denke, je mehr Automatisierung wir einsetzen können, desto weniger manuelle Schritte oder Wartezeiten wird es geben.“\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/UnUfp7pKnEQ?si=qcX2Qm3zpgQOV4xy\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n*Southwest Airlines ist ein rund 24 Milliarden Dollar schweres Unternehmen mit Sitz in Dallas, Texas. Die Fluglinie hat 72 000 Mitarbeitende und fliegt mit 4 000 Flügen pro Trag 120 verschiedene Ziele an. Mit Southwest fliegen mehr Inlandspassagiere als mit jeder anderen Fluglinie.\nLies weitere GitLab-Kundenstorys auf unserer [Kundenseite](https://about.gitlab.com/de-de/customers/).*\n",[925,926,838,897],"DevOps","DevOps platform","2024-12-11",{"slug":929,"featured":6,"template":797},"southwest-looking-to-help-developers-take-flight",{"category":716,"slug":720,"posts":931},[932,945,958],{"content":933,"config":943},{"heroImage":934,"body":935,"authors":936,"updatedDate":938,"date":939,"title":940,"tags":941,"description":942,"category":720},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097063/Blog/Hero%20Images/Blog/Hero%20Images/securitylifecycle-light_securitylifecycle-light.png_1750097063583.png","In der modernen Softwareentwicklung von heute migrieren viele Unternehmen in die Cloud und führen DevSecOps-Prozesse ein. Durch die Vielzahl von Tools und Legacy-Systemen, die nicht für die moderne Entwicklung ausgelegt sind, stellt diese Umstellung jedoch eine große Herausforderung dar. \n\nUm diese Systeme an DevSecOps anzupassen, müssen Unternehmen mehrere Tools für Aufgabenmanagement, CI/CD, Sicherheit, Überwachung und vieles mehr miteinander verknüpfen. Das Ergebnis? Komplexe Betriebsabläufe, hohe Wartungskosten und eine erschwerte Zusammenarbeit zwischen Entwicklungs- und Betriebsteams. Darüber hinaus sind Entwickler(innen) frustriert, da sie ständig zwischen verschiedenen Tools wechseln müssen, um einen einzigen Flow – von der Planung bis zur Produktion – abzuschließen.\n\n![Die Komplexität und die Betriebskosten der Integration mehrerer Tools in einen DevSecOps-Prozess](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097077/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097077287.jpg)\n\n\u003Ccenter>\u003Ci>Wie komplex es sein kann, mehrere Tools in einen DevSecOps-Prozess zu integrieren\u003C/i>\u003C/center> \n\n\u003Cbr>\u003C/br>\n\nDie gute Nachricht ist, es gibt eine Lösung: Eine umfassende DevSecOps-Plattform, die einen einheitlichen Ansatz für die Softwareentwicklung bietet.\n\nDiese Plattformen sind für Unternehmen konzipiert, die in cloudbasierten und DevSecOps-Umgebungen arbeiten. Sie konsolidieren alle Phasen der Softwareentwicklung – von der Codeverwaltung, über CI/CD-Prozesse, Aufgabenmanagement und Sicherheit bis hin zur KI-gestützten Automatisierung – auf einer einzigen Plattform. Die Zentralisierung aller Softwareentwicklungs-Workflows in einer einheitlichen Oberfläche ermöglicht es den Entwicklungs- und Betriebsteams, effizienter zu arbeiten, die Kommunikation zu vereinfachen und die Komplexität der Vorgänge und Störungen zu minimieren. \n\nDarüber hinaus verbessert sich die Entwicklererfahrung erheblich – sie arbeiten viel lieber mit einem Produkt, das speziell für moderne Entwicklungsanforderungen konzipiert wurde.\n\nIn den folgenden Abschnitten erfahren wir, wie GitLab Teams bei der Bewältigung gängiger Herausforderungen hilft – sei es bei der Verwaltung von Projekten und Aufgaben, der Gewährleistung von Sicherheit und Compliance oder der Einführung von KI-basierten Entwicklungstools – und das alles auf einer einzigen, einheitlichen Plattform.\n\n## Integriertes Agile-Projektmanagement\n\n[GitLab](https://about.gitlab.com/de-de/) bietet eine ganzheitliche Lösung, bei der das Projekt- und Aufgabenmanagement über alle Phasen des Softwareentwicklungszyklus hinweg vollständig integriert ist, wie z. B. CI/CD, wodurch der Entwicklungsfortschritt in Echtzeit verfolgt werden kann. Tickets und Epics sind direkt mit den Automatisierungsprozessen verknüpft und ermöglichen einen nahtlosen Flow von der Planung bis zur Bereitstellung in der Produktion. Dieser Ansatz erhöht die Transparenz zwischen den Teams, verringert Verzögerungen und stellt sicher, dass alle Beteiligten einen klaren Überblick über den Entwicklungsstatus in Echtzeit haben.\n\n![Tickets und Epics sind direkt mit Automatisierungsprozessen verknüpft und ermöglichen einen nahtlosen Übergang von der Planung bis zur Bereitstellung in der Produktion.](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097077/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097077288.jpg)\n\n## Integrierte Sicherheit\n\nGitLab legt großen Wert auf die Integration von umfassenden Sicherheitsfunktionen („security first“). Die Plattform integriert eine breite Palette automatisierter Sicherheitsscanner, darunter (Dokumentation nur in englischer Sprache verfügbar):\n\n* [Abhängigkeitssuche](https://docs.gitlab.com/user/application_security/dependency_scanning/)\n* [Statische Anwendungssicherheitstests (SAST)](https://docs.gitlab.com/user/application_security/sast/)\n* [Dynamische Anwendungssicherheitstests (DAST)](https://docs.gitlab.com/user/application_security/dast/)\n* [Erkennung von Geheimnissen](https://docs.gitlab.com/user/application_security/secret_detection/)\n* [Container-Scanning](https://docs.gitlab.com/user/application_security/container_scanning/)\n\n![Sicherheitsscanning-Funktionen, die in verschiedenen Entwicklungsphasen in den CI/CD-Prozess integriert sind](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097077/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097077289.jpg)\n\n\u003Ccenter>\u003Ci>Sicherheitsscanning-Funktionen, die in verschiedenen Entwicklungsphasen in den CI/CD-Prozess integriert sind\u003C/i>\u003C/center>\n\n\u003Cbr>\u003C/br>\n\nDiese Sicherheitsprüfungen werden direkt in jede Phase des Softwareentwicklungszyklus eingebaut, einschließlich der CI/CD-Pipeline, um den Entwickler(inne)n schon früh im Entwicklungszyklus ein unmittelbares Feedback zu potenziellen Sicherheitsproblemen zu geben.\n\n## Compliance und regulatorische Anforderungen\n\nNeben Effizienz und Benutzerfreundlichkeit müssen viele Unternehmen – insbesondere in regulierten Branchen wie Finanzinstituten oder Großunternehmen – sicherstellen, dass ihre Prozesse strengen Sicherheits- und Compliance-Standards entsprechen. Sie müssen in der Lage sein, Richtlinien für verschiedene Projekte durchzusetzen, z. B. einen Sicherheitsscanner vorzuschreiben, wenn eine CI/CD-Pipeline auf bestimmten Code-Branches (Main- oder geschützte Branches) ausgeführt wird, oder bestimmte Genehmigungen zu verlangen, bevor Code in den Main-Branch zusammengeführt wird.\n\nMit GitLab wird dies durch [Compliance-Frameworks (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/introducing-custom-compliance-frameworks-in-gitlab/) erleichtert, eine Funktion, mit der Unternehmen strukturierte Richtlinien für ausgewählte Projekte definieren und durchsetzen können. So wird die Einhaltung automatischer gesetzlicher und sicherheitstechnischer Anforderungen gewährleistet und gleichzeitig ein nahtloser und effizienter Workflow für Entwickler(innen) sichergestellt.\n\n## KI-basierte Entwicklung\n\n[GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/) unterstützt dich in allen Entwicklungsphasen mit KI, sodass du nicht mehr auf externe Tools zurückgreifen musst. Jede KI-unterstützte Anforderung wird im gesamten Kontext des Projekts und der Codebase bearbeitet, was eine intelligentere und effizientere Arbeit ermöglicht.\n\nDie KI kann zum Beispiel folgende Aufgaben übernehmen:\n\n* automatische Erstellung von Aufgabenbeschreibungen\n* intelligente Zusammenfassung von Diskussionen zu Tickets, was Entwickler(inne)n wertvolle Zeit spart\n* erweiterte Code-Review-Funktionen\n* Vorschläge zur Codeverbesserung und -optimierung\n* automatisierte Testgenerierung\n* Erkennung und Behebung von Sicherheitslücken\n* Fehlerbehebung bei der Grundursachenanalyse für CI-Pipeline-Fehler\n* Datenschutz und Datensicherheit\n\nGitLab kennt die Bedürfnisse von regulierten Unternehmen, insbesondere im öffentlichen und im Finanzsektor, und bietet eine einzigartige Lösung für den Einsatz von KI-Modellen in einer sicheren Umgebung. GitLab Duo Self-Hosted ermöglicht es Unternehmen, die volle Kontrolle über Datenschutz, Sicherheit und die Bereitstellung großer Sprachmodelle [(LLMs; nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/what-is-a-large-language-model-llm/) in ihrer eigenen Infrastruktur zu behalten. Dabei wird Folgendes gewährleistet:\n\n* Datenschutz\n* Einhaltung gesetzlicher Anforderungen\n* maximale Sicherheit\n* KI-Vorteile ohne externe Netzwerkabhängigkeiten oder -risiken\n\n## Zusammenfassung\n\nUnternehmen brauchen eine umfassende DevSecOps-Plattform, um Prozesse zu rationalisieren, die Sicherheit zu verbessern und Innovationen zu beschleunigen. GitLab bietet genau das – eine einzige Anwendung, die alle wichtigen Entwicklungs-, Sicherheits- und Betriebswerkzeuge mit integrierter Sicherheitsintegration und KI-basierter Automatisierung vereint.\n\nWillst du GitLab in Aktion sehen? Entdecke interaktive (englischsprachige) Demos für:\n\n* [GitLab Premium und Ultimate mit Duo](https://gitlab.navattic.com/gitlab-premium-with-duo): Erlebe KI-Unterstützung bei der Entwicklung,\n* [Sicherheit in der CI/CD-Pipeline](https://gitlab.navattic.com/gitlab-scans): Sieh dir an, wie integriertes Sicherheitsscanning deine Software schützt.\n* [Compliance-Frameworks](https://gitlab.navattic.com/compliance): Erfahre, wie GitLab Richtlinien projektübergreifend durchsetzt, um eine bessere Governance zu gewährleisten.\n\n> Nimm am virtuellen Launch-Event von GitLab 18 teil, um mehr über die Zukunft der DevSecOps-Plattform zu erfahren, einschließlich der Rolle der agentischen KI. [Registriere dich noch heute!](https://about.gitlab.com/de-de/eighteen/)",[937],"Itzik Gan Baruch","2025-06-23","2025-06-02","Warum steigen Unternehmen auf eine einheitliche DevSecOps-Plattform um?",[716,808,765],"Erfahre mehr über die einheitliche DevSecOps-Plattform von GitLab, die Tools integriert, Sicherheit verbessert und KI für eine effiziente Softwareentwicklung nutzt.",{"slug":944,"featured":6,"template":797},"why-are-organizations-moving-to-a-unified-devsecops-platform",{"content":946,"config":956},{"title":947,"description":948,"authors":949,"heroImage":951,"date":952,"body":953,"category":720,"tags":954,"updatedDate":955},"Der ultimative CI/CD-Leitfaden: Grundlagen für die erweiterte Implementierung","Erfahre, wie du die kontinuierliche Integration/kontinuierliche Bereitstellung modernisierst und die Entwicklung, Lieferung und Sicherheit von Pipelines automatisierst.",[950],"Sandra Gittlen","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749660151/Blog/Hero%20Images/blog-image-template-1800x945__26_.png","2025-01-06","Die kontinuierliche Integration/kontinuierliche Lieferung ([CI/CD](https://about.gitlab.com/de-de/topics/ci-cd/)) hat die Art und Weise revolutioniert, wie Softwareteams Werte für ihre Benutzer(innen) schaffen. Vorbei sind die Zeiten manueller Bereitstellungen und komplizierter Integrationen – moderne Entwicklung erfordert Automatisierung, Zuverlässigkeit und Geschwindigkeit.\n\nIm Grunde geht es bei CI/CD darum, eine nahtlose Pipeline zu erstellen, die Code von der Umgebung der Entwickler(innen) bis hin zur Produktion überführt und Feedback in Echtzeit einbezieht. [CI](https://about.gitlab.com/de-de/topics/ci-cd/benefits-continuous-integration/) hilft Teams, Mängel frühzeitig zu erkennen – bevor sie zu kostspieligen Problemen werden –, indem sichergestellt wird, dass Codeänderungen häufig in einem gemeinsamen Repository zusammengeführt, automatisch getestet und validiert werden. [CD](https://about.gitlab.com/de-de/topics/ci-cd/#what-is-continuous-delivery-cd) führt diesen Ansatz fort, indem es den Bereitstellungsprozess automatisiert und die Releases vorhersehbar und stressfrei macht.\n\nAnstatt sich auf manuelle Prozesse und komplexe Toolchains für die Softwareentwicklung zu verlassen, können Teams eine robuste CI/CD-Pipeline verwenden, um Software zu erstellen, zu testen und bereitzustellen. Die KI kann diesen Prozess noch weiter optimieren und automatisch CI/CD-Pipelines erstellen, die konsistente Qualität, Compliance und Sicherheitsüberprüfungen ermöglichen.\n\nIn diesem Leitfaden werden moderne CI/CD-Pipelines von den Grundprinzipien über Best Practices bis hin zu fortschrittlichen Strategien erklärt. Du erfährst außerdem, wie führende Unternehmen CI/CD nutzen, um wirkungsvolle Ergebnisse zu erzielen. Mit den Erkenntnissen dieses Leitfadens kannst du deine DevSecOps-Umgebung skalieren und Software [agil](https://about.gitlab.com/de-de/topics/ci-cd/continuous-integration-agile/), automatisiert und effizient entwickeln und bereitstellen.\n\n## Inhalt: Das erwartet dich\n\n- [Was ist kontinuierliche Integration?](#was-ist-kontinuierliche-integration%3F)\n- [Was ist kontinuierliche Lieferung?](#was-ist-kontinuierliche-lieferung%3F)\n- [Wie hängt die Quellcodeverwaltung mit CI/CD zusammen?](#wie-hängt-die-quellcodeverwaltung-mit-cicd-zusammen%3F)\n- [Die Vorteile von CI/CD in der modernen Softwareentwicklung](#die-vorteile-von-cicd-in-der-modernen-softwareentwicklung)\n - [Hauptunterschiede zwischen CI/CD und traditioneller Entwicklung](#hauptunterschiede-zwischen-cicd-und-traditioneller-entwicklung)\n- [Grundlagen von CI/CD verstehen](#grundlagen-von-cicd-verstehen)\n - [Was ist eine CI/CD-Pipeline?](#was-ist-eine-cicd-pipeline%3F)\n- [Best Practices für CI/CD-Implementierung und -Management](#best-practices-für-cicd-implementierung-und--management)\n - [Best Practices für CI](#best-practices-für-ci)\n - [Best Practices für CD](#best-practices-für-cd)\n- [Erste Schritte mit CI/CD](#erste-schritte-mit-cicd)\n- [Sicherheit, Compliance und CI/CD](#sicherheit-compliance-und-cicd)\n- [CI/CD und die Cloud](#cicd-und-die-cloud)\n- [Erweitertes CI/CD](#erweitertes-cicd)\n - [Wiederverwendung und Automatisierung in CI/CD](#wiederverwendung-und-automatisierung-in-cicd)\n - [Problembehebung für Pipelines mithilfe von KI](#problembehebung-für-pipelines-mithilfe-von-ki)\n- [So migrierst du zu GitLab CI/CD](#so-migrierst-du-zu-gitlab-cicd)\n- [Erfahrungsberichte von führenden Unternehmen](#erfahrungsberichte-von-führenden-unternehmen)\n- [CI/CD-Tutorials](#cicd-tutorials)\n\n## Was ist kontinuierliche Integration?\n\nUnter [kontinuierlicher Integration](https://about.gitlab.com/de-de/topics/ci-cd/benefits-continuous-integration/) (CI) versteht man das Vorgehen, alle Codeänderungen frühzeitig und häufig in den main-Branch eines gemeinsamen Quellcode-Repositorys zu integrieren, Änderungen automatisch zu testen, wenn sie committet oder zusammengeführt werden, und automatisch einen Build zu starten. Mit kontinuierlicher Integration können Teams Fehler und Sicherheitsprobleme leichter und viel früher im Entwicklungsprozess erkennen und beheben.\n\n## Was ist kontinuierliche Lieferung?\n[Kontinuierliche Lieferung](https://about.gitlab.com/de-de/topics/ci-cd/#what-is-continuous-delivery-cd) (CD) – manchmal auch _kontinuierliche Bereitstellung_ genannt – ermöglicht es Unternehmen, ihre Anwendungen automatisch bereitzustellen, sodass Entwickler(innen) mehr Zeit haben, sich auf die Überwachung des Bereitstellungsstatus zu konzentrieren und den Erfolg sicherzustellen. Bei der kontinuierlichen Lieferung legen DevOps-Teams die Kriterien für die Codefreigabe im Voraus fest. Wenn diese Kriterien erfüllt und validiert sind, wird der Code in der Produktivumgebung bereitgestellt. So können Unternehmen flexibler sein und neue Funktionen den Benutzer(inne)n schneller zur Verfügung stellen.\n\n## Wie hängt die Quellcodeverwaltung mit CI/CD zusammen?\n\nQuellcodeverwaltung ([Source Code Management, SCM](https://about.gitlab.com/de-de/solutions/source-code-management/)) und CI/CD bilden die Grundlage moderner Softwareentwicklungsverfahren. SCM-Systeme wie [Git](https://about.gitlab.com/de-de/blog/what-is-git-the-ultimate-guide-to-gits-role-and-functionality/) bieten eine zentrale Möglichkeit, Änderungen zu verfolgen, verschiedene Codeversionen zu verwalten und die Zusammenarbeit zwischen den Teammitgliedern zu erleichtern. Wenn Entwickler(innen) an neuen Funktionen oder Fehlerbehebungen arbeiten, erstellen sie Branches aus der main-Codebase, nehmen ihre Änderungen vor und [führen sie dann über Merge Requests zusammen](https://docs.gitlab.com/ee/user/project/merge_requests/) (Artikel nur in englischer Sprache verfügbar). Diese Branching-Strategie macht es möglich, dass mehrere Entwickler(innen) gleichzeitig arbeiten können, ohne sich gegenseitig in die Quere zu kommen, und gleichzeitig einen stabilen main-Branch zu bewahren, der immer produktionsreifen Code enthält.\n\nCI/CD übernimmt den von SCM-Systemen verwalteten Code und erstellt, testet und validiert ihn automatisch, wenn Änderungen gepusht werden. Wenn Entwickler(innen) Codeänderungen einreichen, ruft das CI/CD-System automatisch den neuesten Code ab, kombiniert ihn mit der vorhandenen Codebase und führt eine Reihe automatisierter Überprüfungen durch. Dazu gehören in der Regel das Kompilieren des Codes, das Ausführen von Unit-Tests, das Durchführen einer statischen Codeanalyse und das Überprüfen der Testabdeckung. Wenn einer dieser Schritte fehlschlägt, wird das Team sofort benachrichtigt, sodass es Probleme beheben kann, bevor sie sich auf andere Entwickler(innen) auswirken oder in die Produktivumgebung überführt werden. Durch diese enge Integration zwischen Versionskontrolle und kontinuierlicher Integration entsteht eine Feedbackschleife, die dazu beiträgt, die Codequalität aufrechtzuerhalten, und verhindert, dass sich Integrationsprobleme ansammeln.\n\n## Die Vorteile von CI/CD in der modernen Softwareentwicklung\n\n[CI/CD bringt transformative Vorteile für die moderne Softwareentwicklung](https://about.gitlab.com/blog/ten-reasons-why-your-business-needs-ci-cd/) (Blogbeitrag nur in englischer Sprache verfügbar), indem die Zeit und das Risiko drastisch reduziert werden, die neue Funktionen und Fixes mit sich bringen. Durch die kontinuierliche Feedbackschleife können DevSecOps-Teams sicher sein, dass ihre Änderungen automatisch für die gesamte Codebase validiert werden. Das Ergebnis sind hochwertigere Software, kürzere Lieferzeiten und häufigere Veröffentlichungen, mit denen man schneller auf Benutzer- und Marktanforderungen reagieren kann.\n\nEiner der wichtigsten Aspekte ist jedoch, dass CI/CD eine Kultur der Zusammenarbeit und Transparenz innerhalb von Softwareentwicklungsteams fördert. Wenn jeder den Status von Builds, Tests und Bereitstellungen in Echtzeit sehen kann, wird es einfacher, Engpässe im Bereitstellungsprozess zu identifizieren und zu beheben. Die von CI/CD ermöglichte Automatisierung reduziert auch die kognitive Belastung für Entwickler(innen) und gibt ihnen die Möglichkeit, sich auf das Schreiben von Code zu konzentrieren, anstatt manuelle Bereitstellungsprozesse zu verwalten. Dies führt zu einer höheren Zufriedenheit und Produktivität der Entwickler(innen) und reduziert gleichzeitig das Risiko, das traditionell mit dem gesamten Softwareveröffentlichungsprozess verbunden ist. Teams können freier experimentieren, wenn sie wissen, dass schnelle Code Reviews Teil des Prozesses sind, und sie können Änderungen bei Bedarf schnell zurücknehmen, was Innovationen und kontinuierliche Verbesserungen fördert.\n\n### Hauptunterschiede zwischen CI/CD und traditioneller Entwicklung\n\nCI/CD unterscheidet sich in vielerlei Hinsicht von der traditionellen Softwareentwicklung:\n\n**Häufige Code-Commits** \n\nEntwickler(innen) arbeiten oft unabhängig und laden ihren Code selten in eine main-Codebase hoch, was zu Merge-Konflikten und anderen zeitaufwändigen Problemen führt. Mit CI/CD pushen Entwickler(innen) Commits den ganzen Tag über, um sicherzustellen, dass Konflikte frühzeitig erkannt werden und die Codebase auf dem neuesten Stand bleibt.\n\n**Reduziertes Risiko**\n\nLangwierige Testzyklen und eine umfassende Vorabplanung kennzeichnen die traditionelle Softwareentwicklung. Dadurch sollen Risiken minimiert werden, jedoch wird die Möglichkeit eingeschränkt, Probleme zu finden und zu beheben. Das Risikomanagement in CI/CD basiert darauf, dass kleine, inkrementelle Änderungen vorgenommen werden, die genau überwacht und leicht rückgängig gemacht werden können.\n\n**Automatisierte und kontinuierliche Tests**\n\nIn der traditionellen Softwareentwicklung werden Tests durchgeführt, sobald die Entwicklung abgeschlossen ist. Dies führt jedoch zu Problemen wie verspäteter Lieferung und kostspieliger Fehlerbehebungen. CI/CD unterstützt automatisierte Tests, die während der gesamten Entwicklung kontinuierlich durchgeführt und durch jeden Code-Commit ausgelöst werden. Entwickler(innen) erhalten außerdem Feedback, auf das sie schnell reagieren können.\n\n**Automatisierte, wiederholbare und häufige Bereitstellungen**\n\nMit CI/CD sind Bereitstellungen automatisierte Prozesse, die den typischen Stress und Aufwand für große Software-Rollouts reduzieren. Der gleiche Bereitstellungsprozess kann in allen Umgebungen wiederholt werden, was Zeit spart und Fehler und Inkonsistenzen reduziert.\n\n## Grundlagen von CI/CD verstehen\n\nCI/CD dient als Framework für den Aufbau skalierbarer, wartbarer Bereitstellungsprozesse. Daher ist es für DevSecOps-Teams wichtig, die Kernkonzepte wirklich zu verstehen. Durch ein solides Verständnis der CI/CD-Prinzipien können Teams, Strategien und Praktiken an die Entwicklung der Technologie anpassen, anstatt an alte Ansätze gebunden zu sein. Hier sind einige der Grundlagen.\n\n### Was ist eine CI/CD-Pipeline?\n\nEine [CI/CD-Pipeline](https://about.gitlab.com/de-de/topics/ci-cd/cicd-pipeline/) ist eine Reihe von Schritten wie Erstellen, Testen und Bereitstellen, durch die der Softwarebereitstellungsprozess automatisiert und optimiert wird. [Jede Phase dient als Qualitätsüberprüfung](https://about.gitlab.com/blog/guide-to-ci-cd-pipelines/) (Blogbeitrag nur in englischer Sprache verfügbar) und stellt sicher, dass nur validierter Code weiterentwickelt wird. In den frühen Phasen werden in der Regel grundlegende Überprüfungen wie Kompilierung und Unit-Tests durchgeführt, während spätere Phasen Integrationstests, Leistungstests, Konformitätstests und gestaffelte Bereitstellungen in verschiedenen Umgebungen umfassen können.\n\nDie Pipeline kann so konfiguriert werden, dass manuelle Genehmigungen an kritischen Punkten erforderlich sind, z. B. vor der Bereitstellung für die Produktion, während gleichzeitig Routineaufgaben automatisiert werden und Entwickler(innen) schnelles Feedback über den Zustand ihrer Änderungen erhalten. Dieser strukturierte Ansatz sorgt für Konsistenz, reduziert menschliche Fehler und bietet einen klaren Audit-Trail, wie Codeänderungen sich von der Entwicklung bis in die Produktion bewegen. Moderne Pipelines werden oft als Code implementiert, so dass sie wie Anwendungscode versioniert, getestet und gepflegt werden können.\n\nAuch die folgenden Begriffe sind für CI/CD wichtig:\n- **Commit:** eine Codeänderung\n- **Job:** Anweisungen, die ein Runner ausführen muss\n- **Runner:** ein Agent oder Server, der jeden Job einzeln ausführt und nach Bedarf hoch- oder herunterfahren kann\n- **Phase:** ein Schlüsselwort, das bestimmte Jobphasen definiert, z. B. „Erstellen“ und „Bereitstellen“. Jobs der gleichen Phase werden parallel ausgeführt. Pipelines werden mithilfe der versionierten YAML-Datei `.gitlab-ci.yml` auf der Root-Ebene eines Projekts konfiguriert.\n\n![CI/CD-Pipeline-Schema](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749673928/Blog/Content%20Images/1690824533476.png)\n\n## Best Practices für die Implementierung und das Management von CI/CD\n\nWie erfolgreich du mit CI/CD bist, hängt stark von den [Best Practices](https://about.gitlab.com/de-de/blog/how-to-keep-up-with-ci-cd-best-practices/) ab, die du implementierst. \n\n#### Best Practices für CI\n\n* Committe früh und oft.\n* Optimiere die Pipeline-Phasen.\n* Erstelle Builds schnell und einfach.\n* Nutze Fehlschläge, um Prozesse zu verbessern.\n* Stelle sicher, dass die Testumgebung die Produktion widerspiegelt.\n\n#### Best Practices für CD\n\n* Beginne dort, wo du gerade bist – du kannst jederzeit iterieren.\n* Die beste kontinuierliche Lieferung erfolgt mit minimalen Mitteln.\n* Verfolge, was passiert, damit Probleme und Merge Requests nicht außer Kontrolle geraten.\n* Optimiere Benutzerakzeptanztests und Staging mit Automatisierung.\n* Verwalte die Release-Pipeline durch Automatisierung.\n* Implementiere Überwachung für Transparenz und Effizienz. \n\n> ### Setz dir ein Lesezeichen!\n>\n>Sieh dir unser englischsprachiges [Webinar „Intro to CI/CD“](https://www.youtube.com/watch?v=sQ7Nw3o0izc) (Einführung in CI/CD) an!\n>\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n\u003Ciframe src=\"https://www.youtube.com/embed/sQ7Nw3o0izc?si=3HpNqIClrc2ncr7Y\" title=\"Intro to CI/CD webinar\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n## Erste Schritte mit CI/CD\n\nDer Einstieg in CI/CD beginnt mit einem einfachen, aber repräsentativen Projekt, das als Pilotprojekt dienen soll. Wähle eine einfache Anwendung mit simplen Testanforderungen aus, damit du dich auf das Erlernen der Pipeline-Mechanismen konzentrieren kannst, anstatt dich mit komplexen Bereitstellungsszenarien zu befassen. Stelle zunächst sicher, dass dein Code [versioniert](https://about.gitlab.com/de-de/topics/version-control/) ist und einige [grundlegende automatisierte Tests](https://about.gitlab.com/blog/develop-c-unit-testing-with-catch2-junit-and-gitlab-ci/) (Blogbeitrag nur in englischer Sprache verfügbar) enthält  – dabei reichen schon ein paar Unit-Tests aus. Das Ziel besteht darin, [eine minimale Pipeline zu erstellen](https://about.gitlab.com/blog/how-to-learn-ci-cd-fast/) (Blogbeitrag nur in englischer Sprache verfügbar), die du mit zunehmendem Verständnis nach und nach ausbauen kannst.\n\nIm Fall von GitLab beginnt der Prozess mit dem Erstellen der Datei `.gitlab-ci.yml` im Stammverzeichnis deines Projekts. Diese YAML-Datei definiert deine Pipeline-Phasen (grundlegende Phasen wie Erstellen, Testen und Bereitstellen) und Jobs. Eine einfache Pipeline könnte so aussehen: In der Phase „Erstellen“ wird deine Code kompiliert und es werden Artefakte erstellt, die Testphase führt deine Unit-Tests aus und die Phase „Bereitstellen“ pusht deine Anwendung in eine Staging-Umgebung. GitLab erkennt diese Datei automatisch und beginnt, deine Pipeline auszuführen, wenn Änderungen in dein Repository gepusht werden. Die Plattform bietet [integrierte Runner](https://docs.gitlab.com/runner/) (Artikel nur in englischer Sprache verfügbar), um deine Pipeline-Jobs auszuführen, aber du kannst auch eigene Runner einrichten, wenn du mehr Kontrolle haben willst.\n\nWenn du mit den Grundlagen vertraut bist, kannst du nach und nach anspruchsvollere Elemente zu deiner Pipeline hinzufügen. Du kannst zum Beispiel Code-Qualitätsprüfungen, [Sicherheitsscans](https://docs.gitlab.com/ee/user/application_security/#security-scanning) (Artikel nur in englischer Sprache verfügbar) oder die automatisierte Bereitstellung für die Produktion hinzufügen. Die DevSecOps-Plattform von GitLab bietet Funktionen wie [Compliance-Management](https://about.gitlab.com/blog/meet-regulatory-standards-with-gitlab/), [Bereitstellungsvariablen](https://about.gitlab.com/blog/demystifying-ci-cd-variables/) (Blogbeiträge nur in englischer Sprache verfügbar) und manuelle Genehmigungsprüfungen, die du integrieren kannst, wenn deine Pipeline ausgereift ist. Achte auf die Ausführungszeit der Pipeline und suche nach Möglichkeiten, Jobs parallel auszuführen. Denke daran, die richtige Fehlerbehandlung und Benachrichtigungen hinzuzufügen, damit deine Teammitglieder umgehend über alle Pipeline-Ausfälle informiert werden. Beginne damit, häufige Probleme und Lösungen zu dokumentieren, wenn sie auftauchen – dies wird von unschätzbarem Wert sein, wenn dein Team wächst.\n\n> ### Möchtest du mehr über die ersten Schritte mit CI/CD erfahren? Registriere dich für einen [kostenlosen, englischsprachigen CI/CD-Kurs auf GitLab University](https://university.gitlab.com/courses/continuous-integration-and-delivery-ci-cd-with-gitlab).\n\n## Sicherheit, Compliance und CI/CD\n\nEiner der größten Vorteile von CI/CD ist die Möglichkeit, Sicherheits- und Compliance-Prüfungen frühzeitig und häufig in den Software-Entwicklungsprozess einzubetten. In GitLab können Teams die Konfiguration `.gitlab-ci.yml` verwenden, um automatisch Sicherheitsscans in mehreren Phasen auszulösen, vom ersten Code Commit bis zur Bereitstellung in der Produktivumgebung. Container-Scanning, Abhängigkeitsuche und Sicherheitsscans auf der Plattform ([Dynamische Anwendungssicherheitstests](https://docs.gitlab.com/ee/user/application_security/dast/) und [Erweitertes SAST](https://about.gitlab.com/blog/gitlab-advanced-sast-is-now-generally-available/); beide nur in englischer Sprache verfügbar) können so konfiguriert werden, dass sie bei jeder Codeänderung automatisch ausgeführt werden, um auf Sicherheitslücken, Compliance-Verstöße und Sicherheitsfehlkonfigurationen zu prüfen. Die API der Plattform ermöglicht die Integration mit [externen Sicherheitstools](https://about.gitlab.com/blog/integrate-external-security-scanners-into-your-devsecops-workflow/) (Blogbeitrag nur in englischer Sprache verfügbar) und die Testabdeckungsfunktionen stellen sicher, dass die Sicherheitstests die erforderlichen Anforderungen erfüllen.\n\nDie Sicherheitstestberichte von GitLab enthalten detaillierte Informationen zu den Ergebnissen und sollen sicherstellen, dass Sicherheitsprobleme schnell behoben werden können, bevor sie in die Produktion kommen. Das Sicherheitsdashboard bietet eine zentrale Ansicht von Sicherheitslücken in allen Projekten, während [Sicherheitsrichtlinien](https://about.gitlab.com/blog/how-gitlab-supports-the-nsa-and-cisa-cicd-security-guidance/) (Blogbeitrag nur in englischer Sprache verfügbar) durch Merge-Request-Genehmigungen und Pipeline-Gates durchgesetzt werden können. Darüber hinaus bietet GitLab mehrere Sicherheitsebenen, um vertrauliche Daten während des gesamten CI/CD-Prozesses zu schützen, Audit-Protokolle, um den Zugriff auf Geheimnisse zu verfolgen, und rollenbasierte Zugriffskontrolle (RBAC), um sicherzustellen, dass nur autorisierte Benutzer(innen) vertrauliche Konfigurationsdaten anzeigen oder ändern können.\n\nGitLab unterstützt auch die Erstellung einer Software-Stückliste ([SBOM](https://about.gitlab.com/de-de/blog/the-ultimate-guide-to-sboms/)), die eine umfassende Bestandsaufnahme aller Softwarekomponenten, Abhängigkeiten und Lizenzen in einer Anwendung bietet und es den Teams ermöglicht, Sicherheitslücken schnell zu identifizieren, darauf zu reagieren und behördliche Auflagen zu erfüllen.\n\n## CI/CD und die Cloud\n\nDie CI/CD-Plattform von GitLab bietet eine robuste Integration mit großen Cloud-Anbietern wie [Amazon Web Services](https://about.gitlab.com/de-de/partners/technology-partners/aws/), [Google Cloud Platform](https://about.gitlab.com/blog/provision-group-runners-with-google-cloud-platform-and-gitlab-ci/) (Blogbeitrag nur in englischer Sprache verfügbar) und [Microsoft Azure](https://docs.gitlab.com/ee/install/azure/) (Artikel nur in englischer Sprache verfügbar), sodass Teams ihre Cloud-Bereitstellungen direkt aus ihren Pipelines heraus automatisieren können. Durch die Cloud-Integrationen von GitLab können Teams Cloud-Ressourcen verwalten, Anwendungen bereitstellen und Cloud-Dienste innerhalb der GitLab-Oberfläche überwachen. Die integrierten Cloud-Bereitstellungsvorlagen und [Auto-DevOps-Funktionen](https://docs.gitlab.com/ee/topics/autodevops/) (Artikel nur in englischer Sprache verfügbar) der Plattform reduzieren die Komplexität von Cloud-Bereitstellungen erheblich, sodass sich die Teams auf die Anwendungsentwicklung konzentrieren können und sich nicht mit dem Infrastrukturmanagement befassen müssen. Für Unternehmen, die ihre IT-Infrastruktur mit GitOps automatisieren möchten, bietet GitLab eine [Flux-CD-Integration](https://about.gitlab.com/blog/why-did-we-choose-to-integrate-fluxcd-with-gitlab/) (Blogbeitrag nur in englischer Sprache verfügbar).\n\nDie Cloud-Funktionen von GitLab gehen weit über die einfache Automatisierung der Bereitstellung hinaus. Die [Kubernetes-Integration](https://about.gitlab.com/blog/kubernetes-overview-operate-cluster-data-on-the-frontend/) (Blogbeitrag nur in englischer Sprache verfügbar) der Plattform ermöglicht es den Teams, die Container-Orchestrierung über mehrere Cloud-Anbieter hinweg zu verwalten, während die [Cloud-nativen Installationsoptionen von GitLab](https://about.gitlab.com/de-de/topics/ci-cd/cloud-native-continuous-integration/) den Betrieb der Plattform selbst in Cloud-Umgebungen ermöglichen. Durch die Cloud-nativen Funktionen von GitLab können Teams Runner mit automatischer Skalierung implementieren, die dynamisch Cloud-Ressourcen für die Pipeline-Ausführung bereitstellen und so Kosten und Leistung optimieren. Die Integration der Plattform mit den Sicherheitsdiensten von Cloud-Anbietern macht es möglich, dass die Sicherheits- und Konformitätsanforderungen während des gesamten Bereitstellungsprozesses erfüllt werden.\n\nFür Multi-Cloud-Umgebungen stellt GitLab konsistente Workflows und Tools zur Verfügung, unabhängig vom zugrunde liegenden Cloud-Anbieter. Teams können die Umgebungsverwaltung von GitLab verwenden, um verschiedene Cloud-Konfigurationen in Entwicklungs-, Staging- und Produktivumgebungen zu verwalten. Da die Plattform [Infrastructure as Code](https://docs.gitlab.com/ee/user/infrastructure/iac/) (Artikel nur in englischer Sprache verfügbar) unterstützt – insbesondere die native Integration mit Terraform – können Teams ihre Cloud-Infrastruktur-Bereitstellung steuern und automatisieren. Die Überwachungs- und Beobachtungsfunktionen von GitLab lassen sich in die Metriken von Cloud-Anbietern integrieren und bieten einen umfassenden Überblick über den Zustand von Anwendungen und Infrastruktur in allen Cloud-Umgebungen.\n\n## Erweitertes CI/CD \nCI/CD hat sich weit über das einfache Erstellen und Bereitstellen von Pipelines hinaus entwickelt. In umfassenderen Implementierungen bietet CI/CD eine ausgefeilte Orchestrierung von automatisierten Tests, Sicherheitsscans, Infrastrukturbereitstellung, KI und mehr. Hier findest du einige Strategien für Erweitertes CI/CD, die Entwicklungsteams dabei helfen können, ihre Pipelines zu skalieren und Probleme zu beheben, auch wenn die architektonische Komplexität zunimmt.\n\n### Wiederverwendung und Automatisierung in CI/CD\n\nGitLab verändert die Art und Weise, wie Entwicklungsteams CI/CD-Pipelines erstellen und verwalten. Dazu tragen vor allem zwei wichtige Innovationen bei: der [CI/CD-Katalog](https://about.gitlab.com/blog/ci-cd-catalog-goes-ga-no-more-building-pipelines-from-scratch/) und [CI/CD Steps](https://about.gitlab.com/blog/introducing-ci-cd-steps-a-programming-language-for-devsecops-automation/) (Blogbeiträge nur in englischer Sprache verfügbar), eine neue Programmiersprache für DevSecOps-Automatisierung, die derzeit getestet wird. Der CI/CD-Katalog ist eine zentralisierte Plattform, auf der Entwickler(innen) CI/CD-Komponenten entdecken, wiederverwenden und beitragen können. Komponenten fungieren als wiederverwendbare Bausteine mit einem einzigen Zweck und sollen die Pipeline-Konfiguration vereinfachen – du kannst sie dir wie Legosteine für CI/CD-Workflows vorstellen. CI/CD Steps unterstützt komplexe Workflows, indem es Entwickler(inne)n ermöglicht, Eingaben und Ausgaben für einen CI/CD-Job zu erstellen. Mit dem CI/CD-Katalog und CI/CD Steps können DevSecOps-Teams CI/CD und seine Komponenten einfach standardisieren und so die Entwicklung und Pflege von CI/CD-Pipelines vereinfachen.\n\n> Weitere Informationen findest du in unseren [CI/CD-Katalog-FAQ](https://about.gitlab.com/blog/faq-gitlab-ci-cd-catalog/) und der [Dokumentation für CI/CD Steps](https://docs.gitlab.com/ee/ci/steps/) (beide nur in englischer Sprache verfügbar).\n\n### Problembehebung für Pipelines mithilfe von KI\n\nCI/CD-Pipelines können zwar ab und zu ausfallen, aber eine schnelle Problembehebung kann die Auswirkungen minimieren. GitLab Duo Root Cause Analysis, schafft als Teil eines Programmpakets KI-basierter Funktionen Klarheit, indem es [die Grundursache für eine defekte CI/CD-Pipeline ermittelt](https://about.gitlab.com/blog/quickly-resolve-broken-ci-cd-pipelines-with-ai/) (Blogbeitrag nur in englischer Sprache verfügbar). Wenn eine Pipeline fehlschlägt, stellt GitLab detaillierte Job-Protokolle, Fehlermeldungen und Ausführungsverläufe bereit, die genau zeigen, wo und warum der Fehler aufgetreten ist. Root Cause Analysis schlägt dann mithilfe von KI eine Lösung vor.\nSieh dir GitLab Duo Root Cause Analysisin Aktion an:\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n\u003Ciframe src=\"https://www.youtube.com/embed/sTpSLwX5DIs?si=J6-0Bf6PtYjrHX1K\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n## So migrierst zu GitLab CI/CD\n\nFür die Migration auf die DevSecOps-Plattform und ihr integriertes CI/CD ist ein systematischer Ansatz nötig, um deine vorhandene Pipeline-Konfigurationen, Abhängigkeiten und Bereitstellungsprozesse zu analysieren und dann den entsprechenden Funktionen und der Syntax von GitLab zuzuordnen. Die folgenden englischsprachigen Anleitungen sollen dir den Einstieg erleichtern.\n\n* [So migrierst du von Bamboo zu GitLab CI/CD](https://about.gitlab.com/blog/migrating-from-bamboo-to-gitlab-cicd/)\n* [Von Jenkins zu GitLab: der ultimative Leitfaden zur Modernisierung deiner CI/CD-Umgebung](https://about.gitlab.com/blog/jenkins-gitlab-ultimate-guide-to-modernizing-cicd-environment/)\n* [Einfache Migration von GitHub zu GitLab](https://about.gitlab.com/blog/github-to-gitlab-migration-made-easy/)\n\n## Erfahrungsberichte von führenden Unternehmen\n\nDiese führenden Unternehmen sind zu GitLab migriert und profitieren von den unzähligen Vorteilen von CI/CD. Lies ihre Stories.\n\n- [Lockheed Martin](https://about.gitlab.com/de-de/customers/lockheed-martin/)\n- [Indeed](https://about.gitlab.com/de-de/blog/how-indeed-transformed-its-ci-platform-with-gitlab/)\n- [CARFAX](https://about.gitlab.com/de-de/customers/carfax/)\n- [HackerOne](https://about.gitlab.com/de-de/customers/hackerone/)\n- [Betstudios](https://about.gitlab.com/blog/betstudios-cto-on-improving-ci-cd-capabilities-with-gitlab-premium/) (nur in englischer Sprache verfügbar)\n- [Thales und Carrefour](https://about.gitlab.com/blog/how-carrefour-and-thales-are-evolving-their-ci-cd-platforms/) (nur in englischer Sprache verfügbar)\n\n## CI/CD-Tutorials\n\nWerde mit diesen einfach verständlichen Tutorials zum CI/CD-Profi. (Die Tutorials sind im Moment nur in englischer Sprache verfügbar.)\n\n* [Grundlagen von CI: So führst du Jobs sequenziell, parallel oder unregelmäßig aus](https://about.gitlab.com/blog/basics-of-gitlab-ci-updated/)\n* [So richtest du deine erste CI/CD-Komponente mit GitLab ein](https://about.gitlab.com/blog/tutorial-how-to-set-up-your-first-gitlab-ci-cd-component/)\n* [Einfacher Aufbau einer CI/CD-Pipeline mit GitLab für ein Monorepo](https://about.gitlab.com/blog/building-a-gitlab-ci-cd-pipeline-for-a-monorepo-the-easy-way/)\n* [Verwendung von untergeordneten Pipelines für die kontinuierliche Bereitstellung in fünf Umgebungen](https://about.gitlab.com/blog/using-child-pipelines-to-continuously-deploy-to-five-environments/)\n* [CI/CD-Automatisierung: Maximiere die Auswirkungen eines Bereitstellungsstopps auf GitLab-Gruppen](https://about.gitlab.com/blog/ci-cd-automation-maximize-deploy-freeze-impact-across-gitlab-groups/)\n* [Refaktorisierung einer CI/CD-Vorlage zu einer CI/CD-Komponente](https://about.gitlab.com/blog/refactoring-a-ci-cd-template-to-a-ci-cd-component/)\n* [Kommentiere Container-Images mit Build-Provenienz mithilfe von Cosign in GitLab CI/CD](https://about.gitlab.com/blog/annotate-container-images-with-build-provenance-using-cosign-in-gitlab-ci-cd)\n\n> #### Erste Schritte mit GitLab CI/CD. [Registriere dich für GitLab Ultimate](https://gitlab.com/-/trials/new) und teste die KI-basierte DevSecOps-Plattform 60 Tage lang kostenlos.",[109,716,808,810,776,765],"2025-05-08",{"slug":957,"featured":91,"template":797},"ultimate-guide-to-ci-cd-fundamentals-to-advanced-implementation",{"content":959,"config":967},{"title":960,"description":961,"authors":962,"heroImage":963,"date":964,"body":965,"category":720,"tags":966},"Was ist eine REST-API? Guide & Funktionen","REST-APIs sind der de-facto-Standard für die Kommunikation zwischen Server und Client. Erfahren Sie hier alles Wissenswerte zum Thema!",[789],"https://res.cloudinary.com/about-gitlab-com/image/upload/v1749662858/Blog/Hero%20Images/API-REST.jpg","2024-10-16","REST-APIs sind seit über zwei Jahrzehnten ein zentraler Baustein des Internets. Bei ihnen handelt es sich um Programmierschnittstellen (APIs), die den Austausch von Daten zwischen Client und Server regeln. REST-APIs unterliegen einem Satz von Bedingungen, welche der Wissenschaftler Roy Fielding im Jahr 2000 entwickelt und unter der Abkürzung REST (representational state transfer) [festgelegt hat](https://ics.uci.edu/~fielding/pubs/dissertation/rest_arch_style.htm#sec_5_1_7 \"festgelegt hat\").\n\nREST legt die genaue technische Umsetzung dieser Schnittstellen nicht fest. Fielding hat REST vielmehr als einen „Architektur-Stil“ [bezeichnet](https://www.youtube.com/watch?v=6oFAmQUM8ws \"bezeichnet\"), der eine Vielzahl praktischer Lösungen erlaubt. Jede API, die sich innerhalb der Grenzen dieser Architektur bewegt, entspricht dem REST-Standard.\n\nIn diesem Artikel zeigen wir Ihnen, warum sich REST seit seiner Einführung zum dominanten Modell entwickelt hat und welche Vorteile sich für Web-Development-Teams daraus ergeben. \n\n## Constraints: Die Grundbausteine der REST-Architektur\n\nREST baut auf insgesamt sechs sogenannten „Constraints“ (Einschränkungen) auf. \n\nAus ihnen ergibt sich eine Architektur, die einfach und anpassungsfähig ist und auch in einem rasch wandelnden Geschäftsumfeld langfristig Bestand haben kann.\n\n## Definition: Was ist eine Rest-API?\n\nREST-APIs sind praktische Softwarelösungen, die auf der REST-Dokumentation aufbauen und gemäß der folgenden sechs REST-Prinzipien für ein Client-Server-Modell erstellt werden: \n\n- Unabhängigkeit zwischen Client und Server,\n- Zustandslosigkeit,\n- ein mehrschichtiges Systemmodell, \n- eine einheitliche Schnittstelle,\n- Cache-Fähigkeit und\n- ein optionales Constraint: Code on Demand.\n\nIn den folgenden Abschnitten betrachten wir diese Constraints genauer. \n\n### Unabhängigkeit zwischen Client und Server\n\nREST findet wie erwähnt für APIs Anwendung, die den Austausch von Ressourcen zwischen einem Client und einem Server ermöglichen. Entscheidend ist, dass Client und Server vollkommen unabhängig voneinander bleiben. \n\nSo kann beispielsweise der Code des Servers verändert werden, ohne dass der Client ebenfalls Änderungen vornehmen muss, um weiterhin Informationen anfragen und erhalten zu können. \n\n### Zustandslosigkeit\n\nDie Einschränkung der Zustandslosigkeit hat der REST-Architektur ihren Namen verliehen. Für APIs soll gemäß dieser Vorgabe gelten, dass für die korrekte Beantwortung einer Anfrage die übermittelten Informationen der aktuellen Sitzung ausreichen.\n\nDas bedeutet: Es ist keine dauerhafte Verbindung zwischen Client und Server erforderlich und Client-Anfragen müssen auf der Server-Seite auch nicht zwischengespeichert werden. \n\nZustandslosigkeit führt zu höherer Daten- und Ausfallsicherheit. Gleichzeitig gilt aber auch: Benötigen Nutzer(innen) dieselben Informationen ein zweites Mal, müssen sämtliche Informationen der vorigen Sitzung erneut eingeben werden. \n\n### Mehrschichtiges Systemmodell\n\nFür jedes Unternehmen ist eine andere Server-Struktur optimal. Werden Informationen beispielsweise in verschiedenen Schichten gespeichert, gestaltet sich die Abfrage mehr oder weniger komplex. Das aber sollte für eine Anfrage unerheblich bleiben, solange die Daten korrekt übermittelt werden.  \n\nDie Einschränkung des mehrschichtigen Systemmodells ist somit das Gegenstück zur Zustandslosigkeit. Während letztere besagt, dass der Server vom Client nichts weiter benötigt als die Anfrageinformationen, verlangt das mehrschichtige Modell, dass dem Client nicht bekannt zu sein braucht, wie der Server die angeforderten Daten bereitstellt. \n\nDer Server kann also mit einer Vielzahl verschiedener Architekturen arbeiten, ohne dass die REST-API-Schnittstelle beeinflusst wird. \n\n### Einheitliche Schnittstelle\n\nDiese Einschränkung ist etwas komplexer und wiederum aus vier Unterpunkten aufgebaut. Für Roy Fielding war sie die womöglich wichtigste der gesamten REST-API-Architektur. \n\nDie einheitliche Schnittstelle fordert:\n\n- dass jeder Datensatz über eine einzige URI eindeutig gekennzeichnet ist,\n- dass Veränderungen oder auch Löschungen der Daten nur mittels der grundlegenden Netzwerkprotokollbefehle, wie GET, POST, PUT/PATCH und DELETE, vorgenommen werden können,\n- dass jede Nachricht, die versandt wird, mittels Metadaten sämtliche Informationen bereithält, die für die Bearbeitung der Daten erforderlich ist und\n- dass, sofern erforderlich, Hyperlinks (HATEOAS) bereitgestellt werden, um weitere benötigte Informationen einzuholen.\n\nDie einheitliche Schnittstelle sorgt für maximale Klarheit und eine einfache, standardisierte Client-Server-Kommunikation. \n\n### Cache-Fähigkeit\n\nZwar findet bei REST-APIs der Ressourcenaustausch zustandslos statt, zugleich aber sollten einmal angeforderte Daten aus einer Sitzung auf demselben Endgerät weiterverwendet werden können.\n\nIndem REST das Cachen dieser Informationen ermöglicht, sorgt es für eine höhere Effizienz und beschleunigt viele Prozesse bedeutend.\n\n### Code on Demand\n\nFür die meisten Anwendungen reicht die Bereitstellung der Daten in der Form von XML or JSON vollkommen aus. In bestimmten Fällen aber kann es von Vorteil sein, dem Client darüber hinaus –      oder stattdessen – eine Anwendung bereitzustellen. Denken Sie dabei an Java Applets oder JavaScript.\n\nCode on Demand stellt eine sinnvolle Erweiterung der REST-Architektur dar, aber sie ist als einzige der sechs Einschränkungen optional. \n\n## Wofür eignen sich REST-APIs?\n\nFlexibilität ist eines der Hauptmerkmale von REST-APIs. So sind sehr viele praktische Anwendungen denkbar:\n\n- Ganz grundsätzlich das Abrufen und Bereitstellen von Daten. Social-Media-Seiten wie Instagram oder Facebook nutzen REST-APIs beispielsweise um Updates zu posten.\n- Gerade weil sie zustandslos sind, eignen sich REST-APIs für Cloud-Services: Auch wenn die Verbindung abbricht, können die Daten weiter genutzt werden. \n- [Microservices](https://microservices.io/ \"Microservices\") gewinnen rasch an Beliebtheit und Bedeutung. Mit ihnen geht ein umfassender Perspektivenwechsel einher: Applikationen werden nicht mehr als riesige, in sich geschlossene Systeme gedacht, sondern als modular und aus kleineren, schlanken Elementen zusammengesetzt. REST-APIs bilden die ideale Schnittstelle zur nahtlosen Integration dieser verschiedenen Bausteine.\n\nIm Laufe der letzten 20 Jahre sind Alternativen zu REST-APIs verfügbar geworden. Dennoch hat sich keine davon auf breiter Basis durchsetzen können. Ganz offensichtlich ist REST auch aktuell der beste Ansatz zum Datenaustausch im Netz. \n\n## Was sind die Vorteile einer Rest-     API?\n\nIn den frühen Tagen des Internets war SOAP (Simple object access protocol) die dominante Form des Datenaustauschs. \n\nDass sich REST seitdem durchgesetzt hat und fast ein Vierteljahrhundert lang relevant geblieben ist, lässt sich recht einfach aus seinen inhärenten Vorteilen erklären:\n\n- SOAP vs REST: SOAP ist ein Protokoll, das Regeln und auch technische Realisierungen im Gegensatz zu REST sehr präzise vorschreibt. Daraus ergibt sich unmittelbar, dass APIs, die auf diesen Anforderungen aufbauen, weitaus komplexer als REST-APIs sind.\n- Die APIs, die gemäß der REST-Richtlinien programmiert wurden, basieren auf dem HTTP-Standard. Sie sind schnell und effizient und in nahezu jedem Kontext einsetzbar. Aus genau diesen Gründen eignen sich REST-APIs auch besonders gut für mobile Anwendungen.\n- Der Begriff der Skalierbarkeit ist bereits gefallen und er ist auch einer der maßgeblichen Argumente für die Verwendung von REST-APIs. Darunter ist zu verstehen, dass bei Erweiterungen der Server-Architektur nicht die darunter liegende Datenaustausch-Technologie verändert werden muss. \n- Einige Unternehmen setzen aus Sicherheitserwägungen immer noch auf SOAP. Allerdings sind REST-APIs keineswegs grundsätzlich unsicher. Entscheidend ist, einige grundlegende Best Practices anzuwenden – darunter die Verwendung von HTTPS sowie Autorisierung und Authentifizierung. \n\n## Gibt es eine REST-API von GitLab?\n\nAuch bei GitLab sind wir von den Vorzügen der REST-Architektur überzeugt. Aus diesem Grund stellen wir unseren Nutzer(inne)n eine [GitLab-REST-API](https://docs.gitlab.com/ee/api/rest/ \"GitLab-REST-API\") zur Verfügung. \n\nBei GitLab handelt es sich um den führenden Anbieter von DevSecOps-Lösungen. Anwender(innen) nutzen die Plattform, um sicher, fehlerfrei und kollaborativ an Entwicklungsprojekten zu arbeiten. \n\nDie GitLab-API kann sowohl genutzt werden, um öffentlich sichtbare, als auch nicht öffentliche Daten (nach erfolgter Authentifizierung und Autorisierung) abzurufen. Weil die API unmittelbar auf GitLab abgestimmt ist, erfolgt der Austausch sicher, schnell und effizient. \n\n## REST-API FAQs\n\n### Ist REST ein Standard?\n\nREST ist ein Satz aus sechs Einschränkungen, die den Datenaustausch in einer Client-Server-Beziehung regeln. Alle API-Schnittstellen, die diesen Vorgaben entsprechen, sind „RESTful“. \nEs ist somit nicht falsch, REST als einen Standard zu bezeichnen. Allerdings gilt dies weniger im Sinne eines Protokolls oder konkreter Anweisungen. REST gibt vielmehr Leitlinien und Anforderungen vor, deren Umsetzung zu gewünschten Ergebnissen führen, unabhängig davon, wie diese technisch realisiert werden.\n\nAus diesem Grund wird REST zumeist als ein „Architektur-Stil“ definiert. \n\n### Muss ich alle sechs REST-Einschränkungen befolgen?\n\nRoy Fielding hat hierzu persönlich im Laufe der Jahre mehrfach [Stellung bezogen](https://www.infoq.com/articles/roy-fielding-on-versioning/ \"Stellung bezogen\"). Seine Ansichten zu dieser Frage sind eindeutig: REST ist nicht in allen Fällen zwangsläufig die beste Option. Wenn man aber eine REST-konforme Architektur wünscht, müssen sämtliche Constraints ausnahmslos umgesetzt werden. \n\nEine API beispielsweise, die alle Einschränkungen umsetzt, bei der aber keine Daten gecached werden können, ist nicht RESTful. \n\nDie einzige Ausnahme ist Code on Demand. Diese Einschränkung ist optional und muss somit nicht umgesetzt werden, damit eine REST-API die Kriterien erfüllt. \n\n### Wie passen Cache-Fähigkeit und Zustandslosigkeit zusammen?\n\nZwischen den Einschränkungen der Cache-Fähigkeit und Zustandslosigkeit scheint ein Spannungsverhältnis zu bestehen. Wenn bei jeder Anfrage die Daten neu übermittelt werden müssen, widerspricht das Zwischenspeichern von Daten im Cache dann nicht dieser Forderung? \n\nIn Wahrheit fordert Zustandslosigkeit lediglich, dass der Server jede Anfrage so behandelt, als wäre sie die erste. Es besteht keine Zuordnung der Daten im Cache zu einer aktuellen Anfrage. \n\nDas Cachen der Daten dient lediglich einer höheren Effizienz und sorgt für Stabilität. \n\n### Was bedeutet der Begriff Idempotenz im Zusammenhang mit REST-APIs?\n\nWenn ein Client dieselbe Anfrage mehrfach nacheinander stellt, spricht man von Idempotenz. Das kann entweder passieren, weil die Verbindung instabil oder der Code fehlerhaft ist. \n\nEntscheidend ist, dass eine solche idempotente Anfrage nicht zu einem Fehler bei der Beantwortung der Anfrage führt. \n\nDie Einschränkung der Cache-Fähigkeit sorgt dafür, dass idempotente Anfragen als solche erkannt und fehlerfrei bearbeitet werden können. \n\n### Wie lassen sich Rest-APIs sichern?\n\nREST-APIs können sehr effektiv gesichert werden. \n\nÜbliche und sehr effiziente Methoden sind die Verwendung von HTTPS und API-Schlüsseln, die Durchführung von Authentifizierungen und Autorisierungen sowie die Durchführung einer Input-Validation und eines Audit-Loggings. \n\nAuch die Begrenzung der Anfragen in einem bestimmten Zeitfenster im Sinne eines Rate-Limiting empfiehlt sich.",[925,716],{"slug":968,"featured":6,"template":797},"what-is-a-rest-api-guide-and-functions",{"category":728,"slug":732,"posts":970},[971,982,993],{"content":972,"config":980},{"title":973,"description":974,"authors":975,"heroImage":976,"date":977,"body":978,"category":732,"tags":979,"updatedDate":977},"Was ist Kubernetes?","Container haben Softwareentwicklung und -Deployment revolutioniert. Wir zeigen dir hier die Vorteile von Kubernetes.",[789],"https://res.cloudinary.com/about-gitlab-com/image/upload/v1749662245/Blog/Hero%20Images/blog-image-template-1800x945__16_.png","2025-05-15","# Kubernetes: Einfach erklärt\n\nKubernetes hat sich weltweit als führende Technologie in der Container-Orchestrierung durchgesetzt. Die Vielfalt an Funktionalitäten, die Kubernetes bereitstellt, ist aber nicht immer leicht zu nutzen. Lukas Gentele schreibt auf entwickler.de, dass \"von vielen Entwicklern Kubernetes als zu komplex und kaum zu beherrschen wahrgenommen wird\". Damit spricht er aus, was viele denken.\n\nIronischerweise besteht der Hauptnutzen von Kubernetes darin, viele Anwendungen überhaupt erst beherrschbar zu machen. Warum das kein Widerspruch ist, was Kubernetes ist und wie es funktioniert, erfährst du in diesem Artikel. \n\n## Inhaltsverzeichnis\n- [Kubernetes: Einfach erklärt](#kubernetes-einfach-erklärt)\n  - [Kubernetes-Container: Kein Pod kommt ohne aus](#kubernetes-container-kein-pod-kommt-ohne-aus)\n  - [Container – übersichtlich, kollaborativ, effizient](#container-–-übersichtlich-kollaborativ%2C-effizient)\n  - [Pod: Container Kombinationen](#pod-container-kombinationen)\n  - [Orchestrierung: Container kontrollieren](#orchestrierung-container-kontrollieren)\n  - [Abstraktion und Zustandsorientierung](#abstraktion-und-zustandsorientierung)\n  - [Node, Kubelet, Cluster: Die Welt von Kubernetes](#node-kubelet%2C-cluster-die-welt-von-kubernetes)\n  - [Wie funktioniert Kubernetes?](#wie-funktioniert-kubernetes%3F)\n  - [Kubernetes in der Praxis](#kubernetes-in-der-praxis)\n  - [Die Vorteile von Kubernetes](#die-vorteile-von-kubernetes)\n  - [Wie funktioniert die Kubernetes-Integration unter GitLab?](#wie-funktioniert-die-kubernetes-integration-unter-gitlab)\n  - [FAQs zu Kubernetes (K8s)](#faqs-zu-kubernetes-(k8s))\n\n## Kubernetes-Container: Kein Pod kommt ohne aus\n\nWenn wir ein Verständnis über Kubernetes vermitteln wollen, kommen wir an einem Bestandteil nicht vorbei – dem Container. \n\nÄhnlich wie Betriebssysteme wurden Anwendungen noch bis vor wenigen Jahre als Monolith entwickelt. Das bedeutet, Anwendungen bestanden aus einer einzigen unteilbaren Codebasis, welche alle Informationen enthält, die zum Betrieb notwendig sind.\n\nAuch, wenn nur wenige Teile der Anwendung benötigt wurden, musste trotzdem das gesamte Programm geladen werden. Das verbrauchte offensichtlich viele Ressourcen, das System wurde langsam und fehleranfällig.\n\n## Container – übersichtlich, kollaborativ, effizient\n\nErste Versuche, die Nachteile einer monolithischen Architektur zu umgehen und Teile eines Programms gezielt zu isolieren, entstanden in den späten 70ern und frühen 80er-Jahren. Doch erst Docker, welches 2013 veröffentlicht wurde, verhalf dem Gedanken auf breiter Basis zum Durchbruch.\n\nDie verschiedenen Funktionalitäten einer Anwendung werden mit einer Software wie Docker isoliert und in Pakete aufgeteilt. Diese Container enthalten sämtliche Daten, Software und Bibliotheken, die zum Betrieb genau dieser Funktionalitäten erforderlich sind.\n\nDie Container können eigenständig genutzt oder getestet werden. Aber man kann sie auch zu einer größeren Architektur verknüpfen und \"aufeinanderstapeln\" wie Container (die Idee entstand [laut dem ehemaligen Docker-CEO Ben Golub](https://www.computerwoche.de/a/der-niedergang-von-docker,3551769) \"als wir all die Containerschiffe im Hafen von Oakland einlaufen sahen\").\n\nFrüher als monolithische Anwendungen entwickelt, werden Programme heute als Zusammensetzungen einzelner Container betrachtet. Anstatt den gesamten Code zu laden, werden nur die Container verwendet, die für die jeweils auszuführenden Aufgaben notwendig sind. Dadurch, dass die Container bereits alle Daten enthalten, die benötigt werden, um das Programm zu starten, wird es deutlich einfacher, einzelne Komponenten von einem Server mit Betriebssystem A auf einen anderen mit Betriebssystem B zu verschieben.\n\n## Pod: Container Kombinationen\n\nAusgehend von den einzelnen Docker-Containern bilden Anwender(innen) nun Gruppen aus Containern, die im Rahmen einer bestimmten Anwendung oder eines größeren Systems zusammenarbeiten. Jede dieser virtuellen Gruppen bezeichnet man als \"Pod\".\n\nIm Beispiel eines E-Commerces Unternehmen, kann nun ein Pod die Benutzeroberfläche enthalten, während andere Pods die Bezahlung, oder die Lieferung abwickeln. Die Vorteile sind klar: Dieser Ansatz ist schlanker und robuster als der monolithische und lässt sich konsistent auf verschiedenen Betriebssystemen verwenden. Gerade in der Softwareentwicklung bedeutete diese Zuverlässigkeit einen deutlichen Sprung nach vorne.\n\n## Orchestrierung: Container kontrollieren\n\nGleichzeitig erfordert eine Anwendung, die aus mehreren Containern zusammengesetzt ist, ein höheres Maß an Management.\n\nWas passiert beispielsweise, wenn ein Pod ausfällt? Wie geht man mit Fehlern in einem Pod um? Wo sollen die Pods ausgeführt werden? Wie wirkt sich die Containerisierung auf die Entwicklung neuer Funktionalitäten aus? Wie funktioniert überhaupt die ständige Neuverteilung verschiedener Pods innerhalb derselben Anwendung während des laufenden Betriebs?\n\nDiese Fragen werden dringlicher, je mehr Container eine Anwendung verwendet. Und sie werden geradezu kritisch in einer Umgebung, in der sehr viele Nutzer(innen) auf eine Vielzahl containerisierter Anwendungen zugreifen sollen.\n\nWenn es keinen monolithischen Code mehr gibt, welcher festlegt, in welchen Situationen bestimmte Kombinationen zur Anwendung kommen, werden neue Prinzipien zur Aktivierung benötigt. Darüber hinaus ergeben sich durch die Containerisierung eine Vielzahl spezifischer Herausforderungen.\n\nDie Lösungsansätze, die sich mit dieser Herausforderung beschäftigen, werden unter dem Begriff Container-Orchestrierung zusammengefasst. Einfach erklärt ist Kubernetes das derzeit wohl leistungsfähigste und effizienteste Orchestrierungs-Tool.\n\n## Abstraktion und Zustandsorientierung\n\nVor der Einführung der Containerisierung, die mit Docker ihren Durchbruch fand, waren Programme im Wesentlichen Stories, die durch ihren Code zusammengehalten wurden. Mit Containern wird dieses Narrativ jedoch aufgebrochen und in seine einzelnen Bestandteile zerlegt. Damit aus diesen Teilen wieder eine sinnvolle Geschichte entsteht, benötigt man einen „roten Faden\", der die einzelnen Komponenten zusammenführt.\n\nAus der Perspektive von Kubernetes werden Anwendungen schlicht als „Arbeitslasten\" (Workloads) betrachtet – also Dienste, die eine bestimmte Menge an Systemressourcen beanspruchen. Pods fungieren dabei als Abstraktionen, da der Zusammenhang zwischen den einzelnen Pods jederzeit aufgelöst und neu gestaltet werden kann.\n\nDas bedeutet, dass du jederzeit eine bestehende Struktur aufbrechen und nach Belieben neu zusammensetzen kannst. Mit denselben Komponenten lässt sich so etwas völlig Neues erschaffen.\n\nWichtig bei der Wahl der geeigneten Abstraktion ist der Zustand (State), der durch die Kombination oder Aktivierung von Nutzlasten im System entsteht. Manche Zustände sind gewünscht, andere nicht.\n\nWenn man Kubernetes einfach definieren würde, würde man sagen Kubernetes stellt sicher, dass alle Komponenten im richtigen Zustand sind.\n\n## Node, Kubelet, Cluster: Die Welt von Kubernetes\n\nIn einem System werden Pods, also funktional zusammengehörige Kombinationen von Kubernetes-Containern auf sogenannte Knoten (englisch: Nodes) verteilt. Ein Knoten kann sowohl ein physischer Rechner (PC) als auch eine virtuelle Maschine (VM) sein.\n\nEs gibt zwei Formen von Knoten:\n\n* Die sogenannten Master-Nodes, welche die Steuerung und Kontrolle übernehmen sowie  \n* die Work-Nodes, auf denen die Anwendungen liegen, welche die Funktionalität einer Anwendung übernehmen.\n\nDie Kommunikation zwischen diesen Ebenen wird von kleinen Managementagenten übernommen, den Kubelets.\n\nSchließlich kann man mehrere Knoten zu Kubernetes-Clustern aufsetzen. Diese bilden dann die Umgebung ab, die Kubernetes verwaltet und auf welcher Kubernetes läuft.\n\n## Wie funktioniert Kubernetes?\n\nKubernetes automatisiert die Container-Orchestrierung, jedoch ist es als Administrator wichtig, stets die Kontrolle darüber zu behalten, welche Prioritäten dabei gesetzt und welche Aspekte berücksichtigt werden müssen.\n\nAdministrator(inn)en erarbeiten zusammen mit den Entwickler(innen)/Anwender(innen) eine Liste an gewünschten Zuständen. Dazu kann beispielsweise der Wunsch gehören, dass gewisse Pods stets aktiv sein sollten. Auch dann, wenn sie formal nicht ununterbrochen benötigt werden.\n\nDas ist ein völlig neuer Ansatz, wie über die Kontrolle der Software nachgedacht werden muss. Statt ständig auf sich ändernde Anforderungen mit neuen Befehlen zu reagieren, definiert man stattdessen, welche Zustände erfüllt werden sollen und überlässt es dann Kubernetes diese zu erfüllen. \n\n*Man bezeichnet diese Form der Kontrolle auch als \"deklarativ\", gegenüber dem traditionellen Modell der \"imperativen\" (befehlsgebenden) Kontrolle.*\n\nEin weiteres Eingreifen seitens Administrator(inn)en ist im Idealfall nicht mehr erforderlich. Senior Solutions Manager Brendan O'Leary von GitLab hat das einmal folgendermaßen auf den Punkt gebracht: *\"Kubernetes sorgt dafür, dass das System so bleibt, wie wir es haben wollen.\"*\n\n## Kubernetes in der Praxis\n\nWie funktioniert die Orchestrierung nun?\n\nKubernetes übernimmt eine Vielzahl von Funktionen, welche die Verwendung der Pods im Cluster optimieren: \n\n* Der Kubernetes Scheduler sorgt dafür, dass Pods den für sie besten Knoten zugeordnet werden.  \n* Kubernetes bringt die Nachfrage nach Nutzlasten mit dem Angebot in Einklang. Das bedeutet: Wenn besonders viele Nutzer(inn)en ein ganz bestimmtes Pod anfragen, droht eine Überlastung. Kubernetes kann hierauf mit zwei Antworten reagieren: Es kann für diesen Pod mehr Ressourcen bereitstellen, oder es kann den Pod duplizieren, also Kopien erstellen und die Anfragen auf diese neuen Pods verteilen. Dieser Prozess wird als load balancing bezeichnet.  \n* Kubernetes aktualisiert sich stets selbst und bleibt somit immer auf dem neuesten Stand.  \n* Entstehen in einem Pod Fehler, die zu einem Ausfall führen, kann Kubernetes im Rahmen seines Self-healings (Selbstheilung) entweder den Pod reparieren oder es auf einen funktionsfähigen früheren Zustand zurücksetzen.  \n* Hast du einmal ein Kubernetes-Cluster aufgesetzt, werden Nutzlasten oft von einem Knoten auf einen anderen verschoben. Interne IP-Adressen können hier also nicht mehr verwendet werden, um den aktuellen Ort eines Pods zu bestimmen (weil er sich ständig ändert). Mit der Service-Discovery-Funktion übernimmt Kubernetes die Aufgabe, dass Anfragen auf dem richtigen Pod auch ankommen.\n\n## Die Vorteile von Kubernetes\n\nGerade bei sehr großen Cloud-Umgebungen ist leicht ersichtlich, warum die oben beschriebene, automatisierte Gewährleistung eines optimalen Zustands einen großen Nutzen mit sich bringt.\n\nEin weiterer Vorteil von Kubernetes besteht in der Entwicklung neuer Funktionen. Es ermöglicht ein reibungsloses Testen, ohne dass es dabei zum Ausfall des Systems kommt. Neue Container und Pods können unkompliziert hinzugefügt werden. Teams können gezielt nur an den Diensten arbeiten, für die sie zuständig sind und so ganz gezielt und spezifisch das System optimieren.\n\nGerade Letzteres war der Grund, dass GitLab sich bereits 2017 für ein Container-zentriertes System mit Kubernetes entschieden hat.\n\nLukas Gentele schreibt dazu:\n\n*\"Dass das Kubernetes-Ökosystem so vielseitig ist, mag auf den ersten Blick abschrecken, doch es ist notwendig, da die Architektur von Kubernetes ein großes Maß an Flexibilität bietet.\"*\n\n## Wie funktioniert die Kubernetes-Integration unter GitLab?\n\nGitLab ist eine Platform die [Kontinuierlichen Integration und Auslieferung](https://about.gitlab.com/de-de/solutions/continuous-integration/) ermöglicht. Somit kannst du als GitLab-Nutzer(in) die Vorteile von Kubernetes bezüglich der Container-Orchestrierung für dich nutzen.\n\nWeil GitLab CE und Kubernetes so natürlich miteinander harmonieren, fällt die Integration recht unkompliziert aus. Wir haben für dich einen Artikel vorbereitet, der genau erklärt, wie du ein [Kubernetes Cluster mit GitLab verbindest](https://docs.gitlab.com/ee/user/clusters/agent/). \n\nKurz zusammengefasst erfordert die Integration folgende Punkte:\n\n* Definiere das Cluster, welches über Kubernetes automatisiert werden soll.  \n* Installiere einen Agenten, der die Kommunikation mit dem Cluster übernimmt.  \n* Konfiguriere die GitLab-CI/CD Pipeline so, dass sie die Kubernetes-API verwendet.\n\n## FAQs zu Kubernetes (K8s)\n\n### Warum wird Kubernetes auch K8s genannt? Was bedeutet der Begriff?\n\nK8s ist eine smarte, leicht kryptische Abkürzung des Begriffs Kubernetes: \"K\" und \"s\" bezeichnen den ersten und letzten Buchstaben, die \"8\" schlicht die Anzahl der Buchstaben, die dazwischen liegen.\n\nDas Wort Kubernetes stammt aus dem Griechischen und bedeutet Steuer- oder Fährmann. Der Begriff bezieht sich auf die zentrale Aufgabe von Kubernetes, ein System auch bei \"hohem Wellengang\" stets stabil zu halten und vor dem Kentern zu bewahren.\n\n### Wer hat Kubernetes entwickelt?\n\nDie ersten Impulse für Kubernetes setzte Google mit seinen Vorläuferprojekten \"Borg\" und \"Project 7\". Beide beschäftigten sich mit der Problemstellung, die Komplexität containierisierter Anwendungen beherrschbar zu machen.\n\nBewusst als Open-Source-Plattform entwickelt, entstand Kubernetes aus der Kollaboration verschiedener großer und kleiner Unternehmen, die sich in der Cloud Native Computing Foundation zusammenschlossen.\n\nDarüber hinaus wurde es maßgeblich über die Git-Community ergänzt und weiterentwickelt.\n\n### Was kostet die Nutzung von Kubernetes?\n\nBei Kubernetes handelt es sich um ein Open-Source-System. Das bedeutet, dass das Programm kostenfrei heruntergeladen werden kann. Trotzdem entstehen bei der Nutzung von Kubernetes in deinem Unternehmen Kosten, potentiell sogar recht hohe.\n\nDer Grund dafür ist, dass die nackte Basisversion der Anwendung letzten Endes für die meisten Anwender(innen) nicht nutzbar ist.\n\nNeben den Kosten, die für das Hosten der Kubernetes-Cluster in der Cloud anfallen, solltest du folgende möglichen Kostenpunkte berücksichtigen:\n\n* Die Nutzung von Kubernetes-Dienstleistungen, welche den Einsatz vereinfachen.  \n* Experten, die das Kubernetes-System konfigurieren, es gegebenenfalls warten und es auf dem neuesten Stand halten. Gerade angesichts des hohen Spezialisierungsgrads des Anforderungsprofils sowie der Menge der anfallenden Arbeitsstunden können hierbei erhebliche Kosten entstehen.  \n* Nach dem Aufsetzen eines Kubernetes-Clusters liegen Ressourcen auf verschiedenen Cloud-Speichern. Ein wichtiger Teil der Funktionalität von Kubernetes besteht darin, Nutzlasten dynamisch zwischen diesen Cloud-Speichern zu verschieben, so dass die Stabilität, Sicherheit und Geschwindigkeit des Systems optimiert wird. Allerdings wird dir das Verschieben von Datenpaketen von einem Speicher auf einen anderen sogar dann berechnet, wenn alle deine Daten bei demselben/derselben Provider(in) liegen. Diese Egress-Kosten werden gemäß des verschobenen Datenvolumens kalkuliert und können sich, abhängig von der Größe der Kubernetes-Cluster, am Ende des Jahres wahrhaft auftürmen.\n\nImmer mehr Anbieter(innen) haben inzwischen Kubernetes-Online-Rechner im Angebot, mit denen du einen besseren Eindruck über die möglichen Kosten erhältst. Allerdings bleibt es meistens bei einer [Schätzung](https://www.heise.de/news/Kosten-der-Google-Kubernetes-Engine-vorab-berechnen-zumindest-grob-7120708.html).",[551],{"slug":981,"featured":6,"template":797},"definition-what-is-kubernetes",{"content":983,"config":991},{"title":984,"description":985,"authors":986,"heroImage":987,"date":988,"body":989,"category":732,"tags":990},"Linux-Server: Warum sich die Installation lohnt","Linux-Server sind weltweit führend. Wir erklären dir, warum und du selbst von den Vorteilen profitieren kannst.",[789],"https://res.cloudinary.com/about-gitlab-com/image/upload/v1749663065/Blog/Hero%20Images/serveur-linux.jpg","2025-04-14","# Linux-Server: Warum sich die Installation lohnt\nServer bilden die Basis des Internets. Und Linux bildet weltweit die Basis für die meisten Server. Seit der Entwicklung von Linux hat sich das Betriebssystem gegenüber weitaus größeren Konkurrenten wie Microsoft nicht nur behaupten, sondern seine Vormachtstellung sogar weiter ausbauen können.\n\nIn diesem Artikel gehen wir auf alle Aspekte eines Linux-Servers ein. Wir wägen Vorteile eines Linux-Servers gegen eventuelle Nachteile ab und stellen dir alle kostenfreien und kommerziellen Varianten („Distributionen“) vor, die aktuell erhältlich sind. Wir zeigen dir, wie du einen Linux-Server verbindest und ein Backup erstellst.\n\nIn der Softwareentwicklung und generell bei DevOps-Projekten eignet sich GitLab besonders gut für die Nutzung auf einem Linux-Server. Dafür gibt es sehr gute Gründe, die wir dir ebenfalls gerne vorstellen möchten.\n\n## Was ist ein Linux-Server?\n\n**Ein Linux-Server ist ein Server, der Linux OS als Betriebssystem nutzt. Bei Linux handelt es sich um ein modulares, monolithisches OS („Operating System“), das in den frühen 1990ern von dem finnisch-amerikanischen Programmierer Linus Torvalds entwickelt wurde.**\n\n- **„Modular“** bezieht sich darauf, dass Linux sowohl um einige Komponenten reduziert, als auch um neue erweitert werden kann, ohne seine Funktionsfähigkeit zu verlieren.\n\n- Gleichzeitig aber ist Linux **„monolithisch“**, was bedeutet, dass der Kern (Kernel) des Betriebssystems nicht geteilt werden kann. Schlankere Ansätze wie beispielsweise Minix arbeiten hingegen mit einem Microkernel, der stets nur die Module nutzt, die wirklich benötigt werden.\n\nTorvalds konzipierte sein eigenes System von Anfang an als Open-Source-Projekt und legte den Quellcode offen. Das bedeutet: Grundsätzlich kannst du Linux in seiner grundlegenden Basisversion nutzen, ohne Lizenzgebühren abzuführen.\n\n## Was ist ein Windows-Server?\nEin Windows-Server ist ein Server, der Microsoft Windows als Betriebssystem nutzt. Dies ist kein Artikel über Microsoft-Server, aber ein kurzer Blick auf ihre Architektur ist hilfreich um zu verstehen, was Linux-Server ausmacht und worauf es sich bei der Auswahl des für dich passenden OS zu achten lohnt.\n\nAuch Microsoft Windows ist monolithisch und eingeschränkt modular. Allerdings nutzt Windows ein grafisches Benutzer-Interface („GUI“), während Linux zumindest in seiner Basisvariante ein Command-Line-Interface („CLI“) verwendet – also über Text und Code angesteuert wird.\n\nDas GUI macht Windows weitaus intuitiver in der Anwendung. GUIs aber verbrauchen sehr viel Arbeitsspeicher und machen das System somit weitaus langsamer und weniger effizient.\n\nDer zweite wichtige Unterschied besteht darin, dass Windows geschlossen und sein Quellcode somit nicht frei einsehbar ist. Daraus ergibt sich eine Vielzahl von Konsequenzen, die größtenteils erklären, weshalb es Microsoft bis heute nicht gelungen ist, das Quasi-Monopol von Linux im Serverbereich aufzubrechen.\n\n## Linux-Server: Vorteile und Entscheidungsgrundlagen\nWie erwähnt ist Linux weltweit führend bei Server-Betriebssystemen. Aktuellen Schätzungen zufolge hatte Linux hier einen Marktanteil von über 80 %. Trotzdem sind sich Expert(inn)en      einig darüber, dass Linux nicht in jedem Fall die beste Wahl ist.\n\n**Ob eine Linux-Architektur für dich geeignet ist, kannst du anhand von vier Kriterien entscheiden:**\n\n**- Stabilität**\n\n**- Sicherheit**\n\n**- Skalierbarkeit und Kundenorientierung**\n\n**- Kosten**\n\nIn den folgenden Abschnitten sehen wir uns diese Punkte genauer an, um dir zu zeigen, wie die Vorteile eines Linux-Servers in der Praxis aussehen.\n\n## Stabilität\nMonolithische Server sind sehr leistungsfähig. Aber sie sind nicht die stabilste Option.\n\nWeil stets der gesamte Kernel genutzt wird, können selbst kleine Fehler in einem isolierten Teil des Betriebssystems zum Absturz führen. Wer wurde nicht schon einmal von dem blauen Bildschirm in Windows „überrascht“! Gerade wenn auf einem Server wichtige Daten liegen oder wenn über ihn eine Website läuft, können sogar kurzzeitige Aussetzer zu hohen Gewinnausfällen oder Kosten führen.\n\nLinux umgeht dieses grundlegende Problem mit einer äußerst schlanken Architektur, die auch der Geschwindigkeit des OS zugutekommt. Diese Leichtigkeit beansprucht weniger Hardware-Ressourcen und stabilisiert das monolithische System auf eine sehr überzeugende Weise.\n\nDarüber hinaus kommt Linux sein offener Quellcode und die Einbettung in die Open-Source-Comunity zugute. Seit 30 Jahren tauschen sich Entwickler(innen) und Systemadministrator(inn)en täglich zu Problemen und Lösungen aus. Sogar akute, schwere Ausfälle können so oftmals schnell behoben werden.\n\nDie „Uptime“ von Linux-Servern, also die Zeit, die ein Server am Stück und ohne Ausfälle online ist, ist bemerkenswert. Bei einigen Linux-Distributionen sind Zeiten von über einem Jahr keine Seltenheit. \n\n## Sicherheit\nSicherheit ist für die meisten Unternehmen neben der Stabilität und Performance der wichtigste Betrachtungspunkt bei der Serverwahl.\n\nLinux wurde von Anfang an mit einigen Features versehen, die das Betriebssystem besonders gut vor eventuellen Angriffen oder ungewünschter Datennutzung schützen. Hier findet sich bereits ein erster Überschneidungspunkt mit der GitLab-Philosophie, bei der Planungseffizienz, Kundenorientierung und Sicherheit stets Hand in Hand gehen.\n\nDazu gehört das standardmäßige Absichern eines Downloads mit einer erzwungenen (Root-)Passwortabfrage oder auch das Abgleichen eines Downloads mit einer Liste als sicher geltender Webseiten.\n\nBesonders vorteilhaft ist, dass Updates auf Linux-Servern im laufenden Betrieb direkt implementiert werden können. Windows verlangt hierzu einen Neustart. Das wird einige Administrator(inn)en dazu verleiten, Updates zu verschieben und damit die Uptime gegenüber      der Sicherheit zu priorisieren. Solche Konflikte entstehen bei Linux nicht.\n\n## Kosten\nLinux ist als Open-Source-Produkt grundsätzlich kostenfrei nutzbar. Die Nutzung von Windows wird über eine Server-Lizenz abgeglichen. So erscheint Linux als die ideale Option für alle, die ihre Kosten möglichst niedrig halten möchten.\n\nIn Wahrheit sind die Kostenunterschiede in der Praxis jedoch nicht so auffällig. In seiner einfachsten Variante erfordert Linux beispielsweise gut geschulte Administrator(inn)en, die mit diesem System arbeiten und es für den konkreten Praxiseinsatz konfigurieren können.\n\nAuch bedarf es einer gewissen Erfahrung, den Kontakt mit der Linux-Community zu nutzen. Hier sind die Support- und Sicherheitspakete kommerzieller Anbieter gelegentlich günstiger.\n\nDer wahre Grund, warum so viele Betriebe auf Linux setzen, ist vielmehr ein anderer:\n\n## Skalierbarkeit und Kundenorientierung\nEine häufig genannte Statistik ist die Dominanz des Linux OS im Supercomputer-Bereich, also seinem Einsatz auf den 500 schnellsten Rechnern der Welt. Hier nähert sich der Wert seit vielen Jahren immer mehr den 100 % an. Tatsächlich wenden gerade große Unternehmen verschiedene Linux-Distributionen besonders gerne an.\n\nSicherlich ist Skalierbarkeit kein Alleinstellungsmerkmal von Linux. Wohl aber wird das traditionelle kommerzielle Lizenzmodell von Windows gerade für rasch wachsende Unternehmen zum Kostenfaktor. Linux hingegen bietet aufgrund seiner inhärent modularen Konstruktion einfache Aufstockungsoptionen – ohne deinen Betrieb dabei finanziell übermäßig zu belasten.\n\nAllerdings brauchen auch mittelgroße und kleine Unternehmen nicht zwangsläufig auf Windows zu setzen. Schließlich wurde Torvalds ursprünglich unter anderem dazu motiviert, Linux zu entwickeln, um die Funktionalität eines großen Servers auf sehr moderater Hardware zu liefern.\n\n## Was sind “Linux-Distributionen”?\nIn seiner Basis-Variante wird Linux sich nur für wenige Unternehmen eignen. Sogar, wenn du die Kosten so niedrig wie möglich halten möchtest, wirst du sehr wahrscheinlich einige Anpassungen vornehmen müssen.\n\nUm dir diese Arbeit abzunehmen und um Linux an deine spezifischen Bedürfnisse anzupassen, haben sich feste Systemkonfigurationen herauskristallisiert. Alle nutzen den Linux-Kernel als Ausgangspunkt und haben ihn um gewisse Elemente und Features erweitert.\n\nDie beliebtesten, offiziell unterstützen Pakete sind Ubuntu, Debian, CentOS, AlmaLinux, Amazon Linux, OpenSUSE Leap und Raspberry Pi OS. Jede dieser Linux-Distributionen hat ihre eigenen Vor- und Nachteile. Sehen wir sie uns der Reihe nach an.\n\n## Linux-Distribution #1: Ubuntu\nUbuntu ist einer der frühesten Linux-Distributionen. Daraus ergibt sich auch unmittelbar einer seiner Hauptvorteile: Die Ubuntu-Community ist global und groß und eventuelle Fragen können in der Regel schnell und effizient beantwortet werden.\n\nUbuntu ist noch immer eine hervorragende Möglichkeit, in die Linux-Welt einzusteigen – auch wenn es inzwischen intuitivere Alternativen gibt. Das User Interface erfordert eine gewisse Einarbeitungs- und Eingewöhnungsphase, ist aber keineswegs komplex und zudem sehr logisch aufgebaut.\n\nFür Privatnutzer ist Ubuntu kostenlos. Die verschiedenen Lizenzlevels für eine kommerzielle Nutzung sind an die Möglichkeiten der jeweiligen Nutzer(innen) angepasst.\n\n## Linux-Distribution #2: Debian\nDebian ist die wohl langlebigste Linux-Distribution. In vielen Ländern, darunter auch Deutschland, bleibt sie die meistgenutzte Linux-Umsetzung für Server.\nDieser Erfolg beruht auf der unvergleichlichen Sicherheit und Stabilität von Debian, die seinesgleichen sucht.\n\nGerade weil Debian so zuverlässig ist, nutzen viele Entwickler(innen) es, um um seinen Core herum eine neue Distribution zu entwickeln. Doch bleibt auch 2024 das ursprüngliche Debian für Linux-Server eine hervorragende Wahl.\n\nAlternativ steht dir mit Raspberry Pi OS ein exzellenter Debian-Klon zur Verfügung.\n\n## Linux-Distribution #3: CentOS\nNach Ubuntu ist CentOS die weltweit beliebteste Linux-Distribution. Von RedHat entwickelt zeichnet sich auch CentOS vor allem durch seine Stabilität und Sicherheit aus. Auch seine einfache Kontrolle und Skalierbarkeit sind hervorzuheben. Und im direkten Vergleich mit anderen Distributionen fällt die bemerkenswerte Geschwindigkeit auf, die für viele Anwender(innen) ein absolutes Alleinstellungsmerkmal darstellt.\n\nLeider wurde der Support von CentOS für Linux eingestellt. Damit werden zwar nicht sofort alle mit dieser Distribution ausgestatteten Server obsolet, zum      Einstieg eignet sich CentOS nach aktuellem Stand aber nicht mehr.\n\n## Linux-Distribution #4: AlmaLinux\nDie Ansprüche von AlmaLinux sind hoch. So hat sich diese Linux Distribution zum Ziel gesetzt, den Status eines Enterprise-Level-Betriebssystems zu erreichen. Um diese Auszeichnung tragen zu dürfen, müssen bestimmte, hohe Kriterien in Bezug auf die Sicherheit und Funktionalität des Systems erreicht werden und es muss durch außenstehende Dienstleister verwaltet und gewartet werden können.\n\nDamit bietet AlmaLinux das volle Leistungspaket für Unternehmen jeder Größenordnung, bleibt aber wegen seines OpenSource-Ansatzes weiter kostenfrei. Durch seine Einbindung in die CentOS-Architektur wird es zudem regelmäßig aktualisiert.\n\nNachteilig wirkt sich allerdings aus, dass die zeitlichen Abstände zwischen neuen Versionen dieser Linux-Distribution eher lang ausfallen. Darüber hinaus ist die Softwareumgebung für Alma eher klein. Das bedeutet, dass du für bestimmte Herausforderungen in deinem Betrieb möglicherweise nicht die passende Lösung findest.\n\n## Linux-Distribution #5: Amazon Linux\nAmazon ist einer der jüngsten Anbieter im Linux-Bereich. Bei Amazon Linux dreht sich alles um die Einbindung in die Amazon Web Services (AWS). Daraus ergeben sich Vorteile in Sachen Kosten und Performance.\n\nAndererseits bedeutet diese enge Verknüpfung auch, dass dir für eventuelle Unterstützung nur eine kleine Community zur Verfügung steht. Das könnte der Grund dafür sein, dass, trotz der Marktmacht, die Amazon hat, das vom Online-Retailer angebotene OS bisher nur einen Anteil von einem halben Prozent erlangt hat.\n\n## Linux-Distribution #6: OpenSUSE Leap\nDas deutsche Unternehmen SUSE hat mit dieser Distribution eine der derzeit beliebtesten neuen Linux-Distributionen vorgelegt. Gerade unter Software-Entwickler(inne)n genießt es eine sehr hohe Wertschätzung.\n\nOpenSUSE Leap macht einiges anders als andere Distributionen. Dazu gehört der hervorragende Package Manager sowie ein optionales grafisches Interface (GUI). Auch in Sachen Sicherheit hat es einigen der etablierteren Distributionen den Rang abgelaufen.\n\n## GitLab und Linux-Server\nBei Git handelt es sich um eine Softwareentwicklungs- und Kollaborationsplattform, die eng mit der agilen Methodologie verknüpft ist. Es mag noch andere Version-Control-Programme geben, doch keines ist so gut für den Einsatz auf einem Linux-Server geeignet wie Git.\n\nDafür reicht ein kurzer Blick in die Geschichte von Git aus. So wurde die Plattform ebenfalls von Linus Torvalds geschrieben, ganz spezifisch für einen Einsatz auf einem Linux-OS. Daraus ergibt sich eine enge Abstimmung, die eine optimale Performance garantiert.\n\nGitLab ist eine der weltweit führenden Git-Plattformen und ergänzt den dahintersteckenden DevOps-Gedanken noch um eine besondere Betonung des Themas Sicherheit.\nUm GitLab unter Linux zu nutzen, richte zunächst den Linux-Server ein und installiere anschließend GitLab.\n\n## Einen Linux-Server einrichten\nJede der genannten Linux-Distributionen hat ihre Eigen- und Besonderheiten. \n\n**Das Einrichten und Verbinden eines Linux-Servers allerdings folgt jeweils einem nahezu identischen Ablauf:**\n\n**- Lade die aktuelle Version der jeweiligen Software auf deinen Rechner und erstelle ein Boot-Medium – entweder auf einem optischen Träger oder einem USB-Stick.**\n\n**- Verbinde das Boot-Medium mit deinem Linux-Server und installiere die Software.**\n\n**- Installiere anschließend den für dich passenden Datenbankserver, einen Webserver und lege die Skriptsprache fest.**\n\n**- Nun kannst du noch eine grafische Benutzeroberfläche hinzufügen oder den Server über Text ansteuern.**\n\nInstalliere anschließend sämtliche weitere Software, die du benötigst.\n\n## Einen Linux-Server sichern\nNach dem Einrichten deines Linux-Servers läuft das Absichern genauso ab wie bei einem Standard-Desktop-PC.\n\nEntscheidend ist, dass du das Linux-Server-Backup wirklich häufig und regelmäßig vornimmst und genau festlegst, was gesichert und was nicht gesichert werden soll. Weil auf Servern oftmals große Datenmengen gespeichert sind, kommt diesem Punkt hier eine noch höhere Bedeutung als im Heimbereich zu. Als Speicherort kann eine hochwertige zweite Festplatte dienen.\n\nWichtig ist die Wahl des besten Backup-Tools. In dieser Übersicht zu Server-Backups unter Linux werden die Vorteile und Nachteile einander anschaulich gegenübergestellt.\n\n## GitLab auf einem Linux-Server nutzen\nUm von den Vorteilen einer GitLab-Nutzung unter Linux profitieren zu können, installiere den Git-Repository-Manager auf einer der obengenannten Distributionen deiner Wahl.\n\n**Der Ablauf der Installation besteht dabei aus drei Schritten:**\n\n**- Dem Installieren und Konfigurieren der verlangten externen Software und/oder Bibliotheken**\n\n**- Dem Hinzufügen des GitLab-Repository und der Installation des Pakets.**\n\n**- Dem Ausführen des Setups.**\n\nAnschließend kannst du von den Funktionen von GitLab für deine Teamarbeit voll profitieren – zum Beispiel im Rahmen deiner Epics und User Stories.",[551],{"slug":992,"featured":6,"template":797},"what-is-a-linux-server",{"content":994,"config":1004},{"title":995,"description":996,"authors":997,"heroImage":998,"date":999,"body":1000,"category":732,"tags":1001,"updatedDate":1003},"Automatisierung der Migration von Container-Images von Amazon ECR zu GitLab","Wenn Plattformteams ihre CI/CD zu GitLab verschieben, sollte die Migration von Container-Images kein Engpass sein. Befolge diese Schritt-für-Schritt-Anleitung, um den Pipeline-Migrationsprozess zu automatisieren.",[875],"https://res.cloudinary.com/about-gitlab-com/image/upload/v1749663129/Blog/Hero%20Images/blog-image-template-1800x945__28_.png","2025-02-13","„Wir müssen Hunderte von Container-Images von Amazon Elastic Container Registry (ECR) zu GitLab migrieren. Könnt ihr uns helfen?“ Diese Frage taucht immer wieder in Gesprächen mit Platform Engineers auf. Sie modernisierten also ihre DevSecOps-Toolchain mit GitLab, kamen aber beim Verschieben ihrer Container-Images nicht weiter. Während ein einzelner Image-Transfer einfach ist, erscheint das schiere Volumen überwältigend.\n\nEin Platform Engineer brachte es auf den Punkt: „Ich weiß genau, was zu tun ist – pullen, neu kennzeichnen, pushen. Aber ich habe 200 Microservices mit jeweils mehreren Tags. Ich kann es nicht rechtfertigen, Wochen für diese Migration aufzuwenden, während wichtige Infrastrukturarbeiten anstehen.“\n\n## Die Herausforderung\n\nDieses Gespräch führte zu einer Idee. Was wäre, wenn wir den gesamten Prozess automatisieren könnten? Wenn Plattformteams ihre [CI/CD](https://about.gitlab.com/de-de/topics/ci-cd/) zu GitLab verschieben, sollte die Migration von Container-Images kein Engpass sein. Der manuelle Prozess ist einfach, aber repetitiv: Jedes Image pullen, neu kennzeichnen und in die Container-Registry von GitLab pushen. Angesichts dutzender Repositories und mehrerer Tags pro Image, bedeutet dies Tage oder Wochen langwieriger Arbeit.\n\n## Die Lösung\n\nWir haben uns daran gemacht, eine GitLab-Pipeline zu erstellen, die all diese schwierigen Aufgaben automatisch erledigt. Das Ziel war einfach: Wir wollten Platform Engineers ein Tool zur Verfügung stellen, das sie in wenigen Minuten einrichten und über Nacht ausführen können, sodass am nächsten Morgen alle ihre Images erfolgreich migriert wurden.\n\n### Einrichten des Zugriffs\n\nDas Wichtigste zuerst: die Sicherheit. Teams sollen diese Migration mit minimalen AWS-Berechtigungen durchführen können. Hier ist die schreibgeschützte Identitäts- und Zugriffsmanagement (IAM)-Richtlinie dafür:\n\n```json\n{\n    \"Version\": \"2012-10-17\",\n    \"Statement\": [\n        {\n            \"Effect\": \"Allow\",\n            \"Action\": [\n                \"ecr:GetAuthorizationToken\",\n                \"ecr:BatchCheckLayerAvailability\",\n                \"ecr:GetDownloadUrlForLayer\",\n                \"ecr:DescribeRepositories\",\n                \"ecr:ListImages\",\n                \"ecr:DescribeImages\",\n                \"ecr:BatchGetImage\"\n            ],\n            \"Resource\": \"*\"\n        }\n    ]\n}\n```\n\n### GitLab-Konfiguration\n\nNachdem die Sicherheit gewährleistet ist, ist der nächste Schritt die Einrichtung von GitLab. Wir haben uns auf das Wesentliche beschränkt. Du musst diese Variablen in deinen CI/CD-Einstellungen konfigurieren:\n\n```\nAWS_ACCOUNT_ID: Your AWS account number\nAWS_DEFAULT_REGION: Your ECR region\nAWS_ACCESS_KEY_ID: [Masked]\nAWS_SECRET_ACCESS_KEY: [Masked]\nBULK_MIGRATE: true\n```\n\n### Die Migrationspipeline\n\nJetzt wird es interessant. Wir haben die Pipeline mit Docker-in-Docker erstellt, um alle Image-Vorgänge zuverlässig zu verarbeiten:\n\n```yaml\nimage: docker:20.10\nservices:\n  - docker:20.10-dind\n\nbefore_script:\n  - apk add --no-cache aws-cli jq\n  - aws sts get-caller-identity\n  - aws ecr get-login-password | docker login --username AWS --password-stdin\n  - docker login -u ${CI_REGISTRY_USER} -p ${CI_REGISTRY_PASSWORD} ${CI_REGISTRY}\n```\n\nDie Pipeline hat drei Phasen, die jeweils auf der letzten aufbauen:\n\n1. Entdeckung\n\nZuerst findet sie alle deine Repositories:\n\n```bash\nREPOS=$(aws ecr describe-repositories --query 'repositories[*].repositoryName' --output text)\n```\n\n2. Tag-Auflistung\n\nDann ruft sie für jedes Repository alle Tags ab:\n\n```bash\nTAGS=$(aws ecr describe-images --repository-name $repo --query 'imageDetails[*].imageTags[]' --output text)\n```\n\n3. Übertragung\n\nSchließlich übernimmt sie die eigentliche Migration:\n\n```bash\ndocker pull ${AWS_ACCOUNT_ID}.dkr.ecr.${AWS_DEFAULT_REGION}.amazonaws.com/${repo}:${tag}\ndocker tag ${AWS_ACCOUNT_ID}.dkr.ecr.${AWS_DEFAULT_REGION}.amazonaws.com/${repo}:${tag} ${CI_REGISTRY_IMAGE}/${repo}:${tag}\ndocker push ${CI_REGISTRY_IMAGE}/${repo}:${tag}\n```\n\n## Das Ergebnis\n\nErinnerst du dich an den Platform Engineer, der nicht wochenlang mit der Migration verbringen wollte? Diese Lösung bietet Folgendes:\n\n- automatisierte Erkennung und Migration aller Repositories und Tags\n- konsistente Image-Benennung zwischen ECR und GitLab\n- Fehlerbehandlung für fehlgeschlagene Übertragungen\n- klare Protokollierung zur Verfolgung des Fortschritts\n\nAnstatt Skripte zu schreiben und die Migration zu überwachen, konnte sich der Plattform Engineer auf wertvollere Arbeit konzentrieren.\n\n## Verwendung\n\nDie ersten Schritte sind einfach:\n\n1. Kopiere die Datei `.gitlab-ci.yml` in dein Repository.\n2. Konfiguriere die AWS- und GitLab-Variablen.\n3. Setze `BULK_MIGRATE` auf „true“, um die Migration zu starten.\n\n## Best Practices\n\nBei der Unterstützung von Teams bei ihren Migrationen haben wir einige Dinge gelernt:\n\n- Der Prozess sollte außerhalb der Stoßzeiten durchgeführt werden, um die Auswirkungen auf dein Team zu minimieren.\n- Die Pipeline-Protokolle sind wichtig – darin findest du Informationen, wenn es ein Problem gibt.\n- Die Elastic Container Registry (ECR) sollte erst deaktiviert werden, wenn du überprüft hast, dass alle Images erfolgreich übertragen wurden.\n- Bei sehr großen Migrationen solltest du eine Ratenbegrenzung in Betracht ziehen, um eine Überlastung deines Netzwerks zu vermeiden.\n\nWir haben diese Pipeline in unserem öffentlichen GitLab-Repository quelloffen verfügbar gemacht, weil wir der Meinung sind, dass Plattform Engineers Zeit damit verbringen sollten, wertvolle Infrastrukturen aufzubauen, anstatt Container-Images zu kopieren. Passe sie an deine Bedürfnisse an und stelle Fragen zur Implementierung, wenn etwas unklar ist.\n\n> #### Informationen dazu und zu anderen Paketkomponenten findest du in unserer [CI/CD-Katalog-Dokumentation](https://gitlab.com/explore/catalog/components/package).",[109,864,810,808,765,1002],"solutions architecture","2025-04-10",{"slug":1005,"featured":91,"template":797},"automating-container-image-migration-from-amazon-ecr-to-gitlab",{"category":739,"slug":743,"posts":1007},[1008,1022,1035],{"content":1009,"config":1020},{"title":1010,"description":1011,"authors":1012,"heroImage":1014,"date":1015,"body":1016,"category":743,"tags":1017,"updatedDate":1019},"Wirtschaftliche Gesamtauswirkungen von GitLab Ultimate: 483 % ROI über 3 Jahre","Eine Untersuchung von Forrester Consulting zu GitLab Ultimate zeigte, dass die DevSecOps-Plattform die Sicherheitslage verbesserte und die 5-fache Zeit bei Sicherheitsaktivitäten eingespart werden konnte.\n",[1013],"Dave Steer","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750098354/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%281%29_5XrohmuWBNuqL89BxVUzWm_1750098354056.png","2024-11-13","Eine leistungsstarke DevSecOps-Plattform optimiert den Betrieb, verhindert, dass Sicherheitslücken deinen Betrieb stören (und dadurch Kosten verursachen), steigert die Produktivität und fördert eine Kultur der Innovation und Zusammenarbeit. Genau dafür haben wir GitLab entwickelt – und der Ultimate-Tarif steht wie kein anderer für die volle Leistung unserer Plattform. Um zu sehen, wie unser Produkt in der realen Welt besteht, haben wir Forrester Consulting beauftragt, eine Untersuchung der wirtschaftlichen Gesamtauswirkungen von GitLab Ultimate vorzunehmen und den sogenannten „Total Economic Impact™“ zu messen. Hier siehst du auf einen Blick, was wir herausgefunden haben.\n\nLaut Studie kann GitLab für ein fiktives kombiniertes Unternehmen, das aus den Daten der befragten Kund(inn)en zusammengeführt wurde, folgende Ergebnisse erzielen:\n\n* **Drei-Jahres-ROI von 483 %**\n* **400 % Verbesserung der Produktivität der Entwickler(innen)**\n* **15 x kürzere Zeit bis zur ersten Release\u003Csup>1\u003C/sup>**\n* **5-fache Zeitersparnis bei Sicherheitsaktivitäten**\n\n**Insgesamt ermöglichte GitLab 50 % mehr Arbeit mit geschäftlichem Wert.** \n\nDie Zahlen zeichnen ein klares Bild: Die Plattform von GitLab verändert die Zusammenarbeit von Teams. Egal, ob du Führungskraft im Bereich der Anwendungssicherheit bist und die Sicherheitslage des Unternehmens verbessern musst, als Entwickler(in) schneller höherwertigen Code liefern sollst oder als CTO nach einer skalierbaren, sicheren und flexiblen DevSecOps-Plattform suchst: Diese Studie zeigt, dass GitLab Ultimate hält, was es verspricht. Die vollständige Methodik findest du weiter unten. Nun wollen wir die Ergebnisse aufschlüsseln.\n\n> Lade den vollständigen Bericht (auf Englisch) hier herunter: [2024 Forrester Consulting „Total Economic Impact of GitLab Ultimate“](https://about.gitlab.com/resources/study-forrester-tei-gitlab-ultimate/).\n\n## **1\\. Drei-Jahres-ROI von 483 %**\n\n*„Der große Gewinn für uns war die Effizienz – sowohl in der Verwaltung als auch im Gesamtbetrieb. Jetzt können alle zusammenarbeiten und wir können unsere Pipeline ganz einfach automatisieren. Außerdem kann ich die Personen effizienter zu anderen Aufgaben verschieben. Ich muss sie jetzt nicht mehr in verschiedenen Tools in den einzelnen Programmen schulen, sondern es reicht, wenn man GitLab erlernt – und schon kann man losarbeiten.“* - CTO und Senior-Vizepräsident(in), Verteidigungsindustrie\n\nDie Studie zeigte, dass sich die Einführung von GitLab Ultimate in einem Team innerhalb von sechs Monaten zu amortisieren begann, vor allem durch die verbesserte Effizienz. Mit einem **ROI von 483 % über drei Jahre** können Unternehmen die Kosten ihrer Software-Toolchains um 25 % senken und die Zeit, die IT-Teams für die Verwaltung komplexer Toolchains aufwenden, um 75 % verkürzen. Neben den Kosteneinsparungen bringt der Umstieg auf eine vereinheitlichte Software fundamentale Verbesserungen hinsichtlich dessen, wie Teams Software entwickeln und bereitstellen.\n\n## **2\\. 400 % Produktivitätssteigerung**\n\n*„Wenn ich mit unseren Entwickler(inne)n über GitLab spreche, sind sie sich einig, dass die Lösung die Produktivität in unserem Unternehmen in allen Teams und Positionen gesteigert hat. Wir haben jetzt eine Plattform mit Funktionen, die alle nutzen können.“* - Softwarearchitekt(in), Energie-/Forschungsbranche\n\nEntwickler(innen) sind in Umgebungen am produktivsten, in denen sie einfach und ohne Unterbrechung zwischen den Aufgaben wechseln können. Laut der Studie können Entwickler(innen) bis zu 305 Stunden pro Jahr durch [Testautomatisierung](https://about.gitlab.com/topics/devops/devops-test-automation/) mit GitLab einsparen, denn damit können sie häufiger testen und Fehler schneller beheben – und all das auf einer einzigen Benutzeroberfläche ohne Kontextwechsel. Dank diesem optimierten Workflow können sie sich auf das Programmieren konzentrieren und müssen nicht mehr verschiedene Tools und Prozesse koordinieren.\n\nDie Produktivitätssteigerung ist auch beim Onboarding zu merken: Neue Mitarbeitende im Softwareentwicklungsteam des kombinierten Unternehmens erreichten um 75 % schneller ihre volle Produktivität (d. h. in 1,5 Wochen anstatt in 1,5 Monaten). Die Auswirkungen sind klar: Alle im Team können dadurch schneller Arbeit leisten, die wirklich etwas bewirkt.\n\n## **3\\. 15 x kürzere Zeit bis zur ersten Veröffentlichung**\n\n*„Software ist unsere Superkraft. Sie wird in Geschwindigkeit sowie in der Fähigkeit gemessen, unseren Kund(inn)en neue Funktionen zu bieten. Damit dies unser Hauptaugenmerk blieb, war es in wirtschaftlicher Hinsicht klar, zu einer einheitlichen Plattform zu wechseln.“* - CTO und Senior-Vizepräsident(in), Verteidigungsindustrie\n\nDie zusammengefassten Daten aus den Kundeninterviews zeigen, dass Unternehmen mit GitLab die Veröffentlichung der ersten Release um das 15-Fache beschleunigen konnten. Dieser enorme Vorteil wird durch eine raschere Initiierung von Projekten, häufigere Softwarereleases und einen proaktiven Sicherheitsansatz erreicht, bei dem Sicherheitsscans von Beginn an in den Entwicklungsprozess integriert werden. Trotz dieser Geschwindigkeitssteigerung bleiben Softwarequalität und Sicherheit auf dem gleichen hohen Niveau, da die Entwickler(innen) Probleme frühzeitig und schnell beheben können.\n\nDa die [Sicherheit direkt in den Entwicklungsprozess integriert wurde](https://about.gitlab.com/solutions/security-compliance/), können Entwickler(innen) Sicherheitslücken identifizieren, priorisieren und beheben, ohne ihren Workflow unterbrechen zu müssen. Dieser vereinheitlichte Ansatz für den gesamten Software-Entwicklungsprozess sorgt dafür, dass Teams schneller vorwärts kommen, ohne Kompromisse bei der Sicherheit eingehen zu müssen.\n\n## **4\\. 5-fache Zeitersparnis bei Sicherheitsaktivitäten**\n\n*„Die Integration von Sicherheits- und Qualitätsscannern in die Pipeline war für uns ein Wendepunkt. Durch mehr Automatisierung und weniger manueller Arbeit gibt es weniger Ausfälle, weniger Probleme und schnellere Fortschritte.“* - Programmmanager(in), Finanzbranche \n\nSicherheit steht für jedes Unternehmen an erster Stelle, da sich die Entwicklung beschleunigt und sich die Bedrohungen ständig weiterentwickeln. Mit GitLab können die Mitglieder des Sicherheitsteams im kombinierten Unternehmen **78 Stunden pro Mitglied und Jahr** einsparen, indem wiederkehrende Aufgaben wie Vorbereitungen für die Notfallwiederherstellung, Auditing und Compliance-Überprüfungen automatisiert werden. GitLab verbessert zudem die Transparenz im Software-Entwicklungsprozess und hilft den Sicherheits- und Entwicklungsteams dabei, effizienter zusammenzuarbeiten.\n\nDie Cybersicherheits- und Softwareentwicklungsteams im kombinierten Unternehmen konnten **Sicherheitsrisiken im Software-Entwicklungsprozess mit 81 % weniger Aufwand verwalten und mindern.** Dies ist darauf zurückzuführen, dass sie dank GitLab Sicherheitsprotokolle und -scans in allen Phasen des Software-Entwicklungsprozesses integrieren können. Dadurch konnten strenge Sicherheitsstandards viel einfacher umgesetzt werden. Da Sicherheitstests und die Fehlerbehebung in die Pipelines integriert werden, können Teams die durchschnittlichen Reaktionszeiten sowie das Risiko, dass Probleme in die Produktion gelangen, senken.\n\n# **Erlebe DevSecOps in Aktion**\n\nMit einem ROI von 483 %, einer kurzen Amortisationszeit und unzähligen Erfolgsgeschichten ist GitLab ein unschätzbares Tool für Unternehmen, die ihre Software-Entwicklungsprozesse transformieren möchten.\n\n> Um herauszufinden, wie GitLab auch dein Unternehmen unterstützen kann, lade den vollständigen Bericht noch heute herunter (nur auf Englisch verfügbar): [Forrester Consulting „Total Economic Impact of GitLab Ultimate“ ](https://about.gitlab.com/resources/study-forrester-tei-gitlab-ultimate/).\n\n**Methodik**  \n*Für die Studie befragte Forrester vier GitLab-Ultimate-Kund(inn)en aus verschiedenen Branchen, darunter Finanzwesen, Verteidigung und Forschung, und bildete aus den Angaben ein fiktives kombiniertes Unternehmen, das die aggregierten Ergebnisse der Befragungen widerspiegelt. Es wird erwartet, dass das kombinierte Unternehmen GitLab Ultimate in einem Zeitraum von drei Jahren in allen Teams einführt.*\n\n*Das kombinierte Unternehmen ist ein 5 Milliarden Dollar schweres Unternehmen mit 5 000 Mitarbeitenden, von denen 40 % an der Softwarebereitstellung beteiligt sind und in dem 50 % des Jahresumsatzes durch Softwareentwicklung erzielt werden. Die Ziele des fiktiven Unternehmens sind, mehrere Tools in eine einzige integrierte Plattform zu konsolidieren, die Produktivität der Entwickler(innen) zu steigern, die Einhaltung von Branchenvorgaben und internen Richtlinien zu erreichen und die Sicherheit im gesamten Entwicklungsprozess zu steigern.*\n\n*1. Basierend auf zusammenfassenden Daten aus Kundeninterviews; nicht auf die Ergebnisse des kombinierten Unternehmens anwendbar.*",[808,1018,743,776],"research","2024-11-26",{"slug":1021,"featured":91,"template":797},"gitlab-ultimates-total-economic-impact-483-roi-over-3-years",{"content":1023,"config":1033},{"title":1024,"description":1025,"authors":1026,"heroImage":1028,"date":1029,"body":1030,"category":743,"tags":1031,"updatedDate":1032},"Einführung in The Source: Einblicke in die Zukunft der Softwareentwicklung","In unserer neuen Publikation findest du transformative Softwareentwicklungsstrategien und Ratschläge von Expert(inn)en zu neuen Technologien.",[1027],"Chandler Gibbons","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674616/Blog/Hero%20Images/blog-image-template-1800x945__1_.png","2024-10-29","Die moderne Softwareentwicklung verändert die Art und Weise, wie Unternehmen geschäftlichen Mehrwert schaffen, liefern und skalieren. Die Teams müssen in der Lage sein, schnell und effizient Lösungen zu entwickeln und gleichzeitig mit den zunehmenden Sicherheitsbedrohungen, neuen Technologien und immer komplexeren Compliance-Anforderungen umzugehen.\n\nHeute bringt GitLab [The Source](https://about.gitlab.com/the-source/) auf den Markt, eine neue Publikation, die sich mit der Entwicklung der Softwareentwicklung als Motor für den Geschäftserfolg beschäftigt. Wir bieten regelmäßig Einblicke in die Zukunft der Softwareentwicklung, gestützt auf eigene Forschung und Analysen unserer Fachleute und Vordenker(innen).\n\nAuf The Source findest du zum Beispiel Antworten auf folgende Fragen:  \n* Wie können Führungskräfte den ROI von KI über den gesamten Software-Entwicklungsprozess hinweg messen?    \n* Wie lassen sich Sicherheit und Compliance in der gesamten Software-Lieferkette am besten gewährleisten?\n* Welche Arten von Effizienzgewinnen können Teams durch die Konsolidierung von Plattformen und Toolchains erzielen?\n\nHier ein aktueller Auszug von The Source:\n\n**4 Schritte zur Messung der Auswirkungen von KI**\n\n„Die Bewertung der Produktivität von KI-gestütztem Coding erfordert einen differenzierteren Ansatz als herkömmliche Kennzahlen wie Codezeilen, Code Commits oder die Erledigung von Aufgaben. Es ist notwendig, den Fokus auf reale Geschäftsergebnisse zu verlagern, die ein Gleichgewicht zwischen Entwicklungsgeschwindigkeit, Softwarequalität und Sicherheit herstellen.“  \n- [Erfahre mehr über die 4 nötigen Schritte vom KI-Experten Taylor McCaslin (nur in englischer Sprache)](https://about.gitlab.com/the-source/ai/4-steps-for-measuring-the-impact-of-ai/)\n\n**Behebung der Grundursache für häufigen Frust, der durch umständliche Sicherheitsanforderungen verursacht wird**\n\n„DevSecOps verspricht eine bessere Integration zwischen Engineering und Sicherheit, aber es ist klar, dass Frustrationen und Fehlausrichtungen bestehen bleiben. Das liegt daran, dass diese Herausforderungen Symptome eines größeren Problems sind, wie Unternehmen Sicherheit sehen, wie Teams zusammenarbeiten und wie sie Zeit für Sicherheit aufwenden.“\n- [Löse dieses Problem mit fachkundigem Rat des CISO von GitLab, Josh Lemos (nur in englischer Sprache).](https://about.gitlab.com/the-source/security/security-its-more-than-culture-addressing-the-root-cause-of-common-security/)\n\n**Bessere Geschäftsergebnisse durch Platform Engineering**\n\n„Platform Engineering zielt darauf ab, die Workflows von Entwickler(inne)n zu normalisieren und zu standardisieren, indem es Entwickler(inne)n optimierte „Golden Paths“ für die meisten ihrer Workloads und Flexibilität bei der Definition von Ausnahmen für den Rest bietet.“\n- [Entdecke die Best Practices für den Erfolg des Platform Engineerings von Brian Wald, Field CTO von GitLab (nur in englischer Sprache).](https://about.gitlab.com/the-source/platform-and-infrastructure/driving-business-results-with-platform-engineering/)\n\n## Lass dir von The Source bei deinen Entscheidungen helfen\n\nAuf [The Source (nur in englischer Sprache)](https://about.gitlab.com/the-source/), findest du die neuesten Erkenntnisse, Antworten auf deine Fragen zu Führungsthemen und kannst immer etwas Neues lernen, das du mit deinen Teams teilen kannst. Du kannst auch unseren Newsletter abonnieren, um regelmäßige Updates direkt in deinem Posteingang zu erhalten. Werde Teil unserer Community zukunftsorientierter Technologie-Leader und gestalte die Zukunft der Softwareentwicklung mit.",[838,776,743,716],"2024-11-14",{"slug":1034,"featured":91,"template":797},"introducing-the-source-insights-for-the-future-of-software-development",{"content":1036,"config":1045},{"title":1037,"description":1038,"authors":1039,"heroImage":1041,"date":1042,"body":1043,"category":743,"tags":1044,"updatedDate":861},"GitLab ist ein Leader im Gartner Magic Quadrant für DevOps-Plattformen 2024","GitLab ist in den Bereichen „Ability to execute“ und „Completeness of vision“ am besten positioniert. Eine Anerkennung für unsere Kund(inn)en und GitLabs DevOps-Innovationen.",[1040],"Ashley Kramer","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749662523/Blog/Hero%20Images/Gartner_DevOps_Blog_Post_Cover_Image_1800x945__2_.png","2024-09-05","DevOps war ursprünglich nur ein Konzept – eine Methode, um Software schneller bereitzustellen, indem traditionell getrennte Teams zusammengebracht werden. Es war eine Antwort auf alle Probleme, die durch die Trennung zwischen denen, die Software entwickelten, und denen, die sie einsetzten, verursacht wurden. \n\nBei GitLab haben wir dieses Konzept weiterentwickelt: Anstatt Tools zu einer komplexen DevOps-Toolchain zusammenzufügen, würde eine [einheitliche DevOps-Plattform](https://about.gitlab.com/de-de/platform/) eine engere Zusammenarbeit, eine stärkere Automatisierung sowie skalierbare und standardisierte Prozesse ermöglichen. \n\nWir glauben, dass diese Strategie, die auf den Erfolg unserer Kund(inn)en ausgerichtet ist, die richtige Wahl war. In der zweiten Iteration des [Gartner Magic Quadrant für DevOps-Plattformen](https://about.gitlab.com/de-de/gartner-magic-quadrant/) sind wir erneut Leader. Diesmal sind wir auf beiden Achsen „Ability to Execute“ und „Completeness of vision“ am besten positioniert.\n\n![Bild von Gartner MQ für DevOps-Plattformen 2024](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749674334/Blog/Content%20Images/figure1.png)\n\n> Lade den [Bericht des Gartner® Magic Quadrant™ für DevOps-Plattformen 2024](https://about.gitlab.com/gartner-magic-quadrant/) herunter.\n\nDie Softwareunternehmen von heute müssen sich mit zunehmenden Sicherheitsbedrohungen, komplexen Compliance-Anforderungen und der vorsichtigen Einführung neuer Technologien wie generativer KI auseinandersetzen. Außerdem müssen sie ihr Versprechen von skalierbaren Dienstleistungen und kontinuierlicher Innovation gegenüber ihren eigenen Kund(inn)en einhalten.\n\nMit GitLab können unseren Kund(inn)en sich diesen Herausforderungen stellen und in ihren Branchen führend werden. Dank unserer KI-basierten DevSecOps-Plattform wird die Sicherheit früher im SDLC berücksichtigt, Transparenz im gesamten Entwicklungslebenszyklus geschaffen und alle Beteiligten zusammengebracht, um die Software zu entwickeln, die unsere Welt antreibt.\n\n## Die DevOps-Vision fördern\n\nUnsere Arbeit hier ist noch nicht erledigt. Wir werden die DevOps-Vision weiter vorantreiben und unsere DevSecOps-Plattform auf zwei Arten weiterentwickeln.\n\nZum einen wollen wir noch mehr Teams dazu einladen, auf einer gemeinsamen Plattform zusammenzuarbeiten, und zwar mit speziellen Funktionen für diejenigen, die sich mit [Agile Planning](https://about.gitlab.com/de-de/blog/categories/agile-planning/), [Data Science](https://about.gitlab.com/de-de/topics/devops/the-role-of-ai-in-devops/) und [Beobachtbarkeit und Anwendungsüberwachung](https://about.gitlab.com/solutions/gitlab-observability/) (englischsprachige Seite) beschäftigen.\n\nZum anderen wollen wir die Optionen für die Einführung und Bereitstellung unserer Plattform noch flexibler gestalten, um die unterschiedlichen Bedürfnisse unserer Kund(inn)en zu erfüllen. Dazu gehört auch die Investition in [GitLab Dedicated](https://about.gitlab.com/de-de/dedicated/), unsere gehostete Single-Tenant-Option, mit der Unternehmen in stark regulierten Branchen die Einfachheit von SaaS und die Leistungsfähigkeit der neuesten Funktionen und Möglichkeiten nutzen und gleichzeitig die Compliance-Anforderungen einer isolierten Infrastruktur erfüllen können.\n\n## Unterstützung von Unternehmen bei der Entwicklung sicherer Software\n\nNeben der Entwicklung einer besseren Plattform für die Zusammenarbeit bei der Bereitstellung von Software gehört es zu den wichtigsten Aufgaben von GitLab, Unternehmen bei der Entwicklung sicherer und gesetzeskonformer Software zu unterstützen. Unsere Vision unterscheidet uns hier von anderen, denn GitLab integriert [Sicherheitsscans](https://about.gitlab.com/de-de/solutions/security-compliance/) bereits bei der Übergabe des Codes und nicht erst, wenn die Anwendungen zur Veröffentlichung bereit sind. Das hilft den Teams, Sicherheitslücken früher zu erkennen, was zu schnelleren Release-Zyklen führt. GitLab erleichtert außerdem die Einhaltung von Richtlinien durch Leitlinien und die automatische Erstellung [einer Software-Stückliste](https://about.gitlab.com/de-de/blog/the-ultimate-guide-to-sboms/).\n\nWir wissen, dass unsere Kund(inn)en mit immer mehr Sicherheitsbedrohungen konfrontiert sind, wenn die Angriffsfläche für ihre eigene Software wächst. Deshalb planen wir, in den nächsten 12 Monaten unsere SAST-Scanner weiter zu verbessern, zusätzliche Richtlinienkontrollen hinzuzufügen und [einen neuen nativen Geheimnismanager](https://about.gitlab.com/blog/gitlab-native-secrets-manager-to-give-software-supply-chain-security-a-boost/) (englischsprachiger Artikel) zu erstellen.\n\n## Führend mit KI im gesamten SDLC\n\nUnsere Vision ist es, auch im Bereich KI führend zu sein – und zwar nicht nur, wenn es darum geht, unseren Kund(inn)en zu ermöglichen, innovative Software mit KI zu entwickeln, sondern auch, wenn es darum geht, dies mit datenschutzorientierter KI-Technologie zu tun. Die künstliche Intelligenz bedeutet einen gewaltigen Sprung nach vorn und bietet unglaublich viele Möglichkeiten, wenn sie in den gesamten Software-Entwicklungsprozess integriert wird. Wir entwickeln Innovationen verantwortungsbewusst. Wir haben die Bedenken unserer Kund(inn)en gehört: Sie wollen [KI mit Leitlinien](https://about.gitlab.com/blog/velocity-with-guardrails-ai-automation/) (englischsprachiger Artikel), [KI, die transparent ist](https://about.gitlab.com/de-de/ai-transparency-center/) und KI, die ihren Code und ihr geistiges Eigentum respektiert.\n\n[GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/), eine Suite von KI-gestützten Funktionen für unsere DevSecOps-Plattform, soll die folgenden Kriterien erfüllen: sie soll umfassend, datenschutzorientiert und den gesamten Lebenszyklus der Softwareentwicklung unterstützen.\n\nWir glauben, dass dieses Engagement und unsere GitLab-Duo-Funktionen der Grund dafür sind, dass [Gartner® uns kürzlich auch in seinem ersten Magic Quadrant™ für KI-Programmierassistenten zum Leader ernannt hat](https://about.gitlab.com/de-de/blog/gitlab-named-a-leader-in-2024-gartner-magic-quadrant-for-ai-code-assistants/).\n\nWir sind stolz auf diese Auszeichnung und sehen sie als Signal, weiterhin auf euch – unsere Kund(inn)en – zu hören, denn das treibt unsere Vision, unsere Produkt-Roadmap und unser Engagement an, die beste DevSecOps-Plattform zu liefern.\n\n> Lade den [Bericht des Gartner® Magic Quadrant™ für DevOps-Plattformen 2024](https://about.gitlab.com/de-de/gartner-magic-quadrant/) herunter.\n\n***Quelle: Gartner, Magic Quadrant für DevOps-Plattformen, Keith Mann, Thomas Murphy, Bill Holz, George Spafford, August 2024***\n\n***GARTNER ist eine eingetragene Marke und Dienstleistungsmarke von Gartner, Inc. und/oder seinen verbundenen Unternehmen in den USA und international, und MAGIC QUADRANT ist eine\neingetragene Marke von Gartner, Inc. und/oder seinen verbundenen Unternehmen und wird hierin mit Genehmigung verwendet. Alle Rechte vorbehalten.***\n\n***Gartner empfiehlt keine Anbieter, Produkte oder Dienstleistungen, die in seinen Forschungspublikationen abgebildet sind, und rät Technologiebenutzer(inne)n nicht, nur die Anbieter mit den höchsten Bewertungen oder anderen Bezeichnungen auszuwählen. Gartner-Forschungspublikationen stellen die Meinungen der Forschungsorganisation von Gartner dar und sollten nicht als Tatsachenbehauptungen ausgelegt werden. Gartner lehnt alle ausdrücklichen oder stillschweigenden Gewährleistungen in Bezug auf diese Studie ab, einschließlich aller Gewährleistungen der Marktgängigkeit oder Eignung für einen bestimmten Zweck.***\n\n***Diese Grafik wurde von Gartner Inc. als Teil eines umfassenderen Berichts veröffentlicht und sollte im Kontext des gesamten Dokuments bewertet werden. Das Gartner-Dokument ist auf Anfrage bei Gartner erhältlich.***",[743,1018,808,925,716],{"slug":1046,"featured":91,"template":797},"gitlab-named-a-leader-in-the-2024-gartner-magic-quadrant-for-devops",{"category":751,"slug":755,"posts":1048},[1049,1061,1072],{"content":1050,"config":1059},{"title":1051,"description":1052,"authors":1053,"heroImage":1055,"date":988,"body":1056,"category":755,"tags":1057,"updatedDate":791},"20 Jahre GitLab: Begib dich mit uns auf eine Reise","Begib dich mit uns auf die Spuren des ersten Commits, die einzigartigen Aspekte der frühen Releases und die Verwirrung, die ein Update des Standardverhaltens von git-push(1) ausgelöst hat.",[1054],"Patrick Steinhardt","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097380/Blog/Hero%20Images/Blog/Hero%20Images/git-20-years-opt2_TWNsNk8KH43b3jP0KLD0U_1750097380123.png","Das Git-Projekt ist gerade 20 Jahre alt geworden. In diesen Jahren ist viel passiert – während das konzeptionelle Design von [GitLab](https://about.gitlab.com/de-de/) seit seiner Entstehung nicht wesentlich verändert wurde, hat sich doch die Art und Weise, wie Benutzer(innen) mit dem Tool interagieren, deutlich geändert. Wir bei GitLab sind stolz darauf, auf dieser wichtigen Software aufzubauen und Teil ihrer Erfolgsgeschichte zu sein.\n\nBegleite uns auf einer Reise durch die Geschichte von Git und entdecke, wie sich das System im Laufe der Jahre entwickelt hat.\n\n## Der erste Commit\n\nDer erste Commit wurde am 7. April 2005 von [Linus Torvalds](https://about.gitlab.com/de-de/blog/celebrating-gits-20th-anniversary-with-creator-linus-torvalds/), dem Schöpfer des Linux-Kernels, vorgenommen: `e83c5163316 (Initial revision\nof \"git\", the information manager from hell, 2005-04-07)`.\n\nWie wir sehen können, enthält dieser Commit nicht viele Dateien:\n\n```shell\n$ git ls-tree e83c5163316\n100644 blob a6bba79ba1f46a1bbf7773449c3bd2bb9bf48e8b\tMakefile\n100644 blob 27577f76849c09d3405397244eb3d8ae1d11b0f3\tREADME\n100644 blob 98a32a9ad39883c6d05a000a68511d4b1ee2b3c7\tcache.h\n100644 blob 74a0a234dd346fff51c773aa57d82fc4b83a8557\tcat-file.c\n100644 blob 840307af0cfaab31555795ce7175d5e9c9f981a0\tcommit-tree.c\n100644 blob 25dc13fe101b219f74007f3194b787dd99e863da\tinit-db.c\n100644 blob c924a6e0fc4c36bad6f23cb87ee59518c771f936\tread-cache.c\n100644 blob 1b47742d8cbc0d98903777758b7b519980e7499e\tread-tree.c\n100644 blob b8522886a15db861508fb6d03d4d88d6de912a4b\tshow-diff.c\n100644 blob 5085a5cb53ee52e1886ff6d46c609bdb2fc6d6cd\tupdate-cache.c\n100644 blob 921f981353229db0c56103a52609d35aff16f41b\twrite-tree.c\n```\n\nNeben der Build-Infrastruktur bietet der erste Commit sieben Top-Level-Befehle:\n\n- `init-db` zum Initialisieren eines neuen Git-Repositorys\n- `update-cache` zum Hinzufügen von Dateien zum Index\n- `write-tree`, um den Inhalt des Index heranzuziehen und daraus einen neuen Baum zu erstellen\n- `read-tree` zum Lesen eines Baum-Objekts\n- `commit-tree` zum Erstellen eines Commits aus einem Baum\n- `cat-file` zum Lesen eines spezifischen Objekts in eine temporäre Datei\n\nBeachte, dass der Befehl `git` zu der Zeit noch gar nicht existierte.\n\nStattdessen mussten diese Befehle direkt ausgeführt werden.\n\nErstellen wir zum Beispiel ein neues Repository:\n\n```shell\n$ mkdir repo\n$ cd repo\n$ init-db\ndefaulting to private storage area\n$ ls -a\n.  ..  .dircache\n```\n\nDas sieht ziemlich unbekannt aus: Es gibt kein `.git`-Verzeichnis, aber dafür gibt es das Verzeichnis `.dircache`. Und wo war der private Speicherbereich?\n\nDas frühe Design von Git unterschied zwischen einem „geteilten“ und einem „privaten“ Objektspeicherbereich. In diesem Objektspeicherbereich befanden sich alle Git-Objekte. Zum Beispiel deine Commits und Blobs.\n\nStandardmäßig erstellte `init-db` einen privaten Objektspeicherbereich, der nur für das verwaltete Verzeichnis verwendet wurde, in dem es erstellt wurde. Ein „geteilter“ Objektspeicherbereich hingegen teilte Objektinhalte über mehrere verwaltete Verzeichnisse, so dass dasselbe Objekt nicht zweimal gespeichert werden musste.\n\n### Einen Commit erstellen\n\nWir haben nun ein Repository, doch wie wurde damals ein Commit erstellt? Das war nicht ganz so einfach wie heute mit `git add . && git commit`. Stattdessen musste man wie folgt vorgehen:\n\n1. Man musste den Index aktualisieren, indem man `update-cache` für jede Datei aufrief, die man hinzufügen wollte.\n2. Dann schrieb man einen neuen Baum, indem man `write-tree` aufrief, wodurch alles herangezogen wurde, was zum Index hinzugefügt worden war.\n3. Man richtete Umgebungsvariablen ein, um Git mitzuteilen, wer man ist.\n4. Dann schrieb man ein Commit-Objekt, indem man `commit-tree` aufrief.\n\nErstellen wir einen Commit im Repository:\n\n```shell\n$ echo content-1 >file-a\n$ update-cache file-a\n$ echo content-2 >file-b\n$ update-cache file-b\n$ write-tree\n3f143dfb48f2d84936626e2e5402e1f10c2050fb\n$ export COMMITTER_NAME=\"Patrick Steinhardt\"\n$ export COMMITER_EMAIL=ps@pks.im\n$ echo \"commit message\" | commit-tree 3f143dfb48f2d84936626e2e5402e1f10c2050fb\nCommitting initial tree 3f143dfb48f2d84936626e2e5402e1f10c2050fb\n5f8e928066c03cebe5fd0a0cc1b93d058155b969\n```\n\nDas ist nicht gerade ergonomisch, aber es funktioniert! Werfen wir einen Blick auf den generierten Commit:\n\n```shell\n$ cat-file 5f8e928066c03cebe5fd0a0cc1b93d058155b969\ntemp_git_file_rlTXtE: commit\n$ cat temp_git_file_rlTXtE\ntree 3f143dfb48f2d84936626e2e5402e1f10c2050fb\nauthor Patrick Steinhardt \u003Cps@pks.im> Wed Mar 26 13:10:16 2025\ncommitter Patrick Steinhardt \u003Cps@pks.im> Wed Mar 26 13:10:16 2025\n\ncommit message\n```\n\nBeachte, dass `cat-file` den Inhalt nicht direkt gedruckt hat, sondern ihn zuerst in eine temporäre Datei geschrieben hat. Der Inhalt der Datei sieht jedoch genauso aus, wie ein moderner Commit aussehen würde.\n\n### Änderungen vornehmen\n\nWie können wir nun den Status der Dateien ermitteln? Vielleicht hast du es erraten: mit `show-diff`:\n\n```shell\n$ show-diff\nfile-a: ok\nfile-b: ok\n\n$ echo modified-content >file-a\n$ show-diff\n--- -\t2025-03-26 13:14:53.457611094 +0100\n+++ file-a\t2025-03-26 13:14:52.230085756 +0100\n@@ -1 +1 @@\n-content-1\n+modified-content\nfile-a:  46d8be14cdec97aac6a769fdbce4db340e888bf8\nfile-b: ok\n```\n\nLustigerweise konnte `show-diff` bereits diffs zwischen dem alten und neuen Zustand der geänderten Datei generieren! Git hat das jedoch erreicht, indem es einfach das Unix-Tool diff(1) ausgeführt hat.\n\nZusammenfassend lässt sich sagen, dass dies zwar alles noch recht spartanisch war, aber das Nötige bot, um den Verlauf nachzuverfolgen. Es gab aber noch viele Einschränkungen:\n\n- Es gab noch keine einfache Möglichkeit, zwischen Commits zu wechseln.\n- Es gab keine Möglichkeit, Protokolle anzuzeigen.\n- Es gab keine Branches, Tags und nicht einmal Referenzen. Von den Benutzer(inne)n wurde erwartet, dass sie die Objekt-IDs manuell verfolgen.- Es gab keine Möglichkeit, zwei Repositories miteinander zu synchronisieren. Stattdessen wurde von den Benutzer(inne)n erwartet, dass sie „rsync(1)“ verwenden, um die `.dircache`-Verzeichnisse zu synchronisieren.\n- Es gab keine Möglichkeit, Merges durchzuführen.\n\n## Git 0.99\n\nDie erste Testversion von Git war Version 0.99. Diese Release kam nur zwei Monate nach dem ersten Commit auf, enthielt aber bereits 1.076 Commits. Es waren fast 50 verschiedene Entwickler(innen) beteiligt. Der häufigste Commiter war zu diesem Zeitpunkt Linus selbst, dicht gefolgt von Junio Hamano, dem aktuellen Betreuer.\n\nViele Dinge hatten sich seit dem ersten Commit geändert:\n\n- Git begann, verschiedene Entwicklungs-Branches mithilfe von Referenzen zu verfolgen, wodurch in den meisten Fällen Objekt-IDs nicht mehr manuell nachverfolgt werden mussten.\n- Es gab ein neues Remote-Protokoll, das es zwei Repositories ermöglichte, Objekte miteinander auszutauschen.\n- Das Verzeichnis `.dircache` wurde in `.git` umbenannt.\n- Es wurde möglich, einzelne Dateien zusammenzuführen.\n\nDie wichtigste offensichtliche Änderung war jedoch die Einführung des Top-Level-Befehls `git` und seiner Unterbefehle. Interessanterweise wurden mit dieser Version auch die Befehle „Plumbing“ und „Porcelain“ eingeführt:\n\n- „Plumbing“-Tools sind Low-Level-Befehle, die auf das zugrunde liegende Git-Repository zugreifen.\n- „Porcelain“-Tools sind Shell-Skripte, die die Plumbing-Befehle einpacken, um eine schönere, hochwertige Benutzeroberfläche zu bieten.Diese Aufteilung existiert auch heute noch, wie in [`git(1)`](https://git-scm.com/docs/git#_high_level_commands_porcelain) dokumentiert ist. Da die meisten Porcelain-Tools jedoch von Shell-Skripten zu C umgeschrieben wurden, verschwimmt die Trennung zwischen den beiden Kategorien mittlerweile deutlich.\n\n## Linus übergibt die Leitung\n\nLinus hat Git nie gegründet, weil sein Herz für Versionskontrollsysteme schlägt, sondern weil er für die Entwicklung des Linux-Kernels eine brauchbare Alternative zu BitKeeper suchte. Daher hatte er nie vor, Git für immer zu leiten. Die Absicht war, es so lange zu leiten, bis er eine(n) vertrauenswürdige(n) Nachfolger(in) gefunden hatte.\n\nDieser Jemand war Junio Hamano. Junio stieg etwa eine Woche nach dem ersten Commit von Linus bei Git ein und hatte nach der Veröffentlichung von Git 0.99 bereits einige hundert Commits im Verlauf. Am 26. Juli 2005 machte [Linus daher Junio zum neuen Betreuer des Git-Projekts](https://lore.kernel.org/git/Pine.LNX.4.58.0507262004320.3227@g5.osdl.org/). Linus trug zwar weiter zu Git bei, doch seine Beteiligung wurde nach und nach immer weniger – nicht verwunderlich, da er als Leiter des Linux-Projektes ziemlich beschäftigt ist.\n\nJunio leitet das Git-Projekt auch heute noch.\n\n> Lies unser großes [Interview mit Linus Torvalds](https://about.gitlab.com/de-de/blog/celebrating-gits-20th-anniversary-with-creator-linus-torvalds/) und erfahre noch mehr über die Geschichte von Git.\n\n## Git 1.0\n\nDie erste größere Version von Git wurde am 21. Dezember 2005 von Junio veröffentlicht. Interessanterweise gab es 34 Releases zwischen Version 0.99 und Version 1.0: 0.99.1 bis 0.99.7, 0.99.7a bis 0.99.7d, 0.99.8 bis 0.99.8g und 0.99.9 bis 0.99.9n.\n\nEiner der wichtigsten Meilensteine seit Version 0.99 war wahrscheinlich der Befehl `git-merge(1)`, der hinzugefügt wurde und mit dem man zwei Bäume zusammenführen kann. Dies ist eine enorme Veränderung zu vorher, wo man im Grunde die Zusammenführungen Datei für Datei skripten musste.\n\n### Remotes\n\nEine weitere wesentliche Änderung war die Einführung der Kurzschreibweise für Remote-Repositories. Während Git bereits wusste, wie man mit Remote-Repositories kommuniziert, mussten Benutzer(innen) jedes Mal die URL angeben, von der sie abrufen wollten, um Änderungen daran vorzunehmen. Dies war ziemlich unpraktisch für die Benutzer(innen), da sie im Normalfall immer wieder mit demselben Remote interagieren wollten.\n\nDu weißt vielleicht, wie Remotes jetzt funktionieren, aber der Vorgang war damals noch deutlich anders. Es gab keinen `git-remote(1)`-Befehl, mit dem man seine Remotes verwalten konnte. Remotes wurden nicht einmal in der Datei `.git/config` gespeichert. Als Remotes in Version 0.99.2 eingeführt wurden, *gab* es in Git nicht einmal Konfigurationsdateien.\n\nStattdessen musste man Remotes konfigurieren, indem man eine Datei in das Verzeichnis `.git/branches` schrieb, was dem heutigen Empfinden nach gegen jegliche Intuition geht. Aber der Mechanismus funktioniert auch heute noch:\n\n```shell\n$ git init repo --\nInitialized empty Git repository in /tmp/repo/.git/\n$ cd repo\n$ mkdir .git/branches\n$ echo https://gitlab.com/git-scm/git.git >.git/branches/origin\n$ git fetch origin refs/heads/master\n```\n\nAber das ist noch nicht alles! Das Verzeichnis wurde bald darauf mit der Git-Version 0.99.5 in „remotes“ umbenannt, also gibt es in einem modernen Git-Client insgesamt drei verschiedene Möglichkeiten, Remotes zu konfigurieren.\n\nDie meisten von euch haben wahrscheinlich weder `.git/branches` noch `.git/remotes` verwendet, denn beide Mechanismen gelten seit 2005 bzw. 2011 als veraltet. Darüber hinaus werden diese Verzeichnisse in Git 3.0 endgültig entfernt.\n\n## Git-Branding\n\nIm Jahr 2007 wurde das erste Git-Logo erstellt. Ob man das schon als Logo bezeichnen kann, ist fraglich, da es nur aus drei roten Minuszeichen über drei grünen Pluszeichen bestand. Dies sollte widerspiegeln, wie die Ausgabe von `git diff` aussah:\n\n![Drei rote Minuszeichen über drei grünen Pluszeichen, die die Ausgabe von `git diff` widerspiegeln](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097388/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097387927.png)\n\nEtwas später, im Jahr 2008, wurde die Website [git-scm.com](https://git-scm.com) veröffentlicht:\n\n![Startseite für git-scm.com im Jahr 2006](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097388/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750097387930.png)\n\nIm Jahr 2012 wurde die Git-Webseite von Scott Chacon und Jason Long [überarbeitet](https://lore.kernel.org/git/CAP2yMaJy=1c3b4F72h6jL_454+0ydEQNXYiC6E-ZeQQgE0PcVA@mail.gmail.com/). Sie sieht ziemlich ähnlich aus wie heute:\n\n![Die Git-Website wurde 2012 überarbeitet](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097388/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097387932.png)\n\nDieses neue Design der Website weist das neue rot-orangefarbene Logo von Jason Long auf, das auch derzeit verwendet wird:\n\n![Git-Logo](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097388/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097387934.png)\n\n## Git 2.0\n\nGit begann schon in der Version 1.0, dem modernen Git sehr ähnlich zu sehen. Daher folgt nun der große historische Sprung zu Git 2.0. Diese Version wurde etwa 10 Jahre nach Git 1.0 veröffentlicht und war die erste Version, die absichtlich abwärtskompatible Änderungen in zentralen Workflows enthielt.\n\n### Standardverhalten von `git-push(1)`\n\nDie Änderung, die wohl die meiste Verwirrung in dieser Version verursachte, war das geänderte Standardverhalten von `git-push(1)`.\n\nEs gibt ein paar verschiedene Aktionen, die Git ausführen kann, wenn du in ein Remote-Repository pusht und nicht genau angibst, was genau du pushen möchtest:\n\n- Git kann verweigern, irgendetwas zu tun, und bittet dich um weitere Informationen darüber, was genau du pushen möchtest.\n- Git kann den aktuell ausgecheckten Branch pushen.\n- Git kann den aktuell ausgecheckten Branch pushen, aber nur, wenn es weiß, dass es ein Äquivalent auf der Remote-Seite gibt.\n- Git kann alle deine Branches pushen, die ein Äquivalent auf der Remote-Seite haben.\n\nDas Verhalten des modernen Git ist die sogenannte „einfache“ Strategie, also die dritte der oben angeführten Optionen. Vor Git 2.0 war das Standardverhalten jedoch die „Matching“-Strategie, also die letzte der genannten Optionen.\n\nDie „Matching“-Strategie war deutlich riskanter. Man musste vor dem Pushen immer sicherstellen, dass es in Ordnung war, alle lokalen Branches zu pushen, die ein Äquivalent auf der Remote-Seite haben. Andernfalls hätte man möglicherweise unbeabsichtigt Änderungen gepusht. Daher wurde beschlossen, die Strategie auf die „einfache“ Strategie zu ändern, um das Risiko zu verringern und Einsteiger(inne)n die ersten Schritte mit Git zu erleichtern.\n\n### `git-add(1)`\n\nEine weitere große Änderung war das Standardverhalten von `git-add(1)` im Hinblick auf nachverfolgte Dateien, die gelöscht wurden. Vor Git 2.0 hätte `git-add(1)` gelöschte Dateien nicht automatisch gestaged, sondern du hättest jede gelöschte Datei manuell mit `git-rm(1)` hinzufügen müssen, damit sie Teil des Commits ist. Mit Git 2.0 wurde dieses Verhalten geändert, sodass `git-add(1)` auch gelöschte Dateien zum Index hinzufügt.\n\n## Wir feiern die Git-Community\n\nIch werde dich nicht mit Details darüber langweilen, wie Git heute funktioniert – du nutzt es wahrscheinlich ohnehin täglich, und wenn nicht, gibt es viele tolle Tutorials, die dir beim Einstieg helfen. Stattdessen wollen wir die Git-Community hochleben lassen – sie ist es nämlich, dank der Git auch 20 Jahre später noch wunderbar funktioniert.\n\nIm Laufe der Zeit hat Git:\n\n- 56 721 Commits seit der Veröffentlichung von Git 2.49 erhalten.\n- Beiträge von mehr als 2 000 verschiedenen Personen erhalten.\n- 60 Hauptversionen veröffentlicht.Das Git-Projekt hat auch einen stetigen Zustrom neuer Mitwirkender durch die Teilnahme am [Google Summer of Code](https://summerofcode.withgoogle.com/) und [Outreachy](https://www.outreachy.org/) erfahren. Neue Mitwirkende wie diese werden dafür sorgen, dass das Git-Projekt auch langfristig weitergeführt wird.\n\nDaher möchte ich allen Mitwirkenden von Herzen danken. Es sind eure Beiträge, die Git erst möglich gemacht haben.\n\n## Ein Blick in die Zukunft\n\nEs steht außer Frage, dass Git den Wettlauf um das beste Versionskontrollsystem gewonnen hat. Es hat einen bedeutenden Marktanteil, und es ist nicht einfach, Open-Source-Projekte zu finden, die ein anderes Versionskontrollsystem als Git verwenden. Git hat also eindeutig vieles richtig gemacht.\n\nDennoch ist die Entwicklung nicht stillgestanden und auch in Zukunft werden viele Herausforderungen auf Git warten. Einerseits sind das technische Herausforderungen:\n- Modernisierung einer alternden Codebasis\n- Skalierung mit der ständig wachsenden Größe von Monorepos\n- Bessere Handhabung großer Binärdateien\n\nAndererseits tauchen Probleme sozialer Art auf:\n- Verbesserung der Benutzerfreundlichkeit von Git\n- Förderung der Git-Community, damit das Projekt langfristig gesund bleibt\n\nEs gibt immer noch viel zu tun und wir bei GitLab sind stolz darauf, Teil dieser Bemühungen zu sein. Gemeinsam können wir sicherstellen, dass Git auch in den nächsten 20 Jahren ein so fantastisches Versionskontrollsystem bleibt.\n\n## Erfahre mehr über Git\n\n- [Wir feiern das 20-jährige Git-Jubiläum mit dessen Erfinder Linus Torvalds](https://about.gitlab.com/de-de/blog/celebrating-gits-20th-anniversary-with-creator-linus-torvalds/)\n- [Was gibt es Neues in Git 2.49.0?](https://about.gitlab.com/de-de/blog/whats-new-in-git-2-49-0/)\n- [Was gibt es Neues in Git 2.48.0?](https://about.gitlab.com/de-de/blog/whats-new-in-git-2-48-0/)\n- [Der Anfängerleitfaden zum „reftable“-Format von Git](https://about.gitlab.com/de-de/blog/a-beginners-guide-to-the-git-reftable-format/)",[896,1058],"git",{"slug":1060,"featured":91,"template":797},"journey-through-gits-20-year-history",{"content":1062,"config":1070},{"title":1063,"description":1064,"authors":1065,"heroImage":1066,"date":1067,"body":1068,"category":755,"tags":1069,"updatedDate":861},"Wir feiern das 20-jährige Git-Jubiläum mit dessen Erfinder Linus Torvalds","Erfahre, wie das Open-Source-Versionskontrollsystem entstanden ist und was Linus davon hält, neue Programmiersprachen zu Git hinzuzufügen.",[1054],"https://res.cloudinary.com/about-gitlab-com/image/upload/v1749662510/Blog/Hero%20Images/git-20-years-opt1.png","2025-04-07","Das Versionskontrollsystem Git wurde am 7. April 2005 vom \"Vater\" des Linux-Kernels, Linus Torvalds, veröffentlicht. Heute feiern wir den 20. Jahrestag dieses wichtigen Projekts, das mittlerweile von fast allen Entwickler(inne)n verwendet wird. Zu diesem Anlass habe ich mit Linus über die Geschichte von Git und darüber gesprochen, warum er die Rolle des Chefentwicklers von Git abgegeben hat und was seiner Meinung nach die wichtigsten Meilensteine sind.\n\n**2005 warst du bereits Betreuer des aufstrebenden Linux-Kernels. Warum hast du dich entschieden, ein neues Versionskontrollsystem zu entwickeln?**\n\nAnfangs habe ich Versionskontrolle wirklich gehasst.\n\nIch habe herkömmliche Versionskontrollsysteme (CVS/RCS/SCCS) sowohl als Endbenutzer (z. B. beim Nachverfolgen von Open-Source-Projekten wie [GCC](https://gcc.gnu.org/)) als auch als Entwickler (bei Transmeta haben wir für alles CVS genutzt) kennengelernt und hatte wirklich eine tiefe Abneigung dagegen.\n\n\u003Cimg src=\"https://about.gitlab.com/images/blogimages/linustorvalds.png\" align=\"left\" width=\"200px\" style=\"padding-right: 20px; padding-bottom: 10px\"/>\n\nDamals wechselten die meisten Projekte, die CVS verwendeten, vermutlich zu [SVN](https://subversion.apache.org/), aber für mich war das ehrlich gesagt nur Schönrederei. SVN war ja nichts als CVS in einer anderen Form und mit einem geringfügig besseren UI, aber die grundlegenden Dinge waren nicht besser und es wurden sogar einige neue Probleme hinzugefügt.\n\nEs gibt zu viele Probleme mit CVS und den anderen Lösungen, um sie hier alle aufzulisten. Glücklicherweise wurden sie alle zum Großteil obsolet und junge Entwickler(innen) müssen sich wahrscheinlich nie mit einem dieser Systeme beschäftigen. Ich weigerte mich also kategorisch, für den Kernel damit zu arbeiten, auch wenn wir für die Nachverfolgung des Codes einiger Untersysteme (vor allem beim Netzwerk) in den 90ern tatsächlich CVS verwendeten.\n\nDamals lebte ich in der Bay Area. Larry McVoy, den ich von früheren Projekten kannte (vor allem von [Imbench](https://www.usenix.org/legacy/publications/library/proceedings/sd96/full_papers/mcvoy.pdf)), hatte BitMover gegründet, bei dem ein neues Versionskontrollmodell namens BitKeeper, oder kurz BK, verwendet wurde.\n\nBK war zwar nicht Open Source, aber Larry hatte eine Vorliebe für Open-Source-Projekte und hatte das Gefühl, dass die fehlende Versionskontrolle die Entwicklung des Kernels wirklich ausbremste. Er hatte nicht unrecht, aber die traditionelle Quellcodeverwaltung funktionierte für mich einfach nicht. Larry verbrachte einige Zeit damit, mir und David Miller (einem Netzwerkbetreuer und bestehendem CVS-Benutzer) zu zeigen, was BitKeeper alles konnte.\n\nBK war nicht perfekt und basierte wie so viele andere Systeme zur Quellcodeverwaltung auf dem Source Code Control System (SCCS) und setzte daher wie alle anderen auf dasselbe unzureichende Modell mit „dateibasiertem Verlauf“. Dieses verursachte riesige, fundamentale Probleme, wenn Dateien umbenannt und gelöscht wurden.\n\nAndererseits war BK nicht nur reine Schönrederei. Es basierte zwar grundlegend auf SCCS, aber auf höherer Ebene behob es einige wirklich fundamentale Probleme und ermöglichte eine echte verteilte Entwicklung. Zudem hatte es einen echten globalen – keinen reinen dateibasierten – Verlauf, sodass es tatsächlich Code von verschiedenen Entwicklungszweigen zusammenführen konnte.\n\nMit CVS war das Erstellen von Branches und deren Zusammenführung etwas, das man mit anderen planen und besprechen musste – also ein großes Ereignis. Mit BK war jedes Repository ein Branch. Heute halten wir das für selbstverständlich, und natürlich ist Git noch viel weiter gegangen: Es gibt viele Branches *pro* Repository. Doch auch das viel eingeschränktere Modell von BK war zu diesem Zeitpunkt ein echter Wendepunkt.\n\nAber wie gesagt, BK war nicht perfekt. Es nutzte einen dateibasierten Verlauf, was ein fundamentales Problem ist, denn dadurch können Dateien einfach nicht zuverlässig umbenannt und zusammengeführt werden, was unvermeidlich zu Chaos und Probleme führt (alle, die CVS kennen: Denkt an Attic …). Außerdem gab es Einschränkungen bei der Skalierbarkeit. Diese wurden aber nur langsam etwas problematischer.\n\nDas größte Problem bei BK war die Lizenzierung. Auch wenn im Laufe der Jahre (wir verwendeten BK von 2002 bis 2005) viele Kernel-Betreuer(innen) zu diesem System wechselten, gab es immer wieder Schwierigkeiten damit. Diese Schwierigkeiten spitzten sich Ende 2004 zu, als der Einsatz von BK für den Kernel einige Monate später praktisch nicht mehr möglich war.\n\nIch war nun in der Situation, dass ich drei Jahre lang endlich eine Versionskontrolle verwendet hatte, die tatsächlich funktionierte und viele Probleme gelöst hat. Ich wollte also keinesfalls wieder zum Zustand vor der Versionskontrolle zurückkehren, doch in den Jahren, in denen wir BK eingesetzt hatten, war von der Open-Source-Community nicht wirklich eine bessere Lösung gekommen.\n\nSicher, die Leute wussten, dass CVS und SVN nicht wirklich gut funktionierten, und es gab Projekte, in denen alternative Ansätze verfolgt wurden, doch diese waren teilweise sogar noch schlechter (sie waren im Grunde einfach nur schick verpacktes Patch-Tracking). Einige dagegen hatten zwar gute Ideen, machten aber schreckliche Entwicklungsfehler (siehe [Monotone](https://www.monotone.ca/)).\n\nIch sah mich also eine Weile um und erkannte dann, dass es nur einen Ausweg gab: Ich musste meine eigene Lösung programmieren.\n\nTechnisch gesehen dauerte es nur wenige Tage, die erste Version von Git zu erstellen – das kann man alles im Git-Commit-Verlauf nachlesen. Dort sieht man wunderbar, wie es von quasi Null zu einer gerade so nutzbaren Lösung wurde, für die ich dann eine Woche später Patches veröffentlichte (und die dann einige Tage danach aktiv für den Kernel verwendet wurde).\n\nDabei wird aber die Tatsache außer Acht gelassen, dass ich bis zu diesem Zeitpunkt schon eine Weile über das Problem *nachgedacht* hatte. Programmieren ist einfach. Ein gutes Konzept ist das, was zählt. Hinter diesen wenigen Tagen steckt also einiges an Vorarbeit, die sehr wichtig ist – und das sieht man im Verlauf nicht.\n\nDiese erste Version war sehr, sehr einfach und konnte vieles von dem nicht, was später noch kommen sollte. Man kann aber auch in diesen ersten Tagen schon viel vom Kernkonzept sehen.\n\n**Kannst du uns einen kurzen Rückblick über die ersten Tage und Wochen des Git-Projekts geben?**\n\nIch hatte im Grunde beschlossen, die Kernel-Entwicklung einzustellen, bis ich eine Alternative hatte, die für mich funktionierte. Das Resultat sollte eine verteilte Entwicklung und Höchstleistung ermöglichen sowie ein System sein, mit dem man absolut verlässlich jegliche Beeinträchtigung verhindern kann.\n\nIch möchte betonen, dass ich mich nicht wirklich für Quellcodeverwaltungssysteme interessierte. Ich war am Endergebnis interessiert, nicht am Prozess. Git war mir also nie so wichtig wie der Kernel: Ich arbeite an Linux, weil ich Kernels spannend finde. Ich habe an Git gearbeitet, weil ich es musste.\n\nDamit wären wir dann auch schon bei deiner nächsten Frage.\n\n**Du hast die Rolle des Chefentwicklers von Git nach einigen Monaten an Junio Hamano übergeben, der dies noch immer ist. Warum hast du deine Position abgegeben, und warum an Junio?**\n\nDie Übergabe der Rolle war keine schwierige Entscheidung. Es war vielmehr so: „Sobald ich jemanden finde, dem ich das Projekt anvertrauen kann, gehe ich wieder zurück und arbeite nur noch am Kernel.“\n\nDas soll nicht heißen, dass ich einfach alles hingeworfen und auf das Beste gehofft habe. Ich war rund vier Monate lang Chefentwickler von Git, weil ich spürte, dass ich jemanden finden musste, der gekommen war, um zu bleiben, und der diesen ominösen „guten Riecher“ hatte.\n\nJunio war als einer der Ersten dabei – quasi ab der ersten Woche. Aber ich bin nicht einfach zu ihm hin gerannt und habe gesagt: „Du bist dran.“ Es braucht eine Weile, bis man sieht, wer wirklich dabei bleibt und wer sinnvollen Code schreibt und sinnvolle Entscheidungen trifft.\n\nUnd ich denke, Junio war ein echtes Vorbild. Ich bekomme viel zu viel Lob für die paar Monate, die ich in Git gesteckt habe – besonders angesichts des 20-jährigen Jubiläums. Ich bin zwar dafür verantwortlich, dass das Kernkonzept richtig umgesetzt und das Projekt zum Laufen gebracht wurde, aber Junio hat das Projekt wirklich geleitet (damit will ich nicht die hunderten anderen Beteiligten vergessen).\n\n**Die erste Version des Versionskontrollsystems Mercurial wurde 12 Tage nach der ersten Version von Git am 19. April 2005 veröffentlicht. Viele Leute behaupten, dass die User Experience von Mercurial der von Git überlegen war, aber heute ist Git deutlich beliebter. Warum glaubst du, hat Git sich gegen Mercurial durchgesetzt?**\n\nOh, ein großer Teil davon sind offensichtlich nur Netzwerkeffekte, und Quellcodeverwaltungssysteme haben sehr starke Netzwerkeffekte. Deshalb hat CVS trotz all seiner Einschränkungen so lange überlebt.\n\nDer Kernel verwendete Git und es wurde irgendwann in der Community von Ruby on Rails sehr beliebt – und dann setzte es sich überall durch.\n\nAber ich bin wirklich überzeugt, dass das Konzept von Git besser ist. Das Kernmodell ist sowohl sehr einfach als auch sehr leistungsfähig, und ich denke, das machte es einfacher, es in andere Umgebungen zu übertragen. JGit war ein frühes Beispiel dafür, aber es gibt natürlich Implementierungen wie das virtuelle Dateisystem MSgit usw.\n\nWährend Git anfangs berühmt-berüchtigterweise schwierig zu nutzen war, glaube ich, dass vieles davon darauf zurückzuführen ist, dass die Leute Dinge zuvor „richtig“ machen mussten. Die Leute kamen nämlich von anderen Umgebungen und fanden Git nicht intuitiv, da Git ein paar harte Entscheidungen getroffen hatte, die Nutzer(innen) von herkömmlichen Quellcodeverwaltungssystemen niemals gemacht hätten.\n\n**Das Git-Projekt ist nie stehengeblieben, seit du die Rolle des Chefentwicklers an Junio übergeben hast, und die Community arbeitet kontinuierlich an neuen Funktionen. Was waren deiner Meinung nach die wichtigsten Meilensteine, nachdem du das Projekt verlassen hast?**\n\nDas ist schwer zu beantworten, da ich Git ja so entwickelt hatte, dass es für mich funktionierte. Die Dinge, die *ich* verwende, haben also quasi vom ersten Tag an funktioniert. Ein offensichtliches Beispiel: Für viele Leute war es offensichtlich ein riesiger Schritt, Git auf Windows zum Laufen zu bringen, aber *mich* betraf das überhaupt nicht. ;-)\n\nGit hat ja auch eine ganze Infrastruktur, mit der es einfacher zu nutzen ist. Die größten Meilensteine entstanden meiner Meinung nach aber, als die Menschen die Git-Infrastruktur heranzogen und Dinge darauf aufbauend entwickelten. Diese fließen natürlich oft auch wieder in Git-Funktionen ein, aber gleichzeitig ist der Meilenstein etwas Externes.\n\nEin offensichtliches Beispiel: Alle großen Git-Hosting-Websites waren große Meilensteine. Dadurch, dass Git verteilt war, waren diese viel einfacher zu entwickeln, aber der *Meilenstein* war dann, dass das Hosting es den Benutzer(innen) so einfach machte, Git für verschiedenste Projekte zu nutzen.\n\n**Wenn du wieder in der Lage wärst, hauptberuflich an Git zu arbeiten, gäbe es etwas, das du gerne implementieren würdest?**\n\nAuf keinen Fall. Git hat von Anfang an alles getan, was ich brauchte – ich nutze es tatsächlich nur ziemlich eingeschränkt, und mir ist nur ein Projekt wichtig.\n\nUnd ich sage „Auf keinen Fall“, weil ich mich auf eine meiner früheren Antworten beziehe: Ich war noch nie wirklich an Quellcodeverwaltungssystemen interessiert. Ich denke, ein wichtiger Grund dafür, dass Git sich von anderen Quellcodeverwaltungssystemen so sehr unterscheidet – größtenteils im positiven Sinne – ist, dass ich Git eher wie ein verteiltes Journaling-Dateisystem angegangen bin und nicht wie eine herkömmliche Quellcodeverwaltung.\n\n**Gibt es eine Funktion oder eine konzeptionelle Entscheidung in Git, die du im Nachhinein bereust?**\n\nKonzeptionelle Entscheidungen? Nein. Ich bin immer noch überzeugt, dass das übergeordnete Konzept sehr gut ist. Man kann verschiedene Git-Konzepte diskutieren, ohne auf die kleinteilige Komplexität der eigentlichen Implementierung eingehen zu müssen.\n\nUnd ich denke, das ist wichtig in einem Projekt. Man benötigt ein bestimmtes übergeordnetes Prinzip, dem die konzeptionelle Ausrichtung eines Projekts folgt.\n\nManchmal treiben die Leute das zu weit und denken, dass das übergeordnete Konzept bedeutet, dass die Implementierung dann sklavisch einem Kernprinzip folgen muss. Das ist aber auch falsch – die *Implementierung* hat viele hässliche Grenzfälle, da die Realität nun einmal hart ist und Menschen seltsame Dinge wollen. Es ist schon eine Art übergeordnetes Konzept nötig, auf das man sich beziehen kann und über das man auf übergeordneter Ebene argumentieren kann, bevor man sich die Hände an der harten Realität schmutzig macht.\n\nIch denke, Git hat da ein gutes Gleichgewicht gefunden. Ein sehr geradliniges Objektspeicher-Konzept („strukturierte Merkle-Bäume“, wenn du aus dem CS-Bereich kommst, oder stell sie dir einfach als „inhaltsadressierbaren Speicher“ vor, wenn du aus dem Dateisystem-Bereich kommst). Dieses Kernkonzept ist da, ist aber gleichzeitig in der Realität nur ein winziger Teil des eigentlichen Codes. Der größte Teil des *Codes* betrifft all die Dinge, die man mit dem Kernkonzept machen kann. Diese grundlegende konzeptionelle Klarheit gibt dem Projekt trotzdem eine Art übergeordnete Struktur.\n\nEs ist die gleiche Art von übergeordneter Struktur, die Unix selbst hatte, von „alles ist eine Datei“ bis hin zur Prozessabwicklung. Es gibt zwar ein paar übergeordnete „Konzepte“, aber bei 99 % des Codes geht es ganz einfach darum, das, was man auf diesem Design aufgebaut ist, so zu gestalten, dass es uns in der realen Welt nutzt.\n\nIch habe zwei Mantras hinsichtlich der Technologie: „Wenn ich weiter geblickt habe, so deshalb, weil ich auf den Schultern von Riesen stehe“ (Newton) und „Genie ist 1 % Inspiration und 99 % Prozent Transpiration“ (Edison).\n\nAber da wir schon über die 99 % Transpiration sprechen: Obwohl ich mit dem Gesamtdesign sehr zufrieden bin, gibt es sicherlich verschiedene Details, die ich anders gemacht hätte, wenn ich Git heute entwickeln würde.\n\nEhrlich gesagt, sind sie aber nicht so wichtig. Viel wichtiger sind all die *guten* Details, die in den letzten zwei Jahrzehnten entwickelt wurden.\n\n**Im Linux-Kernel wurde Rust als Programmiersprache für einige der Subsysteme eingeführt. Glaubst du, dass es sinnvoll ist, solche neueren Programmiersprachen auch in Git zu verwenden?**\n\nIch vermute, dass es bei Git weniger Gründe gibt, Sprachen zu mischen, was immer etwas schwierig ist.\n\nIm Kernel ist das Endergebnis eine einzige Kernel-Binärdatei – auch wenn der Großteil davon dynamisch als Module geladen werden kann, sind sie immer noch effektiv in einer einzige Binärdatei verbunden.\n\nDas macht die Verwendung mehrerer Sprachen komplexer. Andererseits gibt es für den Kernel auch mehr Gründe, sich mit der Speichersicherheit und folglich mit neueren Sprachen zu befassen.\n\nWenn jemand Teile von Git in Rust oder einer anderen Programmiersprache schreiben möchte, ist es vermutlich viel sinnvoller, einfach eine separate Implementierung zu erstellen, anstatt zu versuchen, in einer Binärdatei mehrere Sprachen zu mischen.\n\nDie Kernideen von Git sind im Grunde so einfach, dass es vermutlich nicht allzu schwierig ist, einfach parallele Implementierungen des Kernel zu haben. Dann kann man bestimmte Problembereiche gezielt angehen, in denen unterschiedliche Sprachen sinnvoll sind.\n\nDas haben wir natürlich schon in Git gesehen: Genau das ist JGit. Hier wurde eine andere Programmiersprache verwendet, die sinnvoller für die webbasierte Umgebung war.\n\nIch weiß, dass es bereits Rust-Implementierungen einiger der Kernfunktionen von Git gibt. Hier ist die Situation vermutlich ähnlich: Sie werden in bestimmten Situationen sinnvoller sein als einfach alles in Rust umzuwandeln.\n\nAllen, die sich für die Implementierung mit Rust interessieren, empfehle ich, nach Bereichen Ausschau zu halten, in denen die Vorteile von Rust offensichtlicher sind. Ich glaube nicht, dass die Verwendung von C für den Standard-Quellcode von Git wirklich so problematisch ist.\n\n**Alle paar Jahre tauchen neue Versionskontrollsysteme auf. Glaubst du, dass Git auch in Zukunft vorne dabei bleiben wird?**\n\nIch habe bereits die Netzwerkeffekte bei Quellcodeverwaltungssystemen erwähnt. Meiner Meinung nach muss ein neues System daher nicht einfach nur ein bisschen, sondern viel, viel besser sein, um Git zu ersetzen. Oder aber so kompatibel, dass es dann eigentlich nur eine neue Implementierung von Git ist.\n\nIch denke, dass sich die Situation in der Quellcodeverwaltung geändert hat: Git hat nicht die riesigen, fundamentalen Lücken, die Quellcodeverwaltungssysteme vor Git hatten. Es ist also ziemlich schwer, „enorm besser“ zu sein.\n\nAlso, ja, ich gehe davon aus, dass Git auf absehbare Zeit vorne dabei bleibt und die Leute eher an Verbesserungen *an* Git arbeiten als an Ersatzlösungen.\n\n*Hinweis: Dieses Interview wurde aus Platzgründen und zur besseren Übersichtlichkeit bearbeitet.* \n\n## Erfahre mehr über Git\n\n- [Was gibt es Neues in Git 2.49.0?](https://about.gitlab.com/de-de/blog/whats-new-in-git-2-49-0/)  \n- [Was gibt es Neues in Git 2.48.0?](https://about.gitlab.com/de-de/blog/whats-new-in-git-2-48-0/)\n- [Der Anfängerleitfaden zum „reftable“-Format von Git](https://about.gitlab.com/de-de/blog/a-beginners-guide-to-the-git-reftable-format/)\n- [Git-Projekt](https://git-scm.com/)",[896,1058],{"slug":1071,"featured":91,"template":797},"celebrating-gits-20th-anniversary-with-creator-linus-torvalds",{"content":1073,"config":1080},{"title":1074,"description":1075,"authors":1076,"heroImage":1077,"date":820,"body":1078,"category":755,"tags":1079},"Open Source & OSS: Was es ist, was es dir bringt","Der ultimative Open-Source-Software-Guide: OSS Definition, Beispiele, Projekte, Empfehlungen und Hilfe bei der Umsetzung.",[789],"https://res.cloudinary.com/about-gitlab-com/image/upload/v1749690483/Blog/Hero%20Images/blog-image-template-1800x945__11_.png","# Open Source & OSS: Was es ist und was es dir bringt\n\nUm Open-Source-Software (OSS) ranken sich viele Missverständnisse und scheinbare Widersprüche.\n\nEinerseits stieg die Zahl der Unternehmen in Deutschland, die OSS nutzen, alleine zwischen 2019 und 2023 um knapp 15 %: über drei Viertel aller Betriebe nutzen heute zumindest teilweise Open-Source-Software.  Und sogar die weltweit führende Unternehmensberatung PWC urteilte angesichts dieser Entwicklung: „Open-Source-Software ist mittlerweile der Stand der Technik in der deutschen Wirtschaft.” \n\nAndererseits aber fällt vielen Betrieben die praktische Einbindung von OSS in ihre IT-Struktur und Prozesse schwer. Wie auch Computer Weekly in einem ausführlichen Spezial zum Thema klarstellte: „Der Einsatz von OSS stellt insbesondere mittelständische Unternehmen häufig vor erhebliche Herausforderungen. Ohne [...] Initialinvestition wird jedes Open-Source-Projekt scheitern, ehe es begann.”\n\nDas freilich scheint der beliebten Vorstellung zu widersprechen, dass OSS sich gerade deswegen rechne, weil sie nichts koste.\n\nWie passen diese beiden Perspektiven zusammen? In diesem Artikel helfen wir dir, Antworten auf diese Frage zu finden. Wir erklären, welche Vorteile du aus OSS ziehen kannst, was dich OSS in der Praxis kostet und wie du Umsetzungsschwierigkeiten überwindest.\n\nZunächst aber:\n\n## Was bedeutet Open Source?\n\nÜblicherweise betrachten wir Open Source und Open-Source-Software als Synonyme. Aber die damit verbundene Idee – der freie Austausch bestimmter Technologien, Ideen und Konzepte – existiert schon sehr viel länger.\n\nEines der frühesten und am häufigsten angeführten Beispiele stammt aus den frühen Jahren der amerikanischen Automobilindustrie. Für einen gewissen Zeitraum beschlossen die Hersteller, neue Entwicklungen nicht zu patentieren. Der Gedanke dahinter war, dass es besser für alle Beteiligten sein könnte, wenn der Markt als Ganzes wächst. Auch heute arbeiten konkurrierende Automobilproduzenten zusammen an Open-Source-Projekten. \n\nIn den 1950ern und -60ern teilte auch IBM seine Software-Geheimnisse mit der Welt. Das war seinerzeit ein äußerst innovativer Schachzug. Doch muss man der Ehrlichkeit halber hinzufügen, dass Software damals als nahezu wertlos galt und das Unternehmen sein Geld mit dem Vermieten seiner Hardwarekomponenten verdiente.\n\nDiese frühen Open-Source-Beispiele haben eines gemeinsam: Statt die Ergebnisse der eigenen Forschungsarbeit vor anderen Betrieben zu schützen, wurden sie großzügig der Öffentlichkeit zur Verfügung gestellt.\n\n## Open-Source-Software: Definition\n\nIm Softwarebereich entfaltete der Open-Source-Gedanke eine Wirkung, die weit über die Grenzen der Branche hinausging.\n\nIn Open-Source-Projekten wie den Open-Source-Seeds – Saatgut, welches ganz gezielt nicht patentiert wird – lebt er bis heute in vielen Bereichen weiter (wohl auch deswegen, weil sich genetische Codes sehr leicht als Software betrachten lassen).\n\nDie  Definition von Open-Source-Software lautet:\n\n**Eine Software kann als Open Source bezeichnet werden, wenn ihr Quellcode offen geteilt wird und eingesehen und verändert werden kann. Anderen Programmierern steht es frei, abgeleitete Werke aus ihr zu erstellen oder die Software in ihre eigenen Projekte einzubauen.**\n\nDiese Open-Source-Software-Definition schließt noch nicht alle Details mit ein. Auch gibt es ein paar Feinheiten bei der Frage von Lizenzen zu beachten – auf diese werden wir später im Artikel noch genauer eingehen. Als Einstieg in die Thematik aber ist sie bereits sehr präzise und umfassend.\n\n## Ist OSS immer kostenlos?\n\nNein. Dieses Missverständnis rankt sich bis heute um die OSS-Thematik. Dabei wurde der Name „Open Source” bewusst gewählt, weil der ursprüngliche – „Free Software” - sich bereits als zu missverständlich erwiesen hatte.\n\nSo ist es durchaus denkbar, dass du ein Open-Source-Produkt zu einem Premium-Preis verkaufst. Solange du den Quellcode dabei offenlegst, ist das wichtigste Kriterium erfüllt.\n\nZugegebenermaßen wird Open-Source-Software in der Regel tatsächlich kostenfrei angeboten. Die meisten professionellen Anbieter basieren ihr Erlösmodell inzwischen nicht mehr auf dem Verkauf von Lizenzen, sondern auf Dienstleistungen rund um das Produkt.\n\nOpen-Source-Software versteht sich als ein Instrument für Transparenz und Innovation. Als solches folgt es auch weiterhin den Leitlinien der Free Software – auch wenn es inzwischen nicht mehr unter diesem Banner läuft.\n\nSehen wir uns die Entwicklung von Closed Software zur Free Software und von dort zur Open-Source-Philosophie ein wenig genauer an.\n\n## Von Closed Software zu Free Software\n\nFree Software ist ein Begriff aus den frühen 1980ern. Er entstand, da immer mehr Entwickler(innen) es als unethisch betrachteten, dass ihre Arbeit von großen Unternehmen oder sogar Bildungseinrichtungen wie Universitäten kommerziell verwertet wurde.\n\nAls IBM seine Betriebssysteme mit der Welt teilte, stand dahinter weder Idealismus noch Profitdenken. Es war eine Entscheidung, die nahezu nebenbei getätigt wurde und an die wohl nur wenige der Beteiligten allzu viele Gedanken verschwendeten. Doch schon bald war eine rege Industrie um den Verkauf von Softwarelizenzen zu teilweise extrem hohen Preisen entstanden. Diese kostenpflichtigen Lösungen, deren Quellcode als Betriebsgeheimnis gehütet und mit Patenten geschützt wurde, bezeichnet man als „Closed Software” oder auch als „proprietäre” (mit einem Besitzanspruch verbundene) Software.  \n\nDank des Einsatzes führender proprietärer Software erlangten finanzkräftige Betriebe oftmals einen deutlichen Wettbewerbsvorsprung. Kleine Konkurrenten mit guten Ideen, aber einem geringen Budget, gerieten demgegenüber ins Hintertreffen.\n\nFreie Software sollte allen zur Verfügung stehen. Durch das Freilegen des Source Codes wurde es möglich, die Funktionalität in eigene Software-Lösungen einzubauen und somit die Effizienz in der Software-Entwicklung zu steigern.\n\n## Von Free Software zu Open-Source-Software\n\nDe Begrifflichkeit von „Free Software” war von Anfang ein Problem. „Free” sollte sich auf die freie Verwendung beziehen, nicht auf eine kostenlose Nutzung. Um diesen Gedanken klarer hervorzuheben, entschied man sich schließlich für eine Umbenennung.\n\n„Open Source” drückt genau aus, worum es wirklich geht – nämlich um den Quellcode, der die Grundlage der Funktionalität bildet.  \n\nHeute koexistieren beide Konzepte und ihre Schwerpunkte unterscheiden sich marginal:  Die Free-Software-Community beispielsweise versteht sich als philosophisches und politisches Fundament für die gesamte Branche, auf der letzten Endes auch konkreter gefasste Konzepte wie OSS (Open-Source-Software) aufbauen.\n\n## Open-Source-Software: Beispiele\n\nEs gibt inzwischen unzählige Beispiele für die Verwendung von Open Source in der Entwicklung neuer Software.\n\nDas erste Beispiel, mit dem die meisten Privatnutzer(innen) konfrontiert wurden, war zweifelsohne der Firefox-Internetbrowser. Vor dem Markteintritt war der Markt zunächst von einem Browser dominiert worden, der kostenlos, aber nicht Open Source war (Altavista), dann von einem, der fest mit dem proprietären Microsoft Windows Betriebssystem verbunden war (Internet Explorer). Firefox bot eine hervorragende und für seine vielen Add-ons gepriesene Open-Source-Alternative.\n\nSeitdem ist Open Source zum dominanten Distributions- beziehungsweise Lizenzierungsmodell aufgestiegen. Das Online-Wirtschaftsmagazin Deutsche Startups hat für verschiedene Branchen eine hervorragende Übersicht zusammengestellt:\n\n**Entwicklungswerkzeuge:** Python, Ruby und OGC sind Beispiele für Open-Source-Tools, auf die Entwickler zurückgreifen können.\n\n**Datenbanken:** MySQL, die führende Datenbanklösung weltweit, ist als Open Source angelegt. Gleiches gilt auch für konkurrierende Produkte wie PostgreSQL oder MongoDB. Anverwandte Lösungen wie [Kubernetes](https://about.gitlab.com/de-de/solutions/kubernetes/) sind ebenfalls Open-Source-Software, genauso wie der Dateimanager FreeCommander.\nGrafikdesign und Multimedia: GIMP oder Blender sind hervorragende Tools für alle, denen lizenzpflichtige, proprietäre Produkte zu teuer sind. Der VLC-Mediaplayer stellt die Funktionalität der meisten Nicht-Open-Source-Player in den Schatten.\n\n**Webtechnologie:** Einige grundlegende Technologien wie PHP erfüllen die Kriterien von Open Source.\n\n**Anderes:** LibreOffice und OpenOffice sind komplett als Open-Source-Anwendungen angelegt. Das E-Mail-Verwaltungsprogramm Thunderbird läuft ebenfalls unter einer Open-Source-Lizenz.\n\n## Was erhoffen sich Unternehmen von Open-Source-Software?\n\nVielleicht denkst du auch darüber nach, die IT deines Unternehmens so weit wie möglich auf eine Open-Source-Basis zu stellen. Damit stehst du, wie bereits erwähnt, nicht alleine da. Genau genommen sind Firmen, die ausschließlich auf proprietäre Lösungen setzen, inzwischen zur Minderheit geworden.\n\nFür die meisten Unternehmen spielen dabei die folgenden Überlegungen eine zentrale Rolle:\n\nOpen-Source-Software kann dazu beitragen, deine IT-Kosten zu senken.\nOpen-Source-Software ist flexibel und kann somit einfacher an persönliche Bedürfnisse angepasst werden.\n\nOpen-Source-Software genießt den Ruf, weniger Speicherkapazität zu verbrauchen und somit die Leistungsfähigkeit des Systems zu verbessern.\n\nOpen-Source-Software gilt als innovativer und anpassungsfähiger an sich wandelnde Marktbedingungen.\n\nWie nehmen sich diese vermeintlichen Vorteile in der Praxis aus? Werfen wir einen genaueren Blick auf OSS als Faktor in deinem Unternehmen.\n\nEinen Punkt können wir dabei nicht genug betonen:\n\n## OSS ist kein Business-Modell\n\nWie erwähnt erhoffen sich Unternehmen viel von OSS und sind enttäuscht darüber, wenn sich diese Erwartungen nicht erfüllen. Vor allem die finanziellen Auswirkungen stellen sich oftmals ganz und gar nicht so dar, wie erwartet.\n\nAuf die genauen Gründe dafür gehen wir noch genauer ein. Du solltest dir aber immer vor Augen führen, dass Open Source an sich niemals ein Geschäftsmodell darstellt, nicht einmal für die Unternehmen, die Software unter einer Open-Source-Lizenz vertreiben!\n\nOpen-Source-Software ist ein Konzept, das aus der Informations- und Datenfreiheitsbewegung stammt. Es erleichtert bestimmte Methoden und Vorgehensweisen, macht andere aber möglicherweise komplexer und aufwendiger.\n\nDu kannst Open Source nutzen, um deinen Geschäftserfolg zu steigern. Die Konzepte dafür aber musst du immer noch selbst entwickeln.\n\n## Warum manche Unternehmen trotzdem auf proprietäre Lösungen setzen\n\nDer Siegeszug von Open Source ist unbestreitbar. Letzten Endes lässt er sich auch damit begründen, dass kostenlose Software nahezu immer eine unwiderstehliche Anziehungskraft ausübt; sogar dann, wenn es vollkommen klar ist, dass der „Preis Null” teilweise teuer erkauft werden muss.\n\nUnd dennoch lebt Closed Software auch weiterhin fort. Wie kommt es dazu?\n\nZum einen bleibt es ungemein zufriedenstellend, wenn ein Softwarepaket so umfassend ist, dass es nicht nur sofort benutzt werden kann, sondern gleich alle erforderlichen Komponenten mitliefert. In vielen Bereichen sind proprietäre Produkte schlicht professioneller und umfassender. LibreOffice und Open Office sind hervorragend. An Office aber reichen sie noch immer nicht heran.\n\nWas noch schwerer wiegt: Bei OSS kommt es leichter zu Kompatibilitätsproblemen. Das ist bei Dokumenten wie Word noch zu verschmerzen. Bei komplexeren Fällen aber kann es den Entwicklungsprozess langsamer, fehleranfälliger oder sogar unmöglich machen.\n\nUnd obwohl manche Closed-Software-Anbieter langsamer auf Kundenanfragen reagieren als ihre Open-Source-Gegenspieler, so zeichnen sich andere durch prompte Reaktionen und schnelle Updates aus. Trotzdem ist es immer beruhigend, wenn dir bei Schwierigkeiten ein direkter Ansprechpartner zur Verfügung steht (weswegen dieser Aspekt inzwischen auch bei vielen OSS-Produkten berücksichtigt wird).\n\n## Die wahren Vorteile von Open-Source-Software\n\nEinige der von Unternehmer(innen) erwarteten Vorteile von Open Source sind durchaus berechtigt: So erhöht OSS in der Tat die Transparenz der verwendeten Software. Da du den Quellcode einsehen kannst, kannst du ihn nun potentiell nach deinem Geschmack anpassen, erweitern oder kürzen. Du kannst ihn in Software-Pakete einbauen, die du selbst entwickelst und damit den Aufwand deutlich reduzieren.\n\nAuch zeichnen sich viele Open-Source-Programme durch eine hohe Innovationskraft aus. Die dahinter stehenden Communities sind dynamisch, offen und helfen Neulingen in der Regel gerne.\n\nDarüber hinaus sind noch die folgenden Vorteile zu nennen:\n\nDurch die ständige praktische Prüfung durch andere Anwender(innen) erhalten die Entwickler(innen) der Software einen stetigen Feedback-Strom, der als Ausgangspunkt für Updates oder neue Versionen dienen kann.\nLangfristige Anwendbarkeit: Kommerzielle, proprietäre Software wird oftmals so schnell wie eine schlecht laufende Fernsehserie wieder vom Markt genommen, wenn sich der Verkaufserfolg nicht einstellt. Open-Source-Projekte sind nicht an solche Erwägungen gebunden und können auch über die ursprünglichen Entwickler hinweg Bestand haben.\n\nIst OSS tatsächlich kostengünstiger? Wir meinen: Es kommt auf das konkrete Beispiel an, aber in der Regel schon.\n\nOSS verursacht zusätzliche Kosten durch die Notwendigkeit von Schulungeneiner genaueren Zusammenstellung der Komponenten sowie einer feinen Abstimmung zwischen den Bausteinen. Gerade bei sehr teuren Einzelplatzlizenzen aber bleibt OSS die günstigere Alternative.\n\n## Die drei Lizenzmodelle von Open-Source-Software\n\nAn dieser Stelle macht aus unserer Sicht ein kleiner Einschub Sinn. Denn es könnte inzwischen der Eindruck entstanden sein, dass OSS als offenes, oftmals kostenlos angebotenes Produkt im Widerspruch zu Lizenzmodellen steht.\n\nDem ist aber nicht so. In Wahrheit ist auch Open-Source-Software nahezu immer mit einer bestimmten Lizenz verbunden. Diese Lizenzen regeln die Weiterverwendung der Software und sind sogar von essenzieller Bedeutung dafür, dass die Grundgedanken der Open-Source-Bewegung auch tatsächlich gewahrt bleiben.\n\nDie folgenden drei Lizenzen sind üblich:\n\n**Copyleft-Lizenz:** Hierbei handelt es sich um die strengste Lizenz. Sie schützt die ursprünglichen Freiheiten der Software und zwingt alle Nutzer(innen) der Software, jedwede Folgeprodukte unter den selben Lizenzbedingungen zu vertreiben oder anzubieten.\n\n**Beschränkte Copyleft-Lizenzen:** Bei manchen Produkten kann die Lizenz der Bearbeitungen teilweise abweichen. Dies räumt den Anwender(inne)n und Entwickler(inne)n mehr Freiheiten ein.\n\n**Permissive Lizenzen:** Kommen ohne Anweisungen aus. Was für OSS bedeutet, dass es den Bearbeiter(innen) frei steht, welche Lizenzbedingungen für die Ergebnisse ihrer Arbeit gelten sollen.\n\nBei allen Lizenzen kannst du für deine Produkte und deine Arbeit Geld verlangen. Darauf gehen wir  gleich noch ein.\n\n## Open Source & Agile-Methodik\n\nEin wichtiger Grund, warum Open Source in der Softwareentwicklung nahezu sofort auf ein so breites und positives Echo gestoßen ist, liegt in seiner Nähe zur agilen Methodik.\n\nBei [Agile Delivery](https://about.gitlab.com/de-de/solutions/agile-delivery/) steht ein Prozess im Fokus, bei dem durch das fortlaufende Einholen von Daten und einer Formalisierung des Austauschs im Team schnell und regelmäßig funktionierende Prototypen entwickelt werden.Diese dienen dann wiederum als Basis für weitere Optimierungen.\n\nIn beiden Ansätzen stehen Transparenz, Offenheit, schnelles Agieren, Teamarbeit, Kundenorientierung und ein schneller Weg zum fertigen Produkt im Mittelpunkt. Im Gegensatz zu proprietären Lösungen sind Open-Source-Produkte niemals wirklich fertig, sondern immer nur ein Zwischenstand.\n\nDu wirst feststellen, dass es dir deutlich leichter fällt, OSS in deinem Betrieb einzuführen, wenn du bereits Erfahrungen mit agilen Methoden gemacht hast.\n\n## Fallbeispiel 1: Linux\n\nDie möglicherweise bekannteste Open-Source-Software überhaupt ist Linux.\n\nLinux ist zu 100 % Open Source und der Quellcode ist somit frei einsehbar. In einer faszinierenden Entwicklung hat sich hieraus eine Vielzahl sogenannter „Distributionen” herausgebildet. Darunter versteht man eine bestimmte Konfiguration von Linux mit einer eigenen Anwendungsoberfläche und einer Palette zugehöriger Tools.\n\nLinux weist gegenüber Windows eine Vielzahl genau derjenigen Vorteile auf, die wir oben genannt haben: Es ist deutlich effizienter/schneller, flexibler und günstiger. Gerade seine einzigartige Anpassungsfähigkeit hat ihm zur Führerschaft im Serverbereich verholfen.\n\nGleichzeitig aber ist es auch komplizierter, sowohl was die Installation und den praktischen Einsatz angeht, und auf ein gut vorbereitetes IT-Team angewiesen.\n\nDas Besondere an Linux ist, dass die verschiedenen Distributionen unter unterschiedlichen Lizenzen vertrieben werden. So gibt es komplett kostenlose und sehr minimalistisch gehaltene Versionen; Varianten, die auf innovative Entwickler zugeschnitten sind; und zu guter Letzt Komplettpakete, die genauso komfortabel und komplett sind wie kommerzielle Closed Software (und entsprechend auch deutlich teurer).\n\nLinux ist ein Paradebeispiel dafür, wie vielseitig Open Source in der Praxis sein kann.\n\n## Fallbeispiel 2: GitLab\n\nAuch GitLab wurde von Anfang an und aus Überzeugung als Open-Source-Projekt angelegt.\n\nWas bedeutet OSS für uns konkret?\n\n*Der Quellcode von GitLab wurde unter einer MIT Open-Source-License veröffentlicht und kann frei eingesehen werden.\nWir freuen uns immer über Vorschläge zu Verbesserungen oder Erweiterungen. Im [GitLab-Forum](https://forum.gitlab.com/c/community/gitlab-for-open-source/49) findest du darüber hinaus andere Entwickler(innen), mit denen du dich spezifisch zu Open-Source-Themen austauschen kannst. \nMit dem GitLab-Development-Kit bieten wir eine Möglichkeit an, selbst aktiv den Quellcode an persönliche Präferenzen und Bedürfnisse anzupassen.\nIn unseren Repositories liegen unzählige Open-Source-Projekte.\nMit dem GitLab-for-Open-Source-Program unterstützen wir das Anlegen neuer OSS-Projekte, von denen die gesamte Community profitiert.*\n\nBei GitLab ist Open Source keine trockene Theorie. Beeindruckend ist zum Beispiel wie sich der Content-Management-Anbieter Drupal zu seinem 20-jährigen Jubiläum neu erfand und seine Dienstleistungen mit GitLab für neue Zielgruppen öffnete. Mehr dazu findest du in unserem Artikel über GitLab-Open-Source-Case-Studies.\n\nGerne stellen wir dir eine kostenlose [30-Tage-GitLab-Test-Lizenz](https://gitlab.com/-/trials/new) zur Verfügung. \n\n## OSS: Herausforderungen bei der Umsetzung\n\nAus der Sicht von Computer Weekly liegt der Hauptgrund dafür, dass viele Open-Source-Projekte in der Umsetzung scheitern, darin, dass nicht ausreichend Expertise im Unternehmen vorhanden ist.\n\nAus der Sicht des Magazins „müssen Unternehmen bereits vorab Zeit und Ressourcen investieren, um die erforderlichen Fähigkeiten und Kenntnisse aufzubauen oder externe Unterstützung in Anspruch zu nehmen – ob nun über einen Partner oder das Recruiting neuer Fachkräfte.”\n\nComputer Weekly betont auch, dass einer der potenziellen Vorteile von OSS – die Dynamik der Community und die Vielzahl von Lösungen, die nahezu täglich erscheinen – für manche Betriebe zu einem Nachteil werden kann. Beispielsweise, wenn die Optionen nicht mehr überschaubar sind und vor allem die Zusammenstellung der richtigen Komponenten sich als zu komplex und aufwändig gestaltet.\n\nDie Expertin Marieke Merkle empfiehlt deswegen ein Risk Mapping: \n\n„Bei einem solchen werden die Risiken identifiziert, welche mit dem konkreten im Unternehmen bereits erfolgenden oder geplanten Einsatz von Open-Source-Software verbunden sind. Auf dieser Grundlage kann ein Compliance-Prozess zunächst für denjenigen Einsatzbereich aufgebaut werden, bei welchem die größten Risiken bestehen. Im Anschluss kann die Compliance-Struktur sodann auf weitere Einsatzbereiche von Open-Source-Software ausgedehnt werden.”\n\n## Wie sieht die Zukunft von OSS aus?\n\nVorhersagen im IT-Bereich sind generell schwierig. In diesem Fall aber deuten sich doch einige klare Trends an:\n\nOSS wird weiter alle Bereiche der Industrie erreichen. Chief Visionary Officer der Firma Telmekom, Sergio Vemic, sagt dazu: „Ich glaube, dass Open Source in Zukunft immer wichtiger wird. Immer mehr Menschen werden sich damit beschäftigen, werden sie weiterentwickeln und pushen. Auch Firmen, die heute proprietäre Software anbieten, werden sich überlegen, diese künftig vielleicht als Open Source zu veröffentlichen.”\n\nOSS wird einen erheblichen Schub erfahren durch die weltweite Bevorzugung von Open-Source-Produkten im öffentlichen Sektor. Die Europäische Union nimmt hier bereits eine Vorreiterrolle ein.\n\nIn einigen Schlüsselindustrien wird OSS sich zu einer ernstzunehmenden Alternative zu Closed Software entwickeln. Dazu zählen zum Beispiel Edge Computing, [DevOps](https://about.gitlab.com/de-de/solutions/devops-platform/), Container-Orchestrierung sowie natürlich KI.\n\nGleichzeitig sehen einige Experten, dass bei vielen Investoren eine zunehmende Skepsis besteht, ob diese Projekte tatsächlich eine nennenswerte Rendite abwerfen können. Wir haben es bereits erwähnt: Open Source ist kein Business-Modell – aber es kann gelegentlich durchaus einem lohnenswerten Geschäft im Weg stehen! Es bleibt also weiterhin spannend. \n\n## Was sind die Potentiale von OSS und KI?\n\nKünstliche Intelligenz und Open-Source-Software sind die vielleicht stärksten aktuellen Trends im Bereich der Softwareentwicklung. So kann es kaum verwundern, dass sich eine gemeinsame Betrachtung lohnt.\n\nDas Institut für Innovation und Technik in Berlin stellt hierzu die alles entscheidende Frage: „Was bedeutet Open Source für Künstliche Intelligenz (KI)?” Die Analyse geht auf einige faszinierende Fälle ein, in denen Künstliche Intelligenz in der Open-Source-Software-Entwicklung bestimmte Projekte ermöglicht  hat, die in einem proprietär-kommerziellen Umfeld schlicht nicht zustande gekommen wären. Dazu gehört unter anderem ein Übersetzungs-Tool für verschiedene afrikanische Sprachen. \n\nSchon heute gibt es auch für Entwickler eine Vielzahl von OSS-Lösungen mit einem signifikanten KI-Anteil. Dazu gehören FauxPilot (Entwicklungstool), DALL-E (Text-to-Word-Anwendung) oder PaddleNLP (NLP-Bibliothek). Weitere KI- & OSS-Beispiele finden sich in einem Artikel der Computerwoche. \n\nMan kann aber auch fragen: Was bedeutet Künstliche Intelligenz für Open Source? Avi Press, CEO von Scarf, einem Unternehmen an der Schnittstelle zwischen KI, OSS und Kund(inn)en, meint dazu: \n\n„Ein zunehmender Anteil des (Open-Source- und sonstigen) Codes, auf den wir uns verlassen, wird von KI und nicht von Menschen geschrieben werden ... und wir wissen noch nicht, wie wir mit all den Auswirkungen einer Welt umgehen sollen, in der Menschen nicht die einzigen Hauptakteure sind.”\n\nEines steht fest: KI und OSS werden beide wachsen und sie werden gemeinsam wachsen. Die Ergebnisse aber werden zumindest teilweise das, was wir uns vorstellen können, um ein Vielfaches übersteigen.\n\n## Werden wir jemals ganz ohne Closed Software auskommen?\n\nDiese Vermutung bietet sich angesichts der oben genannten Entwicklungen und Tendenzen geradezu an.\n\nSicher ist, dass OSS entweder als eigenständiges Produkt oder Komponente einer größeren Software-Architektur an Bedeutung gewinnen wird. Genau so sicher ist aber, dass es auch in Zukunft Bereiche geben wird, in denen Unternehmen auf Closed Software setzen werden:\n\nTechnologien, mit denen sich in einem proprietären Umfeld höhere Gewinne erzielen lassen.\nTechnologien, die selbst entwickelt und nun intern genutzt werden und die einen signifikanten Vorsprung gegenüber der Konkurrenz gewährleisten.\nTechnologien, bei denen ein extrem hohes Maß an [Sicherheit / Security Compliance](https://about.gitlab.com/de-de/solutions/security-compliance/) gefordert ist. Es scheint unwahrscheinlich, dass Banken in absehbarer Zeit auf einen breiten oder gar exklusiven Einsatz von OSS setzen werden.\n\nEs gibt allerdings bereits Bemühungen, Schwachpunkte von OSS systematisch auszumerzen. Wenn diese greifen, steht einer noch weitflächigeren Verwendung von Open Source auch in sicherheitskritischen Industrien nichts mehr im Weg.",[551,896],{"slug":1081,"featured":6,"template":797},"what-is-open-source-software",{"category":90,"slug":765,"posts":1083},[1084,1097,1107],{"content":1085,"config":1095},{"heroImage":1086,"body":1087,"authors":1088,"updatedDate":938,"date":1091,"title":1092,"tags":1093,"description":1094,"category":765},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1750440008/myqt5vcjlffh8sszw507.png","GitLab und IBM haben sich zusammengeschlossen, um eine grundlegende Diskrepanz in der Unternehmensentwicklung zu lösen: Mainframe-Entwickler(innen) sollen mit denselben modernen Tools, Workflows und Kollaborationsfunktionen arbeiten können wie ihre Kolleg(inn)en in verteilten Umgebungen.\n\nGitLab Ultimate für IBM Z, eine von GitLab zertifizierte, integrierte DevSecOps-Lösung, die speziell für die Mainframe-Umgebung entwickelt wurde, macht genau das möglich: Sie ermöglicht es Unternehmen, ihre Mainframe-Entwicklungsworkflows zu modernisieren, indem eine nahtlose Migration von veralteten Legacy-Bibliotheksmanagern erleichtert wird. Mit CI/CD-Pipelines, die nativ auf IBM z/OS laufen, erleben Kund(inn)en beschleunigte Innovation und reduzierte Betriebskosten.\n\n## Herausforderungen der heutigen Mainframe-Entwicklung\n\nUnternehmen, die IBM Z-Systeme für geschäftskritische Workloads einsetzen, stehen vor Herausforderungen, für die herkömmliche DevSecOps-Tools nicht ausgestattet sind. Cloud-native Teams profitieren von modernen [CI/CD](https://about.gitlab.com/topics/ci-cd/)-Pipelines, kollaborativer Entwicklung und automatisierten Tests. Im Gegensatz dazu werden Mainframe-Teams oft zurückgelassen – sie stecken mit veralteten Tools fest, die zu kostspieligen Ineffizienzen und operativen Silos führen.\n\nTeams greifen oft auf Workarounds zurück, wie SSH-Verbindungen und manuelle Dateiübertragungen, die Sicherheitslücken schaffen und Audits erschweren. Wenn Compliance-Anforderungen streng sind, werden diese improvisierten Lösungen zu inakzeptablen Risiken. Gleichzeitig unterhalten Organisationen teure parallele Toolchains, wobei Legacy-Mainframe-Entwicklungstools Premium-Lizenzkosten verursachen, während sie im Vergleich zu modernen Alternativen nur eingeschränkte Funktionalität bieten.\n\nDiese Fragmentierung schafft zwei Probleme: langsamere Bereitstellungszyklen und Schwierigkeiten bei der Rekrutierung von Entwickler(inne)n, die modernste Prozesse erwarten.\n\n> **„GitLab Ultimate für IBM Z stellt einen wichtigen Schritt zur Bewältigung einer langjährigen Branchenherausforderung dar. IDC-Forschung zeigt, dass Mainframe-Entwickler(innen) oft mit Legacy-Tools arbeiten, die zu Bereitstellungsineffizienzen beitragen und es schwieriger machen, neue Talente anzuziehen. Mit diesem Angebot werden moderne DevSecOps-Fähigkeiten und einheitliche Workflows direkt auf den Mainframe gebracht. Dies befähigt Entwickler(innen), kollaborativer und effizienter zu arbeiten, während es Organisationen hilft, Innovation zu beschleunigen und Mainframe-Entwicklung in breitere digitale Transformationsstrategien zu integrieren.\"** - Katie Norton, Research Manager, DevSecOps und Software Supply Chain Security bei IDC\n\n## Vereinheitlichte Entwicklungsumgebungen\n\nWahre Modernisierung bedeutet mehr als nur die Aktualisierung der Mainframe-Entwicklung. Es bedeutet, eine einheitliche Plattform zu schaffen, auf der Mainframe-, Cloud-native-, Web- und Mobile-Entwicklungsteams nahtlos zusammenarbeiten.\n\nGitLab Ultimate für IBM Z ermöglicht es Entwickler(inne)n, konsistente Workflows zu verwenden, unabhängig davon, ob sie auf z/OS, Cloud oder On-Premises-Infrastruktur bereitstellen – Wissen wird zwischen Teams übertragen, anstatt in Silos zu verbleiben. Organisationen können schrittweise modernisieren, ohne Geschäftsunterbrechungen, da Legacy-Systeme weiterhin funktionieren, während Teams moderne Praktiken in ihrem eigenen Tempo übernehmen.\n\nWährend Organisationen Hybrid-Cloud-Strategien verfolgen, bietet GitLab die Grundlage für Anwendungen, die sich über Mainframe- und Cloud-native-Umgebungen erstrecken.\n\n## Was ist GitLab Ultimate für IBM Z?\n\nGitLab Ultimate für IBM Z bietet native z/OS-Runner-Unterstützung und ermöglicht eine nahtlose CI/CD-Pipeline-Ausführung direkt auf Ihrer Mainframe-Infrastruktur. Diese von GitLab zertifizierte Lösung hilft, die Notwendigkeit komplexer Workarounds zu eliminieren und gleichzeitig die Sicherheit und Zuverlässigkeit zu gewährleisten, die Ihre Unternehmensanwendungen erfordern.\n\nDie Kombination aus GitLabs umfassender DevSecOps-Plattform und IBMs tiefgreifender Mainframe-Expertise schafft etwas Einzigartiges auf dem Markt: eine zertifizierte Lösung, die eine echte Brücke zwischen unternehmenskritischen Legacy-Systemen und Cloud-nativer Innovation bietet.\n\n## GitLab Ultimate für IBM Z Funktionen\n\nGitLab Ultimate für IBM Z bietet Unternehmensteams die Tools, die sie benötigen, um die Mainframe-Entwicklung zu modernisieren und gleichzeitig kritische Geschäftssysteme zu erhalten.\n\n**Native z/OS-Runner-Unterstützung** hilft, Sicherheitsrisiken und Skalierbarkeitsengpässe im Zusammenhang mit Remote-Verbindungen zu eliminieren, während die Bereitstellung durch CI/CD-Pipelines beschleunigt wird, die direkt dort ausgeführt werden, wo sich Ihr Mainframe-Code befindet.\n\n**Einheitliches Source Code Management** modernisiert Toolchains, indem teure Legacy-Bibliotheksmanager durch GitLabs durchsuchbares, versionskontrolliertes Repository-System ersetzt werden, was zur Reduzierung von Lizenzkosten und Wartungsaufwand beiträgt.\n\n**Nahtlose Integration** mit IBM Developer for z/OS Enterprise Edition (IDzEE) liefert schnellere Software-Releases durch abhängigkeitsbasierte Builds, automatisiertes Code-Scanning und umfassende Debugging-Tools in vertrauten Entwicklerumgebungen, wodurch sowohl Qualität als auch Sicherheit verbessert werden.\n\n**End-to-End-Transparenz** über Mainframe- und verteilte Umgebungen hinweg bietet umfassendes Projektmanagement von der Planung bis zur Produktion und ermöglicht automatisierte DevOps-Workflows, die durch moderne Entwicklungstools der nächsten Generation zur Talentbindung beitragen.\n\n## Modernisiere deine Mainframe-Entwicklungsumgebung noch heute\n\nGitLab Ultimate für IBM Z ist jetzt für Organisationen verfügbar, die bereit sind, ihre Mainframe-Entwicklungserfahrung zu transformieren. Weitere Informationen befinden sich auf der [GitLab und IBM Partnerseite](https://about.gitlab.com/de-de/partners/technology-partners/ibm/).",[1089,1090],"Mike Flouton","Andy Bradfield","2025-06-20","GitLab Ultimate für IBM Z: Moderne DevSecOps für Mainframes",[284,765,109,716],"Ein neues Angebot von GitLab und IBM überbrückt Mainframe- und Cloud-native-Entwicklung mit nahtloser Integration, CI/CD-Runner-Unterstützung, End-to-End-Transparenz und Kosteneffizienz.",{"featured":91,"template":797,"slug":1096},"gitlab-ultimate-for-ibm-z-modern-devsecops-for-mainframes",{"content":1098,"config":1105},{"heroImage":1099,"body":1100,"authors":1101,"updatedDate":7,"date":939,"title":1102,"tags":1103,"description":1104,"category":765},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1749658898/Blog/Hero%20Images/blog-post-image-forrester-wave-1800x945px-fy26.png","Die Wahl einer DevSecOps-Plattform ist eine der wichtigesten technologischen Entscheidungen, die ein Unternehmen zu treffen hat. Deshalb freuen wir uns sehr, dass wir als [**führender Anbieter in The Forrester Wave™: DevOps Platforms, Q2 2025** (nur in englischer Sprache verfügbar)](https://about.gitlab.com/forrester-wave-devops-platform/) ausgezeichnet wurden. \n\nWir haben die höchstmöglichen Punktzahlen bei den Kriterien erhalten, die unseren Kund(inn)en laut ihren eigenen Angaben am wichtigsten sind, einschließlich der Benutzungserfahrung am ersten Tag, der Entwicklungstools, der Build-Automatisierung und CI, der automatisierten Bereitstellung, der Risikominderung im Zusammenhang mit KI, KI-Infusion, direkt integrierter Sicherheitstools und Plattformkohäsion.\n\n***„GitLab ist die All-in-One-Lösung unter den All-in-One-Lösungen, die ihrem Namen am stärksten gerecht wird, und eignet sich damit für Unternehmen, die mit einem einzigen Kauf eine Standardisierung herbeiführen möchten.“ –*** Forrester Wave™: DevOps Platforms, Q2 2025\n\nDiese Auszeichnung spiegelt das wider, was wir selbst von unseren Kund(inn)en gehört haben: Sie müssen sichere Software schneller bereitstellen, doch ihre bestehenden Lösungen zwingen sie, Kompromisse bei der Geschwindigkeit, Sicherheit oder Einfachheit einzugehen. GitLab wird jedoch allen drei Anforderungen gerecht. Und mit unserer [Veröffentlichung von GitLab 18.0 (nur in englischer Sprache verfügbar)](https://about.gitlab.com/releases/2025/05/15/gitlab-18-0-released/) im Mai sind wir noch einen Schritt weiter gegangen, indem wir ohne zusätzliche Kosten [die KI-nativen Funktionen von GitLab Duo](https://about.gitlab.com/de-de/blog/gitlab-premium-with-duo/) – wie Test Generation, Code Suggestions und Code Refactoring – direkt in GitLab Premium und GitLab Ultimate integriert haben.\n\n> **[Erhalte jetzt Zugang zum englischsprachigen Bericht.](https://about.gitlab.com/forrester-wave-devops-platform/)**\n\n![ Forrester Wave™: DevOps-Plattformen, Grafik Q2 2025](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749673518/Blog/Content%20Images/Image_DevOps-Platforms-Q2-2025.png)\n\n## Mit unternehmensweiter Kontrolle an der Spitze der KI-Transformation bleiben\n\nDevSecOps entwickelt sich rasant weiter, wobei die KI an der Spitze dieses Wandels steht. Leider zwingen viele KI-Tools die Anwender(innen) zu einer Wahl: entweder modernste Funktionen oder eine höchstmögliche Unternehmenssicherheit. \n\nGitLab hat sowohl bei den Kriterien **KI-Infusion** als auch **KI-Risikominderung** 5 Punkte erhalten – die höchste mögliche Punktzahl. Wir freuen uns, dass unser klarer Fokus auf die Entwicklung innovativer KI-Funktionen, bei denen gleichermaßen eine umfassende Sicherheit gewährleistet bleibt, nicht nur von unseren Kund(inn)en wahrgenommen wird.\n\nDiese doppelte Stärke zeigt sich in unseren KI-Angeboten von GitLab Duo, unter anderem:\n\n* Duo Workflow (private Beta-Version): Autonome KI-Agenten, die komplexe Aufgaben bei der Entwicklung, Sicherheit und Betrieb bewältigen – mit Leitlinien und Audit-Trails auf Enterprise-Niveau.  \n* Agentic Chat: Kontextbezogene, dialogorientierte KI-Unterstützung für alles von Codeerläuterungen bis hin zur Erstellung von Tests – mit integriertem Schutz des geistigen Eigentums und Datenschutzkontrollen.  \n* Code Suggestions: KI-Unterstützung, die Codeblöcke vorausschauend vervollständigen, eine Funktionslogik definieren, Tests generieren und häufig verwendeten Code wie Regex-Muster vorschlagen kann.  \n* KI-native Vulnerability Resolution: Findet und behebt Sicherheitslücken mit automatischen Erklärungen und automatisch erstellten Merge Requests, um so den Entwicklungsprozess zu optimieren.\n\n## Mit weniger mehr erreichen\n\nWir haben deutlich vernommen, dass DevSecOps-Teams nicht noch mehr Tools und Integrationen benötigen, die sie bei einzelnen Abschnitten ihres Software-Entwicklungsprozesses unterstützen. Sie benötigen stattdessen eine nahtlose, integrierte Entwicklererfahrung, die den gesamten Lebenszyklus der Softwareentwicklung abdeckt.\n\nWir sind überzeugt, dass die Bewertungen von GitLab in den folgenden Kriterien unsere kundenorientierte Strategie bestätigen:\n\n* **Nutzungserfahrung am ersten Tag:** Forrester zitiert unsere „starke Nutzungserfahrung am ersten Tag“ und stellt fest, dass „alles sofort einsatzbereit ist“, unterstützt durch umfangreiche Migrationstools und Tutorials. \n* **Entwicklertools:** Forrester verweist beispielhaft auf [GitLab Duo mit Amazon Q](https://about.gitlab.com/de-de/blog/gitlab-duo-with-amazon-q-agentic-ai-optimized-for-aws/), unser Angebot für agentische KI für AWS-Kund(inn)en, sowie auf unsere Entwicklungsumgebung in der Cloud, die integrierte Entwicklungsplattform und Wikis für die Dokumentation.  \n* **Projektplanung und -abstimmung:** Forrester hebt unser „starkes Compliance Center“ hervor und stellt fest, dass wir über Tools verfügen, um die Abstimmung in beide Richtungen voranzutreiben.  \n* **Pipeline-Sicherheit:** Forrester gibt uns die höchstmögliche Punktzahl beim Kriterium Pipeline-Sicherheit.  \n* **Build-Automatisierung und CI:** Forrester erwähnt unsere Build-Automatisierung und CI mit mehrstufigen Build-Pipelines und einer starken Unterstützung für selbst gehostete Installationen.\n\n## Bericht lesen \n\nFür uns spiegelt sich in unserer Auszeichnung als führender Anbieter in The Forrester Wave™: DevOps-Plattformen, Q2 2025 die Breite und Tiefe der Funktionen unserer Plattform wider, die als Single Source of Truth über den gesamten Lebenszyklus der Softwareentwicklung hinweg fungiert. Kein Jonglieren mit mehreren Tools und Integrationen mehr – GitLab bietet eine nahtlose, integrierte Erfahrung, die die Produktivität steigert und Reibungsverluste reduziert. \n\nWir sind überzeugt, dass sich in dieser hervorragenden Platzierung die harte Arbeit unseres Teams, die vielen Beiträge der Open-Source-Community von GitLab, das unschätzbare Feedback unserer Kund(inn)en und unser Engagement für die Gestaltung der Zukunft der Softwareentwicklung widerspiegeln.\n\n> **[Öffne den englischsprachigen Bericht.](https://about.gitlab.com/forrester-wave-devops-platform/)**\n\n*Forrester spricht keine Empfehlung für Unternehmen, Produkte, Marken oder Dienstleistungen aus, die in seinen Forschungspublikationen vorkommen, und rät niemandem, sich auf der Grundlage der in diesen Publikationen aufgeführten Bewertungen für die Produkte oder Dienstleistungen eines Unternehmens oder einer Marke zu entscheiden. Die Informationen basieren auf den besten verfügbaren Ressourcen. Die Meinungen spiegeln die jeweils aktuelle Einschätzung wider und können sich ändern. Weitere Informationen zur Objektivität von Forrester (in englischer Sprache) findest du [hier](https://www.forrester.com/about-us/objectivity/).*",[1013],"GitLab ist ein Leader in der Forrester Wave™: DevOps Platforms, Q2 2025",[1018,765,743,808],"Forrester bezeichnet die GitLab-Plattform als die „All-in-One-Lösung unter den All-in-One-Lösungen“ und geeignet „für Unternehmen, die mit einem Kauf eine Standardisierung herbeiführen möchten“.",{"slug":1106,"featured":91,"template":797},"gitlab-named-a-leader-in-the-forrester-wave-devops-platforms-q2-2025",{"content":1108,"config":1120},{"title":1109,"description":1110,"authors":1111,"heroImage":1113,"date":1114,"body":1115,"category":765,"tags":1116,"updatedDate":1119},"Erste Schritte mit GitLab: Arbeiten mit CI/CD-Variablen","Erfahre, was CI/CD-Variablen sind, warum sie in DevSecOps wichtig sind und wie du sie am besten einsetzt.",[1112],"GitLab Team","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749659525/Blog/Hero%20Images/blog-getting-started-with-gitlab-banner-0497-option4-fy25.png","2025-05-27","*Willkommen zu unserer Serie „Erste Schritte mit GitLab“, in der wir Neueinsteiger(inne)n helfen, sich mit der DevSecOps-Plattform von GitLab vertraut zu machen.* \n\nIn einem früheren Artikel haben wir uns mit [GitLab CI/CD](https://about.gitlab.com/de-de/blog/getting-started-with-gitlab-understanding-ci-cd/) beschäftigt. Jetzt tauchen wir tiefer in die Welt der **CI/CD-Variablen** ein und erschließen ihr volles Potenzial.\n\n## Inhaltsverzeichnis\n\n- [Was sind CI/CD-Variablen?](#was-sind-cicd-variablen%3F)\n- [Warum sind CI/CD-Variablen wichtig?](#warum-sind-cicd-variablen-wichtig%3F)\n- [Geltungsbereiche von CI/CD-Variablen: Projekt, Gruppe und Instanz](#geltungsbereiche-von-cicd-variablen-projekt-gruppe-und-instanz)\n- [Definieren von CI/CD-Variablen](#definieren-von-cicd-variablen)\n- [Verwenden von CI/CD-Variablen](#verwenden-von-cicd-variablen)\n- [Vordefinierte CI/CD-Variablen](#vordefinierte-cicd-variablen)\n- [Bewährte Methoden](#bewährte-methoden)\n- [Entdecke die Leistungsfähigkeit von Variablen](#entdecke-die-leistungsfähigkeit-von-variablen)\n- [Reihe „Erste Schritte mit GitLab\"](#reihe-„erste-schritte-mit-gitlab“)\n\n### Was sind CI/CD-Variablen?\n\nCI/CD-Variablen sind dynamische Schlüssel-Wert-Paare, die du auf verschiedenen Ebenen in deiner GitLab-Umgebung definieren kannst (z. B. Projekt, Gruppe oder Instanz). Diese Variablen fungieren als Platzhalter für Werte, die du in deiner `.gitlab-ci.yml`-Datei verwenden kannst, um deine Pipelines anzupassen, vertrauliche Informationen sicher zu speichern und deine CI/CD-Konfiguration besser zu pflegen.\n\n### Warum sind CI/CD-Variablen wichtig?\n\nCI/CD-Variablen bieten zahlreiche Vorteile:\n\n* **Flexibilität** – Du kannst deine Pipelines leicht an verschiedene Umgebungen, Konfigurationen oder Bereitstellungsziele anpassen, ohne dein zentrales CI/CD-Skript zu ändern. \n* **Sicherheit** – Speichere vertrauliche Informationen wie API-Schlüssel, Passwörter und Token sicher und verhindere so, dass sie in deinem Code offengelegt werden.  \n* **Wartbarkeit** – Verwalte deine CI/CD-Konfiguration sauber und übersichtlich, indem du Werte in Variablen zentralisierst, was Aktualisierungen und Änderungen erleichtert. \n* **Wiederverwendbarkeit** – Definiere Variablen einmal und verwende sie in mehreren Projekten wieder, um die Konsistenz zu fördern und doppelte Arbeit zu vermeiden.\n\n### Geltungsbereiche von CI/CD-Variablen: Projekt, Gruppe und Instanz\n\nMit GitLab kannst du CI/CD-Variablen mit unterschiedlichen Geltungsbereichen definieren und so ihre Sichtbarkeit und Zugänglichkeit steuern:\n\n* **Variablen auf Projektebene** – Diese Variablen sind spezifisch für ein einzelnes Projekt und eignen sich ideal zum Speichern von projektspezifischen Einstellungen, wie zum Beispiel:\n  * Bereitstellungs-URLs: Definiere unterschiedliche URLs für Staging- und Produktivumgebungen. \n  * Datenbank-Zugangsdaten: Speichere Details zur Datenbankverbindung für Tests oder die Bereitstellung.  \n  * Feature-Flags: Aktiviere oder deaktiviere Funktionen in verschiedenen Phasen deiner Pipeline.  \n  * Beispiel: Du hast ein Projekt mit dem Namen „MyWebApp“ und möchtest die URL für die Bereitstellung speichern. Du erstellst eine Variable auf Projektebene mit dem Namen `DPROD_DEPLOY_URL` und dem Wert `https://mywebapp.com`.  \n* **Variablen auf Gruppenebene** – Diese Variablen werden von allen Projekten innerhalb einer GitLab-Gruppe gemeinsam genutzt. Sie sind nützlich für Einstellungen, die für mehrere Projekte gleich sind, wie z. B.:\n\n  * API-Schlüssel für gemeinsam genutzte Dienste: Speichere API-Schlüssel für Dienste wie AWS, Google Cloud oder Docker Hub, die von mehreren Projekten innerhalb der Gruppe genutzt werden.  \n  * Globale Konfigurationseinstellungen: Lege gemeinsame Konfigurationsparameter fest, die für alle Projekte in der Gruppe gelten.  \n  * Beispiel: Du hast eine Gruppe mit dem Namen „Web-Apps“ und möchtest einen API-Schlüssel für Docker Hub speichern. Du erstellst eine Variable auf Gruppenebene mit dem Namen `DOCKER_HUB_API_KEY` und dem entsprechenden API-Schlüsselwert.  \n* **Variablen auf Instanzebene** – Diese Variablen sind für alle Projekte auf einer GitLab-Instanz verfügbar. Sie werden in der Regel für globale Einstellungen verwendet, die für das gesamte Unternehmen gelten, wie z. B.:\n\n  * Standard-Token für die Registrierung von Runnern: Lege ein Standard-Token für die Registrierung neuer [Runner (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/runner/) fest.  \n  * Lizenzinformationen: Hier kannst du Lizenzschlüssel für GitLab-Funktionen oder Tools von Drittanbietern speichern.  \n  * Globale Umgebungseinstellungen: Lege Umgebungsvariablen fest, die für alle Projekte verfügbar sein sollen.  \n  * Beispiel: Du möchtest ein Standard-Docker-Image für alle Projekte in deiner GitLab-Instanz festlegen. Du erstellst eine Variable auf Instanzebene mit dem Namen `DEFAULT_DOCKER_IMAGE` und dem Wert `ubuntu:latest`.\n\n### Definieren von CI/CD-Variablen\n\nSo definierst du eine CI/CD-Variable:\n\n1. Klicke auf die Schaltflächen **Einstellungen > CI/CD** für dein Projekt, deine Gruppe oder deine Instanz.  \n2. Gehe zum Abschnitt **Variablen**.  \n3. Klicke auf **Variable hinzufügen**.  \n4. Gib den **Schlüssel** (z. B. `API_KEY`) und den **Wert** ein.  \n5. Aktiviere optional das Kontrollkästchen **Variable schützen**, wenn es sich um vertrauliche Informationen handelt. Dadurch wird sichergestellt, dass die Variable nur für Pipelines verfügbar ist, die auf geschützten Branches oder Tags ausgeführt werden.  \n6. Aktiviere optional das Kontrollkästchen **Variable maskieren**, um den Wert der Variable in den Job-Protokollen auszublenden und eine versehentliche Offenlegung zu verhindern.  \n7. Klicke auf **Variable speichern**.\n\n### Verwenden von CI/CD-Variablen\n\nUm eine CI/CD-Variable in deiner `.gitlab-ci.yml`-Datei zu verwenden, stellst du dem Variablennamen einfach `$` voran:\n\n```yaml\ndeploy_job:\n  script:\n    - echo \"Deploying to production...\"\n    - curl -H \"Authorization: Bearer $API_KEY\" https://api.example.com/deploy\n```\n\n### Vordefinierte CI/CD-Variablen\n\nGitLab stellt [vordefinierte CI/CD-Variablen (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/ci/variables/predefined_variables/) bereit, die du in deinen Pipelines verwenden kannst. Diese Variablen liefern Informationen über die aktuelle Pipeline, den Job, das Projekt und mehr.\n\nEinige häufig verwendete vordefinierte Variablen sind:\n\n* `$CI_COMMIT_SHA`: Der Commit-SHA der aktuellen Pipeline.  \n* `$CI_PROJECT_DIR`: Das Verzeichnis, in dem das Projekt geklont wird.  \n* `$CI_PIPELINE_ID`: Die ID der aktuellen Pipeline.  \n*`$CI_ENVIRONMENT_NAME`: Der Name der Umgebung, in der bereitgestellt wird (falls zutreffend).\n\n### Bewährte Methoden\n\n* Verwalte vertrauliche Variablen sicher: Verwende geschützte und maskierte Variablen für API-Schlüssel, Passwörter und andere vertrauliche Informationen. \n* Vermeide das Hardcoding von Werten: Verwende Variablen zum Speichern von Konfigurationswerten, um deine Pipelines flexibler und wartbarer zu machen.  \n* Organisiere deine Variablen: Verwende aussagekräftige Namen und gruppiere verwandte Variablen, um sie besser zu organisieren.  \n* Verwende den richtigen Geltungsbereich: Wähle den richtigen Geltungsbereich (Projekt, Gruppe oder Instanz) für deine Variablen aus, je nach Verwendungszweck und Sichtbarkeit.\n\n### Entdecke die Leistungsfähigkeit von Variablen\n\nCI/CD-Variablen sind ein leistungsstarkes Tool zur Anpassung und Sicherung deiner GitLab-Pipelines. Wenn du verstanden hast, wie Variablen funktionieren und ihre unterschiedlichen Geltungsbereiche kennst, kannst du flexiblere, wartbarere und effizientere Workflows erstellen.\n\nWir hoffen, dass diese Informationen für dich hilfreich waren und du jetzt gut gerüstet bist, um die Möglichkeiten von GitLab für deine Entwicklungsprojekte zu nutzen.\n\n> Lege jetzt los mit CI/CD-Variablen mit einer [kostenlosen, 60-tägigen Testversion von GitLab Ultimate mit Duo Enterprise](https://about.gitlab.com/de-de/free-trial/).\n\n## Reihe „Erste Schritte mit GitLab“\nLies weitere Artikel in unserer Serie „Erste Schritte mit GitLab“:\n\n- [Benutzerverwaltung](https://about.gitlab.com/de-de/blog/getting-started-with-gitlab-how-to-manage-users/)\n- [Projekte in GitLab importieren (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/getting-started-with-gitlab-how-to-import-your-projects-to-gitlab/)  \n- [Projektmanagement](https://about.gitlab.com/de-de/blog/getting-started-with-gitlab-mastering-project-management/)\n- [Automatisiere Agile-Workflows mit dem gem gitlab-triage](https://about.gitlab.com/de-de/blog/automating-agile-workflows-with-the-gitlab-triage-gem/)\n- [Grundlegendes zu CI/CD](https://about.gitlab.com/de-de/blog/getting-started-with-gitlab-understanding-ci-cd/)\n",[765,810,1117,1118,109,809],"CI","CD","2025-06-10",{"slug":1121,"featured":91,"template":797},"getting-started-with-gitlab-working-with-ci-cd-variables",{"category":126,"slug":776,"posts":1123},[1124,1136,1148],{"content":1125,"config":1134},{"title":1126,"description":1127,"authors":1128,"heroImage":1130,"date":1131,"body":1132,"category":776,"tags":1133},"So verwendest du die benutzerdefinierten Compliance Frameworks von GitLab in deiner DevSecOps-Umgebung","Erfahre, wie sich regulatorische Anforderungen durch neue Frameworks zusammen mit mehr als 50 standardmäßigen Kontrollen von lästigen Checklisten in integrierte, automatisierte Workflow-Komponenten verwandeln.",[1129],"Fernando Diaz","https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097104/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%284%29_3LZkiDjHLjhqEkvOvBsVKp_1750097104092.png","2025-04-30","Compliance ist mehr als nur ein Kontrollkästchen, sondern vielmehr eine wichtige Unternehmensfunktion, die sich von betrieblichen Risiken bis hin zum Kundenvertrauen auf jeden Bereich auswirkt. Für Entwicklungsteams kann es sich besonders schwierig gestalten, die Compliance-Anforderungen mit einer angemessenen Geschwindigkeit in Einklang zu bringen. Die [benutzerdefinierten Compliance Frameworks (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/introducing-custom-compliance-frameworks-in-gitlab/) von GitLab ermöglichen eine einfache und direkte Integration der Compliance-Verifizierung in deinen Entwicklungsworkflow. In diesem Artikel erfährst du, worum es sich dabei im Detail handelt und wie du sie so effizient wie möglich einsetzen kannst.\n\n## Was sind die benutzerdefinierten Compliance Frameworks von GitLab?\n\nMit den benutzerdefinierten Compliance Frameworks von GitLab können Unternehmen ihre Compliance-Standards direkt in ihrer GitLab-Instanz definieren, implementieren und durchsetzen. Diese Funktion erweitert die integrierten Compliance-Funktionen von GitLab und ermöglicht den Teams die Erstellung benutzerdefinierter Frameworks, die mit den konkreten gesetzlichen Anforderungen, internen Richtlinien oder Branchenstandards übereinstimmen.\n\nDie benutzerdefinierten Compliance Frameworks bieten folgende Vorteile:\n* Weniger manuelle Nachverfolgung  \n* Schnellere Bereitschaft für Audits  \n* Native Durchsetzung von Compliance-Kontrollen\n\n![Screenshot des Compliance Centers mit einer Liste der Frameworks](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image3_aHR0cHM6_1750097114254.png)\n\nIm Rahmen dieser Veröffentlichung werden über 50 standardmäßig verfügbare Kontrollen bereitgestellt (weitere folgen in Kürze), die auf die individuellen Compliance-Anforderungen deines Unternehmens zugeschnitten werden können, einschließlich HIPAA im Gesundheitswesen, DSGVO für den Datenschutz, SOC 2 für Dienstleistungsunternehmen oder branchenspezifische Vorschriften. Einige Beispiele für standardmäßig verfügbare Kontrollen sind unter anderem:\n\n* Aufgabentrennung (z. B. mindestens zwei genehmigende Personen und ein(e) Autor(in) für einen Merge Request)   \n* Ausführung von Sicherheitsscannern (z. B. [SAST (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/application_security/sast/) und [Abhängigkeitssuche (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/application_security/dependency_scanning/)  \n* Authentifizierung/Genehmigung (z. B. keine öffentliche Projektsichtbarkeit und AuthSSO erforderlich)  \n* Anwendungskonfiguration (z. B. Statusprüfungen und Terraform erforderlich)\n\nDarüber hinaus kannst du externe Umgebungskontrollen über die GitLab-API konfigurieren, um den Status und die Details einer externen Umgebung zu überprüfen.\n\n## Entwickeln eines benutzerdefinierten Compliance Frameworks von Grund auf\n\nNachdem wir nun den Wert verstanden haben, wollen wir uns im nächsten Schritt ansehen, wie du benutzerdefinierte Compliance Frameworks in deiner GitLab-Umgebung implementieren kannst. Wir verwenden dazu diese Demo-Anwendung. Du kannst den Details in diesem Video folgen. \n\n**Hinweis:** Dazu ist ein GitLab-Ultimate-Abonnement erforderlich.\n\n\u003C!-- TODO: EMBED_YT_VIDEO -->\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/bSwwv5XeMdQ?si=unDwCltF4vTHT4mB\" title=\"Adhering to compliance requirements with built-in compliance controls\n\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n**Schritt 1: Definiere deine Compliance-Anforderungen**\n\nBevor du dein benutzerdefiniertes Framework erstellst, musst du zunächst deine Compliance-Anforderungen klar definieren:\n\n1. **Identifiziere die geltenden Vorschriften:** Bestimme, welche Vorschriften und Standards für dein Unternehmen gelten (z. B. DSGVO, PCI DSS und HIPAA). \n2. **Ordne die Anforderungen den Kontrollen zu:** Unterteile jede Vorschrift in konkrete umsetzbare Kontrollen.  \n3. **Priorisiere die Anforderungen:** Konzentriere dich auf die Bereiche mit hohem Risiko sowie die Anforderungen mit der größten Wirkung.\n\n**Schritt 2: Entwickle dein benutzerdefiniertes Compliance Framework**\n\nSo entwickelst du ein benutzerdefiniertes Compliance Framework in GitLab:\n\n1. Navigiere in deiner GitLab-Gruppe zum Abschnitt **Sichern > Compliance Center**.  \n2. Klicke auf die Schaltfläche **Neues Framework**.  \n3. Wähle **Leeres Framework erstellen** aus.\n\n![Bildschirm zum Erstellen eines benutzerdefinierten Compliance Frameworks](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image7_aHR0cHM6_1750097114255.png)\n\n4. Gib einen Namen, eine Beschreibung und eine Farbe für dein Framework ein.\n\n![Bildschirm „Neues Compliance Framework“](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image6_aHR0cHM6_1750097114257.png)\n\n5. Füge dem Framework eine Anforderung hinzu:  \n   a. Scrolle nach unten zum Tab **Anforderungen**.\n\n   b. Klicke auf die Schaltfläche **Neue Anforderung**.\n\n   c. Gib einen Namen und eine Beschreibung ein.\n   d. Wähle im Abschnitt **Kontrollen** **GitLab-Kontrolle auswählen** aus.  \n   e. Wähle eine Kontrolle aus der Liste aus (z. B. mindestens zwei Genehmigungen, SAST wird ausgeführt).  \n   f. Klicke auf die Schaltfläche **Anforderung erstellen**.\n\n![Schaltfläche „Neue Anforderung erstellen“](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image2_aHR0cHM6_1750097114258.png)\n\n6. Klicke auf die Schaltfläche **Framework erstellen**.\n\nDas Framework wird wie angegeben erstellt und kann nun zu Projekten hinzugefügt werden. Darüber hinaus können Compliance Frameworks mit einem JSON mit dem entsprechenden Schema [importiert](http://TODO) werden.\n\n**Schritt 3: Wende das Framework auf Projekte an**\n\nSobald dein Framework erstellt wurde, gehst du wie folgt vor:\n1. Wähle im Compliance Center die Registerkarte **Projekte** aus.  \n2. **Suche** mit dem Suchfeld oder **filtere** die Ergebnisse.  \n3. Wähle die Projekte aus, auf die du dein Framework anwenden möchtest.  \n4. Klicke auf die Schaltfläche **Eine Massenaktion auswählen**.  \n5. Wähle **Frameworks auf ausgewählte Projekte anwenden** aus.  \n6. Klicke auf die Schaltfläche **Frameworks auswählen**.  \n7. Wähle deine Frameworks aus der Liste aus.  \n8. Klicke auf die Schaltfläche **Anwenden**.\n\n![Compliance-Center-Fenster mit Dropdown-Liste für das SOC-2-Framework](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image5_aHR0cHM6_1750097114260.png)\n\nDas Framework wird nun auf das Projekt angewendet, wodurch seine Anforderungen sichtbar und nachvollziehbar werden.\n\n**Schritt 4: Überwache die Compliance und erstelle dazu entsprechende Berichte**\n\nSobald dein Framework eingerichtet ist, kannst du Folgendes tun:\n\n1. Im **Compliance Center** kannst du den Compliance-Status über alle Projekte hinweg verfolgen, einschließlich Details und vorgeschlagener Korrekturen für fehlgeschlagene Kontrollen.\n2. Erstelle **Compliance-Berichte** für Audits und Stakeholder-Reviews.  \n3. Richte **Compliance-Alarme** ein, um die Stakeholder über mögliche Compliance-Probleme zu informieren. \n4. Überprüfe **Audit Events**, um einen Überblick über die Maßnahmen zu erhalten, die im Zusammenhang mit den Compliance-Einstellungen ergriffen wurden.\n\n![Bildschirm des Compliance Centers mit SOC-2-Test-Framework](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image4_aHR0cHM6_1750097114263.png)\n\n## Praxisbeispiel: Implementierung eines SOC 2 Compliance Frameworks\n\nSystem and Organization Controls 2, besser bekannt als SOC 2, ist ein strenger Prüfungsstandard, der vom American Institute of Certified Public Accountants entwickelt wurde und die Kontrollen eines Dienstleistungsunternehmens in Bezug auf seine Sicherheit, Verfügbarkeit, Verarbeitungsintegrität, Vertraulichkeit und seinen Datenschutz evaluiert. Weitere Informationen findest du in meinem [Leitfaden zur Erfüllung der SOC-2-Sicherheitsanforderungen mit GitLab (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/guide-to-fulfilling-soc-2-security-requirements-with-gitlab/).\n\nSehen wir uns nun ein praktisches Beispiel für die Verwendung eines benutzerdefinierten Compliance Frameworks zur Überprüfung der SOC-2-Sicherheits-Compliance an, wo folgende Anforderungen gelten:\n\n* Implementierung von Kontrollen zum Schutz vor unbefugtem Zugriff  \n* Einrichtung von Verfahren zur Identifizierung und Minderung von Risiken  \n* Einrichtung von Systemen zur Erkennung von und zum Umgang mit sicherheitsrelevanten Vorfällen\n\n**Haftungsausschlussklausel:** Dies ist nur ein Beispiel, in dem einige der möglichen Kontrollen zur Einhaltung von SOC 2 aufgezeigt werden. Konsultiere dein Sicherheits-/Compliance-Team, bevor du eine Implementierung in die Produktion überführst.\n\nEin benutzerdefiniertes Compliance Framework für SOC 2 sieht bei Verwendung einiger standardmäßiger Kontrollen von GitLab wie folgt aus:\n\n* **Name:** SOC-2-Sicherheitsanforderungen  \n* **Beschreibung:** Ergänzt die Sicherheitsanforderungen für die Einhaltung des SOC-2-Frameworks \n* **Anforderungen:**  \n  * **Implementierung von Kontrollen zum Schutz vor unbefugtem Zugriff**  \n    * Aktivierung von Auth SSO\n    * Aktivierung des CI/CD-Job-Token-Bereichs\n    * MFA auf Organisationsebene erforderlich \n   * **Richte Verfahren zur Identifizierung und Minderung von Risiken ein**\n    * Mindestens zwei genehmigende Personen\n    * Autor(in) hat den Merge Request genehmigt \n    * Die Committer haben den Merge Request genehmigt  \n    * Standard-Branch ist geschützt  \n  * **Einrichtung von Systemen zur Erkennung von und zum Umgang mit sicherheitsrelevanten Vorfällen**  \n    * Abhängigkeitssuche wird ausgeführt    \n    * SAST wird ausgeführt  \n    * DAST wird ausgeführt\n\nWenn du dieses Framework auf dein(e) Projekt(e) anwendest, kannst du überwachen, ob und wann sie nicht mehr die Compliance-Kriterien erfüllen und was getan werden kann, damit die Erfüllung der Compliance-Kriterien wieder gewährleistet ist. Beachte, dass du mehrere Compliance Frameworks für Projekte erstellen und anwenden kannst. Du kannst zum Beispiel eines für die SOC-2-Anforderungen an die Prozessintegrität implementieren.\n\n## Implementiere Sicherheitsrichtlinien, um sicherzustellen, dass die Compliance-Anforderungen erfüllt werden\n\nObwohl dies nicht erforderlich ist, können Sicherheitsrichtlinien auf Projekte angewendet werden, die ein benutzerdefiniertes Compliance Framework enthalten. So kannst du sicherstellen, dass bestimmte Compliance-Kriterien über Sicherheitsrichtlinien durchgesetzt werden. Du kannst zum Beispiel erzwingen, dass Sicherheitsscanner für Projekte ausgeführt werden, die ein benutzerdefiniertes Compliance Framework enthalten, das einen solchen Sicherheitsscan erfordert. \n\nGitLab bietet verschiedene Sicherheitsrichtlinien (Dokumentation nur in englischer Sprache verfügbar):\n\n* [Scan-Ausführungsrichtlinie](https://docs.gitlab.com/user/application_security/policies/scan_execution_policies/): Erzwingt Sicherheitsscans, entweder als Teil der Pipeline oder nach einem festgelegten Zeitplan.  \n* [Merge-Request-Approvalrichtlinie](https://docs.gitlab.com/user/application_security/policies/merge_request_approval_policies/): Erzwingt Einstellungen auf Projektebene und Approvalregeln auf Basis der Ergebnisse des Scans.  \n* [Pipeline-Ausführungsrichtlinie](https://docs.gitlab.com/user/application_security/policies/pipeline_execution_policies/): Erzwingt CI/CD-Jobs als Teil von Projekt-Pipelines. \n* [Richtlinie zum Sicherheitslückenmanagement](https://docs.gitlab.com/user/application_security/policies/vulnerability_management_policy/): Behebt automatisch Sicherheitslücken, die im Standard-Branch nicht mehr erkannt werden.\n\nWir wollen nun die Ausführung eines SAST-Scanners erzwingen, um automatisch alle Anforderungen zu erfüllen, die einen SAST-Scan erfordern. So erstellst du eine Sicherheitsrichtlinie und wendest sie auf ein Projekt mit einem bestimmten Framework an:\n\n1. Navigiere zu einem Projekt mit einem benutzerdefinierten Compliance Framework, das einen **SAST-Scan** erfordert. \n2. Wähle in der Seitenleiste **Sichern > Richtlinien** aus.  \n3. Klicke auf die Schaltfläche **Neue Richtlinie**.  \n4. Klicke unter **Scan-Ausführungsrichtlinien** auf die Schaltfläche **Richtlinie auswählen**. \n5. Gib den **Namen** und die **Beschreibung** ein. \n6. Wähle unter **Aktionen** **SAST** als auszuführenden Scan aus.\n\n![Aktionsbildschirm](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image8_aHR0cHM6_1750097114264.png)\n\n7. Wähle unter **Bedingungen** die Pipeline aus, die ausgelöst werden soll, wenn eine Pipeline für alle Branches ausgeführt wird.\n\n![Bildschirm „Bedingungen“](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097114/Blog/Content%20Images/Blog/Content%20Images/image1_aHR0cHM6_1750097114265.png)\n\n8. Klicke auf die Schaltfläche **Mit einem Merge Request konfigurieren**.  \n9. In einem separaten Projekt wird nun ein MR erstellt, der alle Sicherheitsrichtlinien enthält, die für dieses Projekt gelten.\n10. Klicke auf die Schaltfläche **Zusammenführen**.\n\nJetzt wird SAST für jeden Branch ausgeführt, um sicherzustellen, dass du im jeweiligen Bereich die Compliance-Anforderungen erfüllst. Überprüfe unbedingt die verschiedenen Sicherheitsrichtlinien, um im Detail zu erfahren, wie sie zu deinen Anforderungen passen.\n\n## 5 Best Practices, die du beachten solltest \n\nSo maximierst du den Wert benutzerdefinierter Compliance Frameworks:\n\n1. **Fang klein an:** Beginne mit einer kritischen Vorschrift oder einem Standard, bevor du sukzessive erweiterst.  \n2. **Beteilige die wichtigsten Stakeholder:** Beziehe die Compliance-, Sicherheits- und Entwicklungsteams in die Erstellung des Frameworks ein.  \n3. **Automatisiere, wo möglich:** Verwende GitLab CI/CD, um Compliance-Überprüfungen zu automatisieren.  \n4. **Sorge für eine gründliche Dokumentation:** Pflege eine klare Dokumentation darüber, wie dein Framework den gesetzlichen Anforderungen entspricht.  \n5. **Regelmäßige Überprüfungen:** Aktualisiere deine Frameworks, wenn sich die Vorschriften ändern oder neue Anforderungen entstehen.\n\n## Leg noch heute los\n\nDie benutzerdefinierten Compliance Frameworks von GitLab sind ein bedeutender Fortschritt im DevSecOps-Bereich, da mit ihnen die Compliance direkt in den Entwicklungsworkflow integriert wird. Durch die Implementierung benutzerdefinierter Frameworks können Unternehmen ihren Compliance-Aufwand reduzieren, ihr Risikomanagement verbessern und die Entwicklungszyklen beschleunigen, während sie gleichzeitig beständig die gesetzlichen Anforderungen erfüllen.\n\nDurch die Möglichkeit, benutzerdefinierte Compliance Frameworks zu definieren und durchzusetzen, erhalten die Teams die Flexibilität, die sie benötigen, um die Anforderungen ihrer konkreten regulatorischen Landschaft zu erfüllen. Gleichzeitig erhalten sie so die notwendige Struktur, um einheitliche Compliance-Praktiken im gesamten Unternehmen sicherzustellen.\n\nDa die regulatorischen Anforderungen immer komplexer werden, werden Tools wie die benutzerdefinierten Compliance Frameworks von GitLab für Unternehmen, mit denen die umfassenden Compliance-Anforderungen und eine zielführende Entwicklungsgeschwindigkeit auf nachhaltige Weise in Einklang gebracht werden sollen, immer wichtiger.\n\n> Melde dich für deine [kostenlose 60-tägige Testversion von GitLab Ultimate](https://about.gitlab.com/de-de/free-trial/) an, um die benutzerdefinierten Compliance Frameworks noch heute auszuprobieren.\n\n## Mehr erfahren \n\nIn diesen Ressourcen erfährst du mehr über benutzerdefinierte Compliance Frameworks und ihre Vorteile für dein Unternehmen:\n\n* [Dokumentation zu benutzerdefinierten Compliance Frameworks (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/compliance/compliance_center/compliance_status_report/)   \n* [Epic zu benutzerdefinierten Compliance Frameworks](https://gitlab.com/groups/gitlab-org/-/epics/13295)   \n* [Dokumentation der Sicherheitsrichtlinien (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/application_security/policies/)  \n* [Sicherheits- und Compliance-Lösungen von GitLab](https://about.gitlab.com/de-de/solutions/security-compliance/)",[776,810,808,809,765],{"slug":1135,"featured":91,"template":797},"how-to-use-gitlabs-custom-compliance-frameworks-in-your-devsecops",{"content":1137,"config":1146},{"title":1138,"description":1139,"authors":1140,"heroImage":1141,"date":1142,"body":1143,"category":776,"tags":1144,"updatedDate":811},"Bessere Anwendungssicherheit mit GitLab und HackerOne","Erfahre mehr über die Zusammenarbeit zwischen GitLab und HackerOne und lerne, wie du eine Integration implementierst, die die Sicherheit der Anwendungen in deinem Unternehmen verbessert.",[1129],"https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097503/Blog/Hero%20Images/Blog/Hero%20Images/blog-image-template-1800x945%20%2810%29_5ET24Q6i8ihqrAOkge7a1R_1750097503214.png","2025-04-03","Sicherheit darf im Entwicklungsprozess nicht länger eine Nebensache sein. Unternehmen benötigen robuste Lösungen, mit denen die Sicherheit in den gesamten Software-Entwicklungsprozess integriert wird. Hier kommt die Zusammenarbeit zwischen HackerOne und GitLab ins Spiel, denn sie bietet eine praktische Kombination für moderne Anwendungsentwicklungsteams.\n\n[GitLab](https://about.gitlab.com/de-de/), die umfassende, KI-basierte DevSecOps-Plattform, und HackerOne, die führende Crowd-Sicherheitsplattform, sind eine Partnerschaft eingegangen, die das Beste aus beiden Welten vereint: den optimierten DevSecOps-Workflow von GitLab und die leistungsstarke Sicherheitslückenverwaltung von HackerOne.\n\nIn diesem Tutorial erfährst du, wie du die Produktivität der Entwickler(innen) und deine Sicherheitslage verbessern kannst, indem du die GitLab-Integration von HackerOne implementierst.\n\n## Eine Integration, die Entwickler(innen) befähigt\n\nDie GitLab-Integration von HackerOne ist bemerkenswert einfach und dennoch leistungsstark. Wenn Sicherheitsexpert(inn)en Sicherheitslücken über die Plattform von HackerOne entdecken, werden diese Erkenntnisse automatisch in GitLab-Tickets umgewandelt. Dadurch entsteht ein nahtloser Workflow, der folgendermaßen abläuft:\n\n* Sicherheitsexpert(inn)en identifizieren Sicherheitslücken über die Plattform von HackerOne.\n* Validierte Sicherheitslücken werden automatisch in GitLab-Tickets umgewandelt.\n* Entwicklungsteams können diese Tickets direkt in ihren bestehenden Workflows bearbeiten.\n* Der Lösungsstatus wird zwischen beiden Plattformen synchronisiert.\n\nDu kannst die Vorteile von GitLab und HackerOne nutzen, indem du die [Integration](https://docs.hackerone.com/en/articles/8571227-gitlab-integration) verwendest und GitLab-Tickets als Referenzen auf HackerOne nachverfolgst. Diese Integration bietet eine bidirektionale und nahtlose Datensynchronisierung zwischen deinem HackerOne-Bericht und dem GitLab-Ticket, wodurch die Abstimmung zwischen Entwicklungs- und Sicherheitsteams verbessert und die Behebung von Sicherheitslücken optimiert wird.\n\nFolge den Anweisungen in der [GitLab-Integrationsdokumentation von HackerOne](https://docs.hackerone.com/en/articles/10394699-gitlab-setup), um die GitLab-Integration so zu konfigurieren, dass sie Informationen zwischen deinem HackerOne-Bericht und deinem GitLab-Ticket synchronisiert. Dies umfasst folgende Schritte:\n\n1. [Einrichtung einer OAuth-2.0-Anwendung](https://docs.gitlab.com/ee/integration/oauth_provider.html) für deine GitLab-Instanz mit den bereitgestellten HackerOne-Einstellungen\n2. Verbindung von HackerOne zum neu erstellten OAuth 2.0 auf GitLab\n3. Berechtigung von HackerOne, auf die GitLab-API zuzugreifen\n4. Festlegung des GitLab-Projekts, das du zu HackerOne-Berichten eskalieren möchtest\n5. Auswahl der HackerOne-Felder, die den entsprechenden GitLab-Feldern zugeordnet werden sollen\n6. Ereigniskonfiguration für GitLab zu HackerOne und umgekehrt\n\nSobald die Integration eingerichtet wurde, kannst du Daten bidirektional und nahtlos zwischen GitLab und HackerOne synchronisieren. Dies vereinfacht den Kontextwechsel und ermöglicht es, Sicherheitslücken einfach in beiden Systemen nachzuverfolgen. Die Integration bietet die folgenden Funktionen:\n\n* **Erstellen eines GitLab-Tickets aus HackerOne:** Du kannst neue GitLab-Tickets für Berichte erstellen, die du auf HackerOne erhältst.  \n* **Verknüpfung von HackerOne-Berichten mit bestehenden GitLab-Aufgaben.**   \n* **Synchronisierung von Updates von HackerOne zu GitLab:** Die folgenden Updates eines Berichts werden als Kommentar zu GitLab synchronisiert.\n  * Berichtskommentare  \n  * Staatusänderungen  \n  * Belohnungen  \n  * Änderungen der zuständigen Person  \n  * Öffentlichmachung  \n  * Schließen von GitLab-Tickets  \n* **Synchronisierung von Updates von GitLab zu HackerOne:** Die folgenden Updates in GitLab werden in HackerOne als interner Kommentar zum jeweiligen Bericht angezeigt:  \n  * Kommentare  \n  * Statusänderungen  \n* **Zuordnung von HackerOne-Schweregraden zu GitLab-Labels**: Dadurch kannst du eine benutzerdefinierte Priorität festlegen, wenn du einen Bericht zu GitLab eskalierst.  \n* **Zuordnung von Fälligkeitsdaten:** Damit kannst du basierend auf dem Schweregrad eines Berichts automatisch ein benutzerdefiniertes Fälligkeitsdatum festlegen.\n\n![GitLab und HackerOne fügen Kommentare hinzu oder ändern den Status des Berichts in GitLab](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097510/Blog/Content%20Images/Blog/Content%20Images/sync_aHR0cHM6_1750097509644.png)\n\nDiese Funktionen vereinfachen die Abstimmung zwischen Entwicklungs- und Sicherheitsteams und optimieren die Behebung von Sicherheitslücken. Weitere Informationen zur Funktionsweise der Integration findest du in der [Integrationsdokumentation](https://docs.hackerone.com/en/articles/8571227-gitlab-integration).\n\n## Ein Blick in die Bug-Bounty-Programme von HackerOne\n\nHackerOne bietet Bug-Bounty-Programme oder Cybersicherheitsinitiativen an, bei denen man Belohnungen bekommt, wenn Sicherheitslücken in den Softwaresystemen, Websites oder Anwendungen von Kund(inn)en entdeckt und gemeldet werden. Bug-Bounty-Programme tragen auf folgende Weise zur Sicherheit einer Anwendung bei:\n\n* Sie helfen, Sicherheitsschwachstellen zu identifizieren, bevor diese missbraucht werden können.\n* Sie ermöglichen es, die vielfältige Expertise einer weltweiten Community aus Sicherheitsexpert(inn)en zu nutzen.\n* Sie sind eine kostengünstige Möglichkeit, die Cybersicherheit zu verbessern.\n* Sie ergänzen interne Sicherheitsmaßnahmen und traditionelle Penetrationstests.\n\nGitLab nutzt das Bug-Bounty-Programm von HackerOne und ermöglicht es Sicherheitsexpert(inn)en, Sicherheitslücken in den Anwendungen oder der Infrastruktur von GitLab zu melden. Dieser Crowdsourcing-Ansatz hilft GitLab, potenzielle Sicherheitsprobleme effektiver zu erkennen und zu beheben.\n\n![Bug-Bounty-Seite für GitLab auf HackerOne](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097510/Blog/Content%20Images/Blog/Content%20Images/hackerone_gitlab_bug_bounty_page_aHR0cHM6_1750097509645.png)\n\nIndem Unternehmen die Plattform und die globale Hacker(innen)-Community von HackerOne nutzen, können sie ihre Sicherheitslage deutlich verbessern, Sicherheitslücken schneller erkennen und potenziellen Bedrohungen immer einen Schritt voraus sein.\n\n## Sichere deine Anwendungen und verbessere die Effizienz mit GitLab\n\nGitLab ist eine umfassende DevSecOps-Plattform mit Funktionen für den gesamten Software-Entwicklungsprozess und enthält unter anderem auch Sicherheits- und Compliance-Tools. GitLab unterstützt die folgenden Arten von Sicherheitsscannern:\n- Statische Anwendungssicherheitstests (SAST)\n- Dynamische Anwendungssicherheitstests (DAST)\n- Container-Scanning\n- Abhängigkeitssuche\n- Infrastructure-as-Code-Scanning\n- Abdeckungsgesteuertes Fuzzing\n- Web-API-Fuzzing\n\nMit GitLab kannst du Sicherheitsscans hinzufügen, indem du einfach eine Vorlage auf deine CI/CD-Pipeline-Definitionsdatei anwendest. Ein SAST kann beispielsweise mit einigen wenigen Zeilen Code in der Datei `.gitlab-ci.yml` hinzugefügt werden:\n\n```yaml\nstage:\n  - test\n\ninclude:\n  - template: Jobs/SAST.gitlab-ci.yml\n```\n\nDadurch wird der SAST in der Testphase ausgeführt und es werden [automatisch die verwendeten Sprachen in deiner Anwendung erkannt](https://docs.gitlab.com/ee/user/application_security/sast/#supported-languages-and-frameworks). Wenn du dann einen Merge Request erstellst, erkennt der SAST Sicherheitslücken im diff zwischen dem Feature-Branch und dem Zielbranch und stellt relevante Daten für die einzelnen Sicherheitslücken bereit, damit diese behoben werden können.\n\n![NoSQL-Injection-Sicherheitslücke im MR](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097510/Blog/Content%20Images/Blog/Content%20Images/no_sql_injection_vulnerability_mr_view_aHR0cHM6_1750097509647.png)\n\nDie Ergebnisse des SAST-Scanners können das Zusammenführen von Code blockieren, wenn Sicherheitsrichtlinien eingehalten werden müssen. Native GitLab-Benutzer(innen) können als Genehmiger(innen) festgelegt werden, sodass die erforderlichen Überprüfungen vor dem Zusammenführen von unsicherem Code durchgeführt werden müssen. Dadurch wird sichergestellt, dass alle Sicherheitslücken von den zuständigen Personen überwacht werden.\n\n![Genehmigungsrichtlinie für Merge Requests](https://res.cloudinary.com/about-gitlab-com/image/upload/v1750097510/Blog/Content%20Images/Blog/Content%20Images/merge_request_approval_policy_aHR0cHM6_1750097509649.png)\n\nHackerOne hat GitLab auf verschiedene wichtige Arten in seine Betriebs- und Entwicklungsprozesse integriert, was zu Verbesserungen des Entwicklungsprozesses und einer verbesserten Skalierbarkeit und Zusammenarbeit geführt hat. Zu diesen Verbesserungen gehören schnellere Bereitstellungen und teamübergreifende Planung.\n\n## Hauptvorteile der GitLab-Integration von HackerOne\n\nWerden HackerOne und GitLab zusammen genutzt, erwarten dich folgende Hauptvorteile:\n\n* **Verbesserte Transparenz bei der Sicherheit:** Entwicklungsteams erhalten sofortige Einblicke in Sicherheitslücken, ohne ihre primäre Workflow-Umgebung verlassen zu müssen. Durch diese Erkenntnisse in Echtzeit können Teams Sicherheitsprobleme priorisieren und trotzdem die Entwicklung von Funktionen vorantreiben.\n* **Optimierter Prozess zur Fehlerbehebung:** Indem HackerOne-Berichte direkt in GitLab-Tickets umgewandelt werden, wird die Fehlerbehebung Teil des Standardentwicklungszyklus. Dadurch entfällt der Kontextwechsel zwischen Plattformen und Sicherheitsfixes werden zusammen mit anderen Entwicklungsarbeiten nachverfolgt.  \n* **Raschere Fehlerbehebung:** Die Integration verkürzt die Zeit zwischen der Entdeckung und der Behebung von Sicherheitslücken erheblich. Da HackerOne-Beiträge sofort in GitLab verfügbar sind, können Entwicklungsteams ohne Verzögerung mit der Behebung der Fehler beginnen und so die allgemeine Sicherheitslage verbessern.\n***Verbesserte Zusammenarbeit:** Sicherheitsexpert(inn)en, Sicherheitsteams und Entwickler(innen) können durch diese Integration effektiver kommunizieren. Kommentare und Aktualisierungen werden zwischen beiden Plattformen synchronisiert, wodurch eine kollaborative Umgebung entsteht, bei der die Verbesserung der Sicherheit im Vordergrund steht.\n* **Praktische Auswirkungen:** Unternehmen, die die Integration von HackerOne und GitLab implementiert haben, berichten von folgenden Vorteilen:  \n  * Bis zu 70 % kürzere Zeit von der Entdeckung bis zur Behebung von Sicherheitslücken\n  * Höhere Zufriedenheit der Entwickler(innen), da sie in ihrem bevorzugten Workflow bleiben können\n  * Verbesserte Transparenz hinsichtlich der Sicherheit im gesamten Unternehmen  \n  * Effektivere Zuweisung von Sicherheitsressourcen\n\n> Sieh dir jetzt die [Seite zur Einrichtung der Integration](https://docs.hackerone.com/en/articles/10394699-gitlab-setup) an, um sofort loszulegen.\n\n## Mehr erfahren\n\nWeitere Informationen zu GitLab und HackerOne sowie darüber, wie du deine Sicherheitslage verbessern kannst, findest du in den folgenden Ressourcen:\n* [Nutzung der GitLab-Integration von HackerOne (nur in englischer Sprache verfügbar)](https://docs.hackerone.com/en/articles/8571227-gitlab-integration)  \n* [Bug-Bounty-Programm von GitLab in Zusammenarbeit mit HackerOne (nur in englischer Sprache verfügbar)](https://hackerone.com/gitlab?type=team)\n* [Sicherheits- und Compliance-Lösungen von GitLab](https://about.gitlab.com/de-de/solutions/security-compliance/)  \n* [HackerOne erreicht 5 x schnellere Implementierungen dank der integrierten Sicherheit von GitLab](https://about.gitlab.com/de-de/customers/hackerone/)  \n* [Dokumentation zur Anwendungssicherheit von GitLab](https://docs.gitlab.com/ee/user/application_security/)  \n",[776,810,234,284,808,716,1145],"bug bounty",{"slug":1147,"featured":6,"template":797},"enhance-application-security-with-gitlab-hackerone",{"content":1149,"config":1158},{"title":1150,"description":1151,"authors":1152,"heroImage":1153,"date":1154,"body":1155,"category":776,"tags":1156},"Was du über Self-Hosting & Cloud-Hosting wissen solltest ","Self-Hosting oder Cloud? Wir zeigen dir, welche Vorteile und Nachteile diese Modell haben - und was für eine Rolle GitLab dabei spielt.",[789],"https://res.cloudinary.com/about-gitlab-com/image/upload/v1749664270/Blog/Hero%20Images/AdobeStock_276584891.jpg","2025-02-27","# Was du über Self-Hosting und Cloud-Hosting wissen solltest\n\n„Stets online zu sein ist kein Luxus - es ist in dieser schnelllebigen Zeit eine Notwendigkeit.” Dieses anonyme Zitat bringt die Bedeutung einer sicheren, stabilen und rundum überzeugenden Web-Präsenz auf den Punkt: Mit deiner Website gewinnst und hältst du Kund(inn)en, informierst Interessierte und eröffnest ihnen Kontaktmöglichkeiten, bietest Downloads und Dienstleistungen, oder physische Produkte an. \n\nDamit wird zugleich die hohe Bedeutung des passenden Webhostings klar: Einerseits sollten deine Daten stets für Befugte zugänglich sein, andererseits müssen sie vor unerwünschten Zugriffen und Angriffen geschützt bleiben. Mit der Entscheidung des für dich richtigen Hosting-Pakets stellst du die Weichen auf Erfolg und unterstützt dein Unternehmen langfristig in seiner digitalen Strategie.\n\nDie Bedeutung des Hostings geht sogar noch über das Bereitstellen von Websites hinaus. Auch für DevOps-Teams ist die Entscheidung darüber, wie und wo welche Daten gehostet werden sollen, alles andere als eine Formalität und sollte niemals ausschließlich aufgrund der Kosten getroffen werden.\n\nStehst du gerade vor der Frage, welches Hosting für dich die beste Wahl ist? Dann lies weiter. Denn in diesem Artikel stellen wir dir die drei grundlegenden Hosting-Modelle vor und erklären dir die jeweiligen Vor- und Nachteile. Einiges davon könnte dich überraschen.\n\n## Welcher Zusammenhang besteht zwischen Webhosting und DevOps?\n\nDevOps wird eher selten im Zusammenhang mit Hosting diskutiert. Dabei besteht zwischen den beiden ein sehr enger Bezug, unabhängig davon, ob du dich für ein Self-Hosting-Modell oder Cloud-Hosting entscheidest.\n\nBeim Hosting werden Anwendungen und Inhalte auf einem Server abgelegt und kontrolliert verfügbar gemacht. Ein wichtiger Aspekt von DevOps besteht in der Automatisierung des Deployments von Informationen und Inhalten für deine Website, die auf dem Server gehostet wird. \nIn der Entwicklungspraxis werden die Anwendungen, an denen ein DevOps-Team arbeitet, auf einem gemeinsam genutzten Server gehostet. Nur, wenn das Hosting optimal funktioniert, kann DevOps optimal funktionieren.\n\nIn großen Projekten sind die Verflechtungen oftmals sogar noch enger. So stellen manche Hosting-Dienstleister in ihrem Paket Anwendungen zur Verfügung, mit denen der DevOps-Prozess skaliert und möglichst harmonisch gestaltet werden kann. So greifen die beiden Bereiche ineinander. \nWenn DevOps ein zentrales Element deiner Arbeit darstellt, empfehlen wir dir deshalb, dich intensiv mit dem Thema Hosting auseinanderzusetzen. \n\n## Was muss gutes Webhosting leisten?\n\nDer Begriff Hosting beinhaltet das Speichern und Bereitstellen von Daten über einen Server. Nutzer(innen) greifen auf die Daten zu, die auf dem Server abgelegt sind, können Bestellungen aufgeben oder über ein Kontaktformular Anfragen schicken. \nWas macht gutes Webhosting aus? \n\nAlle Seiten und Anwendungen sollten schnell abrufbar sein, fehlerfrei bleiben und rund um die Uhr zur Verfügung stehen. Die Privatsphäre der Anwender(innen) muss ebenso gewährleistet werden wie die Integrität deiner Unternehmensdaten. Eventuelle Ausfälle werden umgehend beseitigt und das System stets auf dem technisch aktuellen sowie erforderlichen Stand gehalten. \nKurz gesagt: Das zentrale Ziel sollte darin bestehen, dass die User-Experience flüssig, nahtlos und stabil ist. Das richtige Hosting garantiert diese Qualität und passt sie kontinuierlich an aktuelle Gegebenheiten und Forderungen an. \nUm das für dich richtige Hosting zu ermitteln, stellt sich zuerst eine allgemeine Frage: \n\n## Welche Hosting-Optionen stehen mir zur Verfügung?\n\nGrundsätzlich gliedert sich Hosting in drei Varianten auf: Das Self-Hosting, Hosting in der Cloud und die Private Cloud. Wenn du selbst das Hosting übernimmst, bedeutet das, dass du in deinem Unternehmen einen oder mehrere Server einrichtest und deine Websites über diese laufen lässt. Da ein Server zunächst einmal nichts anderes ist als ein regulärer Computer und dir eine Vielzahl bewährter Softwarelösungen für den Betrieb eines Servers zur Verfügung stehen, mutet Self-Hosting (beziehungsweise „On-Premise-Hosting”) nicht übermäßig komplex an. Im nächsten Abschnitt stellen wir diese Vermutung auf den Prüfstand.\n\nDas Gegenmodell zum Self-Hosting-Modell ist das Cloud-Hosting. Die Cloud, in der deine Daten eingebettet werden, ist dabei schlicht eine Server-Architektur, die von externen Anbieter(innen) bereitgestellt wird. Diese speichern die Daten ab, stellen sämtliche erforderliche Software zur Verfügung und sorgen für einen reibungslosen Ablauf. In den frühen Jahren litten Cloud-Lösungen bei vielen Entscheidungsträger(inne)n unter einem Vertrauensdefizit. Doch haben sie in den letzten Jahren zunehmend an Beliebtheit gewonnen und stellen heute den De-Facto-Standard dar. Die Gründe dafür erklären wir dir ein wenig später in diesem Artikel.\n\nDa sowohl Self-Hosting als auch Cloud-Hosting jeweils ganz bestimmte Vorteile haben, welche die andere Lösung nicht anbieten kann, ist in den letzten Jahren verstärkt der Ruf nach einer Art Fusion der beiden Ansätze lauter geworden. Das Private-Cloud-Hosting stellt den Versuch eines Ausgleichs und einer Harmonisierung der jeweiligen Vor- und Nachteile beider Hosting-Modelle dar. Das gelingt in der Regel auch sehr gut, ist aber mit entsprechend hohen Kosten verbunden.\nFalls du GitLab nutzt, besteht sogar noch eine weitere Option:\n\n## Du kannst auch direkt über GitLab hosten!\n\nWenn du bereits für deine [CI/CD-Pipeline](https://about.gitlab.com/topics/ci-cd/cicd-pipeline/) mit GitLab arbeitest, ist das Hosten über GitLab für viele Projekte die optimale Variante. Wie wir oben erwähnt haben, ist eine flüssige, nahtlose und stabile User-Experience das oberste Ziel beim Hosting. Gleiches gilt selbstverständlich auch für die Entwicklungsarbeit. Je weniger Zwischenschritte erforderlich sind, um deine Webseite aus dem Entwicklungsstadium heraus öffentlich zu machen, umso geringer das Fehlerpotential und umso effizienter der Prozess als Ganzes.\n\nAus diesem Grund entscheiden sich viele DevOps-Teams, ihre Websites direkt aus dem Repository heraus zu veröffentlichen. Dabei übernimmt GitLab die gesamte Verwaltung der Daten und viele der beim Hosting anfallenden Aufgaben. Und da wir auf das Thema Sicherheit besonders großen Wert legen, kannst du dich darauf verlassen, dass deine Daten in guten Händen sind.\nAllerdings beschränkt sich die [Hosting-Funktionalität](https://about.gitlab.com/blog/gitlab-pages-setup/) von GitLab auf statische Seiten. Wenn du damit an einem dynamischen Projekt arbeitest, lies weiter, um zu erfahren, worauf du bei der Auswahl Wert legen solltest. \n\n## Welche Kriterien gilt es beim Hosting zu beachten?\n\nHosting ist ein recht einfaches Konzept, doch in seinen Details durchaus komplex. So gibt es eine Vielzahl an Kriterien, die es bei der Auswahl des für dich passenden Modells zu beachten gilt:\n\n- __Kosten:__ Hosting erfordert den Einsatz hochwertiger Hardware und Software sowie geschulten Personals. Je höher und individueller deine Ansprüche, umso höher die Kosten. Je mehr Daten du auf dem Server zu speichern beabsichtigst und je mehr Nutzer(innen) voraussichtlich auf diese Daten zugreifen, umso höher sind die Ansprüche an die Übertragungsleistung - und folglich umso höher auch die Ansprüche an das Hosting.\n\n- __Skalierbarkeit:__ Wenn sich deine Bedürfnisse an die Serverleistung ändern, ist es stets von Vorteil, schnell Anpassungen vornehmen zu können. Je höher die Skalierbarkeit einer Hosting-Lösung, umso besser.\n- \n- __Sicherheit:__ Deine Daten sind dein Kapital. Sie sind aber auch deine Verantwortung und in vielen Fällen an sehr genaue gesetzliche Vorgaben gebunden. Aus diesem Grund genießt die Wahrung der Integrität und Zugriffssicherung persönlicher Informationen, sowie der Informationen all derer, die auf sie zugreifen, höchste Priorität.\nde- __Aktualisierbarkeit:__ Hosting ist eine hochtechnologische Dienstleistung in einem sich rapide wandelnden Umfeld. Nur, wenn du deine Server stets auf dem aktuellen Stand hältst, kannst du die bestmögliche Umsetzung der anderen Kriterien gewährleisten. \n\n- __Flexibilität:__ Es gibt inzwischen eine Vielzahl standardisierter Anwendungen für die unterschiedlichsten Aspekte des Hostings. Das senkt Kosten, kann aber zu Konflikten mit deinen persönlichen Bedürfnissen und Ansprüchen führen. Individuelle Programme und Konfigurationen bieten oftmals mehr Flexibilität. \n\n- __Implementierbarkeit:__ Zwischen Entscheidungsfindung und -Umsetzung können oftmals längere Pausen entstehen. Je schneller dieser Prozess abläuft, desto besser.\nBenutzerfreundlichkeit: Gerade was den täglichen Betrieb angeht, gibt es bei der Wahl des Hosting-Modells erhebliche Unterschiede. Ein Server, dessen Betrieb, Wartung und Aktualisierung intuitiv abläuft, reduziert deinen Aufwand.\n\nJe nachdem, wo deine Ansprüche liegen, wird sich eines der folgenden Modelle für dich als besser geeignet erweisen. Sehen wir uns die jeweiligen Vor- und Nachteile genauer an. \n\n## On-Premise-Hosting/Self-Hosting: Vorteile\n\nViele Jahre lang waren die beiden Begriffe Hosting und Self-Hosting synonym. In den ersten zwei Jahrzehnten des Internets erschien die Vorstellung einer Auslagerung der eigenen Homepage alleine schon aufgrund niedriger Datenübertragungsraten geradezu utopisch. Inzwischen hat sich das Blatt gewendet. Sogar erfahrene Hoster und IT-Experten halten Cloud-Lösungen in den meisten Fällen für die geeignetere Wahl. Dennoch gibt es bis heute unbestreitbare Vorteile des Self-Hostings, die einen genaueren Blick rechtfertigen.\n\nDie große Stärke eines Self-Hosting-Modells besteht ganz offensichtlich darin, dass alle deine Daten bei dir liegen. Du hast also direkten Zugriff und behältst jederzeit die Kontrolle über sie. Darüber hinaus kannst du die Hard- und Software optimal an deine persönlichen Bedürfnisse anpassen. \n\nSelf-Hosting bietet außerdem gewisse Sicherheitsvorteile. Es besteht beispielsweise ein weitaus geringeres Risiko, dass sich Mitarbeiter(innen) einer externen Firma Zugriff auf deine Daten verschaffen. Da du selbst die Sicherheitsmaßnahmen definierst, kannst du die Messlatte sehr hoch ansetzen, um Missbrauch auszuschließen.\nVor allem ist es auf deinen eigenen Servern möglich, für extrem sensible Daten die Einhaltung gesetzlicher Standards zu sichern, die möglicherweise in der Cloud nicht garantiert werden können. \n## On-Premise-Hosting/Self-Hosting: Nachteile\n\nDie Anfänge des Internets waren eine Pionierzeit. Die extrem hohen Anforderungen, die Self-Hosting an das technische Knowhow der Beteiligten stellte, boten gleichzeitig eine großartige Chance, zu lernen und das eigene IT-Verständnis zu verbessern. \nDieser Aspekt hat inzwischen deutlich an Relevanz eingebüßt. Webhosting stellt schlicht eine Infrastruktur zur Verfügung und die meisten Aufgaben werden automatisch von spezialisierten Anwendungen übernommen. \n\nGleichzeitig verlangt der rapide technische Wandel die regelmäßige Durchführung von Updates in sehr kurzen Abständen. Auch müssen Ausfälle unmittelbar und schnell behoben werden. Der Sicherheitsvorsprung des Self-Hosting kann sich nur dann entfalten, wenn du dir ein tiefes Wissen über die besten Lösungen und die geforderten Standards aneignest. All dies überfordert die meisten mittelständischen Unternehmen oder zwingt sie zu hohen Investitionen in Personal und Infrastruktur.Die zunehmende Dominanz des Cloud-Hosting ist darauf zurückzuführen, dass es in einigen essentiellen Punkten deutliche Vorteile gegenüber dem On-Premise-Ansatz aufweist. Sehen wir uns diese genauer an.\n\n## Cloud-Hosting: Vorteile\n\n### Was ist Cloud-Hosting?\n\nBeim Cloud-Hosting  übernimmt der Dienstleistungsanbieter die Investitionen in die Hard- und Software. Das bedeutet, dass der sehr hohe Kapitalaufwand, der beim Self-Hosting unweigerlich entsteht, sich auf mehrere Kunden verteilt. Auch verfügen diese Betriebe über Personal, welches speziell auf die Herausforderungen des Hostings geschult ist und sich dem Thema, und somit ganz konkret deinen Daten, 24 Stunden am Tag widmen kann. Updates werden routinemäßig durchgeführt, Ausfälle (in der Regel) sofort erkannt und so schnell wie möglich behoben. Und all das zu deutlich geringeren Kosten als beim Self-Hosting. \n\nGerade im Hinblick auf das wichtige Thema Skalierbarkeit ist Cloud-Hosting das Optimum. Du benötigst kurzfristig oder auch nur vorübergehend mehr Speicherplatz, weil du große Mediendateien auf dem Server unterbringen willst? Statt dir, wie beim Self-Hosting erforderlich, zusätzlichen physischen Speicherplatz anzuschaffen, kannst du in der Cloud dein Paket bequem erweitern. Das ist im Allgemeinen sogar für saisonale und vorübergehende Peaks möglich. So könntest du bei Bedarf die Ressourcennutzung wenige Monate lang erhöhen und anschließend wieder auf das ursprüngliche Niveau herunterfahren.\n\nIm direkten Vergleich von Self-Hosting vs Cloud-Hosting bietet das Cloud-Hosting somit mehr Flexibilität und Freiraum für schnelle Änderungen. Darüber hinaus besteht eine sehr natürliche Verbindung zu DevOps und [DevSecOps](https://about.gitlab.com/de-de/topics/devsecops/). \n\n## Cloud-Hosting: Nachteile\n\nGanz ohne Nachteile kommt selbstverständlich auch das Cloud-Hosting nicht aus. Gegenüber dem On-Premise-Modell ist die Cloud meist weniger flexibel im Hinblick auf individuelle Lösungen. Die meisten seiner Vorzüge zieht dieses Konzept schließlich gerade daraus, dass es auf breiter Basis und für nahezu alle Anwender funktioniert. Sonderwünsche können dabei eher selten berücksichtigt werden. In der Regel spielt das auch keine Rolle. Für alle, deren Ansprüche im Hinblick auf die Funktionalität über den üblichen Standard hinausgehen, werden Clouds aber nicht zufriedenstellend sein.\nAuch das Thema Sicherheit ist ein zweischneidiges Schwert. Hier geht nichts über einen perfekt eingerichteten, von Experten betreuten und stets aktualisierten On-Premise-Server. Demgegenüber besteht bei Cloud-Anbieter(inne)n stets die Gefahr, dass die Server nicht mit der besten Software ausgerüstet sind und somit Sicherheitslücken entstehen, durch die Daten kompromittiert werden können. \nAndererseits muss festgehalten werden: Sicherheitslücken entstehen auch beim Self-Hosting und das Aufrechterhalten der höchsten Standards ist sehr teuer. Viele Hoster wiederum haben in den letzten Jahren ihr Bemühen um höchste Security-Leistungen erhöht und beauftragen externe Dienstleister, um diese zu zertifizieren. So nähern sich die Levels der beiden Bereiche, Cloud- vs. Self-Hosting, einander an. \n\n## Public Cloud: Das Beste beider Welten?\n\nViele Vorzüge eines Modells lassen sich nicht oder nur sehr schwer auf das andere übertragen. So standen viele Firmen vor dem Dilemma, sich für einen Ansatz zu entscheiden, dabei aber auf die Vorteile des anderen verzichten zu müssen.\n\nDie Public Cloud ist der Versuch, Self-Hosting und Cloud-Hosting miteinander zu verschmelzen. Hierbei werden deine Daten auf Servern eines externen Anbieters untergebracht. Doch werden dabei jeweils komplette Hardware-Bereiche exklusiv für dich reserviert. Das bedeutet, dass auf den Rechnern, auf denen deine Webanwendungen betrieben werden, keine Daten weiterer Unternehmen liegen. Die Daten sind somit physisch und auch sicherheitstechnisch getrennt.\n\nSo wird die Sicherheit beträchtlich erhöht und nähert sich weiter dem On-Premise-Niveau an. Sie ist teurer als Cloud-Pakete, aber in der Regel günstiger als eine Self-hosted-Cloud. Unter anderem, weil du nur für genau die Ressourcen bezahlst, die du auch tatsächlich verwendest. Die Skalierbarkeit ist ebenso einfach möglich wie bei einer Cloud, wenngleich du mit gewissen Einschränkungen in Hinblick auf die Bereitstellung rechnen musst. Oftmals kannst du Sonderwünsche sogar in Absprache mit Dienstleister(innen) äußern und umsetzen.\n\nIst die Public Cloud somit die perfekte Lösung? Das wäre eine wohl zu allgemeine Aussage, denn für die meisten wird bereits der deutlich höhere Preis dieses Konzepts ein Ausschlusskriterium darstellen. Darüber hinaus ist in der Public Cloud nicht immer die Übernahme aller Wartungsmaßnahmen und Aktualisierungen im Paket inbegriffen. Solltest du diese Aspekte selbst übernehmen müssen, entsteht letzten Endes derselbe Aufwand wie bei einem Self-Hosting-Modell.\n\n## FAQ\n\n### Was ist GitLab Pages und wie unterstützt es mein Hosting?\n\nGitLab [Pages](https://docs.gitlab.com/ee/user/project/pages/) ist eine Funktionalität, die es dir erlaubt, statische Websites direkt über GitLab zu hosten. Das bedeutet, dass du die Website im Repository anlegen, bearbeiten und anschließend veröffentlichen kannst. Hierbei fallen keine weiteren Zwischenschritte an und die Wahrscheinlichkeit für Fehler sinkt. \n\nDer größte Pluspunkt besteht darin, dass du unmittelbar von allen CI/CD-Funktionalitäten, darunter beispielsweise der ständigen Versionskontrolle, Gebrauch machen, sowie Änderungen direkt aus dem Repository vornehmen kannst. Auch ein Rollback auf die vorige Version gestaltet sich als extrem unkompliziert. Bei der Nutzung von GitLab Pages entstehen zudem keine zusätzlichen Kosten. \n\n### Ist Self-Hosting sicherer als Cloud-Hosting?\n\nDie meisten Experten schätzen ein Self-Hosting-Modell als __die sicherste Option__ ein. Dies erklärt sich dadurch, dass du als Server-Betreiber die höchsten Standards setzen und einhalten kannst, die Chancen für einen unrechtmäßigen Zugriff auf die Daten sinken und individuelle Sicherheitspakete zusammengestellt werden können, die speziell auf deine Bedürfnisse zugeschnitten sind.\n\nAllerdings gilt dieser Vorteil nur, wenn das Hosting von erfahrenen Mitarbeiter(innen) übernommen wird. Diese müssen zudem über ausreichend zeitliche Reserven verfügen, um das System stets auf dem neuesten Stand zu halten und bei eventuellen Aus- oder Zwischenfällen unmittelbar eine Problemlösung durchzuführen. Ein wichtiger Punkt bei der Entscheidung über das für dich richtige Hosting ist oftmals die Frage nach der Einhaltung gewisser rechtlicher Vorgaben. Hier solltest du genau prüfen, ob dein Cloud-Anbieter die erforderlichen Kriterien erfüllen kann.\n",[1157,776],"cloud native",{"slug":1159,"featured":6,"template":797},"self hosting vs cloud",{"content":1161,"config":1164},{"heroImage":1086,"body":1087,"authors":1162,"updatedDate":938,"date":1091,"title":1092,"tags":1163,"description":1094,"category":765},[1089,1090],[284,765,109,716],{"featured":91,"template":797,"slug":1096},[1166,1171,1176],{"content":1167,"config":1170},{"heroImage":1099,"body":1100,"authors":1168,"updatedDate":7,"date":939,"title":1102,"tags":1169,"description":1104,"category":765},[1013],[1018,765,743,808],{"slug":1106,"featured":91,"template":797},{"content":1172,"config":1175},{"heroImage":934,"body":935,"authors":1173,"updatedDate":938,"date":939,"title":940,"tags":1174,"description":942,"category":720},[937],[716,808,765],{"slug":944,"featured":6,"template":797},{"content":1177,"config":1180},{"title":830,"description":831,"authors":1178,"heroImage":834,"date":835,"body":836,"category":684,"tags":1179,"updatedDate":839},[833],[838,743,809,808,765,810],{"slug":841,"featured":91,"template":797},[1182,1187,1192],{"content":1183,"config":1186},{"title":786,"description":787,"authors":1184,"heroImage":790,"date":791,"body":792,"category":673,"tags":1185,"updatedDate":791},[789],[794],{"slug":796,"featured":6,"template":797},{"content":1188,"config":1191},{"title":973,"description":974,"authors":1189,"heroImage":976,"date":977,"body":978,"category":732,"tags":1190,"updatedDate":977},[789],[551],{"slug":981,"featured":6,"template":797},{"content":1193,"config":1201},{"title":1194,"description":1195,"authors":1196,"heroImage":1198,"date":977,"body":1199,"category":765,"tags":1200,"updatedDate":791},"Künstliche Intelligenz für alle Kund(inn)en von GitLab Premium und Ultimate","GitLab Premium und Ultimate umfassen jetzt GitLab Duo für die Erstellung und das Verständnis von Code während des gesamten Lebenszyklus der Softwareentwicklung – und das ohne zusätzliche Kosten.",[1197],"David DeSanto, Chief Product Officer, GitLab","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749660188/Blog/Hero%20Images/blog-premium-with-duo-cover-0756-fy26-v2-1800x945.png","Heute präsentieren wir GitLab 18.0, das unsere neuesten Innovationen und Pläne in den Bereichen DevSecOps-Workflows, Sicherheit und Compliance sowie KI in den Vordergrund stellt.\n\n**Ab dieser Version enthalten GitLab Premium und Ultimate jetzt auch die grundlegenden KI-Funktionen von GitLab Duo – und das ohne zusätzliche Kosten.**\n\nAlle Kund(inn)en mit Premium- und Ultimate-Lizenz erhalten sofort Zugang zu GitLab Duo Codevorschläge und Duo Chat direkt in ihren bevorzugten unterstützten Quellcode-Editoren und IDEs.\n\n## KI für jedes Entwicklungsteam\n\nKünstliche Intelligenz steht jetzt im Mittelpunkt der Entwicklererfahrung. KI verbessert die Programmierung in vielerlei Hinsicht: Sie analysiert deine Codebase und liefert dir während der Eingabe Vorschläge in Echtzeit, erstellt Funktionen und Methoden basierend auf dem Kontext deines Projekts, reduziert sich wiederholende Aufgaben und automatisiert Code Reviews.\n\nIn den letzten Jahren haben wir [GitLab Duo](https://about.gitlab.com/de-de/gitlab-duo/) entwickelt, um generative und agentische KI-Funktionen wie diese in unsere Plattform einzubauen. Da das Schreiben von Code nur der Anfang des Software-Lebenszyklus ist – unsere [globale DevSecOps-Studie](https://about.gitlab.com/de-de/developer-survey/) hat ergeben, dass Entwickler(innen) 79 % ihrer Zeit mit anderen Aufgaben als der Code-Erstellung verbringen – haben wir eine Strategie entwickelt, um KI in den gesamten Lebenszyklus der Softwareentwicklung zu integrieren. \n\nJetzt freuen wir uns, den nächsten Schritt nach vorne zu machen, indem wir wesentliche Funktionen von GitLab Duo in unsere GitLab-Premium- und Ultimate-Tarife aufnehmen, damit Entwickler(innen) die Vorteile von KI **ohne zusätzliche Kosten** in Anspruch nehmen können.\n\nDurch die Aufnahme von GitLab Duo Chat und Duo Codevorschläge in Premium und Ultimate können alle Softwareentwickler(innen) ihre Workflows innerhalb der IDE beschleunigen – ohne dass sie separate Tools, Lizenzen oder Governance benötigen. Alle bestehenden Kund(inn)en mit Premium- und Ultimate-Lizenz haben sofortigen Zugriff auf Duo Chat und Codevorschläge, sobald sie auf GitLab 18.0 upgraden, und diese Erweiterung wird zum Standard für alle Neukund(inn)en.\n\n> **„GitLab hat bereits dazu beigetragen, dass wir nicht mehr auf eine fragmentierte Toolchain angewiesen sind, was die Kosten für unzusammenhängende Lösungen gesenkt und unseren Workflow optimiert hat. Die Erweiterung von GitLab Premium mit Duo wird unsere Effizienz und Kosteneinsparungen noch weiter steigern, da unsere Entwickler(innen) weniger Zeit für routinemäßige Programmieraufgaben aufwenden müssen und mehr Zeit für die Bewältigung komplexer Herausforderungen haben, die einen echten geschäftlichen Nutzen bringen.“**\n>\n>- Andrei Nita, Chief Technology Officer bei McKenzie Intelligence Services\n\n\u003Cdiv style=\"padding:56.25% 0 0 0;position:relative;\">\u003Ciframe src=\"https://player.vimeo.com/video/1083723619?badge=0&autopause=0&player_id=0&app_id=58479\" frameborder=\"0\" allow=\"autoplay; fullscreen; picture-in-picture; clipboard-write; encrypted-media\" style=\"position:absolute;top:0;left:0;width:100%;height:100%;\" title=\"GitLab Premium with Duo Core\">\u003C/iframe>\u003C/div>\u003Cscript src=\"https://player.vimeo.com/api/player.js\">\u003C/script>\n\n\u003Cbr>\u003C/br>\nKund(inn)en mit Premium- und Ultimate-Lizenz haben jetzt Zugriff auf die folgenden KI-basierten Funktionen:\n\n#### GitLab Duo Codevorschläge\n\n* Generierung vollständiger Funktionen und Codeblöcke aus Kommentaren  \n* Erhalten intelligenter Code-Vervollständigung während der Eingabe  \n* Unterstützung für mehr als 20 Programmiersprachen  \n* Verfügbar in den meisten gängigen IDEs\n\nIn dieser interaktiven Tour erfährst du mehr über GitLab Duo Codevorschläge (klicke auf das Bild, um die Tour zu starten).\n\n\u003Ca href=\"https://gitlab.navattic.com/code-suggestions\">\u003Cimg src=\"//images.ctfassets.net/r9o86ar0p03f/4nclgZ2JUeQ0hR4wjOS30P/ba948ae1a0dce0cff4469ca06490efb1/Screenshot_2024-08-27_at_9.24.32_AM.png\" alt=\"GitLab Duo Code Suggestions cover image\">\u003C/a>\n\nWeitere Informationen findest du in unserer [Dokumentation zu Duo Codevorschläge (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/project/repository/code_suggestions/).\n\n#### GitLab Duo Chat\n\n* Erklärung von unbekanntem Code, um komplexe Funktionen zu verstehen  \n* Refaktorierung von vorhandenem Code, um Qualität und Wartbarkeit zu verbessern  \n* Generierung umfassender Testfälle, um Bugs früher zu erkennen  \n* Behebung von Codeproblemen direkt in deinem Workflow\n\n![Duo Chat – Erklärung des API-Endpunkts](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749673912/Blog/Content%20Images/Duo_Chat_-_gif_-_API_endpoint_explanation__3_.gif)\n\nWeitere Informationen findest du in unserer [Dokumentation zu Duo Chat (nur in englischer Sprache vefügbar)](https://docs.gitlab.com/user/gitlab_duo_chat/).\n\n> **„Für uns als GitLab-Benutzer(innen) sind die intelligenten Codevorschläge von Duo zu einer täglichen Ressource für unsere Entwickler(innen) geworden. In Kombination mit der Chat-Funktion ermöglicht sie sofortiges Feedback und Iteration, was zu schnelleren Entwicklungszyklen und einer sichereren Codebase führt. Es ist eine nahtlose und leistungsstarke Ergänzung zu unseren Workflows.“**\n>\n>- Felix Kortmann, Chief Technology Officer, Ignite by FORVIA HELLA\n\n## Duo Enterprise jetzt für Kund(inn)en von GitLab Premium verfügbar\n\nAuf vielfachen Wunsch unserer Kund(inn)en könnt ihr jetzt auch mit [GitLab Premium](https://about.gitlab.com/de-de/pricing/premium/) Duo Enterprise, unsere komplette KI-Suite, erwerben, ohne auf GitLab Ultimate upgraden zu müssen. Premium-Kund(inn)en kommen in den Genuss eines umfassenden KI-Erlebnisses, das nahtlos in den gesamten Lebenszyklus der Softwareentwicklung integriert ist. Dazu gehören spannende GitLab Duo-Funktionen wie:\n\n* [Root Cause Analysis (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/gitlab_duo/use_cases/#root-cause-analysis-use-cases) hilft bei der schnellen Behebung von CI/CD-Pipeline-Fehlern und sorgt dafür, dass deine CI/CD-Pipelines stabil bleiben.\n* [Code Review (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/project/merge_requests/duo_in_merge_requests/#have-gitlab-duo-review-your-code) ermöglicht eine schnellere Merge-Request-Review, indem Duo als Code-Prüfer genutzt wird.  \n* [Erweiterter Chat (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/gitlab_duo_chat/) fasst Unterhaltungen zusammen, hilft beim Verständnis von Codeänderungen und bietet erweiterte Konfigurationsunterstützung.  \n* [Self-Hosted (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/administration/gitlab_duo_self_hosted/) ermöglicht den Einsatz von Duo in Air-Gapped- und Offline-Umgebungen, indem genehmigte KI-Modelle für Duo gehostet werden.\n\nNeben der Verfügbarkeit von Duo Enterprise investieren wir weiterhin in den Erfolg unserer GitLab-Premium-Kund(inn)en. Seit der Einführung von GitLab 17 [haben wir mehr als hundert Funktionen und Verbesserungen bereitgestellt](https://gitlab.com/gitlab-org/gitlab/-/releases), darunter: \n\n* Der [**CI/CD-Katalog** (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/ci-cd-catalog-goes-ga-no-more-building-pipelines-from-scratch/) ermöglicht es Entwickler(inne)n, bereits vorhandene CI/CD-Komponenten und -Konfigurationen zu teilen, zu entdecken und wiederzuverwenden.  \n\n* Die [**Artefaktregistrierung** (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/packages/virtual_registry/) bietet Entwickler(inne)n sicheren Zugriff auf Artefakte und eine nahtlose Integration in CI/CD-Pipelines.  \n* [**Remote-Entwicklung** (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/user/project/remote_development/) ermöglicht es Entwickler(inne)n, in bedarfsgerechten,  \nCloud-basierten Entwicklungsumgebungen zu arbeiten.\n\n> [Erfahre mehr über die Funktionen von GitLab Premium (nur in englischer Sprache verfügbar).](https://about.gitlab.com/pricing/premium/#wp-premium-features)\n\n## GitLab Duo: KI, die Unternehmen dort unterstützt, wo sie arbeiten\n\nGitLab-Kund(inn)en haben Zugriff auf eine umfassende Auswahl an Duo-Angeboten, die in unseren Pro- und Enterprise-Lösungen enthalten sind. So können sie genau dort eingesetzt werden, wo du dich im KI-Einführungszyklus befindest. Je weiter deine Teams fortgeschritten sind, desto mehr Funktionen kannst du nutzen, um sichere Software schneller zu entwickeln, zu testen und bereitzustellen.\n\n![Hauptfunktionen in GitLab-Duo-Tarifen](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749673912/Blog/Content%20Images/Screenshot_2025-05-14_at_8.50.34_AM.png)\n\n## Wie bestehende Kund(inn)en von GitLab Ultimate und Premium in GitLab Duo einsteigen können\n\nAb GitLab 18.0 sind die Funktionen Duo Codevorschläge und Duo Chat für bestehende Kund(inn)en von GitLab Ultimate und Premium standardmäßig deaktiviert. Du kannst sie aber ganz einfach aktivieren – wie, erfährst du weiter unten.\n\nSo nutzt du GitLab Premium und Ultimate mit Duo: \n\n1. Stelle sicher, dass du GitLab Premium oder Ultimate hast. Wenn nicht, kannst du es 60 Tage lang kostenlos testen. \n\n2. Aktiviere GitLab Duo in deinen Organisationseinstellungen.\n\n3. Wenn du eine lokale IDE verwendest, installiere die entsprechende [Editor-Erweiterung (nur in englischer Sprache verfügbar)](https://docs.gitlab.com/editor_extensions/#available-extensions) für GitLab. \n\n4. Verwende Codevorschläge und Duo Chat in deiner bevorzugten unterstützten lokalen IDE oder der GitLab Web IDE.\n\n**Hinweis:** Für Neukund(inn)en und Testversionen werden die KI-Funktionen von GitLab automatisch aktiviert.\n\n## KI-native Entwicklung erfordert eine DevSecOps-Plattform\n\nKI verändert die Arbeit der Entwickler(innen) grundlegend. In Unternehmen wird es nicht nur mehr Mitarbeitende geben, die Software entwickeln. Es wird auch mehr produktionsreifen Code geben, der von KI generiert wird – **was GitLab wichtiger denn je macht.** \n\nWir haben GitLab Premium und Ultimate mit Duo speziell für diese neue Realität entwickelt, damit Teams eine sichere Grundlage für ihren gesamten Code haben. Wenn KI in deinem Unternehmen Code generiert, wird GitLab zu deinem Kontrollzentrum: keine separaten Tools für Sicherheitsscans, Compliance-Checks oder die Verwaltung von Pipelines. Es reicht eine einzige, einheitliche Plattform, die mit deinem Unternehmen wächst und sicherstellt, dass der gesamte Code deinen Standards entspricht, bevor er in die Produktion gelangt. Während KI deine Entwicklung beschleunigt, kannst du mit GitLab die Kontrolle, Sicherheit und Qualität von Anfang bis Ende gewährleisten.\n\n> Wenn du mehr über GitLab Duo und die Möglichkeiten erfahren möchtest, wie es die Arbeit deines Teams verändern kann, [besuche unsere GitLab-Premium-Seite](https://about.gitlab.com/de-de/pricing/premium/). Wenn du bereits Kund(in) von GitLab bist, wende dich an deine(n) Ansprechpartner(in) bei GitLab, um eine Demo zu planen. Komm am 24. Juni 2025 zu unserem [virtuellen Launch-Event für GitLab 18 (nur in englischer Sprache verfügbar)](https://about.gitlab.com/eighteen/), um mehr über die Zukunft der KI-nativen Softwareentwicklung zu erfahren.\n",[838,808,743,809,765],{"slug":1202,"featured":91,"template":797},"gitlab-premium-with-duo",1751548525401]