Effiziente Docker-Images erstellen: Best Practices für Leistung

Effiziente Docker-Images beschleunigen Ihre Builds, machen Bereitstellungen leichter und erleichtern die Sicherung von Produktionscontainern. Aufgeblähte Images verlangsamen CI, verschwenden Registry-Speicher und enthalten oft Tools, die Ihre Anwendung zur Laufzeit nicht benötigt.

Das Ziel ist nicht, um jeden Preis das kleinstmögliche Image zu erstellen. Das Ziel ist es, ein vorhersagbares Image zu bauen, das Ihre Anwendung, ihre Laufzeitabhängigkeiten und wenig anderes enthält.

Warum Image-Effizienz wichtig ist

Optimierte Docker-Images bieten eine Reihe von Vorteilen im gesamten Softwareentwicklungslebenszyklus:

Schnellere Builds: Kleinere Kontexte und weniger Operationen führen zu einer schnelleren Image-Erstellung und beschleunigen Ihre CI/CD-Pipelines.
Reduzierte Speicherkosten: Weniger Festplattenspeicher auf Registries und Host-Maschinen senkt die Infrastrukturkosten.
Schnellere Bereitstellungen: Kleinere Images werden schneller über Netzwerke übertragen, was zu einer schnellen Bereitstellung und Skalierung in Produktionsumgebungen führt.
Verbesserte Leistung: Weniger zu ladende Daten bedeuten, dass Container effizienter starten und laufen.
Erhöhte Sicherheit: Ein kleineres Image mit weniger Abhängigkeiten und Tools bietet eine reduzierte Angriffsfläche, da es weniger potenzielle Schwachstellen auszubeuten gibt.
Bessere Entwicklererfahrung: Schnellere Feedback-Schleifen und weniger Wartezeit tragen zu einer produktiveren Entwicklungsumgebung bei.

Dockerfile Best Practices für Leistung

Ihr Dockerfile ist die Blaupause für Ihr Image. Die Optimierung ist der erste und wirkungsvollste Schritt zur Effizienz.

1. Wählen Sie ein minimales Basis-Image

Die FROM-Anweisung legt die Grundlage Ihres Images. Mit einem kleineren Basis-Image zu beginnen, reduziert die endgültige Image-Größe drastisch.

Alpine Linux: Sehr klein und nützlich für Anwendungen, die gut mit musl libc funktionieren. Testen Sie sorgfältig, ob Ihre App oder native Abhängigkeiten glibc-Verhalten erwarten.
Distroless Images: Bereitgestellt von Google, enthalten diese Images nur Ihre Anwendung und ihre Laufzeitabhängigkeiten und entfernen Shell, Paketmanager und andere Betriebssystem-Dienstprogramme. Sie bieten hervorragende Sicherheit und minimale Größe.
Spezifische Distributionsversionen: Vermeiden Sie generische Tags wie ubuntu:latest oder node:latest. Verwenden Sie stattdessen spezifische Versionen wie ubuntu:22.04 oder node:18-alpine, um Reproduzierbarkeit und Stabilität zu gewährleisten.

# Schlecht: Großes Basis-Image, potenziell inkonsistent
FROM ubuntu:latest

# Gut: Kleineres, konsistenteres Basis-Image
FROM node:18-alpine

# Noch besser für kompilierte Apps (falls zutreffend)
FROM gcr.io/distroless/static

2. Nutzen Sie `.dockerignore`

Genau wie .gitignore verhindert eine .dockerignore-Datei, dass unnötige Dateien in Ihren Build-Kontext kopiert werden. Dies beschleunigt den docker build-Prozess erheblich, indem die Datenmenge reduziert wird, die der Docker-Daemon verarbeiten muss.

Erstellen Sie eine Datei namens .dockerignore im Stammverzeichnis Ihres Projekts:

# Git-bezogene Dateien ignorieren
.git
.gitignore

# Node.js-Abhängigkeiten ignorieren (werden im Container installiert)
node_modules
npm-debug.log

# Lokale Entwicklungsdateien ignorieren
.env
*.log
*.DS_Store

# Build-Artefakte ignorieren, die im Container erstellt werden
build
dist

3. Minimieren Sie Layer durch Kombinieren von `RUN`-Anweisungen

