Docker Presentation

Introduction générale
Bases
Utilisation avancées
Toujours plus loin
Fondements de la technologie de conteneurisations

docker
Jean-Mathieu Chantrein
LERIA
9 novembre 2018
1/73
Jean-Mathieu Chantrein Fondements de la technologie de conteneurisations docker
Bases
Toujours plus loin
Licence
Ce document est mis à disposition selon les termes de

la licence Creative Commons “Attribution - Pas d’uti-
lisation commerciale - Partage dans les mêmes condi-
tions 3.0 non transposé” .
2/73
Bases
Toujours plus loin
Plan
1 Introduction générale
Conteneur versus machine virtuelle
Des technologies de conteneurisations différentes pour des objectifs différents
2 Bases
Introduction
Définitions et prérequis
Premiers pas
Volatilité, persistance et sécurité des données
Sécurité des conteneurs
Conteneurs graphiques
3 Utilisation avancées
Créations d’images : méthode naı̈ve
Créations d’images : Dockerfile
4 Toujours plus loin
Travaux pratiques
3/73
Bases Conteneur versus machine virtuelle
Utilisation avancées Des technologies de conteneurisations différentes pour des objectifs différents
Toujours plus loin
Plan
2 Bases
Introduction
Premiers pas
Travaux pratiques
4/73
Toujours plus loin
Introduction
Dans cette section nous allons définir quelques notions qui nous permettront de
mieux appréhender les principales différences qu’il y a entre une machine physique
(réelle), une machine virtuelle et un conteneur.
5/73
Toujours plus loin
Au commencement il y avait ...
... la machine physique : l’ordinateur (serveur, PC, Mac, ...)

Il est fabriqué principalement avec des composants électroniques
Il est programmable (on peut lui faire exécuter des programmes)
Il est très puissant pour effectuer des calculs binaires (mais il ne sait faire que
ça)
Système d’exploitation (Operating System, abrégé OS)

Un système d’exploitation est un programme qui a pour but :
d’assurer la communication entre des logiciels et les différents composants
d’une machine (device (RAM, HDD, carte réseau, ...))
d’organiser/planifier l’exécution d’autres programmes
6/73
Toujours plus loin

ça)

6/73
Toujours plus loin

ça)

6/73
Toujours plus loin

ça)

6/73
Toujours plus loin

ça)

6/73
Toujours plus loin
Ensuite, il y a eu la virtualisation ...
... de machine (machine virtuelle, virtual machine, abrégé VM)

Une machine virtuelle est une machine émulée par un logiciel.
Le logiciel d’émulation simule la présence de ressources matérielles telles que
la mémoire, le(s) processeur(s), le(s) disque(s) dur.
Le logiciel d’émulation est capable de simuler un ordinateur.
On appelle hyperviseur le logiciel ayant pour mission de gérer les VM
(QEMU/KVM, HyperV, VMWare, VirtualBox, Xen, Proxmox, ...)
Il y a 2 types d’hyperviseur :
type 1 (bare metal ou native) meilleure performance, l’hyperviseur est l’os
(Ex : Xen, Qemu/KVM) (VM ”aware”)
type 2 (hosted) : Hyperviseur sur OS (Virtual Box) (VM ”no aware”)
7/73
Toujours plus loin

7/73
Toujours plus loin

7/73
Toujours plus loin

7/73
Toujours plus loin

7/73
Toujours plus loin
Architecture simplifiée du modèle VM/hyperviseur
8/73
Toujours plus loin
Avantages
Portabilité des VM
Isolation des applications
Mutualisations des ressources
Ressources à la demande
Démarrage plus rapide qu’une
machine réelle
8/73
Toujours plus loin
Avantages
machine réelle
8/73
Toujours plus loin
Avantages
machine réelle
8/73
Toujours plus loin
Avantages
machine réelle
8/73
Toujours plus loin
Avantages
machine réelle
8/73
Toujours plus loin
Inconvénients
Performance inférieure à une
exécution native
Consommation de mémoire vive
importante
Consommation de mémoire de
masse importante
Plus lent qu’ un conteneur
8/73
Toujours plus loin
Inconvénients
exécution native
importante
masse importante
8/73
Toujours plus loin
Inconvénients
exécution native
importante
masse importante
8/73
Toujours plus loin
Inconvénients
exécution native
importante
masse importante
8/73
Toujours plus loin
... et la virtualisation d’environnement : la conteneurisation
Terminologie : virtualisation légère versus conteneurisation

On désigne souvent la conteneurisation comme étant de la virtualisation
légère.
Le terme de virtualisation légère est bien adapté lorsque il s’agit de mettre en
opposition la conteneurisation face à la virtualisation (appelée aussi
”virtualisation lourde”).
De manière générale, le terme est mal choisi. En effet, lorsque nous utilisons
des techniques de conteneurisation, il n’y a pas de virtualisation.
Pour cette raison, nous n’utiliserons plus le terme de virtualisation lorsque
nous parlerons de conteneurisation dans la suite de cet exposé.
9/73
Toujours plus loin

légère.
9/73
Toujours plus loin

légère.
9/73
Toujours plus loin

légère.
9/73
Toujours plus loin
La conteneurisation
Un conteneur fournit un environnement d’exécution isolé pour une/des
applications
Un conteneur partage le noyau du système d’exploitation de l’hôte
L’isolation est effectuée par des fonctionnalités du noyau (cgroups,
usernamespace, capabilities)
Il existe différents types de conteneurs (chroot, Docker, LXC, OpenVZ,
Rocket, Singularity, ...)
On appelle hyperviseur ou orchestrateur le logiciel ayant pour mission de
gérer les conteneurs (LXD, proxmox (pct), compose, swarm, kubernetes)
10/73
Toujours plus loin
La conteneurisation
applications
10/73
Toujours plus loin
La conteneurisation
applications
10/73
Toujours plus loin
La conteneurisation
applications
10/73
Toujours plus loin
La conteneurisation
applications
10/73
Toujours plus loin
Architecture simplifiée du modèle conteneur/OS
11/73
Toujours plus loin
Avantages
Portabilité des conteneurs (+ ou -)
Isolations des applications (+ ou -)
Démarrage quasiment aussi rapide
qu’une application native
Contrairement aux VMs, pas
d’overhead (économisation des
ressources matérielles)
11/73
Toujours plus loin
Avantages
11/73
Toujours plus loin
Avantages
11/73
Toujours plus loin
Avantages
11/73
Toujours plus loin
Avantages
11/73
Toujours plus loin
Avantages
11/73
Toujours plus loin
Inconvénients
Ne permet d’exécuter que des
applications compatibles avec le
système hôte
Peut-être sans état, volatile
(dépend des technologies
employées) ⇒ pas de snapshot
RAM incluse, pas de persistance
des données nativement
11/73
Toujours plus loin
Inconvénients
Ne permet d’exécuter que des
applications compatibles avec le
système hôte
Peut-être sans état, volatile
(dépend des technologies
employées) ⇒ pas de snapshot
RAM incluse, pas de persistance
des données nativement
11/73
Toujours plus loin
Inconvénients (suite)
Certaines de ces technologies sont
encore jeunes (docker, singularity)
Courbe d’apprentissage un peu plus
élevée que pour des VM
Évolution très (trop ?) rapide
Va-t-on vraiment vers un
changement de paradigme ?
11/73
Toujours plus loin
11/73
Toujours plus loin
11/73
Toujours plus loin
11/73
Toujours plus loin
Divers
On peut imbriquer plusieurs VM ou plusieurs conteneurs les uns dans les autres
(en anglais nested virtualisation/containers)
12/73
Toujours plus loin
Chroot : le prémice de la conteneurisation

