Docker Cheatsheet

Docker révolutionne le déploiement d’applications en utilisant la containerisation. Cette cheatsheet couvre toutes les commandes essentielles.

🐳 Installation de Docker

Ubuntu/Debian

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
# Désinstaller anciennes versions
sudo apt remove docker docker-engine docker.io containerd runc

# Installation via repository officiel
sudo apt update
sudo apt install ca-certificates curl gnupg lsb-release

# Ajouter clé GPG
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# Ajouter repository
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Installer Docker
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin

# Ajouter utilisateur au groupe docker
sudo usermod -aG docker $USER

CentOS/RHEL/Fedora

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
# Installer yum-utils
sudo yum install -y yum-utils

# Ajouter repository
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

# Installer Docker
sudo yum install docker-ce docker-ce-cli containerd.io docker-compose-plugin

# Démarrer et activer Docker
sudo systemctl start docker
sudo systemctl enable docker

Vérification installation

1
2
docker --version
docker run hello-world

📦 Gestion des images

Télécharger et lister des images

Commande	Description
`docker pull ubuntu:22.04`	Télécharger image Ubuntu 22.04
`docker pull nginx:latest`	Télécharger dernière version Nginx
`docker images`	Lister toutes les images
`docker images -q`	Lister seulement les IDs
`docker images --filter dangling=true`	Images orphelines
`docker image ls`	Alternative à docker images

Construire des images

1
2
3
4
5
6
7
8
9
# Construire depuis Dockerfile
docker build -t mon-app:v1.0 .
docker build -t mon-app:latest -f Dockerfile.prod .

# Construire sans cache
docker build --no-cache -t mon-app:v1.0 .

# Construire avec arguments
docker build --build-arg VERSION=1.0 -t mon-app .

Gestion avancée des images

Commande	Description
`docker tag SOURCE_IMAGE TARGET_IMAGE`	Taguer une image
`docker rmi image_id`	Supprimer une image
`docker rmi $(docker images -q)`	Supprimer toutes les images
`docker image prune`	Supprimer images inutilisées
`docker image prune -a`	Supprimer toutes images non utilisées
`docker history image_name`	Historique des couches
`docker inspect image_name`	Informations détaillées

Registry et partage

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
# Connexion à un registry
docker login
docker login registry.example.com

# Pousser une image
docker push username/mon-app:v1.0

# Sauvegarder/charger images
docker save -o mon-app.tar mon-app:v1.0
docker load -i mon-app.tar

🏃‍♂️ Gestion des containers

Lancer des containers

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
# Lancer container en mode détaché
docker run -d --name mon-nginx nginx

# Lancer avec port mapping
docker run -d -p 8080:80 --name web-server nginx

# Lancer avec variables d'environnement
docker run -d -e MYSQL_ROOT_PASSWORD=secret mysql:8.0

# Lancer en mode interactif
docker run -it ubuntu:22.04 /bin/bash
docker run -it --rm ubuntu:22.04 /bin/bash  # suppression auto

# Lancer avec volume
docker run -d -v /host/path:/container/path nginx

# Lancer avec limits de ressources
docker run -d --memory="512m" --cpus="1.0" nginx

Contrôle des containers

Commande	Description
`docker ps`	Containers en cours d’exécution
`docker ps -a`	Tous les containers
`docker ps -q`	Seulement les IDs des containers actifs
`docker start container_name`	Démarrer container
`docker stop container_name`	Arrêter container
`docker restart container_name`	Redémarrer container
`docker pause container_name`	Mettre en pause
`docker unpause container_name`	Reprendre
`docker kill container_name`	Tuer brutalement

Interaction avec les containers

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
# Exécuter commande dans container
docker exec -it container_name /bin/bash
docker exec -it container_name sh

# Exécuter commande ponctuelle
docker exec container_name ls -la
docker exec container_name nginx -t  # test config nginx

# Copier fichiers
docker cp file.txt container_name:/path/to/destination
docker cp container_name:/path/to/file.txt ./local-file.txt

Logs et monitoring

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
# Voir les logs
docker logs container_name
docker logs -f container_name  # suivi en temps réel
docker logs --tail 50 container_name  # 50 dernières lignes
docker logs --since="2024-01-01" container_name

# Statistiques en temps réel
docker stats
docker stats container_name

# Informations détaillées
docker inspect container_name
docker top container_name  # processus dans le container

Nettoyage des containers

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
# Supprimer container
docker rm container_name
docker rm -f container_name  # forcer suppression

# Supprimer tous containers arrêtés
docker container prune

