Split Docker tutorials into basis, orchestration and dockerfiles

tutorial/docker-orchestration/Makefile

@@ -0,0 +1,22 @@
+SOURCES		= tutorial.md setup.md what.md manual.md compose.md project.md
+PANDOCOPTS	= --latex-engine=xelatex \
+		  --standalone \
+		  --normalize \
+		  --number-sections \
+		  --smart \
+		  -M lang=french \
+		  -M fontsize=12pt \
+		  -M papersize=a4paper \
+		  -M mainfont="Linux Libertine O" \
+		  -M monofont="FantasqueSansMono-Regular" \
+		  -M sansfont="Linux Biolinum O" \
+		  --include-in-header=../header.tex
+
+
+all: tutorial.pdf
+
+tutorial.pdf: ${SOURCES}
+	pandoc ${PANDOCOPTS} -o $@ $+
+
+clean::
+	rm tutorial.pdf

tutorial/docker-orchestration/check.sh

@@ -0,0 +1,141 @@
+#!/bin/sh
+
+note_init() {
+    NOTE=0
+    echo -n $@
+}
+
+note() {
+    NOTE=$(($NOTE + $1))
+    echo -n ,$@
+}
+
+for LOGIN in $@
+do
+    note_init $LOGIN
+    pushd $LOGIN > /dev/null
+
+    # Questions
+
+    if grep -i "go" questions.txt 2> /dev/null > /dev/null; then
+	note 1
+    else
+	note 0
+    fi
+
+    if grep -E -i "(linkage|static|statique|liaison)" questions.txt 2> /dev/null > /dev/null; then
+	note 1
+    else
+	note 0
+    fi
+
+
+    # Exercice InfluxDB
+
+    DOCKERFILE_influxdb="influxdb/Dockerfile"
+    if ! [ -f "${DOCKERFILE_influxdb}" ] && [ -f "influxdb/dockerfile" ]; then
+	DOCKERFILE_influxdb="influxdb/dockerfile"
+    fi
+
+    NBRUN=$(grep -E -i ^RUN "${DOCKERFILE_influxdb}" 2> /dev/null | wc -l)
+    if [ $NBRUN -le 2 ] && [ $NBRUN -gt 0 ]; then
+	note 1
+    else
+	note 0
+    fi
+
+    if grep -E -i '^EXPOSE.*8083' "${DOCKERFILE_influxdb}" 2> /dev/null > /dev/null && grep -E -i '^EXPOSE.*8086' "${DOCKERFILE_influxdb}" 2> /dev/null > /dev/null && \
+	    grep -i ^EXPOSE "${DOCKERFILE_influxdb}" 2> /dev/null | sed "s/ 8083//g;s/ 8086//g" | grep -E '^EXPOSE[[:space:]]*$' > /dev/null; then
+	note 1
+    else
+	note 0
+    fi
+
+    if grep -E -i '^MAINTAINER[[:space:]]' "${DOCKERFILE_influxdb}" 2> /dev/null > /dev/null; then
+	note 1
+    else
+	note 0
+    fi
+
+    if grep -E -i '^(ADD|COPY)[[:space:]]' "${DOCKERFILE_influxdb}" 2> /dev/null > /dev/null; then
+	CONFIGFILE=$(grep -E -i '^(ADD|COPY)[[:space:]]' "${DOCKERFILE_influxdb}" | sed -r 's/^(COPY|ADD)[[:space:]]+([^[:space:]]*).*$/\2/')
+	if [ -f "influxdb/${CONFIGFILE}" ]; then
+	    note 1
+	else
+	    note 0
+	fi
+    else
+	note 0
+    fi
+
+
+    # Exercice mymonitoring
+
+    DOCKERFILE_mymonitoring="mymonitoring/Dockerfile"
+    if grep -E -i '^FROM[[:space:]]' "${DOCKERFILE_mymonitoring}" 2> /dev/null > /dev/null; then
+	note 1
+    else
+	note 0
+    fi
+
+    if grep -E -i '^ENV[[:space:]]' "${DOCKERFILE_mymonitoring}" 2> /dev/null > /dev/null; then
+	note 1
+    else
+	note 0
+    fi
+
+    CONFIGFILE=$(grep -E -i '^(ADD|COPY)[[:space:]]' "${DOCKERFILE_mymonitoring}" 2> /dev/null | grep -vi "influx" | grep -vi "chrono" | sed -r 's/^(COPY|ADD)[[:space:]]+([^[:space:]]*).*$/\2/')
+    if ! [ -f "mymonitoring/${CONFIGFILE}" ]; then
+	CONFIGFILE="mymonitoring/supervisor.conf"
+    fi
+    if [ -f "mymonitoring/${CONFIGFILE}" ]; then
+	ERRS=0
+
+	if grep -E -i "command=.*service.*start" "mymonitoring/${CONFIGFILE}" > /dev/null; then
+	    ERRS=$(($ERRS + 1))
+	fi
+
+	note $((2 - $ERRS))
+    else
+	note 0
+    fi
+
+
+    # Exercice docker-compose
+
+    DOCKERCOMPOSE="docker-compose.yml"
+
+    NBBUILD=$(grep -E -i "build[[:space:]]*:" "${DOCKERCOMPOSE}" 2> /dev/null | wc -l)
+    if [ $NBBUILD -ge 2 ]; then
+	note 2
+    elif [ $NBBUILD -ge 1 ]; then
+	note 1
+    else
+	note 0
+    fi
+
+    NBVOLS=$(grep -E -i "volumes[[:space:]]*:" "${DOCKERCOMPOSE}" 2> /dev/null | wc -l)
+    if [ $NBVOLS -ge 2 ]; then
+	note 2
+    elif [ $NBVOLS -ge 1 ]; then
+	note 1
+    else
+	note 0
+    fi
+
+    NBNET=$(grep -E -i "networks[[:space:]]*:" "${DOCKERCOMPOSE}" 2> /dev/null | wc -l)
+    NBLINK=$(grep -E -i "networks[[:space:]]*:" "${DOCKERCOMPOSE}" 2> /dev/null | wc -l)
+    if [ $NBNET -ge 2 ]; then
+	note 2
+    elif [ $NBNET -ge 1 ]; then
+	note 1
+    elif [ $NBLINK -ge 1 ]; then
+	note 2
+    else
+	note 0
+    fi
+
+
+    echo #" = $NOTE"
+    popd > /dev/null
+done

