Quelques informations supplémentaires au sujet de l’administration docker et des outils associés.

La plupart viennent de la leçon 3 des cours sur docker.

Effacer toutes les images intermédiaires

$ docker rmi $(docker images | awk '$2 == "<none>" {print $3}')

Déboguer ce qui se passe dans un container

Pour voir ce qui se passe dans le container:

$ docker logs nostalgic_morse

On peut ajouter -f pour suivre la sortie (un peu comme tail -f).

$ docker logs -f --tail 1 nostalgic_morse

Permet de suivre la dernière ligne.

Pour avoir accès aux fichiers de log de l’application, on peut bien sûr lancer un processus interactif, et aller les voir dans le container, mais il peut être plus pratique de monter de répertoire de logs comme un volume associé à un répertoire de la machine hôte. Exemple:

$ mkdir -p logs/nginx
$ docker run -d -P -v $(pwd)/logs/nginx:/var/log/nginx nginx

Avec docker ps, on peut voir les numéros de ports afin de pouvoir faire des requêtes au serveur. On peut aussi utiliser docker port. On peut maintenant voir par exemple logs/nginx/access.log qui contient des informations sur les requêtes effectuées.

Inspecter un container

La commande suivante donne plein d’information au format Json :

$ docker inspect nostalgic_morse

On peut faire des grep pour trouver l’information que l’on cherche ou utiliser l’option --format (ou -f).

Pour plus d’information, voir dans la doc.

Contrôler le démon

Les options de configuration par défaut de docker sont dans /etc/default/docker. La variable DOCKER_OPTS dans ce fichier permet de contrôler le démon quand celui-ci est lancer par comme un service. Si on change cette variable,

DOCKER_OPTS=``--log-level debug``

il faut redémarrer le démon :

$ sudo service docker restart

On peut aussi relancer un démon docker en spécifiant des options :

$ sudo service docker stop
$ docker -d --log-level-debug
...
$ sudo kill $(pidof docker)
$ sudo service docker start

Sécurité

Dans la mesure où les containers sont isolés, ils ne peuvent s’attaquer. Par contre il faut vérifier que :

on a une totale confiance dans les utilisateurs qui ont accès au démon docker (c’est-à-dire qui sont dans le groupe docker), car celui-ci a les droits root ;
si on associe le démon à une socket TCP, il faut la sécuriser par TLS ;

Pour plus d’information sur la sécurité voir dans la doc.

Dépôt privé

Pour avoir un dépôt privé, on peut par exemple lancer registry dans un container :

$ docker run -d -p 5000:5000 registry:2.0

On peut maintenant utiliser :

docker tag me/my-app  myserver:5000/my-app:1.0
docker push myserver:5000/my-app:1.0
docker pull myserver:5000/my-app:1.0

Ici, myserver est par exemple localhost. Si on utilise une autre machine pour faire l’une ou l’autre des commandes, il faut que la connexion soir protégé par TLS. Il y a un autre moyen, c’est de lancer la démon avec l’option --insecure-registry, mais ce n’est pas trop recommandé.

Docker Machine

Cet outil permet d’installer Docker sur d’autres machines (ou dans des machines virtuelles ou dans le nuage).

récupérer l’outil sur github avec wget,
le mettre quelque part dans le PATH et y ajouter les droits d’exécution.

Pour créer un

  $ docker-machine create --driver virtualbox testhost

Il y a aussi plein de possibilité pour installer dans le nuage.

Quand on a installé plusieurs machine, on peut les voir avec :

$ docker-machine ls

Et on voit celle qui est active te sur laquelle s’applique les commandes. On peut se connecter à un machine (en root) avec

$ docker-machine ssh machine1

Docker Swarm

Permet de répartir les containers sur plusieurs machines (appelés noeuds) en fonction d’une certaine politique de charge.

Docker Compose

Permet de créer une application en plusieurs containers selon une architecture à base de micro-services. L’architecture est décrite dans un fichier .ylm. C’est beaucoup plus pratique que de tout faire à la main dès qu’il y a plus de 3 ou 4 containers.

Installation

$ sudo -i
# curl -L https://github.com/docker/compose/releases/download/1.3.1/docker-compose-`uname -s`-`uname -m` \
     > /usr/local/bin/docker-compose
# chmod +x /usr/local/bin/docker-compose

On peut aussi vouloir installer le fichier de complétion :

curl -L https://raw.githubusercontent.com/docker/compose/$( \
           docker-compose --version | awk 'NR==1{print $NF}' \
           )/contrib/completion/bash/docker-compose \
  > /etc/bash_completion.d/docker-compose

Utilisation

L’architecture est décrite dans un fichier docker_compose.yml (ou fig.ylm). Il est composé d’un section par container à créer.

Pour construire un container, on peut soit spécifier le chemin du Dockerfile :

ctn1:
  build: .

ou alors dire quelle image DockerHub utiliser :

ctn2:
  image: ubuntu

Pour lier les containers, on utilise la commande links:

ctn1:
  build: .
  links:
    - ctn3

Pour démarrer tout ça :

$ docker-compose up

Ça va construire les images pour chaque service, créer et lancer les containers à partir du fichier docker_compose.yml On peut utiliser l’option -d pour tout lancer en arrière plan.

Documentation

Pour plus d’information, voir :

Docker : administration