Docker sur Arch Linux

Qu'est-ce que Docker ?

Docker exécute des applications dans des conteneurs isolés qui partagent le noyau de l'hôte. Le gain principal est la reproductibilité: même image, mêmes dépendances, même lancement.

• Léger: démarrage rapide et consommation réduite.
• Portable: même image sur plusieurs hôtes compatibles.
• Isolé: système de fichiers et réseau séparés par conteneur.
• Reproductible: configuration déclarée par image ou Compose.

Prérequis

Contrôler le noyau et l'architecture avant installation:

uname -r
uname -m

Le poste doit être à jour et l'opérateur doit comprendre que Docker manipule des ressources proches du système hôte.

Installation

Installer Docker Engine et Compose, puis activer le service:

sudo pacman -S docker docker-compose
sudo systemctl start docker.service
sudo systemctl enable docker.service
sudo systemctl status docker.service

sudo usermod -aG docker <OPERATOR>
groups <OPERATOR> | rg 'docker'
sudo docker run --rm hello-world

Concepts de base

Commandes essentielles

Lancer, lister, diagnostiquer et inspecter:

docker run -d --name <CONTAINER_NAME> <IMAGE>:<TAG>
docker run -it <IMAGE>:<TAG> <SHELL>
docker run -d -p <HOST_PORT>:<CONTAINER_PORT> <IMAGE>:<TAG>
docker ps
docker images
docker logs --tail 100 <CONTAINER_NAME>
docker exec -it <CONTAINER_NAME> <SHELL>
docker inspect <CONTAINER_NAME>
docker stats <CONTAINER_NAME>

Exemples pratiques

Exemple web statique avec port et chemin anonymisés:

docker run -d \
  --name <WEB_CONTAINER> \
  -p <HOST_PORT>:80 \
  -v <HOST_HTML_DIR>:/usr/share/nginx/html:ro \
  nginx:alpine

Exemple base de données avec volume persistant et secrets remplacés:

docker run -d \
  --name <DB_CONTAINER> \
  -e POSTGRES_PASSWORD=<DB_PASSWORD> \
  -e POSTGRES_USER=<DB_USER> \
  -e POSTGRES_DB=<DB_NAME> \
  -v <DB_VOLUME>:/var/lib/postgresql/data \
  -p <HOST_DB_PORT>:5432 \
  postgres:<TAG>

Les services comme cloud personnel, interface de gestion ou monitoring suivent la même logique: réseau dédié, volumes nommés, secrets externalisés et exposition minimale.

Docker Compose

Compose décrit une stack multi-conteneurs dans un fichier YAML. La version publique montre la structure, pas les valeurs privées:

services:
  web:
    image: <WEB_IMAGE>:<TAG>
    ports:
      - "<HOST_PORT>:80"
    volumes:
      - <WEB_DATA>:/usr/share/nginx/html:ro
    restart: unless-stopped

  db:
    image: <DB_IMAGE>:<TAG>
    environment:
      POSTGRES_PASSWORD: <DB_PASSWORD>
      POSTGRES_USER: <DB_USER>
      POSTGRES_DB: <DB_NAME>
    volumes:
      - <DB_DATA>:/var/lib/postgresql/data
    restart: unless-stopped

volumes:
  <WEB_DATA>:
  <DB_DATA>:

docker compose config
docker compose up -d
docker compose logs -f
docker compose down
docker compose pull
docker compose up -d

Exemple de mini lab réellement démontré publiquement:

services:
  nginx:
    image: nginx:alpine
    ports:
      - "8080:80"
    volumes:
      - ./nginx/html:/usr/share/nginx/html:ro
      - morpheus_nginx_data:/data
    restart: unless-stopped

volumes:
  morpheus_nginx_data:
    external: true

Gestion des volumes

Les volumes sont traités comme des données à sauvegarder:

docker volume create <VOLUME_NAME>
docker volume ls
docker volume inspect <VOLUME_NAME>
docker volume rm <VOLUME_NAME>

Backup et restauration anonymisés:

docker run --rm -v <VOLUME_NAME>:/data -v <BACKUP_DIR>:/backup alpine tar czf /backup/<ARCHIVE>.tar.gz -C /data .
docker run --rm -v <VOLUME_NAME>:/data -v <BACKUP_DIR>:/backup alpine tar xzf /backup/<ARCHIVE>.tar.gz -C /data

Gestion des réseaux

Utiliser des réseaux explicites pour limiter la communication entre services:

docker network create <NETWORK_NAME>
docker network ls
docker network inspect <NETWORK_NAME>
docker network connect <NETWORK_NAME> <CONTAINER_NAME>
docker network disconnect <NETWORK_NAME> <CONTAINER_NAME>
docker network rm <NETWORK_NAME>

Dockerfile

Créer une image applicative minimale:

FROM <RUNTIME_IMAGE>:<TAG>
WORKDIR /app
COPY <DEPENDENCY_FILES> ./
RUN <INSTALL_DEPENDENCIES>
COPY . .
EXPOSE <APP_PORT>
USER <APP_USER>
CMD ["<START_COMMAND>"]

Les instructions critiques sont FROM, WORKDIR, COPY, RUN, EXPOSE, USER, CMD et ENTRYPOINT.

Bonnes pratiques

• Ne pas stocker de secrets dans une image ou dans l'historique de build.
• Créer un utilisateur non-root dans les images applicatives.
• Limiter les volumes au strict nécessaire.
• Préférer des tags contrôlés plutôt que latest pour les services importants.
• Limiter les logs avec une politique de rotation.
• Documenter les politiques de redémarrage: unless-stopped, always, on-failure ou no.

Maintenance et nettoyage

Mesurer avant de nettoyer:

docker system df
docker container prune
docker image prune -a
docker volume prune
docker network prune
docker system prune -a --volumes

Validation publique réalisée

docker compose ps
curl -i http://127.0.0.1:8080
docker volume inspect morpheus_nginx_data
docker compose restart
docker compose rm -sf
docker compose up -d
curl -i http://127.0.0.1:8080

État observé publiable:

la stack Compose démarre proprement
nginx répond en HTTP 200 sur 127.0.0.1:8080
le volume morpheus_nginx_data est identifié explicitement
le service reste disponible après redémarrage
le service revient après suppression puis recréation du conteneur

Monitoring et statistiques

docker stats
docker stats <CONTAINER_NAME>
docker logs -f <CONTAINER_NAME>
docker logs --tail 100 <CONTAINER_NAME>

Les interfaces de gestion et les agents de monitoring doivent être traités comme des services sensibles, surtout s'ils montent le socket Docker.

Dépannage

Contrôles de base:

docker logs <CONTAINER_NAME>
docker inspect <CONTAINER_NAME>
ss -tlnp | rg '<HOST_PORT>'
docker exec <CONTAINER_NAME> ls -la <DATA_PATH>
docker network inspect <NETWORK_NAME>
docker pull <IMAGE>:<TAG>

Les erreurs fréquentes viennent d'un port déjà utilisé, d'un volume avec permissions incorrectes, d'une variable manquante, d'une image inaccessible ou d'un réseau mal choisi.

Ressources

• Documentation officielle Docker.
• Documentation Docker Compose.
• Wiki Arch Docker.
• Notes privées de services et de backups, non publiées.