0Pricing
DevOps Bootcamp · Lektion

Multi-Stage-Builds für mehr Effizienz

Verwenden Sie Multi-Stage-Builds, um kleinere und sicherere Produktions-Images zu erstellen, indem Sie Build- und Laufzeitabhängigkeiten trennen.

Multi-Stage-Builds für mehr Effizienz ist eine kostenlose DevOps Bootcamp-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des DevOps Bootcamp-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der DevOps Bootcamp-Kurs umfasst insgesamt 4 Lektionen.

Einführung in Multi-Stage-Builds

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.

Multi-Stage-Builds für mehr Effizienz — Illustration 1

Warum kleinere Images wichtig sind

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.

Das Problem einstufiger Builds

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.

Beispiel für einen einstufigen Build (Go)

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:

package main

import "fmt"

func main() {
    fmt.Println("Hello from Single-Stage Docker!")
}

Einstufige Dockerfile

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.

FROM golang:1.21-alpine
WORKDIR /app
COPY main.go .
RUN go build -o myapp main.go
EXPOSE 8080
CMD ["./myapp"]

Aufbau von Multi-Stage-Builds

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.

Struktur eines Multi-Stage-Builds

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.

Multi-Stage-Beispiel (Go)

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.

# Stage 1: Build the application
FROM golang:1.21-alpine AS builder
WORKDIR /app
COPY main.go .
RUN go build -o myapp main.go

# Stage 2: Create the final lightweight image
FROM alpine:latest
WORKDIR /app
COPY --from=builder /app/myapp .
EXPOSE 8080
CMD ["./myapp"]

Multi-Stage-Build ausführen

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.

Vorteile von Multi-Stage-Builds

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.

Wissen überprüfen

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

Zusammenfassung: Effizienz durch Multi-Stage-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!

Häufig gestellte Fragen

Ist die Lektion „Multi-Stage-Builds für mehr Effizienz“ kostenlos?

Ja — der vollständige Text von „Multi-Stage-Builds für mehr Effizienz“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des DevOps Bootcamp-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der DevOps Bootcamp-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Multi-Stage-Builds für mehr Effizienz“?

Verwenden Sie Multi-Stage-Builds, um kleinere und sicherere Produktions-Images zu erstellen, indem Sie Build- und Laufzeitabhängigkeiten trennen. Du übst DevOps Bootcamp mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um DevOps Bootcamp zu starten?

Keine Vorkenntnisse erforderlich. DevOps Bootcamp auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Multi-Stage-Builds für mehr Effizienz“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser DevOps Bootcamp-Lektion Code schreiben und ausführen?

Ja. Jede DevOps Bootcamp-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Multi-Stage-Builds für mehr Effizienz
  2. Build-Caching nutzen
  3. Best Practices für die Dockerfile-Sicherheit
  4. Image-Größe mit Slim- und Distroless-Basen minimieren
← Zurück zu DevOps Bootcamp