Commandes Docker Essentielles & Registries

Maîtriser les commandes Docker du quotidien : gérer les images, les containers, les ports et interagir avec des registries publics ou privés.

Commandes principales

Gestion des images

docker pull nginx:1.25          # Télécharger une image depuis Docker Hub
docker images                   # Lister toutes les images locales
docker rmi nginx:1.25           # Supprimer une image locale

Gestion des containers

docker run nginx:1.25           # Créer ET démarrer un container depuis une image
docker run -d nginx:1.25        # En arrière-plan (detached mode)
docker run -d -p 8080:80 nginx  # Avec mapping de port

docker start <container-id>     # Démarrer un container arrêté
docker stop <container-id>      # Arrêter un container en cours d'exécution
docker rm <container-id>        # Supprimer un container (doit être arrêté)

docker ps                       # Lister les containers EN COURS D'EXÉCUTION
docker ps -a                    # Lister TOUS les containers (running + exited)

Commandes de debug

docker logs <container-id>          # Afficher les logs du container
docker logs -f <container-id>       # Suivre les logs en temps réel

docker exec -it <container-id> bash # Ouvrir un shell dans le container
docker exec -it <container-id> sh   # Si bash n'est pas disponible

Tableau de référence rapide

Ports dans Docker

Plusieurs containers peuvent tourner sur la même machine hôte. Chaque container utilise ses propres ports internes — il faut les mapper sur des ports de l'hôte.

Problème sans mapping de port

Hôte                Container A (port 3000)
                    Container B (port 3000)  ← conflit !

Solution : Port Binding (-p)

docker run -p <host-port>:<container-port> {image}

# Exemples :
docker run -d -p 8080:80 nginx          # hôte:8080 → container:80
docker run -d -p 5432:5432 postgres     # hôte:5432 → container:5432
docker run -d -p 3001:3000 mon-app      # hôte:3001 → container:3000

Hôte (port 3001)  ──►  Container (port 3000)
Accès : http://localhost:3001

• Host Port = port sur la machine hôte (ce que vous tapez dans le navigateur)
• Container Port = port interne à l'application dans le container

Deux containers peuvent utiliser le même port interne (ex: 3000), mais doivent être mappés sur des ports hôtes différents.

Workflow avec Docker

1. Développeur code l'app (JS, Java, Python...)
           │
           ▼ git commit
2. Git repository
           │
           ▼ trigger CI/CD
3. CI Server (Jenkins, GitLab CI)
   ├── Télécharge les dépendances (npm install, mvn install)
   ├── Build le Dockerfile → Docker Image
   └── Push l'image vers le registry
           │
           ▼ push
4. Registry (Docker Hub public OU AWS ECR privé)
           │
           ▼ pull
5. Serveur de déploiement
   └── docker run image:version

Public vs Private Docker Registry

Docker Hub (Public)

Repository par défaut — docker.io est l'adresse implicite :

docker pull mongo:4.2
# équivalent à :
docker pull docker.io/library/mongo:4.2

Registry Privé — AWS ECR

En entreprise, vos images propriétaires sont stockées dans un registry privé. Exemple : AWS ECR (Elastic Container Registry).

3 étapes pour publier dans un registry privé :

# 1. Authentification (login)
docker login <registry-url> -u <username> -p <password>

# 2. Tagger l'image avec l'adresse complète du registry
docker tag mon-app:1.0 <registry-domain>/mon-app:1.0

# 3. Pousser l'image taguée
docker push <registry-domain>/mon-app:1.0

Exemple concret avec AWS ECR :

# Format : <account-id>.dkr.ecr.<region>.amazonaws.com/<repo-name>:<tag>

# Login AWS ECR
aws ecr get-login-password --region eu-central-1 | \
  docker login --username AWS --password-stdin \
  454342277166.dkr.ecr.eu-central-1.amazonaws.com

# Tagger
docker tag mon-app:1.0 \
  454342277166.dkr.ecr.eu-central-1.amazonaws.com/mon-app:1.0

# Push
docker push 454342277166.dkr.ecr.eu-central-1.amazonaws.com/mon-app:1.0

Pour télécharger depuis ECR :

docker pull 454342277166.dkr.ecr.eu-central-1.amazonaws.com/mon-app:1.0

Format général d'une image

registryDomain/imageName:tag

# Exemples :
docker.io/library/nginx:1.25                              ← Docker Hub officiel
mon-compte/mon-app:2.1                                    ← Docker Hub perso
454342277166.dkr.ecr.eu-central-1.amazonaws.com/app:1.0  ← AWS ECR

Déployer sur un serveur distant

Sur un serveur de déploiement, on peut puller depuis les deux types de registry :

# Images publiques (MySQL, MongoDB, Redis)
docker pull mongo:6
docker pull redis:7

# Images privées (votre application)
docker login <registry-privé>
docker pull <registry-privé>/mon-app:1.0

# Lancer les containers
docker run -d -p 27017:27017 mongo:6
docker run -d -p 8080:3000 <registry-privé>/mon-app:1.0

À retenir

• docker run = crée ET démarre un container (= docker pull + docker create + docker start)
• docker ps = containers actifs ; docker ps -a = tous les containers
• docker exec -it <id> bash = entrer dans un container pour débugger
• Port binding : -p hostPort:containerPort — mapper un port hôte vers le container
• Docker Hub (public) : pas de login nécessaire pour puller
• Registry privé (AWS ECR) : login obligatoire + tagger avec l'adresse complète du registry
• Format image privée : registryDomain/imageName:tag