# Supprimer tous containers
docker rm $(docker ps -aq)
docker rm -f $(docker ps -aq)  # forcer

💾 Gestion des volumes

Types de volumes

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
# Volume nommé
docker volume create mon-volume
docker run -d -v mon-volume:/data nginx

# Bind mount (dossier hôte)
docker run -d -v /home/user/data:/data nginx
docker run -d --mount type=bind,source=/home/user/data,target=/data nginx

# tmpfs mount (mémoire)
docker run -d --tmpfs /tmp nginx
docker run -d --mount type=tmpfs,destination=/tmp nginx

Commandes de gestion des volumes

Commande	Description
`docker volume ls`	Lister les volumes
`docker volume create volume_name`	Créer un volume
`docker volume inspect volume_name`	Informations sur le volume
`docker volume rm volume_name`	Supprimer volume
`docker volume prune`	Supprimer volumes inutilisés

Sauvegarde et restauration

1
2
3
4
5
# Sauvegarder volume
docker run --rm -v mon-volume:/data -v $(pwd):/backup ubuntu tar czf /backup/backup.tar.gz -C /data .

# Restaurer volume
docker run --rm -v mon-volume:/data -v $(pwd):/backup ubuntu tar xzf /backup/backup.tar.gz -C /data

🌐 Gestion des réseaux

Types de réseaux Docker

bridge : Réseau par défaut pour containers sur même hôte
host : Container utilise directement réseau hôte
none : Aucune connectivité réseau
overlay : Communication entre containers sur différents hôtes

Commandes réseau

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
# Créer réseau personnalisé
docker network create mon-reseau
docker network create --driver bridge mon-bridge

# Lister réseaux
docker network ls

# Informations réseau
docker network inspect bridge
docker network inspect mon-reseau

# Connecter container à réseau
docker network connect mon-reseau container_name

# Déconnecter
docker network disconnect mon-reseau container_name

# Supprimer réseau
docker network rm mon-reseau
docker network prune  # supprimer réseaux inutilisés

Utilisation des réseaux

1
2
3
4
5
6
# Lancer container sur réseau spécifique
docker run -d --network mon-reseau --name web nginx
docker run -d --network mon-reseau --name db mysql:8.0

# Communication entre containers par nom
docker exec -it web ping db

📋 Dockerfile - Construction d’images

Structure de base

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
# Image de base
FROM ubuntu:22.04

# Métadonnées
LABEL maintainer="admin@example.com"
LABEL version="1.0"
LABEL description="Mon application web"

# Variables d'environnement
ENV APP_ENV=production
ENV APP_PORT=8000

# Répertoire de travail
WORKDIR /app

# Copier fichiers
COPY . /app/
COPY requirements.txt .

# Installer dépendances
RUN apt-get update && \
    apt-get install -y python3 python3-pip && \
    pip3 install -r requirements.txt && \
    apt-get clean

# Exposer port
EXPOSE 8000

# Utilisateur non-root
RUN useradd -m appuser
USER appuser

# Point d'entrée
ENTRYPOINT ["python3"]
CMD ["app.py"]

Instructions Dockerfile principales

Instruction	Description	Exemple
`FROM`	Image de base	`FROM node:16`
`RUN`	Exécuter commande	`RUN npm install`
`COPY`	Copier fichiers	`COPY . /app`
`ADD`	Copier + extraction	`ADD archive.tar /app`
`WORKDIR`	Répertoire de travail	`WORKDIR /app`
`EXPOSE`	Port exposé	`EXPOSE 80`
`ENV`	Variable d’environnement	`ENV NODE_ENV=prod`
`CMD`	Commande par défaut	`CMD ["npm", "start"]`
`ENTRYPOINT`	Point d’entrée fixe	`ENTRYPOINT ["nginx"]`

Bonnes pratiques Dockerfile

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
# Multi-stage build
FROM node:16 AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

FROM node:16-alpine AS runtime
WORKDIR /app
COPY --from=builder /app/node_modules ./node_modules
COPY . .
EXPOSE 3000
USER 1000
CMD ["npm", "start"]

🐙 Docker Compose

Installation Docker Compose

1
2
3
4
5
6
# Vérifier si installé avec Docker Desktop
docker compose version

# Installation manuelle (Linux)
sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

Fichier docker-compose.yml basique

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
version: '3.8'

services:
  web:
    build: .
    ports:
      - "8000:8000"
    environment:
      - DEBUG=1
    volumes:
      - .:/app
    depends_on:
      - db
      - redis

  db:
    image: postgres:14
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    volumes:
      - postgres_data:/var/lib/postgresql/data
    ports:
      - "5432:5432"

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

