Multi-Stage-Builds für mehr Effizienz

Willkommen bei der erweiterten Optimierung von Dockerfiles! Heute sehen wir uns Multi-Stage-Builds an – eine leistungsfähige Technik, um kleinere und effizientere Docker-Images zu erstellen.

Kleinere Images lassen sich schneller herunterladen, verbessern die Sicherheit und nutzen Ressourcen effizienter.

Beim Erstellen eines Docker-Images werden häufig Tools und Abhängigkeiten eingebunden, die nur während des Build-Prozesses, nicht aber zur Laufzeit der fertigen Anwendung benötigt werden.

• Schnellere Pulls: Kleinere Images werden schneller heruntergeladen.
• Weniger Speicherplatz: Spart Speicherplatz in Registries und auf Hosts.
• Verkleinerte Angriffsfläche: Weniger Komponenten bedeuten weniger potenzielle Schwachstellen.
• Verbesserte Sicherheit: Ihr Produktions-Image enthält nur die unbedingt erforderlichen Bestandteile.

Betrachten Sie eine kompilierte Anwendung, beispielsweise eine in Go geschriebene. Eine herkömmliche einstufige Dockerfile würde den gesamten Go-Compiler und die Entwicklungsabhängigkeiten in das finale Image aufnehmen.

Dadurch wird das finale Image deutlich größer als nötig, da der Compiler zum Ausführen der kompilierten Binärdatei nicht benötigt wird.

Hier sehen Sie eine einfache Go-Anwendung und eine Dockerfile, die sie in einer einzigen Phase erstellt. Beachten Sie, dass die Build-Umgebung im finalen Image enthalten ist.

main.go:

Diese Dockerfile verwendet `golang:1.21-alpine` als Basis. Nach dem Erstellen der Anwendung bleibt dieses große Basis-Image zusammen mit allen Build-Tools im finalen Image erhalten.

Multi-Stage-Builds lösen dieses Problem, indem Sie mehrere `FROM`-Anweisungen in einer einzigen Dockerfile definieren können. Jede `FROM`-Anweisung beginnt eine neue Build-Phase.

• Verwenden Sie das Schlüsselwort AS, um eine Phase zu benennen (z. B. FROM golang:1.21-alpine AS builder).
• Anschließend können Sie Artefakte aus einer vorherigen Phase mithilfe von COPY --from=<stage_name> kopieren.

Nur die finale Phase wird als Image gespeichert.

Eine typische Multi-Stage-Dockerfile umfasst mindestens zwei Phasen:

• Build-Phase: Enthält alle Tools und den Quellcode, die zum Kompilieren Ihrer Anwendung benötigt werden.
• Runtime-Phase: Ein minimales Basis-Image, das nur die kompilierte Anwendung und ihre Laufzeitabhängigkeiten enthält.

Das Zwischen-Image der Build-Phase wird verworfen, sodass ein schlankes finales Image übrig bleibt.

Schreiben wir die Dockerfile unserer Go-Anwendung mit einem Multi-Stage-Ansatz neu. Wir erstellen die Anwendung in der ersten Phase und kopieren anschließend nur die kompilierte Binärdatei in ein deutlich kleineres `alpine`-Basis-Image.

Beim Erstellen dieser Dockerfile führt Docker jede Phase aus. Das finale Image wird jedoch nur aus dem Inhalt der letzten `FROM`-Anweisung und den aus vorherigen Phasen kopierten Dateien gebildet.

Dadurch entsteht im Vergleich zum einstufigen Build ein deutlich kleineres Image, da der Go-Compiler und die Build-Tools zurückbleiben.

Multi-Stage-Builds sind besonders nützlich für:

• Kompilierte Sprachen: Go, Java, C++, Rust.
• Frontend-Frameworks: React-/Angular-Anwendungen erstellen und statische Inhalte mit Nginx bereitstellen.
• Node.js-Anwendungen: `node_modules` in einer Build-Phase installieren und anschließend nur `package.json`, `package-lock.json` und die erstellte Anwendung in ein schlankes Runtime-Image kopieren.

Welche der folgenden Punkte sind wesentliche Vorteile von Multi-Stage-Docker-Builds?

Sie haben Multi-Stage-Docker-Builds kennengelernt!

• Sie verwenden mehrere FROM-Anweisungen in einer einzigen Dockerfile.
• Das Schlüsselwort AS benennt Phasen, und COPY --from= überträgt Artefakte.
• Der wichtigste Vorteil sind deutlich kleinere, sicherere und effizientere finale Images.

Diese Technik ist entscheidend für die Optimierung Ihrer containerisierten Anwendungen. Als Nächstes sehen wir uns die Nutzung des Build-Cachings an!