LLI Wiki — My Digital Knowledge Base

Docker : aide-mémoire des commandes courantes

Aide-mémoire Docker : conteneurs, images, réseaux, volumes, ports, Dockerfile, Compose, nettoyage et sécurité.

Aide-mémoire des commandes Docker les plus utiles au quotidien : cycle de vie des conteneurs et des images, réseaux, volumes, ports, Dockerfile, Compose, nettoyage et quelques règles de sécurité. Pour aller plus loin, voir la documentation officielle et le cheat sheet communautaire dont ce mémo s'inspire.

Version

docker version
docker version --format '{{.Server.Version}}'
docker version --format '{{json .}}'

Aide-mémoire de la CLI Docker

Conteneurs

Cycle de vie

Commande Rôle
docker create crée un conteneur sans le démarrer
docker run crée et démarre un conteneur
docker rename renomme un conteneur
docker rm supprime un conteneur (-v : supprime aussi ses volumes anonymes)
docker update modifie les limites de ressources
docker start / stop / restart démarre, arrête, redémarre
docker pause / unpause gèle / reprend les processus
docker kill envoie SIGKILL
docker wait bloque jusqu'à l'arrêt du conteneur
docker attach se connecte à un conteneur en cours d'exécution (détacher : Ctrl+p puis Ctrl+q)

Options courantes de docker run :

docker run -d --name web -p 8080:80 nginx          # arrière-plan, nom, mapping de port hôte:conteneur
docker run -td IMAGE                               # pseudo-TTY + détaché : garde un conteneur actif
docker run --rm IMAGE                              # conteneur jetable, supprimé à l'arrêt
docker run -v /srv/data:/data IMAGE                # monte un dossier de l'hôte
docker run --hostname srv IMAGE                    # nom d'hôte
docker run --add-host nom:192.0.2.10 IMAGE         # entrée DNS statique
docker run -it --entrypoint bash IMAGE             # remplace l'entrypoint
docker run --log-driver=syslog IMAGE               # pilote de journalisation

Sans option, un conteneur dont le processus principal se termine s'arrête aussitôt ; donner un nom avec --name permet ensuite de le piloter par ce nom.

Limites de ressources

docker run -it -c 512 IMAGE                  # cpu-shares : 1024 = poids par défaut, 512 = moitié moins prioritaire
docker run -it --cpuset-cpus=0,4,6 IMAGE     # restreint à certains cœurs
docker run -it -m 300M ubuntu /bin/bash      # limite mémoire
docker run --pids-limit=64 IMAGE             # limite le nombre de processus (protège des fork bombs)

cpu-shares est un poids relatif, pas un plafond. Avec --cpuset-cpus, le conteneur continue de voir tous les CPU mais n'utilise que ceux indiqués.

Capacités et périphériques

docker run --rm -it --cap-add SYS_ADMIN --device /dev/fuse IMAGE   # monter un système de fichiers FUSE
docker run -it --device=/dev/ttyUSB0 debian bash                  # un seul périphérique
docker run -it --privileged -v /dev/bus/usb:/dev/bus/usb debian bash   # tous les périphériques (à éviter)

--cap-add / --cap-drop ajustent les capacités Linux ; préférer ce réglage fin à --privileged.

Informations