volumes:
  postgres_data:

Commandes Docker Compose

Commande	Description
`docker compose up`	Démarrer services
`docker compose up -d`	Démarrer en arrière-plan
`docker compose down`	Arrêter et supprimer containers
`docker compose down -v`	+ supprimer volumes
`docker compose ps`	État des services
`docker compose logs`	Logs de tous services
`docker compose logs web`	Logs du service web
`docker compose exec web bash`	Shell dans service
`docker compose build`	Construire images
`docker compose pull`	Télécharger images
`docker compose restart`	Redémarrer services

Configuration avancée

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile.prod
      args:
        - BUILD_ENV=production
    ports:
      - "80:80"
    environment:
      - APP_ENV=production
    volumes:
      - ./uploads:/app/uploads
    networks:
      - frontend
      - backend
    restart: unless-stopped
    deploy:
      resources:
        limits:
          cpus: '0.50'
          memory: 512M
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost/health"]
      interval: 30s
      timeout: 10s
      retries: 3

networks:
  frontend:
  backend:
    driver: bridge

🔧 Docker utilitaires et outils

Système et maintenance

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
# Informations système Docker
docker system info
docker system df  # utilisation disque

# Nettoyage général
docker system prune  # containers, réseaux, images
docker system prune -a  # tout nettoyer
docker system prune -a --volumes  # inclure volumes

# Events en temps réel
docker system events
docker system events --filter container=mon-container

Sécurité

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
# Scanner vulnerabilités (Docker Desktop)
docker scout quickview
docker scout cves image_name

# Lancer container en lecture seule
docker run --read-only nginx

# Limiter capabilities
docker run --cap-drop ALL --cap-add NET_BIND_SERVICE nginx

# Utiliser utilisateur non-root
docker run --user 1000:1000 nginx

Optimisation et performance

1
2
3
4
5
6
7
8
# Limiter ressources
docker run -m 512m --cpus="1.5" nginx

# Utiliser cache pour build
docker build --build-arg BUILDKIT_INLINE_CACHE=1 .

# Multi-platform build
docker buildx build --platform linux/amd64,linux/arm64 -t app:latest .

🚀 Exemples pratiques complets

Application web Python + PostgreSQL

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# docker-compose.yml
version: '3.8'

services:
  web:
    build: .
    ports:
      - "5000:5000"
    environment:
      - DATABASE_URL=postgresql://user:password@db:5432/webapp
    depends_on:
      - db
    volumes:
      - .:/app
    
  db:
    image: postgres:14
    environment:
      POSTGRES_DB: webapp
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    volumes:
      - postgres_data:/var/lib/postgresql/data
    ports:
      - "5432:5432"

volumes:
  postgres_data:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
# Dockerfile
FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 5000

CMD ["python", "app.py"]

Stack NGINX + PHP + MySQL

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
# docker-compose.yml
version: '3.8'

services:
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
      - ./public:/var/www/html
    depends_on:
      - php

  php:
    image: php:8.1-fpm
    volumes:
      - ./public:/var/www/html
    environment:
      - MYSQL_HOST=mysql
      - MYSQL_DATABASE=webapp
      - MYSQL_USER=user
      - MYSQL_PASSWORD=password

  mysql:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: rootpass
      MYSQL_DATABASE: webapp
      MYSQL_USER: user
      MYSQL_PASSWORD: password
    volumes:
      - mysql_data:/var/lib/mysql
    ports:
      - "3306:3306"

volumes:
  mysql_data:

Application Node.js avec Redis

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
# docker-compose.yml
version: '3.8'

services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - REDIS_URL=redis://redis:6379
    depends_on:
      - redis
    restart: unless-stopped

  redis:
    image: redis:7-alpine
    command: redis-server --appendonly yes
    volumes:
      - redis_data:/data
    ports:
      - "6379:6379"

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - app

volumes:
  redis_data:

🐳 Docker Swarm (orchestration)

Initialisation du swarm

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
# Initialiser swarm manager
docker swarm init

# Rejoindre swarm comme worker
docker swarm join --token SWMTKN-1-xxx manager-ip:2377

# Lister nodes
docker node ls

# Promouvoir worker en manager
docker node promote node-name

Services Swarm

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
# Créer service
docker service create --name web --replicas 3 -p 80:80 nginx

# Lister services
docker service ls
docker service ps web

