Die wich­tigs­ten Docker-Tools

Das Docker-Ökosystem umfasst eine Vielzahl von Tools, die den gesamten Le­bens­zy­klus eines Con­tai­ners abdecken – von der Er­stel­lung (Build) über die Or­ches­trie­rung bis zur Ab­si­che­rung (Security). Während Docker die Kern-Runtime stellt, ergänzen Tools wie Compose, Scout und Ku­ber­netes die Plattform zu einer voll­stän­di­gen Cloud-Native-In­fra­struk­tur.

Docker-Tools im Überblick

Docker Engine als Basis des Docker-Öko­sys­tems

Docker Engine ist die tech­ni­sche Grundlage der Plattform. Sie stellt die Lauf­zeit­um­ge­bung für Docker-Container bereit und übernimmt zentrale Aufgaben beim Erstellen und Ausführen con­tai­ne­ri­sier­ter An­wen­dun­gen.

Zum Kern von Docker Engine gehören:

• der Docker-Daemon als Hin­ter­grund­dienst
• die REST-API zur Steuerung der Engine
• die Docker-CLI für den Zugriff per Kom­man­do­zei­le

Damit bildet Docker Engine die Basis für viele weitere Werkzeuge im Ökosystem, etwa Docker Desktop, Compose oder Buildx.

Docker Desktop als Schalt­stel­le für die lokale Ent­wick­lung

Docker Desktop ist für viele Ent­wick­lungs­um­ge­bun­gen die zentrale Ober­flä­che im Docker-Ökosystem. Die Plattform bündelt die lokale Docker-Umgebung auf macOS, Windows und Linux und stellt eine grafische Ober­flä­che für Container, Docker-Images und An­wen­dun­gen bereit. Zu­sätz­lich enthält Docker Desktop Werkzeuge zum Bauen, Teilen und Ausführen con­tai­ne­ri­sier­ter An­wen­dun­gen.

Typische Funk­tio­nen von Docker Desktop sind:

• Ver­wal­tung von Con­tai­nern, Images, Volumes und Netz­wer­ken
• Zugriff auf Logs und Lauf­zeit­in­for­ma­tio­nen
• In­te­gra­ti­on von Docker Compose
• lokale Ku­ber­netes-Umgebung
• Er­wei­te­rung über Docker Ex­ten­si­ons

Ein wichtiger Be­stand­teil sind die Docker Ex­ten­si­ons. Über den Ex­ten­si­ons Mar­ket­place lassen sich Dritt­an­bie­ter-Tools direkt in Docker Desktop einbinden. Docker be­schreibt Ex­ten­si­ons aus­drück­lich als Mög­lich­keit, Ent­wick­lungs-, Debugging-, Security- und Netz­werk­funk­tio­nen in die lokale Docker-Umgebung zu in­te­grie­ren. Prak­ti­sche Beispiele sind etwa die Grafana-Extension, mit der sich Metriken und Logs aus der lokalen Docker-Desktop-Umgebung an Grafana Cloud anbinden und in Da­sh­boards auswerten lassen, sowie die Trivy-Extension von Aqua Security, mit der lokale oder entfernte Container-Images direkt in Docker Desktop auf bekannte Schwach­stel­len und Fehl­kon­fi­gu­ra­tio­nen geprüft werden können. Trivy wird außerdem für die Er­stel­lung von SBOMs im Docker-Desktop-Umfeld ein­ge­setzt.

Für Teams ist Docker Desktop damit nicht nur eine Lauf­zeit­um­ge­bung, sondern auch ein zentraler Ein­stiegs­punkt in Compose-, Build-, Registry-, Mo­ni­to­ring- und Security-Workflows. Bei Ex­ten­si­ons gilt al­ler­dings: Sie laufen mit erhöhten Rechten auf dem Host. Deshalb sollten nur Er­wei­te­run­gen aus ver­trau­ens­wür­di­gen Quellen in­stal­liert werden.

Docker Compose für An­wen­dun­gen mit mehreren Con­tai­nern