Réalisez un chroot pour un utilisateur d’uid 2000 sur un répertoire nommé
new root. Vous aurez besoin de :
chroot (et de man chroot)
cp
ldd
mkdir
13/73
Toujours plus loin
Terminal:
jmc@laptop/home/jmc $ mkdir new root
jmc@laptop/home/jmc $ cp -r /bin/ new root/
jmc@laptop/home/jmc $ sudo chroot new root /bin/bash
jmc@laptop/home/jmc $ # Zut alors
13/73
Toujours plus loin
Terminal:
jmc@laptop/home/jmc $ ldd /bin/bash
jmc@laptop/home/jmc $ cp -r /lib new root/
jmc@laptop/home/jmc $ cp -r /lib64 new root/
jmc@laptop/home/jmc $ sudo chroot new root /bin/bash
bash-4.3# pwd
/
bash-4.3# echo $UID
0
bash-4.3# exit
jmc@laptop/home/jmc $
13/73
Toujours plus loin
Terminal:
jmc@laptop/home/jmc $ sudo chroot –userspec 2000 :2000 new root /bin/bash
bash-4.3# echo $UID
2000
bash-4.3# ls -l / # A vous de voir
bash-4.3# rm -r –no-preserve-root / # A votre avis ? Et lorsque on ne met pas
l’option userspec ?
bash-4.3# exit
13/73
Toujours plus loin
Plan
2 Bases
Introduction
Premiers pas
Travaux pratiques
14/73
Toujours plus loin
Les conteneurs applicatifs
Il s’agit des conteneurs qui ont pour objectif de n’exécuter qu’une application,
qu’un service, voire même qu’un seul processus. Les deux principaux concurrents
sont :
Docker (Docker Inc.)
Rocket (CoreOS Inc.)
Ce sont des technologies très prisées par le monde du DevOps (relation entre les
développeurs et les administrateurs systèmes/réseaux).
L’utilisation de ces technologies met en avant l’utilisation des architectures de
micro-services (1 conteneur = 1 micro-service, multi-conteneurisation du service).
Il s’agit de conteneur sans état (stateless), il n’y a pas de persistance de données
par défaut, car ces conteneurs sont volatiles.
15/73
Toujours plus loin
Les conteneurs pour l’administration système
Ce sont des conteneurs qui ont pour objectif de remplacer les VM. Ils diffèrent des
conteneurs applicatifs dans le sens ou ils peuvent fournir un ensemble de (micro)
services. Ce sont des conteneurs avec état (statefull) : ils offrent une persistance
des données et ils ont pour vocation d’être manipulés comme des VMs (snapshot,
backup, migration à chaud). Les principaux concurrents sont :
LXC (via LXD, Canonical)
LXC (via Proxmox pct, Proxmox)
OpenVZ
Les conteneurs LXC sont capables d’héberger des conteneurs Docker (sous
conditions : voir
https://stgraber.org/2016/04/13/lxd-2-0-docker-in-lxd-712/).
16/73
Toujours plus loin
Les conteneurs pour le calcul haute performance
L’idée est de se servir du mécanisme des conteneurs pour offrir des

environnements isolés mais performants dans le cadre du calcul haute
performance. Singularity permet l’utilisation de conteneur à destination du HPC
(utilisation sur des clusters de calculs). Les conteneurs singularity sont en mesure
d’exécuter des conteneurs docker. Ils sont également plus sécurisés nativement et
permettent l’utilisation native de certains protocoles (infiniband, openMPI, ...)
17/73
Introduction
Introduction générale Définitions et prérequis
Bases Premiers pas
Utilisation avancées Volatilité, persistance et sécurité des données
Toujours plus loin Sécurité des conteneurs
Plan
2 Bases
Introduction
Premiers pas
Travaux pratiques
18/73
Introduction
Bases Premiers pas
La puissance de docker ?
Démonstration wordpress PWD
19/73
Introduction
Bases Premiers pas
Contexte d’utilisation de docker
Dans le cadre du cours, notre utilisation de Docker se fera uniquement sur un

noyau Linux. En effet, il existe une possibilité d’utiliser docker nativement sur
Windows server 2016 et pour conteneuriser des applications windows.
On peut utiliser docker nativement sur un OS GNU / Linux.
On peut utiliser docker dans une machine virtuelle avec un os GNU/linux.
On peut utiliser docker via une virtualisation Virtual Box minimale de l’os
”boot2docker”via l’outil ”docker toolbox” sur windows et macOS.
On peut avoir un environnement ”bac à sable” docker en ligne avec
l’excellent site ”play with docker” (nécessite un compte docker)
20/73
Introduction
Bases Premiers pas

20/73
Introduction
Bases Premiers pas

20/73
Introduction
Bases Premiers pas

20/73
Introduction
Bases Premiers pas

20/73
Introduction
Bases Premiers pas
Historique
Solomon Hykes débute le projet Docker en interne pour DotCloud en France.
Docker a été distribué en tant que projet open source à partir de mars 2013
À partir de la version 0.9, Docker abandonne l’utilisation de LXC et
développe sa propre librairie de conteneurs : libcontainer
Docker est principalement développé par la société Docker Inc
En 3 ans, 10 000 forks et 1400 contributeurs sur github pour le projet Docker
21/73
Introduction
Bases Premiers pas
Carte d’identité
22/73
Introduction
Bases Premiers pas
N.B : Versions de docker
Il y a eu 2 grands changements majeurs dans l’historique de développements de

docker :
docker 0.9 ⇒ fork de LXC pour création de libcontainer
docker 1.10 ⇒ Changement de gestion des images (4 février 2016)
Ce cours a été fait sur la base de la version 17.03.1-ce. Les explications données
ici peuvent être incompatibles avec les versions antérieures à docker 1.10. Si vous
êtes amenés à consulter des forums sur internet, pensez à regarder la date du post
et/ou la version de docker utilisée. Plus d’informations sur ces changements
majeurs :
https://blog.docker.com/2016/02/docker-1-10/
http://windsock.io/explaining-docker-image-ids/
23/73
Introduction
Bases Premiers pas

docker :
majeurs :
23/73
Introduction
Bases Premiers pas

docker :
majeurs :
23/73
Introduction
Bases Premiers pas
Installation
Ubuntu 16.04 (VM ou natif)
Dernière version stable de docker en CE (Community Edition)
https://docs.docker.com/engine/installation/linux/ubuntu/
#uninstall-old-versions
https://docs.docker.com/engine/installation/linux/ubuntu/
#install-using-the-repository
24/73
Introduction
Bases Premiers pas
Pour ne pas avoir à écrire sudo à chaque commande docker
Terminal:
jmc@laptop/home/jmc $ sudo usermod -aG docker $USER
jmc@laptop/home/jmc $ # Déconnexion, reconnexion
jmc@laptop/home/jmc $ systemctl enable docker # Activation au démarrage de
l’hôte
Considérez que vous êtes root à chaque fois que votre commande est préfixée
par docker
24/73
Introduction
Bases Premiers pas
Pour ne pas avoir à écrire sudo à chaque commande docker
Terminal:
jmc@laptop/home/jmc $ sudo usermod -aG docker $USER
jmc@laptop/home/jmc $ # Déconnexion, reconnexion
jmc@laptop/home/jmc $ systemctl enable docker # Activation au démarrage de
l’hôte
Considérez que vous êtes root à chaque fois que votre commande est préfixée
par docker
24/73
Introduction
Bases Premiers pas
Plan
2 Bases
Introduction
Premiers pas
Travaux pratiques
25/73
Introduction
Bases Premiers pas
Définitions formelles
Les images et les couches : bases des conteneurs docker
Une image désigne une collection ordonnée (par empilement) de
modifications d’un système de fichiers racine.
On conserve chacune de ces modifications du FS dans une couche ou un
layer identifiable par le hash sha256 de son contenu. ⇒ Une image désigne
donc une collection ordonnée de couche.
A chaque couche intermédiaire est associé une image intermédiaire.
Les couches sont créées grâce à l’exécution de conteneurs qui sont
transformés en image. (Pas de panique, on va faire un schéma)
Il peut y avoir des couches vides (empty layer).
Les couches désignées par une image sont nécessairement en lecture seule.
Une image est unique. Elle est identifiée par une fonction de hachage sha256
de son descriptif. Elle n’a pas d’état (i.e. : on n’exécute pas une image) et
elle est immuable.
26/73
Introduction
Bases Premiers pas
elle est immuable.
26/73
Introduction
Bases Premiers pas
elle est immuable.
26/73
Introduction
Bases Premiers pas
elle est immuable.
26/73
Introduction
Bases Premiers pas
elle est immuable.
26/73
Introduction
Bases Premiers pas
elle est immuable.
26/73
Introduction
Bases Premiers pas
elle est immuable.
26/73
Introduction
Bases Premiers pas
Un conteneur : l’instanciation d’une image

Le système de fichiers racine du conteneur est le système de fichiers racine de
l’image sous-jacente, mais celui-ci est en lecture seule.
On a l’illusion de modifier le système de fichiers racine dans le conteneur, car
les changements sont effectuées dans une nouvelle couche en
lecture/écriture. (technologie de Copy On Write (COW))
La suppression du conteneur entraı̂ne systématiquement la suppression de
cette nouvelle couche en lecture/écriture.
On peut pérenniser les modifications effectuées dans le FS d’un conteneur en
créant une nouvelle image qui va ajouter aux couches en lecture seule la
nouvelle couche ainsi créée. La nouvelle couche qui était en lecture/écriture
passe ainsi en lecture seule.
Cette pérennisation se fait via la commande docker commit
27/73
Introduction
Bases Premiers pas

27/73
Introduction
Bases Premiers pas

27/73
Introduction
Bases Premiers pas

27/73
Introduction
Bases Premiers pas

27/73
Introduction
Bases Premiers pas
Ce qu’il faut bien comprendre

Image 6= Couche 6= Conteneur
Une couche contient uniquement les différences d’un système de fichiers.
Un ensemble de couche peut former un système de fichiers racine.
Les couches ne savent rien des images qui les exploitent.
Les couches peuvent être utilisées par plusieurs images.
Une image peut faire référence à plus d’1 couche.
Une image est quelque chose que vous pouvez instancier. Le résultat de
cette instanciation est un conteneur.
Lorsque un conteneur démarre, certaines informations de l’image ayant permis
son instanciation permettent de construire son système de fichiers racine.
28/73
Introduction
Bases Premiers pas

28/73
Introduction
Bases Premiers pas

28/73
Introduction
Bases Premiers pas

28/73
Introduction
Bases Premiers pas

28/73
Introduction
Bases Premiers pas

28/73
Introduction
Bases Premiers pas

28/73
Introduction
Bases Premiers pas

28/73
Introduction
Bases Premiers pas
Représentation graphique
29/73
Introduction
Bases Premiers pas
29/73
Introduction
Bases Premiers pas
29/73
Introduction
Bases Premiers pas
29/73
Introduction
Bases Premiers pas
29/73
Introduction
Bases Premiers pas
29/73
Introduction
Bases Premiers pas
29/73
Introduction
Bases Premiers pas
29/73
Introduction
Bases Premiers pas
29/73
Introduction
Bases Premiers pas
29/73
Introduction
Bases Premiers pas
29/73
Introduction
Bases Premiers pas
29/73
Introduction
Bases Premiers pas
29/73
Introduction
Bases Premiers pas
29/73
Introduction
Bases Premiers pas
Images particulières
Une ”top level image” n’est pas une image intermédiaire
Une image taguée ”none” est une image intermédiaire, sinon c’est une top
level image pendante (dangling)
Une image taguée ”missing” est une image manquante mais dont on a
obtenu le layer associé (via docker pull)
Avant la version 1.10

Chaque image était identifiée par un nombre aléatoire
Chaque image était associée à 1 seule couche.
⇒ Chaque couche était repérée par le même identifiant que l’image
⇒ Problèmes de sécurité à cause du nombre aléatoire
Pour plus d’informations :
30/73
Introduction
Bases Premiers pas

30/73
Introduction
Bases Premiers pas

30/73
Introduction
Bases Premiers pas

30/73
Introduction
Bases Premiers pas

30/73
Introduction
Bases Premiers pas

30/73
Introduction
Bases Premiers pas

30/73
Introduction
Bases Premiers pas

30/73
Introduction
Bases Premiers pas
Quelques commandes de bases
Gestion des images

docker pull : télécharger une image présente sur un registre (docker hub par
défaut)
docker push : pousser (upload) une image sur un registre
docker search : chercher une image sur un registre
docker images : liste les images présentes localement
docker history : affiche l’historique de création d’une image
docker rmi : supprimer une image
docker commit : construire une image à partir d’un conteneur
docker build : construire une image à partir d’un dockerfile
31/73
Introduction
Bases Premiers pas
Gestion des conteneurs

docker run : démarrer un conteneur
docker stop/start/restart/pause/unpause :
arrête/démarre/redémarre/pause/reprise d’un conteneur
docker logs : obtenir les journaux système d’un conteneur
docker kill : tuer un conteneur
docker rm : supprimer un conteneur
docker ps : liste les conteneurs actifs
32/73
Introduction
Bases Premiers pas
Plusieurs commandes pour le même résultat

Les commandes vues précédemment sont les commandes historiques de
docker
Avec le temps, docker a regroupé ses commandes en fonction des ”objets”
concernés
Par exemple, toutes les commandes concernant :
les conteneurs sont regroupées dans docker container cmd
les images sont regroupées dans docker image cmd
et ainsi de suite pour : config, container, image, network, node, plugin, secret,
service, stack, swarm, system et volume
Mais docker container ls -aq est identique à docker ps -aq
Etc, etc
33/73
Introduction
Bases Premiers pas
Gestion de docker
docker info : affiche des informations relatives à l’écosystème docker sur la
machine
docker inspect : affiche des informations de bas niveau sur des objets docker
(images, conteneurs, réseaux, ...)
docker version : affiche la version de docker
34/73
Introduction
Bases Premiers pas
”Philosophie” de docker : Bonnes pratiques recommandées
Un conteneur doit être éphémère (séparation et point de montage des

données dans le conteneur)
Un conteneur = 1 (micro) service (= 1 processus pour les puristes)
On ne devrait pas être root dans un conteneur (sshd, crond, firewall, ... ⇒
Hôte)
Si jamais on doit être root, utilisation d’un setuid, gosu ou su-exec
Minimiser la taille des images (pas de superflu)
Minimiser le nombre de couches dans une image (Dockerfile ⇒ multi-ligne
argument, pipe)
Maximiser le partage des couches
Les couches les plus volumineuses au plus près de la racine (utilisation du
cache de docker build)
35/73
Introduction
Bases Premiers pas

Hôte)
argument, pipe)
35/73
Introduction
Bases Premiers pas