Commande Rôle
docker ps / docker ps -a conteneurs actifs / tous
docker logs journaux du conteneur
docker inspect détails complets (dont l'adresse IP)
docker events flux d'événements
docker port ports publiés
docker top processus du conteneur
docker stats (--all) consommation CPU, mémoire, réseau
docker diff fichiers modifiés dans le conteneur

Copier, exporter, exécuter

docker cp web:/index.html ./index.html     # conteneur -> hôte
docker cp ./index.html web:/index.html     # hôte -> conteneur
docker export web | gzip > web.tar.gz      # système de fichiers du conteneur
docker exec -it web /bin/bash              # ouvrir un shell dans un conteneur actif

Images

Commande Rôle
docker images liste les images
docker build -t nom . construit une image depuis un Dockerfile
docker commit crée une image depuis un conteneur (le Dockerfile est préférable)
docker tag SRC DEST ajoute un nom/tag
docker history historique des couches
docker rmi supprime une image
docker save / docker load archive tar d'image (avec historique et tags)
docker export / docker import archive du système de fichiers d'un conteneur
docker save my_image:my_tag | gzip > my_image.tar.gz
docker load < my_image.tar.gz

docker export my_container | gzip > my_container.tar.gz
cat my_container.tar.gz | docker import - my_image:my_tag

load restaure l'image avec son historique ; import crée une image sans historique, donc plus petite.

Réseaux

docker network create --subnet 203.0.113.0/24 --gateway 203.0.113.254 mynet
docker run --rm -it --net mynet --ip 203.0.113.2 nginx
docker network ls
docker network inspect mynet
docker network connect mynet CONTAINER
docker network disconnect mynet CONTAINER
docker network rm mynet

Les réseaux définis par l'utilisateur permettent aux conteneurs de communiquer par nom, sans publier de ports ; ils remplacent les anciens --link.

Registre

docker login, logout, search, pull, push gèrent l'authentification et le transfert d'images vers un registre. Un registre privé peut être hébergé avec le projet distribution.

Volumes

docker volume create data
docker volume ls
docker volume inspect data
docker volume rm data
docker run --volumes-from CONTAINER IMAGE    # réutilise les volumes d'un autre conteneur

Un volume est un système de fichiers indépendant des conteneurs, utile pour conserver l'état entre des conteneurs jetables. On peut aussi monter un fichier unique, par exemple pour injecter une configuration :

docker run --rm httpd cat /usr/local/apache2/conf/httpd.conf > httpd.conf
# modifier httpd.conf, puis :
docker run --rm -it -v "$PWD/httpd.conf:/usr/local/apache2/conf/httpd.conf:ro" -p 8080:80 httpd

Publication de ports

docker run -p 8080:80 --name web -t IMAGE
docker port web 80

EXPOSE dans un Dockerfile documente seulement le port d'écoute ; seule l'option -p (ou -P pour tous les ports exposés) le publie sur l'hôte.

Dockerfile

Le Dockerfile décrit la construction d'une image avec docker build. Instructions principales :

Instruction Rôle
FROM image de base
RUN exécute une commande dans une nouvelle couche
CMD commande par défaut du conteneur
ENTRYPOINT exécutable principal du conteneur
EXPOSE documente les ports d'écoute (ne les publie pas)
ENV / ARG variable d'environnement / variable de build
COPY / ADD copie des fichiers ; préférer COPY (ADD invalide le cache)
VOLUME point de montage
USER / WORKDIR utilisateur et dossier de travail
LABEL métadonnées (remplace MAINTAINER, obsolète)
ONBUILD déclencheur pour les builds dérivés
STOPSIGNAL signal d'arrêt

COPY copie en tant que root quel que soit USER ; utiliser --chown=utilisateur:groupe pour changer le propriétaire. Un fichier .dockerignore exclut des éléments du contexte de build. Voir les bonnes pratiques officielles.

Réduire la taille : nettoyer APT dans la même couche RUN que l'installation, sinon les couches précédentes conservent les fichiers.

RUN apt-get update && apt-get install -y PACKAGE \
  && apt-get clean \
  && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*

Dockerfile en ligne de commande (heredoc) :

docker build -t htop - << EOF
FROM alpine
RUN apk --no-cache add htop
EOF

Docker Compose

docker-compose -f docker-compose.yml up        # démarre les services (-d pour l'arrière-plan)
docker-compose stop                            # arrête
docker-compose down                            # supprime les conteneurs (--volumes : et les volumes)

Nettoyage

Depuis Docker 1.13 :

docker system df          # espace utilisé par les objets Docker
docker system prune
docker container prune
docker image prune        # -a : toutes les images inutilisées
docker volume prune
docker network prune

Commandes plus anciennes, toujours utiles :

docker kill $(docker ps -q)                                  # tuer tous les conteneurs actifs
docker rm -f $(docker ps -qa)                                # supprimer tous les conteneurs (même actifs)
docker rm -v $(docker ps -a -q -f status=exited)             # supprimer les conteneurs arrêtés
docker rmi $(docker images -q -f dangling=true)              # images orphelines
docker rmi $(docker images -q)                               # toutes les images
docker volume rm $(docker volume ls -q -f dangling=true)     # volumes orphelins

Astuces

# Adresse IP d'un conteneur
docker inspect -f '{{ .NetworkSettings.IPAddress }}' NOM

# Correspondance des ports
docker inspect -f '{{range $p, $conf := .NetworkSettings.Ports}} {{$p}} -> {{(index $conf 0).HostPort}} {{end}}' NOM

# Variables d'environnement d'une image
docker run --rm ubuntu env

# Conteneurs issus d'une image
docker ps -a -f ancestor=ubuntu

# Consommation de tous les conteneurs actifs
docker stats $(docker ps -q)

# Aplatir une image
ID=$(docker run -d image-name /bin/bash)
docker export $ID | docker import - flat-image-name

Sécurité

RUN groupadd -r user && useradd -r -g user user
USER user
docker run --read-only IMAGE                               # système de fichiers en lecture seule
docker run -v "$(pwd)/secrets:/secrets:ro" debian          # volume en lecture seule
docker run --security-opt=no-new-privileges IMAGE          # interdit l'acquisition de nouveaux privilèges
docker run --pids-limit=64 IMAGE                           # limite le nombre de processus

Remarques

Mastodon LLIMastodon SocialFosstodon