Multi-Stage Builds sind eine effektive Methode, um Docker-Images klein, sicher und wartbar zu halten. Bei komplexen Anwendungen wie Node.js, Go oder Python enthalten herkömmliche Images oft unnötige Build-Tools, die die Image-Größe erhöhen. Mit Multi-Stage Builds lassen sich Build- und Runtime-Umgebungen trennen, sodass nur die notwendigen Artefakte ins finale Image gelangen.
Grundprinzip von Multi-Stage Builds
Bei Multi-Stage Builds werden mehrere FROM-Anweisungen in einem Dockerfile genutzt. Jede Stage erzeugt ein temporäres Image. Nur die benötigten Artefakte werden in das finale Image kopiert, wodurch unnötige Dateien und Tools entfernt werden.
Vorteile
- Kleinere Images durch Entfernen von Build-Tools
- Verbesserte Sicherheit, da weniger Pakete im Runtime-Image enthalten sind
- Einfachere Wartung durch klare Trennung von Build- und Runtime-Umgebung
- Flexibilität für unterschiedliche Programmiersprachen und Frameworks
Multi-Stage Builds für Node.js
Node.js-Projekte profitieren stark von Multi-Stage Builds, da Build-Dependencies wie npm oder yarn im finalen Image oft nicht benötigt werden.
Beispiel Dockerfile
FROM node:18-alpine AS build
WORKDIR /app
COPY package*.json ./
RUN npm install --production
COPY . .
RUN npm run build
FROM node:18-alpine
WORKDIR /app
COPY --from=build /app/dist ./dist
COPY --from=build /app/package*.json ./
CMD ["node", "dist/server.js"]
In diesem Beispiel werden alle Build-Dependencies in der build-Stage installiert. Nur die kompilierten Artefakte und benötigten Runtime-Dateien gelangen in das finale Image.
Multi-Stage Builds für Go
Go-Anwendungen lassen sich als statische Binaries kompilieren. Multi-Stage Builds erlauben es, die komplette Go-Toolchain aus dem finalen Image zu entfernen.
Beispiel Dockerfile
FROM golang:1.20-alpine AS build
WORKDIR /app
COPY . .
RUN go mod download
RUN go build -o myapp
FROM alpine:latest
WORKDIR /app
COPY --from=build /app/myapp .
CMD ["./myapp"]
Das finale Image enthält nur das kompakte Go-Binary auf einer minimalen Alpine-Basis, ohne Compiler oder Source-Code.
Multi-Stage Builds für Python
Python-Anwendungen können von Multi-Stage Builds profitieren, um Build-Dependencies wie pip und Header-Dateien im finalen Runtime-Image zu vermeiden.
Beispiel Dockerfile
FROM python:3.11-alpine AS build
WORKDIR /app
COPY requirements.txt .
RUN pip install --prefix=/install -r requirements.txt
COPY . .
FROM python:3.11-alpine
WORKDIR /app
COPY --from=build /install /usr/local
COPY --from=build /app .
CMD ["python", "app.py"]
Alle Build-Abhängigkeiten werden in einer temporären Stage installiert. Das finale Image enthält nur die notwendigen Runtime-Bibliotheken und den Anwendungscode.
Best Practices für Multi-Stage Builds
- Separate Build- und Runtime-Images nutzen, um Image-Größe zu reduzieren
- Nur notwendige Artefakte in die finale Stage kopieren
- Alpine- oder Slim-Images als Basis verwenden
- Build-Tools und temporäre Dateien sofort entfernen
- Layer sinnvoll zusammenfassen, um Caching zu optimieren
- Umgebungsvariablen für Build- und Runtime-Stages sauber trennen
- Security Updates regelmäßig einspielen, insbesondere im Runtime-Image
Praxisbeispiele für Multi-Container-Projekte
Node.js Web-App
FROM node:18-alpine AS build
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build
FROM node:18-alpine
WORKDIR /app
COPY --from=build /app/dist ./dist
COPY --from=build /app/package*.json ./
CMD ["node", "dist/server.js"]
Go API
FROM golang:1.20-alpine AS build
WORKDIR /app
COPY . .
RUN go mod download
RUN go build -o api_server
FROM alpine:latest
WORKDIR /app
COPY --from=build /app/api_server .
CMD ["./api_server"]
Python Backend
FROM python:3.11-alpine AS build
WORKDIR /app
COPY requirements.txt .
RUN pip install --prefix=/install -r requirements.txt
COPY . .
FROM python:3.11-alpine
WORKDIR /app
COPY --from=build /install /usr/local
COPY --from=build /app .
CMD ["python", "app.py"]
Zusammenfassung
Multi-Stage Builds ermöglichen die Erstellung kleiner, sicherer und wartbarer Docker-Images für Node.js, Go und Python. Durch die Trennung von Build- und Runtime-Stages, Nutzung minimaler Basis-Images und gezieltes Kopieren von Artefakten lassen sich Images optimieren, Builds beschleunigen und die Sicherheit erhöhen. Diese Best Practices sind essenziell für produktive Container-Umgebungen und moderne CI/CD-Workflows.
Konfiguriere Cisco Router & Switches und liefere ein Packet-Tracer-Lab/GNS3
Ich biete professionelle Unterstützung im Bereich Netzwerkkonfiguration und Network Automation für private Anforderungen, Studienprojekte, Lernlabore, kleine Unternehmen sowie technische Projekte. Ich unterstütze Sie bei der Konfiguration von Routern und Switches, der Erstellung praxisnaher Topologien in Cisco Packet Tracer, dem Aufbau und Troubleshooting von GNS3- und EVE-NG-Labs sowie bei der Automatisierung von Netzwerkaufgaben mit Netmiko, Paramiko, NAPALM und Ansible. Kontaktieren Sie mich jetzt – klicken Sie hier.
Meine Leistungen umfassen:
-
Professionelle Konfiguration von Routern und Switches
-
Einrichtung von VLANs, Trunks, Routing, DHCP, NAT, ACLs und weiteren Netzwerkfunktionen
-
Erstellung von Topologien und Simulationen in Cisco Packet Tracer
-
Aufbau, Analyse und Fehlerbehebung von Netzwerk-Labs in GNS3 und EVE-NG
-
Automatisierung von Netzwerkkonfigurationen mit Python, Netmiko, Paramiko, NAPALM und Ansible
-
Erstellung von Skripten für wiederkehrende Netzwerkaufgaben
-
Dokumentation der Konfigurationen und Bereitstellung nachvollziehbarer Lösungswege
-
Konfigurations-Backups, Optimierung bestehender Setups und technisches Troubleshooting
Benötigen Sie Unterstützung bei Ihrem Netzwerkprojekt, Ihrer Simulation oder Ihrer Network-Automation-Lösung? Kontaktieren Sie mich jetzt – klicken Sie hier.