Hôte)
argument, pipe)
35/73
Introduction
Bases Premiers pas

Hôte)
argument, pipe)
35/73
Introduction
Bases Premiers pas

Hôte)
argument, pipe)
35/73
Introduction
Bases Premiers pas

Hôte)
argument, pipe)
35/73
Introduction
Bases Premiers pas

Hôte)
argument, pipe)
35/73
Introduction
Bases Premiers pas

Hôte)
argument, pipe)
35/73
Introduction
Bases Premiers pas
”Philosophies” de docker ?
Adapter les bonnes pratiques en fonction de ses besoins et de ses usages

Pour plus d’un processus par conteneur, voir du côté de supervisor
Utilisez-vous la bonne technologie de conteneurisation ?
36/73
Introduction
Bases Premiers pas

36/73
Introduction
Bases Premiers pas

36/73
Introduction
Bases Premiers pas
Plan
2 Bases
Introduction
Premiers pas
Travaux pratiques
37/73
Introduction
Bases Premiers pas
Notre premier conteneur
Hello world !
Terminal:
jmc@laptop/home/jmc $ docker run hello-world
Unable to find image ’hello-world :latest’ locally
latest : Pulling from library/hello-world
78445dd45222 : Downloading [===============> ]
38/73
Introduction
Bases Premiers pas
Hello world !
Terminal:
78445dd45222 : Extracting [=========> ]
38/73
Introduction
Bases Premiers pas
Hello world !
Terminal:
78445dd45222 : Pull complete
Digest :
sha256 :c5515758d4c5e1e838e9cd307f6c6a0d620b5e07e6f927b07d05f6d12a1ac8d7
Status : Downloaded newer image for hello-world :latest
...
38/73
Introduction
Bases Premiers pas