tutorial/docker-orchestration/compose.md

@@ -0,0 +1,155 @@
+\newpage
+
+Compose
+=======
+
+## Automatiser la construction et le lancement
+
+Commencez par lancer tous vos conteneurs à la main pour voir les
+étapes que vous allez devoir automatiser.
+
+Au lieu de faire un script pour construire et lancer tous vos
+conteneurs, définissez à la racine de votre projet un fichier
+`docker-compose.yml` qui contiendra les méthodes de construction et
+les paramètres d'exécution.
+
+```yaml
+version: '2'
+services:
+  influxdb:
+    ...
+  chronograf:
+    build: grafana/
+    image: nginx
+    ports:
+      - "3000:3000"
+    volumes:
+      - ./:/tmp/toto
+    links:
+     - influxdb
+```
+
+Ce fichier est un condensé des options que vous passez habituellement
+au `docker run`.
+
+### `version`
+
+Notez toutefois la présence d'une ligne `version` ; il ne s'agit pas de la
+version de vos conteneurs, mais de la version du format de fichier
+docker-compose qui sera utilisé. Sans indication de version, la version
+originale sera utilisée.
+
+
+### `services`
+
+Cette section énumère la liste des services (ou conteneurs) qui seront gérés
+par `docker-compose`.
+
+Il peuvent dépendre d'une image à construire localement, dans ce cas ils auront
+un fils `build`. Ou ils peuvent utiliser une image déjà existante, dans ce cas
+ils auront un fils `image`.
+
+Les autres fils sont les paramètres classiques que l'on va passer à `docker
+run`.
+
+
+### `volumes`
+
+Cette section est le pendant de la commandes `docker volume`.
+
+L'idée est d'éviter de créer des *Data Volume Container* qui ont une partie de
+système de fichiers inutile, et de ne garder que l'idée d'emplacement servant
+pour du stockage persistant.
+
+On les déclare simplement en leur donnant un nom et un driver comme suit :
+
+```yaml
+volumes:
+  mysql-data:
+    driver: local
+```
+
+Leur utilisation est identique à un *Data Volume Container* : on référence le
+nom ainsi que l'emplacement à partager :
+
+```yaml
+[...]
+  mysql:
+    [...]
+    volumes:
+	  - mysql-data:/var/lib/mysql
+```
+
+
+### `network`
+
+Cette section est le pendant de la commandes `docker network`.
+
+Par défaut, Docker relie tous les conteneurs sur un bridge et fait du NAT pour
+que les conteneur puisse accéder à l'Internet. Mais ce n'est pas le seul mode
+possible !
+
+De la même manière que pour les `volumes`, cette section déclare les réseaux
+qui pourront être utilisés par les `services`. On pourrait donc avoir :
+
+```yaml
+networks:
+  knotdns-slave-net:
+    driver: bridge
+```
+
+
+#### Driver `host`
+
+Le driver `host` réutilise la pile réseau de la machine hôte. Le conteneur
+pourra donc directement accéder au réseau, sans NAT et sans redirection de
+port. Les ports alloués par le conteneur ne devront pas entrer en conflits avec
+les ports ouverts par la machine hôte.
+
+
+#### Driver `null`
+
+Avec le driver `null`, la pile réseau est recréée et aucune interface (autre
+que l'interface de loopback) n'est présente. Le conteneur ne peut donc pas
+accéder à Internet, ni aux autres conteneur, ...
+
+Lorsque l'on exécute un conteneur qui n'a pas besoin d'accéder au réseau, c'est
+le driver à utiliser. Par exemple pour un conteneur dont le but est de vérifier
+un backup de base de données.
+
+
+#### Driver `bridge`
+
+Le driver `bridge` crée un nouveau bridge qui sera partagée entre tous les
+conteneurs qui la référencent.
+
+Avec cette configuration, les conteneurs ont accès à une résolution DNS des
+noms de conteneurs qui partagent leur bridge. Ainsi, sans avoir à utiliser la
+fonctionnalité de `link` au moment du `run`, il est possible de se retrouvé
+lié, même après que l'on ait démarré. La résolution se fera dynamiquement.
+
+
+### Utiliser le `docker-compose.yml`
+
+Consultez <http://docs.docker.com/compose/compose-file/> pour une liste
+exhaustive des options que vous pouvez utiliser.
+
+Une fois que votre `docker-compose.yml` est prêt, lancez tout d'abord
+`docker-compose build` pour commencer la phase de build de tous les conteneurs
+listés dans le fichier.
+
+Une fois le build terminé, vous pouvez lancer la commande suivante et admirer
+le résultat :
+
+```shell
+docker-compose up
+```
+
+Encore une fois, testez la bonne connexion entre chronograf (accessible sur
+<http://localhost:10000>) et influxdb.
+
+
+## Rendu
+
+Pour cette partie, vous devrez rendre la dernière itération de votre
+`docker-compose.yml`.

tutorial/docker-orchestration/manual.md

@@ -0,0 +1,6 @@
+\newpage
+
+Lier des conteneurs entre-eux
+=============================
+
+TODO

tutorial/docker-orchestration/project.md

@@ -0,0 +1,50 @@
+\newpage
+
+Rendu
+=====
+
+## Projet
+
+Amusez-vous à la piscine, il n'y a pas de projet en plus des exercices fait en
+TP !
+
+En complément de ce TP, vous pouvez jetez un œil à
+[Docker Swarm](https://docs.docker.com/engine/swarm) !
+
+
+## Modalité de rendu
+
+Un service automatique s'occupe de réceptionner vos rendus, de faire les
+vérifications nécessaires et de vous envoyer un accusé de réception (ou de
+rejet).
+
+Ce service écoute sur l'adresse <virli@nemunai.re>, c'est donc à cette adresse
+et exclusivement à celle-ci que vous devez envoyer vos rendus. Tout rendu
+envoyé à une autre adresse et/ou non signé ne sera pas pris en compte.
+
+
+## Tarball
+
+Tous les fichiers identifiés comme étant à rendre pour ce TP sont à
+placer dans une tarball (pas d'archive ZIP, RAR, ...).
+
+Les réponses aux questions sont à regrouper dans un fichier `questions.txt` à
+placer à la racine de votre rendu.
+
+Voici une arborescence type:
+
+```
+login_x-TP2/questions.txt
+login_x-TP2/docker-compose.yml
+login_x-TP2/influxdb
+login_x-TP2/influxdb/Dockerfile
+login_x-TP2/influxdb/influxdb.conf
+login_x-TP2/chronograf
+login_x-TP2/chronograf/Dockerfile
+login_x-TP2/chronograf/chronograf.conf
+login_x-TP2/mymonitoring
+login_x-TP2/mymonitoring/Dockerfile
+login_x-TP2/mymonitoring/chronograf.conf
+login_x-TP2/mymonitoring/influxdb.conf
+login_x-TP2/mymonitoring/supervisor.conf
+```

tutorial/docker-orchestration/setup.md

@@ -0,0 +1,123 @@
+\newpage
+
+Mise en place
+=============
+
+Durant le premier TP, nous avons installé l'environnement Docker principal, qui
+inclut le client, le daemon et toute sa machinerie. Mais le projet Docker
+propose de nombreuses autres ressources, souvent directement trouvée dans les
+usages de la communauté, et parfois même approprié par Docker.
+
+
+## `docker-machine`
+
+Pour ce TP, nous allons avoir besoin de `docker-machine`, installez-le sur
+votre machine hôte, même si ce n'est pas un Linux : le but va être de lancer
+plusieurs machines virtuelles Docker pour simuler un cluster.
+
+Ce programme permet de simplifier la gestion du multiples environnements
+Docker, comme par exemple lorsque l'on souhaite gérer un cluster de machines
+pour un projet.
+
+Ainsi, il est possible de provisionner et gérer des machines hôtes sur les
+plates-formes de cloud habituelles. C'est également ce projet qui est à la base
+de *Docker for Mac* et *Docker for Windows*, en permettant de lancer via,
+respectivement, VirtualBox et Hyper-V, un environnement Linux prêt à être
+utilisé avec Docker.
+
+### Par la distribution binaire
+
+L'équipe en charge de `docker-machine` met à disposition un exécutable compilé
+pour bon nombres d'environnements. Nous pouvons l'installer en suivant la
+procédure suivante :
+
+```shell
+curl -L https://github.com/docker/machine/releases/download/v0.12.2/docker-machine-Linux-x86_64 \
+    > /usr/bin/docker-machine
+chmod +x /usr/bin/docker-machine
+```
+
+Si vous êtes dans un environnement différent, jetez un œil à
+[la documentation d'installation](https://docs.docker.com/machine/install-machine/).
+
+
+### Support de KVM
+
+Le programme support de base de nombreux environnement, dont VirtualBox et
+Hyper-V. Bien d'autres environnements peuvent être supportés, au moyen de
+plug-ins.
+
+Si vous utilisez KVM comme hyperviseur, vous allez avoir besoin d'installer le
+plugins
+[`docker-machine-kvm`](https://github.com/dhiltgen/docker-machine-kvm). Vous
+n'aurez qu'à suivre les instructions du
+[`README`](https://github.com/dhiltgen/docker-machine-kvm/blob/master/README.md)
+!
+
+
+### Vérification du fonctionnement
+
+Comme avec Docker, nous pouvons vérifier le bon fonctionnement de
+`docker-machine` en exécutant la commande :
+
+```
+42sh$ docker-machine version
+docker-machine version 0.12.2, build 9371605
+```
+
+
+## `docker-compose`
+
+Pour ce TP, nous allons également avoir besoin de `docker-compose`.
+
+Ce projet ne bénéficie pas d'une intégration au sein du projet Docker et doit
+être téléchargé séparément, car originellement, le projet était développé par
+une équipe indépendante[^fig]. Il constitue aujourd'hui une brique de
+l'écosystème Docker, presque indispensable !
+
+[^fig]: Le site du projet initial est toujours en ligne :
+    <https://www.fig.sh/>.
+
+### Par le gestionnaire de paquets
+
+Les distributions à jour vous proposeront un paquet `docker-compose` qui
+fonctionnera avec la version de Docker qu'ils fournissent.
+
+### Par la distribution binaire
+
+L'équipe en charge de Docker compose met à disposition un exécutable contenant
+tous les scripts. Nous pouvons l'installer en suivant la procédure suivante :
+
+```shell
+curl -L https://github.com/docker/compose/releases/download/1.16.1/docker-compose-Linux-x86_64 \
+    > /usr/bin/docker-compose
+chmod +x /usr/bin/docker-compose
+```
+
+### `pip`
+
+Le projet étant écrit en Python, il est également disponible via `pip`, si vous
+préférez cette méthode. N'oubliez pas de préciser une version compatible avec
+votre version de Docker.
+
+
+### Vérification du fonctionnement
+
+Comme avec Docker, nous pouvons vérifier le bon fonctionnement de
+`docker-compose` en exécutant la commande :
+
+```
+42sh$ docker-compose --version
+docker-compose version: 1.16.1
+```
+
+Si vous obtenez une réponse similaire, c'est que vous êtes prêt à commencer le
+TP ! Alors n'attendons pas, partons à l'aventure !
+
+
+## Play With Docker
+
+Tout comme pour le TP précédent, si vous avez des difficultés pour réaliser les
+exercices sur vos machines, vous pouvez utiliser le projet
+[Play With Docker](https://play-with-docker.com/) qui vous donnera accès à un
+bac à sable avec lequel vous pourrez réaliser tous les exercices de ce TP.

tutorial/docker-orchestration/tutorial.md

@@ -0,0 +1,23 @@
+---
+title: Virtualisation légère -- TP n^o^ 2
+subtitle: Aller plus loin avec Docker
+author: Pierre-Olivier *Nemunaire* Mercier
+institute: EPITA
+date: Jeudi 19 octobre 2017
+...
+
+Durant ce deuxième TP, nous allons approfondir l'utilisation de Docker !
+
+Tous les éléments de ce TP (exercices et projet) sont à rendre à
+<virli@nemunai.re> au plus tard le jeudi 26 octobre 2017 à 8 h 42. Consultez la
+dernière section de chaque partie pour plus d'information sur les éléments à
+rendre.
+
+En tant que personnes sensibilisées à la sécurité des échanges électroniques,
+vous devrez m'envoyer vos rendus signés avec votre clef PGP. Pensez à
+[me](http://pgp.mit.edu/pks/lookup?op=vindex&search=0x842807A84573CC96) faire
+signer votre clef et n'hésitez pas à
+[faire signer votre clef](http://www.meetup.com/fr/Paris-certification-de-cles-PGP-et-CAcert/).
+
+\hypersetup{linkcolor=black}
+\tableofcontents

tutorial/docker-orchestration/what.md

@@ -0,0 +1,20 @@
+\newpage
+
+But du TP
+=========
+
+Aujourd'hui, nous allons réaliser un système de monitoring, prêt à
+être déployé chez un fournisseur de cloud.
+
+Le résultat attendu d'ici la fin du TP, est un groupe de conteneurs
+indépendants les uns des autres, réutilisables en fonction de besoins
+génériques et pouvant facilement être mis à l'échelle.
+
+Nous collecterons les données d'utilisation de votre machine avec
+[Telegraf](https://www.influxdata.com/time-series-platform/telegraf/). Ces
+données seront envoyés vers
+[InfluxDB](https://www.influxdata.com/time-series-platform/influxdb/), puis
+elles seront affichées sous forme de graphique grâce à
+[Chronograf](https://www.influxdata.com/time-series-platform/chronograf/).
+
+![Dashboard de l'utilisation CPU et mémoire sur Chronograf](chronograf.png)