[{"data":1,"prerenderedAt":762},["ShallowReactive",2],{"/de-de/blog/what-is-docker":3,"navigation-de-de":37,"banner-de-de":441,"footer-de-de":451,"blog-post-authors-de-de-GitLab Germany Team":656,"blog-related-posts-de-de-what-is-docker":671,"assessment-promotions-de-de":711,"next-steps-de-de":752},{"id":4,"title":5,"authorSlugs":6,"body":8,"categorySlug":9,"config":10,"content":14,"description":8,"extension":25,"isFeatured":12,"meta":26,"navigation":27,"path":28,"publishedDate":20,"seo":29,"stem":33,"tagSlugs":34,"__hash__":36},"blogPosts/de-de/blog/what-is-docker.yml","What Is Docker",[7],"gitlab-germany-team",null,"open-source",{"slug":11,"featured":12,"template":13},"what-is-docker",false,"BlogPost",{"title":15,"description":16,"authors":17,"heroImage":19,"date":20,"body":21,"category":9,"tags":22},"So optimierst du mit Docker und GitLab deinen DevOps-Prozess","Docker Container bieten deinem Team mehr Raum für Kollaboration, kontinuierliche Integration und Kreativität. Wir zeigen dir, wie die Umsetzung klappt.\n\n",[18],"GitLab Germany Team","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749664248/Blog/Hero%20Images/AdobeStock_564261524.jpg","2025-02-27","# So optimierst du mit Docker und GitLab deinen DevOps-Prozess\n\nIn wenigen Jahren hat sich Docker zu einem globalen Standard entwickelt. Laut aktuellen Statistiken liegt sein Marktanteil in der Containerisierung bei über [80 %](https://6sense.com/tech/containerization/docker-market-share); fast 50 % aller Entwickler(innen) nutzen Docker; und zum Zeitpunkt des Verkaufs des Unternehmens an Mirantis [schätzte man die Zahl seiner Nutzer auf 15 Millionen weltweit](https://cloudnativenow-com.translate.goog/features/docker-inc-dev-tools-boast-15-million-users/?_x_tr_sl=en&_x_tr_tl=de&_x_tr_hl=de&_x_tr_pto=rq). Wenn du im DevOps-Bereich tätig bist, kommst du um Docker somit nicht herum.\n\nDie Vorteile von Docker sprechen für sich. Gegenüber der früher dominanten Virtualisierung läuft es sowohl stabiler als auch schneller. Es unterstützt die Kernziele von [DevOps](https://about.gitlab.com/de-de/topics/devops/), erhöht signifikant die Transparenz eines Projekts und spart Ressourcen ein.\nEntwickler(innen), die mit GitLab arbeiten, können aufgrund einer nahtlosen Integration Docker-Container für sich nutzen. Gleichzeitig gleicht GitLab einige der Nachteile, die bei der Verwendung von Docker auftreten können, aus. Diese enge Verzahnung optimiert die Vorteile beider Anwendungen und bringt deinen DevOps-Prozess weiter nach vorne.\nIn diesem Artikel zeigen wir dir, wie das funktioniert und wie du Docker und GitLab am besten miteinander kombinierst. Aber fangen wir mit einer kurzen Definition an.\n\n## Was ist Docker?\n\nDocker ist eine Plattform zur Containerisierung. Dahinter steht ein neuer Ansatz, über Anwendungen nachzudenken.\nIn der traditionellen „monolithischen” Sichtweise ist das Programm wie eine Art Geschichte angelegt, mit einem Anfang, einem Ende und einer stringenten inneren Logik. Weil alle Funktionen geteilten Annahmen unterworfen sind, lassen sich einzelne Komponenten nur schwer voneinander trennen und ausgliedern.\nBei Docker bildet jede logische Funktion eines Programms eine eigenständige Anwendung, die für sich steht und isoliert ausgeführt werden kann. Dieser Ansatz ist eher modular, die einzelnen Anwendungen können in immer neuen Kombinationen zusammengesetzt und miteinander verzahnt werden. Man könnte sagen: Docker ist kybernetisch, weil es von Systemen, Regelkreisen und Kontrollmechanismen bestimmt wird.\nDocker-Container enthalten alles, was eine Anwendung zur Ausführung benötigt. Mit Docker kannst du Container definieren und anlegen, im Rahmen der Entwicklung plattformunabhängig testen und verbessern und unkompliziert ausliefern.\nDank seiner führenden Rolle ist Docker zu einem Synonym für Containerisierung geworden. Lange bevor Docker aber den Entwicklungsprozess revolutionierte, nutzten DevOps-Teams einen sehr ähnlichen Ansatz namens Virtualisierung.\n\n## Virtualisierung: Die Vorstufe der Containerisierung\n\nDer Grundgedanke der Virtualisierung stammt bereits aus den 1960ern, als IBM an Lösungen arbeitete, die es Anwendern ermöglichen sollten, auf nur einem Rechner mehrere Betriebssysteme laufen zu lassen. Virtualisierung in DevOps nimmt diesen Gedanken zum Ausgangspunkt dafür, Programme so anzulegen und zu verpacken, dass sie unabhängig von den spezifischen Gegebenheiten des Hosts laufen.\n\nJede dieser „virtuellen Maschinen” (VM) bringt alle Anwendungen mit, die für die Ausführung benötigt werden, einschließlich eines eigenen Betriebssystems. Damit können Projektteilnehmer(innen) die Anwendung nutzen, ohne sich mit Kompatibilitätsproblemen auseinandersetzen zu müssen.\n\nVirtuelle Maschinen sind extrem stabil, sicher und werden auch heute noch in vielen Bereichen bevorzugt genutzt. Allerdings haben sie zwei Nachteile:\n\n- Das in jeder VM enthaltene Betriebssystem belastet den Speicher und beeinträchtigt die Systemleistung des Hosts.\n- Der„Hypervisor” einer VM, der für den Betrieb benötigt wird, Ressourcen. Docker ist kein Ersatz für virtuelle Maschinen. Es soll sie vielmehr optimieren und ihre Nachteile so weit wie möglich beseitigen.\n\n## Wie Docker die Nachteile virtueller Maschinen ausgleicht\n\nContainer sind virtuellen Maschinen sehr ähnlich, betonen aber den Aspekt der Isolation über den der Autonomie (wir werden darauf noch genauer eingehen). In ihnen sind ebenfalls alle relevanten Daten und Apps enthalten. Das ermöglicht eine Ausführung unabhängig vom Host-Betriebssystem. Der Unterschied zur Virtualisierung besteht darin, dass Docker-Container kein eigenes Betriebssystem enthalten. Sie teilen sich stattdessen den Kernel des Hosts. Das ist effizienter, schont Systemressourcen und macht Container vor allem weitaus schneller als VM.\n\nDie Vorzüge von Docker waren derart offensichtlich, dass es einen rasanten Aufstieg durchmachte. 2013 veröffentlicht, wurde es ein Jahr später Teil der Pakete von Red Hat Enterprise Linux 7.0 und openSUSE. Die Beliebtheit von Docker war zu diesem Zeitpunkt bereits so stark angewachsen, dass sich einige der größten IT-Unternehmen der Welt zusammenschlossen, um ein System zu entwickeln, mit dem sich Docker-Container besser verwalten lassen sollten. Das daraus entstandene [Kubernetes](https://about.gitlab.com/de-de/solutions/kubernetes/) wird bis heute zur Orchestrierung (Verwaltung) von Containern verwendet.\n\n## Docker: Grundbegriffe\n\nDas Grundkonzept von Docker Containern ist die „Isolation”. Dieses Prinzip unterscheidet sie von den grundsätzlich sehr ähnlichen virtuellen Maschinen.\nVirtuelle Maschinen bilden ein eigenständiges System, das auf keine äußeren Ressourcen angewiesen ist. Container isolieren zwar ebenfalls den größten Teil ihrer Prozesse und Anwendungen, teilen sich aber mit dem Host den Kernel. Es mag so scheinen, als seien diese Unterschiede zwischen den beiden Begriffen eher gering. In der Praxis aber können sie recht große Konsequenzen haben.\n\nDer Lebenszyklus von Docker-Containern beginnt mit sogenannten „Images”. Was ist ein Docker-Image? In ihm ist gewissermaßen der „Bauplan” (oder auch das „Rezept”) enthalten, wie die ausführbaren Docker-Container zusammengestellt werden sollen. Entwickler(innen) „schreiben” den Bauplan in ein Docker-File, zu dem sie Informationen in Schichten („Layern”) sowie die erforderlichen Daten hinzufügen. Eine der entscheidenden Eigenschaften von Docker besteht darin, dass es ein Standardformat für diese Images bereitstellt.\n\nImages werden in der „Registry\" gespeichert und verwaltet. Hier können Änderungen der verschiedenen Versionen nachvollzogen werden, die ein Image bis zum heutigen Stand durchlaufen hat. GitLab bietet ebenfalls eine solche Registry an, von der aus du deine Programme direkt testen und optimieren kannst. Sobald ein Docker-Image mittels seiner Runtime zur Ausführung kommt, entsteht ein Container. Container sind somit das aktivierte Gegenstück eines Images. Sie sind sofort lauffähig und müssen nicht erst „hochgefahren” werden.\n\n## Wie funktioniert Docker im Rahmen von DevOps?\n\nGeschwindigkeit und Effizienz sind zweifelsohne wichtige Aspekte in allen Wirtschaftsbereichen. Im DevOps aber sind sie geradezu essenziell. Dies erklärt die besonders hohe Wertschätzung, die Docker in der Entwicklung genießt. Doch enden die Stärken von Docker dort nicht. Vielmehr kann die Containerisierung alle zentralen Aspekte von DevOps unterstützen:\n\n- Kollaboration: Container können auf jedem Rechner mit denselben Funktionalitäten gestartet werden. Das reduziert Probleme bei der plattformübergreifenden Zusammenarbeit, auch innerhalb eines Teams.\n\n- Kontinuierliche Verbesserung: Als Teil der Kollaboration können immer wieder sehr einfach neue Images geschrieben und neue Container generiert werden, die Optimierungen enthalten. So wird der Prozess der kontinuierlichen Verbesserung deutlich vereinfacht.\n\n- Kundenorientierung: Weil Docker-Container einfach und schnell auf allen Systemen laufen, kann der aktulle Stand eines Projekts jederzeit mit den Kund(inn)en geteilt werden. Damit kann man sich immer wieder wertvolles Feedback holen und das Produkt voll und ganz auf die Kundenwünsche ausrichten.\n\n- Lernen aus Fehlern: Einen Fehler in einer Entwicklungsumgebung zu beheben, war früher aufwändig und komplex. Mit Docker hingegen werden diese Änderungen zu einem selbstverständlichen Teil des Prozesses. Dies führt zu einer Arbeitsphilosophie, bei der mehr ausprobiert werden darf, neue Ideen stets willkommen sind und das Projekt durch Fehler gewinnt, statt durch sie aufgehalten zu werden.\n\n## DevSecOps: Wie sicher sind Docker-Container?\n\nContainer opfern gegenüber virtuellen Maschinen ein wenig Sicherheit zugunsten einer besseren Performance. Virtuelle Maschinen sind dank ihres mitgelieferten Betriebssystems vollständig unabhängig vom Host. Docker allerdings teilt sich den Kernel. Das bedeutet in Hinblick auf die Sicherheit, dass:\n\n- Sicherheitslücken im Kernel auch Auswirkungen auf die Container des Hosts haben können.\n- Sicherheitsprobleme mit einem Container auf alle Container übergreifen können.\n- Sicherheitslücken im Kernel das gesamte Host-System infizieren können - und von dort aus dann die Container.\n\nHinzu kommt, dass es bei Docker mehrere potentielle Stellen für Sicherheitsrisiken gibt. So gibt es nicht nur ein einziges Image, sondern mehrere Instanzen, den Docker-Daemon (der im Hintergrund die Anfragen an Docker verarbeitet), die Cloud in der der Server gehostet wird sowie verschiedene Netzwerke, welche die Kommunikation zwischen den Containern orchestrieren. Im Prinzip muss jede dieser potenziellen Schwachpunkte individuell gesichert werden.\n\n## Wie du die Sicherheit von Docker verbessern kannst\n\nZum Glück gibt es einige einfach umzusetzende Punkte, mit denen du den Einsatz von Docker in deinen Entwicklungsprojekten vor Eingriffen schützen kannst:\n\nNutze die Möglichkeit, Ressourcen zu beschränken. Mit der „Ressource Quota” schränkst du den Zugriff auf Speicher und CPU gezielt ein. Das ist bereits deswegen sinnvoll, da es die Performance des gesamten Container-Systems optimiert. Darüber hinaus blockiert es auch die Möglichkeit, dass ein „infizierter” Container die gesamte Systemleistung reduziert.\n\nVermeide es, die Zugriffsrechte zu umgehen, indem du einen Container als „root” laufen lässt. Das mag in manchen Situationen zwar komfortabler sein, sobald du aber geschützte Testumgebungen verlässt und kollektiv an einem Projekt arbeitest, solltest du der Datensicherheit stets oberste Priorität zuweisen. Stelle sicher, dass deine Registry ausreichend gesichert ist.\nUm die Sicherheit deiner Projekte weiter zu erhöhen, bietet sich GitLab als ein hervorragendes Instrument an, um Container im Rahmen von DevSecOps sicherer zu machen.\n\n## Welche Rolle spielt Docker für GitLabs DevSecOps-Funktionalität?\n\nSicherheitsaspekte spielen für GitLab eine zentrale Rolle: Der Schutz deiner Daten ist nicht von der Entwicklung zu trennen, sowohl was die Arbeit innerhalb des Teams angeht, als auch die Absprache und kontinuierliche Verbesserung mit Kund(inn)en. GitLab nutzt Docker-Container, um diesen Schutz jederzeit zu gewährleisten.\n\nEine der zentralen Funktionen von GitLab ist das [Container-Scanning](https://docs.gitlab.com/ee/user/application_security/container_scanning/). Es basiert auf dem Gedanken, dass Sicherheits-Schwachpunkte bereits im Docker-Image ihren Ursprung haben können, oft in der Form von Abhängigkeiten, die du nicht selbst geschrieben hast, sondern aus externen Quellen importierst. Du kannst entweder nur die Container scannen oder die Abhängigkeiten - wobei wir dir für optimalen Schutz stets beides empfehlen.\n\nAuf einer noch grundlegenderen Ebene unterstützen selbstverständlich auch die allgemeinen Sicherheits-Features von GitLab die Verwendung von Docker-Images und Docker-Containern. Eine zentrale Funktion ist beispielsweise Auto-Remediation, eine intelligente kollaborative Anwendung, die dir bereits beim Entwickeln Vorschläge zur Fehlervermeidung und zu effizienterem Code macht.\n\n## 3 Docker Herausforderungen und wie GitLab bei der Lösung hilft\n\nDocker ist ein bestechendes Konzept, das die Arbeit für Millionen Entwickler(innen) täglich besser und einfacher macht. Seine Flexibilität und Individualisierung aber stellen Nutzer(innen) zugleich vor einige Herausforderungen.\nSehen wir uns drei zentrale Herausforderungen näher an - und wie GitLab dabei helfen kann, sie zu bewältigen.\n### Standardisierung:\n\nDocker ist ein offenes Konzept, das Entwickler(innen) höchst individuelle Lösungswege eröffnet. Wenn aber in Teams verschiedene Mitglieder an einem Projekt arbeiten und dabei sehr unterschiedliche Coding-Stile benutzen oder teilweise sogar widersprüchliche Anweisungen geben, kann es zu Konflikten kommen.\n\nGitLab bietet Standardisierungsoptionen an, beispielsweise durch [CI/CD-Templates](https://docs.gitlab.com/ee/ci/examples/), mit denen das gesamte DevOps-Team arbeiten kann. Shared Runners ermöglichen anschließend das Testen des aktuellen Standes in einer von dir vorgegebenen oder standardisierten Umgebung.\nAll dies ist gerade bei großen Projekten eine unermessliche Hilfe, da dabei bis zu tausende Container gleichzeitig miteinander abgestimmt werden müssen.\n\n### Ressourcenoptimierung:\n\nDocker Container nutzen Ressourcen in der Regel weitaus schonender als virtuelle Maschinen. Wie oben angesprochen kann sich die Gesamtzahl aller Container aber zu riesigen Zahlen summieren.\nMit verschiedenen Funktionen sorgt GitLab dafür, dass gerade speicherintensive Jobs optimiert- und gewisse Container zeitweise deaktiviert werden, um die Systemleistung zu verbessern.\n\n### Orchestrierung:\n\nDas wichtigste Thema in der Containerisierung ist heute zweifelsohne die Orchestrierung. Wenn du sehr viele Container nutzt, die zusammen mit den Anwendungen auf verschiedenen Servern untergebracht sind und zu unterschiedlichen Zeiten und in immer neuen Konstellationen miteinander kombiniert werden sollen, kommt es leicht zu Engpässen, Ausfällen oder Fehlern.\nKubernetes ist die komplexe Lösung für diese Probleme und GitLab ist direkt mit Kubernetes abgestimmt. Du kannst mit GitLab und Kubernetes die gesamte [CI/CD](https://about.gitlab.com/topics/ci-cd/)-Pipeline automatisieren und dabei dein System optimieren.\n\n## FAQ\n\n### Was ist Docker Compose?\n\nDocker Compose ist ein Tool, das dir bei der Orchestrierung hilft. Es findet in Multi-Container-Umgebungen Anwendung. In diesem Artikel haben wir bisher angenommen, dass eine Anwendung einem Container entspricht. Das ist zur Erklärung der grundlegenden Zusammenhänge sinnvoll. In der Praxis aber ergeben sich zumeist weitaus komplexere Sachverhalte.\n\nEin typischer Fall besteht darin, dass eine Anwendung mehrere Container benötigt, die zu unterschiedlichen Zeitpunkten gestartet und beendet werden. Diesen Ablauf präzise zu definieren sowie dabei die einzelnen Container-Aktionen aufeinander abzustimmen und im Rahmen eventueller Fehler oder Probleme zu optimieren, erweist sich als komplex. Wie [Data Scientist](https://datascientest.com/de/docker-compose-von-der-installation-bis-zur-bereitstellung-von-anwendungen) betont, liegt die Schwierigkeit darin, die verschiedenen Container „separat auszuführen, während sie gleichzeitig miteinander kommunizieren.”\n\n[Docker Compose](https://forum.gitlab.com/t/how-to-use-docker-compose-in-gitlab-ci/97671) unterstützt die Orchestrierung bei genau diesen Szenarien. Entwickler(innen) können in einer speziellen Datei mit einer laut [Heise](https://www.heise.de/hintergrund/Multi-Tier-Applikationen-mit-Docker-Compose-Machine-und-Swarm-3014669.html?seite=3) „simplen Syntax” alle Aktionen festlegen, die beim Aufbau und der Interaktion der Container zum Tragen kommen. Zurecht gilt Docker Compose deswegen als „ein mächtiges Werkzeug für den Einsatz und die Verwaltung von Multi-Container-Anwendungen”.\n\n### Wie funktioniert die Continuous Integration von Docker in GitLab?\n\nDocker wirkt sich positiv auf alle drei Prinzipien von CI/CD aus, vom kontinuierlichen Deployment bis hin zur kontinuierlichen Lieferung (delivery). Bei der kontinuierlichen Integration aber (Continuous Integration) sind die Vorteile ganz besonders offensichtlich.\nBei der Continuous Integration (CI) werden sämtliche branches (Enwticklungszweige) so oft wie möglich mit der main branch (dem Hauptentwicklungszweig) zusammengeführt. Dadurch haben alle Mitglieder eines Teams stets Zugriff auf den aktuellen Stand des Projekts und eine Änderung an einem Teil der Anwendung kann direkt auf seine Auswirkungen auf andere Bereiche hin überprüft werden. So wird vermieden, dass möglicherweise schwerwiegende Fehler im Zusammenspiel erst kurz vor Veröffentlichung des Produkts entdeckt werden.\n\nContainer sind das optimale Instrument, um Continuous Integration in deiner CI/CD-Pipeline zu realisieren. In ihrer containerisierten Form können Anwendungen schnell und in verschiedenen Umgebungen getestet werden. Das Feedback lässt sich unmittelbar auswerten und bewerten. Anschließend machst du Änderungen für alle branches durch das Definieren eines neuen, aktualisierten Images sichtbar und überprüfbar.\nZusammenfassend lässt sich sagen, dass Container die Integration im CI/CD-Prozess robuster und zuverlässiger gestalten und somit die Basis für erfolgreiches Deployment und Delivery bereiten.\n\n### Wann empfiehlt es sich, mit virtuellen Maschinen zu arbeiten statt mit Docker?\n\nDocker ist eine Weiterentwicklung virtueller Maschinen. Daraus sollte aber nicht der Schluss gezogen werden, dass es sich bei VM um eine veraltete oder gar überholte Technologie handelt. Vielmehr bleiben die Vorzüge dieses Modells auch in Zukunft bestehen.\n[Computer Weekly](https://www.computerweekly.com/de/ratgeber/Sechs-Anwendungsfaelle-fuer-die-sich-Docker-eignet) hat drei Situationen ermittelt, in denen Virtualisierung die bessere Option darstellt:\n\n__- Bei besonders sensiblen Daten:__ hier kann ein Höchstmaß an Isolierung erforderlich sein. Da sie mit dem Host in der Regel in keinem direkten Austausch stehen, sind virtuelle Maschinen hier zweifelsfrei die sicherste Wahl.\n\n__- Bei grafikintensiven Anwendungen__ lassen sich zwar grundsätzlich auch über Container verwenden, in der Regel aber ist Virtualisierung hier einfacher in der Handhabung.\n__In kleinen Teams__– wenn du nur selten Änderungen an deinen Anwendungen vornimmst, sind virtuelle Maschinen eine hervorragende Alternative, weil sie leichter zu verwalten sind.\n\n### Läuft Docker auch auf Windows und MacOs?\n\nDocker kann auf allen Hosts laufen, die Docker unterstützen. Tatsächlich aber ist die Plattform vor allem auf eine Linux-Nutzung hin optimiert.\nDie originäre Version von Docker ist so ausgelegt, dass sie die Funktionalitäten eines Linux-Kernels mit dem Host teilen kann. In diesem Umfeld funktionieren Container am effizientesten und die Vorteile der Containerisierung kommen voll zur Geltung.\n\nUm Docker auch für Windows und MacOs nutzbar zu machen, stehen entsprechende Docker-Versionen zur Verfügung. Diese aber geben das strenge Isolierungs-Prinzip auf und fügen eine virtuelle Maschine hinzu, welche eine Nutzung auf Linux-fremden Umgebungen erlaubt.\nAuch, wenn Docker unter Windows und MacOs nicht ganz so effizient ist wie unter Linux, ist die benötigte VM sehr leicht und schränkt Geschwindigkeit und Speicher nicht so stark ein wie eine vollständige virtuelle Maschine. Die gelegentliche Behauptung, Docker lasse sich nur unter Linux sinnvoll verwenden, ist deswegen zweifelsfrei sehr radikal.\n",[23,24],"DevOps","open source","yml",{},true,"/de-de/blog/what-is-docker",{"title":15,"description":16,"ogTitle":15,"ogDescription":16,"noIndex":12,"ogImage":19,"ogUrl":30,"ogSiteName":31,"ogType":32,"canonicalUrls":30},"https://about.gitlab.com/blog/what is docker","https://about.gitlab.com","article","de-de/blog/what-is-docker",[35,9],"devops","aIUjf3POZ6cD0lhwZ_gAS2wROat2w2HuwyWFHs4Mhp4",{"data":38},{"logo":39,"freeTrial":44,"sales":49,"login":54,"items":59,"search":368,"minimal":403,"duo":421,"pricingDeployment":431},{"config":40},{"href":41,"dataGaName":42,"dataGaLocation":43},"/de-de/","gitlab logo","header",{"text":45,"config":46},"Kostenlose Testversion anfordern",{"href":47,"dataGaName":48,"dataGaLocation":43},"https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com&glm_content=default-saas-trial/","free trial",{"text":50,"config":51},"Vertrieb kontaktieren",{"href":52,"dataGaName":53,"dataGaLocation":43},"/de-de/sales/","sales",{"text":55,"config":56},"Anmelden",{"href":57,"dataGaName":58,"dataGaLocation":43},"https://gitlab.com/users/sign_in/","sign in",[60,87,183,188,289,349],{"text":61,"config":62,"cards":64},"Plattform",{"dataNavLevelOne":63},"platform",[65,71,79],{"title":61,"description":66,"link":67},"Die intelligente Orchestrierungsplattform für DevSecOps",{"text":68,"config":69},"Erkunde unsere Plattform",{"href":70,"dataGaName":63,"dataGaLocation":43},"/de-de/platform/",{"title":72,"description":73,"link":74},"GitLab Duo Agent Platform","Agentische KI für den gesamten Softwareentwicklungszyklus",{"text":75,"config":76},"Lerne GitLab Duo kennen",{"href":77,"dataGaName":78,"dataGaLocation":43},"/de-de/gitlab-duo-agent-platform/","gitlab duo agent platform",{"title":80,"description":81,"link":82},"Gründe, die für GitLab sprechen","Erfahre, warum Unternehmen auf GitLab setzen",{"text":83,"config":84},"Mehr erfahren",{"href":85,"dataGaName":86,"dataGaLocation":43},"/de-de/why-gitlab/","why gitlab",{"text":88,"left":27,"config":89,"link":91,"lists":95,"footer":165},"Produkt",{"dataNavLevelOne":90},"solutions",{"text":92,"config":93},"Alle Lösungen anzeigen",{"href":94,"dataGaName":90,"dataGaLocation":43},"/de-de/solutions/",[96,121,143],{"title":97,"description":98,"link":99,"items":104},"Automatisierung","CI/CD und Automatisierung zur Beschleunigung der Bereitstellung",{"config":100},{"icon":101,"href":102,"dataGaName":103,"dataGaLocation":43},"AutomatedCodeAlt","/de-de/solutions/delivery-automation/","automated software delivery",[105,109,112,117],{"text":106,"config":107},"CI/CD",{"href":108,"dataGaLocation":43,"dataGaName":106},"/de-de/solutions/continuous-integration/",{"text":72,"config":110},{"href":77,"dataGaLocation":43,"dataGaName":111},"gitlab duo agent platform - product menu",{"text":113,"config":114},"Quellcodeverwaltung",{"href":115,"dataGaLocation":43,"dataGaName":116},"/de-de/solutions/source-code-management/","Source Code Management",{"text":118,"config":119},"Automatisierte Softwarebereitstellung",{"href":102,"dataGaLocation":43,"dataGaName":120},"Automated software delivery",{"title":122,"description":123,"link":124,"items":129},"Sicherheit","Entwickle schneller, ohne die Sicherheit zu gefährden",{"config":125},{"href":126,"dataGaName":127,"dataGaLocation":43,"icon":128},"/de-de/solutions/application-security-testing/","security and compliance","ShieldCheckLight",[130,134,139],{"text":131,"config":132},"Application Security Testing",{"href":126,"dataGaName":133,"dataGaLocation":43},"Application security testing",{"text":135,"config":136},"Schutz der Software-Lieferkette",{"href":137,"dataGaLocation":43,"dataGaName":138},"/de-de/solutions/supply-chain/","Software supply chain security",{"text":140,"config":141},"Software Compliance",{"href":142,"dataGaName":140,"dataGaLocation":43},"/de-de/solutions/software-compliance/",{"title":144,"link":145,"items":150},"Bewertung",{"config":146},{"icon":147,"href":148,"dataGaName":149,"dataGaLocation":43},"DigitalTransformation","/de-de/solutions/visibility-measurement/","visibility and measurement",[151,155,160],{"text":152,"config":153},"Sichtbarkeit und Bewertung",{"href":148,"dataGaLocation":43,"dataGaName":154},"Visibility and Measurement",{"text":156,"config":157},"Wertstrommanagement",{"href":158,"dataGaLocation":43,"dataGaName":159},"/de-de/solutions/value-stream-management/","Value Stream Management",{"text":161,"config":162},"Analysen und Einblicke",{"href":163,"dataGaLocation":43,"dataGaName":164},"/de-de/solutions/analytics-and-insights/","Analytics and insights",{"title":166,"items":167},"GitLab für",[168,173,178],{"text":169,"config":170},"Enterprise",{"href":171,"dataGaLocation":43,"dataGaName":172},"/de-de/enterprise/","enterprise",{"text":174,"config":175},"Kleinunternehmen",{"href":176,"dataGaLocation":43,"dataGaName":177},"/de-de/small-business/","small business",{"text":179,"config":180},"den öffentlichen Sektor",{"href":181,"dataGaLocation":43,"dataGaName":182},"/de-de/solutions/public-sector/","public sector",{"text":184,"config":185},"Preise",{"href":186,"dataGaName":187,"dataGaLocation":43,"dataNavLevelOne":187},"/de-de/pricing/","pricing",{"text":189,"config":190,"link":192,"lists":196,"feature":276},"Ressourcen",{"dataNavLevelOne":191},"resources",{"text":193,"config":194},"Alle Ressourcen anzeigen",{"href":195,"dataGaName":191,"dataGaLocation":43},"/de-de/resources/",[197,230,248],{"title":198,"items":199},"Erste Schritte",[200,205,210,215,220,225],{"text":201,"config":202},"Installieren",{"href":203,"dataGaName":204,"dataGaLocation":43},"/de-de/install/","install",{"text":206,"config":207},"Kurzanleitungen",{"href":208,"dataGaName":209,"dataGaLocation":43},"/de-de/get-started/","quick setup checklists",{"text":211,"config":212},"Lernen",{"href":213,"dataGaLocation":43,"dataGaName":214},"https://university.gitlab.com/","learn",{"text":216,"config":217},"Produktdokumentation",{"href":218,"dataGaName":219,"dataGaLocation":43},"https://docs.gitlab.com/","product documentation",{"text":221,"config":222},"Best-Practice-Videos",{"href":223,"dataGaName":224,"dataGaLocation":43},"/de-de/getting-started-videos/","best practice videos",{"text":226,"config":227},"Integrationen",{"href":228,"dataGaName":229,"dataGaLocation":43},"/de-de/integrations/","integrations",{"title":231,"items":232},"Entdecken",[233,238,243],{"text":234,"config":235},"Kundenerfolge",{"href":236,"dataGaName":237,"dataGaLocation":43},"/de-de/customers/","customer success stories",{"text":239,"config":240},"Blog",{"href":241,"dataGaName":242,"dataGaLocation":43},"/de-de/blog/","blog",{"text":244,"config":245},"Remote",{"href":246,"dataGaName":247,"dataGaLocation":43},"https://handbook.gitlab.com/handbook/company/culture/all-remote/","remote",{"title":249,"items":250},"Vernetzen",[251,256,261,266,271],{"text":252,"config":253},"GitLab-Services",{"href":254,"dataGaName":255,"dataGaLocation":43},"/de-de/services/","services",{"text":257,"config":258},"Community",{"href":259,"dataGaName":260,"dataGaLocation":43},"/community/","community",{"text":262,"config":263},"Forum",{"href":264,"dataGaName":265,"dataGaLocation":43},"https://forum.gitlab.com/","forum",{"text":267,"config":268},"Veranstaltungen",{"href":269,"dataGaName":270,"dataGaLocation":43},"/events/","events",{"text":272,"config":273},"Partner",{"href":274,"dataGaName":275,"dataGaLocation":43},"/de-de/partners/","partners",{"backgroundColor":277,"textColor":278,"text":279,"image":280,"link":284},"#2f2a6b","#fff","Perspektiven für die Softwareentwicklung der Zukunft",{"altText":281,"config":282},"the source promo card",{"src":283},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758208064/dzl0dbift9xdizyelkk4.svg",{"text":285,"config":286},"Lies die News",{"href":287,"dataGaName":288,"dataGaLocation":43},"/de-de/the-source/","the source",{"text":290,"config":291,"lists":293},"Unternehmen",{"dataNavLevelOne":292},"company",[294],{"items":295},[296,301,307,309,314,319,324,329,334,339,344],{"text":297,"config":298},"Über",{"href":299,"dataGaName":300,"dataGaLocation":43},"/de-de/company/","about",{"text":302,"config":303,"footerGa":306},"Karriere",{"href":304,"dataGaName":305,"dataGaLocation":43},"/jobs/","jobs",{"dataGaName":305},{"text":267,"config":308},{"href":269,"dataGaName":270,"dataGaLocation":43},{"text":310,"config":311},"Geschäftsführung",{"href":312,"dataGaName":313,"dataGaLocation":43},"/company/team/e-group/","leadership",{"text":315,"config":316},"Team",{"href":317,"dataGaName":318,"dataGaLocation":43},"/company/team/","team",{"text":320,"config":321},"Handbuch",{"href":322,"dataGaName":323,"dataGaLocation":43},"https://handbook.gitlab.com/","handbook",{"text":325,"config":326},"Investor Relations",{"href":327,"dataGaName":328,"dataGaLocation":43},"https://ir.gitlab.com/","investor relations",{"text":330,"config":331},"Trust Center",{"href":332,"dataGaName":333,"dataGaLocation":43},"/de-de/security/","trust center",{"text":335,"config":336},"AI Transparency Center",{"href":337,"dataGaName":338,"dataGaLocation":43},"/de-de/ai-transparency-center/","ai transparency center",{"text":340,"config":341},"Newsletter",{"href":342,"dataGaName":343,"dataGaLocation":43},"/company/contact/#contact-forms","newsletter",{"text":345,"config":346},"Presse",{"href":347,"dataGaName":348,"dataGaLocation":43},"/press/","press",{"text":350,"config":351,"lists":352},"Kontakt",{"dataNavLevelOne":292},[353],{"items":354},[355,358,363],{"text":50,"config":356},{"href":52,"dataGaName":357,"dataGaLocation":43},"talk to sales",{"text":359,"config":360},"Support-Portal",{"href":361,"dataGaName":362,"dataGaLocation":43},"https://support.gitlab.com","support portal",{"text":364,"config":365},"Kundenportal",{"href":366,"dataGaName":367,"dataGaLocation":43},"https://customers.gitlab.com/customers/sign_in/","customer portal",{"close":369,"login":370,"suggestions":377},"Schließen",{"text":371,"link":372},"Um Repositories und Projekte zu durchsuchen, melde dich an bei",{"text":373,"config":374},"gitlab.com",{"href":57,"dataGaName":375,"dataGaLocation":376},"search login","search",{"text":378,"default":379},"Vorschläge",[380,382,387,389,394,399],{"text":72,"config":381},{"href":77,"dataGaName":72,"dataGaLocation":376},{"text":383,"config":384},"Code Suggestions (KI)",{"href":385,"dataGaName":386,"dataGaLocation":376},"/de-de/solutions/code-suggestions/","Code Suggestions (AI)",{"text":106,"config":388},{"href":108,"dataGaName":106,"dataGaLocation":376},{"text":390,"config":391},"GitLab auf AWS",{"href":392,"dataGaName":393,"dataGaLocation":376},"/de-de/partners/technology-partners/aws/","GitLab on AWS",{"text":395,"config":396},"GitLab auf Google Cloud",{"href":397,"dataGaName":398,"dataGaLocation":376},"/de-de/partners/technology-partners/google-cloud-platform/","GitLab on Google Cloud",{"text":400,"config":401},"Warum GitLab?",{"href":85,"dataGaName":402,"dataGaLocation":376},"Why GitLab?",{"freeTrial":404,"mobileIcon":409,"desktopIcon":414,"secondaryButton":417},{"text":405,"config":406},"Kostenlos testen",{"href":407,"dataGaName":48,"dataGaLocation":408},"https://gitlab.com/-/trials/new/","nav",{"altText":410,"config":411},"GitLab-Symbol",{"src":412,"dataGaName":413,"dataGaLocation":408},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758203874/jypbw1jx72aexsoohd7x.svg","gitlab icon",{"altText":410,"config":415},{"src":416,"dataGaName":413,"dataGaLocation":408},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758203875/gs4c8p8opsgvflgkswz9.svg",{"text":198,"config":418},{"href":419,"dataGaName":420,"dataGaLocation":408},"https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com/de-de/compare/gitlab-vs-github/","get started",{"freeTrial":422,"mobileIcon":427,"desktopIcon":429},{"text":423,"config":424},"Erfahre mehr über GitLab Duo",{"href":425,"dataGaName":426,"dataGaLocation":408},"/de-de/gitlab-duo/","gitlab duo",{"altText":410,"config":428},{"src":412,"dataGaName":413,"dataGaLocation":408},{"altText":410,"config":430},{"src":416,"dataGaName":413,"dataGaLocation":408},{"freeTrial":432,"mobileIcon":437,"desktopIcon":439},{"text":433,"config":434},"Zurück zur Preisübersicht",{"href":186,"dataGaName":435,"dataGaLocation":408,"icon":436},"back to pricing","GoBack",{"altText":410,"config":438},{"src":412,"dataGaName":413,"dataGaLocation":408},{"altText":410,"config":440},{"src":416,"dataGaName":413,"dataGaLocation":408},{"title":442,"button":443,"config":448},"Sieh dir an, wie agentische KI die Softwarebereitstellung transformiert",{"text":444,"config":445},"GitLab Transcend jetzt ansehen",{"href":446,"dataGaName":447,"dataGaLocation":43},"/de-de/events/transcend/virtual/","transcend event",{"layout":449,"icon":450},"release","AiStar",{"data":452},{"text":453,"source":454,"edit":460,"contribute":465,"config":470,"items":475,"minimal":648},"Git ist eine Marke von Software Freedom Conservancy und unsere Verwendung von „GitLab“ erfolgt unter Lizenz.",{"text":455,"config":456},"Quelltext der Seite anzeigen",{"href":457,"dataGaName":458,"dataGaLocation":459},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/","page source","footer",{"text":461,"config":462},"Diese Seite bearbeiten",{"href":463,"dataGaName":464,"dataGaLocation":459},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/content/","web ide",{"text":466,"config":467},"Beteilige dich",{"href":468,"dataGaName":469,"dataGaLocation":459},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/CONTRIBUTING.md/","please contribute",{"twitter":471,"facebook":472,"youtube":473,"linkedin":474},"https://x.com/gitlab","https://www.facebook.com/gitlab","https://www.youtube.com/channel/UCnMGQ8QHMAnVIsI3xJrihhg","https://www.linkedin.com/company/gitlab-com",[476,499,554,581,615],{"title":61,"links":477,"subMenu":482},[478],{"text":479,"config":480},"DevSecOps-Plattform",{"href":70,"dataGaName":481,"dataGaLocation":459},"devsecops platform",[483],{"title":184,"links":484},[485,489,494],{"text":486,"config":487},"Tarife anzeigen",{"href":186,"dataGaName":488,"dataGaLocation":459},"view plans",{"text":490,"config":491},"Vorteile von Premium",{"href":492,"dataGaName":493,"dataGaLocation":459},"/de-de/pricing/premium/","why premium",{"text":495,"config":496},"Vorteile von Ultimate",{"href":497,"dataGaName":498,"dataGaLocation":459},"/de-de/pricing/ultimate/","why ultimate",{"title":500,"links":501},"Lösungen",[502,507,510,512,517,522,526,529,532,537,539,541,544,549],{"text":503,"config":504},"Digitale Transformation",{"href":505,"dataGaName":506,"dataGaLocation":459},"/de-de/topics/digital-transformation/","digital transformation",{"text":508,"config":509},"Sicherheit und Compliance",{"href":126,"dataGaName":133,"dataGaLocation":459},{"text":118,"config":511},{"href":102,"dataGaName":103,"dataGaLocation":459},{"text":513,"config":514},"Agile Entwicklung",{"href":515,"dataGaName":516,"dataGaLocation":459},"/de-de/solutions/agile-delivery/","agile delivery",{"text":518,"config":519},"Cloud-Transformation",{"href":520,"dataGaName":521,"dataGaLocation":459},"/de-de/topics/cloud-native/","cloud transformation",{"text":523,"config":524},"SCM",{"href":115,"dataGaName":525,"dataGaLocation":459},"source code management",{"text":106,"config":527},{"href":108,"dataGaName":528,"dataGaLocation":459},"continuous integration & delivery",{"text":156,"config":530},{"href":158,"dataGaName":531,"dataGaLocation":459},"value stream management",{"text":533,"config":534},"GitOps",{"href":535,"dataGaName":536,"dataGaLocation":459},"/de-de/solutions/gitops/","gitops",{"text":169,"config":538},{"href":171,"dataGaName":172,"dataGaLocation":459},{"text":174,"config":540},{"href":176,"dataGaName":177,"dataGaLocation":459},{"text":542,"config":543},"Öffentlicher Sektor",{"href":181,"dataGaName":182,"dataGaLocation":459},{"text":545,"config":546},"Bildungswesen",{"href":547,"dataGaName":548,"dataGaLocation":459},"/de-de/solutions/education/","education",{"text":550,"config":551},"Finanzdienstleistungen",{"href":552,"dataGaName":553,"dataGaLocation":459},"/de-de/solutions/finance/","financial services",{"title":189,"links":555},[556,558,560,562,565,567,569,571,573,575,577,579],{"text":201,"config":557},{"href":203,"dataGaName":204,"dataGaLocation":459},{"text":206,"config":559},{"href":208,"dataGaName":209,"dataGaLocation":459},{"text":211,"config":561},{"href":213,"dataGaName":214,"dataGaLocation":459},{"text":216,"config":563},{"href":218,"dataGaName":564,"dataGaLocation":459},"docs",{"text":239,"config":566},{"href":241,"dataGaName":242,"dataGaLocation":459},{"text":234,"config":568},{"href":236,"dataGaName":237,"dataGaLocation":459},{"text":244,"config":570},{"href":246,"dataGaName":247,"dataGaLocation":459},{"text":252,"config":572},{"href":254,"dataGaName":255,"dataGaLocation":459},{"text":257,"config":574},{"href":259,"dataGaName":260,"dataGaLocation":459},{"text":262,"config":576},{"href":264,"dataGaName":265,"dataGaLocation":459},{"text":267,"config":578},{"href":269,"dataGaName":270,"dataGaLocation":459},{"text":272,"config":580},{"href":274,"dataGaName":275,"dataGaLocation":459},{"title":290,"links":582},[583,585,587,589,591,593,595,599,604,606,608,610],{"text":297,"config":584},{"href":299,"dataGaName":292,"dataGaLocation":459},{"text":302,"config":586},{"href":304,"dataGaName":305,"dataGaLocation":459},{"text":310,"config":588},{"href":312,"dataGaName":313,"dataGaLocation":459},{"text":315,"config":590},{"href":317,"dataGaName":318,"dataGaLocation":459},{"text":320,"config":592},{"href":322,"dataGaName":323,"dataGaLocation":459},{"text":325,"config":594},{"href":327,"dataGaName":328,"dataGaLocation":459},{"text":596,"config":597},"Sustainability",{"href":598,"dataGaName":596,"dataGaLocation":459},"/sustainability/",{"text":600,"config":601},"Vielfalt, Inklusion und Zugehörigkeit",{"href":602,"dataGaName":603,"dataGaLocation":459},"/de-de/diversity-inclusion-belonging/","Diversity, inclusion and belonging",{"text":330,"config":605},{"href":332,"dataGaName":333,"dataGaLocation":459},{"text":340,"config":607},{"href":342,"dataGaName":343,"dataGaLocation":459},{"text":345,"config":609},{"href":347,"dataGaName":348,"dataGaLocation":459},{"text":611,"config":612},"Transparenzerklärung zu moderner Sklaverei",{"href":613,"dataGaName":614,"dataGaLocation":459},"https://handbook.gitlab.com/handbook/legal/modern-slavery-act-transparency-statement/","modern slavery transparency statement",{"title":616,"links":617},"Nimm Kontakt auf",[618,621,626,628,633,638,643],{"text":619,"config":620},"Sprich mit einem Experten/einer Expertin",{"href":52,"dataGaName":53,"dataGaLocation":459},{"text":622,"config":623},"Support",{"href":624,"dataGaName":625,"dataGaLocation":459},"/support/","get help",{"text":364,"config":627},{"href":366,"dataGaName":367,"dataGaLocation":459},{"text":629,"config":630},"Status",{"href":631,"dataGaName":632,"dataGaLocation":459},"https://status.gitlab.com/","status",{"text":634,"config":635},"Nutzungsbedingungen",{"href":636,"dataGaName":637,"dataGaLocation":459},"/terms/","terms of use",{"text":639,"config":640},"Datenschutzerklärung",{"href":641,"dataGaName":642,"dataGaLocation":459},"/de-de/privacy/","privacy statement",{"text":644,"config":645},"Cookie-Einstellungen",{"dataGaName":646,"dataGaLocation":459,"id":647,"isOneTrustButton":27},"cookie preferences","ot-sdk-btn",{"items":649},[650,652,654],{"text":634,"config":651},{"href":636,"dataGaName":637,"dataGaLocation":459},{"text":639,"config":653},{"href":641,"dataGaName":642,"dataGaLocation":459},{"text":644,"config":655},{"dataGaName":646,"dataGaLocation":459,"id":647,"isOneTrustButton":27},[657],{"id":658,"title":659,"body":8,"config":660,"content":662,"description":8,"extension":25,"meta":666,"navigation":27,"path":667,"seo":668,"stem":669,"__hash__":670},"blogAuthors/en-us/blog/authors/gitlab-germany-team.yml","Gitlab Germany Team",{"template":661},"BlogAuthor",{"name":18,"config":663},{"headshot":664,"ctfId":665},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1749659488/Blog/Author%20Headshots/gitlab-logo-extra-whitespace.png","6tNquF8jQeRRRi8k3ZXpvS",{},"/en-us/blog/authors/gitlab-germany-team",{},"en-us/blog/authors/gitlab-germany-team","vGs9BT_ji6dORS29vl80DKX6mSputlQV2W7-4vW2hL8",[672,685,698],{"content":673,"config":683},{"title":674,"description":675,"authors":676,"heroImage":678,"date":679,"body":680,"category":9,"tags":681,"updatedDate":679},"Kubernetes: Container-Orchestrierung verstehen und einsetzen","Kubernetes (K8s) für containerisierte Anwendungen: Dieser Artikel erklärt Architektur, Vorteile, Grenzen und den Einsatz mit GitLab.",[677],"GitLab Team","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749660215/Blog/Hero%20Images/kubernetes-container-orchestration-solution.jpg","2026-03-02","Kubernetes automatisiert die Bereitstellung und Verwaltung\ncontainerisierter Anwendungen in großem Maßstab. Mit der Zeit ist\nKubernetes zu einem zentralen Werkzeug für die Anwendungsentwicklung\ngeworden – etwa in den Bereichen\n[Microservices](https://about.gitlab.com/de-de/topics/microservices/),\nWebanwendungen und Datenbanken. Leistungsfähigkeit und Skalierbarkeit\nmachen K8s heute zum anerkannten Standard im Container-Management.\n\nDieser Artikel bietet einen umfassenden Einstieg in Kubernetes.\n\n## Was ist Kubernetes?\n\nKubernetes ist ein Open-Source-System zur effizienten Orchestrierung von\nContainern einer Softwareanwendung. Containerisierung ist ein weit\nverbreiteter Ansatz in der Anwendungsentwicklung – besonders im Bereich\nder digitalen Transformation und der Cloud.\n\nZur Erinnerung: **Containerisierung ist eine Methode der\nAnwendungsentwicklung, bei der die Komponenten einer Anwendung in\nstandardisierte, geräte- und betriebssystemunabhängige Einheiten –\nsogenannte Container – zusammengefasst werden.** Durch die Isolierung von\nAnwendungen von ihrer Umgebung erleichtert diese Technologie die\nBereitstellung und Portabilität und reduziert Kompatibilitätsprobleme.\n\nHier kommt Kubernetes ins Spiel. Container ermöglichen zwar die Aufteilung\nvon Anwendungen in kleinere, eigenständige Module, die leichter\nbereitzustellen sind. Damit Container jedoch innerhalb einer Anwendung\nzusammenarbeiten können, ist ein übergeordnetes Verwaltungssystem\nerforderlich. Genau das leistet Kubernetes: Die Plattform steuert, wo und\nwie Container ausgeführt werden, und ermöglicht so die Orchestrierung und\nPlanung containerisierter Anwendungen in großem Maßstab.\n\n> Weitere [GitLab-Artikel zu Kubernetes](https://about.gitlab.com/de-de/blog/tags/kubernetes/).\n\n## Wie funktioniert eine Kubernetes-Architektur?\n\nUm die Kubernetes-Architektur zu verstehen, sind einige grundlegende\nKonzepte wichtig – allen voran das des Clusters, der die umfassendste\nEinheit innerhalb der Architektur darstellt. Ein Kubernetes-Cluster ist\ndie Gesamtheit der virtuellen oder physischen Maschinen, auf denen eine\ncontainerisierte Anwendung betrieben wird.\n\n![Komponenten von\nKubernetes](https://res.cloudinary.com/about-gitlab-com/image/upload/v1749673941/Blog/Content%20Images/components-of-kubernetes.png)\n\nQuelle:\n[Kubernetes](https://kubernetes.io/docs/concepts/overview/components/).\n\nEin Cluster besteht aus verschiedenen Elementen:\n- Node: Eine Arbeitseinheit im Kubernetes-Cluster – eine virtuelle oder\nphysische Maschine, die Aufgaben im Auftrag der Anwendung übernimmt.\n- Pod: Der kleinste bereitstellbare Baustein in Kubernetes. Ein Pod ist\neine Gruppe von Containern, die gemeinsam auf demselben Node ausgeführt\nwerden. Container innerhalb eines Pods teilen dasselbe Netzwerk und\nkommunizieren über localhost miteinander.\n- Service: Ein Kubernetes-Service macht einen Pod für das Netzwerk oder\nandere Pods zugänglich und bietet einen stabilen, klar definierten\nZugangspunkt zu den in Pods gehosteten Anwendungen.\n- Volume: Eine Ordnerabstraktion, die Probleme beim Teilen und Abrufen\nvon Dateien innerhalb eines Containers löst.\n- Namespace: Ein Namespace ermöglicht die Gruppierung und Isolierung von\nRessourcen zu einem virtuellen Cluster.\n\nDie Kubernetes-Architektur basiert auf zwei Knotentypen: dem Master Node\nund den Worker Nodes. Der Master Node ist für die übergeordnete Verwaltung\ndes Kubernetes-Clusters und die Kommunikation mit den Worker Nodes\nzuständig. Zu seinen zentralen Komponenten zählt die API als\nKommunikationszentrum zwischen Nutzenden und Cluster. Das\n[etcd](https://kubernetes.io/docs/concepts/overview/components/#etcd)\nist die Key-Value-Datenbank, in der Konfigurationen, Systemzustand und\nObjekt-Metadaten gespeichert werden. Der Controller Manager koordiniert\nHintergrundoperationen wie die Pod-Replikation, der Scheduler platziert\nPods auf Nodes entsprechend der verfügbaren Ressourcen.\n\nWorker Nodes hingegen sind die Maschinen, auf denen die in den Pods\nenthaltenen Anwendungen ausgeführt und verwaltet werden. Das\n[kubelet](https://kubernetes.io/docs/concepts/overview/components/#kubelet)\nist der Agent, der auf jedem Node läuft und mit dem Master kommuniziert,\num Befehle zu empfangen und den Status der Pods zu übermitteln. Der\nNetzwerk-Proxy\n[kube-proxy](https://kubernetes.io/docs/concepts/overview/components/)\npflegt die Netzwerkregeln auf den Nodes und ermöglicht so den Zugriff auf\nServices von außerhalb des Kubernetes-Clusters. Die Container-Runtime\nschließlich ist die Software, die für die Ausführung und Verwaltung der\nContainer innerhalb der Pods verantwortlich ist.\n\n### Die Rolle von Docker\n\nBei allen Komponenten eines K8s-Clusters ist die Wahl der Runtime innerhalb\nder Worker Nodes von Bedeutung. Verschiedene Softwarelösungen stehen dafür\nzur Verfügung, etwa CRI-O – Docker ist jedoch das am häufigsten eingesetzte\nWerkzeug.\n\n### Was ist der Unterschied zwischen Docker und Kubernetes?\n\nDocker ist eine Open-Source-Lösung, die speziell auf Container-Ebene\neingesetzt wird. Sie ermöglicht die Paketierung von Containern in einem\nstandardisierten und schlanken Format, was ihre Portabilität in\nverschiedenen Umgebungen erhöht. Docker ist damit ein ergänzendes Werkzeug\nzu K8s: Es vereinfacht die Verwaltung der Container selbst, während\nKubernetes deren Integration und Kommunikation innerhalb der Anwendung\nerleichtert.\n\n## Welche Vorteile bietet Kubernetes?\n\nSeit dem Start durch Google im Jahr 2014 und der ersten stabilen Version\nim Juli 2015 hat sich Kubernetes als Referenz im Bereich der\nContainer-Orchestrierung etabliert – insbesondere für\nMicroservice-orientierte Architekturen. Diese Verbreitung ist vor allem\nauf die Leistungsfähigkeit von K8s in der Container-Orchestrierung\nzurückzuführen.\n\nDie Vorteile von Kubernetes im Überblick:\n- Automatisierung: Kubernetes erleichtert die Automatisierung von Aufgaben\nrund um Bereitstellung, Skalierung und Aktualisierung containerisierter\nAnwendungen.\n- Flexibilität: Die Software passt sich an unterschiedliche\nContainer-Technologien sowie verschiedene Hardware-Architekturen und\nBetriebssysteme an.\n- Skalierbarkeit: K8s ermöglicht die Bereitstellung und Verwaltung\ntausender Container – unabhängig von deren Status: laufend, pausiert oder\ngestoppt.\n- Migration: Anwendungen lassen sich zu Kubernetes migrieren, ohne den\nQuellcode ändern zu müssen.\n- Multi-Cluster-Unterstützung: Kubernetes verwaltet zentral mehrere\nContainer-Cluster, die über verschiedene Infrastrukturen verteilt sind.\n- Update-Management: Die Software unterstützt Rolling-Update-Deployments,\num Anwendungen ohne Serviceunterbrechung zu aktualisieren.\n\n## Ein robustes und skalierbares Ökosystem\n\nKubernetes zeichnet sich durch die Fähigkeit aus, Container effizient und\nzuverlässig zu verwalten und dabei unabhängig von Cloud-Infrastrukturanbietern\nzu bleiben. Die modulare Architektur passt sich den spezifischen\nAnforderungen jedes Unternehmens an und unterstützt ein breites Spektrum\nan Anwendungen und Diensten – von Webservices über Datenverarbeitung bis\nhin zu mobilen Anwendungen.\n\nKubernetes profitiert dabei von einem umfangreichen und aktiven\nOpen-Source-Ökosystem. Verwaltet von der Cloud Native Computing Foundation\n([CNCF](https://www.cncf.io/)), wird K8s von tausenden Entwicklerinnen\nund Entwicklern weltweit unterstützt, die kontinuierlich zur\nWeiterentwicklung des Projekts und seiner Funktionen beitragen.\n\n## Was sind die Grenzen von Kubernetes?\n\nDie Stärken von Kubernetes machen es für viele Entwicklungsteams im\nCloud-nativen Bereich zur soliden Grundlage. Dennoch lohnt es sich,\neinige Einschränkungen zu benennen. Kubernetes erfordert fundierte\ntechnische Kenntnisse sowie die Einarbeitung in neue Entwicklungskonzepte\nund -methoden. Die Konfiguration kann zu Beginn eines Projekts komplex\nsein – ist dabei aber entscheidend, insbesondere für die Absicherung der\nPlattform. Ein erfahrenes Entwicklungsteam mit K8s-Kenntnissen ist daher\nein wesentlicher Vorteil.\n\nEine weitere Herausforderung ist die Implementierung und Wartung einer\nK8s-Architektur, die Zeit und Ressourcen erfordert – vor allem für die\nAktualisierung der verschiedenen Komponenten und Softwareteile. Dabei\nstellt sich auch die Frage nach möglichem Oversizing: Bei kleineren\nAnwendungen oder Projekten ohne besondere Skalierungsanforderungen kann\neine einfachere Architektur ausreichend und wirtschaftlicher sein.\n\n## Kubernetes im Unternehmenseinsatz\n\nZehntausende Unternehmen haben eine Kubernetes-Architektur für ihre\ndigitale Transformation übernommen. K8s wird von Organisationen aller\nGrößen genutzt – von Startups bis zu multinationalen Konzernen.\n\nEin Beispiel für eine erfolgreiche Integration ist Haven Technologies.\nDas Unternehmen hat seine SaaS-Dienste zu K8s migriert. Dabei setzt es\nauf eine Kubernetes-Strategie mit der GitLab-DevSecOps-Plattform –\nmit messbaren Verbesserungen bei Effizienz, Sicherheit und\nEntwicklungsgeschwindigkeit. Weitere Details in der\n[Kundenreferenz](https://about.gitlab.com/customers/haven-technologies/).\n\n## Kubernetes, Git und GitLab\n\nKubernetes, Git und GitLab sind zentrale Bausteine der DevOps-Landschaft.\nKubernetes bietet hohe Flexibilität bei der Bereitstellung und Verwaltung\nder verschiedenen Anwendungskomponenten. GitLab – aufgebaut auf Git und\ndessen nativer Versionskontrolle – ermöglicht eine präzise Nachverfolgung\nvon Quellcode und Änderungen und stellt eine umfassende Werkzeugsammlung\nfür den gesamten Software-Entwicklungslebenszyklus bereit.\n\nDiese Kombination schafft gemeinsam mit einem\n[GitOps-Ansatz](https://about.gitlab.com/de-de/topics/gitops/), der die\nAutomatisierung moderner Cloud-Infrastrukturen zum Ziel hat, eine agile\nUmgebung für Anwendungsentwicklung und -bereitstellung. Alle\n[GitLab-Lösungen für den Einsatz mit Kubernetes](https://about.gitlab.com/de-de/solutions/kubernetes/)\nim Überblick.\n\n## Kubernetes FAQ\n\n### Welche Alternativen zu K8s gibt es?\n\nEs gibt verschiedene Alternativen zu Kubernetes, darunter Docker Swarm\nund Marathon. Kubernetes gilt jedoch als die ausgereifteste und am\nweitesten verbreitete Lösung auf dem Markt. Die große Nutzerbasis,\numfangreiche Dokumentation und eine aktive Community machen K8s zur\nsoliden Wahl für alle, die ein Container-Orchestrierungssystem einsetzen\nmöchten.\n\n### Was ist ein Kubernetes-Cluster?\n\nEin Kubernetes-Cluster besteht aus einem Master Node und mehreren Worker\nNodes. Der Master Node koordiniert die Aufgaben im Cluster, während die\nWorker Nodes diese Orchestrierungsaufgaben ausführen und die Container\nhosten. K8s-Cluster sind hoch skalierbar – Nodes lassen sich hinzufügen\noder entfernen, um die Clusterressourcen an die Anforderungen der Anwendung\nanzupassen.\n\n### Wie startet man mit Kubernetes?\n\nZunächst ist die Installation der Kubernetes-Software in einer kompatiblen\nUmgebung (Linux, macOS oder Windows) erforderlich. Kubernetes lässt sich\nsowohl in einer klassischen Hosting-Umgebung als auch in der Cloud\ninstallieren – etwa auf Google Kubernetes Engine oder Amazon EKS. Nach\ndem Download und der Installation von der offiziellen Website folgt die\nErstkonfiguration zur Verbindung von Master und Worker Nodes. Danach ist\ndie erste Anwendung mit Kubernetes einsatzbereit.\n\n### Warum Kubernetes wählen?\n\nKubernetes bietet hohe Flexibilität und vollständige Portabilität zwischen\nverschiedenen Cloud-Plattformen oder On-Premises-Infrastrukturen. Durch\ndie Automatisierung von Orchestrierungsaufgaben lassen sich Ressourcen\noptimieren und Betriebskosten senken. Das Kubernetes-Ökosystem ist\numfangreich und wird von einer großen Open-Source-Community\nkontinuierlich weiterentwickelt.\n\n## Mehr erfahren\n\n- [Logs über das GitLab Dashboard für Kubernetes streamen](https://about.gitlab.com/blog/how-to-stream-logs-through-the-gitlab-dashboard-for-kubernetes/)\n- [Kubernetes-Überblick: Cluster-Daten im Frontend verwalten](https://about.gitlab.com/blog/kubernetes-overview-operate-cluster-data-on-the-frontend/)\n- [Cloud-Account-Management für Kubernetes-Zugriff vereinfachen](https://about.gitlab.com/blog/simplify-your-cloud-account-management-for-kubernetes-access/)\n",[682,24],"kubernetes",{"slug":684,"featured":12,"template":13},"kubernetes-the-container-orchestration-solution",{"content":686,"config":696},{"title":687,"description":688,"authors":689,"date":691,"body":692,"heroImage":693,"category":9,"tags":694},"Was ist neu in Git 2.53.0?","Alles, was du über dieses Release wissen musst, darunter Fixes für geometrisches Repacking, Updates zu den Commit-Signature-Handling-Optionen von git-fast-import(1) und mehr.",[690],"Justin Tobler","2026-02-02","Das Git-Projekt hat kürzlich [Git 2.53.0](https://lore.kernel.org/git/xmqq4inz13e3.fsf@gitster.g/T/#u) veröffentlicht. Schauen wir uns einige Highlights dieses Releases an, das auch Beiträge vom Git-Team bei GitLab enthält.\n\n## Unterstützung für geometrisches Repacking mit Promisor Remotes\n\nNeu geschriebene Objekte in einem Git-Repository werden oft als einzelne Loose Files gespeichert. Um gute Performance und optimale Nutzung des Speicherplatzes zu gewährleisten, werden diese Loose Objects regelmäßig in sogenannte Packfiles komprimiert. Die Anzahl der Packfiles in einem Repository wächst im Laufe der Zeit durch die Aktivitäten des Users, wie das Schreiben neuer Commits oder das Fetchen von einem Remote. Je mehr Packfiles sich in einem Repository befinden, desto mehr Arbeit hat Git beim Nachschlagen einzelner Objekte. Um die optimale Repository-Performance zu erhalten, werden Packfiles daher regelmäßig über git-repack(1) neu gepackt, um die Objekte in weniger Packfiles zu konsolidieren. Beim Repacking gibt es zwei Strategien: „All-into-One\" und „Geometric\".\n\nDie All-into-One-Strategie ist relativ unkompliziert und derzeit der Standard. Wie der Name schon sagt, werden alle Objekte im Repository in ein einziges Packfile gepackt. Aus Performance-Sicht ist das großartig für das Repository, da Git nur ein einzelnes Packfile durchsuchen muss, um Objekte nachzuschlagen. Der Hauptnachteil dieser Repacking-Strategie ist, dass die Berechnung eines einzigen Packfiles für ein Repository bei großen Repositories erheblich viel Zeit in Anspruch nehmen kann.\n\nDie Geometric-Strategie hilft, dieses Problem zu entschärfen, indem sie eine geometrische Progression von Packfiles basierend auf ihrer Größe beibehält, anstatt immer in ein einziges Packfile neu zu packen. Also: Beim Repacking pflegt Git eine Reihe von Packfiles, die nach Größe geordnet sind, wobei jedes Packfile in der Sequenz mindestens doppelt so groß sein soll wie das vorhergehende Packfile. Wenn ein Packfile in der Sequenz diese Eigenschaft verletzt, werden Packfiles bei Bedarf kombiniert, bis die Progression wiederhergestellt ist. Diese Strategie hat den Vorteil, dass sie die Anzahl der Packfiles in einem Repository minimiert und gleichzeitig den Arbeitsaufwand für die meisten Repacking-Operationen minimiert.\n\nEin Problem mit der geometrischen Repacking-Strategie war, dass sie nicht mit Partial Clones kompatibel war. Partial Clones ermöglichen es dir, nur Teile eines Repositorys zu klonen, indem du zum Beispiel alle Blobs größer als 1 Megabyte überspringst. Das kann die Größe eines Repositorys erheblich reduzieren, und Git weiß, wie es fehlende Objekte nachträglich abrufen kann, auf die es zu einem späteren Zeitpunkt zugreifen muss.\n\nDas Ergebnis ist ein Repository, dem einige Objekte fehlen, und jedes Objekt, das möglicherweise nicht vollständig verbunden ist, wird in einem „Promisor\"-Packfile gespeichert. Beim Repacking muss diese Promisor-Eigenschaft für Packfiles, die ein Promisor-Objekt enthalten, beibehalten werden, damit bekannt ist, ob ein fehlendes Objekt erwartet wird und vom Promisor Remote nachgeladen werden kann. \n\nBei einem All-into-One-Repack weiß Git, wie es Promisor-Objekte richtig behandelt und speichert sie in einem separaten Promisor-Packfile. Leider wusste die geometrische Repacking-Strategie nicht, Promisor-Packfiles eine Sonderbehandlung zu geben, und würde sie stattdessen mit normalen Packfiles zusammenführen, ohne zu berücksichtigen, ob sie auf Promisor-Objekte verweisen. Glücklicherweise schlägt aufgrund eines Bugs das zugrunde liegende git-pack-objects(1) fehl, wenn geometrisches Repacking in einem Partial-Clone-Repository verwendet wird. Das bedeutet, dass Repositories in dieser Konfiguration sowieso nicht neu gepackt werden konnten, was nicht großartig ist, aber besser als Repository-Korruption.\n\nMit dem Release von Git 2.53 funktioniert geometrisches Repacking jetzt mit Partial-Clone-Repositories. Bei einem geometrischen Repack werden Promisor-Packfiles separat behandelt, um die Promisor-Markierung zu erhalten, und nach einer separaten geometrischen Progression neu gepackt. Mit diesem Fix rückt die geometrische Strategie näher daran, die Standard-Repacking-Strategie zu werden. Für weitere Informationen schau dir den entsprechenden [Mailing-List-Thread](https://lore.kernel.org/git/20260105-pks-geometric-repack-with-promisors-v1-0-c4660573437e@pks.im/) an.\n\nDieses Projekt wurde von [Patrick Steinhardt](https://gitlab.com/pks-gitlab) geleitet.\n\n## git-fast-import(1) hat gelernt, nur gültige Signaturen zu erhalten\n\nIn unserem [Git 2.52 Release-Artikel](https://about.gitlab.com/de-de/blog/whats-new-in-git-2-52-0/) haben wir signatur-bezogene Verbesserungen an git-fast-import(1) und git-fast-export(1) behandelt. Schau dir diesen Post unbedingt an für eine detailliertere Erklärung dieser Befehle, wie sie verwendet werden und welche Änderungen in Bezug auf Signaturen vorgenommen werden.\n\nUm es kurz zusammenzufassen: git-fast-import(1) bietet ein Backend zum effizienten Importieren von Daten in ein Repository und wird von Tools wie [git-filter-repo(1)](https://github.com/newren/git-filter-repo) verwendet, um die History eines Repositorys in großem Umfang neu zu schreiben. Im Git 2.52 Release hat git-fast-import(1) die Option `--signed-commits=\u003Cmode>` gelernt, ähnlich wie die gleiche Option in git-fast-export(1). Mit dieser Option wurde es möglich, Signaturen von Commits/Tags ohne Bedingung beizubehalten oder zu entfernen.\n\nIn Situationen, in denen nur ein Teil der Repository-History neu geschrieben wurde, wird jede Signatur für neu geschriebene Commits/Tags ungültig. Das bedeutet, dass git-fast-import(1) darauf beschränkt ist, entweder alle Signaturen zu entfernen oder alle Signaturen zu behalten, selbst wenn sie ungültig geworden sind. Aber ungültige Signaturen zu behalten, macht nicht viel Sinn, daher führt das Neuschreiben der History mit git-filter-repo(1) dazu, dass alle Signaturen entfernt werden, selbst wenn der zugrunde liegende Commit/Tag nicht neu geschrieben wurde. Das ist schade, denn wenn der Commit/Tag unverändert ist, ist seine Signatur noch gültig, und es gibt daher keinen wirklichen Grund, sie zu entfernen. Was wirklich benötigt wird, ist eine Möglichkeit, Signaturen für unveränderte Objekte zu erhalten, aber ungültige zu entfernen.\n\nMit dem Release von Git 2.53 hat die Option `--signed-commits=\u003Cmode>` von git-fast-import(1) einen neuen Modus `strip-if-invalid` gelernt, der, wenn angegeben, nur Signaturen von Commits entfernt, die durch das Neuschreiben ungültig werden. Mit dieser Option wird es also möglich, einige Commit-Signaturen bei der Verwendung von git-fast-import(1) zu erhalten. Das ist ein entscheidender Schritt zur Bereitstellung der Grundlage für Tools wie git-filter-repo(1), um gültige Signaturen zu erhalten und schließlich ungültige Signaturen neu zu signieren.\n\nDieses Projekt wurde von [Christian Couder](https://gitlab.com/chriscool) geleitet.\n\n## Mehr Daten in git-repo-structure gesammelt\n\nIm Git 2.52 Release wurde der „structure\"-Subcommand zu git-repo(1) eingeführt. Die Absicht dieses Befehls war es, Informationen über das Repository zu sammeln und schließlich ein nativer Ersatz für Tools wie [git-sizer(1)](https://github.com/github/git-sizer) zu werden. Bei GitLab hosten wir einige extrem große Repositories, und Einblicke in die allgemeine Struktur eines Repositorys sind entscheidend, um seine Performance-Charakteristiken zu verstehen. In diesem Release sammelt der Befehl jetzt auch Informationen zur Gesamtgröße von erreichbaren Objekten in einem Repository, um die Gesamtgröße des Repositorys zu verstehen. In der folgenden Ausgabe kannst du sehen, dass der Befehl jetzt sowohl die gesamten Inflated- als auch Disk-Größen von erreichbaren Objekten nach Objekttyp sammelt.\n\n```shell\n\n$ git repo structure\n\n| Repository structure | Value      |\n| -------------------- | ---------- |\n| * References         |            |\n|   * Count            |   1.78 k   |\n|     * Branches       |      5     |\n|     * Tags           |   1.03 k   |\n|     * Remotes        |    749     |\n|     * Others         |      0     |\n|                      |            |\n| * Reachable objects  |            |\n|   * Count            | 421.37 k   |\n|     * Commits        |  88.03 k   |\n|     * Trees          | 169.95 k   |\n|     * Blobs          | 162.40 k   |\n|     * Tags           |    994     |\n|   * Inflated size    |   7.61 GiB |\n|     * Commits        |  60.95 MiB |\n|     * Trees          |   2.44 GiB |\n|     * Blobs          |   5.11 GiB |\n|     * Tags           | 731.73 KiB |\n|   * Disk size        | 301.50 MiB |\n|     * Commits        |  33.57 MiB |\n|     * Trees          |  77.92 MiB |\n|     * Blobs          | 189.44 MiB |\n|     * Tags           | 578.13 KiB |\n\n```\n\nWer genau hinschaut, dem fällt vielleicht auch auf, dass die Größenwerte in der Tabellenausgabe jetzt auch benutzerfreundlicher mit angehängten Einheiten aufgelistet werden. In zukünftigen Releases hoffen wir, die Ausgabe dieses Befehls weiter zu erweitern, um zusätzliche Datenpunkte bereitzustellen, wie zum Beispiel die größten einzelnen Objekte im Repository.\n\nDieses Projekt wurde von [Justin Tobler](https://gitlab.com/justintobler) geleitet.\n\n## Mehr erfahren\n\nDieser Artikel hat nur einige der Beiträge von GitLab und der breiteren Git-Community für dieses neueste Release hervorgehoben. Du kannst mehr über diese aus der [offiziellen Release-Ankündigung](https://lore.kernel.org/git/xmqq4inz13e3.fsf@gitster.g/T/#u) des Git-Projekts erfahren. Schau dir auch unsere [früheren Git-Release-Blogposts](https://about.gitlab.com/blog/tags/git/) an, um andere vergangene Highlights von Beiträgen der GitLab-Teammitglieder zu sehen.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749663087/Blog/Hero%20Images/git3-cover.png",[24,695,260],"git",{"featured":12,"template":13,"slug":697},"whats-new-in-git-2-53-0",{"content":699,"config":709},{"title":700,"description":701,"authors":702,"heroImage":693,"date":706,"body":707,"category":9,"tags":708},"Was ist neu in Git 2.52.0?","Alles zum aktuellen Release, darunter der neue git-last-modified(1)-Befehl, Verbesserungen an History-Rewriting-Tools und eine neue Maintenance-Strategie.",[703,704,705],"Christian Couder","Toon Claes","Patrick Steinhardt","2025-11-17","Das Git-Projekt hat kürzlich [Git 2.52](https://lore.kernel.org/git/xmqqh5usmvsd.fsf@gitster.g/) veröffentlicht. Nach einem relativ kurzen 8-Wochen-[Release-Zyklus für 2.51](https://about.gitlab.com/de-de/blog/what-s-new-in-git-2-51-0/), aufgrund des Sommers auf der Nordhalbkugel, ist dieses Release wieder beim üblichen 12-Wochen-Zyklus.\n\nSchauen wir uns einige Highlights an, darunter Beiträge vom GitLab Git-Team und der weiteren Git-Community.\n\n## Neuer git-last-modified(1)-Befehl\n\nViele Git-Forges wie GitLab zeigen Dateien in einer Tree-Ansicht wie dieser an:\n\n\n| Name        | Last commit                                             | Last update  |\n| ------------- | --------------------------------------------------------- | -------------- |\n| README.md   | README: *.txt -> *.adoc fixes                           | 4 months ago |\n| RelNotes    | Start 2.51 cycle, the first batch                       | 4 weeks ago  |\n| SECURITY.md | SECURITY: describe how to report vulnerabilities        | 4 years      |\n| abspath.c   | abspath: move related functions to abspath              | 2 years      |\n| abspath.h   | abspath: move related functions to abspath              | 2 years      |\n| aclocal.m4  | configure: use AC_LANG_PROGRAM consistently             | 15 years ago |\n| add-patch.c | pager: stop using `the_repository`                      | 7 months ago |\n| advice.c    | advice: allow disabling default branch name advice      | 4 months ago |\n| advice.h    | advice: allow disabling default branch name advice      | 4 months ago |\n| alias.h     | rebase -m: fix serialization of strategy options        | 2 years      |\n| alloc.h     | git-compat-util: move alloc macros to git-compat-util.h | 2 years ago  |\n| apply.c     | apply: only write intents to add for new files          | 8 days ago   |\n| archive.c   | Merge branch 'ps/parse-options-integers'                | 3 months ago |\n| archive.h   | archive.h: remove unnecessary include                   | 1 year       |\n| attr.h      | fuzz: port fuzz-parse-attr-line from OSS-Fuzz           | 9 months ago |\n| banned.h    | banned.h: mark `strtok()` and `strtok_r()` as banned    | 2 years      |\n\n\n\u003Cbr>\u003C/br>\n\nNeben den Dateien selbst zeigen wir auch an, welcher Commit jede jeweilige Datei zuletzt geändert hat. Diese Information lässt sich einfach aus Git extrahieren, indem du folgenden Befehl ausführst:\n\n```shell\n\n$ git log --max-count=1 HEAD -- \u003Cfilename>\n\n```\n\nObwohl schön und einfach, hat das einen erheblichen Haken: Git hat keine Möglichkeit, diese Information für jede dieser Dateien in einem einzigen Befehl zu extrahieren. Um also den letzten Commit für alle Dateien im Tree zu erhalten, müssten wir diesen Befehl für jede Datei separat ausführen. Das führt zu einer Befehlspipeline ähnlich der folgenden:\n\n```shell\n\n$ git ls-tree HEAD --name-only | xargs --max-args=1 git log --max-count=1 HEAD --\n\n```\n\nNatürlich ist das nicht sehr effizient:\n\n\n* Wir müssen für jede Datei einen neuen Git-Befehl starten.\n\n\n* Git muss die History für jede Datei separat durchlaufen.\n\n\n\nAls Konsequenz ist diese gesamte Operation ziemlich kostspielig und erzeugt erhebliche Last für GitLab.\n\n\n\nUm diese Probleme zu beheben, wurde ein neuer Git-Subcommand `git-last-modified(1)` eingeführt. Dieser Befehl gibt den Commit für jede Datei eines gegebenen Commits zurück:\n\n```shell\n\n$ git last-modified HEAD\n\n\ne56f6dcd7b4c90192018e848d0810f091d092913        add-patch.c\n373ad8917beb99dc643b6e7f5c117a294384a57e        advice.h\ne9330ae4b820147c98e723399e9438c8bee60a80        advice.c\n5e2feb5ca692c5c4d39b11e1ffa056911dd7dfd3        alloc.h\n954d33a9757fcfab723a824116902f1eb16e05f7        RelNotes\n4ce0caa7cc27d50ee1bedf1dff03f13be4c54c1f        apply.c\n5d215a7b3eb0a9a69c0cb9aa43dcae956a0aa03e        archive.c\nc50fbb2dd225e7e82abba4380423ae105089f4d7        README.md\n72686d4e5e9a7236b9716368d86fae5bf1ae6156        attr.h\nc2c4138c07ca4d5ffc41ace0bfda0f189d3e262e        archive.h\n5d1344b4973c8ea4904005f3bb51a47334ebb370        abspath.c\n5d1344b4973c8ea4904005f3bb51a47334ebb370        abspath.h\n60ff56f50372c1498718938ef504e744fe011ffb        banned.h\n4960e5c7bdd399e791353bc6c551f09298746f61        alias.h\n2e99b1e383d2da56c81d7ab7dd849e9dab5b7bf0        SECURITY.md\n1e58dba142c673c59fbb9d10aeecf62217d4fc9c        aclocal.m4\n\n```\n\n\n\nDer Vorteil davon ist offensichtlich, dass wir jetzt nur noch einen einzigen Git-Prozess ausführen müssen, um all diese Informationen abzuleiten. Aber noch wichtiger ist, dass wir die History nur einmal für alle Dateien zusammen durchlaufen müssen, anstatt sie mehrmals durchlaufen zu müssen. Dies wird wie folgt erreicht:\n\n\n1. Beginne damit, die History vom angegebenen Commit aus zu durchlaufen.\n\n\n2. Für jeden Commit:\n\n\n\n   1. Wenn er keinen der Pfade ändert, an denen wir interessiert sind, fahren wir mit dem nächsten Commit fort.\n   2. Wenn er es tut, geben wir die Commit-ID zusammen mit dem Pfad aus. Außerdem entfernen wir den Pfad aus der Menge der interessanten Pfade.\n\n\n\n3. Wenn die Liste der interessanten Pfade leer wird, stoppen wir.\n\n\n\nGitaly wurde bereits angepasst, um den neuen Befehl zu verwenden, aber die Logik ist noch hinter einem Feature-Flag geschützt. Vorläufige Tests haben gezeigt, dass `git-last-modified(1)` in den meisten Situationen mindestens doppelt so schnell ist wie die Verwendung von `git log --max-count=1`.\n\n\n\n*Diese Änderungen wurden [ursprünglich geschrieben](https://github.com/ttaylorr/git/tree/tb/blame-tree) von mehreren Entwicklern von GitHub und wurden [upstream](https://lore.kernel.org/git/20250805093358.1791633-1-toon@iotcl.com/) in Git von [Toon Claes](https://gitlab.com/toon) integriert.*\n\n\n\n## Signatur-bezogene Verbesserungen für git-fast-export(1) und git-fast-import(1)\n\n\n\nDie Befehle `git-fast-export(1)` und `git-fast-import(1)` sind dafür konzipiert, hauptsächlich von Interoperabilitäts- oder History-Rewriting-Tools verwendet zu werden. Das Ziel von Interoperabilitäts-Tools ist es, Git problemlos mit anderer Software interagieren zu lassen, normalerweise einem anderen Versionskontrollsystem, das Daten in einem anderen Format als Git speichert. Zum Beispiel ist [hg-fast-export.sh](https://github.com/frej/fast-export) ein „Mercurial-zu-Git-Konverter, der git-fast-import verwendet.\"\n\n\n\nAlternativ lassen History-Rewriting-Tools Benutzer – normalerweise Admins – Änderungen an der History ihrer Repositories vornehmen, die Versionskontrollsysteme nicht zulassen. Zum Beispiel sagt [reposurgeon](http://www.catb.org/esr/reposurgeon/) in seiner [Einführung](https://gitlab.com/esr/reposurgeon/-/blob/master/repository-editing.adoc?ref_type=heads#introduction), dass sein Zweck ist, „riskante Operationen zu ermöglichen, die Versionskontrollsysteme dich nicht durchführen lassen wollen, wie zum Beispiel (a) Bearbeitung vergangener Kommentare und Metadaten, (b) Entfernung von Commits, (c) Zusammenführung und Aufteilung von Commits, (d) Entfernung von Dateien und Subtrees aus der Repo-History, (e) Zusammenführung oder Verknüpfung von zwei oder mehr Repos und (f) Aufteilung eines Repos in zwei durch Durchtrennung einer Parent-Child-Verbindung, wobei die Branch-Struktur beider Child-Repos erhalten bleibt.\"\n\n\n\nInnerhalb von GitLab verwenden wir [git-filter-repo](https://github.com/newren/git-filter-repo), um Admins einige riskante Operationen an ihren Git-Repositories durchführen zu lassen. Leider haben bis Git 2.50 (veröffentlicht im letzten Juni) sowohl `git-fast-export(1)` als auch `git-fast-import(1)` kryptografische Commit-Signaturen überhaupt nicht behandelt. Obwohl `git-fast-export(1)` also eine Option `--signed-tags=\u003Cmode>` hatte, die es Benutzern ermöglicht zu ändern, wie kryptografische Tag-Signaturen behandelt werden, wurden Commit-Signaturen einfach ignoriert.\n\n\n\nKryptografische Signaturen sind sehr fragil, weil sie auf den exakten Commit- oder Tag-Daten basieren, die signiert wurden. Wenn sich die signierten Daten oder irgendetwas von ihrer vorhergehenden History ändert, wird die kryptografische Signatur ungültig. Dies ist eine fragile, aber notwendige Anforderung, um diese Signaturen nützlich zu machen.\n\n\n\nAber im Kontext des Neuschreibens der History ist das ein Problem:\n\n\n\n* Wir möchten vielleicht kryptografische Signaturen sowohl für Commits als auch für Tags behalten, die nach dem Neuschreiben noch gültig sind (z.B. weil sich die History, die zu ihnen führt, nicht geändert hat).\n\n\n* Wir möchten vielleicht neue kryptografische Signaturen für Commits und Tags erstellen, bei denen die vorherige Signatur ungültig geworden ist.\n\n\n\nWeder `git-fast-import(1)` noch `git-fast-export(1)` erlauben diese Anwendungsfälle jedoch, was einschränkt, was Tools wie [git-filter-repo](https://github.com/newren/git-filter-repo) oder [reposurgeon](http://www.catb.org/esr/reposurgeon/) erreichen können.\n\n\n\nWir haben einige erhebliche Fortschritte gemacht:\n\n\n\n* In Git 2.50 haben wir eine Option `--signed-commits=\u003Cmode>` zu `git-fast-export(1)` hinzugefügt, um Commit-Signaturen zu exportieren, und Unterstützung in `git-fast-import(1)`, um sie zu importieren.\n\n\n* In Git 2.51 haben wir das Format verbessert, das zum Exportieren und Importieren von Commit-Signaturen verwendet wird, und wir haben es für `git-fast-import(1)` möglich gemacht, sowohl eine Signatur zu importieren, die auf der SHA-1-Objekt-ID des Commits gemacht wurde, als auch eine, die auf seiner SHA-256-Objekt-ID gemacht wurde.\n\n\n* In Git 2.52 haben wir die Optionen `--signed-commits=\u003Cmode>` und `--signed-tags=\u003Cmode>` zu `git-fast-import(1)` hinzugefügt, sodass der Benutzer Kontrolle darüber hat, wie signierte Daten zum Zeitpunkt des Imports behandelt werden.\n\n\n\nEs gibt noch mehr zu tun. Wir müssen die Fähigkeit hinzufügen:\n\n\n\n* Nur die Commit-Signaturen beizubehalten, die noch gültig sind, zu `git-fast-import(1)`.\n\n\n* Daten neu zu signieren, bei denen die Signatur ungültig wurde.\n\n\n\nWir arbeiten bereits an diesen nächsten Schritten, und erwarten, dass dies in Git 2.53 landet. Sobald das erledigt ist, werden Tools wie `git-filter-repo(1)` endlich beginnen, kryptografische Signaturen eleganter zu handhaben. Wir werden dich in unserem nächsten Git-Release-Blogpost auf dem Laufenden halten.\n\n\n\n*Dieses Projekt wurde von [Christian Couder](https://gitlab.com/chriscool) geleitet.*\n\n\n\n## Neue und verbesserte git-maintenance(1)-Strategien\n\n\n\nGit-Repositories benötigen regelmäßige Wartung, um sicherzustellen, dass sie gut funktionieren. Diese Wartung führt eine Reihe verschiedener Aufgaben aus: Referenzen werden optimiert, Objekte werden komprimiert und veraltete Daten werden bereinigt.\n\n\n\nBis Git 2.28 wurden diese Wartungsaufgaben von `git-gc(1)` durchgeführt. Das Problem mit diesem Befehl war, dass er nicht mit Blick auf Anpassbarkeit entwickelt wurde: Während bestimmte Parameter konfiguriert werden können, ist es nicht möglich zu kontrollieren, welche Teile eines Repositorys optimiert werden sollen. Das bedeutet, dass es möglicherweise nicht für alle Anwendungsfälle gut geeignet ist. Noch wichtiger ist, dass es sehr schwer wurde, darüber zu iterieren, wie genau Git Repository-Wartung durchführt.\n\n\n\nUm dieses Problem zu beheben und uns wieder iterieren zu lassen, hat [Derrick Stolee](https://github.com/derrickstolee) `git-maintenance(1)` eingeführt. Im Gegensatz zu `git-gc(1)` ist es mit Blick auf Anpassbarkeit entwickelt und ermöglicht es dem Benutzer zu konfigurieren, welche Aufgaben speziell in einem bestimmten Repository ausgeführt werden sollen. Dieses neue Tool wurde in Git 2.29 zum Standard für Gits automatisierte Wartung gemacht, aber standardmäßig verwendet es immer noch `git-gc(1)`, um die Wartung durchzuführen.\n\n\n\nWährend diese Standard-Wartungsstrategie in kleinen oder sogar mittelgroßen Repositories gut funktioniert, ist sie im Kontext großer Monorepos problematisch. Der größte limitierende Faktor ist, wie `git-gc(1)` Objekte neu packt: Immer wenn es mehr als 50 Packfiles gibt, wird das Tool alle zusammen in ein einziges Packfile zusammenführen. Diese Operation ist ziemlich CPU-intensiv und verursacht viele I/O-Operationen, sodass diese Operation für große Monorepos leicht viele Minuten oder sogar Stunden dauern kann.\n\n\n\nGit weiß bereits, wie diese Repacks durch „geometrisches Repacking\" minimiert werden können. Die Idee ist einfach: Die Packfiles, die im Repository existieren, müssen einer geometrischen Progression folgen, bei der jedes Packfile mindestens doppelt so viele Objekte enthalten muss wie das nächstkleinere. Dies ermöglicht es Git, die Anzahl der erforderlichen Repacks zu amortisieren und gleichzeitig sicherzustellen, dass es insgesamt nur eine relativ kleine Anzahl von Packfiles gibt. Dieser Modus wurde von [Taylor Blau](https://github.com/ttaylorr) in Git 2.32 eingeführt, aber er wurde nicht als Teil der automatisierten Wartung eingebunden.\n\n\n\nAlle Teile existieren, um die Repository-Wartung für große Monorepos viel skalierbarer zu machen: Wir haben das flexible `git-maintenance(1)`-Tool, das erweitert werden kann, um eine neue Wartungsstrategie zu haben, und wir haben einen besseren Weg, Objekte neu zu packen. Alles, was getan werden muss, ist, diese beiden zu kombinieren.\n\n\n\nUnd genau das haben wir mit Git 2.52 getan! Wir haben eine neue „geometrische\" Wartungsstrategie eingeführt, die du in deinen Git-Repositories konfigurieren kannst. Diese Strategie ist als vollständiger Ersatz für die alte Strategie basierend auf `git-gc(1)` gedacht. Hier ist der Config-Code, den du benötigst:\n\n\n```shell\n\n$ git config set maintenance.strategy geometric\n\n```\n\n\n\nAb jetzt verwendet Git geometrisches Repacking verwenden, um deine Objekte zu optimieren. Das sollte zu weniger Churn führen und gleichzeitig sicherstellen, dass deine Objekte in einem besser optimierten Zustand sind, besonders in großen Monorepos.\n\n\n\nIn Git 2.53 wollen wir dies zur Standard-Strategie machen. Also bleib dran!\n\n\n\n*Dieses Projekt wurde von [Patrick Steinhardt](https://gitlab.com/pks-gitlab) geleitet.*\n\n\n\n## Neuer Subcommand für git-repo(1) zur Anzeige von Repository-Metriken\n\n\n\nDie Performance von Git-Operationen in einem Repository hängt oft von bestimmten Eigenschaften seiner zugrunde liegenden Struktur ab. Bei GitLab hosten wir einige extrem große Repositories, und Einblicke in die allgemeine Struktur eines Repositorys sind entscheidend, um die Performance zu verstehen. Während es möglich ist, verschiedene Git-Befehle und andere Tools zusammenzusetzen, um bestimmte Repository-Metriken zu ermitteln, fehlt Git eine Möglichkeit, Informationen über die Form/Struktur eines Repositorys über einen einzigen Befehl zu liefern. Dies hat zur Entwicklung anderer externer Tools geführt, wie [git-sizer(1)](https://github.com/github/git-sizer), um diese Lücke zu füllen.\n\n\n\nMit dem Release von Git 2.52 wurde ein neuer „structure\"-Subcommand zu git-repo(1) hinzugefügt mit dem Ziel, Informationen über die Struktur eines Repositorys zu liefern. Derzeit zeigt er Informationen über die Anzahl der Referenzen und Objekte im Repository in der folgenden Form an:\n\n```shell\n\n$ git repo structure\n\n\n| Repository structure | Value  |\n| -------------------- | ------ |\n| * References         |        |\n|   * Count            |   1772 |\n|     * Branches       |      3 |\n|     * Tags           |   1025 |\n|     * Remotes        |    744 |\n|     * Others         |      0 |\n|                      |        |\n| * Reachable objects  |        |\n|   * Count            | 418958 |\n|     * Commits        |  87468 |\n|     * Trees          | 168866 |\n|     * Blobs          | 161632 |\n|     * Tags           |    992 |\n\n```\n\n\n\nIn zukünftigen Releases hoffen wir, dies zu erweitern und andere interessante Datenpunkte bereitzustellen, wie die größten Objekte im Repository.\n\n\n\n*Dieses Projekt wurde von [Justin Tobler](https://gitlab.com/justintobler) geleitet.*\n\n\n\n## Verbesserungen im Zusammenhang mit dem Google Summer of Code 2025\n\n\n\nWir hatten drei erfolgreiche Projekte mit dem Google Summer of Code.\n\n\n\n### Refactoring zur Reduzierung von Gits globalem Status\n\n\n\nGit enthält mehrere globale Variablen, die in der gesamten Codebasis verwendet werden. Dies erhöht die Komplexität des Codes und verringert die Wartbarkeit. Als Teil dieses Projekts hat [Ayush Chandekar](https://ayu-ch.github.io/) daran gearbeitet, die Verwendung der globalen Variable `the_repository` durch eine Reihe von Patches zu reduzieren.\n\n\n\n*Das Projekt wurde betreut von [Christian Couder](https://gitlab.com/chriscool) und [Ghanshyam Thakkar](https://in.linkedin.com/in/ghanshyam-thakkar).*\n\n\n\n### Maschinenlesbares Repository-Informations-Abfrage-Tool\n\n\n\nGit fehlt ein zentraler Weg, um Repository-Informationen abzurufen, was Benutzer zwingt, sie aus verschiedenen Befehlen zusammenzusetzen. Während `git-rev-parse(1)` zum De-facto-Tool für den Zugriff auf viele dieser Informationen geworden ist, liegt dies außerhalb seines Hauptzwecks.\n\n\n\nAls Teil dieses Projekts hat [Lucas Oshiro](https://lucasoshiro.github.io/en/) einen neuen Befehl eingeführt, `git-repo(1)`, der alle Repository-Level-Informationen beherbergen wird. Benutzer können jetzt `git repo info` verwenden, um Repository-Informationen zu erhalten:\n\n```shell\n\n$ git repo info layout.bare layout.shallow object.format references.format\n\nlayout.bare=false\nlayout.shallow=false\nobject.format=sha1\nreferences.format=reftable\n\n```\n\n\n\n*Das Projekt wurde betreut von [Patrick Steinhardt](https://gitlab.com/pks-gitlab) und [Karthik Nayak](https://gitlab.com/knayakgl).*\n\n\n\n### Konsolidierung ref-bezogener Funktionalität in git-refs\n\n\n\nGit bietet mehrere Befehle zur Verwaltung von Referenzen, nämlich `git-for-each-ref(1)`, `git show-ref(1)`, `git-update-ref(1)` und `git-pack-refs(1)`. Das macht sie schwerer zu entdecken und erzeugt sich überschneidende Funktionalität. Um dies anzugehen, haben wir den Befehl `git-refs(1)` eingeführt, um diese Operationen unter einer einzigen Schnittstelle zu konsolidieren. Als Teil dieses Projekts hat [Meet Soni](https://inosmeet.github.io/) den Befehl durch Hinzufügen der folgenden Subcommands erweitert:\n\n\n\n* `git refs optimize` zur Optimierung des Reference-Backends\n\n\n* `git refs list` zum Auflisten aller Referenzen\n\n\n* `git refs exists` zur Überprüfung der Existenz einer Referenz\n\n\n\n*Das Projekt wurde betreut von [Patrick Steinhardt](https://gitlab.com/pks-gitlab) und [shejialuo](https://luolibrary.com/).*\n\n\n\n## Was kommt als Nächstes?\n\n\n\nBereit, diese Verbesserungen zu erleben? Aktualisiere auf Git 2.52.0 und fang an, `git last-modified` zu verwenden.\n\n\n\nBei GitLab werden wir natürlich sicherstellen, dass all diese Verbesserungen schließlich in einer GitLab-Instanz in deiner Nähe landen!\n\n\n\nErfahre mehr in den [offiziellen Git 2.52.0 Release Notes](https://lore.kernel.org/git/xmqqh5usmvsd.fsf@gitster.g/) und erkunde unser [vollständiges Archiv der Git-Entwicklungs-Berichterstattung](https://about.gitlab.com/blog/tags/git/).",[24,695,260],{"featured":12,"template":13,"slug":710},"whats-new-in-git-2-52-0",{"promotions":712},[713,727,740],{"id":714,"categories":715,"header":717,"text":718,"button":719,"image":724},"ai-modernization",[716],"ai-ml","Is AI achieving its promise at scale?","Quiz will take 5 minutes or less",{"text":720,"config":721},"Get your AI maturity score",{"href":722,"dataGaName":723,"dataGaLocation":242},"/assessments/ai-modernization-assessment/","modernization assessment",{"config":725},{"src":726},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1772138786/qix0m7kwnd8x2fh1zq49.png",{"id":728,"categories":729,"header":732,"text":718,"button":733,"image":737},"devops-modernization",[730,731],"product","devsecops","Are you just managing tools or shipping innovation?",{"text":734,"config":735},"Get your DevOps maturity score",{"href":736,"dataGaName":723,"dataGaLocation":242},"/assessments/devops-modernization-assessment/",{"config":738},{"src":739},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1772138785/eg818fmakweyuznttgid.png",{"id":741,"categories":742,"header":744,"text":718,"button":745,"image":749},"security-modernization",[743],"security","Are you trading speed for security?",{"text":746,"config":747},"Get your security maturity score",{"href":748,"dataGaName":723,"dataGaLocation":242},"/assessments/security-modernization-assessment/",{"config":750},{"src":751},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1772138786/p4pbqd9nnjejg5ds6mdk.png",{"header":753,"blurb":754,"button":755,"secondaryButton":760},"Beginne noch heute, schneller zu entwickeln","Entdecke, was dein Team mit der intelligenten Orchestrierungsplattform für DevSecOps erreichen kann.\n",{"text":756,"config":757},"Kostenlosen Test starten",{"href":758,"dataGaName":48,"dataGaLocation":759},"https://gitlab.com/-/trial_registrations/new?glm_content=default-saas-trial&glm_source=about.gitlab.com/","feature",{"text":50,"config":761},{"href":52,"dataGaName":53,"dataGaLocation":759},1772652056895]