## Introduction

La gestion des données sensibles telles que les mots de passe, les clés API et les certificats TLS à l'intérieur des conteneurs est un défi opérationnel courant. Stocker les secrets dans les images, les variables d'environnement ou le code applicatif crée des risques de sécurité et complique la rotation. Docker Secrets fournit un mécanisme intégré pour transmettre et gérer les secrets de manière sécurisée dans Docker Swarm.

Ce guide se concentre sur les commandes et les flux de travail nécessaires pour utiliser efficacement Docker Secrets. Vous apprendrez à créer, inspecter, utiliser et faire pivoter les secrets, avec des exemples pratiques et des techniques de dépannage. L'objectif est la sécurité opérationnelle : comprendre l'état actuel avant d'apporter des modifications, limiter le rayon d'impact, protéger les valeurs réelles des secrets et toujours vérifier le résultat.

## Prérequis et inventaire de l'environnement

Avant d'utiliser Docker Secrets, vous devez exécuter Docker en mode Swarm. Les secrets sont une fonctionnalité de Swarm et ne sont pas disponibles pour les conteneurs autonomes. Vérifiez votre version de Docker et l'état de Swarm avec :

```bash
docker version
```

Recherchez la version du serveur et assurez-vous qu'elle est 1.13 ou supérieure (la version qui a introduit les secrets). Pour vérifier que le mode Swarm est actif :

```bash
docker info --format '{{.Swarm.LocalNodeState}}'
```

La sortie attendue est `active`. Si c'est `inactive`, initialisez un swarm avec :

```bash
docker swarm init
```

Sur un nœud manager, vous pouvez gérer les secrets. Les nœuds worker peuvent accéder aux secrets uniquement si le service y est planifié.

Un inventaire rapide de l'environnement permet d'identifier ce qui est en cours d'exécution et où les secrets pourraient être utilisés. Utilisez ces commandes :

```bash
# Lister les conteneurs en cours d'exécution avec noms, statut et ports
docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"

# Lister les services dans le swarm
docker service ls

# Inspecter un service pour voir ses références aux secrets
docker service inspect <nom-du-service> --pretty
```

Par exemple, vous pourriez voir un service nommé `web` qui référence un secret appelé `db_password`.

Lorsque vous traitez des volumes de données, il est important de savoir où les fichiers sont stockés. Un volume nommé comme `app_data:/var/lib/app` est géré par Docker et persiste lors des reconstructions de conteneurs. Un montage bind comme `./data:/var/lib/app` mappe un répertoire hôte et est utile pour le développement mais peut causer des problèmes de permissions et de portabilité. Testez la persistance en arrêtant, recréant et vérifiant les données.

## Création et gestion des secrets

### Création de secrets

Il existe plusieurs façons de créer un secret. La plus courante est à partir d'un fichier ou de l'entrée standard.

**À partir d'un fichier :**

Le fichier doit contenir la valeur du secret sans sauts de ligne à la fin. Par exemple, créez un fichier `db_password.txt` avec le contenu `s3cr3tP@ss`. Ensuite, exécutez :

```bash
docker secret create db_password db_password.txt
```

Cette commande affiche l'ID du secret, comme `a1b2c3d4e5f6`. Le secret est désormais stocké chiffré dans le journal Raft du Swarm et disponible pour les services.

**À partir de l'entrée standard :**

Vous pouvez acheminer une valeur directement, mais faites attention à l'historique du shell. Par exemple :

```bash
echo "s3cr3tP@ss" | docker secret create db_password -
```

Utiliser `-` comme source indique à Docker de lire depuis stdin. Notez que l'utilisation d'`echo` peut exposer le secret dans les listes de processus. Des alternatives plus sûres utilisent un gestionnaire de mots de passe ou un fichier.

**Utilisation d'un libellé :**

Vous pouvez ajouter des libellés aux secrets pour faciliter la gestion :

```bash
docker secret create --label env=prod db_password db_password.txt
```

