Einstieg
Grundlegende Befehle
docker run erzeugt und startet einen Container. -d läuft im Hintergrund, -p mappt einen Host-Port auf einen Container-Port. pull lädt Images aus einer Registry (standardmäßig Docker Hub).
# check version
docker --version
# pull an image
docker pull nginx:latest
# run a container
docker run -d --name mynginx -p 8080:80 nginx
# list running containers
docker ps
# list all containers (including stopped)
docker ps -a
# stop and remove a container
docker stop mynginx
docker rm mynginx
# list images
docker imagesContainer-Lebenszyklus
create + start ist das, was run intern macht. stop sendet SIGTERM für ein sauberes Herunterfahren; kill sendet sofort SIGKILL. pause nutzt den cgroup freezer — praktisch für Snapshots, ohne den Prozess anzuhalten.
# create a container without starting it
docker create --name web nginx
# start a created (or stopped) container
docker start web
# stop gracefully (SIGTERM then SIGKILL after 10s)
docker stop web
# force kill immediately
docker kill web
# restart a container
docker restart web
# pause/resume (freezes process with cgroups)
docker pause web
docker unpause webImage-Grundlagen
Images sind schreibgeschützte Layer. rmi schlägt fehl, wenn ein Container das Image noch referenziert — entferne zuerst den Container. history zeigt jede Anweisung, die einen Layer erzeugt hat, samt Größe — nützlich zum Optimieren von Builds.
# list local images
docker images
docker image ls
# remove an image
docker rmi nginx:latest
docker image rm nginx
# remove all dangling (untagged) images
docker image prune
# remove all unused images
docker image prune -a
# show image history (each layer)
docker history nginx:latestSysteminformationen
docker info zeigt die Daemon-Konfiguration: Storage-Treiber, Runtime, Registries, Swarm-Status. system df offenbart freigebbaren Speicher — hängende Images und gestoppte Container verschwenden Platz. Der --format-Flag nutzt Go-Templates für strukturierte Ausgabe.
# docker system-wide info
docker info
docker version
# disk usage breakdown (images, containers, volumes)
docker system df
# detailed disk usage with reclaimable space
docker system df -v
# running containers count
docker ps -q | wc -l
# show docker root directory and storage driver
docker info --format '{{.DockerRootDir}} {{.Driver}}'Aufräumen & Prune
prune entfernt gestoppte/hängende Ressourcen auf sichere Weise. system prune -a entfernt zusätzlich Images, die von keinem Container referenziert werden. Mit --volumes werden auch Volumes gelöscht, die von keinem Container genutzt werden — unwiderruflicher Datenverlust, in Produktion mit Vorsicht einsetzen.
# remove stopped containers
docker container prune
# remove dangling images
docker image prune
# remove unused volumes (CAUTION: data loss)
docker volume prune
# remove unused networks
docker network prune
# remove everything unused at once
docker system prune
# also remove volumes (very aggressive)
docker system prune -a --volumesHilfe bekommen
Docker gruppiert Befehle in Management-Namespaces (docker image, docker container, docker network, docker volume). Sowohl die alte (docker rmi) als auch die neue Form (docker image rm) funktioniert. --help auf jedem Subcommand zeigt Flags und Nutzung.
# list all commands
docker --help
docker help
# help for a specific command
docker run --help
docker image --help
# list management commands (grouped)
docker image --help
docker container --help
docker network --help
# show daemon config
docker info
# command reference online
# https://docs.docker.com/reference/Image-Verwaltung
Images laden
Tags sind veränderliche Labels — dasselbe Tag kann im Laufe der Zeit auf unterschiedliche Images zeigen. Für reproduzierbare Deployments pinnt man über den Digest (@sha256:...). Das Laden mit --platform erlaubt es, ein Image für eine andere Architektur zu holen — nützlich für ARM-Builds auf x86-Hosts.
# pull latest tag
docker pull nginx
# pull specific tag
docker pull nginx:1.25-alpine
# pull all tags of a repository
docker pull -a alpine
# pull from a different registry
docker pull ghcr.io/user/repo:tag
# pull by digest (immutable, reproducible)
docker pull nginx@sha256:abc123...
# pull multiple platforms (multi-arch)
docker pull --platform linux/arm64 nginxImages bauen
Der abschließende . ist der Build-Kontext — die an den Daemon gesendeten Dateien. Halte ihn mit .dockerignore klein, um Builds zu beschleunigen. --no-cache erzwingt frische Layer beim Debuggen. BuildKit ermöglicht Multi-Stage-Caching, SSH-Mounts und das Einbinden von Secrets.
# build from Dockerfile in current dir, tag it
docker build -t myapp:1.0 .
# build with a different Dockerfile name
docker build -f Dockerfile.prod -t myapp:prod .
# build with build args
docker build --build-arg VERSION=1.2.3 -t myapp .
# build with no cache
docker build --no-cache -t myapp .
# build for a different platform
docker build --platform linux/arm64 -t myapp:arm .
# build using BuildKit (advanced features)
DOCKER_BUILDKIT=1 docker build -t myapp .Images taggen
Tags sind Aliase, die auf dieselbe Image-ID zeigen. Ein verbreiteter Workflow baut mit einem Versions-Tag und fügt dann latest- und Major-Version-Tags hinzu. Das Taggen mit einer Registry-URL bereitet das Image für einen Push in diese Registry vor.
# tag a local image
docker tag myapp:1.0 myapp:latest
# tag for pushing to Docker Hub
docker tag myapp:1.0 username/myapp:1.0
# tag for a private registry
docker tag myapp:1.0 registry.local:5000/myapp:1.0
# tag with multiple tags at once
docker tag myapp:1.0 myapp:stable
docker tag myapp:1.0 myapp:1
# tag by digest reference
docker tag myapp@sha256:abc... myapp:pinnedImages pushen
Vor dem Push muss das Image mit dem Registry-Ziel getaggt sein. push lädt nur Layer hoch, die noch nicht in der Registry vorhanden sind. Bei privaten Registries mit selbstsignierten Zertifikaten konfiguriert man den Daemon in /etc/docker/daemon.json mit insecure-registries.
# login to Docker Hub
docker login
# login to a private registry
docker login registry.local:5000 -u user -p pass
# push to Docker Hub
docker push username/myapp:1.0
# push all tags in a repository
docker push -a username/myapp
# push to private registry
docker push registry.local:5000/myapp:1.0
# logout when done
docker logoutImages inspizieren
inspect liefert detailliertes JSON: Architektur, OS, Layer, Umgebungsvariablen, Entrypoint, Konfiguration. history offenbart den Befehl und die Größe jedes Layers — die Grundlage der Image-Optimierung. manifest inspect prüft eine Remote-Registry, ohne etwas zu laden.
# low-level image metadata (JSON)
docker inspect nginx:latest
# specific field via Go template
docker inspect --format '{{.Arch}} {{.Os}}' nginx
# show image layers and sizes
docker history nginx:latest
# no-trunc to see full command for each layer
docker history --no-trunc nginx:latest
# inspect an image in a registry (manifest)
docker manifest inspect nginx:latestImages sichern & laden
save/load bewahrt Image-Layer und Historie — die richtige Wahl für den Offline-Transfer von Images. export/import reduziert auf einen einzigen Layer und verliert die Historie. Für den Online-Transfer sind Registry-Push/Pull tar-Archiven vorzuziehen.
# save an image to a tar file
docker save -o myapp.tar myapp:1.0
# save multiple images
docker save -o bundle.tar myapp:1.0 nginx:latest
# load an image from a tar file
docker load -i myapp.tar
# pipe between hosts (no intermediate file)
docker save myapp:1.0 | gzip | ssh host 'gunzip | docker load'
# export a container filesystem (not an image)
docker export mycontainer | gzip > fs.tar.gzContainer-Verwaltung
Container starten
-it kombiniert -i (stdin offen halten) und -t (tty zuweisen) für interaktive Sitzungen. --rm räumt nach dem Beenden auf — ideal für Einmalbefehle. --restart unless-stopped überlebt Neustarts, respektiert aber manuelle Stops.
# run in background with a name and port mapping
docker run -d --name web -p 8080:80 nginx
# run interactively with a terminal
docker run -it --name shell alpine sh
# run and auto-remove on exit
docker run --rm alpine echo hello
# run with a volume
docker run -d -v mydata:/data alpine
# run with environment variables
docker run -d -e MYSQL_ROOT_PASSWORD=secret mysql
# run with a restart policy
docker run -d --restart unless-stopped nginxBefehle ausführen (exec)
exec startet einen neuen Prozess in einem bereits laufenden Container — der ursprüngliche Entrypoint läuft weiter. Nützlich zum Debuggen, für Admin-Aufgaben oder Einmalskripte. Der Standardbenutzer ist der USER des Images; mit -u überschreibbar.
# open an interactive shell in a running container
docker exec -it web sh
# run a command and return
docker exec web ls /usr/share/nginx/html
# run as a specific user
docker exec -u root web whoami
# set environment variables for the command
docker exec -e DEBUG=1 web env
# run with a working directory
docker exec -w /tmp web pwd
# run as detached (rarely useful)
docker exec -d web touch /tmp/markerLogs ansehen
logs zeigt stdout/stderr, wie sie vom Logging-Treiber des Containers erfasst wurden. Anwendungen sollten nach stdout statt in Dateien loggen, um mit docker logs zu funktionieren. --since/--until akzeptieren RFC3339-Zeitstempel oder Go-Durations (30m, 2h).
# follow (tail) logs
docker logs -f web
# show last 100 lines
docker logs --tail 100 web
# show logs since a timestamp
docker logs --since 2024-01-01T00:00:00 web
# show logs from the last 30 minutes
docker logs --since 30m web
# add timestamps to each line
docker logs -t web
# show logs for a specific timeframe
docker logs --since 10m --until 5m webContainer inspizieren
inspect liefert umfangreiches JSON mit Konfiguration, Zustand, Netzwerk und Mounts. Go-Templates extrahieren einzelne Felder — extrem nützlich für Skripte. LogPath verrät, wo der json-file-Treiber die Logs auf dem Host ablegt.
# full JSON metadata
docker inspect web
# container IP address
docker inspect --format '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' web
# container log path (json-file driver)
docker inspect --format '{{.LogPath}}' web
# mounts and volumes
docker inspect --format '{{json .Mounts}}' web
# container state (running, exited, etc.)
docker inspect --format '{{.State.Status}} {{.State.ExitCode}}' web
# all container ports
docker inspect --format '{{json .NetworkSettings.Ports}}' webStarten, Stoppen & Neustarten
start setzt einen gestoppten Container mit seiner ursprünglichen Konfiguration fort. update ändert Limits und die Restart-Policy eines laufenden Containers, ohne ihn neu zu erzeugen — praktisch, um Ressourcen-Limits in der Produktion nachzuziehen.
# start a stopped container
docker start web
# stop with a custom timeout (seconds)
docker stop -t 30 web
# restart (keeps container intact)
docker restart web
# rename a container
docker rename web webserver
# update container config (e.g. restart policy)
docker update --restart unless-stopped web
# pause/resume (cgroup freezer)
docker pause web
docker unpause webDateien kopieren
cp funktioniert in beide Richtungen und auch bei gestoppten Containern — praktisch, um Hotfixes einzuspielen oder Logs zu extrahieren. Für häufige Synchronisation ist es nicht gedacht; in Entwicklungs-Workflows einen Bind-Mount oder ein Volume verwenden. Der tar+exec-Trick streamt große Verzeichnisse effizient.
# copy a file from host to container
docker cp file.txt web:/tmp/
# copy from container to host
docker cp web:/etc/nginx/nginx.conf ./nginx.conf
# copy a directory
docker cp ./app web:/usr/src/app
# copy with archive mode (preserves perms)
docker cp -a ./config web:/etc/app
# copy to a stopped container (works too)
docker cp script.sh web:/script.sh
# tar stream from host to container stdin
docker exec -i web tar xzf - -C /app < app.tar.gzDockerfile-Grundlagen
FROM — Basis-Image
FROM ist die erste Anweisung und definiert den Basis-Layer. Minimale Basen wählen (alpine, distroless, scratch), um Angriffsfläche und Größe zu reduzieren. Das Pinnen per Digest garantiert reproduzierbare Builds, da sich Tags ändern können.
# use an official base image
FROM ubuntu:22.04
# pin a specific digest for reproducibility
FROM ubuntu@sha256:abc123def...
# multi-arch build (buildx picks the host arch)
FROM --platform=$BUILDPLATFORM golang:1.21 AS builder
# use a minimal image
FROM alpine:3.18
# scratch = empty image, for static binaries
FROM scratch
# use a previous build stage
FROM builder AS finalRUN — Befehle ausführen
Jedes RUN erzeugt einen Layer. Zusammengehörige Befehle mit && kombinieren und im selben Layer aufräumen, um Images klein zu halten. Die exec-Form (JSON-Array) ruft keine Shell auf, daher keine Variablenexpansion oder Verkettung — sie verarbeitet Signale aber korrekt.
# install packages
RUN apt-get update && apt-get install -y curl
# clean up in the same layer to reduce size
RUN apt-get update && apt-get install -y --no-install-recommends curl \
&& rm -rf /var/lib/apt/lists/*
# combine commands with && to reduce layers
RUN mkdir -p /app/config && chown 1000:1000 /app/config
# use exec form (preferred) to ensure signals
RUN ["npm", "install"]
# use a shell for variables and chaining
RUN VERSION=1.0 && wget https://example.com/v${VERSION}.tar.gzCOPY & ADD
COPY ist für lokale Dateien vorzuziehen — explizit und vorhersagbar. ADD hat Zaubereigenschaften: URL-Downloads und automatisches Entpacken von tar/zip-Archiven. Diese Magie kann überraschen; ADD nur einsetzen, wenn Entpacken nötig ist. Beide erzeugen einen Layer.
# copy a file into the image
COPY package.json /app/
# copy a directory
COPY src/ /app/src/
# copy with ownership
COPY --chown=node:node package.json /app/
# copy from a previous build stage
COPY --from=builder /app/dist /app/dist
# ADD can fetch URLs and extract archives
ADD https://example.com/app.tar.gz /tmp/
# ADD extracts local tar archives automatically
ADD app.tar.gz /usr/src/WORKDIR
WORKDIR setzt das Arbeitsverzeichnis für nachfolgende Anweisungen und als Container-Standard. Es erzeugt das Verzeichnis, falls es fehlt. Immer WORKDIR statt cd in RUN verwenden — cd überlebt keine Layer-Grenze. Absolute Pfade nutzen für Klarheit.
# set the working directory
WORKDIR /usr/src/app
# subsequent RUN, CMD, COPY use this dir
COPY . .
RUN npm install
# WORKDIR creates the directory if it does not exist
WORKDIR /opt/data/logs
# use a relative path (relative to previous WORKDIR)
WORKDIR sub
# avoid this anti-pattern (use absolute paths)
WORKDIR /app
RUN cd /app && do_something # cd is lost after RUNUSER
USER setzt den Benutzer (und optional die Gruppe) für RUN, CMD und ENTRYPOINT. Ausführen ohne root ist eine zentrale Sicherheitsbest-Practice. Der Benutzer muss im Image existieren. Numerische UIDs sind portabel über Images hinweg und vermeiden Probleme bei der Namensauflösung.
# create a non-root user and switch to it
RUN groupadd -r app && useradd -r -g app appuser
USER appuser
# run subsequent instructions as this user
RUN whoami # appuser
# use a numeric UID for portability
USER 1000
# USER in compose/runtime overrides this
USER 1000:1000
# common pattern: node image ships a 'node' user
FROM node:20-alpine
USER node.dockerignore
.dockerignore verkleinert den an den Daemon gesendeten Build-Kontext — schnellere Builds, kleinerer Kontext und verhindert, dass Secrets wie .env in Image-Layer gelangen. Die Syntax ähnelt .gitignore. node_modules und Build-Artefakte, die beim Build neu erzeugt werden, immer ausschließen.
# .dockerignore — exclude files from the build context
# version control
.git
.gitignore
# dependencies (fetched inside the image)
node_modules
npm-debug.log
# build artifacts
dist
build
*.log
# local env files (NEVER bake secrets)
.env
.env.local
# docker files themselves
Dockerfile
docker-compose*.yml
# OS files
.DS_Store
Thumbs.dbDockerfile Fortgeschritten
CMD vs ENTRYPOINT
ENTRYPOINT definiert die ausführbare Datei; CMD liefert Standardargumente, die überschrieben werden können. Die exec-Form (JSON-Array) verwenden, damit der Prozess Signale direkt empfängt — die Shell-Form wickelt den Befehl in /bin/sh -c und verhindert sauberes Herunterfahren. Häufiges Muster: ENTRYPOINT-Skript + CMD-Standardargumente.
# CMD: default command, easily overridden
CMD ["nginx", "-g", "daemon off;"]
# override at runtime
# docker run myimage nginx -v
# ENTRYPOINT: fixed command, CMD becomes args
ENTRYPOINT ["nginx"]
CMD ["-g", "daemon off;"]
# runtime args append to ENTRYPOINT
# docker run myimage -v -> nginx -v
# shell form (avoid — no signal handling)
CMD nginx -g "daemon off;"
# script as entrypoint that accepts args
ENTRYPOINT ["./entrypoint.sh"]
CMD ["--help"]ENV — Umgebungsvariablen
ENV erzeugt Image-Variablen, die bei Build und Laufzeit sichtbar sind. Für reinen Build-Zeit-Werte ARG verwenden, damit keine Konfiguration ins finale Image gelangt. In exec-Form CMD/ENTRYPOINT wird ${VAR} nicht von der Shell expandiert — mit sh -c umwickeln.
# set a persistent env var (baked into image)
ENV NODE_ENV=production
ENV PATH=/app/node_modules/.bin:$PATH
# use in subsequent RUN instructions
ENV VERSION=1.2.3
RUN wget https://example.com/v${VERSION}.tar.gz
# multiple in one line
ENV NODE_ENV=production PORT=3000 LOG_LEVEL=info
# override at runtime
# docker run -e NODE_ENV=development myapp
# view env vars of a container
docker exec web env
# reference env vars in CMD
ENV APP_PORT=3000
CMD ["sh", "-c", "node server.js ${APP_PORT}"]ARG — Build-Argumente
ARG-Werte existieren nur während des Builds der Stage, die sie deklariert. Sie überleben nicht in den Laufzeit-Container — mit ENV einen Wert zur Laufzeit transportieren. Vor FROM deklarierte ARGs sind 'global', müssen aber in jeder Stage erneut deklariert werden, um dort nutzbar zu sein.
# declare a build argument with a default
ARG VERSION=latest
FROM base:${VERSION}
# use ARG only during build (not at runtime)
ARG NODE_ENV=production
RUN echo "Building for ${NODE_ENV}"
# multi-stage: ARG must be redeclared per stage
ARG VERSION
FROM base:${VERSION}
ARG VERSION
RUN echo ${VERSION}
# pass at build time
# docker build --build-arg VERSION=1.0 .
# ARG not available in CMD (use ENV to pass through)
ARG PORT=3000
ENV PORT=${PORT}
CMD ["sh", "-c", "serve --port ${PORT}"]EXPOSE
EXPOSE ist Dokumentation — es publiziert keine Ports. Publizieren passiert zur Laufzeit mit -p (host:container) oder mit ports: in Compose. EXPOSE hilft Tooling, die vorgesehenen Ports zu verstehen, und ermöglicht automatisches Linking in älteren Netzwerken.
# document which port the container listens on
EXPOSE 80
# expose multiple ports
EXPOSE 80 443
# expose with protocol
EXPOSE 53/udp
# EXPOSE does NOT publish the port
# you still need -p at runtime
# docker run -p 8080:80 myapp
# in compose, expose vs ports
# expose: only to linked services
# ports: published to the host
# view exposed ports
docker inspect --format '{{json .Config.ExposedPorts}}' myappLABEL & Metadaten
LABEL hängt Key-Value-Metadaten an Images. Die OCI-Labels org.opencontainers.image.* übernehmen für Interoperabilität mit Registries und Tools. Labels eignen sich zum Nachverfolgen von Version, Quelle, Lizenzierung und CI-Build-Infos.
# add a label (key=value metadata)
LABEL maintainer="[email protected]"
LABEL version="1.0"
LABEL description="My web app"
# multiple labels in one instruction
LABEL org.opencontainers.image.title="myapp" \
org.opencontainers.image.version="1.0" \
org.opencontainers.image.source="https://github.com/me/myapp"
# view labels
docker inspect --format '{{json .Config.Labels}}' myapp
# filter images by label
docker images --filter "label=version=1.0"
# deprecated: MAINTAINER (use LABEL maintainer instead)
# MAINTAINER Alice <[email protected]>VOLUME im Dockerfile
VOLUME deklariert einen Mount-Punkt; Docker erzeugt beim ersten Start ein anonymes Volume, sofern kein Host-Pfad gebunden ist. Es signalisiert, dass das Verzeichnis zustandsbehaftete Daten enthält. Stolperfalle: VOLUME nach COPY zu deklarieren kann die kopierten Dateien mit einem leeren Volume überdecken.
# declare an anonymous volume mount point
VOLUME /data
# multiple mount points
VOLUME /data /config /logs
# at runtime, Docker creates an anonymous volume
# docker run -v mydata:/data myapp (named instead)
# VOLUME in Dockerfile: any files copied to /data
# are copied into the new anonymous volume on first run
# inspect volumes
docker inspect --format '{{json .Mounts}}' myapp
# avoid: VOLUME after COPY can hide your data
COPY ./config /config
VOLUME /config # new empty volume shadows /configMulti-Stage-Builds
Einfaches Multi-Stage
Multi-Stage-Builds kopieren nur die finalen Artefakte ins Runtime-Image — Build-Tools, Quellcode und Dev-Abhängigkeiten bleiben in der Builder-Stage. Ergebnis: ein winziges, sicheres Runtime-Image. Stages mit AS benennen, um sie in COPY --from zu referenzieren.
# stage 1: build
FROM node:20 AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build
# stage 2: runtime (small)
FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]Build-Stage auswählen
--target baut nur bis zur benannten Stage und überspringt spätere Stages. So reicht ein einziger Dockerfile für Dev, Test und Produktion: 'test' für CI ansteuern, 'final' für Produktion. BuildKit parallelisiert unabhängige Stages automatisch.
# build only up to a named stage
# docker build --target builder -t myapp:dev .
FROM node:20 AS builder
RUN npm ci && npm run build
FROM node:20-alpine AS test
COPY --from=builder /app /app
RUN npm test
FROM nginx:alpine AS final
COPY --from=builder /app/dist /usr/share/nginx/html
# target a specific stage
# docker build --target test .Schlanke Runtime-Images
Für statische Binaries (Go, Rust) erzeugt scratch das kleinstmögliche Image mit null Angriffsfläche. CA-Zertifikate für HTTPS hinzufügen. Distroless bietet eine minimale Basis mit Root-CAs und einem Nicht-root-Benutzer — ideal für dynamische Sprachen oder wenn man eine Runtime ohne Shell braucht.
# build stage
FROM golang:1.21 AS builder
WORKDIR /src
COPY . .
RUN CGO_ENABLED=0 go build -o app -ldflags="-s -w" .
# scratch = empty image, only the static binary
FROM scratch
COPY --from=builder /src/app /app
COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
ENTRYPOINT ["/app"]
# result: ~10MB image
# or use distroless for a minimal OS base
FROM gcr.io/distroless/static
COPY --from=builder /src/app /app
ENTRYPOINT ["/app"]Builder-Pattern für kompilierte Sprachen
In einem vollständigen SDK-Image kompilieren, dann das Artefakt in ein reines Runtime-Image (JRE) kopieren. Das verkleinert das Image drastisch (JDK ~600MB vs. JRE ~200MB) und entfernt Build-Tools aus der Produktion. Abhängigkeiten vor COPY vorab laden verbessert das Layer-Caching.
# stage 1: compile
FROM maven:3.9 AS builder
WORKDIR /build
COPY pom.xml .
RUN mvn dependency:go-offline
COPY src ./src
RUN mvn package -DskipTests
# stage 2: runtime with only the JRE
FROM eclipse-temurin:21-jre-alpine
COPY --from=builder /build/target/*.jar /app/app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "/app/app.jar"]
# benefits: no JDK, no source, no Maven cache in runtimeAus externen Images kopieren
COPY --from kann aus jedem Image ziehen — praktisch, um Tools aus mehreren Basen zusammenzustellen, ohne eine Build-Stage. Stages sind auch per Index referenzierbar (0-basiert), aber Benennung mit AS ist klarer. Externe Images per Digest pinnen für Reproduzierbarkeit.
# copy a binary from another image (no build stage needed)
FROM alpine:3.18
COPY --from=nginx:alpine /usr/sbin/nginx /usr/sbin/nginx
COPY --from=nginx:alpine /etc/nginx /etc/nginx
RUN apk add --no-cache libpcre2
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]
# use a specific digest for reproducibility
COPY --from=redis:7@sha256:abc... /usr/local/bin/redis-server /usr/local/bin/
# copy from a built stage referenced by index
COPY --from=0 /build/output /appBuildKit-Features
BuildKit bringt Cache-Mounts (npm/pip-Caches überdauern Builds, ohne das Image aufzublähen), Secret-Mounts (Credentials berühren nie einen Layer), SSH-Forwarding für private Repos und Heredoc-Syntax für übersichtlichere mehrzeilige RUN-Befehle. Mit der # syntax-Direktive die Dockerfile-Frontend-Version pinnen.
# enable BuildKit
# DOCKER_BUILDKIT=1 docker build .
# syntax directive for latest frontend
# syntax=docker/dockerfile:1
FROM alpine
# mount a cache (persists across builds, not in image)
RUN --mount=type=cache,target=/root/.npm npm ci
# mount a secret (never written to layers)
RUN --mount=type=secret,id=npmrc,target=/root/.npmrc npm ci
# mount an SSH socket for private repos
RUN --mount=type=ssh git clone [email protected]:me/repo.git
# heredoc for multi-line scripts
RUN <<EOF
set -ex
apk add --no-cache curl
mkdir -p /app/data
EOFVolumes
Volumes anlegen und nutzen
Benannte Volumes werden von Docker verwaltet und sind die empfohlene Art, Daten zu persistieren. Sie überleben das Entfernen des Containers und sind unabhängig vom Dateisystem-Layout des Hosts. Das Suffix :ro mountet schreibgeschützt. inspect enthüllt den Pfad auf der Platte unter /var/lib/docker/volumes.
# create a named volume
docker volume create mydata
# use it in a container
docker run -d -v mydata:/data alpine sh -c "sleep 1h"
# inspect the volume
docker volume inspect mydata
# mount read-only
docker run -v mydata:/data:ro alpine ls /data
# mount with a different filesystem (e.g. tmpfs)
docker run --tmpfs /cache alpine
# default volume driver: local
docker volume create --driver local mydataVolumes auflisten und inspizieren
ls listet benannte Volumes; inspect zeigt Treiber und Mountpoint. Um herauszufinden, welche Container ein Volume nutzen, ps nach Volume filtern. Volumes liegen auf Linux-Hosts unter /var/lib/docker/volumes/<name>/_data — Zugriff über docker exec statt durch direktes Bearbeiten auf dem Host.
# list all volumes
docker volume ls
# filter by name
docker volume ls -q --filter name=mydata
# show volume details (driver, mountpoint, options)
docker volume inspect mydata
# find the on-disk path
docker volume inspect --format '{{.Mountpoint}}' mydata
# find containers using a volume
docker ps -a --filter volume=mydata --format '{{.Names}}'
# check volume disk usage
docker system df -v | grep mydataVolume-Treiber
Der lokale Treiber unterstützt NFS, Blockgeräte und tmpfs über Mount-Optionen. Für Cloud-Speicher (EBS, Azure Disk) einen Plugin-Treiber verwenden. Treiber abstrahieren Storage, sodass Container zwischen Hosts wandern können, ohne den run-Befehl zu ändern — zentral für Swarm/Kubernetes.
# local driver (default, on host disk)
docker volume create --driver local mydata
# NFS volume
docker volume create --driver local \
--opt type=nfs \
--opt o=addr=10.0.0.5,rw \
--opt device=:/export/data nfsvol
# tmpfs (in-memory, ephemeral)
docker run --tmpfs /cache alpine
# block device
docker volume create --driver local \
--opt type=ext4 \
--opt device=/dev/sdb1 blockvol
# third-party drivers (e.g. cloud)
docker volume create --driver rexray/ebs ebsvolVolumes sichern
Ein Volume sichert man, indem man in einem temporären Container sowohl das Volume als auch ein Host-Verzeichnis mountet und die Inhalte mit tar packt. Restore läuft umgekehrt. Dieses Muster funktioniert mit jedem Volume-Treiber und ist die Grundlage automatisierter Backup-Skripte.
# back up a volume to a tar file
docker run --rm -v mydata:/data -v $(pwd):/backup alpine \
tar czf /backup/mydata.tar.gz -C /data .
# restore a volume from a tar file
docker volume create mydata2
docker run --rm -v mydata2:/data -v $(pwd):/backup alpine \
tar xzf /backup/mydata.tar.gz -C /data
# migrate data between volumes
docker run --rm -v src:/src -v dst:/dst alpine \
cp -a /src/. /dst/
# snapshot using a temporary container
docker run --rm -v mydata:/data alpine ls -la /dataVolumes entfernen
Ein Volume lässt sich nicht entfernen, solange ein Container es referenziert (zuerst den Container entfernen). prune entfernt nur ungenutzte Volumes. Das Löschen von Volumes ist unwiderruflich — die Daten sind dauerhaft verloren. Produktions-Volumes vor jedem Prune sichern.
# remove a named volume (must not be in use)
docker volume rm mydata
# remove all unused volumes
docker volume prune
# remove volumes older than 24h not used
docker volume prune --filter "until=24h"
# force remove (even if a stopped container referenced it)
docker volume rm -f mydata
# remove with a label filter
docker volume prune --filter "label=temporary"
# CAUTION: data is gone permanently
docker volume rm mydataVolumes zwischen Containern teilen
Mehrere Container können dasselbe Volume mounten, um Zustand zu teilen. --volumes-from klont die Volume-Mounts eines anderen Containers — praktisch für Sidecar-Muster. Mit :ro für nur lesende Konsumenten. Gleichzeitige Schreibzugriffe koordinieren, um Korruption zu vermeiden; manche Apps brauchen ein Lock.
# share a volume between two containers
docker run -d --name db -v shared:/data alpine sleep 1h
docker run -d --name app -v shared:/data alpine sleep 1h
# use --volumes-from to copy a container's mounts
docker run -d --name helper --volumes-from db alpine sleep 1h
# read-only shared volume
docker run -d --name reader -v shared:/data:ro alpine sleep 1h
# compose: shared volume across services
# volumes:
# shared:
# services share 'shared' via volumes: ['shared:/data']
# verify both see the same data
docker exec db sh -c "echo hi > /data/msg"
docker exec app cat /data/msgBind-Mounts
Einfacher Bind-Mount
Bind-Mounts mappen einen Host-Pfad direkt in den Container — ideal für Live-Entwicklung, bei der Host-Änderungen sofort wirken. Absolute Host-Pfade verwenden. Das Suffix :ro verhindert, dass der Container auf den Host zurückschreibt. Die moderne Syntax nutzt --mount zur besseren Verständlichkeit.
# bind mount a host directory (modern syntax)
docker run -d --type bind --source $(pwd)/app --target /app nginx
# short form (-v)
docker run -d -v $(pwd)/app:/app nginx
# absolute host path required
docker run -v /home/me/app:/app nginx
# mount a single file
docker run -v /home/me/app.conf:/etc/app/app.conf:ro nginx
# mount read-only
docker run -v $(pwd)/app:/app:ro nginx
# compose equivalent
# volumes:
# - ./app:/appSchreibgeschützter Bind-Mount
Schreibgeschützte Mounts schützen die Host-Konfiguration vor Container-Schreibzugriffen — sicherheitskritisch. --read-only macht das gesamte Root-Dateisystem unveränderlich und erfordert explizite schreibbare Mounts für /tmp und Log-Verzeichnisse. Das härtet Container gegen Kompromittierung.
# mount config read-only
docker run -v /etc/myapp:/etc/myapp:ro myapp
# --mount equivalent with explicit type
docker run --mount type=bind,source=/etc/myapp,target=/etc/myapp,readonly myapp
# read-only root filesystem (extra security)
docker run --read-only -v /tmp myapp
# combine read-only root with a writable tmpfs
docker run --read-only --tmpfs /tmp --tmpfs /var/cache myapp
# verify the mount is read-only
docker exec myapp touch /etc/myapp/test # should failEntwicklungs-Workflow
Quellcode mounten, damit Host-Änderungen sofort im Container ankommen. Der Trick mit dem 'anonymen Volume für node_modules' verhindert, dass das leere node_modules des Hosts die im Image installierten Abhängigkeiten überdeckt. Auf Windows/Mac kann Polling nötig sein, damit File-Watching zuverlässig funktioniert.
# live-reload: mount source, run dev server
docker run -d -p 3000:3000 -v $(pwd)/src:/app/src node:20 \
sh -c "cd /app && npm run dev"
# mount node_modules separately (avoid host override)
docker run -d -v $(pwd):/app -v /app/node_modules node:20 npm start
# compose dev workflow
# services:
# web:
# volumes:
# - ./src:/app/src
# - /app/node_modules # anonymous, isolates deps
# hot reload with file watching (polling for Windows/Mac)
docker run -e CHOKIDAR_USEPOLLING=true -v $(pwd):/app node:20 npm startSELinux- & AppArmor-Labels
Auf SELinux-fähigen Hosts (RHEL/CentOS/Fedora) brauchen Bind-Mounts ein :z- oder :Z-Suffix, damit der Host-Pfad umgelabelt wird und der Container zugreifen kann. :z teilt den Pfad zwischen Containern; :Z macht ihn privat. Ohne das Suffix gibt es 'permission denied'-Fehler.
# SELinux: :z (shared) or :Z (private) suffix
docker run -v /host/path:/container/path:z myapp
docker run -v /host/path:/container/path:Z myapp
# :z labels the host path as shared among containers
# :Z labels it private to this container
# disable SELinux isolation (NOT recommended)
docker run --security-opt label=disable myapp
# AppArmor profile
docker run --security-opt apparmor=docker-default myapp
# custom AppArmor profile
docker run --security-opt apparmor=myprofile myappMount vs. Volume vs. tmpfs
Volumes: Docker-verwaltet, portabel, ideal für persistente Daten. Bind-Mounts: Host-Pfade, ideal für Dev und Konfigurations-Injection. tmpfs: im Arbeitsspeicher, ideal für Secrets und flüchtige Caches. Die --mount-Syntax ist expliziter und selbstdokumentierend als -v.
# named volume (Docker-managed, portable)
docker run -v mydata:/data nginx
# bind mount (host path, host-dependent)
docker run -v /home/me/data:/data nginx
# --mount explicit syntax (recommended)
docker run --mount type=volume,source=mydata,target=/data nginx
docker run --mount type=bind,source=/home/me/data,target=/data nginx
docker run --mount type=tmpfs,target=/cache nginx
# tmpfs (in-memory, ephemeral, fast)
docker run --tmpfs /cache nginx
# tmpfs with size limit
docker run --mount type=tmpfs,target=/cache,tmpfs-size=64m nginxBind-Mounts in Compose
In Compose erzeugt ein relativer Pfad (./html) einen Bind-Mount, während ein Name (logs), der auf die volumes:-Sektion verweist, ein benanntes Volume anlegt. Ein nackter Pfad (/cache) erzeugt ein anonymes Volume. Die Langform-Syntax macht Optionen wie read_only explizit.
# docker-compose.yml
services:
web:
image: nginx
volumes:
# relative host path = bind mount
- ./html:/usr/share/nginx/html:ro
# named volume
- logs:/var/log/nginx
# anonymous volume
- /cache
volumes:
logs: # declare named volumes here
# use ~ (tilde) — Compose expands it
volumes:
- ~/config:/etc/app:ro
# long-form syntax with options
volumes:
- type: bind
source: ./html
target: /usr/share/nginx/html
read_only: trueNetzwerk
Bridge-Netzwerk (Standard)
Dem Standard-Bridge-Netzwerk fehlt automatisches DNS — Container müssen IPs verwenden. Eigene Bridge-Netzwerke bieten DNS-basiertes Service-Discovery: Container lösen sich gegenseitig über Namen auf. Genau deshalb legt Compose automatisch ein eigenes Netzwerk pro Projekt an.
# the default bridge network (named 'bridge')
docker run -d --name web nginx
# create a custom bridge network (recommended)
docker network create mynet
# attach a container to a custom network
docker run -d --name web --network mynet nginx
docker run -d --name db --network mynet postgres
# containers on the same custom network can resolve by name
docker exec web ping db # DNS resolves 'db'
# the default bridge does NOT support DNS names
# always use a custom bridge for multi-container appsHost-Netzwerk
Host-Netzwerk entfernt den Netzwerk-Namespace — der Container teilt die Interfaces und Ports des Hosts. Beste Performance, aber ohne Isolation und Port-Mapping. Nur unter Linux verfügbar; auf Mac/Windows mappt es in ein VM-Netzwerk, nicht auf den Host.
# use the host's network stack directly (no isolation)
docker run --network host nginx
# host network disables port mapping
# -p is ignored when --network host is used
# useful for performance-sensitive apps
docker run --network host -d myapp
# only works on Linux (not Docker Desktop on Mac/Windows)
# inspect host network
docker network inspect host
# bound to host interfaces — be careful with privileged ports
docker run --network host --cap-add NET_ADMIN myappOverlay-Netzwerk (Swarm)
Overlay-Netzwerke überspannen mehrere Swarm-Knoten und ermöglichen sichere Host-übergreifende Kommunikation mit eingebautem DNS. --attachable lässt eigenständige Container einem Overlay beitreten (nützlich zum Debuggen). Verschlüsselung sichert den Verkehr zwischen Knoten; für sensible Workloads aktivieren.
# create an overlay network (requires Swarm mode)
docker network create -d overlay myoverlay
# overlay with encryption
docker network create -d overlay -o encrypted myoverlay
# deploy a service on the overlay
docker service create --network myoverlay --name web nginx
# multi-host communication for Swarm services
# containers on different nodes resolve by service name
# node-local network bridged to overlay
docker network create -d overlay --attachable myoverlay
docker run -d --network myoverlay alpine # standalone containerEigene Netzwerke
Eigene Netzwerke erlauben Kontrolle über Subnetze, Gateways und Isolation. --internal verhindert ausgehenden Internetzugriff. macvlan gibt Containern echte Präsenz im physischen LAN (jeder bekommt eine eigene MAC) — nützlich für Legacy-Apps, bricht aber standardmäßig die Host-zu-Container-Kommunikation.
# create a bridge network with a subnet
docker network create --subnet 172.20.0.0/16 mynet
# assign a static IP
docker run -d --network mynet --ip 172.20.0.10 nginx
# set a custom gateway
docker network create --subnet 172.20.0.0/16 \
--gateway 172.20.0.1 mynet
# restrict to internal only (no external access)
docker network create --internal mynet
# specify a driver and options
docker network create -d bridge \
-o com.docker.network.bridge.name=br0 mynet
# macvlan (container gets a MAC on the physical network)
docker network create -d macvlan \
--subnet 192.168.1.0/24 -o parent=eth0 mymacvlanContainer-DNS
Das eingebettete DNS von Docker (127.0.0.11) löst Containernamen in benutzerdefinierten Netzwerken auf. Die Standard-Bridge hat kein DNS. --dns ergänzt externe Resolver; --add-host injiziert statische Einträge. Für Container-zu-Container-Kommunikation Service-Namen (nicht IPs) verwenden, damit Redeployments das DNS nicht brechen.
# containers on custom networks resolve by name
docker network create mynet
docker run -d --name db --network mynet postgres
docker run -it --network mynet alpine nslookup db
# the embedded DNS server is at 127.0.0.11
docker exec web cat /etc/resolv.conf
# add custom DNS servers
docker run --dns 8.8.8.8 alpine nslookup example.com
# add DNS search domains
docker run --dns-search example.com alpine nslookup myhost
# add a host entry (like /etc/hosts)
docker run --add-host myservice:10.0.0.5 alpine ping myservice
# extra hosts in compose
# extra_hosts:
# - "myservice:10.0.0.5"Netzwerk-Inspektion & Verwaltung
network connect/disconnect erlaubt es, einen laufenden Container ohne Neustart an weitere Netzwerke anzuhängen — nützlich für Sidecars. inspect zeigt verbundene Container, Subnetz und Treiber. prune entfernt Netzwerke, die von keinem Container genutzt werden.
# list all networks
docker network ls
# inspect a network (containers, IPAM, driver)
docker network inspect mynet
# see which containers are on a network
docker network inspect --format '{{range .Containers}}{{.Name}} {{end}}' mynet
# connect a running container to another network
docker network connect mynet2 web
# disconnect a container from a network
docker network disconnect mynet web
# remove an unused network
docker network rm mynet
docker network prunePort-Mapping
Einfaches Port-Mapping
-p host:container mappt einen Host-Port auf einen Container-Port. Lässt man den Host-Port weg, wählt Docker einen (mit docker port herausfinden). Jeder Host-Port kann nur auf einen Container gemappt werden — für mehrere Instanzen einen Reverse-Proxy oder unterschiedliche Host-Ports nutzen.
# map host:container
docker run -d -p 8080:80 nginx
# map to a random host port
docker run -d -p 80 nginx
docker port $(docker ps -lq) 80 # find the assigned port
# map multiple ports
docker run -d -p 8080:80 -p 8443:443 nginx
# map the same port on host and container
docker run -d -p 80:80 nginx
# explicit protocol (default tcp)
docker run -d -p 53:53/udp dns
# long form
docker run -d --publish 8080:80 nginxAn eine bestimmte IP binden
Ein vorangestelltes IP steuert, an welches Interface der Port gebunden wird. 127.0.0.1 hält den Dienst lokal — wichtig für Datenbanken, die nicht exponiert werden sollen. 0.0.0.0 (Standard) bindet an alle Interfaces. In Produktion Datenbanken immer an localhost binden.
# bind to a specific host IP
docker run -d -p 127.0.0.1:8080:80 nginx
# bind to localhost only (not exposed externally)
docker run -d -p 127.0.0.1:5432:5432 postgres
# bind to all interfaces (default)
docker run -d -p 0.0.0.0:8080:80 nginx
# bind to an IPv6 address
docker run -d -p [::1]:8080:80 nginx
# multiple bindings
docker run -d -p 127.0.0.1:8080:80 -p 0.0.0.0:8443:443 nginx
# compose: specify IP
# ports:
# - "127.0.0.1:5432:5432"UDP- & SCTP-Ports
Das Suffix /udp oder /sctp wählt das Protokoll; TCP ist der Standard. Für Dienste wie DNS, die beides brauchen, beide Mappings deklarieren. Port-Bereiche mappen 1:1 zwischen Host und Container — nützlich für WebRTC, RTP oder passives FTP. Sicherstellen, dass Firewall-Regeln zu den Protokollen passen.
# UDP port (DNS, syslog, statsd)
docker run -d -p 53:53/udp coredns
# both TCP and UDP
docker run -d -p 53:53/tcp -p 53:53/udp coredns
# SCTP (e.g. telecom signaling)
docker run -d -p 3868:3868/sctp myapp
# range of ports (host range maps to container range)
docker run -d -p 8000-8100:8000-8100 myapp
# UDP range
docker run -d -p 50000-50010:50000-50010/udp myapp
# compose with protocol
# ports:
# - "53:53/udp"Port-Bereiche
Port-Bereiche mappen 1:1 (Host 8000-8005 auf Container 8000-8005). -P (groß) publiziert jeden EXPOSE-Port automatisch auf einen zufälligen hohen Host-Port — praktisch für schnelle Tests. Bei zufälligen Ports mit docker ps die tatsächlichen Mappings anzeigen.
# map a range of host ports to container ports
docker run -d -p 8000-8005:8000-8005 myapp
# map host range to a single container port (NOT supported)
# this maps range-to-range only
# random port for each (useful for testing)
docker run -d -p 80 -p 443 nginx
docker port $(docker ps -lq)
# expose a range with EXPOSE (documentation only)
# EXPOSE 8000-8005
# publish all exposed ports at once
docker run -d -P nginx # capital P publishes all EXPOSE ports
# view the random mappings
docker ps --format '{{.Names}} {{.Ports}}'Exposen vs. Publizieren
EXPOSE dokumentiert die Absicht; -p publiziert tatsächlich. In Compose teilt expose einen Port nur mit anderen Diensten im selben Netzwerk, während ports ihn auf dem Host publiziert. Dieser Unterschied ist bei Datenbanken wichtig: intern exposen, in Produktion nie auf den Host publizieren.
# Dockerfile: EXPOSE is documentation, NOT a publish
EXPOSE 80 443
# runtime: -p PUBLISHES the port to the host
docker run -d -p 8080:80 nginx
# -P publishes all EXPOSE ports to random host ports
docker run -d -P nginx
# compose: expose vs ports
services:
web:
image: nginx
expose:
- "80" # only to linked services, NOT to host
ports:
- "8080:80" # published to the host
# view exposed (not published) ports
docker inspect --format '{{json .Config.ExposedPorts}}' nginxZufälliges Port-Mapping
Lässt man den Host-Port weg, wählt Docker einen zufälligen ephemeren Port (standardmäßig 32768-60999). Mit docker port oder docker ps herausfinden. Nützlich, um identische Dienste auf einem Host zu skalieren. Den ephemeren Bereich in /proc/sys/net/ipv4/ip_local_port_range unter Linux anpassen.
# publish to a random high host port
docker run -d -p 80 nginx
# publish all EXPOSE ports randomly
docker run -d -P nginx
# find the assigned port
docker port <container> 80
docker port <container>
# see mappings in ps output
docker ps --format 'table {{.Names}} {{.Ports}}'
# prefer a range for random allocation
docker run -d -p 30000-40000:80 nginx
# compose: random host port
# ports:
# - "80" # random host port, container port 80Umgebungsvariablen
Env-Variablen setzen
-e (oder --env) setzt Umgebungsvariablen im Container. -e VAR (ohne Wert) erbt die Variable aus der Host-Shell. Für sensible Werte sind --env-file oder Docker Secrets vorzuziehen, denn plain -e ist in docker inspect und Prozesslisten sichtbar.
# single variable
docker run -d -e MYSQL_ROOT_PASSWORD=secret mysql
# multiple variables
docker run -d \
-e MYSQL_ROOT_PASSWORD=secret \
-e MYSQL_DATABASE=mydb \
-e MYSQL_USER=app \
mysql
# pass from the host environment
docker run -d -e HOST_PWD mysql
# HOST_PWD in the container = $HOST_PWD on host
# set a variable without a value (passes host value or empty)
docker run -e DEBUG alpine env
# long form
docker run --env MYSQL_ROOT_PASSWORD=secret mysqlEnv-Dateien
--env-file lädt Variablen aus einer Datei, hält den run-Befehl sauber und Secrets aus der Shell-History. Compose lädt eine .env auf oberster Ebene automatisch für die Variablenersetzung in der Compose-Datei selbst. Kommentare (#) und Leerzeilen werden ignoriert; Anführungszeichen bleiben wörtlich erhalten.
# .env file
# DB_HOST=db
# DB_USER=app
# DB_PASSWORD=secret
# load variables from a file
docker run --env-file .env myapp
# load multiple env files
docker run --env-file .env --env-file .env.local myapp
# Compose reads .env automatically for variable substitution
# and supports env_file per service:
# services:
# web:
# env_file:
# - .env
# - .env.local
# env file with comments and blank lines
docker run --env-file config.env myappEnv-Variablen im Dockerfile
ENV bäckt Variablen ins Image, sichtbar bei Build und Laufzeit. ARG gilt nur zur Build-Zeit — in ENV umwandeln, wenn die Laufzeit ihn braucht. Eingebäckte Werte lassen sich zur Laufzeit mit -e überschreiben. Hinweis: Env-Variablen sind in docker inspect sichtbar, also keine Secrets dort speichern.
# ENV sets a persistent variable
ENV NODE_ENV=production
ENV PATH=/app/bin:$PATH
# use ARG for build-time only, ENV for runtime
ARG BUILD_VERSION=1.0
ENV APP_VERSION=${BUILD_VERSION}
# view all env vars
docker exec web env
# inspect a specific variable
docker exec web printenv NODE_ENV
# override at runtime
docker run -e NODE_ENV=development myapp
# set via Compose
# environment:
# - NODE_ENV=development
# - DEBUG=trueDynamische Env-Variablen & Substitution
Shell-Expansion ($(...) oder ${VAR}) passiert auf dem Host, bevor Docker den Wert sieht. In Compose wird ${VAR} aus der .env-Datei ersetzt. In exec-Form CMD wird ${VAR} NICHT expandiert — mit sh -c umwickeln. Die Host-UID übergeben, damit Bind-Mounts die richtige Datei-Eigentümerschaft bekommen.
# pass a computed value at runtime
docker run -e STARTUP_TIME=$(date +%s) myapp
# use host shell expansion
docker run -e USER_ID=$(id -u) myapp
# Compose variable substitution from .env
# services:
# web:
# environment:
# DB_HOST: ${DB_HOST}
# .env file:
# DB_HOST=db
# Compose with default values
# DB_HOST: ${DB_HOST:-localhost}
# pass the current user for permission matching
docker run -u $(id -u):$(id -g) -e HOME=/tmp myapp
# resolve env at runtime with sh -c (not in exec form)
ENV PORT=3000
CMD ["sh", "-c", "node server.js --port ${PORT}"]Compose-Environment
Composes environment akzeptiert Listen- oder Map-Syntax. env_file lädt Werte in den Container; .env (oberste Ebene) liefert Variablen für ${}-Substitution in der Compose-Datei selbst. Bei vielen Variablen ist die Map-Form lesbarer.
# docker-compose.yml
services:
web:
image: myapp
environment:
- NODE_ENV=production
- DEBUG=false
- DB_HOST=db
# map form (cleaner for many vars)
environment:
NODE_ENV: production
DB_HOST: db
db:
image: postgres
env_file:
- .env.db
environment:
POSTGRES_DB: ${DB_NAME} # from .env
# top-level .env for substitution
# DB_NAME=mydbSecrets-Verwaltung
Secrets werden als Dateien unter /run/secrets gemountet, nie als Env-Variablen, und sind in Swarm in Transit und Ruhezustand verschlüsselt. Secrets nicht ins Image bäcken (ENV) oder per -e übergeben — beides leakt über docker inspect und Image-Layer. BuildKit-Secret-Mounts halten Build-Zeit-Credentials aus den Layern heraus.
# Docker Swarm secrets (encrypted, mounted as files)
echo "supersecret" | docker secret create db_password -
docker service create --secret db_password myapp
# read in the app
# cat /run/secrets/db_password
# Compose secrets (v3.1+)
# services:
# web:
# secrets:
# - db_password
# secrets:
# db_password:
# file: ./secrets/db_password.txt
# BuildKit secret mount (build-time, not in layers)
# RUN --mount=type=secret,id=npmrc,target=/root/.npmrc npm ci
# avoid: baking secrets in ENV or -e (visible in inspect)
docker run -e API_KEY=xxx myapp # NOT recommendedDocker Compose Grundlagen
Einfache docker-compose.yml
Compose beschreibt eine Multi-Container-App in einer einzigen YAML-Datei. services beschreibt jeden Container; volumes und networks werden auf oberster Ebene deklariert. depends_on steuert die Startreihenfolge. docker compose up -d startet alles im Hintergrund.
# docker-compose.yml (Compose spec v2)
services:
web:
image: nginx:alpine
ports:
- "8080:80"
volumes:
- ./html:/usr/share/nginx/html:ro
depends_on:
- db
restart: unless-stopped
db:
image: postgres:16
environment:
POSTGRES_PASSWORD: secret
volumes:
- dbdata:/var/lib/postgresql/data
volumes:
dbdata:
# run: docker compose up -dCompose-Befehle
up erzeugt und startet, down stoppt und entfernt. Mit -v bei down werden auch Volumes gelöscht (Datenverlust). exec führt einen Befehl in einem laufenden Service aus; run startet einen neuen Container für eine Einmalaufgabe. --scale startet mehrere Replikas eines Service auf demselben Host.
# start all services (foreground)
docker compose up
# start in background (detached)
docker compose up -d
# rebuild images before starting
docker compose up -d --build
# stop and remove containers (keeps volumes)
docker compose down
# also remove volumes (data loss)
docker compose down -v
# view logs (all services)
docker compose logs -f
# scale a service
docker compose up -d --scale worker=3
# run a one-off command in a service
docker compose exec web sh
docker compose run --rm web python manage.py migrateService-Abhängigkeiten
depends_on steuert die Startreihenfolge, aber die Abhängigkeit ist nicht unbedingt 'ready' — condition: service_healthy mit einem Healthcheck verwenden, um zu warten, bis die Datenbank Verbindungen annimmt. service_completed_successfully wartet auf Init-Container. Anwendungen sollten Verbindungen trotzdem mit Retries aufbauen.
services:
web:
image: myapp
depends_on:
db:
condition: service_healthy
redis:
condition: service_started
restart: on-failure
db:
image: postgres
healthcheck:
test: ["CMD", "pg_isready", "-U", "postgres"]
interval: 5s
retries: 5
redis:
image: redis
# conditions: service_started | service_healthy | service_completed_successfullyBuild in Compose
build definiert, wie ein Image aus dem Quellcode entsteht; image taggt das Ergebnis. context wird an den Builder gesendet (klein halten). target wählt eine Multi-Stage-Build-Stage. --build erzwingt beim up einen Neubau. Build-Args übergeben Werte zur Build-Zeit.
services:
web:
build:
context: ./app
dockerfile: Dockerfile.prod
args:
VERSION: 1.0
target: final
image: myapp:1.0
ports:
- "8080:80"
worker:
build: ./worker # shorthand: context only
image: myworker:1.0
# build and tag
docker compose build
docker compose build --no-cache web
docker compose up -d --buildVolumes in Compose
Ein relativer Pfad (./html) ist ein Bind-Mount; ein Name (logs), der unter top-level volumes: deklariert ist, ein benanntes Volume; ein nackter Pfad (/cache) ist anonym. Benannte Volumes können einen Treiber und Optionen angeben (z. B. NFS). Compose stellt Volume-Namen den Projektnamen voran.
services:
web:
image: nginx
volumes:
# named volume
- logs:/var/log/nginx
# bind mount (relative path)
- ./html:/usr/share/nginx/html:ro
# anonymous volume
- /cache
db:
image: postgres
volumes:
- dbdata:/var/lib/lib/postgresql/data
volumes:
logs:
dbdata:
driver: local
driver_opts:
type: nfs
device: ":/export/data"
o: addr=10.0.0.5,rwNetzwerke in Compose
Compose erstellt ein Standard-Netzwerk für alle Services, aber eigene Netzwerke erlauben die Isolation von Schichten. web verbindet Frontend und Backend. internal: true blockiert Internetzugriff für das Backend. Services im selben Netzwerk lösen sich über DNS per Service-Namen auf.
services:
web:
image: nginx
networks:
- frontend
- backend
db:
image: postgres
networks:
- backend
proxy:
image: traefik
networks:
- frontend
networks:
frontend:
driver: bridge
backend:
driver: bridge
internal: true # no external access
# custom subnet
networks:
backend:
ipam:
config:
- subnet: 172.28.0.0/16Docker Compose Fortgeschritten
Compose-Profiles
Profiles gruppieren optionale Services. Services ohne Profil starten immer; Profile-Services starten erst, wenn ihr Profil mit --profile aktiviert wird. So dient eine Compose-Datei für Dev, Test und Prod: Profile je Umgebung gezielt einschalten.
services:
web:
image: nginx
profiles: ["default", "prod"]
debug:
image: nginx
profiles: ["debug"]
ports:
- "8080:80"
test:
image: myapp-test
profiles: ["test"]
# start only default services
docker compose up -d
# start with the debug profile
docker compose --profile debug up -d
# run tests
docker compose --profile test run test
# start multiple profiles
docker compose --profile prod --profile debug up -dCompose-Overrides
Compose lädt docker-compose.override.yml automatisch auf docker-compose.yml für lokale Dev-Anpassungen. Für andere Umgebungen mehrere -f-Dateien in Reihenfolge übergeben — spätere Dateien überschreiben frühere. So trennt man Basiskonfiguration sauber von umgebungsspezifischen Anpassungen.
# docker-compose.yml (base)
services:
web:
image: myapp:latest
environment:
NODE_ENV: production
# docker-compose.override.yml (auto-loaded for dev)
services:
web:
build: ./app
environment:
NODE_ENV: development
DEBUG: "true"
volumes:
- ./src:/app/src
command: npm run dev
# explicit override file
docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d
# merge order: later files override earlier ones
# docker compose -f base.yml -f dev.yml -f local.yml upHealthchecks in Compose
Healthchecks in Compose spiegeln den Dockerfile-HEALTHCHECK. start_period gewährt Schonfrist beim Start. Die Kombination aus healthcheck und depends_on: condition: service_healthy lässt einen Service warten, bis seine Abhängigkeiten wirklich bereit sind — nicht nur gestartet.
services:
web:
image: nginx
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost"]
interval: 30s
timeout: 5s
retries: 3
start_period: 10s
db:
image: postgres
healthcheck:
test: ["CMD-SHELL", "pg_isready -U postgres"]
interval: 10s
timeout: 5s
retries: 5
app:
image: myapp
depends_on:
db:
condition: service_healthySkalierung & Replikas
--scale startet N identische Container auf einem Host — der Service darf keinen festen Host-Port binden (zufälligen Port oder kein Host-Mapping verwenden). Der Key deploy.replicas wird von Swarm beachtet; für plain Compose --scale verwenden. Ein Load Balancer steht vor skalierten Services.
# scale at startup (single host)
docker compose up -d --scale worker=4
# docker-compose.yml with replicas (Compose spec)
services:
worker:
image: myworker
deploy:
replicas: 4
resources:
limits:
cpus: "0.5"
memory: 512M
web:
image: nginx
deploy:
replicas: 2
update_config:
parallelism: 1
delay: 10s
# note: replicas deploy key is for Swarm;
# plain Compose uses --scale
# prevent port conflicts when scaling
docker compose up -d --scale web=3 # web must use random portsCompose-Konfiguration & Validierung
config validiert und rendert die zusammengeführte Compose-Datei (inkl. Overrides und .env-Substitution) — unschätzbar beim Debuggen. --services, --images und --volumes inventarisieren die Ressourcen. In CI mit -q fehlschlagen, sobald Compose-Dateien malformed sind.
# validate and print the merged compose file
docker compose config
# check for errors only
docker compose config -q
# list all services
docker compose config --services
# list all images used
docker compose config --images
# list all volumes
docker compose config --volumes
# render with variable substitution (resolve .env)
docker compose config > rendered.yml
# validate before deploying
docker compose config -q && docker compose up -dMehrere Compose-Dateien
Gestapelte Compose-Dateien trennen Belange: Basiskonfiguration, Umgebungs-Overrides, lokale Anpassungen. COMPOSE_FILE (durch Doppelpunkte getrennt unter Linux/Mac, Semikolon unter Windows) vermeidet das Wiederholen von -f. Listen wie ports werden angehängt; Maps wie environment per Key zusammengeführt.
# base, dev, and prod files
docker compose -f docker-compose.yml -f docker-compose.dev.yml up
docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d
# COMPOSE_FILE env var (avoids -f repetition)
export COMPOSE_FILE=docker-compose.yml:docker-compose.dev.yml
docker compose up -d
# docker-compose.prod.yml
services:
web:
image: registry.com/myapp:${TAG}
environment:
NODE_ENV: production
deploy:
replicas: 3
# difference files: add/override specific keys
# lists (ports, volumes) are merged; maps (environment) are mergedDocker Registry
Lokale Registry betreiben
Das Image registry:2 betreibt eine private Registry auf Port 5000. Ein Volume mounten, um Images zu persistieren. Für Remote-Hosts oder HTTPS TLS-Zertifikate konfigurieren oder die Registry in /etc/docker/daemon.json zu insecure-registries hinzufügen. Die v2-API erlaubt das Katalogisieren von Repositories via curl.
# run the official registry image
docker run -d -p 5000:5000 --name registry \
-v registrydata:/var/lib/registry \
--restart always \
registry:2
# tag and push to it
docker tag myapp:1.0 localhost:5000/myapp:1.0
docker push localhost:5000/myapp:1.0
# pull from it
docker pull localhost:5000/myapp:1.0
# list repositories in the registry
curl http://localhost:5000/v2/_catalog
# list tags for a repository
curl http://localhost:5000/v2/myapp/tags/listIn eine private Registry pushen
Images müssen vor dem Push mit dem Registry-Host getaggt sein. Bei Registries mit selbstsignierten Zertifikaten den Host zu insecure-registries hinzufügen und den Daemon neu starten (für Produktion nicht empfohlen — lieber eine echte CA oder interne CA). push -a lädt alle Tags des Repositories hoch.
# tag with the registry URL
docker tag myapp:1.0 registry.local:5000/myapp:1.0
# login
docker login registry.local:5000
# push
docker push registry.local:5000/myapp:1.0
# push all tags
docker push -a registry.local:5000/myapp
# verify it landed
curl http://registry.local:5000/v2/myapp/tags/list
# self-signed cert: configure the daemon
# /etc/docker/daemon.json:
# { "insecure-registries": ["registry.local:5000"] }
# then: systemctl restart dockerAus einer privaten Registry laden
Aus einer privaten Registry lädt man, indem man den vollständigen Image-Namen angibt. Login-Credentials liegen in ~/.docker/config.json (aus Sicherheitsgründen einen Credential-Helper verwenden). In CI/CD Credentials als Secrets speichern und vor dem Pull einloggen. Für reproduzierbare Deployments per Digest pinnen.
# login first (credentials cached in ~/.docker/config.json)
docker login registry.local:5000
# pull by full name
docker pull registry.local:5000/myapp:1.0
# pull by digest (immutable)
docker pull registry.local:5000/myapp@sha256:abc123...
# use in Compose
# services:
# web:
# image: registry.local:5000/myapp:1.0
# logout
docker logout registry.local:5000
# check stored credentials
cat ~/.docker/config.jsonRegistry-Authentifizierung
Eine Registry mit htpasswd-Basic-Auth oder einem Token-Server (OAuth) absichern. Für TLS Zertifikate mounten und auf 443 lauschen. Credential-Helfer (credsStore) speichern Passwörter im OS-Schlüsselbund statt in der Klartext-config.json — unverzichtbar auf geteilten oder CI-Maschinen.
# htpasswd-based auth
mkdir -p auth
docker run --entrypoint htpasswd httpd:2 -Bbn user password > auth/htpasswd
# run registry with auth
docker run -d -p 5000:5000 --name registry \
-v $(pwd)/auth:/auth \
-e REGISTRY_AUTH=htpasswd \
-e REGISTRY_AUTH_HTPASSWD_REALM=Registry \
-e REGISTRY_AUTH_HTPASSWD_PATH=/auth/htpasswd \
registry:2
# login now required
docker login localhost:5000
# token-based auth (OAuth, JWT) for enterprise
# configure REGISTRY_AUTH=token with an auth server
# credential helpers (avoid storing in config.json)
# "credsStore": "secretservice" (Linux)
# "credsStore": "osxkeychain" (Mac)
# "credsStore": "wincred" (Windows)Registry-API
Die Registry-HTTP-API v2 erlaubt skriptgesteuertes Registry-Management. _catalog listet Repos; manifests beschreiben Image-Layer. Löschen erfordert REGISTRY_STORAGE_DELETE_ENABLED=true und entfernt Manifeste — Blobs räumt die Garbage Collection auf (registry garbage-collect).
# list all repositories
curl http://localhost:5000/v2/_catalog
# list tags for a repo
curl http://localhost:5000/v2/myapp/tags/list
# get a manifest
curl -H "Accept: application/vnd.docker.distribution.manifest.v2+json" \
http://localhost:5000/v2/myapp/manifests/1.0
# delete a manifest (by digest)
curl -X DELETE \
http://localhost:5000/v2/myapp/manifests/sha256:abc123...
# enable delete API
# -e REGISTRY_STORAGE_DELETE_ENABLED=true
# check if a blob exists
curl -I http://localhost:5000/v2/myapp/blobs/sha256:abc...Garbage Collection
Das Löschen eines Manifests hinterlässt verwaiste Blobs, bis die Garbage Collection läuft. Die Registry stoppen (oder --dry-run verwenden), um keine genutzten Layer einzusammeln. In Produktion GC regelmäßig einplanen, um Speicher von gelöschten oder ersetzten Images zurückzugewinnen. Der Pfad config.yml ist die Konfigurationsdatei der Registry.
# run garbage collection on a registry
docker exec -it registry \
garbage-collect --dry-run /etc/docker/registry/config.yml
# actual collection (stop the registry first for consistency)
docker stop registry
docker run --rm -v registrydata:/var/lib/registry \
-v /path/config.yml:/etc/docker/registry/config.yml \
registry:2 garbage-collect /etc/docker/registry/config.yml
docker start registry
# delete unreferenced blobs after manifest deletion
# schedule GC as a cron job for production registries
# view disk usage
docker exec registry du -sh /var/lib/registryDocker Hub
Login & Logout
Access Tokens statt Passwörter bevorzugen — sie sind widerrufbar und im Umfang begrenzt. --password-stdin liest von stdin und hält das Passwort aus Shell-History und Prozesslisten. Einen Credential-Helper konfigurieren, um Credentials im OS-Schlüsselbund statt in der Klartext-config.json zu speichern.
# interactive login (prompts for username/password)
docker login
# login with a token (recommended over password)
docker login -u username -p dckr_pat_xxxxx
# login via stdin (avoids shell history)
echo "dckr_pat_xxxxx" | docker login -u username --password-stdin
# logout
docker logout
# credentials stored in ~/.docker/config.json
# or OS keychain via credential helper
# create an access token on Docker Hub
# Account Settings -> Security -> New Access TokenImages suchen
docker search fragt Docker Hub aus der CLI ab, mit Filtern für Stars, offiziellen Status und automatisierte Builds. Offizielle Images (library/nginx) sind von Docker geprüft — als Basis bevorzugen. Das Web-UI bietet reichhaltigere Filter nach OS, Architektur und Kategorie.
# search Docker Hub from the CLI
docker search nginx
# filter by stars
docker search --filter stars=100 nginx
# only official images
docker search --filter is-official nginx
# only automated builds
docker search --filter is-automated nginx
# limit results
docker search --limit 5 nginx
# show full description (no truncation)
docker search --no-trunc nginx
# search on the web for richer filtering
# https://hub.docker.com/search?q=nginxZu Docker Hub pushen
Images als username/repo:tag taggen, dann pushen, um auf Docker Hub zu publizieren. Das Repository entsteht automatisch beim ersten Push (standardmäßig öffentlich). push -a lädt alle Tags hoch. Free-Accounts bekommen ein privates Repo; Bezahlpläne mehr. Die Sichtbarkeit des Repositories im Hub-Web-UI einstellen.
# tag with your username
docker tag myapp:1.0 username/myapp:1.0
# also tag as latest
docker tag username/myapp:1.0 username/myapp:latest
# login
docker login
# push (creates the repo if it doesn't exist)
docker push username/myapp:1.0
docker push username/myapp:latest
# push all tags
docker push -a username/myapp
# make the repo private on Docker Hub
# (Hub web UI -> Repository -> Settings -> Make Private)Automatisierte Builds
Autobuilds von Docker Hub verknüpfen ein git-Repo und bauen bei jedem Push. Moderne Workflows bevorzugen GitHub Actions mit buildx und push — mehr Kontrolle, Caching und Multi-Arch-Builds. Hub-Autobuilds bleiben eine bequeme Option für einfache Projekte.
# connect a GitHub/Bitbucket repo to Docker Hub
# Hub web UI -> Create -> Build Rule
# build rule examples:
# Source: github.com/me/myapp Branch: main
# Dockerfile location: /Dockerfile
# Image tag: latest
# trigger a build via webhook
curl -H "Content-Type: application/json" \
--data '{"build": true}' \
https://hub.docker.com/api/build/v1/source/.../trigger/.../call/
# build context with multiple tags and stages
# Source: Branch main -> Tag: branch-main
# Source: Tag v1.0 -> Tag: 1.0, latest
# Autobuild triggers on git push
# (deprecated in favor of GitHub Actions)Organisation & Teams
Organisationen teilen Repositories im Team mit rollenbasierter Zugriffskontrolle. Teams bekommen Berechtigungen pro Repository (read, write, admin). Service-Accounts liefern nicht-persönliche Tokens für CI/CD — widerruf- und rotierbar ohne Auswirkung auf Einzelpersonen. Namespace orgname/repo verwenden.
# create an organization on Docker Hub
# (web UI: Create Organization)
# create a team and add members
# Org -> Teams -> Create Team -> Add Members
# assign repository permissions per team
# Repository -> Permissions -> Add Team
# Read-only, Read-write, Admin
# create a service account token for CI
# Org -> Service Accounts -> New Service Account
# use the token in CI: docker login -u tokenname -p token
# team namespaces: orgname/repo
docker tag myapp orgname/myapp:1.0
docker push orgname/myapp:1.0Image Trust (DCT)
Docker Content Trust (DCT) signiert Image-Tags mit Notary und stellt sicher, dass das geladene Image das vom Herausgeber gepushte ist. Aktivieren über DOCKER_CONTENT_TRUST=1. Mit DCT können nur signierte Images geladen oder gepusht werden. Signaturschlüssel sorgfältig verwalten — ihr Verlust kann Images unbrauchbar machen.
# enable Docker Content Trust (signing)
export DOCKER_CONTENT_TRUST=1
# push signs the image automatically
docker push username/myapp:1.0
# pull refuses unsigned images when DCT is on
docker pull username/myapp:1.0
# disable for a single command
DOCKER_CONTENT_TRUST=0 docker pull unsigned/myapp:1.0
# generate delegation keys
docker trust key generate alice
# add a signer to a repository
docker trust signer add --key alice.pub alice username/myapp
# view signatures
docker trust inspect username/myapp:1.0
# revoke and rotate keys via the notary CLIHealthcheck
Einfacher Healthcheck
Ein Healthcheck führt periodisch einen Befehl aus; exit 0 bedeutet healthy, nicht-null unhealthy. Der Container startet im Zustand 'starting' und wird nach erfolgreichen retries 'healthy' bzw. nach fehlgeschlagenen 'unhealthy'. start_period gibt Schonfrist beim Hochfahren. Der Healthzustand steuert Swarm-Restart-Entscheidungen.
# add a healthcheck at runtime
docker run -d --name web \
--health-cmd="curl -f http://localhost/ || exit 1" \
--health-interval=30s \
--health-timeout=5s \
--health-retries=3 \
--health-start-period=10s \
nginx
# check health status
docker inspect --format '{{.State.Health.Status}}' web
# view health check log (last 5 results)
docker inspect --format '{{json .State.Health.Log}}' web | jq
# states: starting | healthy | unhealthy | noneHealthcheck im Dockerfile
HEALTHCHECK im Dockerfile bäckt den Check ins Image. Den leichtesten Check verwenden, der bestätigt, dass die App tatsächlich ausliefert — curl -f oder wget --spider für HTTP, pg_isready für Postgres. HEALTHCHECK NONE deaktiviert einen geerbten Check. Zu breite Checks verursachen flatterndes 'unhealthy'.
FROM nginx:alpine
# basic healthcheck (exec form)
HEALTHCHECK --interval=30s --timeout=5s --retries=3 --start-period=10s \
CMD curl -f http://localhost/ || exit 1
# using wget (alpine)
HEALTHCHECK CMD wget --spider -q http://localhost/ || exit 1
# postgres ships a ready check
HEALTHCHECK CMD pg_isready -U postgres
# disable a healthcheck inherited from the base image
HEALTHCHECK NONE
# verify
docker inspect --format '{{.Config.Healthcheck}}' myappHealthcheck-Optionen
interval setzt die Prüffrequenz; timeout begrenzt jeden Check; retries ist die Schwelle aufeinanderfolgender Fehlschläge. start_period ignoriert Fehlschläge beim Hochfahren und verhindert falsches 'unhealthy' während der App warm wird. Diese Werte so abstimmen, dass echte Ausfälle schnell erkannt werden, ohne unter Last zu flattern.
# full set of options
HEALTHCHECK \
--interval=30s \ # time between checks (default 30s)
--timeout=5s \ # max time per check (default 30s)
--retries=3 \ # failures to mark unhealthy (default 3)
--start-period=30s \ # boot grace period (default 0s)
CMD curl -f http://localhost/
# interval: how often to run
# timeout: if a check exceeds this, it's a failure
# retries: consecutive failures before unhealthy
# start-period: failures during this don't count
# compose form
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost"]
interval: 30s
timeout: 5s
retries: 3
start_period: 30sHealth-Status inspizieren
ps zeigt (healthy)/(unhealthy) neben dem Status. Health.Log hält die Ausgaben der letzten 5 Checks fest — unbezahlbar, um zu verstehen, warum ein Check scheitert. Den Check-Befehl manuell per exec ausführen, um den tatsächlichen Fehler zu sehen. ps nach health filtern, um kranke Container schnell zu finden.
# current status
docker inspect --format '{{.State.Health.Status}}' web
# last 5 check results
docker inspect --format '{{range .State.Health.Log}}\
{{.ExitCode}} {{.Output}}{{end}}' web
# show in ps (status column shows (healthy)/(unhealthy))
docker ps
# filter containers by health
docker ps --filter "health=unhealthy"
# troubleshoot a failing check
docker inspect --format '{{json .State.Health.Log}}' web | jq
# run the check command manually
docker exec web curl -f http://localhost/Compose-Healthcheck
Der Compose-Healthcheck spiegelt den Dockerfile-Check. test akzeptiert ein Array (exec-Form) oder einen CMD-SHELL-String. disable: true entfernt einen geerbten Check. healthcheck mit depends_on: condition: service_healthy koppeln, damit ein Service wartet, bis Abhängigkeiten wirklich bereit sind — nicht nur gestartet.
services:
web:
image: nginx
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost"]
interval: 30s
timeout: 5s
retries: 3
start_period: 10s
db:
image: postgres
healthcheck:
test: ["CMD-SHELL", "pg_isready -U postgres"]
interval: 10s
retries: 5
app:
image: myapp
depends_on:
db:
condition: service_healthy
web:
condition: service_healthy
# disable a healthcheck
debug:
image: nginx
healthcheck:
disable: trueHealthcheck Best Practices
Einen echten /healthz-Endpoint prüfen, der kritische Abhängigkeiten (DB, Cache) verifiziert — ein reiner TCP-Check kann durchgehen, obwohl die App kaputt ist. Checks leichtgewichtig und schnell halten; sie laufen in jedem Intervall. start_period für langsam startende Runtimes (JVM, Rails) verwenden, damit sie beim Hochfahren nicht als unhealthy markiert werden.
# check the actual app endpoint, not just TCP
HEALTHCHECK CMD curl -f http://localhost/healthz || exit 1
# include a /healthz endpoint in your app
# that verifies DB and cache connectivity
# keep checks fast (under timeout)
HEALTHCHECK --timeout=3s CMD curl -f http://localhost/healthz
# avoid heavy checks — they run every interval
# don't run migrations or full DB queries
# use start-period for slow starters (Java, Rails)
HEALTHCHECK --start-period=60s CMD ...
# for Swarm, health enables auto-restart of unhealthy tasks
# combine with restart policies and update_config
# example app endpoint (Express)
# app.get('/healthz', (req, res) => res.send('ok'))Ressourcen-Limits
Memory-Limits
--memory setzt ein hartes Limit; Überschreitung löst den OOM-Kill aus. --memory-swap begrenzt Memory+Swap zusammen; gleiches Setzen wie memory deaktiviert Swap. --memory-reservation ist ein weicher Hinweis für den Kernel. Für latenzempfindliche Workloads Swap deaktivieren, um vorhersagbare Performance zu bekommen.
# limit to 512MB of memory
docker run -d --memory="512m" nginx
# memory + swap (swap = memory + swap allowance)
docker run -d --memory="512m" --memory-swap="1g" nginx
# soft limit (hint to the kernel, may be exceeded)
docker run -d --memory-reservation="256m" nginx
# disable swap (swap = memory, no extra)
docker run -d --memory="512m" --memory-swap="512m" nginx
# OOM behavior: kill the container (default)
docker run -d --memory="512m" --oom-kill-disable nginx
# verify limits
docker inspect --format '{{.HostConfig.Memory}}' <container>CPU-Limits
--cpus setzt das CPU-Limit als Anteil an Kernen (1.5 = 1,5 Kerne). --cpu-shares ist ein relatives Gewicht bei Ressourcenkonflikt, kein hartes Limit. --cpuset-cpus pinnt einen Container auf bestimmte Kerne — nützlich für Performance-Isolation. Quota/period ist die Low-Level-cgroup-Form.
# limit to 1 CPU (1.0 = one full core)
docker run -d --cpus="1.0" nginx
# limit to 1.5 CPUs
docker run -d --cpus="1.5" nginx
# CPU shares (relative weight, default 1024)
docker run -d --cpu-shares=512 nginx
# pin to specific CPU cores (0,1)
docker run -d --cpuset-cpus="0,1" nginx
# pin to cores 0-3
docker run -d --cpuset-cpus="0-3" nginx
# quota/period form (100000us per 100000us = 1 CPU)
docker run -d --cpu-quota=50000 --cpu-period=100000 nginxMemory- & Swap-Verhalten
memory-swap ist die Summe aus memory + swap. Gleich wie memory gesetzt, deaktiviert es Swap. -1 erlaubt unbegrenzten Swap. Swappiness (0-100) steuert die Neigung des Kernels zum Swappen; kleinere Werte halten Seiten lieber im RAM. Kernel-Memory-Limits sind fortgeschritten und selten nötig.
# memory limit, swap disabled
docker run -d -m 512m --memory-swap 512m nginx
# memory limit, 512m extra swap
docker run -d -m 512m --memory-swap 1g nginx
# unlimited swap (limited memory)
docker run -d -m 512m --memory-swap -1 nginx
# swappiness (0-100, lower = less swapping)
docker run -d -m 512m --memory-swappiness=10 nginx
# kernel memory limit (advanced, rarely needed)
docker run -d --kernel-memory="100m" nginx
# verify swap settings
docker inspect --format '{{.HostConfig.MemorySwap}}' <container>Ressourcen-Limits in Compose
deploy.resources.limits setzt harte Grenzen; reservations weiche Zusicherungen (für Scheduling verwendet). Swarm beachtet diese nativ. Für plain Compose (non-Swarm) top-level mem_limit und cpus im v2-Format verwenden. Reservations lassen einen Container auch im Leerlauf ein Minimum beanspruchen.
services:
web:
image: nginx
deploy:
resources:
limits:
cpus: "1.0"
memory: 512M
reservations:
cpus: "0.25"
memory: 256M
worker:
image: myworker
mem_swappiness: 10
memswap_limit: 1g
cpus: 2.0
# limits = hard caps; reservations = soft guarantees
# Swarm honors deploy.resources
# plain Compose: use top-level mem_limit, cpus (v2 compat)OOM- & Restart-Verhalten
Bei Memory-Erschöpfung wählt der Kernel-OOM-Killer ein Opfer. oom-kill-disable schützt einen Container, kann aber den Host zum Absturz bringen — nur mit Host-Memory-Limits verwenden. oom-score-adj beeinflusst die Auswahl: positiv = zuerst gekillt, negativ = geschützt. OOMKilled prüfen, um Restarts zu diagnostizieren.
# default: OOM kills the container, restart policy restarts it
docker run -d --memory=512m --restart unless-stopped nginx
# disable OOM kill for this container (risky)
docker run -d --memory=512m --oom-kill-disable nginx
# set OOM score adjustment (higher = killed first)
docker run -d --oom-score-adj=500 nginx
# protect a critical container (killed last)
docker run -d --oom-score-adj=-500 nginx
# verify restart count
docker inspect --format '{{.RestartCount}}' <container>
# check if OOM-killed
docker inspect --format '{{.State.OOMKilled}}' <container>Ressourcenverbrauch inspizieren
docker stats streamt live CPU, Memory, Netzwerk und Disk-IO pro Container — erste Wahl für schnelle Diagnose. --no-stream liefert einen einzelnen Snapshot für Skripte. Für tiefere Analyse /sys/fs/cgroup auslesen oder Prometheus-Metriken über cAdvisor exponieren. Verbrauch mit Limits vergleichen, um richtig zu dimensionieren.
# live resource stats (CPU, memory, network, IO)
docker stats
# specific container
docker stats web
# one snapshot (no streaming)
docker stats --no-stream
# custom format
docker stats --format "table {{.Name}} {{.CPUPerc}} {{.MemUsage}}"
# container cgroup details
docker exec web cat /sys/fs/cgroup/memory/memory.usage_in_bytes
docker exec web cat /sys/fs/cgroup/cpu/cpu.stat
# inspect configured limits
docker inspect --format '{{.HostConfig.Memory}} {{.HostConfig.NanoCpus}}' webSicherheit
Nicht-root-Benutzer
Ausführen ohne root begrenzt den Schaden, falls die App kompromittiert wird. Im Dockerfile einen eigenen Benutzer anlegen und mit USER dorthin wechseln. Muss man einen privilegierten Port binden, einen Reverse-Proxy (nginx) verwenden oder die Capability NET_BIND_SERVICE gewähren statt als root zu laufen.
# Dockerfile: create and use a non-root user
FROM node:20-alpine
RUN addgroup -S app && adduser -S app -G app
USER app
WORKDIR /app
COPY --chown=app:app . .
CMD ["node", "server.js"]
# at runtime, override the user
docker run -u 1000:1000 myapp
# verify the current user
docker exec web id
# bind to privileged ports? Use capabilities or a reverse proxy
# non-root cannot bind to ports < 1024 without NET_BIND_SERVICE
# distroless images ship a non-root user by default
FROM gcr.io/distroless/nodejs20
USER nonrootSchreibgeschütztes Root-Dateisystem
Ein schreibgeschütztes Root-Dateisystem verhindert, dass Angreifer bei einer Kompromittierung Malware schreiben oder Konfigurationen ändern. Mit tmpfs für Scratch-Verzeichnisse (/tmp, /cache) und Volumes für persistente Daten kombinieren. Apps müssen dafür ausgelegt sein — manche Frameworks schreiben an unerwartete Pfade und brauchen tmpfs-Mounts.
# make the root filesystem read-only
docker run --read-only nginx
# allow writes only to specific dirs via tmpfs
docker run --read-only --tmpfs /tmp --tmpfs /var/cache nginx
# combine with a writable volume for persistent data
docker run --read-only -v appdata:/data --tmpfs /tmp myapp
# compose form
services:
web:
image: nginx
read_only: true
tmpfs:
- /tmp
- /var/cache/nginx
# apps must be designed to not write outside allowed pathsLinux-Capabilities
Standardmäßig gewährt Docker eine eingeschränkte Menge an Linux-Capabilities. ALL droppen und nur das zurückgeben, was die App braucht — das Prinzip der geringsten Privilegien. --privileged gewährt alle Capabilities und Host-Gerätezugriff; außer für vertrauenswürdige Container-Runtimes komplett vermeiden. NET_RAW standardmäßig droppen.
# drop all capabilities, add only what's needed
docker run --cap-drop=ALL --cap-add=NET_BIND_SERVICE nginx
# add a specific capability
docker run --cap-add=SYS_PTRACE myapp
# common capabilities to drop (rarely needed by apps)
# CHOWN, DAC_OVERRIDE, FOWNER, KILL, NET_RAW, SETGID, SETUID
# NET_RAW is often safe to drop (prevents raw sockets/ping)
docker run --cap-drop=NET_RAW myapp
# privileged = all capabilities + host access (AVOID)
docker run --privileged myapp # DANGEROUS
# inspect capabilities
docker inspect --format '{{json .HostConfig.CapAdd}}' <container>Seccomp & AppArmor
Seccomp filtert, welche Syscalls ein Container ausführen darf — das Standardprofil blockiert ~44 gefährliche Syscalls. AppArmor beschränkt Datei- und Capability-Zugriff. no-new-privileges verhindert, dass setuid-Binaries neue Privilegien verleihen — eine günstige, hochwirksame Härtung für jeden Container.
# default seccomp profile blocks dangerous syscalls
docker run --security-opt seccomp=default.json nginx
# custom seccomp profile
docker run --security-opt seccomp=/path/to/profile.json nginx
# disable seccomp (NOT recommended)
docker run --security-opt seccomp=unconfined nginx
# AppArmor profile
docker run --security-opt apparmor=docker-default nginx
# custom AppArmor profile
docker run --security-opt apparmor=myprofile nginx
# no-new-privileges (prevents setuid escalation)
docker run --security-opt no-new-privileges nginxImage-Scanning
Images vor dem Push auf bekannte Schwachstellen (CVEs) scannen. docker scout (ehemals das snyk-basierte docker scan) ist eingebaut. Trivy und Grype sind beliebte Alternativen. Scanning in CI integrieren, um Images mit hochkritischen CVEs zu blockieren. Basis-Images periodisch neu scannen, wenn neue CVEs veröffentlicht werden.
# docker scout (built-in, replaces docker scan)
docker scout cves myapp:1.0
# scan a local image
docker scout cves --format json myapp:1.0
# compare two images
docker scout compare myapp:1.0 --to myapp:1.1
# Trivy (third-party, popular)
trivy image myapp:1.0
# Grype (third-party)
grype myapp:1.0
# scan a Dockerfile for bad practices
docker scout policy myapp --only-stream-default
# integrate scanning in CI
# - build image
# - scan
# - fail the pipeline on HIGH/CRITICAL CVEsDocker Content Trust & Härtung
Content Trust stellt sicher, dass man signierte Images lädt. Den Daemon härten: Container-zu-Container-Kommunikation deaktivieren (icc=false), live-restore aktivieren, damit Container Daemon-Restarts überleben, und User-Namespaces aktivieren (userns-remap), um Container-root auf eine Nicht-root-Host-UID abzubilden — für stärkere Isolation.
# enable content trust (image signing)
export DOCKER_CONTENT_TRUST=1
docker pull myapp:1.0 # refuses unsigned
# sign on push
docker push myapp:1.0 # signs with your key
# daemon hardening in /etc/docker/daemon.json
# {
# "userland-proxy": false,
# "live-restore": true,
# "no-new-privileges": true,
# "icc": false # disable inter-container communication on default bridge
# }
# restrict registry access
# "registry-mirrors": [],
# "insecure-registries": []
# audit the daemon
docker info --format '{{json .SecurityOptions}}'
# use user namespaces for host UID isolation
# /etc/docker/daemon.json: "userns-remap": "default"Logging & Monitoring
Logs ansehen
docker logs liest stdout/stderr, wie sie der Logging-Treiber erfasst hat. Apps sollten nach stdout loggen — nicht in Dateien — damit docker logs funktioniert. --tail und --since begrenzen die Ausgabe. Compose logs aggregiert über Services hinweg. Der Standard-Treiber json-file wächst unbegrenzt, wenn man ihn nicht begrenzt.
# follow logs
docker logs -f web
# last 100 lines
docker logs --tail 100 web
# since a timestamp
docker logs --since 30m web
# with timestamps
docker logs -t web
# a specific time range
docker logs --since 1h --until 30m web
# write logs to a file
docker logs web > web.log 2>&1
# logs for all containers (compose)
docker compose logs -f
docker compose logs -f web dbLog-Treiber
Der json-file-Treiber wächst ohne Rotation unbegrenzt — max-size und max-file setzen, um Plattenerschöpfung zu verhindern. In Produktion Logs an ein zentrales System liefern (fluentd, splunk, awslogs, gelf). In daemon.json einen globalen Standard setzen, damit jeder Container standardmäßig rotiert.
# default: json-file
docker run -d --log-driver=json-file nginx
# cap log size and rotate (json-file)
docker run -d \
--log-driver=json-file \
--log-opt max-size=10m \
--log-opt max-file=3 \
nginx
# syslog
docker run -d --log-driver=syslog nginx
# journald
docker run -d --log-driver=journald nginx
# fluentd / splunk / gelf / awslogs
docker run -d --log-driver=fluentd nginx
# global default in /etc/docker/daemon.json
# { "log-driver": "json-file",
# "log-opts": { "max-size": "10m", "max-file": "3" } }Log-Tagging & Attribute
Das tag-Template passt Log-Identifikatoren an — {{.Name}} erzeugt lesbare Containernamen statt abgeschnittener IDs. Für fluentd/splunk werden Labels und Env-Variablen an Log-Datensätze angehängt und ermöglichen Filterung. Daemon-weite Tag-Templates setzen, damit alle Container konsistent getaggt sind.
# tag logs with container name instead of ID
docker run -d \
--log-driver=json-file \
--log-opt tag="{{.Name}}" \
nginx
# tag with image name and tag
--log-opt tag="{{.ImageName}}/{{.Name}}"
# fluentd: add labels and attributes
docker run -d \
--log-driver=fluentd \
--log-opt fluentd-address=localhost:24224 \
--log-opt tag="docker.{{.Name}}" \
--log-opt labels=app,env \
--label app=web --label env=prod \
nginx
# syslog with facility
docker run -d --log-driver=syslog \
--log-opt syslog-facility=daemon nginxStats & Ressourcen-Monitoring
stats streamt CPU, Memory, Netzwerk und Block-IO. docker events ist ein Echtzeit-Stream von Daemon-Ereignissen — nützlich für Alerting-Skripte. docker top zeigt Prozesse im Container; docker diff zeigt Dateisystem-Änderungen (A=hinzugefügt, C=geändert, D=gelöscht) seit Image-Erstellung.
# live stats for all containers
docker stats
# specific container, one snapshot
docker stats --no-stream web
# custom format
docker stats --format "table {{.Name}} {{.CPUPerc}} {{.MemUsage}} {{.NetIO}}"
# events stream (start, stop, die, etc.)
docker events
# filter events
docker events --filter type=container --filter event=die
# container process list (like top)
docker top web
# container file changes since creation
docker diff webDocker Events
docker events ist ein Echtzeit-Stream von Lifecycle-Ereignissen: create, start, stop, pause, die, destroy, dazu Image- und Netzwerk-Events. Nach Typ, Event oder Container filtern. Die Grundlage für Alerting-Skripte, die auf Container-Tode reagieren oder ausgefallene Services automatisch neu starten.
# stream all events
docker events
# container events only
docker events --filter type=container
# specific event types
docker events --filter event=start --filter event=die
# events for a specific container
docker events --filter container=web
# events since a timestamp
docker events --since 1h
# format output
docker events --format '{{.Time}} {{.Action}} {{.Actor.Attributes.name}}'
# pipe to a monitoring script
docker events --filter event=die | while read event; do
echo "Container died: $event"
donePrometheus- & Grafana-Stack
cAdvisor exponiert Container-Metriken (CPU, Memory, Netzwerk, Dateisystem) im Prometheus-Format. Prometheus sammelt und speichert sie; Grafana visualisiert. Das de-facto Open-Source-Monitoring-Stack für Docker. node-exporter für Host-Metriken und alertmanager für Alerting ergänzen.
# run cAdvisor (container metrics exporter)
docker run -d --name cadvisor \
-v /:/rootfs:ro -v /var/run:/var/run:ro \
-v /sys:/sys:ro -v /var/lib/docker/:/var/lib/docker:ro \
-p 8080:8080 gcr.io/cadvisor/cadvisor
# run Prometheus
docker run -d -p 9090:9090 \
-v ./prometheus.yml:/etc/prometheus/prometheus.yml \
prom/prometheus
# run Grafana
docker run -d -p 3000:3000 grafana/grafana
# scrape cAdvisor in prometheus.yml
# scrape_configs:
# - job_name: cadvisor
# static_configs:
# - targets: ['cadvisor:8080']
# view dashboards in Grafana at http://localhost:3000Docker Swarm
Swarm initialisieren
swarm init macht einen Docker-Host zum Swarm-Manager. Das Join-Token lässt Worker und weitere Manager beitreten. Manager-Tokens geheim halten — sie können den Cluster steuern. Ungerade Anzahl an Managern betreiben (3 oder 5) für Raft-Konsens-Toleranz. Worker führen Tasks aus; Manager planen sie ein.
# initialize a Swarm (this node becomes a manager)
docker swarm init --advertise-addr 10.0.0.5
# get a join token for workers
docker swarm join-token worker
# get a join token for managers
docker swarm join-token manager
# on a worker node
docker swarm join --token SWMTKN-... 10.0.0.5:2377
# list nodes
docker node ls
# promote a worker to manager
docker node promote <node>
# demote a manager
docker node demote <node>
# leave the Swarm (worker)
docker swarm leaveServices deployen
Services sind die Swarm-Abstraktion über Containern. Ein replizierter Service führt N identische Tasks aus; ein globaler Service eine Task pro Knoten. update rollt standardmäßig mit null Downtime ein neues Image aus. scale ändert die Replika-Zahl live. Swarm plant neu, wenn ein Knoten ausfällt.
# deploy a service
docker service create --name web -p 80:80 nginx
# with replicas
docker service create --name web --replicas 3 -p 80:80 nginx
# with a constraint (e.g. only on worker nodes)
docker service create --name web --replicas 3 \
--constraint node.role==worker nginx
# with a global service (one per node)
docker service create --name log --mode global fluentd
# update the image
docker service update --image nginx:1.25 web
# scale a service
docker service scale web=5
# remove a service
docker service rm webSkalierung & Updates
scale ändert die Replika-Zahl sofort. update macht Rolling-Updates — parallelism steuert, wie viele Tasks gleichzeitig aktualisiert werden, delay staffelt sie, und failure-action=rollback kehrt bei Fehlern automatisch zurück. Swarm hält alte Tasks laufen, bis neue healthy sind — so gelingen Zero-Downtime-Deployments.
# scale up
docker service scale web=10
# scale multiple services
docker service scale web=5 worker=8
# rolling update
docker service update --image myapp:2.0 web
# update with parallelism and delay
docker service update \
--image myapp:2.0 \
--update-parallelism 2 \
--update-delay 30s \
--update-failure-action rollback \
web
# environment or port update without redeploy
docker service update --env-add DEBUG=true web
docker service update --publish-rm 80:80 --publish-add 8080:80 web
# rollback to previous version
docker service rollback webStack-Deployment
Ein Stack ist eine für Swarm deployed Compose-Datei. Der deploy:-Key konfiguriert Replikas, Update-/Rollback-Policies, Platzierungs-Constraints und Ressourcen — alles Swarm-spezifisch. docker stack deploy wendet die Spezifikation deklarativ an. Stacks gruppieren zugehörige Services, Netzwerke und Secrets.
# docker-compose.yml as a Swarm stack
docker stack deploy -c docker-compose.yml mystack
# the compose file uses deploy: for Swarm config
services:
web:
image: nginx
deploy:
replicas: 3
update_config:
parallelism: 1
delay: 10s
restart_policy:
condition: on-failure
placement:
constraints: [node.role == worker]
ports:
- "80:80"
# list stacks and services
docker stack ls
docker stack services mystack
# remove a stack
docker stack rm mystackNode-Verwaltung
Vor Wartung einen Knoten drainen, damit seine Tasks sanft anderweitig eingeplant werden. active/pause/drain steuern das Scheduling. Labels ermöglichen Platzierungs-Constraints (z. B. DB nur auf Knoten mit tier=db). Knoten erst entfernen, wenn er mit docker swarm leave den Swarm verlassen hat.
# list nodes
docker node ls
# node details (status, role, labels, resources)
docker node inspect <node>
# drain a node (reschedule tasks off it, for maintenance)
docker node update --availability drain <node>
# activate a drained node
docker node update --availability active <node>
# pause a node (no new tasks, existing stay)
docker node update --availability pause <node>
# add a label (for placement constraints)
docker node update --label-add tier=db <node>
# remove a node from the Swarm
docker node rm <node>
# (node must have left via 'docker swarm leave' first)Secrets & Configs
Secrets sind im Ruhezustand und in Transit verschlüsselt, werden als Dateien unter /run/secrets gemountet und landen nie in Image-Layern oder Env-Variablen. Sie sind unveränderlich — zum Rotieren ein neues Secret anlegen und den Service aktualisieren. Configs ähneln ihnen, sind aber für nicht-sensible Daten wie Konfigurationsdateien. Beide nur in Swarm.
# create a secret from a file
docker secret create db_password ./db_password.txt
# create from stdin
echo "supersecret" | docker secret create db_password -
# use in a service
docker service create --name app --secret db_password myapp
# read in the app
# cat /run/secrets/db_password
# update a secret (immutable — create a new one)
echo "newsecret" | docker secret create db_password_v2 -
docker service update --secret-rm db_password --secret-add source=db_password_v2 app
# configs (non-sensitive, e.g. nginx.conf)
echo "server {...}" | docker config create nginx_conf -
docker service create --config nginx_conf nginx
# list and remove
docker secret ls
docker config lsVerwandte Docker-Snippets
Copy-paste ready code for common tasks.
Run a Container
Run, list, stop, and remove Docker containers.
Writing a Dockerfile
Build an image from a Dockerfile with multi-instruction layers.
Image Management
Pull, list, tag, push, and prune images.
Volumes & Bind Mounts
Persist data with named volumes, anonymous volumes, and bind mounts.
Networking
Create networks, attach containers, and expose ports.
Docker Compose
Define and run multi-container apps with compose.
Multi-Stage Build
Build artifacts in one stage and copy them into a slim final image.
Exec & Logs
Run commands inside running containers and inspect logs.
Was this helpful?