Hello world !
Terminal:
Conteneur:
Hello from Docker!

This message shows that your installation appears to be working correctly.
To generate this message, Docker took the following steps:

1. The Docker client contacted the Docker daemon.
2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
3. The Docker daemon created a new container from that image which runs the
executable that produces the output you are currently reading.
4. The Docker daemon streamed that output to the Docker client, which sent it
to your terminal.
To try something more ambitious, you can run an Ubuntu container with:
$ docker run -it ubuntu bash
Share images, automate workflows, and more with a free Docker ID:
https://cloud.docker.com/
For more examples and ideas, visit:

https://docs.docker.com/engine/userguide/
38/73
Introduction
Bases Premiers pas

Hello world !
Terminal:
jmc@laptop/home/jmc $ docker ps
jmc@laptop/home/jmc $ docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

ccdd8f78bf58 hello-world "/hello" 15 minutes ago Exited (0) 15 minutes ago furious_pare
jmc@laptop/home/jmc $ docker ps -aq

ccdd8f78bf58
jmc@laptop/home/jmc $ docker inspect –format=’{{.ID}}’ furious pare
ccdd8f78bf58e744968462d979bde759155dcd6892cad94bea2bf64fe3fa0012
1 Aucun conteneur actif

2 1 conteneur inactif (-a = all), si nom non spécifié, attribution d’un nom
aléatoire
3 (-q = quiet)
4 CONTAINER ID affecté aléatoirement
38/73
Introduction
Bases Premiers pas

Hello world !
Terminal:


ccdd8f78bf58

aléatoire
3 (-q = quiet)
38/73
Introduction
Bases Premiers pas

Hello world !
Terminal:


ccdd8f78bf58

aléatoire
3 (-q = quiet)
38/73
Introduction
Bases Premiers pas

Hello world !
Terminal:


ccdd8f78bf58

aléatoire
3 (-q = quiet)
38/73
Introduction
Bases Premiers pas
Hello world !
Terminal:
jmc@laptop/home/jmc $ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE

hello-world latest 48b5124b2768 4 months ago 1.84 kB
jmc@laptop/home/jmc $ docker images -aq

48b5124b2768
jmc@laptop/home/jmc $ docker inspect –format=’{{.ID}}’ hello-world
sha256 :48b5124b2768d2b917edcb640435044a97967015485e812545546cbed5cf0233
jmc@laptop/home/jmc $ docker inspect –format=’{{.RootFS.layers}}’ hello-world
[sha256 :98c944e98de8d35097100ff70a31083ec57704be0991a92c51700465e4544d08]
1 Liste les images de plus haut niveau (top level image)

2 Liste de façon silencieuse (-q) toutes les images (intermédiaires également)
3 IMAGE ID affecté par fonction de hachage
4 Fonction de hachage du layer décompressé (N.B. : présence des [])
38/73
Introduction
Bases Premiers pas
Hello world !
Terminal:


48b5124b2768

38/73
Introduction
Bases Premiers pas
Hello world !
Terminal:


48b5124b2768

38/73
Introduction
Bases Premiers pas
Hello world !
Terminal:


48b5124b2768

38/73
Introduction
Bases Premiers pas
Hello world !
Terminal:
jmc@laptop/home/jmc $ docker rm furious pare # docker rm ccdd8 (debut CONTAINER ID)
furious pare
Suppression du conteneur par son nom ou son identifiant
38/73
Introduction
Bases Premiers pas
Hello world !
Terminal:
jmc@laptop/home/jmc $ docker rmi hello-world # docker rmi 48b (debut IMAGE ID)
Untagged : hello-world :latest
Untagged : hello-world@sha256 :c5515758d4c5e1e838e9cd307f6c6a0d620b5e07e6f927b07d05f6d12a1ac8d7
Deleted : sha256 :48b5124b2768d2b917edcb640435044a97967015485e812545546cbed5cf0233
Deleted : sha256 :98c944e98de8d35097100ff70a31083ec57704be0991a92c51700465e4544d08
latest considéré comme tag par défaut (untagged by user)

hello-world@sha256 :c55... considéré comme tag par défaut (untagged by
user)(Hash Image Compressed)
Deleted : sha256 :48b... ⇒ Suppression de l’image
Deleted : sha256 :98c... ⇒ Suppression des couches de l’image (1 seule en
l’occurrence) car couches non partagées par d’autres images.
A quoi correspond 78445dd45222 lors du pull ? ⇒ Hash Layer Compressed
38/73
Introduction
Bases Premiers pas
Hello world !
Terminal:

38/73
Introduction
Bases Premiers pas
Hello world !
Terminal:

38/73
Introduction
Bases Premiers pas
Hello world !
Terminal:

38/73
Introduction
Bases Premiers pas
Hello world !
Terminal:

38/73
Introduction
Bases Premiers pas
Quelques cas faciles

Quelques conteneurs à exécuter
Prenez le temps de lancer quelques conteneurs simplement, par exemple :
1 Exécutez ”/bin/bash” dans un conteneur interactif ubuntu
2 Exécutez ”/bin/ls” dans un conteneur non interactif ubuntu
3 Exécutez ”/bin/ps -eflH” dans un conteneur non interactif ubuntu
4 Exécutez ”/bin/bash” dans un conteneur interactif nommé
”mon conteneur c0” ubuntu
5 Détachez-vous du conteneur ”mon conteneur c0” avec Crtl+p Ctrl+q
6 Rattachez-vous au conteneur ”mon conteneur c0”
7 Sortez du conteneur ”mon conteneur c0”
8 Listez les conteneurs actifs, listez tous les conteneurs
9 Supprimez tous les conteneurs inactifs en 1 commande (docker container
help)
39/73
Introduction
Bases Premiers pas
Quelques cas faciles : commentaires

Prenez le temps de lancer quelques conteneurs simplement, par exemple :
1 docker run -it ubuntu /bin/bash
2 docker run ubuntu /bin/ls
3 docker run ubuntu /bin/ps -eflH
4 docker run -it –name mon conteneur c0 ubuntu
5 Ctrl+p Ctrl+q
6 docker container attach mon conteneur
7 exit
8 docker container ls ; docker container ls -a
9 docker container prune
40/73
Introduction
Bases Premiers pas
Quelques cas pénibles

Vous utiliserez les commandes docker run et docker container.
docker cmd help pour l’aide sur la commande cmd
1 Essayez d’exécuter ”/bin/bash” dans un conteneur interactif alpine
2 Exécutez ”echo hello world !” dans un conteneur non interactif centos ”c1”
3 Essayez de démarrer 1 fois le conteneur ”c1”. Faites docker logs c1
4 Exécutez ”/bin/bash” dans un conteneur non interactif centos ”c2”
5 Essayez de démarrer 1 fois le conteneur ”c2”. Faites docker logs c2
6 Exécutez ”/bin/bash” dans un conteneur interactif centos ”c3” et exit de c3
7 Démarrez, connectez vous avec un nouveau bash et détachez vous du
conteneur ”c3”
8 Listez les processus du conteneur ”c3” depuis l’hôte et depuis le conteneur
(ps)
41/73
Introduction
Bases Premiers pas
Quelques cas pénibles : commentaires

