Démarrage
Commandes de base
docker run crée et démarre un conteneur. -d exécute en arrière-plan, -p mappe un port hôte à un port conteneur. pull télécharge des images depuis un registre (Docker Hub par défaut).
# 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 imagesCycle de vie du conteneur
create + start est ce que run fait sous le capot. stop envoie SIGTERM pour un arrêt gracieux ; kill envoie SIGKILL immédiatement. pause emploie le freezer cgroup — utile pour des instantanés sans arrêter le processus.
# 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 webBases des images
Les images sont des couches en lecture seule. rmi échoue si un conteneur référence encore l'image — retirez d'abord le conteneur. history montre chaque instruction ayant créé une couche et sa taille, utile pour optimiser les builds.
# list local images
docker images
docker image ls
# remove an image
docker rmi nginx:latest
docker image rm nginx
# remove all dangling (untagged) images
docker image prune
# remove all unused images
docker image prune -a
# show image history (each layer)
docker history nginx:latestInformations système
docker info montre la config du daemon : driver de stockage, runtime, registres, état swarm. system df révèle l'espace récupérable — images suspendues et conteneurs arrêtés gaspillent du disque. Le flag --format emploie des templates Go pour une sortie structurée.
# 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}}'Nettoyage et prune
prune retire en sécurité les ressources arrêtées/suspendues. system prune -a retire aussi les images non référencées par aucun conteneur. Ajouter --volumes supprime les volumes non employés par aucun conteneur — perte de données irréversible, à employer avec prudence en production.
# 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 --volumesObtenir de l'aide
Docker regroupe les commandes en namespaces de gestion (docker image, docker container, docker network, docker volume). Les formes anciennes (docker rmi) et nouvelles (docker image rm) fonctionnent toutes deux. --help sur toute sous-commande montre les flags et l'usage.
# 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/Gestion des images
Tirer des images
Les tags sont des étiquettes mutables — le même tag peut pointer vers des images différentes au fil du temps. Pour des déploiements reproductibles, épinglez par digest (@sha256:...). Tirer par --platform permet de récupérer une image d'une autre architecture, utile pour des builds ARM sur hôtes x86.
# 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 nginxConstruire des images
Le . final est le contexte de build — les fichiers envoyés au daemon. Gardez-le petit avec .dockerignore pour accélérer les builds. --no-cache force des couches fraîches pendant le débogage. BuildKit active le cache multi-étapes, les montages SSH et le montage de secrets.
# build from Dockerfile in current dir, tag it
docker build -t myapp:1.0 .
# build with a different Dockerfile name
docker build -f Dockerfile.prod -t myapp:prod .
# build with build args
docker build --build-arg VERSION=1.2.3 -t myapp .
# build with no cache
docker build --no-cache -t myapp .
# build for a different platform
docker build --platform linux/arm64 -t myapp:arm .
# build using BuildKit (advanced features)
DOCKER_BUILDKIT=1 docker build -t myapp .Étiqueter des images
Les tags sont des alias pointant vers le même ID d'image. Un workflow courant construit avec un tag de version puis ajoute les tags latest et version majeure. Étiqueter avec une URL de registre prépare l'image à un push vers ce registre.
# 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:pinnedPousser des images
Il faut étiqueter l'image avec la destination du registre avant de pousser. push n'envoie que les couches déjà absentes du registre. Pour des registres privés à certificats auto-signés, configurez le daemon dans /etc/docker/daemon.json avec insecure-registries.
# login to Docker Hub
docker login
# login to a private registry
docker login registry.local:5000 -u user -p pass
# push to Docker Hub
docker push username/myapp:1.0
# push all tags in a repository
docker push -a username/myapp
# push to private registry
docker push registry.local:5000/myapp:1.0
# logout when done
docker logoutInspecter les images
inspect renvoie un JSON détaillé : architecture, OS, couches, env, entrypoint, config. history révèle la commande et la taille de chaque couche — le fondement de l'optimisation d'images. manifest inspect vérifie un registre distant sans tirer.
# 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:latestSauvegarder et charger des images
save/load préserve les couches et l'historique de l'image — le bon choix pour transférer des images hors ligne. export/import aplatit en une seule couche, perdant l'historique. Pour un transfert en ligne, préférez push/pull de registre aux fichiers tar.
# 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.gzGestion des conteneurs
Exécuter des conteneurs
-it combine -i (garder stdin ouvert) et -t (allouer un tty) pour des sessions interactives. --rm nettoie à la sortie — idéal pour des commandes ponctuelles. --restart unless-stopped survit aux redémarrages mais respecte les arrêts manuels.
# 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 nginxExécuter des commandes (exec)
exec lance un nouveau processus dans un conteneur déjà en marche — l'entrypoint d'origine continue de tourner. Employez-le pour le débogage, les tâches d'admin ou des scripts ponctuels. L'utilisateur par défaut est le USER de l'image ; surchargez avec -u.
# 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/markerVoir les logs
logs montre le stdout/stderr capté par le driver de logging du conteneur. Les applications devraient logger sur stdout, pas dans des fichiers, pour s'intégrer à docker logs. --since/--until acceptent des horodatages RFC3339 ou des durées Go (30m, 2h).
# follow (tail) logs
docker logs -f web
# show last 100 lines
docker logs --tail 100 web
# show logs since a timestamp
docker logs --since 2024-01-01T00:00:00 web
# show logs from the last 30 minutes
docker logs --since 30m web
# add timestamps to each line
docker logs -t web
# show logs for a specific timeframe
docker logs --since 10m --until 5m webInspection du conteneur
inspect renvoie un JSON riche couvrant config, état, réseau et montages. Les templates Go extraient des champs précis — extrêmement utile pour les scripts. LogPath révèle où le driver json-file stocke les logs sur l'hôte.
# 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}}' webDémarrer, arrêter et redémarrer
start reprend un conteneur arrêté avec sa config d'origine. update modifie les contraintes et la politique de redémarrage d'un conteneur en cours sans le recréer — utile pour resserrer les limites de ressources en production.
# 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 webCopier des fichiers
cp fonctionne dans les deux sens et sur les conteneurs arrêtés — pratique pour injecter des correctifs à chaud ou extraire des logs. Il n'est pas conçu pour une sync à haute fréquence ; employez un bind mount ou un volume pour les workflows de développement. L'astuce tar+exec diffuse efficacement de grands arbres.
# 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.gzBases du Dockerfile
FROM — image de base
FROM est la première instruction et définit la couche de base. Choisissez des bases minimales (alpine, distroless, scratch) pour réduire la surface d'attaque et la taille. Épingler par digest garantit des builds reproductibles puisque les tags peuvent changer.
# use an official base image
FROM ubuntu:22.04
# pin a specific digest for reproducibility
FROM ubuntu@sha256:abc123def...
# multi-arch build (buildx picks the host arch)
FROM --platform=$BUILDPLATFORM golang:1.21 AS builder
# use a minimal image
FROM alpine:3.18
# scratch = empty image, for static binaries
FROM scratch
# use a previous build stage
FROM builder AS finalRUN — exécuter des commandes
Chaque RUN crée une couche. Combinez les commandes liées avec && et nettoyez dans la même couche pour garder les images petites. La forme exec (tableau JSON) n'invoque pas de shell, donc pas d'expansion de variables ni d'enchaînement — mais elle traite correctement les signaux.
# install packages
RUN apt-get update && apt-get install -y curl
# clean up in the same layer to reduce size
RUN apt-get update && apt-get install -y --no-install-recommends curl \
&& rm -rf /var/lib/apt/lists/*
# combine commands with && to reduce layers
RUN mkdir -p /app/config && chown 1000:1000 /app/config
# use exec form (preferred) to ensure signals
RUN ["npm", "install"]
# use a shell for variables and chaining
RUN VERSION=1.0 && wget https://example.com/v${VERSION}.tar.gzCOPY et ADD
COPY est préféré pour les fichiers locaux — explicite et prévisible. ADD ajoute de la magie : récupération d'URL et extraction automatique des archives tar/zip. Cette magie peut surprendre ; recourez à ADD seulement pour l'extraction. Les deux créent une couche.
# 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 fixe le répertoire de travail des instructions suivantes et le défaut du conteneur. Il crée le répertoire s'il manque. Préférez toujours WORKDIR à cd dans RUN — cd ne persiste pas entre les couches. Employez des chemins absolus pour la clarté.
# set the working directory
WORKDIR /usr/src/app
# subsequent RUN, CMD, COPY use this dir
COPY . .
RUN npm install
# WORKDIR creates the directory if it does not exist
WORKDIR /opt/data/logs
# use a relative path (relative to previous WORKDIR)
WORKDIR sub
# avoid this anti-pattern (use absolute paths)
WORKDIR /app
RUN cd /app && do_something # cd is lost after RUNUSER
USER fixe l'utilisateur (et éventuellement le groupe) pour RUN, CMD et ENTRYPOINT. Tourner hors root est une bonne pratique de sécurité clé. L'utilisateur doit exister dans l'image. Les UIDs numériques sont portables entre images et évitent les problèmes de résolution de nom.
# 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 réduit le contexte de build envoyé au daemon — builds plus rapides, contexte plus petit, et empêche des secrets comme .env de fuiter dans les couches de l'image. Syntaxe semblable à .gitignore. Excluez toujours node_modules et les artefacts de build recréés pendant le build.
# .dockerignore — exclude files from the build context
# version control
.git
.gitignore
# dependencies (fetched inside the image)
node_modules
npm-debug.log
# build artifacts
dist
build
*.log
# local env files (NEVER bake secrets)
.env
.env.local
# docker files themselves
Dockerfile
docker-compose*.yml
# OS files
.DS_Store
Thumbs.dbDockerfile avancé
CMD vs ENTRYPOINT
ENTRYPOINT définit l'exécutable ; CMD fournit des arguments par défaut surchargeables. Employez la forme exec (tableau JSON) pour que le processus reçoive directement les signaux — la forme shell enveloppe la commande dans /bin/sh -c, cassant l'arrêt gracieux. Pattern courant : script en ENTRYPOINT + args par défaut en CMD.
# 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 — variables d'environnement
ENV crée des variables au niveau image, visibles au build et à l'exécution. Employez ARG pour les valeurs propres au build afin d'éviter de fuiter la config dans l'image finale. Dans les CMD/ENTRYPOINT en forme exec, ${VAR} n'est pas développé par le shell — enveloppez avec sh -c pour développer.
# 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 — arguments de build
Les valeurs ARG n'existent que pendant le build de l'étape qui les déclare. Elles ne persistent pas dans le conteneur d'exécution — employez ENV pour porter une valeur vers l'exécution. Les ARG déclarés avant FROM sont « globaux » mais doivent être re-déclarés dans chaque étape pour y être employés.
# 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 est de la documentation — il ne publie pas de ports. La publication se fait avec -p (hôte:conteneur) à l'exécution ou ports: dans Compose. EXPOSE aide les outils à comprendre les ports prévus et active le lien automatique dans les réseaux anciens.
# document which port the container listens on
EXPOSE 80
# expose multiple ports
EXPOSE 80 443
# expose with protocol
EXPOSE 53/udp
# EXPOSE does NOT publish the port
# you still need -p at runtime
# docker run -p 8080:80 myapp
# in compose, expose vs ports
# expose: only to linked services
# ports: published to the host
# view exposed ports
docker inspect --format '{{json .Config.ExposedPorts}}' myappLABEL et métadonnées
LABEL attache des métadonnées clé-valeur aux images. Adoptez les labels OCI org.opencontainers.image.* pour l'interopérabilité avec registres et outils. Les labels servent à tracer version, source, licence et infos de build CI.
# 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 dans le Dockerfile
VOLUME déclare un point de montage ; Docker crée un volume anonyme au premier run sauf si vous liez un chemin hôte. Il signale que le répertoire porte des données avec état. Piège : déclarer VOLUME après COPY peut masquer vos fichiers copiés par un volume vide.
# 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 /configBuilds multi-étapes
Multi-étapes de base
Les builds multi-étapes ne copient que les artefacts finaux dans l'image d'exécution — outils de build, sources et dépendances de dev restent dans l'étape de construction. Résultat : une image d'exécution minuscule et sûre. Nommez les étapes avec AS pour les référencer dans COPY --from.
# 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;"]Choisir une étape de build
--target ne construit que jusqu'à l'étape nommée, en sautant les suivantes. Cela permet un Dockerfile unique pour dev, test et production : ciblez 'test' pour la CI, 'final' pour la production. BuildKit parallélise automatiquement les étapes indépendantes.
# 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 .Images d'exécution minces
Pour les binaires statiques (Go, Rust), scratch produit la plus petite image possible avec une surface d'attaque nulle. Ajoutez les certificats CA pour le HTTPS. Distroless offre une base minimale avec CAs racines et un utilisateur non root, idéal pour les langages dynamiques ou un runtime sans shell.
# 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"]Pattern de builder pour langages compilés
Compilez dans une image SDK complète, puis copiez l'artefact dans une image d'exécution seule (JRE). Cela réduit drastiquement l'image (JDK ~600 Mo vs JRE ~200 Mo) et retire les outils de build de la production. Pré-tirer les dépendances avant COPY améliore le cache de couches.
# 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 runtimeCopier depuis des images externes
COPY --from peut tirer depuis n'importe quelle image — utile pour assembler des outils depuis plusieurs bases sans étape de build. Les étapes peuvent aussi se référencer par index (base 0), mais les nommer avec AS est plus clair. Épinglez les images externes par digest pour la reproductibilité.
# 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 /appFonctionnalités BuildKit
BuildKit débloque les mounts de cache (les caches npm/pip persistent entre builds sans gonfler l'image), les mounts de secrets (les identifiants ne touchent aucune couche), le forwarding SSH pour les dépôts privés, et la syntaxe heredoc pour des RUN multi-lignes plus propres. Ajoutez la directive # syntax pour épingler la version du frontend Dockerfile.
# enable BuildKit
# DOCKER_BUILDKIT=1 docker build .
# syntax directive for latest frontend
# syntax=docker/dockerfile:1
FROM alpine
# mount a cache (persists across builds, not in image)
RUN --mount=type=cache,target=/root/.npm npm ci
# mount a secret (never written to layers)
RUN --mount=type=secret,id=npmrc,target=/root/.npmrc npm ci
# mount an SSH socket for private repos
RUN --mount=type=ssh git clone [email protected]:me/repo.git
# heredoc for multi-line scripts
RUN <<EOF
set -ex
apk add --no-cache curl
mkdir -p /app/data
EOFVolumes
Créer et employer des volumes
Les volumes nommés sont gérés par Docker et la façon recommandée de persister les données. Ils survivent à la suppression du conteneur et sont indépendants de la disposition du système de fichiers hôte. Le suffixe :ro monte en lecture seule. inspect révèle le chemin disque sous /var/lib/docker/volumes.
# create a named volume
docker volume create mydata
# use it in a container
docker run -d -v mydata:/data alpine sh -c "sleep 1h"
# inspect the volume
docker volume inspect mydata
# mount read-only
docker run -v mydata:/data:ro alpine ls /data
# mount with a different filesystem (e.g. tmpfs)
docker run --tmpfs /cache alpine
# default volume driver: local
docker volume create --driver local mydataLister et inspecter les volumes
ls liste les volumes nommés ; inspect montre le driver et le point de montage. Pour trouver quels conteneurs emploient un volume, filtrez ps par volume. Les volumes vivent sous /var/lib/docker/volumes/<nom>/_data sur les hôtes Linux — accédez-y via docker exec, pas par édition directe de l'hôte.
# 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 mydataDrivers de volume
Le driver local gère NFS, périphériques bloc et tmpfs via des options de montage. Pour le stockage cloud (EBS, Azure Disk), employez un driver plugin. Les drivers abstraient le stockage pour que les conteneurs se déplacent entre hôtes sans changer la commande run — clé pour Swarm/Kubernetes.
# local driver (default, on host disk)
docker volume create --driver local mydata
# NFS volume
docker volume create --driver local \
--opt type=nfs \
--opt o=addr=10.0.0.5,rw \
--opt device=:/export/data nfsvol
# tmpfs (in-memory, ephemeral)
docker run --tmpfs /cache alpine
# block device
docker volume create --driver local \
--opt type=ext4 \
--opt device=/dev/sdb1 blockvol
# third-party drivers (e.g. cloud)
docker volume create --driver rexray/ebs ebsvolSauvegarder les volumes
Sauvegardez un volume en montant le volume et un répertoire hôte dans un conteneur temporaire, puis en tarrant le contenu. La restauration inverse le processus. Ce pattern fonctionne pour tout driver de volume et fonde les scripts de sauvegarde automatisés.
# 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 /dataSupprimer des volumes
Un volume ne peut être supprimé tant qu'un conteneur le référence (retirez d'abord le conteneur). prune ne retire que les volumes inutilisés. La suppression de volume est irréversible — les données sont définitivement perdues. Sauvegardez toujours les volumes de production avant un prune.
# 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 mydataPartager des volumes entre conteneurs
Plusieurs conteneurs peuvent monter le même volume pour partager l'état. --volumes-from clone les montages de volume d'un autre conteneur — pratique pour les patterns sidecar. Ajoutez :ro pour des consommateurs en lecture seule. Coordonnez les écritures concurrentes pour éviter la corruption ; certaines apps exigent un verrou.
# share a volume between two containers
docker run -d --name db -v shared:/data alpine sleep 1h
docker run -d --name app -v shared:/data alpine sleep 1h
# use --volumes-from to copy a container's mounts
docker run -d --name helper --volumes-from db alpine sleep 1h
# read-only shared volume
docker run -d --name reader -v shared:/data:ro alpine sleep 1h
# compose: shared volume across services
# volumes:
# shared:
# services share 'shared' via volumes: ['shared:/data']
# verify both see the same data
docker exec db sh -c "echo hi > /data/msg"
docker exec app cat /data/msgBind mounts
Bind mount de base
Les bind mounts mappent directement un chemin hôte dans le conteneur — idéal pour le développement en direct où les éditions de l'hôte se reflètent instantanément. Employez des chemins hôtes absolus. Le suffixe :ro empêche le conteneur d'écrire vers l'hôte. La syntaxe moderne --mount est plus claire.
# 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:/appBind mount en lecture seule
Les montages en lecture seule protègent la configuration de l'hôte des écritures du conteneur — critique pour la sécurité. --read-only rend tout le système de fichiers racine immuable, exigeant des montages inscriptibles explicites pour /tmp et les répertoires de logs. Cela durcit les conteneurs face à la compromission.
# 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 failWorkflow de développement
Montez le code source pour que les éditions de l'hôte se reflètent instantanément dans le conteneur. L'astuce du « volume anonyme pour node_modules » empêche le node_modules vide de l'hôte de masquer les dépendances installées dans l'image. Le polling peut être nécessaire sur Windows/Mac pour la fiabilité de la surveillance de fichiers.
# 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 startLabels SELinux et AppArmor
Sur les hôtes avec SELinux (RHEL/CentOS/Fedora), les bind mounts exigent un suffixe :z ou :Z pour re-étiqueter le chemin hôte afin que le conteneur y accède. :z partage le chemin entre conteneurs ; :Z le rend privé. Oublier le suffixe cause des erreurs « permission denied ».
# SELinux: :z (shared) or :Z (private) suffix
docker run -v /host/path:/container/path:z myapp
docker run -v /host/path:/container/path:Z myapp
# :z labels the host path as shared among containers
# :Z labels it private to this container
# disable SELinux isolation (NOT recommended)
docker run --security-opt label=disable myapp
# AppArmor profile
docker run --security-opt apparmor=docker-default myapp
# custom AppArmor profile
docker run --security-opt apparmor=myprofile myappMount vs volume vs tmpfs
Volumes : gérés par Docker, portables, idéals pour les données persistantes. Bind mounts : chemins hôtes, idéals pour le dev et l'injection de config. tmpfs : en mémoire, idéal pour les secrets et caches éphémères. La syntaxe --mount est plus explicite et auto-documentée que -v.
# named volume (Docker-managed, portable)
docker run -v mydata:/data nginx
# bind mount (host path, host-dependent)
docker run -v /home/me/data:/data nginx
# --mount explicit syntax (recommended)
docker run --mount type=volume,source=mydata,target=/data nginx
docker run --mount type=bind,source=/home/me/data,target=/data nginx
docker run --mount type=tmpfs,target=/cache nginx
# tmpfs (in-memory, ephemeral, fast)
docker run --tmpfs /cache nginx
# tmpfs with size limit
docker run --mount type=tmpfs,target=/cache,tmpfs-size=64m nginxBind mounts dans Compose
Dans Compose, un chemin relatif (./html) crée un bind mount, tandis qu'un nom (logs) référençant la section volumes: crée un volume nommé. Un chemin nu (/cache) crée un volume anonyme. La syntaxe longue rend explicites des options comme read_only.
# 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: trueRéseau
Réseau bridge (défaut)
Le réseau bridge par défaut manque de DNS automatique — les conteneurs doivent employer des IP. Les réseaux bridge personnalisés offrent la découverte de services par DNS : les conteneurs se résolvent par nom. C'est pourquoi Compose crée automatiquement un réseau personnalisé par projet.
# 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 appsRéseau host
Le réseau host supprime le namespace réseau — le conteneur partage les interfaces et ports de l'hôte. Meilleures performances mais isolement et mappage de ports sacrifiés. Disponible seulement sur Linux ; sur Mac/Windows, cela mappe vers un réseau de VM, pas l'hôte.
# 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 myappRéseau overlay (Swarm)
Les réseaux overlay s'étendent sur plusieurs nœuds Swarm, permettant une communication inter-hôtes sécurisée avec DNS intégré. --attachable laisse des conteneurs autonomes rejoindre un overlay (utile pour le débogage). Le chiffrement sécurise le trafic entre nœuds ; activez-le pour les charges sensibles.
# 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 containerRéseaux personnalisés
Les réseaux personnalisés permettent de contrôler sous-réseaux, passerelles et isolement. --internal empêche l'accès Internet sortant. macvlan donne aux conteneurs une vraie présence sur le LAN physique (chacun reçoit sa propre MAC) — utile pour les apps anciennes mais casse la communication hôte-conteneur par défaut.
# 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 mymacvlanDNS du conteneur
Le DNS embarqué de Docker (127.0.0.11) résout les noms de conteneurs sur les réseaux définis par l'utilisateur. Le bridge par défaut n'a pas de DNS. --dns ajoute des résolveurs externes ; --add-host injecte des entrées statiques. Employez des noms de services (pas des IP) pour la communication inter-conteneurs pour que les redéploiements ne cassent pas le DNS.
# 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"Inspection et gestion du réseau
network connect/disconnect permet d'attacher un conteneur en cours à des réseaux supplémentaires sans redémarrer — utile pour les sidecars. inspect montre les conteneurs connectés, le sous-réseau et le driver. prune retire les réseaux non employés par aucun conteneur.
# 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 pruneMappage de ports
Mappage de ports de base
-p hôte:conteneur mappe un port hôte à un port conteneur. Si vous omettez le port hôte, Docker en choisit un (employez docker port pour le trouver). Chaque port hôte ne peut mapper qu'à un conteneur — employez un reverse proxy ou des ports hôtes différents pour plusieurs instances.
# 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 nginxLier à une IP précise
Préfixer par une IP contrôle sur quelle interface le port se lie. 127.0.0.1 garde le service local uniquement — essentiel pour les bases qu'on ne veut pas exposer. 0.0.0.0 (défaut) se lie à toutes les interfaces. Liez toujours les bases à localhost en production.
# 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"Ports UDP et SCTP
Le suffixe /udp ou /sctp choisit le protocole ; TCP est le défaut. Pour des services comme DNS qui exigent les deux, déclarez les deux mappages. Les plages de ports se mappent 1:1 entre hôte et conteneur — utile pour WebRTC, RTP ou FTP passif. Assurez que les règles de pare-feu suivent les protocoles.
# 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"Plage de ports
Les plages de ports se mappent 1:1 (hôte 8000-8005 vers conteneur 8000-8005). -P (majuscule) publie automatiquement chaque port EXPOSE vers un port hôte haut aléatoire — pratique pour des tests rapides. Employez docker ps pour voir les mappages réels quand les ports sont aléatoires.
# 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}}'Exposer vs publier
EXPOSE documente l'intention ; -p publie réellement. Dans Compose, expose partage un port seulement avec les autres services du même réseau, tandis que ports publie vers l'hôte. Cette distinction compte pour les bases : exposez en interne, ne publiez jamais vers l'hôte en production.
# 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}}' nginxMappage de port aléatoire
Omettre le port hôte laisse Docker choisir un port éphémère aléatoire (32768-60999 par défaut). Employez docker port ou docker ps pour le découvrir. Utile pour faire monter des services identiques sur un même hôte. Ajustez la plage éphémère dans /proc/sys/net/ipv4/ip_local_port_range sur Linux.
# 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 80Variables d'environnement
Régler les variables d'env
-e (ou --env) règle des variables d'environnement dans le conteneur. -e VAR (sans valeur) hérite la variable du shell hôte. Pour les valeurs sensibles, préférez --env-file ou les secrets Docker au -e simple, visible dans docker inspect et les listes de processus.
# 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 mysqlFichiers d'env
--env-file charge les variables depuis un fichier, gardant la commande run propre et les secrets hors de l'historique du shell. Compose charge automatiquement un .env de premier niveau pour la substitution de variables dans le fichier compose lui-même. Les commentaires (#) et lignes vides sont ignorés ; les guillemets sont conservés littéralement.
# .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 myappVariables d'env dans le Dockerfile
ENV cuit les variables dans l'image, visibles au build et à l'exécution. ARG n'existe qu'au build — convertissez en ENV si l'exécution en a besoin. Surchargez les valeurs cuites avec -e à l'exécution. Note : les variables d'env sont visibles dans docker inspect, n'y stockez donc pas de secrets.
# 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=trueVariables d'env dynamiques et substitution
L'expansion shell ($(...) ou ${VAR}) se produit sur l'hôte avant que Docker voie la valeur. Dans Compose, ${VAR} est substitué depuis le fichier .env. Dans un CMD en forme exec, ${VAR} n'est PAS développé — enveloppez avec sh -c. Passez l'UID hôte pour une propriété de fichiers correcte dans les bind mounts.
# 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}"]Environnement Compose
L'environment de Compose accepte la syntaxe liste ou map. env_file charge les valeurs dans le conteneur ; .env (premier niveau) fournit les variables pour la substitution ${} dans le fichier compose lui-même. Employez la forme map pour la lisibilité avec beaucoup de variables.
# 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=mydbGestion des secrets
Les secrets se montent en fichiers sous /run/secrets, jamais en variables d'env, et sont chiffrés en transit et au repos dans Swarm. Évitez de cuire les secrets dans les images (ENV) ou de les passer via -e — les deux fuient via docker inspect et les couches d'image. Les mounts de secrets BuildKit gardent les identifiants de build hors des couches.
# 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 recommendedBases de Docker Compose
docker-compose.yml de base
Compose définit une app multi-conteneurs dans un seul fichier YAML. services décrit chaque conteneur ; volumes et networks se déclarent au premier niveau. depends_on contrôle l'ordre de démarrage. docker compose up -d démarre tout en arrière-plan.
# 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 -dCommandes Compose
up crée et démarre, down arrête et retire. Ajoutez -v à down pour supprimer les volumes (perte de données). exec exécute une commande dans un service en cours ; run démarre un nouveau conteneur pour une tâche ponctuelle. --scale lance plusieurs réplicas d'un service sur le même hôte.
# 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 migrateDépendances de services
depends_on contrôle l'ordre de démarrage, mais la dépendance peut ne pas être « prête » — employez condition: service_healthy avec un healthcheck pour attendre que la base accepte les connexions. service_completed_successfully attend les conteneurs d'init. Les apps devraient quand même réessayer les connexions.
services:
web:
image: myapp
depends_on:
db:
condition: service_healthy
redis:
condition: service_started
restart: on-failure
db:
image: postgres
healthcheck:
test: ["CMD", "pg_isready", "-U", "postgres"]
interval: 5s
retries: 5
redis:
image: redis
# conditions: service_started | service_healthy | service_completed_successfullyBuild dans Compose
build définit comment construire une image depuis les sources ; image étiquette le résultat. context est envoyé au builder (gardez-le petit). target choisit une étape de build multi- étapes. --build force une reconstruction à l'up. Les build args passent des valeurs au moment du build.
services:
web:
build:
context: ./app
dockerfile: Dockerfile.prod
args:
VERSION: 1.0
target: final
image: myapp:1.0
ports:
- "8080:80"
worker:
build: ./worker # shorthand: context only
image: myworker:1.0
# build and tag
docker compose build
docker compose build --no-cache web
docker compose up -d --buildVolumes dans Compose
Un chemin relatif (./html) est un bind mount ; un nom (logs) déclaré sous les volumes: de premier niveau est un volume nommé ; un chemin nu (/cache) est anonyme. Les volumes nommés peuvent préciser un driver et des options (ex. NFS). Compose préfixe les noms de volumes avec le nom du projet.
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,rwRéseaux dans Compose
Compose crée un réseau par défaut pour tous les services, mais définir des réseaux personnalisés permet d'isoler les étages. web ponte frontend et backend. internal: true bloque l'accès Internet du backend. Les services du même réseau se résolvent par nom de service via le DNS.
services:
web:
image: nginx
networks:
- frontend
- backend
db:
image: postgres
networks:
- backend
proxy:
image: traefik
networks:
- frontend
networks:
frontend:
driver: bridge
backend:
driver: bridge
internal: true # no external access
# custom subnet
networks:
backend:
ipam:
config:
- subnet: 172.28.0.0/16Docker Compose avancé
Profils Compose
Les profiles groupent les services optionnels. Les services sans profil démarrent toujours ; les services profilés ne démarrent que si leur profil est activé avec --profile. Cela permet à un fichier compose de servir dev, test et prod : activez les profils sélectivement par environnement.
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 -dSurcharges Compose
Compose charge automatiquement docker-compose.override.yml par-dessus docker-compose.yml pour la personnalisation de dev locale. Pour d'autres environnements, passez plusieurs fichiers -f dans l'ordre — les suivants l'emportent sur les précédents. Cela sépare proprement la config de base des ajustements par environnement.
# docker-compose.yml (base)
services:
web:
image: myapp:latest
environment:
NODE_ENV: production
# docker-compose.override.yml (auto-loaded for dev)
services:
web:
build: ./app
environment:
NODE_ENV: development
DEBUG: "true"
volumes:
- ./src:/app/src
command: npm run dev
# explicit override file
docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d
# merge order: later files override earlier ones
# docker compose -f base.yml -f dev.yml -f local.yml upHealthchecks dans Compose
Les healthchecks de Compose reflètent HEALTHCHECK du Dockerfile. start_period accorde un temps de grâce pendant le démarrage. Combiner healthcheck avec depends_on: condition: service_healthy fait attendre à un service que ses dépendances soient réellement prêtes, pas seulement démarrées.
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_healthyMise à l'échelle et réplicas
--scale lance N conteneurs identiques sur un hôte — le service ne doit pas se lier à un port hôte fixe (employez un port aléatoire ou sans mappage hôte). La clé deploy.replicas est honorée par Swarm ; pour Compose simple, employez --scale. Un load balancer frontale les services à l'échelle.
# 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 portsConfig et validation Compose
config valide et rend le fichier compose fusionné (surcharges et substitution .env incluses), inestimable pour le débogage. --services, --images et --volumes inventorient les ressources. Employez -q en CI pour échouer vite sur des fichiers compose malformés.
# 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 -dPlusieurs fichiers Compose
Empiler des fichiers compose sépare les préoccupations : config de base, surcharges d'environnement, ajustements locaux. COMPOSE_FILE (séparé par deux-points sur Linux/Mac, point-virgule sur Windows) évite de répéter -f. Les listes comme ports s'ajoutent ; les maps comme environment fusionnent par clé.
# 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 mergedRegistre Docker
Faire tourner un registre local
L'image registry:2 fait tourner un registre privé sur le port 5000. Montez un volume pour persister les images. Pour des hôtes distants ou HTTPS, configurez des certificats TLS ou ajoutez le registre à insecure-registries dans /etc/docker/daemon.json. L'API v2 permet de cataloguer les dépôts via curl.
# run the official registry image
docker run -d -p 5000:5000 --name registry \
-v registrydata:/var/lib/registry \
--restart always \
registry:2
# tag and push to it
docker tag myapp:1.0 localhost:5000/myapp:1.0
docker push localhost:5000/myapp:1.0
# pull from it
docker pull localhost:5000/myapp:1.0
# list repositories in the registry
curl http://localhost:5000/v2/_catalog
# list tags for a repository
curl http://localhost:5000/v2/myapp/tags/listPousser vers un registre privé
Les images doivent être étiquetées avec l'hôte du registre avant le push. Pour les registres à certificats auto-signés, ajoutez l'hôte à insecure-registries et redémarrez le daemon (déconseillé en production — employez plutôt une vraie CA ou une CA interne). push -a envoie tous les tags du dépôt.
# 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 dockerTirer depuis un registre privé
Tirez d'un registre privé en précisant le nom d'image complet. Les identifiants de connexion se stockent dans ~/.docker/config.json (employez un credential helper pour la sécurité). Pour la CI/CD, stockez les identifiants en secrets et connectez-vous avant de tirer. Épinglez par digest pour des déploiements reproductibles.
# 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.jsonAuthentification du registre
Sécurisez un registre avec une auth basique htpasswd ou un serveur de tokens (OAuth). Pour le TLS, montez les certs et écoutez sur 443. Les credential helpers (credsStore) stockent les mots de passe dans le trousseau de l'OS au lieu du config.json en clair — essentiel pour les machines partagées ou de CI.
# 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)API du registre
L'API HTTP du registre v2 permet de scripter la gestion du registre. _catalog liste les dépôts ; manifests décrit les couches de l'image. La suppression exige REGISTRY_STORAGE_DELETE_ENABLED=true et retire les manifests — les blobs se nettoient par le ramasse-miettes (registry garbage-collect).
# list all repositories
curl http://localhost:5000/v2/_catalog
# list tags for a repo
curl http://localhost:5000/v2/myapp/tags/list
# get a manifest
curl -H "Accept: application/vnd.docker.distribution.manifest.v2+json" \
http://localhost:5000/v2/myapp/manifests/1.0
# delete a manifest (by digest)
curl -X DELETE \
http://localhost:5000/v2/myapp/manifests/sha256:abc123...
# enable delete API
# -e REGISTRY_STORAGE_DELETE_ENABLED=true
# check if a blob exists
curl -I http://localhost:5000/v2/myapp/blobs/sha256:abc...Ramasse-miettes
Supprimer un manifest laisse des blobs orphelins jusqu'au passage du ramasse-miettes. Arrêtez le registre (ou employez --dry-run) pour éviter de collecter des couches en usage. Planifiez le GC régulièrement en production pour récupérer le disque des images supprimées ou remplacées. Le chemin config.yml est le fichier de config du registre.
# run garbage collection on a registry
docker exec -it registry \
garbage-collect --dry-run /etc/docker/registry/config.yml
# actual collection (stop the registry first for consistency)
docker stop registry
docker run --rm -v registrydata:/var/lib/registry \
-v /path/config.yml:/etc/docker/registry/config.yml \
registry:2 garbage-collect /etc/docker/registry/config.yml
docker start registry
# delete unreferenced blobs after manifest deletion
# schedule GC as a cron job for production registries
# view disk usage
docker exec registry du -sh /var/lib/registryDocker Hub
Connexion et déconnexion
Préférez les tokens d'accès aux mots de passe — révocables et à portée limitée. --password-stdin lit depuis stdin, évitant le mot de passe dans l'historique du shell et les listes de processus. Configurez un credential helper pour stocker les identifiants dans le trousseau de l'OS plutôt qu'en config.json en clair.
# 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 TokenChercher des images
docker search interroge Docker Hub depuis la CLI, avec filtres pour les étoiles, le statut officiel et les builds automatisés. Les images officielles (library/nginx) sont vérifiées par Docker — préférez-les comme bases. L'UI web offre un filtrage plus riche par OS, architecture et catégorie.
# 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=nginxPousser vers Docker Hub
Étiquetez les images en username/repo:tag, puis poussez pour publier sur Docker Hub. Le dépôt se crée automatiquement au premier push (public par défaut). Push -a envoie tous les tags. Les comptes gratuits ont un dépôt privé ; les plans payants en offrent plus. Réglez la visibilité du dépôt dans l'UI web du Hub.
# 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)Builds automatisés
Les autobuilds de Docker Hub relient un dépôt git et construisent à chaque push. Les workflows modernes préfèrent GitHub Actions avec buildx et push, offrant plus de contrôle, du cache et des builds multi-arch. Les autobuilds du Hub restent une option peu coûteuse pour les projets simples.
# 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)Organisations et équipes
Les organisations partagent les dépôts dans une équipe avec accès par rôles. Les équipes reçoivent des permissions par dépôt (read, write, admin). Les comptes de service fournissent des tokens non personnels pour la CI/CD — révocables et renouvelables sans toucher aux individus. Employez le namespacing orgname/repo.
# 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.0Confiance d'image (DCT)
Docker Content Trust (DCT) emploie Notary pour signer les tags d'images, garantissant que l'image tirée est celle que l'éditeur a poussée. Activez via DOCKER_CONTENT_TRUST=1. Avec DCT, seules les images signées peuvent être tirées ou poussées. Gérez soigneusement les clés de signature — les perdre peut vous verrouiller hors de vos images.
# enable Docker Content Trust (signing)
export DOCKER_CONTENT_TRUST=1
# push signs the image automatically
docker push username/myapp:1.0
# pull refuses unsigned images when DCT is on
docker pull username/myapp:1.0
# disable for a single command
DOCKER_CONTENT_TRUST=0 docker pull unsigned/myapp:1.0
# generate delegation keys
docker trust key generate alice
# add a signer to a repository
docker trust signer add --key alice.pub alice username/myapp
# view signatures
docker trust inspect username/myapp:1.0
# revoke and rotate keys via the notary CLIHealthcheck
Healthcheck de base
Un healthcheck exécute une commande périodiquement ; sortie 0 = sain, non nul = malsain. Le conteneur démarre en 'starting' et devient 'healthy' après succès des reprises, ou 'unhealthy' après échec. start_period accorde un temps de grâce au démarrage. La santé pilote les décisions de redémarrage de Swarm.
# add a healthcheck at runtime
docker run -d --name web \
--health-cmd="curl -f http://localhost/ || exit 1" \
--health-interval=30s \
--health-timeout=5s \
--health-retries=3 \
--health-start-period=10s \
nginx
# check health status
docker inspect --format '{{.State.Health.Status}}' web
# view health check log (last 5 results)
docker inspect --format '{{json .State.Health.Log}}' web | jq
# states: starting | healthy | unhealthy | noneHealthcheck dans le Dockerfile
HEALTHCHECK dans un Dockerfile cuit la vérification dans l'image. Employez la vérification la plus légère confirmant que l'app sert réellement — curl -f ou wget --spider pour HTTP, pg_isready pour Postgres. HEALTHCHECK NONE désactive une vérification héritée. Des vérifications trop larges causent un clignotement faux « unhealthy ».
FROM nginx:alpine
# basic healthcheck (exec form)
HEALTHCHECK --interval=30s --timeout=5s --retries=3 --start-period=10s \
CMD curl -f http://localhost/ || exit 1
# using wget (alpine)
HEALTHCHECK CMD wget --spider -q http://localhost/ || exit 1
# postgres ships a ready check
HEALTHCHECK CMD pg_isready -U postgres
# disable a healthcheck inherited from the base image
HEALTHCHECK NONE
# verify
docker inspect --format '{{.Config.Healthcheck}}' myappOptions du healthcheck
interval règle la fréquence des vérifications ; timeout borne chaque vérification ; retries est le seuil d'échecs consécutifs. start_period ignore les échecs pendant le démarrage, prévenant un faux « unhealthy » pendant l'échauffement de l'app. Ajustez-les pour attraper vite les vraies pannes sans clignoter sous charge.
# 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: 30sInspecter l'état de santé
ps montre (healthy)/(unhealthy) à côté du statut. Health.Log enregistre les 5 dernières sorties de vérification — inestimable pour déboguer pourquoi une vérification échoue. Exécutez la commande de vérification manuellement via exec pour voir l'erreur réelle. Filtrez ps par santé pour trouver vite les conteneurs malades.
# 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/Healthcheck Compose
Le healthcheck de Compose reflète celui du Dockerfile. test accepte un tableau (forme exec) ou une chaîne CMD-SHELL. disable: true retire une vérification héritée. Associez healthcheck à depends_on: condition: service_healthy pour qu'un service attende que ses dépendances soient réellement prêtes, pas seulement démarrées.
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: trueBonnes pratiques du healthcheck
Vérifiez un vrai endpoint /healthz qui contrôle les dépendances critiques (base, cache) — une vérification TCP nue peut passer alors que l'app est cassée. Gardez des vérifications légères et rapides ; elles tournent à chaque intervalle. Employez start_period pour les runtimes à démarrage lent (JVM, Rails) pour qu'ils ne soient pas marqués malsains pendant le boot.
# 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'))Limites de ressources
Limites mémoire
--memory fixe une limite dure ; la dépasser déclenche un OOM kill. --memory-swap plafonne mémoire+swap combinés ; l'égaler à memory désactive le swap. --memory-reservation est une indication souple pour le noyau. Désactivez le swap pour une performance prévisible dans les charges sensibles à la latence.
# 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>Limites CPU
--cpus fixe la limite CPU en fraction de cœurs (1.5 = 1,5 cœur). --cpu-shares est un poids relatif employé en contention, pas un plafond dur. --cpuset-cpus épingle un conteneur à des cœurs précis, utile pour l'isolement des performances. Quota/period est la forme cgroup bas niveau.
# 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 nginxComportement mémoire et swap
memory-swap est le total de mémoire + swap. L'égaler à memory désactive le swap. -1 autorise un swap illimité. Swappiness (0-100) contrôle la tendance du noyau à swapper ; des valeurs basses favorisent le maintien des pages en RAM. Les limites de mémoire noyau sont avancées et rarement nécessaires.
# 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>Limites de ressources Compose
deploy.resources.limits fixe des plafonds durs ; reservations des garanties souples (employées pour l'ordonnancement). Swarm les honore nativement. Pour Compose simple (hors Swarm), employez mem_limit et cpus au premier niveau au format v2. Les reservations laissent un conteneur réclamer un minimum même inactif.
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 et comportement de redémarrage
Quand la mémoire s'épuise, le OOM-killer du noyau choisit une victime. oom-kill-disable protège un conteneur mais peut faire planter l'hôte — employez-le seulement avec des limites mémoire hôte. oom-score-adj biaise la sélection : positif = tué en premier, négatif = protégé. Vérifiez OOMKilled pour diagnostiquer les redémarrages.
# 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>Inspecter l'usage des ressources
docker stats diffuse CPU, mémoire, réseau et E/S disque en direct par conteneur — l'outil réflexe du triage rapide. --no-stream donne un seul instantané pour les scripts. Pour une analyse plus profonde, scrapez /sys/fs/cgroup ou exposez des métriques Prometheus via cAdvisor. Comparez l'usage aux limites pour dimensionner justement.
# 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}}' webSécurité
Utilisateur non root
Tourner hors root limite le rayon de l'explosion si l'app est compromise. Créez un utilisateur dédié dans le Dockerfile et basculez vers lui avec USER. Si vous devez vous lier à un port privilégié, employez un reverse proxy (nginx) ou accordez la capability NET_BIND_SERVICE plutôt que de tourner en root.
# 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 nonrootSystème de fichiers racine en lecture seule
Un système de fichiers racine en lecture seule empêche les attaquants d'écrire des malwares ou de modifier les configs en cas de compromission. Associez tmpfs pour les répertoires de travail (/tmp, /cache) et volumes pour les données persistantes. Les apps doivent être conçues pour cela — certains frameworks écrivent dans des chemins inattendus et exigent des montages tmpfs.
# 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 pathsCapabilities Linux
Par défaut, Docker accorde un ensemble limité de capabilities Linux. Retirez ALL et ne rajoutez que ce dont l'app a besoin — le principe du moindre privilège. --privileged accorde toutes les capabilities et l'accès aux périphériques hôtes ; évitez-le entièrement sauf pour des runtimes de conteneurs de confiance. Retirez NET_RAW par défaut.
# 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 et AppArmor
Seccomp filtre les syscalls qu'un conteneur peut employer — le profil par défaut bloque ~44 syscalls dangereux. AppArmor confine l'accès fichiers et capabilities. no-new-privileges empêche les binaires setuid d'accorder de nouveaux privilèges — un durcissement bon marché et de grande valeur pour tout conteneur.
# 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 nginxScan d'images
Scannez les images pour les vulnérabilités connues (CVE) avant de pousser. docker scout (ex docker scan basé snyk) est intégré. Trivy et Grype sont des alternatives populaires. Intégrez le scan à la CI pour bloquer les images avec des CVE de haute sévérité. Re-scannez périodiquement les images de base à mesure que de nouvelles CVE sont divulguées.
# docker scout (built-in, replaces docker scan)
docker scout cves myapp:1.0
# scan a local image
docker scout cves --format json myapp:1.0
# compare two images
docker scout compare myapp:1.0 --to myapp:1.1
# Trivy (third-party, popular)
trivy image myapp:1.0
# Grype (third-party)
grype myapp:1.0
# scan a Dockerfile for bad practices
docker scout policy myapp --only-stream-default
# integrate scanning in CI
# - build image
# - scan
# - fail the pipeline on HIGH/CRITICAL CVEsDocker Content Trust et durcissement
Content Trust garantit que vous tirez des images signées. Durcissez le daemon : désactivez la communication inter-conteneurs (icc=false), activez live-restore pour que les conteneurs survivent aux redémarrages du daemon, et activez les namespaces utilisateur (userns-remap) pour mapper le root du conteneur à un UID hôte non root pour un isolement plus fort.
# 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"Logs et supervision
Voir les logs
docker logs lit le stdout/stderr capté par le driver de logging. Les apps devraient logger sur stdout — pas dans des fichiers — pour s'intégrer à docker logs. --tail et --since limitent la sortie. Compose logs agrège entre services. Le driver json-file par défaut croît sans borne si vous ne le plafonnez pas.
# 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 dbDrivers de logs
Le driver json-file croît sans borne sans rotation — réglez max-size et max-file pour prévenir l'épuisement du disque. En production, envoyez les logs vers un système central (fluentd, splunk, awslogs, gelf). Réglez un défaut global dans daemon.json pour que chaque conteneur ait la rotation par défaut.
# 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" } }Étiquetage et attributs des logs
Le template tag personnalise les identifiants de log — employer {{.Name}} produit des noms de conteneurs lisibles au lieu d'IDs tronqués. Pour fluentd/splunk, les labels et variables d'env s'attachent aux enregistrements de log pour le filtrage. Réglez des templates de tag au niveau daemon pour que tous les conteneurs soient étiquetés de façon cohérente.
# tag logs with container name instead of ID
docker run -d \
--log-driver=json-file \
--log-opt tag="{{.Name}}" \
nginx
# tag with image name and tag
--log-opt tag="{{.ImageName}}/{{.Name}}"
# fluentd: add labels and attributes
docker run -d \
--log-driver=fluentd \
--log-opt fluentd-address=localhost:24224 \
--log-opt tag="docker.{{.Name}}" \
--log-opt labels=app,env \
--label app=web --label env=prod \
nginx
# syslog with facility
docker run -d --log-driver=syslog \
--log-opt syslog-facility=daemon nginxStats et supervision des ressources
stats diffuse CPU, mémoire, réseau et E/S bloc. docker events est un flux temps réel des événements du daemon — utile pour les scripts d'alerte. docker top montre les processus d'un conteneur ; docker diff montre les changements du système de fichiers (A=ajouté, C=changé, D=supprimé) depuis la création de l'image.
# 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Événements Docker
docker events est un flux temps réel des événements de cycle de vie : create, start, stop, pause, die, destroy, plus les événements d'image et de réseau. Filtrez par type, événement ou conteneur. C'est la base des scripts d'alerte qui réagissent aux morts de conteneurs ou redémarrent automatiquement des services défaillants.
# 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"
donePile Prometheus et Grafana
cAdvisor expose des métriques par conteneur (CPU, mémoire, réseau, système de fichiers) au format Prometheus. Prometheus les scrape et les stocke ; Grafana visualise. C'est la pile de supervision open source de facto pour Docker. Ajoutez node-exporter pour les métriques hôte et alertmanager pour les alertes.
# run cAdvisor (container metrics exporter)
docker run -d --name cadvisor \
-v /:/rootfs:ro -v /var/run:/var/run:ro \
-v /sys:/sys:ro -v /var/lib/docker/:/var/lib/docker:ro \
-p 8080:8080 gcr.io/cadvisor/cadvisor
# run Prometheus
docker run -d -p 9090:9090 \
-v ./prometheus.yml:/etc/prometheus/prometheus.yml \
prom/prometheus
# run Grafana
docker run -d -p 3000:3000 grafana/grafana
# scrape cAdvisor in prometheus.yml
# scrape_configs:
# - job_name: cadvisor
# static_configs:
# - targets: ['cadvisor:8080']
# view dashboards in Grafana at http://localhost:3000Docker Swarm
Initialiser Swarm
swarm init transforme un hôte Docker en manager Swarm. Le token de join permet aux workers et managers supplémentaires de rejoindre. Gardez les tokens de manager secrets — ils peuvent contrôler le cluster. Faites tourner un nombre impair de managers (3 ou 5) pour la tolérance au consensus Raft. Les workers exécutent les tâches ; les managers les ordonnancent.
# 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 leaveDéployer des services
Les services sont l'abstraction Swarm des conteneurs. Un service répliqué exécute N tâches identiques ; un service global une tâche par nœud. update déploie une nouvelle image sans interruption par défaut. scale change le compte de réplicas à chaud. Swarm gère la reprogrammation si un nœud tombe.
# 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 webMise à l'échelle et mises à jour
scale change le compte de réplicas instantanément. update effectue des mises à jour glissantes — parallelism contrôle combien de tâches se mettent à jour à la fois, delay les espace, et failure-action=rollback revient automatiquement en arrière en cas d'erreur. Swarm garde les vieilles tâches en marche jusqu'à ce que les nouvelles soient saines, permettant des déploiements sans interruption.
# 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 webDéploiement de stack
Une stack est un fichier Compose déployé sur Swarm. La clé deploy: configure réplicas, politiques update/rollback, contraintes de placement et ressources — tout est propre à Swarm. docker stack deploy applique la spec déclarativement. Les stacks groupent services, réseaux et secrets liés.
# 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 mystackGestion des nœuds
Drainez un nœud avant maintenance pour reprogrammer gracieusement ses tâches ailleurs. Active/pause/drain contrôle l'ordonnancement. Les labels permettent des contraintes de placement (ex. ne faire tourner la base que sur les nœuds étiquetés tier=db). Retirez un nœud seulement après qu'il a quitté le Swarm avec docker swarm leave.
# 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 et configs
Les secrets sont chiffrés au repos et en transit, montés en fichiers sous /run/secrets, et jamais écrits dans les couches d'image ni les variables d'env. Ils sont immuables — pour les renouveler, créez un nouveau secret et mettez à jour le service. Les configs sont semblables mais pour les données non sensibles comme les fichiers de config. Les deux sont propres à Swarm.
# create a secret from a file
docker secret create db_password ./db_password.txt
# create from stdin
echo "supersecret" | docker secret create db_password -
# use in a service
docker service create --name app --secret db_password myapp
# read in the app
# cat /run/secrets/db_password
# update a secret (immutable — create a new one)
echo "newsecret" | docker secret create db_password_v2 -
docker service update --secret-rm db_password --secret-add source=db_password_v2 app
# configs (non-sensitive, e.g. nginx.conf)
echo "server {...}" | docker config create nginx_conf -
docker service create --config nginx_conf nginx
# list and remove
docker secret ls
docker config lsSnippets Docker associés
Copy-paste ready code for common tasks.
Run a Container
Run, list, stop, and remove Docker containers.
Writing a Dockerfile
Build an image from a Dockerfile with multi-instruction layers.
Image Management
Pull, list, tag, push, and prune images.
Volumes & Bind Mounts
Persist data with named volumes, anonymous volumes, and bind mounts.
Networking
Create networks, attach containers, and expose ports.
Docker Compose
Define and run multi-container apps with compose.
Multi-Stage Build
Build artifacts in one stage and copy them into a slim final image.
Exec & Logs
Run commands inside running containers and inspect logs.
Was this helpful?