Gérer les conteneurs Linux avec Docker sur Ubuntu

Version : 1.0
Auteurs : Srijan Kishore
Dernière modification : 02 /Juil/2014

Ce guide explique comment installer Docker et gérer efficacement les machines virtuelles. Docker est une plateforme de virtualisation Linux Open Source pour les développeurs et les administrateurs système afin de construire, déployer et exécuter facilement des applications distribuées. Docker se compose du Docker Engine, une couche d’exécution légère et de virtualisation, d’outils pour empaqueter et versionner des machines virtuelles similaires à un dépôt de code source et de Docker Hub, un service dans le cloud pour partager des applications et automatiser le flux de travail. Docker permet d’assembler rapidement des applications à partir de composants et élimine les frictions entre les environnements de développement, le contrôle qualité et la production.

1 Remarque préliminaire

Dans mon cas, j’ai Ubuntu 14.04 sur lequel je vais installer Docker. Sur le marché des logiciels de virtualisation, nous avons plusieurs technologies de virtualisation matérielle complète disponibles comme KVM, Xen ou Hyper-V. Mais les visualisations complètes sont trop lourdes pour virtualiser des applications uniques sur Linux. Nous pouvons surmonter cette situation en utilisant des conteneurs Linux qui sont une bonne alternative pour la virtualisation au niveau du système d’exploitation. Les conteneurs Linux sont très utiles pour avoir un environnement de développement/test dans un ensemble sécurisé de conteneurs. Docker fournit un environnement de conteneurs Linux à cet effet.

2 Installation

Comme je l’ai mentionné ci-dessus, j’ai Ubuntu sur lequel je vais installer Docker. Dans ce chapitre, je vais vous montrer 2 options pour installer Docker, dans 2a j’utilise la version de Docker du dépôt Ubuntu, cette version est maintenue par Ubuntu pour les 5 années complètes de support LTS, mais ce n’est pas la dernière version. Dans 2b, j’utiliserai la dernière version du dépôt PPA d’Ubuntu. Comme Docker est en développement actif, la dernière version de Docker de 2b) conviendra très probablement à la plupart des utilisateurs. Veuillez utiliser soit la méthode 2a soit 2b mais pas les deux en même temps !

2a Installer depuis le dépôt officiel d’Ubuntu

Pour installer, utilisez :

sudo apt-get update  
sudo apt-get install docker.io

et créez un lien symbolique pour faciliter l’utilisation dans le shell.

sudo ln -sf /usr/bin/docker.io /usr/local/bin/docker  
sudo sed -i '$acomplete -F _docker docker' /etc/bash_completion.d/docker.io

2b Installer la dernière version de Docker

Pour installer la dernière version de Docker depuis le dépôt docker.io, exécutez cette commande

curl -s https://get.docker.io/ubuntu/ | sudo sh

3 Préparer l’environnement shell

Maintenant, je vais ajouter mon utilisateur=srijan au groupe docker

sudo usermod -a -G docker srijan

Ou utilisez :

sudo usermod -a -G docker $USER

Ici, je vais me déconnecter de ma session actuelle et me reconnecter. Maintenant, je vais ajouter le fichier de configuration Docker pour que le système soit notifié de son emplacement.

sudo vi /etc/default/docker.io

| DOCKER="/usr/bin/docker.io" |

Maintenant, redémarrez le service comme suit :

sudo service docker.io restart

4 Gestion des conteneurs

Je vais démarrer un conteneur avec le système d’exploitation Ubuntu. Je vais télécharger l’image Docker comme suit :

docker pull ubuntu

 Remarque : pull est utilisé pour tirer une image ou un dépôt depuis le registre

Maintenant, je vais me connecter au shell bash du conteneur Ubuntu en utilisant :

docker run -i -t ubuntu /bin/bash

Juste pour confirmation, je vais vérifier l’IP de mon conteneur comme suit :