# Mettre à jour service
docker service update --image nginx:alpine web
docker service scale web=5

# Supprimer service
docker service rm web

Stack deployment

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# docker-stack.yml
version: '3.8'

services:
  web:
    image: nginx:alpine
    ports:
      - "80:80"
    deploy:
      replicas: 3
      update_config:
        parallelism: 1
        delay: 10s
      restart_policy:
        condition: on-failure
    networks:
      - webnet

  visualizer:
    image: dockersamples/visualizer:stable
    ports:
      - "8080:8080"
    volumes:
      - "/var/run/docker.sock:/var/run/docker.sock"
    deploy:
      placement:
        constraints: [node.role == manager]

networks:
  webnet:

1
2
3
4
5
6
7
8
9
# Déployer stack
docker stack deploy -c docker-stack.yml mystack

# Lister stacks
docker stack ls
docker stack services mystack

# Supprimer stack
docker stack rm mystack

🔍 Debugging et troubleshooting

Diagnostics containers

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
# Vérifier processus container
docker exec container_name ps aux

# Vérifier connectivité réseau
docker exec container_name ping google.com
docker exec container_name nslookup database

# Vérifier ports ouverts
docker exec container_name netstat -tlnp

# Vérifier filesystem
docker exec container_name df -h
docker exec container_name ls -la /path

Analyse des logs

1
2
3
4
5
6
7
8
9
# Logs détaillés avec timestamps
docker logs --timestamps container_name

# Filtrer logs par date
docker logs --since="2024-01-01T00:00:00" container_name
docker logs --until="2024-01-01T23:59:59" container_name

# Logs en continu avec grep
docker logs -f container_name | grep ERROR

Problèmes courants et solutions

Problème	Solution
Container s’arrête immédiatement	Vérifier CMD/ENTRYPOINT, logs
Port déjà utilisé	Changer port mapping `-p 8081:80`
Permission denied	Vérifier utilisateur, SELinux
Out of disk space	`docker system prune -a`
Container ne démarre pas	`docker logs container_name`
DNS ne fonctionne pas	Vérifier réseau Docker

📊 Monitoring et observabilité

Docker stats et métriques

1
2
3
4
5
6
# Stats en temps réel
docker stats
docker stats --format "table {{.Container}}\t{{.CPUPerc}}\t{{.MemUsage}}"

# Export métriques
docker stats --no-stream --format "json" > stats.json

Intégration monitoring

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# Prometheus + Grafana stack
version: '3.8'

services:
  prometheus:
    image: prom/prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      
  grafana:
    image: grafana/grafana
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
    volumes:
      - grafana_data:/var/lib/grafana

  cadvisor:
    image: gcr.io/cadvisor/cadvisor
    ports:
      - "8080:8080"
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:rw
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro

volumes:
  grafana_data:

🔒 Sécurité Docker

Bonnes pratiques sécurité

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
# Dockerfile sécurisé
FROM node:16-alpine

# Créer utilisateur non-root
RUN addgroup -g 1001 -S nodejs && \
    adduser -S nextjs -u 1001

# Copier seulement nécessaire
COPY --chown=nextjs:nodejs package*.json ./
RUN npm ci --only=production && npm cache clean --force

# Utiliser utilisateur non-root
USER nextjs

# Exposer port non-privilégié
EXPOSE 3000

# Sanity check
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
    CMD curl -f http://localhost:3000/health || exit 1

Runtime security

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
# Lancer avec restrictions
docker run --security-opt=no-new-privileges:true \
           --cap-drop ALL \
           --cap-add NET_BIND_SERVICE \
           --read-only \
           --tmpfs /tmp \
           --user 1000:1000 \
           nginx

# Scanner image pour vulnérabilités
docker run --rm -v /var/run/docker.sock:/var/run/docker.sock \
           aquasec/trivy image nginx:latest

📚 Ressources et outils utiles

Extensions et plugins

1
2
3
# Docker extensions utiles
docker extension install docker/logs-explorer-extension
docker extension install docker/disk-usage-extension

Outils de développement

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
# Docker-compose override pour dev
# docker-compose.override.yml
version: '3.8'
services:
  app:
    volumes:
      - .:/app
    environment:
      - DEBUG=1
    command: npm run dev

Scripts utiles

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#!/bin/bash
# docker-cleanup.sh - Nettoyage complet

echo "🧹 Nettoyage Docker en cours..."

# Arrêter tous containers
docker stop $(docker ps -q) 2>/dev/null

# Supprimer containers arrêtés
docker container prune -f

