E-NO
DevOps 10 min de lecture

Docker Secrets : commandes essentielles et exemples pratiques

calendar_today Publié : 2026-11-19
update Dernière mise à jour : 2026-11-19
analytics Efficacité SEO : 100%
Illustration du guide technique pour « Docker Secrets : commandes essentielles et exemples pratiques ».

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 :

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 :

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

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

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 :

# 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 :

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 :

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 :

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 :

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 :

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 :

[
  {
    "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 :

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.

Question rapide 1 sur 2

Lequel des éléments suivants n'est PAS listé comme exemple de données sensibles pouvant être gérées avec les secrets Docker ?

Le passage liste les noms d'utilisateur et mots de passe, les certificats et clés TLS, les clés SSH, les noms de base de données et les chaînes génériques ou contenus binaires comme exemples de données sensibles pouvant être gérées avec les secrets. Les journaux de conteneurs ne sont pas mentionnés.

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 :

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 :

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é :

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 :

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 :

docker service update --secret-add db_password web

Pour supprimer un secret :

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 :

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: :

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 :
docker secret create db_password_v2 new_secret_value.txt
  1. 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 :
docker service update --secret-add db_password_v2 web
  1. Mettez à jour l'application pour utiliser le nouveau secret, puis supprimez l'ancien du service :
docker service update --secret-rm db_password web
  1. Supprimez l'ancien secret du swarm après avoir confirmé qu'aucun service ne l'utilise :
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 :

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 :

docker service logs web --tail 100

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

docker exec -it <container-id> sh

Ensuite, vérifiez le fichier du secret :

cat /run/secrets/db_password

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

Question rapide 2 sur 2

Selon le passage, quelle est la taille maximale d'un secret ?

Le passage indique que les secrets peuvent être des chaînes génériques ou du contenu binaire jusqu'à 500 Ko.

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 :

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.

Recherches connexes

Score de qualité de l’article

Utilité pour le lecteur 100%
  • check_circle Guide prêt à lire
  • check_circle Exemples pratiques inclus
  • check_circle URL d’article optimisée pour le SEO