# Docker Swarm - Gestion des secrets 

Un **secret** est une information qui doit rester cachée aux utilisateurs et applications non autorisés. Les noms d'utilisateur, les mots de passe, les clés privées, les certificats et les noms et emplacements des ressources sont des exemples de secrets.   

L'objectif des secrets est de stocker des informations sensibles, nécessaires aux services, dans un endroit sûr. En d'autres termes, vous devez éviter de stocker ces informations en clair dans les images docker et les fichiers docker compose.

Le moteur Docker fournit un ensemble de commandes pour gérer les secrets et les rendre disponibles à vos applications. Ces commandes doivent être exécutées sur les gestionnaires d'essaims Docker.

Les secrets Docker ont les propriétés suivantes :
- Les secrets sont cryptés lorsqu'ils sont transmis et au repos dans l'essaim de dockers.
- Les secrets ne sont accessibles qu'aux services et utilisateurs autorisés.
- Les secrets ne sont disponibles que pour les services, **mais pas pour les conteneurs ordinaires**.
- Les secrets sont accessibles lorsque la tâche est en cours d'exécution

Docker fournit des secrets aux services sous forme de fichiers montés dans le dossier `/run/secrets` en utilisant le système de fichiers *tmpfs*. Par exemple, le secret **mypass** est stocké dans le fichier `/run/secrets/mypass` à l'intérieur du conteneur en cours d'exécution.

## Créer un secret
La commande de création d'un secret a le modèle suivant :

```sh
$ docker secret create [options] <nom du secret> [nom du fichier | -]
```

Un secret peut être créé de deux manières différentes. La première méthode utilise l'entrée standard pour créer un secret :

```sh
$ echo "secret one content" | docker secret create mysecret1 -
```

La commande echo imprime le texte fourni en paramètre sur la sortie standard, qui est ensuite dirigé vers l'entrée standard de la commande docker secret create. Le tiret (-) à la fin de la commande indique à la commande docker de lire à partir de l'entrée standard.

La deuxième méthode de création d'un secret consiste à utiliser un fichier qui stocke le secret.

```sh
$ echo "secret two content" > secret-file.txt
$ docker secret create mysecret2 ./secret-file.txt
```

## Lister les secrets

La commande ls liste tous les secrets existants dans l'essaim docker.

```sh
$ docker secret ls
```
La commande affiche l'identifiant, le nom, les dates de création et de mise à jour des secrets.

## Inspecter un secret

La commande inspect affiche des informations détaillées sur un secret au format JSON. Le contenu du secret n'est pas affiché.

```sh
$ docker secret ls
$ docker secret inspect mysecret1
```

Une sortie conviviale peut être affichée en utilisant l'option --pretty.

```sh
$ docker secret inspect --pretty mysecret1
```
Une information spécifique peut être affichée en utilisant l'option --format.

```sh
$ docker secret inspect --format '{{.UpdatedAt}}' mysecret
```

## Supprimer un secret

La commande rm supprime un secret d'un essaim. La commande ne demande pas de confirmation avant de supprimer le secret.

```sh
$ docker secret rm myscret1
```

Un secret utilisé par un service en cours d'exécution ne peut pas être supprimé. Vous pouvez utiliser la rotation de secret pour supprimer un secret alors qu'un service est en cours d'exécution.  


## Utilisation des secrets dans les applications

Les secrets sont spécifiés lors de la création des services, soit en utilisant l'interface de ligne de commande, soit dans le fichier docker compose.

### Exemple 1 : Utilisation de l'interface en ligne de commande

Créer un secret en utilisant l'interface en ligne de commande :

```sh
$ echo "the password secret" | docker secret create mypass -
$ docker secret ls
$ docker secret inspect mypass
```

Créez un service qui utilise le secret :

```sh
$ docker service create --name mynginx --secret mypass nginx:latest
$ docker service ls
```

Obtenir l'ID de la tâche (ID du conteneur) qui est nécessaire pour la commande docker exec.

```sh
$ docker ps
```

Afficher le contenu du secret stocké dans le dossier /run/secrets :

```sh
$ docker exec 7be95f99dbad cat /run/secrets/mypass
```

La commande ci-dessus devrait afficher le texte "the password secret".

Supprimez le service et le secret :

```sh
$ docker service rm mynginx
$ docker secret rm mypass
```


### Exemple 2 : Utilisation du fichier docker compose

Créez le fichier stack.yaml suivant :

```yml
services :
  db :
    image : postgres:latest
    environnement :
      POSTGRES_USER : webuser
      POSTGRES_PASSWORD_FILE : /run/secrets/db_password
      POSTGRES_DB : webdatabase
    secrets :
      - db_password

  adminer :
    image : adminer:latest
    ports :
     - 8080:8080

secrets :
  db_password :
    fichier : db_password.txt
```

Créer un fichier contenant le mot de passe de la base de données :

```sh
$ echo mypassword > db_password.txt
```
Déployez la pile en utilisant le fichier docker compose :

```sh
$ docker stack deploy --compose-file stack.yaml myapp
```


Pour tester la pile déployée, naviguez jusqu'à l'adresse `http://localhost:8080` et connectez-vous à l'adminer en utilisant les paramètres suivants :
- System : PostgeSQL
- Serveur : db
- Nom d'utilisateur : webuser
- Mot de passe : mypassword
- Base de données : webdatabase

Dans le cas où le secret **db_password** est créé à l'aide de la ligne de commande :

```sh
$ echo mypassword | docker secret create db_password -
$ docker secret ls
```

La section secrets du fichier de composition de docker doit être mise à jour pour indiquer au moteur de docker que le secret dp_password est créé en dehors du fichier de composition :

```yml
secrets :
  db_password :
    external : true
```
Redéployez l'application et naviguez jusqu'à l'adresse `http://localhost:8080` pour tester votre pile.

Lorsque vous avez terminé, vous pouvez supprimer la pile et le secret :

```sh
$ docker stack rm myapp
$ docker secret rm db_password
```