# Supprimer images inutilisées
docker image prune -a -f

# Supprimer volumes non utilisés
docker volume prune -f

# Supprimer réseaux non utilisés
docker network prune -f

# Nettoyage système complet
docker system prune -a --volumes -f

echo "✅ Nettoyage terminé!"
docker system df

💡 Tips et astuces avancées

Optimisation des builds

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
# Utiliser .dockerignore
# .dockerignore
node_modules
.git
*.md
.env.local

# Multi-stage pour réduire taille
FROM node:16 AS dependencies
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

FROM node:16-alpine AS runtime
WORKDIR /app
COPY --from=dependencies /app/node_modules ./node_modules
COPY . .
EXPOSE 3000
CMD ["npm", "start"]

Variables d’environnement

1
2
3
4
5
6
7
# Fichier .env pour docker-compose
# .env
MYSQL_ROOT_PASSWORD=secure_password
MYSQL_DATABASE=myapp
MYSQL_USER=appuser
MYSQL_PASSWORD=apppass
NODE_ENV=production

Automation avec Makefile

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# Makefile
.PHONY: build up down logs clean

build:
	docker-compose build

up:
	docker-compose up -d

down:
	docker-compose down

logs:
	docker-compose logs -f

clean:
	docker system prune -a --volumes -f

restart: down up

shell-app:
	docker-compose exec app /bin/bash

backup-db:
	docker-compose exec db pg_dump -U user myapp > backup.sql

🎯 Commandes de référence rapide

One-liners utiles

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
# Supprimer tous containers
docker rm -f $(docker ps -aq)

# Supprimer toutes images
docker rmi -f $(docker images -q)

# Entrer dans dernier container lancé
docker exec -it $(docker ps -q -l) /bin/bash

# Logs de tous containers
docker ps -q | xargs -I {} docker logs {}

# Statistiques formatées
docker stats --format "table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}\t{{.NetIO}}"

# Backup volume vers tar
docker run --rm -v volume_name:/data -v $(pwd):/backup alpine tar czf /backup/backup.tar.gz -C /data .

Alias bash utiles

1
2
3
4
5
6
7
8
9
# Ajouter à ~/.bashrc
alias dps='docker ps'
alias dpa='docker ps -a'
alias di='docker images'
alias dlog='docker logs -f'
alias dex='docker exec -it'
alias dcu='docker-compose up -d'
alias dcd='docker-compose down'
alias dcl='docker-compose logs -f'

Docker révolutionne le déploiement d’applications. Maîtrisez ces commandes pour optimiser vos workflows de développement et de production !

Docker Cheatsheet#

🐳 Installation de Docker#

Ubuntu/Debian#

CentOS/RHEL/Fedora#

Vérification installation#

📦 Gestion des images#

Télécharger et lister des images#

Construire des images#

Gestion avancée des images#

Registry et partage#

🏃‍♂️ Gestion des containers#

Lancer des containers#

Contrôle des containers#

Interaction avec les containers#

Logs et monitoring#

Nettoyage des containers#

💾 Gestion des volumes#

Types de volumes#

Commandes de gestion des volumes#

Sauvegarde et restauration#

🌐 Gestion des réseaux#

Types de réseaux Docker#

Commandes réseau#

Utilisation des réseaux#

📋 Dockerfile - Construction d’images#

Structure de base#

Instructions Dockerfile principales#

Bonnes pratiques Dockerfile#

🐙 Docker Compose#

Installation Docker Compose#

Fichier docker-compose.yml basique#

Commandes Docker Compose#

Configuration avancée#

🔧 Docker utilitaires et outils#

Système et maintenance#

Sécurité#

Optimisation et performance#

🚀 Exemples pratiques complets#

Application web Python + PostgreSQL#

Stack NGINX + PHP + MySQL#

Application Node.js avec Redis#

🐳 Docker Swarm (orchestration)#

Initialisation du swarm#

Services Swarm#

Stack deployment#

🔍 Debugging et troubleshooting#

Diagnostics containers#

Analyse des logs#

Problèmes courants et solutions#

📊 Monitoring et observabilité#

Docker stats et métriques#

Intégration monitoring#

🔒 Sécurité Docker#

Bonnes pratiques sécurité#

Runtime security#

📚 Ressources et outils utiles#

Extensions et plugins#

Outils de développement#

Scripts utiles#

💡 Tips et astuces avancées#

Optimisation des builds#

Variables d’environnement#

Automation avec Makefile#

🎯 Commandes de référence rapide#

One-liners utiles#

Alias bash utiles#