Vous utiliserez les commandes docker run et docker container.
docker cmd help pour l’aide sur la commande cmd
1 /bin/bash n’est pas présent par défaut dans alpine (Idée sous-jacente :
Minimiser la taille des images, on n’installe que ce dont a besoin
La distribution Alpine fait 5 Mo !
2 docker run centos echo hello world !
3 c1 est en mode non interactif et ”echo” est sans boucle d’événement, mais
”hello” effectué réellement 2 fois.
4 c2 est en mode non interactif et il n’y a pas de pseudo-terminal alloué
5 La commande ”/bin/bash” est effectué réellement 2 fois
6 docker run -it –name c3 centos /bin/bash ; exit ;
7 docker start c3 ; docker exec -it c3 /bin/bash ; Ctrl+p Ctrl+q
8 docker container top c3 ; docker exec c3 ps ; PID host, PID guest
42/73
Introduction
Bases Premiers pas
Plan
2 Bases
Introduction
Premiers pas
Travaux pratiques
43/73
Introduction
Bases Premiers pas

Something more ambitious
Terminal:
jmc@laptop/home/jmc $ docker run -it ubuntu /bin/bash
Unable to find image ’ubuntu :latest’ locally
latest : Pulling from library/ubuntu
bd97b43c27e3 : Pull complete
6960dc1aba18 : Pull complete
2b61829b0db5 : Pull complete
1f88dc826b14 : Pull complete
73b3859b1e43 : Pull complete
Digest :
sha256 :ea1d854d38be82f54d39efe2c67000bed1b03348bcc2f3dc094f260855dff368
Status : Downloaded newer image for ubuntu :latest
44/73
Introduction
Bases Premiers pas
Terminal:
Conteneur:
root@dfdf734253a9 :/# ls
bin boot dev etc home lib lib64 media mnt opt proc root run sbin srv sys tmp usr
var
root@dfdf734253a9 :/# rm -rf / # Aucune incidence sur l’hôte car pas de
montage de volume
rm : it is dangerous to operate recursively on ’/’
rm : use –no-preserve-root to override this failsafe
44/73
Introduction
Bases Premiers pas
Terminal:
Conteneur:
root@dfdf734253a9 :/# rm -rf –no-preserve-root /
...
rm : cannot remove ’/proc/fs/aufs/plink maint’ : Read-only file system
...
root@dfdf734253a9 :/# ls
bash : /bin/ls : No such file or directory
root@dfdf734253a9 :/# exit
44/73
Introduction
Bases Premiers pas
Terminal:
dfdf734253a9 ubuntu "/bin/bash" 26 minutes ago Exited (127) 6 minutes ago stoic_engelbart
jmc@laptop/home/jmc $ docker rm dfd

dfd
44/73
Introduction
Bases Premiers pas
Terminal:
jmc@laptop/home/jmc $ docker run -it ubuntu /bin/bash
Conteneur:
root@63f0abcc808a :/# #Ceci est un nouveau conteneur
root@63f0abcc808a :/# ls
bin boot dev etc home lib lib64 media mnt opt proc root run sbin srv sys tmp usr
var
root@63f0abcc808a :/# exit
44/73
Introduction
Bases Premiers pas
Terminal:
63f0abcc808a ubuntu "/bin/bash" 32 minutes ago Exited (0) 27 seconds ago suspicious_goldstine
jmc@laptop/home/jmc $ docker rm suspicious goldstine

suspicious goldstine
44/73
Introduction
Bases Premiers pas

Terminal:
jmc@laptop/home/jmc $ docker run -it -v / :/danger racine hote –hostname
myhostname –name myname ubuntu /bin/bash
Conteneur:
root@myhostname :/# ls
bin boot dev etc home lib lib64 media mnt opt proc danger racine hote root run
sbin srv sys tmp usr var
root@myhostname :/# ls /danger racine hote
bin boot cdrom dev etc home initrd.img lib lib64 lost+found media mnt opt proc
root run sbin srv sys tmp usr var vmlinuz
root@myhostname :/# # Ne pas faire rm -rf /danger racine hote :-0
44/73
Introduction
Bases Premiers pas
Terminal:
5c2eacbfcfee ubuntu "/bin/bash" 8 minutes ago Exited (0) 28 seconds ago myname
jmc@laptop/home/jmc $ docker rm myname

myname
44/73
Introduction
Bases Premiers pas
Terminal:
jmc@laptop/home/jmc $ docker run -it –rm ubuntu /bin/bash
Conteneur:
root@30481297b94c :/# exit
44/73
Introduction
Bases Premiers pas
Résumé
Il peut être dangereux d’exécuter des conteneurs contenant des processus root
On peut monter des répertoires de l’hôte dans le conteneur afin d’assurer la
persistance de certaines données
Cette technologie de persistance s’appelle data volume
Pour des montages sur des ressources partagées (NFS, ISCSI, FC) : voir
docker volume plugin
Il existe une technologie de persistance à travers des conteneurs : data
volume container
45/73
Introduction
Bases Premiers pas
Résumé
volume container
45/73
Introduction
Bases Premiers pas
Résumé
volume container
45/73
Introduction
Bases Premiers pas
Résumé
volume container
45/73
Introduction
Bases Premiers pas
Résumé
volume container
45/73
Introduction
Bases Premiers pas
Plan
2 Bases
Introduction
Premiers pas
Travaux pratiques
46/73
Introduction
Bases Premiers pas

Namespace : isolation de base
Les processus exécutés dans un conteneur ne peuvent ni voir ni affecter les
processus exécutés dans un autre conteneur ou dans le système hôte.
Chaque conteneur possède son propre réseau. Si l’hôte est configuré en
conséquence, les conteneurs peuvent interagir les uns avec les autres (et avec
l’hôte) au travers de leurs interfaces de réseau respectives
Tous les conteneurs d’un hôte Docker sont connectés à des bridges (virtual
switch).
Il est tout de même déconseillé d’utiliser des applications root (ssh, vpn,
dhcp, ...). L’hôte étant supposé subvenir à ces besoins.
Si on souhaite modifier le comportement par défaut de l’isolation, cela
implique une intervention et une connaissance des ”capabilities” (c’est un
prix à payer lorsque l’on partage le même noyau)
Plus d’info sur https://docs.docker.com/engine/security/security/
47/73
Introduction
Bases Premiers pas

switch).
47/73
Introduction
Bases Premiers pas

switch).
47/73
Introduction
Bases Premiers pas

switch).
47/73
Introduction
Bases Premiers pas

switch).
47/73
Introduction
Bases Premiers pas

switch).
47/73
Introduction
Bases Premiers pas
Capabilities
En cas d’escalade de privilège depuis le conteneur sur l’hôte : par défaut le
root dans le conteneur n’a pas les mêmes droits que le potentiel root sur
l’hôte.
En effet celui-ci ne dispose pas de toutes les capabilities.
Plus d’info sur https://linux.die.net/man/7/capabilities
48/73
Introduction
Bases Premiers pas
Capabilities
l’hôte.
48/73
Introduction
Bases Premiers pas
Capabilities
l’hôte.
48/73
Introduction
Bases Premiers pas
Capabilities
l’hôte.
48/73
Introduction
Bases Premiers pas
Capabilities par défaut
CAP CHOWN CAP SETUID

