Utilisation de Docker

Concepts de base

Docker est une alternative aux machines virtuelles. C'est une architecture logicielle qui permet d'exécuter du code (y compris des logiciels système) en local sur sa machine mais dans un environnement isolé (appelé « container »). Pour en savoir plus : voir la page Wikipédia.

Docker utilise deux concepts de base:

les images qui sont les différentes applications possibles pouvant tourner sur votre machine (par exemple une image « Ubuntu 16.04 », une image pour un server Web (« httpd »), une image pour un simple « hello world », etc.) ;
les containers qui sont des instances d'images en cours d'exécution ; on peut par exemple avoir plusieurs containers de l'image « Ubuntu 16.04 ».

Il est important de bien comprendre la distinction des deux. En particulier, des modifications effectuées dans containers ne vont pas affecter son image (contrairement à ce qui se passe avec une machine virutelle par exemple).

Pour voir toutes les images disponibles sur votre machine (une fois Docker installé, cf ci-dessous) :

docker images

Pour voir tous les containers en cours sur votre machine :

docker ps -a

Installation de docker

L'installation de Docker sur votre machine est normalement assez facile. Voir leur page d'installation pour plus de détails.

Vérifiez que Docker fonctionne

docker run hello-world

En cas de succes, vous verrez un message de confirmation "Hello from Docker".

Par contre, certaines installations nécessite des privilèges additionnels pour tourner Docker.

Si vous avez un message d'erreur, suivez les instructions ici et changez les permissions du socket si nécessaire.

Pour Ubuntu comme host, la marche à suivre est:

sudo groupadd docker
sudo usermod -aG docker ${USER}
sudo chmod 666 /var/run/docker.sock

Création d'une image pour le cours

Si vous souhaitez développer sous Docker (mais ce n' est pas ce que nous recommandons comme premier choix, en particulier à celles et ceux qui ne codent pas sur la ligne de commande (vim) mais utilisent plutôt une interface graphique), vous pouvez créer votre propre image de travail.
Si vous n'utiliserez Docker que pour recevoir le feedback du cours, il n'est pas nécessaire de faire une image spécifique (nous fournirons notre image pour les tests).

Docker propose déjà plusieurs images sur son « hub ». Le plus simple pour créer une image de développement pour le cours, c'est de partir d'une image Ubuntu :

docker pull ubuntu

Puis lancer l'image (= créer un nouveau container ; voir tout en bas de la page pour un rappel des principales commandes) :

docker run -ti ubuntu bash

Au cas où l'image ne serait pas à jour (ces commandes sont à exécuter dans le shell du container Ubuntu) :

apt update
apt upgrade -y

Installation des outils nécessaires pour le cours (cette commande est à exécuter dans le shell du container Ubuntu) :

apt install build-essential clang check wdiff colordiff git openssh-client manpages manpages-dev doxygen curl
apt install libssl-dev libssl-doc libcurl4-openssl-dev libjson-c-dev

Quittez le container :

exit

Créez une nouvelle image à partir de nouvel état de votre container :

cherchez l'id du container :
```
  docker ps -a
```

créez l'image :

  docker commit CONTAINER_ID projet-cs212

en remplaçant CONTAINER_ID par le bon id; par exemple :

  docker commit 55959d62b348 projet-cs212

supprimez le container :
```
  docker rm CONTAINER_ID
```

Première compilation

Vous pouvez maintenant lancer votre nouvelle image et, par exemple, y compiler votre projet. Pour cela, nous vous conseillons de « mounter » le répertoire où se trouvent vos codes sources sur le container avec l'option -v de docker run.

Par exemple, si vous êtes sur une machine Unix, allez dans le répertoire de vos codes sources et faites :

docker run -ti --rm -v $(pwd):/localhost projet-cs212

Autre exemple :

docker run -ti --rm -v /home/chezmoi/projet:/localhost projet-cs212

Vous aurez alors accès dans le container à vos fichiers via /localhost. Par exemple :

ls /localhost

Vous pouvez alors y compiler votre projet. Par exemple :

cd /localhost
make

Quittez le container avec :

exit

(ou simplement CTRL-D).

Quelques commandes Docker utiles

obtenir de l'aide :
```
  docker help COMMAND
```
par exemple :
```
  docker help ps
```
Liste de tous les containters :
```
  docker ps -a
```
Supprimer un container :
```
  docker rm CONTAINER_ID
```
Supprimer tous les containers :
```
  docker rm $(docker ps -aq)
```
Liste de toutes les images :
```
  docker images
```
Supprimer une image (qui n'a plus de container) :
```
  docker rmi IMAGE_ID
```

Créer un container en mode interactif et le supprimer automatiquement en fin :

  docker run -ti --rm CONTAINER_ID 
  docker run -ti --rm CONTAINER_ID COMMANDE

par exemple :

  docker run -ti --rm ubuntu bash

Créer un container en mode interactif sans le supprimer automatiquement :
```
  docker run -ti CONTAINER_ID 
```
Créer un container en mode interactif en « mountant » le système de fichier local (c.-à-d. en ayant dans le container un accès à un endroit du disque local) :
```
  docker run -ti --rm -v local_dirname:container_dirname CONTAINER_ID 
```
par exemple :
```
  docker run -ti --rm -v /home/machin:/tmp/home_machin_local CONTAINER_ID 
```
Note : les noms de fichiers/répertoires doivent être absolus (pas relatifs).
Redémarrer un container en pause :
```
  docker start CONTAINER_ID 
```
Copier des fichiers entre la machine locale et un container :
- de la machine locale au container :
```
docker cp local_filename CONTAINER_ID:where_to_put
```
- du container à la machine locale :
```
docker cp CONTAINER_ID:where_to_get local_filename
```
Créer une nouvelle image à partir de l'état d'un container :
```
  docker commit CONTAINER_ID IMAGE_ID
```