Jede RUN-Anweisung in einem Dockerfile erstellt einen neuen Layer. Während Layer für das Caching unerlässlich sind, können zu viele das Image aufblähen. Kombinieren Sie verwandte Befehle in einer einzigen RUN-Anweisung und verketten Sie sie mit &&.

# Schlecht: Erstellt mehrere Layer
RUN apt-get update
RUN apt-get install -y --no-install-recommends git curl
RUN rm -rf /var/lib/apt/lists/*

# Gut: Erstellt einen einzigen Layer und räumt in einem Durchgang auf
RUN apt-get update && \
    apt-get install -y --no-install-recommends git curl && \
    rm -rf /var/lib/apt/lists/*

Tipp: Fügen Sie Bereinigungsbefehle wie rm -rf /var/lib/apt/lists/* für Debian und Ubuntu immer in derselben RUN-Anweisung hinzu, die Pakete installiert. Für Alpine bevorzugen Sie apk add --no-cache anstatt /var/cache/apk manuell zu bereinigen.

4. Ordnen Sie Dockerfile-Anweisungen optimal an

Docker cached Layer basierend auf der Reihenfolge der Anweisungen. Platzieren Sie die stabilsten und am wenigsten häufig wechselnden Anweisungen zuerst in Ihrem Dockerfile. Dadurch wird sichergestellt, dass Docker zwischengespeicherte Layer aus früheren Builds wiederverwenden kann, was nachfolgende Builds erheblich beschleunigt.

Allgemeine Reihenfolge:

FROM (Basis-Image)
ARG (Build-Argumente)
ENV (Umgebungsvariablen)
WORKDIR (Arbeitsverzeichnis)
COPY für Abhängigkeiten (z. B. package.json, pom.xml, requirements.txt)
RUN zum Installieren von Abhängigkeiten (z. B. npm install, pip install)
COPY für Anwendungsquellcode
EXPOSE (Ports)
ENTRYPOINT / CMD (Anwendungsausführung)

FROM node:18-alpine
WORKDIR /app

# Diese Dateien ändern sich seltener als der Quellcode, also setzen Sie sie zuerst
COPY package.json package-lock.json ./ 
RUN npm ci --omit=dev

# Anwendungsquellcode ändert sich häufiger
COPY . . 

CMD ["node", "server.js"]

5. Verwenden Sie spezifische Paketversionen

Das Festlegen von Versionen für Pakete, die über RUN-Befehle installiert werden (z. B. apt-get install mypackage=1.2.3), gewährleistet Reproduzierbarkeit und verhindert unerwartete Probleme oder Größensteigerungen aufgrund neuer Paketversionen.

6. Vermeiden Sie die Installation unnötiger Tools

Installieren Sie nur das, was für den Betrieb Ihrer Anwendung unbedingt erforderlich ist. Entwicklungstools, Debugger oder Texteditoren haben in einem Produktions-Image nichts zu suchen.

Multi-Stage-Builds nutzen

Multi-Stage-Builds sind ein Eckpfeiler der effizienten Docker-Image-Erstellung. Sie ermöglichen die Verwendung mehrerer FROM-Anweisungen in einem einzigen Dockerfile, wobei jede FROM eine neue Build-Stufe beginnt. Sie können dann selektiv Artefakte von einer Stufe in eine endgültige, schlanke Stufe kopieren und dabei alle Build-Zeit-Abhängigkeiten, Zwischendateien und Tools zurücklassen.

Dies reduziert die endgültige Image-Größe drastisch und verbessert die Sicherheit, indem nur das aufgenommen wird, was zur Laufzeit benötigt wird.

Wie Multi-Stage-Builds funktionieren

Builder-Stufe: Diese Stufe enthält alle Tools und Abhängigkeiten, die zum Kompilieren Ihrer Anwendung benötigt werden (z. B. Compiler, SDKs, Entwicklungsbibliotheken). Sie produziert die ausführbaren oder bereitstellbaren Artefakte.
Runner-Stufe: Diese Stufe beginnt mit einem minimalen Basis-Image und kopiert nur die notwendigen Artefakte aus der Builder-Stufe. Sie verwirft alles andere aus der Builder-Stufe, was zu einem erheblich kleineren endgültigen Image führt.

Multi-Stage-Build Beispiel (Go-Anwendung)

Betrachten Sie eine Go-Anwendung. Zum Erstellen wird ein Go-Compiler benötigt, aber die endgültige ausführbare Datei benötigt nur eine Laufzeitumgebung.

# Stufe 1: Builder
FROM golang:1.20-alpine AS builder

WORKDIR /app
COPY go.mod go.sum ./ 
RUN go mod download

COPY . . 
RUN CGO_ENABLED=0 GOOS=linux go build -a -ldflags '-s -w' -o myapp .

# Stufe 2: Runner
FROM alpine:3.20
WORKDIR /root/

# Nur die kompilierte ausführbare Datei aus der Builder-Stufe kopieren
COPY --from=builder /app/myapp .

EXPOSE 8080
CMD ["./myapp"]

In diesem Beispiel:

Die builder-Stufe verwendet golang:1.20-alpine, um die Go-Anwendung zu kompilieren.
Die runner-Stufe beginnt mit einem kleinen Alpine-Image und kopiert nur die ausführbare Datei myapp aus der builder-Stufe, wobei das Go-SDK und die Build-Abhängigkeiten verworfen werden.

Fortgeschrittene Optimierungstechniken

1. Erwägen Sie die Verwendung von `COPY --chown`

Verwenden Sie beim Kopieren von Dateien --chown, um den Besitzer und die Gruppe auf einen Nicht-Root-Benutzer zu setzen. Dies ist eine bewährte Sicherheitspraxis und kann Berechtigungsprobleme verhindern.

RUN addgroup --system appgroup && adduser --system --ingroup appgroup appuser
USER appuser

# Dateien direkt als Nicht-Root-Benutzer kopieren
COPY --chown=appuser:appgroup ./app /app

2. Fügen Sie keine sensiblen Informationen hinzu

Hinterlegen Sie niemals Geheimnisse (API-Schlüssel, Passwörter) direkt in Ihrem Dockerfile oder Image. Verwenden Sie Umgebungsvariablen, Docker Secrets oder externe Geheimnisverwaltungssysteme. Build-Argumente (ARG) sind in der Image-Historie sichtbar, daher ist ihre Verwendung für Geheimnisse ebenfalls riskant.

3. Nutzen Sie BuildKit-Funktionen (falls verfügbar)

Wenn Ihr Docker-Build BuildKit verwendet, können Sie Funktionen wie RUN --mount=type=cache für Abhängigkeits-Caches oder RUN --mount=type=secret für Build-Zeit-Geheimnisse nutzen, die nicht in das Image eingebrannt werden sollen.

# Beispiel mit BuildKit-Cache für npm
FROM node:18-alpine

WORKDIR /app
COPY package.json package-lock.json ./

RUN --mount=type=cache,target=/root/.npm \
    npm ci --omit=dev

COPY . . 
CMD ["node", "server.js"]

Fazit

Die Erstellung effizienter Docker-Images beginnt mit einer einfachen Gewohnheit: Lassen Sie jede Datei und jedes Paket seinen Platz im endgültigen Image rechtfertigen. Verwenden Sie ein schlankes Basis-Image, halten Sie den Build-Kontext klein, ordnen Sie Anweisungen für das Caching und verschieben Sie Compiler oder SDKs in eine Builder-Stufe.

Wichtige Erkenntnisse:

Klein anfangen: Wählen Sie das kleinstmögliche Basis-Image (Alpine, Distroless).
Clever mit Layern umgehen: Kombinieren Sie RUN-Befehle und räumen Sie effektiv auf.
Clever cachen: Ordnen Sie Anweisungen so an, dass Cache-Treffer maximiert werden.
Build-Artefakte isolieren: Verwenden Sie Multi-Stage-Builds, um Build-Zeit-Abhängigkeiten zu verwerfen.
Schlank halten: Fügen Sie nur das absolut Notwendige für die Laufzeit hinzu.

Überwachen Sie kontinuierlich Ihre Image-Größen und Build-Zeiten. Tools wie docker history können Ihnen helfen zu verstehen, wie jede Anweisung zur endgültigen Image-Größe beiträgt. Überprüfen und refaktorisieren Sie Ihre Dockerfiles regelmäßig, während sich Ihre Anwendung weiterentwickelt, um optimale Effizienz und Leistung zu erhalten.