CAP DAC OVERRIDE CAP SETFCAP
CAP FSETID CAP SETPCAP
CAP FOWNER CAP NET BIND SERVICE
CAP MKNOD CAP SYS CHROOT
CAP NET RAW CAP KILL
CAP SETGID CAP AUDIT WRITE
49/73
Introduction
Bases Premiers pas
CGroups : limitations des ressources

Comptabilité et limitations des ressources par conteneur
Par défaut : part équitable de ressources (CPU, RAM, I/O) par conteneur
Empêche l’utilisation de toutes les ressources par un conteneur (démo fork
bomb –cpuset-cpus 0)
D’une certaine manière, ils empêchent certaines attaques de type DOS
”Garantit” une disponibilité et une performance quasiment constante
50/73
Introduction
Bases Premiers pas

50/73
Introduction
Bases Premiers pas

50/73
Introduction
Bases Premiers pas

50/73
Introduction
Bases Premiers pas

50/73
Introduction
Bases Premiers pas
Démon docker
Surface d’attaque
Le démon docker est exécuté en root !
Seul un administrateur devrait pouvoir contrôler ce démon. (quid wrapper)
Quelle confiance accordez vous à l’image docker que vous téléchargez ?
Il est recommandé de n’utiliser que docker sur un serveur (à part ssh, dhcp,
etc, s’il y a d’autres applications, il faut les conteneuriser ou il faut les
déplacer)
Il ne faut pas faire ses tests de conteneur sur une machine de prod !
51/73
Introduction
Bases Premiers pas
Démon docker
Surface d’attaque
déplacer)
51/73
Introduction
Bases Premiers pas
Démon docker
Surface d’attaque
déplacer)
51/73
Introduction
Bases Premiers pas
Démon docker
Surface d’attaque
déplacer)
51/73
Introduction
Bases Premiers pas
Démon docker
Surface d’attaque
déplacer)
51/73
Introduction
Bases Premiers pas
Plan
2 Bases
Introduction
Premiers pas
Travaux pratiques
52/73
Introduction
Bases Premiers pas
C’est possible
Il est tout à fait possible d’exécuter des conteneurs graphiques (skype dans
un conteneur par exemple).
En général, on fait un mapping de /tmp/.X11-unix et de /.Xauthority de
l’hôte vers le conteneur avec Xorg.
Certains utilisent vnc (beaucoup moins efficace, mais plus sécurisé ...).
Quid de Wayland ?
Nous n’aborderons pas plus cet aspect dans ce cours.
53/73
Bases Créations d’images : méthode naı̈ve
Utilisation avancées Créations d’images : Dockerfile
Toujours plus loin
Plan
2 Bases
Introduction
Premiers pas
Travaux pratiques
54/73
Toujours plus loin
La méthode naı̈ve
3 cas d’usage
Pour un usage pédagogique
Lorsque l’on n’est pas en mesure de configurer un environnement autrement
qu’en mode graphique :-( (éclipse par exemple)
Pour déboguer une construction automatisée (docker build)
55/73
Toujours plus loin
Utilisation de docker commit
Terminal:
jmc@laptop/home/jmc $ docker run -it -h conteneur –name
conteneur avant commit ubuntu /bin/bash
Conteneur:
root@conteneur :/# echo ”hello world !”
>/nouveau fichier dans le systeme de fichier racine.txt
root@conteneur :/# exit
exit
56/73
Toujours plus loin
Terminal:

ubuntu latest 7b9b13f7b9c0 2 weeks ago 118 MB
jmc@laptop/home/jmc $ docker commit conteneur avant commit

image apres commit du conteneur
sha256 :ca0028fa88252c281db33655b17517f3484b82ae42057e26193a6b91045bf2b8
image_apres_commit_du_conteneur latest ca0028fa8825 16 minutes ago 118 MB
ubuntu latest 7b9b13f7b9c0 2 weeks ago 118 MB
56/73
Toujours plus loin
Terminal:
jmc@laptop/home/jmc $ docker run –rm image apres commit du conteneur cat
/nouveau fichier dans le systeme de fichier racine.txt
Conteneur:
hello world !
56/73
Toujours plus loin
A vous
Faire une image ”mon image” à partir d’une ubuntu 16.04
Cette nouvelle image contiendra le paquet inetutils-ping
Tester la commande ”docker run mon image ping localhost”
Problème de résolution DNS dans certains sous-réseaux

Il se peut que votre réseau vous oblige à passer par un DNS précis. Ce DNS précis ne
correspond pas forcément aux adresses présentes dans /etc/resolv.conf de l’hôte
(surcharge effectuée par network manager). Dans ce cas, la résolution de nom ne se fera
pas dans le conteneur (et vous ne pourrez pas installer de paquets), car la surcharge de
network manager n’affectera pas le conteneur (qui lui s’en tiendra au fichier
/etc/resolv.conf). De fait, il vous faut soit changer le contenu de /etc/resolv.conf, soit
passer l’argument –dns IP DNS lors du lancement du conteneur. Il préférable, pour la
suite, de privilégier l’ajout du serveur DNS dans le fichier /etc/resolv.conf de l’hôte. Pour
obtenir IP DNS, vous pouvez utiliser l’utilitaire nmcli (network manager command line
interface), en général : nmcli device show | grep DNS.
57/73
Toujours plus loin
Plan
2 Bases
Introduction
Premiers pas
Travaux pratiques
58/73
Toujours plus loin
La méthode efficace : Dockerfile

Un Dockerfile est un document texte contenant toutes les commandes que
vous exécuteriez normalement manuellement sur un OS (apt/yum,
configurations de logiciels, créations d’utilisateurs, variables
d’environnements, ...).
Avec la commande docker build, docker peut créer des images
automatiquement en lisant les instructions d’un Dockerfile.
A chaque instructions du dockerfile, docker build génère une image et un
layer si nécessaire (car potentiellement vide), on parle d’image intermédiaire,
sauf pour la dernière instruction, qui correspond à l’image finale (top level
image).
Les images intermédiaires sont générées par un mécanisme de commit des
conteneurs dans lesquels les instructions ont été exécutées.
On peut créer plusieurs images avec un seul Dockerfile (mais on ne devrait
pas)
59/73
Toujours plus loin

image).
pas)
59/73
Toujours plus loin

image).
pas)
59/73
Toujours plus loin

image).
pas)
59/73
Toujours plus loin

image).
pas)
59/73
Toujours plus loin
Il faut dédier un répertoire pour chaque création d’image par dockerfile. En

effet, docker build fonctionne avec une notion de contexte qui s’applique
récursivement à partir du chemin (path) du répertoire contenant le Dockerfile.
Il ne faut surtout pas créer un Dockerfile à la racine du système. En effet, le
contexte envoyé au démon docker concernerait l’intégralité du système de
fichiers !
À l’instar de git, vous pouvez utiliser un fichier .dockerignore.
docker build ignorera tous les fichiers/répertoires indiqués dans .dockerignore
(i.e. ils ne feront pas partie du contexte).
Les commentaires dans un Dockerfile sont préfixés par #.
60/73
Toujours plus loin
Il est possible d’utiliser des variables interprétables par certaines instructions

dans un Dockerfile.
Ces variables sont des variables d’environnement (comme HOME, PATH, ...)
61/73
Toujours plus loin

Liste des instructions possibles
FROM
ENTRYPOINT
RUN
VOLUME
CMD
USER
LABEL
WORKDIR
MAINTAINER (déprécié,
ARG
utiliser LABEL)
ONBUILD
EXPOSE
STOPSIGNAL
ENV
HEALTHCHECK
ADD
SHELL
COPY
Capables d’interpréter les variables d’environnement
62/73
Toujours plus loin