Docker Compose dient dazu, An­wen­dun­gen mit mehreren Con­tai­nern zu de­fi­nie­ren und aus­zu­füh­ren. Services, Netzwerke und Volumes werden in einer YAML-Datei be­schrie­ben und an­schlie­ßend gemeinsam gestartet. Das ver­ein­facht lokale Setups, in denen etwa Web­an­wen­dung, Datenbank, Cache und weitere Dienste zu­sam­men­ar­bei­ten.

Compose eignet sich besonders für:

• lokale Ent­wick­lungs­um­ge­bun­gen
• Test- und In­te­gra­ti­ons­sze­na­ri­en
• re­pro­du­zier­ba­re Projekt-Setups
• An­wen­dun­gen mit klar de­fi­nier­ten Ab­hän­gig­kei­ten zwischen mehreren Services

Compose ist direkt in die Docker-CLI in­te­griert und wird über docker compose auf­ge­ru­fen. Für Ent­wick­lungs-, Test- und In­te­gra­ti­ons­um­ge­bun­gen ist das Werkzeug besonders praktisch, weil sich komplette An­wen­dungs­stacks mit einer einzigen Kon­fi­gu­ra­ti­on re­pro­du­zier­bar starten lassen.

Container-Re­gis­tries für Ver­tei­lung und Zu­sam­men­ar­beit

Container-Re­gis­tries über­neh­men die Spei­che­rung, Ver­sio­nie­rung und Ver­tei­lung von Images. Docker Hub ist dabei weiterhin eine wichtige Standard-Registry im Docker-Umfeld und die Default-Registry für viele öf­fent­li­che Images und Basis-Images. Gleich­zei­tig spielen in Team- und Un­ter­neh­mens­um­ge­bun­gen heute auch andere Registry-Lösungen eine wichtige Rolle.

In der Praxis erfüllen Re­gis­tries mehrere Aufgaben:

• Images zentral speichern
• Versionen verwalten
• Artefakte im Team be­reit­stel­len
• Build-, CI/CD- und De­ploy­ment-Prozesse anbinden

Neben Docker Hub ist vor allem die GitHub Container Registry relevant. Sie speichert Images innerhalb per­sön­li­cher oder or­ga­ni­sa­to­ri­scher Accounts, lässt sich mit Re­po­si­to­ries ver­knüp­fen und un­ter­stützt granulare Be­rech­ti­gun­gen. In Cloud-Um­ge­bun­gen kommen zudem häufig provider-native Re­gis­tries wie die Azure Container Registry oder die Google Artifact Registry zum Einsatz, die eng in be­stehen­de Build- und De­ploy­ment-Workflows ein­ge­bun­den sind.

Re­gis­tries sind damit nicht nur Ab­la­ge­or­te für Images, sondern ein wichtiger Be­stand­teil der Software-Lie­fer­ket­te. In diesem Zu­sam­men­hang gewinnt auch die Si­gnie­rung von Images an Bedeutung. Tools wie Cosign helfen dabei, Artefakte zu signieren und Si­gna­tu­ren zu ve­ri­fi­zie­ren, um Releases nach­voll­zieh­ba­rer und ver­trau­ens­wür­di­ger zu machen.

BuildKit und Buildx für per­for­man­te Builds

BuildKit ist die Build-Engine von Docker und ver­bes­sert Build-Prozesse unter anderem bei Per­for­mance und bei kom­ple­xe­ren Build-Szenarien. Buildx erweitert diese Funk­tio­nen in der CLI und stellt zu­sätz­li­che Build-Fä­hig­kei­ten bereit.

Besonders relevant sind dabei:

• ef­fi­zi­en­te­res Caching
• parallele Build-Schritte
• Multi-Plattform-Builds
• zu­sätz­li­che Build-Metadaten
• bessere In­te­gra­ti­on in au­to­ma­ti­sier­te Pipelines

Ein zentraler An­wen­dungs­fall sind Multi-Plattform-Builds. Mit docker buildx build lassen sich Docker-Images für ver­schie­de­ne Ziel­ar­chi­tek­tu­ren wie amd64 und arm64 erzeugen. Das ist relevant, wenn Ent­wick­lungs­rech­ner, CI-Systeme und Ziel­um­ge­bun­gen auf un­ter­schied­li­chen Platt­for­men laufen.

