Road-to-DevOps/Pepiniere/docker/travaux-pratiques/slides/swarm/tp-secrets.md

# TP secrets

## Chapitre 1

Objectif : Comprendre le fonctionnement des _secrets_ dans Swarm.


## Comprendre le fonctionnement des secrets

* Créer un secret nommé `pass1` à partir de `STDIN`.

* Créer un secret nommé `pass2` à partir d'un fichier.

* Vérifier que les secrets sont bien présents.


<!-- .slide: data-background="#2E2E2E" data-state="medium-code" -->
Créer un secret nommé `pass1` à partir de `STDIN` :
```none
$ echo "mon-super-mot-de-passe" | docker secret create pass1 -
s4kfgdeanybxhl6xj7nrrrsyl
```

Créer un secret nommé `pass2` à partir d'un fichier :
```none
$ echo "mon-autre-mot-de-passe" > file
$ docker secret create pass2 file
cbi6igm8jdwrd9fa1gbb9dfrm
rm file
```

Vérifier que les secrets sont bien présents :
```none
$ docker secret ls
ID                          NAME    CREATED              UPDATED
s4kfgdeanybxhl6xj7nrrrsyl   pass1   About a minute ago   About...
cbi6igm8jdwrd9fa1gbb9dfrm   pass2   16 seconds ago       16 se...
```


* Créer un service :

    - nommé `s1`,

    - basé sur l'image `debian:bullseye`,

    - qui lance la commande `/bin/sleep 3600` dans le conteneur,

    - qui passe les secrets `pass1` et `pass2` au conteneur.

* Se connecter dans le conteneur et vérifier que les secrets sont bien présents.


<!-- .slide: data-background="#2E2E2E" -->
Lancer le service `s1` :
```none
$ docker service create \
  --detach \
  --name s1 \
  --secret pass1 \
  --secret pass2 \
  debian:bullseye /bin/sleep 3600
gkyg5c33qc4x6nf6j11h59r44
```


<!-- .slide: data-background="#2E2E2E" data-state="small-code" -->
Récupérer l'identifiant du conteneur :
```none
$ docker ps
CONTAINER ID   IMAGE           COMMAND             ... NAMES
81ec752f3027   debian:latest   "/bin/sleep 3600"   ... s1.1.fdot5o8wk03r18y7b5tbjbrj1
```

Se connecter dans le conteneur :
```none
$ docker exec -ti s1.1.fdot5o8wk03r18y7b5tbjbrj1 /bin/bash
```


<!-- .slide: data-background="#2E2E2E" data-state="medium-code" -->

Vérifier la présence des secrets  
à l'intérieur du conteneur :
```none
root@81ec752f3027:/# ls -l /run/secrets/
-r--r--r-- 1 root root 23 Feb  6 09:07 pass1
-r--r--r-- 1 root root 23 Feb  6 09:07 pass2
```

Afficher le contenu des secrets :
```none
root@81ec752f3027:/# cat /run/secrets/pass1
mon-super-mot-de-passe
```

```none
root@81ec752f3027:/# cat /run/secrets/pass2
mon-autre-mot-de-passe
```



# TP secrets

## Chapitre II

Objectif : Utiliser les _secrets_ pour envoyer les mots de passe à nos services `web` et `db`.

TP à réaliser après le TP Swarm : nécessite `docker stack deploy`.


* Créer un secret nommé `mysql-secret` qui contiendra le mot de passe de la base de données.


<!-- .slide: data-background="#2E2E2E" data-state="medium-code" -->
Créer le secret
```none
$ echo 'docker' | docker secret create mysql-secret -
ippk0jji4fk6lzkl7aldygn58
```

```none
$ docker secret ls
ID                          NAME           ...
rcbrlh7dudey8qomnik3xrv7j   mysql-secret   ...
```


<!-- .slide: data-state="medium-code" -->
* Modifier le fichier `start.sh` comme suit :

```
#!/bin/bash

if [ -f /run/secrets/mysql-secret ] ; then
    export MYSQL_PASSWORD="$(tail -n 1 /run/secrets/mysql-secret)"
fi

rm -f /run/apache2/apache2.pid
echo "PassEnv MYSQL_USER MYSQL_PASSWORD MYSQL_DATABASE \
MYSQL_HOST" > /etc/apache2/conf-available/env.conf
a2enconf env
exec /usr/sbin/apache2ctl -D FOREGROUND
```

On récupère le secret dans le conteneur et on le passe à l'application via une variable d'environnement.


* Reconstruire l'image `web` (avec le tag `secret`) en prenant en compte le nouveau fichier `start.sh`.