root@fd98ee950252:/# ifconfig 
eth0      Link encap:Ethernet  HWaddr 5a:a6:c6:88:f2:48  
          inet addr:172.17.0.3  Bcast:0.0.0.0  Mask:255.255.0.0
          inet6 addr: fe80::58a6:c6ff:fe88:f248/64 Scope:Link
          UP BROADCAST RUNNING  MTU:1500  Metric:1
          RX packets:7 errors:0 dropped:2 overruns:0 frame:0
          TX packets:8 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000 
          RX bytes:558 (558.0 B)  TX bytes:648 (648.0 B)

lo        Link encap:Local Loopback  
          inet addr:127.0.0.1  Mask:255.0.0.0
          inet6 addr: ::1/128 Scope:Host
          UP LOOPBACK RUNNING  MTU:1500  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0 
          RX bytes:0 (0.0 B)  TX bytes:0 (0.0 B)

root@fd98ee950252:/#

J’ai une IP de 172.17.0.3 sur mon conteneur. De même, je peux utiliser d’autres conteneurs aussi. Pour quitter le conteneur, tapez simplement :

exit

De même, vous pouvez avoir d’autres conteneurs OS, par exemple.

Je veux utiliser un conteneur Debian, j’utiliserai le code :

docker run -i -t debian /bin/bash

Si vous voulez avoir une distribution particulière, utilisez :

docker run -i -t ubuntu:12.04 /bin/bash

Cela créera le conteneur ubuntu12.04. Je vais le vérifier comme suit :

root@44b56100fd1f:/# cat /etc/lsb-release 
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=12.04
DISTRIB_CODENAME=precise
DISTRIB_DESCRIPTION="Ubuntu 12.04.4 LTS"
root@44b56100fd1f:/#

4 Construire nos propres images

Il existe deux façons de créer une image Docker :

Via la commande docker commit
Via la commande docker build avec un Dockerfile

La méthode docker commit n’est actuellement pas recommandée, car la construction avec un Dockerfile est beaucoup plus flexible et puissante, mais nous allons vous la démontrer pour des raisons de complétude. Après cela, je me concentrerai sur la méthode recommandée pour construire des images Docker : écrire un Dockerfile et utiliser la commande docker build.

4.1 Utiliser Docker commit pour créer des images

Je vais créer un conteneur, apporter des modifications à ce conteneur comme vous le feriez pour changer du code, puis valider ces modifications dans une nouvelle image.

Commençons par créer un conteneur à partir de l’image Ubuntu que nous avons utilisée dans le passé.

docker run -i -t ubuntu /bin/bash  
root@73527b8b4261:/#

Remarque : Veuillez voir ci-dessus, root montre le nom d'hôte 73527b8b4261, c'est le nom du conteneur créé et il différera dans votre cas.

Ensuite, j’installerai Apache dedans :

apt-get install apache2

J’ai lancé le conteneur et ensuite installé Apache à l’intérieur. Maintenant, je vais utiliser ce conteneur comme serveur web, donc je vais le sauvegarder dans son état actuel.
Cela nous évitera d’avoir à le reconstruire avec Apache chaque fois que je crée un nouveau conteneur. Pour ce faire, je vais quitter le conteneur, en utilisant la commande exit,
et utiliser la commande docker commit.

exit

docker commit 73527b8b4261 srijan/apache2 8ce0ea7a1528

Remarque : ici 73527b8b4261 est le nom de mon conteneur et j’utilise 8ce0ea7a1528 comme tag pour le conteneur, vous pouvez donner n’importe quel nom de tag ou utiliser le même.

Supposons que vous ayez oublié l’ID du dernier conteneur créé, vous pouvez utiliser :

docker ps -l -q

Cela donnera 73527b8b4261

Remarque : 73527b8b4261 est le nom de votre dernier conteneur créé, il différera dans votre cas.*

Voyons notre nouvelle image. Cela peut être réalisé comme suit :

docker images srijan/apache2