Dockerfile d’un serveur ssh
63/73
Toujours plus loin
Dockerfile serveur ssh : /home/jmc/sshd/Dockerfile
Terminal:
jmc@laptop/home/jmc/sshd $ docker build . -t sshd
Sending build context to Docker daemon 8.192 kB

Step 1/8 : FROM debian:testing-slim
testing-slim: Pulling from library/debian
8f99754b7fe0: Pull complete
Digest: sha256:a00ac0aa75d79b5db3e5b0c66ddae4ccb6a9b0d28a856607de7ef2ac6527cdc7
Status: Downloaded newer image for debian:testing-slim
---> f2020c7a5565
Step 2/8 : ENV VERSION 1 DEBIAN_FRONTEND noninteractive
---> Running in 358b9c6ec81e
---> e3ef9a7b6a23
Removing intermediate container 358b9c6ec81e
Step 3/8 : LABEL maintainer "Jean-Mathieu Chantrein" maintainer_email "[email protected]" version "${VERSION}"
---> Running in f4d7a947fe58
---> fbb7230757c2
Removing intermediate container f4d7a947fe58
Step 4/8 : RUN useradd lambda --create-home --shell /bin/bash && echo "lambda:password" | chpasswd
---> Running in a9c930c23c4a
---> a17fecb71d55
Removing intermediate container a9c930c23c4a
64/73
Toujours plus loin