Les libellés aident à organiser les secrets selon les environnements.

### Liste des secrets

Pour voir tous les secrets dans le swarm :

```bash
docker secret ls
```

Exemple de sortie :

```
ID                          NAME          CREATED             UPDATED
abc123def456                db_password   5 minutes ago       5 minutes ago
xyz789uvw012                api_key       2 hours ago         2 hours ago
```

Cela montre les ID des secrets, les noms et les horodatages. Notez que les valeurs des secrets ne sont jamais affichées.

### Inspection des secrets

Pour afficher les métadonnées d'un secret :

```bash
docker secret inspect db_password
```

Cela renvoie du JSON, incluant l'ID, le nom, les libellés et la date de création, mais jamais la valeur du secret. Exemple :

```json
[
  {
    "ID": "abc123def456",
    "Version": {
      "Index": 1
    },
    "CreatedAt": "2025-03-15T10:00:00Z",
    "UpdatedAt": "2025-03-15T10:00:00Z",
    "Spec": {
      "Name": "db_password",
      "Labels": {}
    }
  }
]
```

### Suppression de secrets

Pour supprimer un secret qui n'est plus nécessaire :

```bash
docker secret rm db_password
```

Note : Vous ne pouvez pas supprimer un secret actuellement utilisé par un service en cours d'exécution. D'abord, mettez à jour ou supprimez le service, puis supprimez le secret.

## Utilisation des secrets dans les services

Les secrets sont montés sous forme de fichiers dans les conteneurs à `/run/secrets/<nom-du-secret>`. Pour utiliser un secret, vous devez accorder à un service l'accès à celui-ci.

### Création d'un service avec un secret

Cet exemple crée un service avec un secret :

```bash
docker service create \
  --name web \
  --secret db_password \
  --publish 80:80 \
  nginx:latest
```

Le secret sera monté à `/run/secrets/db_password` dans le conteneur. Vous pouvez le vérifier en exécutant une commande dans le conteneur en cours d'exécution :

```bash
docker exec -it $(docker ps -q -f name=web) cat /run/secrets/db_password
```

Cela affiche la valeur du secret. Soyez prudent avec cette commande en production.

Vous pouvez spécifier un chemin cible personnalisé :

```bash
docker service create \
  --name web \
  --secret source=db_password,target=/etc/secrets/db_password \
  --publish 80:80 \
  nginx:latest
```

Le fichier du secret sera à `/etc/secrets/db_password`.

Vous pouvez également définir les permissions du fichier pour le secret :

```bash
docker service create \
  --name web \
  --secret source=db_password,target=/run/secrets/db_password,mode=0400 \
  --publish 80:80 \
  nginx:latest
```

Cela restreint l'accès en lecture au propriétaire du fichier uniquement.

### Mise à jour d'un service pour ajouter ou supprimer des secrets

Pour ajouter un secret à un service existant :

```bash
docker service update --secret-add db_password web
```

Pour supprimer un secret :

```bash
docker service update --secret-rm db_password web
```

Note : Cela déclenchera une mise à jour continue du service, recréant les conteneurs.

### Utilisation des secrets dans Docker Compose

Dans les fichiers Compose (version 3.1+), vous pouvez définir les secrets dans la clé de premier niveau `secrets`. Exemple :

```yaml
version: '3.8'

services:
  web:
    image: nginx:latest
    secrets:
      - db_password
    environment:
      - DB_PASSWORD_FILE=/run/secrets/db_password
    deploy:
      replicas: 2
    ports:
      - "80:80"

secrets:
  db_password:
    external: true
```

Ici, le secret `db_password` doit déjà exister dans le swarm. Le service le monte à `/run/secrets/db_password`, et l'application peut lire la valeur depuis ce fichier.

Vous pouvez également définir le contenu du secret dans le fichier Compose en utilisant `file:` :

```yaml
secrets:
  db_password:
    file: ./db_password.txt
```

Cependant, il est plus sûr de garder les valeurs des secrets hors du fichier Compose et du contrôle de source.

