Skip to content

Docker Spickzettel

Plattform zum Entwickeln, Ausliefern und Betreiben von Anwendungen in Containern.

01

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).

docker
# 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 images

Container-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.

docker
# 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 web

Image-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.

docker
# 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:latest

Systeminformationen

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
# 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.

docker
# 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 --volumes

Hilfe 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.

docker
# 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/
02

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.

docker
# 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 nginx

Images 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.

docker
# 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.

docker
# 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:pinned

Images 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.

docker
# 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 logout

Images 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.

docker
# 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:latest

Images 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.

docker
# 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.gz
03

Container-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.

docker
# 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 nginx

Befehle 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.

docker
# 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/marker

Logs 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).

docker
# 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 web

Container 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.

docker
# 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}}' web

Starten, 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.

docker
# 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 web

Dateien 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.

docker
# 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.gz
04

Dockerfile-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.

docker
# 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 final

RUN — 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.

docker
# 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.gz

COPY & 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.

docker
# 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.

docker
# 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 RUN

USER

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.

docker
# 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.

docker
# .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.db
05

Dockerfile 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.

docker
# 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.

docker
# 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.

docker
# 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.

docker
# 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}}' myapp

LABEL & 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.

docker
# 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.

docker
# 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 /config
06

Multi-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.

docker
# 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.

docker
# 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.

docker
# 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.

docker
# 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 runtime

Aus 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.

docker
# 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 /app

BuildKit-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.

docker
# 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
EOF
07

Volumes

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.

docker
# 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 mydata

Volumes 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.

docker
# 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 mydata

Volume-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.

docker
# 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 ebsvol

Volumes 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.

docker
# 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 /data

Volumes 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.

docker
# 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 mydata

Volumes 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.

docker
# 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/msg
08

Bind-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.

docker
# 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:/app

Schreibgeschü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.

docker
# 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 fail

Entwicklungs-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.

docker
# 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 start

SELinux- & 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.

docker
# 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 myapp

Mount 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.

docker
# 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 nginx

Bind-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
# 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: true
09

Netzwerk

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.

docker
# 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 apps

Host-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.

docker
# 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 myapp

Overlay-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.

docker
# 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 container

Eigene 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.

docker
# 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 mymacvlan

Container-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.

docker
# 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.

docker
# 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 prune
10

Port-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.

docker
# 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 nginx

An 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.

docker
# 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.

docker
# 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.

docker
# 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.

docker
# 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}}' nginx

Zufä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.

docker
# 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 80
11

Umgebungsvariablen

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.

docker
# 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 mysql

Env-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.

docker
# .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 myapp

Env-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.

docker
# 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=true

Dynamische 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.

docker
# 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
# 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=mydb

Secrets-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
# 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 recommended
12

Docker 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
# 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 -d

Compose-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.

docker
# 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 migrate

Service-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.

docker
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_successfully

Build 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.

docker
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 --build

Volumes 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.

docker
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,rw

Netzwerke 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.

docker
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/16
13

Docker 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.

docker
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 -d

Compose-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
# 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 up

Healthchecks 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.

docker
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_healthy

Skalierung & 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.

docker
# 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 ports

Compose-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.

docker
# 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 -d

Mehrere 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.

docker
# 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 merged
14

Docker 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.

docker
# 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/list

In 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.

docker
# 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 docker

Aus 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.

docker
# 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.json

Registry-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.

docker
# 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).

docker
# 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.

docker
# 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/registry
15

Docker 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.

docker
# 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 Token

Images 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.

docker
# 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=nginx

Zu 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.

docker
# 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.

docker
# 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.

docker
# 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.0

Image 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.

docker
# 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 CLI
16

Healthcheck

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.

docker
# 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 | none

Healthcheck 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'.

docker
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}}' myapp

Healthcheck-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.

docker
# 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: 30s

Health-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.

docker
# 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.

docker
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: true

Healthcheck 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.

docker
# 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'))
17

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.

docker
# 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.

docker
# 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 nginx

Memory- & 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.

docker
# 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.

docker
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.

docker
# 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.

docker
# 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}}' web
18

Sicherheit

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.

docker
# 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 nonroot

Schreibgeschü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.

docker
# 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 paths

Linux-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.

docker
# 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.

docker
# 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 nginx

Image-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
# 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 CVEs

Docker 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.

docker
# 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"
19

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.

docker
# 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 db

Log-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.

docker
# 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.

docker
# 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 nginx

Stats & 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.

docker
# 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 web

Docker 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.

docker
# 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"
done

Prometheus- & 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.

docker
# 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:3000
20

Docker 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.

docker
# 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 leave

Services 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.

docker
# 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 web

Skalierung & 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.

docker
# 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 web

Stack-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
# 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 mystack

Node-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.

docker
# 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.

docker
# 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 ls

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.