<!-- .slide: data-background="#2E2E2E" data-state="medium-code" -->
Rappel : `formation/web/Dockerfile`
```docker
FROM debian:bullseye

LABEL maintainer "me@sii.fr"

# Debian en mode non interactif
ENV DEBIAN_FRONTEND noninteractive

# On installe Apache et le client Mysql
# et on nettoie le cache apt pour diminuer la taille de l'image
RUN apt update \
  && apt install -y apache2 mysql-client \
  && rm -rf /var/lib/apt/lists/*

# On copie nos scripts
COPY index.sh /usr/lib/cgi-bin/index.sh
COPY docker.sql /tmp/docker.sql
COPY start.sh /start.sh

# On rend les scripts exécutables
RUN chmod +x /start.sh
RUN chmod +x /usr/lib/cgi-bin/index.sh

# On active le module Apache CGI
RUN a2enmod cgi

# On expose le port 80
EXPOSE 80

# On indique le script qui doit être lancé au démarrage du conteneur
ENTRYPOINT ["/start.sh"]
```


<!-- .slide: data-background="#2E2E2E" -->
```none
$ docker build --tag web:secret .
```

```none
$ docker image ls | grep web
web   secret   01722677133b   2 minutes ago   289MB
web   1        74a456d5a9f2   3 hours ago     289MB
```


* Nous allons créer un Registry privé pour stocker notre nouvelle image.

* Créer un service registry basé sur l'image officielle `registry:2` et le publier sur le port 5000.  

* Tester la disponibilité du registry.


<!-- .slide: data-background="#2E2E2E" data-state="medium-code" -->
Créer un service registry
```none
$ docker service create \
    --name registry \
    --publish 5000:5000 \
    registry:2
```

Tester la disponibilité du registry
```none
$ curl 127.0.0.1:5000/v2/_catalog
{"repositories":[]}

```


* Pousser l'image `web:secret` sur le registry en utilisant les tags pour préciser l'adresse du registry, ici `127.0.0.1:5000`.

* Récupérer l'image `web:secret` sur tous les noeuds.


<!-- .slide: data-background="#2E2E2E" -->
Tagguer l'image
```none
$ docker tag web:secret 127.0.0.1:5000/web:secret
```

Pousser l'image sur le Registry
```none
$ docker push 127.0.0.1:5000/web:secret
```

Vérifier le contenu du Registry
```none
$ curl 127.0.0.1:5000/v2/_catalog
{"repositories":["web"]}
```


<!-- .slide: data-background="#2E2E2E" -->
Récupérer l'image sur le second Node
```none
$ docker pull 127.0.0.1:5000/web:secret
```


* Adapter le fichier docker-compose précédent pour utiliser le secret `mysql-secret` dans les services `web` et `db`.

* Lancer la stack applicative et vérifier que l'application fonctionne correctement.

[https://docs.docker.com/compose/compose-file/](https://docs.docker.com/compose/compose-file/)  
[https://docs.docker.com/engine/swarm/secrets/#use-secrets-in-compose](https://docs.docker.com/engine/swarm/secrets/#use-secrets-in-compose)  
[https://hub.docker.com/_/mariadb/](https://hub.docker.com/_/mariadb/)


<!-- .slide: data-background="#2E2E2E" data-state="small-code" -->
`formation/docker-compose-secrets.yml`  
```yaml
# Les secrets ne sont pris en charge qu'à partir de la version 3.1
# du format Compose file.
#
# Ce fichier compose ne fonctionne qu'avec la commande 'docker stack deploy',
# il ne marchera pas avec un 'docker-compose up -d'
#
# Seules les versions récentes de l'image mariadb savent gérer les secrets,
# la version 10.7.1 est OK.

version: "3.1"
services:
  web:
    image: 127.0.0.1:5000/web:secret
    depends_on:
      - db
    ports:
      - 8080:80
    environment:
      - MYSQL_HOST=db
      - MYSQL_DATABASE=docker
      - MYSQL_USER=docker
    secrets:
      - mysql-secret
  db:
    image: mariadb:10.7.1
    environment:
      - MYSQL_DATABASE=docker
      - MYSQL_USER=docker
      - MYSQL_PASSWORD_FILE=/run/secrets/mysql-secret
      - MYSQL_ROOT_PASSWORD_FILE=/run/secrets/mysql-secret
    secrets:
      - mysql-secret
    volumes:
      - mariadb-data:/var/lib/mysql
secrets:
  mysql-secret:
    external: true
volumes:
  mariadb-data:
```


<!-- .slide: data-background="#2E2E2E" data-state="small-code" -->
Lancer la stack applicative
```none
$ docker stack deploy -c docker-compose-secrets.yml secrets
```