## Rotation des secrets

La rotation des secrets est essentielle pour la sécurité. Docker ne fait pas automatiquement pivoter les secrets ; vous devez créer un nouveau secret et mettre à jour les services pour l'utiliser. Voici une procédure de rotation sûre :

1. Créez un nouveau secret avec une nouvelle valeur :

```bash
docker secret create db_password_v2 new_secret_value.txt
```

2. Mettez à jour le service pour utiliser temporairement les anciens et nouveaux secrets, permettant aux applications d'accepter les deux. Par exemple, si votre application peut lire plusieurs fichiers de secrets, ajoutez le nouveau secret :

```bash
docker service update --secret-add db_password_v2 web
```

3. Mettez à jour l'application pour utiliser le nouveau secret, puis supprimez l'ancien du service :

```bash
docker service update --secret-rm db_password web
```

4. Supprimez l'ancien secret du swarm après avoir confirmé qu'aucun service ne l'utilise :

```bash
docker secret rm db_password
```

Ce processus minimise les temps d'arrêt et évite de bloquer les services.

## Dépannage et diagnostics

### Secret non accessible dans le conteneur

Si le fichier du secret est manquant ou illisible, vérifiez les points suivants :

- Assurez-vous que le service a le secret attaché. Utilisez `docker service inspect <service> --pretty` et recherchez la section `Secrets`.
- Vérifiez le chemin cible. Par défaut, c'est `/run/secrets/<nom>`. Si vous avez spécifié une cible personnalisée, assurez-vous que l'application lit depuis ce chemin.
- Vérifiez les permissions du fichier. Si vous avez défini un mode restrictif, assurez-vous que l'utilisateur exécutant l'application a l'accès en lecture.
- Si le service a été créé avant l'ajout du secret, mettez à jour le service avec `--secret-add`.

### Suppression d'un secret en cours d'utilisation

Si vous essayez `docker secret rm db_password` et obtenez une erreur comme `Error response from daemon: rpc error: code = InvalidArgument desc = secret 'db_password' is in use by the following service: web`, vous devez d'abord supprimer le secret de tous les services. Utilisez `docker service update --secret-rm db_password <service>` pour chaque service, puis réessayez la suppression.

### Valeurs des secrets et exposition dans le shell

Évitez d'exposer les valeurs des secrets dans l'historique du shell ou les listes de processus. Au lieu de `echo "secret" | docker secret create`, utilisez un fichier généré par un gestionnaire de mots de passe ou un here-document sans exposition en ligne de commande. Par exemple :

```bash
docker secret create db_password - <<EOF
s3cr3tP@ss
EOF
```

Cela peut encore être exposé dans certains shells ; l'utilisation d'un fichier est plus sûre.

### Débogage avec les journaux Docker et exec

Pour voir les journaux récents d'un conteneur de service :

```bash
docker service logs web --tail 100
```

Pour entrer dans un conteneur en cours d'exécution pour inspection :

```bash
docker exec -it <container-id> sh
```

Ensuite, vérifiez le fichier du secret :

```bash
cat /run/secrets/db_password
```

Utilisez ces commandes pour vérifier que le secret est présent et contient la valeur attendue.

## Pièges courants et erreurs

### Stockage des secrets dans les images ou les variables d'environnement

**Erreur :** Intégrer des secrets dans les Dockerfiles ou utiliser des variables d'environnement comme `ENV DB_PASSWORD=secret`.

**Pourquoi cela arrive :** Cela semble pratique et fonctionne en développement local.

**Comment éviter :** Utilisez Docker Secrets pour toutes les données sensibles dans Swarm. Pour le développement local sans Swarm, envisagez un gestionnaire de secrets ou des fichiers `.env` exclus du contrôle de version. Les variables d'environnement sont visibles dans `docker inspect` et peuvent fuiter dans les journaux ou les listes de processus.

### Ne pas faire pivoter les secrets régulièrement

