\newpage

Mon premier conteneur
=====================

Afin de tester la bonne marche de notre installation, lançons notre premier
conteneur avec la commande :

<div lang="en-US">
```
    docker container run hello-world
```
</div>

Cette commande va automatiquement exécuter une série de commandes pour nous,
comme indiqué dans le message affiché en retour :

D'abord, le daemon va rechercher s'il possède localement l'image
*hello-world*. Si ce n'est pas le cas, il va aller la récupérer sur
`store.docker.com`. Ce site met à disposition un grand nombre d'images : des
systèmes de base comme Ubuntu, Debian, Centos, etc. jusqu'à des conteneurs
prêts à l'emploi : le serveur web nginx, la base de données MySQL, un serveur
node.js, etc.

Nous pouvons directement utiliser le client pour rechercher une image sur le
*Store*, en utilisant la commande `search` :

<div lang="en-US">
```
    docker search mariadb
```
</div>

Il est possible de mettre à jour les images locales ou simplement
pré-télécharger des images depuis le Store en utilisant la commande `pull` :

<div lang="en-US">
```
    docker image pull ubuntu
```
</div>

Remarquez comment on interagit avec chaque *objet Docker* : dans la ligne de
commande, le premier mot clef est le type d'objet (`container`, `image`,
`service`, `network`, `volume`, ...) ; ensuite, vient l'action que l'on
souhaite faire dans ce cadre.[^oldcall]

[^oldcall]: cela n'a pas toujours été aussi simple, cette syntaxe n'existe que
    depuis la version 1.13 (janvier 2017). C'est pourquoi, lorsque vous ferez
    des recherches sur internet, vous trouverez de nombreux articles utilisant
    l'ancienne syntaxe, sans le type d'objets : `docker images` au lieu de
    `docker image ls`, `docker run` au lieu de `docker container run`, ...

	L'ancienne syntaxe est dépréciée, mais il reste actuellement possible de
    l'utiliser.

Par exemple, pour consulter la liste des images dont nous disposons localement
(soit parce qu'on les a téléchargées, soit parce que nous les avons créées
nous-même), on utilise la commande `ls` sous le type d'objets `image` :

<div lang="en-US">
```
    docker image ls
```
</div>

Vous devriez constater la présence de plusieurs images « Ubuntu », mais chacune
a un *TAG* différent. En effet, souvent, il existe plusieurs versions d'une même
image. Pour Ubuntu par exemple, nous avons la possibilité de lancer la version
`trusty`, `xenial`, `zesty` ou `artful`.

Chaque image est identifiable par son *Image ID* unique ; les noms d'images
ainsi que leurs tags sont, comme les tags Git, une manière humainement plus
simple de faire référence aux identifiants.

Chaque nom d'image possède au moins un tag associé par défaut : *latest*. C'est
le tag qui est automatiquement recherché lorsque l'on ne le précise pas en
lançant l'image.


## Exécuter un programme dans un conteneur

Maintenant que nous avons à notre disposition l'image d'un conteneur Ubuntu,
lançons-la !

La commande `run` de Docker prend comme derniers arguments le programme à
lancer dans le conteneur ainsi que ses éventuels arguments. Essayons d'afficher
un Hello World :

<div lang="en-US">
```
    docker container run ubuntu /bin/echo "Hello World"
```
</div>

Dans notre exemple, c'est bien le `/bin/echo` présent dans le conteneur qui est
appelé. Ce n'est pas le programme `/bin/echo` de la machine hôte qui a été
transféré dans le conteneur.

Pour nous en convaincre, nous pouvons tenter d'exécuter un programme qui n'est
pas présent sur notre machine, mais bien uniquement dans le conteneur. Si vous
n'utilisez pas [Alpine Linux](https://www.alpine-linux.org), vous pourriez
tenter d'utiliser son gestionnaire de paquet `apk`, via :

<div lang="en-US">
```
    docker container run alpine /sbin/apk stats
```
</div>


### Images vs. conteneurs

À chaque fois que nous lançons un `run`, un nouveau conteneur est créé.
L'image fournie comme argument est utilisée comme un modèle de base pour le
conteneur et est recopiée grâce à un mécanisme de *Copy-On-Write*: c'est donc
très rapide et ne consomme pas beaucoup d'espace disque.

Étant donné que chaque conteneur est créé à partir d'un modèle, cela signifie
que lorsque nous exécutons une commande modifiant les fichiers d'un conteneur,
cela ne modifie pas l'image de base, mais crée une nouvelle image. Que nous
pouvons ensuite utiliser comme image de base.

![Images vs. conteneurs](img-vs-cntr.png "Images vs. conteneurs"){ width=85% }

Dans ce schéma, on considère les images comme étant la partie figée de Docker à
partir desquelles on peut créer des conteneurs.

Si l'on souhaite qu'une modification faite dans un conteneur (par exemple
l'installation d'un paquet) s'applique à d'autres conteneurs, il va falloir
créer une nouvelle image à partir de ce conteneur.


### Les paramètres

Vous avez remarqué l'utilisation des options `--tty` et `--interactive` ? Avant
le nom de l'image, elles sont gérées par Docker pour modifier le comportement
du `run`. En fait, tout comme `git(1)` et ses sous-commandes, chaque niveau de
commande peut prendre des paramètres :

<div lang="en-US">
```
    docker DOCKER_PARAMS container run RUN_OPTS image IMAGE_CMD IMAGE_ARGS ...
```
</div>

Par exemple :

<div lang="en-US">
```
    docker -H unix:///var/run/docker.sock container run -it alpine /bin/ash -c "echo foo"
```
</div>

Ici, l'option `-H` sera traitée par le client Docker (pour définir
l'emplacement du point de communication avec le daemon), tandis que les options
`-it` seront utilisées lors du traitement du `run`. Quant au `-c`, il sera
simplement transmis au conteneur comme argument au premier `execve(2)` du
conteneur.

Avec l'option `--interactive`, on s'assure que l'entrée standard ne sera pas
fermée (`close(2)`). Nous demandons également l'allocation d'un TTY,
sans quoi `bash` ne se lancera pas en mode interractif[^bashnointer].

[^bashnointer]: Mais il sera possible de l'utiliser sans allouer de TTY, comme
    par exemple en faisant :

	<div lang="en-US">
	```
    	42sh$ cat cmd
    	echo foo
    	42sh$ cat cmd | docker run -i busybox
    	foo
	```
    </div>

	L'option `-i` reste néanmoins nécessaire pour que l'entrée standard soit
    transmise au conteneur.


## Lister les conteneurs

Avant de quitter notre conteneur, regardons, à l'aide d'un autre terminal,
l'état de notre conteneur. La commande suivnate permet d'obtenir la liste des
conteneurs en cours d'exécution :

<div lang="en-US">
```
    42sh$ docker container ls
    CONTAINER ID   IMAGE    COMMAND       CREATED         STATUS        PORTS   NAMES
    4c39fc049cd1   ubuntu   "/bin/bash"   6 minutes ago   Up 5 minutes          suspicious_galileo
```
</div>


## Sortir d'un conteneur

Pour mettre fin à l'exécution d'un conteneur, il convient de terminer le
premier processus lancé dans celui-ci.

Si vous faites face à une invite de commande, le classique `exit` ou `^D`
mettra fin au *shell*, qui était le premier processus lancé de notre conteneur,
comme le montre la colonne `COMMAND`. Nous retrouvons juste après notre invite
habituelle, dans l'état où nous l'avions laissée avant de lancer notre
conteneur. En effet, le conteneur était alors le processus fils lancé par notre
shell.