srijan@vboxtest:~$ docker images srijan/apache2
REPOSITORY          TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
srijan/apache2      8ce0ea7a1528        741155868ac8        6 minutes ago       207.2 MB
srijan@vboxtest:~$

Remarque : Ici 8ce0ea7a1528 était le nom de tag que j'ai utilisé au moment de la sauvegarde du conteneur,   
Remarque : 741155868ac8 est l'ID de l'IMAGE de ce conteneur  
Remarque : Toutes ces valeurs différeront dans votre cas car au moment de la sauvegarde du conteneur, Docker génère des noms aléatoires pour eux.

Maintenant, je vais sauvegarder l’image personnalisée comme suit :

docker commit -m="Une nouvelle image personnalisée" --author="Srijan Kishore" 73527b8b4261 srijan/apache2:webserver

Cela donnera le résultat suivant :

srijan@vboxtest:~$ docker commit -m="Une nouvelle image personnalisée" --author="Srijan Kishore" 73527b8b4261 srijan/apache2:webserver
f0367362eb405c513ac002b5cf172a2c0bc6c8212eab91c613f9ee611cf92fec

Pour exécuter un conteneur à partir de notre nouvelle image, nous pouvons le faire en utilisant la commande docker run.

docker run -t -i srijan/apache2:webserver /bin/bash

Nous pouvons vérifier notre image validée comme suit :

docker inspect srijan/apache2:webserver

srijan@vboxtest:~$ docker inspect srijan/apache2:webserver
[{
    "Architecture": "amd64",
    "Author": "Srijan Kishore",
    "Comment": "Une nouvelle image personnalisée",
    "Config": {
        "AttachStderr": false,
        "AttachStdin": false,
        "AttachStdout": false,
        "Cmd": [
            "/bin/bash"
        ],
        "CpuShares": 0,
        "Cpuset": "",
        "Domainname": "",
        "Entrypoint": null,
        "Env": [
            "HOME=/",
            "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
        ],
        "ExposedPorts": null,
        "Hostname": "",
        "Image": "",
        "Memory": 0,
        "MemorySwap": 0,
        "NetworkDisabled": false,
        "OnBuild": null,
        "OpenStdin": false,
        "PortSpecs": null,
        "StdinOnce": false,
        "Tty": false,
        "User": "",
        "Volumes": null,
        "WorkingDir": ""
    },
    "Container": "73527b8b42614f6ecd83fb5f9822d6086988d3b68fd5e32b4afbc7cd415402fd",
    "ContainerConfig": {
        "AttachStderr": true,
        "AttachStdin": true,
        "AttachStdout": true,
        "Cmd": [
            "/bin/bash"
        ],
        "CpuShares": 0,
        "Cpuset": "",
        "Domainname": "",
        "Entrypoint": null,
        "Env": [
            "HOME=/",
            "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
        ],
        "ExposedPorts": null,
        "Hostname": "73527b8b4261",
        "Image": "ubuntu",
        "Memory": 0,
        "MemorySwap": 0,
        "NetworkDisabled": false,
        "OnBuild": null,
        "OpenStdin": true,
        "PortSpecs": null,
        "StdinOnce": true,
        "Tty": true,
        "User": "",
        "Volumes": null,
        "WorkingDir": ""
    },
    "Created": "2014-06-30T12:58:04.973349049Z",
    "DockerVersion": "1.0.1",
    "Id": "f0367362eb405c513ac002b5cf172a2c0bc6c8212eab91c613f9ee611cf92fec",
    "Os": "linux",
    "Parent": "ef83896b7fb99b00b9e0e6ac943826386e7edcef11a3a2f58b42011ab4a4e683",
    "Size": 14463026
}
srijan@vboxtest:~$

Pour exécuter un conteneur à partir de notre nouvelle image, nous pouvons le faire en utilisant la commande docker run.

docker run -t -i srijan/apache2:webserver /bin/bash