**Erreur :** Utiliser le même secret indéfiniment.

**Pourquoi cela arrive :** La rotation est manuelle et peut causer des temps d'arrêt si elle n'est pas faite avec soin.

**Comment éviter :** Mettez en place un calendrier de rotation (par exemple, tous les 90 jours) et utilisez l'approche multi-secrets décrite précédemment pour éviter les temps d'arrêt. Automatisez le processus avec des scripts ou des pipelines CI/CD.

### Création de secrets avec des sauts de ligne à la fin

**Erreur :** Lors de la création d'un secret à partir d'un fichier, le fichier peut contenir un saut de ligne à la fin. Ce saut de ligne fait partie de la valeur du secret et peut causer des échecs d'authentification.

**Pourquoi cela arrive :** Les éditeurs de texte ajoutent souvent un saut de ligne à la fin d'un fichier.

**Comment éviter :** Utilisez `printf` sans saut de ligne à la fin pour créer le fichier, ou supprimez les sauts de ligne avant de créer le secret :

```bash
printf 's3cr3tP@ss' > db_password.txt
docker secret create db_password db_password.txt
```

### Oubli de supprimer les secrets inutilisés

**Erreur :** Laisser d'anciens secrets dans le swarm après la rotation ou la suppression du service.

**Pourquoi cela arrive :** Il est facile d'oublier ou de supposer qu'ils sont inoffensifs.

**Comment éviter :** Auditez régulièrement les secrets avec `docker secret ls` et supprimez ceux qui ne sont pas utilisés. Utilisez des libellés pour suivre la propriété et l'expiration.

### Mauvaise gestion des permissions des secrets

**Erreur :** Définir des permissions de fichier de secret trop ouvertes (par exemple, `0644`) ou trop restrictives (par exemple, `0000`) causant des erreurs applicatives.

**Pourquoi cela arrive :** Manque de compréhension des contextes utilisateur des conteneurs.

**Comment éviter :** Utilisez `mode=0400` pour la plupart des secrets et assurez-vous que l'application s'exécute en tant qu'utilisateur pouvant lire le fichier. Testez dans un environnement non productif.

## Bonnes pratiques et considérations de sécurité

- **Moindre privilège :** Accordez les secrets uniquement aux services qui en ont besoin. Évitez d'utiliser `--secret` de manière large ; attachez par service.
- **Chiffrement en transit et au repos :** Les secrets sont chiffrés lors de la transmission aux conteneurs et stockés chiffrés dans le journal Raft. Cependant, ils sont stockés non chiffrés sur les systèmes de fichiers des conteneurs ; minimisez l'accès.
- **Rotation régulière :** Faites pivoter les secrets périodiquement et après toute compromission suspectée.
- **Éviter de journaliser les secrets :** Assurez-vous que les applications ne journalisent pas les valeurs des secrets. Utilisez la surveillance pour détecter une exposition accidentelle.
- **Sauvegarder les secrets en toute sécurité :** Si vous devez sauvegarder les secrets, utilisez un stockage chiffré et des contrôles d'accès stricts.
- **Utiliser des libellés pour la gestion :** Étiquetez les secrets avec l'environnement, le propriétaire et la date d'expiration pour faciliter les audits.

## Conclusion

Docker Secrets est une fonctionnalité puissante pour gérer les données sensibles dans les clusters Swarm. En suivant les commandes et les exemples de ce guide, vous pouvez créer, utiliser et faire pivoter les secrets en toute sécurité tout en minimisant les risques opérationnels. N'oubliez pas de vérifier votre environnement, d'utiliser des pratiques sûres et d'auditer régulièrement vos secrets.

Prochaines étapes : choisissez un service à faible risque, attachez-lui un secret et vérifiez son accessibilité dans le conteneur. Ensuite, planifiez une procédure de rotation et documentez-la pour votre équipe. Avec une gestion soignée, Docker Secrets peut devenir une pierre angulaire de votre posture de sécurité des conteneurs.