---
date: 2025-03-01
favoris: true
tags:
- docker
- devops
- conteneur
title: Docker Guide
---

# Docker Guide

## Installation de Docker

### Sur Linux (Debian/Ubuntu)
```bash
# Mettre à jour les paquets
sudo apt update

# Installer les dépendances
sudo apt install -y apt-transport-https ca-certificates curl gnupg lsb-release

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

# Ajouter le dépôt Docker
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 Engine
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io

# Vérifier l'installation
sudo docker run hello-world
```

### Sur macOS/Windows
- Télécharger [Docker Desktop](https://www.docker.com/products/docker-desktop/) et suivre les instructions.

---

## Commandes essentielles

```bash
# Lister les conteneurs
docker ps -a

# Build une image
docker build -t myapp:latest .

# Lancer un conteneur
docker run -d -p 8080:80 --name my_container myapp:latest

# Voir les logs
docker logs -f my_container

# Arrêter un conteneur
docker stop my_container

# Supprimer un conteneur
docker rm my_container

# Supprimer une image
docker rmi myapp:latest
```

---

## Réseaux Docker

Docker propose plusieurs types de réseaux pour isoler ou connecter vos conteneurs :

| Type       | Description                          | Exemple d'utilisation               |
|------------|--------------------------------------|-------------------------------------|
| **bridge** | Réseau par défaut pour les conteneurs | `docker run -p 8080:80 myapp`       |
| **host**   | Conteneur utilise l'IP de l'hôte     | `docker run --network host myapp`   |
| **overlay**| Pour les swarms multi-hôtes           | Utilisé avec `docker stack deploy`  |

**Exemple : Créer un réseau personnalisé**
```bash
docker network create my_network
docker run -d --network my_network --name db redis
```

---

## Volumes

Les volumes permettent de persister les données :

- **Named volumes** : gérés par Docker
  ```bash
docker volume create my_volume
docker run -v my_volume:/data myapp
```

- **Bind mounts** : montage direct depuis l'hôte
  ```bash
docker run -v /chemin/absolu:/data myapp
```

- **tmpfs** : stockage en mémoire
  ```bash
docker run --tmpfs /data myapp
```

Voir aussi : [[Proxmox Setup]]

---

## Docker Compose

Exemple de fichier `docker-compose.yml` avec variables d'environnement et dépendances :

```yaml
version: "3.9"

services:
  web:
    image: nginx:alpine
    ports:
      - "80:80"
    environment:
      - NGINX_ENV=production
    depends_on:
      - redis
    networks:
      - frontend

  redis:
    image: redis:alpine
    volumes:
      - redis_data:/data
    networks:
      - frontend

volumes:
  redis_data:

networks:
  frontend:
    driver: bridge
```

**Commandes utiles**
```bash
# Démarrer les services
docker-compose up -d

# Arrêter les services
docker-compose down

# Voir les logs
docker-compose logs -f
```

---

## Dockerfile : Exemple commenté

Voici un exemple de `Dockerfile` pour une application Python (FastAPI) :

```dockerfile
# Utiliser une image officielle Python comme base
FROM python:3.9-slim

# Définir le répertoire de travail
WORKDIR /app

# Copier les fichiers de dépendances
COPY requirements.txt .

# Installer les dépendances
RUN pip install --no-cache-dir -r requirements.txt

# Copier le reste du code source
COPY . .

# Exposer le port 8000
EXPOSE 8000

# Commande pour lancer l'application
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
```

**Bonnes pratiques pour un Dockerfile** :
- Utiliser des images `slim` ou `alpine` pour réduire la taille.
- Multi-stage builds pour les applications compilées (Go, Rust, etc.).
- Toujours inclure un fichier `.dockerignore`.

---

## Sécurité

### Bonnes pratiques
- **Éviter de lancer des conteneurs en tant que `root`** :
  ```bash
docker run --user 1000:1000 myapp
```

- **Rendre le système de fichiers en lecture seule** :
  ```bash
docker run --read-only myapp
```

- **Limiter les capacités du conteneur** :
  ```bash
docker run --cap-drop=ALL --cap-add=NET_BIND_SERVICE myapp
```

- **Scanner les images pour des vulnérabilités** :
  Utiliser des outils comme [Trivy](https://github.com/aquasecurity/trivy) ou [Clair](https://github.com/quay/clair).

---

## Nettoyage des ressources

Pour libérer de l'espace, supprimez les ressources inutilisées :

```bash
# Supprimer les conteneurs arrêtés
docker container prune

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

# Supprimer les volumes inutilisés
docker volume prune

# Supprimer les réseaux inutilisés
docker network prune

# Nettoyer TOUT (attention, irréversible !)
docker system prune -a --volumes
```

---

## Bonnes pratiques

- [x] Utiliser des images Alpine ou `slim`
- [x] Multi-stage builds pour les applications compilées
- [x] Fichier `.dockerignore`
- [x] Un processus par conteneur
- [x] Limiter les ressources (CPU/mémoire) avec `--memory` et `--cpus`
- [x] Utiliser des secrets pour les variables sensibles (ex: `--env-file` ou `docker secret`)

---

## Ressources utiles
- [Documentation officielle Docker](https://docs.docker.com/)
- [Docker Curriculum](https://docker-curriculum.com/)
- [Awesome Docker](https://github.com/veggiemonk/awesome-docker)
- [Tutoriel Docker Compose](https://docs.docker.com/compose/)

Voir aussi : [[Proxmox Setup]]