Dockerfile serveur ssh : /home/jmc/sshd/Dockerfile
Terminal:
Step 5/8 : RUN apt update && apt install -yq openssh-server && rm -rf /varlib/apt/lists/* && mkdir /var/run/sshd
---> Running in c378b292a0d0
[update, install, config ...]
---> 15bd3d357785
Removing intermediate container c378b292a0d0
Step 6/8 : RUN chmod u+s /usr/sbin/sshd
---> Running in a697d7d0bcde
---> 174bd751e04d
Removing intermediate container a697d7d0bcde
Step 7/8 : USER lambda
---> Running in e512834f2b07
---> c7002394e3de
Removing intermediate container e512834f2b07
Step 8/8 : CMD /usr/sbin/sshd -D
---> Running in 83b6f14485f3
---> 1c1305bc7c28
Removing intermediate container 83b6f14485f3
Successfully built 1c1305bc7c28
jmc@laptop/home/jmc/sshd $
64/73
Toujours plus loin

Dockerfile serveur ssh : explication graphique
65/73
Toujours plus loin

65/73
Toujours plus loin

65/73
Toujours plus loin

65/73
Toujours plus loin

65/73
Toujours plus loin

65/73
Toujours plus loin

65/73
Toujours plus loin

65/73
Toujours plus loin

65/73
Toujours plus loin

65/73
Toujours plus loin

65/73
Toujours plus loin

65/73
Toujours plus loin

65/73
Toujours plus loin

65/73
Toujours plus loin

65/73
Toujours plus loin

Dockerfile d’un serveur ssh : notions de contexte et de cache
66/73
Toujours plus loin
Dockerfile serveur ssh : notions de contexte et de cache
Terminal:
jmc@laptop/home/jmc/sshd $ docker build . -t sshd
Sending build context to Docker daemon 8.192 kB
Step 1/8 : FROM debian:testing-slim
---> f2020c7a5565
Step 2/8 : ENV VERSION 1 DEBIAN_FRONTEND noninteractive
---> Using cache
---> e3ef9a7b6a23
Step 3/8 : LABEL maintainer "Jean-Mathieu Chantrein" maintainer_email "[email protected]" version "${VERSION}"
---> Using cache
---> fbb7230757c2
Step 4/8 : RUN useradd lambda --create-home --shell /bin/bash && echo "lambda:password" | chpasswd
---> Using cache
---> a17fecb71d55
Step 5/8 : RUN apt update && apt install -yq openssh-server && rm -rf /varlib/apt/lists/* && mkdir /var/run/sshd
---> Using cache
---> 15bd3d357785
67/73
Toujours plus loin
Terminal:
Step 6/8 : RUN chmod u+s /usr/sbin/sshd && echo "Une modification de cette instruction"
---> Running in a74783d3335a
Une modification de cette instruction
---> 1e8030a5f34b
Removing intermediate container a74783d3335a
Step 7/8 : USER lambda
---> Running in 6275d6897c41
---> 07c952331a94
Removing intermediate container 6275d6897c41
Step 8/8 : CMD /usr/sbin/sshd -D
---> Running in 35b3a68cb6e8
---> 8f8b2b932bc7
Removing intermediate container 35b3a68cb6e8
Successfully built 8f8b2b932bc7
jmc@laptop/home/jmc/sshd $
67/73
Toujours plus loin

Terminal:
jmc@laptop/home/jmc/sshd $ docker images
sshd latest 8f8b2b932bc7 17 minutes ago 143 MB
<none> <none> 1c1305bc7c28 2 days ago 143 MB
debian testing-slim f2020c7a5565 5 days ago 55.2 MB
jmc@laptop/home/jmc/sshd $ docker images -a # Combien d’images ?

<none> <none> 07c952331a94 9 minutes ago 143 MB
<none> <none> 1e8030a5f34b 9 minutes ago 143 MB
<none> <none> c7002394e3de 2 days ago 143 MB
<none> <none> 15bd3d357785 2 days ago 142 MB
<none> <none> 174bd751e04d 2 days ago 143 MB
<none> <none> a17fecb71d55 2 days ago 55.6 MB
<none> <none> e3ef9a7b6a23 2 days ago 55.2 MB
<none> <none> fbb7230757c2 2 days ago 55.2 MB
67/73
Toujours plus loin

Terminal:
jmc@laptop/home/jmc/sshd $ docker images -a –filter dangling=true
jmc@laptop/home/jmc/sshd $ docker rmi 1c1

Deleted: sha256:1c1305bc7c283f1e5644209d9144184f9b1d4fd15020486eda7217227f7ad3e4
Deleted: sha256:c7002394e3de48d4e085b957c747fbb1f82123b09ccc1987045b4692c6834eff
Deleted: sha256:174bd751e04da05124ec3b7c42cd04f22e2507b11afde8782e772a755d1ee4b5
Suppression automatique des images non utilisées (i.e. : n’étant parentes d’aucune
top level image taguée)
67/73
Toujours plus loin
Terminal:
jmc@laptop/home/jmc/sshd $ docker images -a # Combien d’images ?
<none> <none> 07c952331a94 29 minutes ago 143 MB
<none> <none> 1e8030a5f34b 29 minutes ago 143 MB
<none> <none> 15bd3d357785 2 days ago 142 MB
<none> <none> a17fecb71d55 2 days ago 55.6 MB
<none> <none> fbb7230757c2 2 days ago 55.2 MB
<none> <none> e3ef9a7b6a23 2 days ago 55.2 MB
Les images non utilisées ont bel et bien été supprimées
67/73
Toujours plus loin

Terminal:
jmc@laptop/home/jmc/sshd $ docker history sshd
IMAGE CREATED CREATED BY SIZE COMMENT
8f8b2b932bc7 About an hour ago /bin/sh -c #(nop) CMD ["/usr/sbin/sshd" "... 0 B
07c952331a94 About an hour ago /bin/sh -c #(nop) USER [lambda] 0 B
1e8030a5f34b About an hour ago /bin/sh -c chmod u+s /usr/sbin/sshd && ec... 791 kB
15bd3d357785 3 days ago /bin/sh -c apt update && apt install -... 86.8 MB
a17fecb71d55 3 days ago /bin/sh -c useradd lambda --create-home --... 333 kB
fbb7230757c2 3 days ago /bin/sh -c #(nop) LABEL maintainer=Jean-M... 0 B
e3ef9a7b6a23 3 days ago /bin/sh -c #(nop) ENV VERSION=1 DEBIAN_FR... 0 B
f2020c7a5565 5 days ago /bin/sh -c #(nop) CMD ["bash"] 0 B
<missing> 5 days ago /bin/sh -c #(nop) ADD file:2bad6c695080ae4... 55.2 MB
Les images de taille 0 n’ont pas généré de layer et reposent sur les layers des
images parentes (on parle de layer vide (empty layer))
Pourquoi y a-t-il une différence de 3 jours dans la création des images ?
67/73
Toujours plus loin
Encore quelques informations

Il est important de taguer/versionner ses images de production
Les images les plus lourdes devraient être les plus basses (utilisation efficace
du mécanisme du cache)
Les instructions susceptibles de changer régulièrement devraient se situer
dans les couches basses
Attention aux directives ”update” et ”install” lors de l’utilisation du cache
Tout changement de contexte (modifications d’un fichier ajouté par ADD ou
COPY) entraine une reconstruction des images à partir de la couche affectée
Chaque construction (build) d’un Dockerfile génère une nouvelle image
(modulo une utilisation totale du cache).
Chaque instruction est indépendante (cela n’a pas de sens d’écrire RUN cd
/tmp )
68/73
Toujours plus loin

/tmp )
68/73
Toujours plus loin

/tmp )
68/73
Toujours plus loin

/tmp )
68/73
Toujours plus loin

/tmp )
68/73
Toujours plus loin

/tmp )
68/73
Toujours plus loin

/tmp )
68/73
Toujours plus loin

Terminal:
jmc@laptop/home/jmc $ docker built . -t independant instruction
Step 1/4 : FROM alpine:latest
---> 7328f6f8b418
Step 2/4 : RUN cd /tmp
---> Running in d172a17e8705
---> 1eb259884a9f
Removing intermediate container d172a17e8705
Step 3/4 : RUN pwd
---> Running in 80a06bfd0434
/
---> 9f59028b0464
Removing intermediate container 80a06bfd0434
Step 4/4 : [...]
68/73
Toujours plus loin
Pour info
Pour changer de répertoire pour les instructions à suivre (y compris pour

d’éventuelles images enfantes) ⇒ Utiliser l’instruction WORKDIR
69/73
Toujours plus loin
A vous
Rédigez un dockerfile permettant de créer une image ”mon image” à partir
d’une ubuntu 16.04
Cette nouvelle image contiendra le paquet inetutils-ping
La commande par défaut doit être ping localhost (instruction CMD)
Testez votre image en instanciant un conteneur
Essayez de surcharger la commande par défaut en la remplaçant par ping
qwant.com
70/73
Toujours plus loin
Différence entre les intructions CMD et ENTRYPOINT

Construisez l’image du Dockerfile suivant avec docker build . -t ping :
FROM ubuntu:16.04
RUN DEBIAN_FRONTEND=noninterractive apt update && \
apt install -yq inetutils-ping && \
apt clean
ENTRYPOINT ["ping","-c 2"]
CMD ["localhost"]
Instanciez cette image sans surcharge avec docker run ping
Instanciez cette image en surchargeant avec docker run ping qwant.com
71/73
Toujours plus loin
Différence entre les intructions CMD et ENTRYPOINT

Construisez l’image du Dockerfile suivant avec docker build . -t ping :
FROM ubuntu:16.04
RUN DEBIAN_FRONTEND=noninterractive apt update && \
apt install -yq inetutils-ping && \
apt clean
ENTRYPOINT ["ping","-c 2"]
CMD ["localhost"]
Instanciez cette image sans surcharge avec docker run ping
Instanciez cette image en surchargeant avec docker run ping qwant.com
ENTRYPOINT permet de se servir d’un conteneur comme d’un exécutable

On peut surcharger ENTRYPOINT avec l’option –entrypoint
On peut modifier les paramètres de l’exécutable définit dans ENTRYPOINT
en surchargeant CMD
On peut ajouter des paramètres à ENTRYPOINT qui ne seront pas
surchargés par CMD 71/73
Bases
Travaux pratiques
Toujours plus loin
Plan
2 Bases
Introduction
Premiers pas
Travaux pratiques
72/73
Bases
Travaux pratiques
Toujours plus loin
Travaux pratiques : de dockerfile à docker swarm en

passant par docker compose
Réaliser un service wordpress conteneurisé

Nous changeons de support afin de passer (enfin) à la pratique
Merci de vous rendre sur la page web suivante : https://github.com/
jmchantrein/formation_docker/blob/master/travaux_pratiques.md
73/73

Docker Presentation

Transféré par

Droits d'auteur :

Formats disponibles

Docker Presentation

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Docker Presentation

Transféré par

Droits d'auteur :

Formats disponibles

Introduction générale

Fondements de la technologie de conteneurisations

Ce document est mis à disposition selon les termes de

Au commencement il y avait ...

... la machine physique : l’ordinateur (serveur, PC, Mac, ...)

Système d’exploitation (Operating System, abrégé OS)

Au commencement il y avait ...

... la machine physique : l’ordinateur (serveur, PC, Mac, ...)

Système d’exploitation (Operating System, abrégé OS)

Au commencement il y avait ...

... la machine physique : l’ordinateur (serveur, PC, Mac, ...)

Système d’exploitation (Operating System, abrégé OS)

Au commencement il y avait ...

... la machine physique : l’ordinateur (serveur, PC, Mac, ...)

Système d’exploitation (Operating System, abrégé OS)

Au commencement il y avait ...

... la machine physique : l’ordinateur (serveur, PC, Mac, ...)

Système d’exploitation (Operating System, abrégé OS)

Ensuite, il y a eu la virtualisation ...

... de machine (machine virtuelle, virtual machine, abrégé VM)

Ensuite, il y a eu la virtualisation ...

... de machine (machine virtuelle, virtual machine, abrégé VM)

Ensuite, il y a eu la virtualisation ...

... de machine (machine virtuelle, virtual machine, abrégé VM)

Ensuite, il y a eu la virtualisation ...

... de machine (machine virtuelle, virtual machine, abrégé VM)

Ensuite, il y a eu la virtualisation ...

... de machine (machine virtuelle, virtual machine, abrégé VM)

Architecture simplifiée du modèle VM/hyperviseur

Architecture simplifiée du modèle VM/hyperviseur

Architecture simplifiée du modèle VM/hyperviseur

Architecture simplifiée du modèle VM/hyperviseur

Architecture simplifiée du modèle VM/hyperviseur

Architecture simplifiée du modèle VM/hyperviseur

Architecture simplifiée du modèle VM/hyperviseur

Architecture simplifiée du modèle VM/hyperviseur

Architecture simplifiée du modèle VM/hyperviseur

Architecture simplifiée du modèle VM/hyperviseur

... et la virtualisation d’environnement : la conteneurisation

Terminologie : virtualisation légère versus conteneurisation

... et la virtualisation d’environnement : la conteneurisation

Terminologie : virtualisation légère versus conteneurisation

... et la virtualisation d’environnement : la conteneurisation

Terminologie : virtualisation légère versus conteneurisation

... et la virtualisation d’environnement : la conteneurisation

Terminologie : virtualisation légère versus conteneurisation

Architecture simplifiée du modèle conteneur/OS

Architecture simplifiée du modèle conteneur/OS

Architecture simplifiée du modèle conteneur/OS

Architecture simplifiée du modèle conteneur/OS

Architecture simplifiée du modèle conteneur/OS

Architecture simplifiée du modèle conteneur/OS

Architecture simplifiée du modèle conteneur/OS

Architecture simplifiée du modèle conteneur/OS

Architecture simplifiée du modèle conteneur/OS

Architecture simplifiée du modèle conteneur/OS

Architecture simplifiée du modèle conteneur/OS

Architecture simplifiée du modèle conteneur/OS

Architecture simplifiée du modèle conteneur/OS

Chroot : le prémice de la conteneurisation