BuildKit und Buildx un­ter­stüt­zen außerdem zu­sätz­li­che Build-Metadaten wie SBOM und Pro­ven­an­ce-At­te­sta­ti­ons. Dadurch lassen sich Herkunft und Zu­sam­men­set­zung eines Images präziser do­ku­men­tie­ren und in Security- und Com­pli­ance-Prozesse einbinden.

Docker Scout und Cosign für Security und Supply Chain

Docker Scout ana­ly­siert Container-Images, macht deren Zu­sam­men­set­zung sichtbar und ordnet bekannte Schwach­stel­len zu. Der Dienst un­ter­stützt damit Si­cher­heits­prü­fun­gen direkt im Container-Workflow.

Im Mit­tel­punkt stehen dabei vor allem:

• Analyse von Paketen und Ab­hän­gig­kei­ten
• Erkennung bekannter Schwach­stel­len
• Bewertung von Basis-Images
• mehr Trans­pa­renz in der Software-Lie­fer­ket­te

Für Ent­wick­lungs­teams bedeutet das mehr Trans­pa­renz über Ab­hän­gig­kei­ten, Pakete und Si­cher­heits­ri­si­ken im gesamten Image. Scout kann zudem Emp­feh­lun­gen für Basis-Image-Updates ausgeben und damit helfen, Schwach­stel­len und Pfle­ge­auf­wand zu re­du­zie­ren.

Ergänzend dazu eignet sich Cosign für die Si­gnie­rung und Ve­ri­fi­ka­ti­on von Container-Images. Damit lassen sich Artefakte in der Registry als ver­trau­ens­wür­di­ge Releases kenn­zeich­nen und in Supply-Chain-Workflows einbinden.

Docker und Ku­ber­netes im Ent­wick­lungs-Workflow

Docker und Ku­ber­netes decken un­ter­schied­li­che Aufgaben ab. Docker ist auf das Bauen und Ausführen con­tai­ne­ri­sier­ter An­wen­dun­gen aus­ge­rich­tet. Ku­ber­netes au­to­ma­ti­siert De­ploy­ment, Ska­lie­rung und Ver­wal­tung con­tai­ne­ri­sier­ter Workloads im Cluster.

Für lokale und team­über­grei­fen­de Workflows ergeben sich daraus typische Kom­bi­na­tio­nen:

• Docker für Build und lokale Aus­füh­rung
• Compose für Multi-Container-An­wen­dun­gen
• kind für lokale Ku­ber­netes-Cluster
• Skaffold für au­to­ma­ti­sier­te Build-, Push- und Deploy-Prozesse

Docker Desktop bietet eine in­te­grier­te Ku­ber­netes-Umgebung. kind startet lokale Ku­ber­netes-Cluster auf dem eigenen Rechner. Skaffold au­to­ma­ti­siert Build-, Push- und De­ploy­ment-Schritte für con­tai­ner­ba­sier­te Ku­ber­netes-An­wen­dun­gen und un­ter­stützt damit einen durch­ge­hen­den Ent­wick­lungs­zy­klus.

Aus dieser Kom­bi­na­ti­on entsteht ein Workflow, in dem An­wen­dun­gen lokal mit Docker gebaut, mit Compose or­ga­ni­siert, in Re­gis­tries ver­öf­fent­licht und an­schlie­ßend in Ku­ber­netes-Um­ge­bun­gen getestet oder aus­ge­rollt werden.

Als einfache Al­ter­na­ti­ve zur Cluster-Or­ches­trie­rung lässt sich auch Docker Swarm einsetzen. Das Werkzeug ist Teil von Docker Engine und kann für kleinere, über­schau­ba­re Docker-Setups sinnvoll sein. Für neue Cloud-Native-Projekte stehen heute jedoch meist Ku­ber­netes und dessen Ökosystem stärker im Vor­der­grund.