Introduction à Docker

@AlexisHassler

Principes de base

Fonctionnement
Usages
Ecosystème

Fonctionnement de Docker

Docker allows you to package an application with all of its dependencies into a standardized unit for software development.

https://www.docker.com/what-docker

Architecture

Isolation
- 1 conteneur = 1 application

Architecture

Virtual Machine vs Container

Docker est un système de conteneurs dont le but est d’isoler l’exécution de process au sein d’un système hôte. Et si l’objectif ressemble un peu à celui de la virtualisation, la technologie n’a rien à voir.

Dans Docker, on ne cherche ni à émuler des ressources matérielles, ni à s’abstraire du système d’exploitation. Dans Docker, tout se passe en Linux, sur le noyau de la machine hôte. Docker définit un contexte d’exécution différent de la machine hôte pour que le process ne puisse accéder ni aux ressources de la machine hôte ni aux ressources système des autres conteneurs. Pour ça, Docker utilise des fonctionnalités du noyaux Linux qui sont cgroup (control group) et namespace.

Docker n’est pas la première technologie de conteneur. Sur Linux, on avait déjà LXC et ce fonctionnement existait sur d’autres systèmes. Par contre, Docker la rend plus pratique à utiliser.

Architecture

Client / Serveur

En développement

En production

Déploiement

Ecosystème

La brique de base de l’écosystème est Docker Engine. C’est le moteur de conteneurs sur lequel on va travailler. Il exécutera des conteneurs basés sur des images qu’on construira ou qu’on téléchargera à partir d’un Docker Registry. Par défaut, on utilisera le Docker Hub.

Docker Compose va nous permettre de manipuler un ensemble de conteneurs sur le même hôte pour qu’ils forment un ensemble cohérent.

Docker Machine doit nous simplifier l’installation de Docker sur des environnements hétérogènes ou distants. Par exemple, il peut installer et manipuler du Docker dans une machine virtuelle VirtualBox pour mettre à disposition Docker sur une machine Windows ou MacOS. Il peut faire la méme chose sur des serveurs distants pour peu qu’un driver soit intégré (Amazon Web Services, Microsoft Azure, Google Compute Engine,…) ou disponible chez un tier (OVH Cloud, 1&1 Cloud Server, VMWare Workstation, Citrix XenServer,…).

Pour des environnements plus complexes, on utilisera Docker Swarm ou le Swarm mode qui peut gérer un cluster basé sur des conteneurs. Il a plusieurs concurrents comme Kubernetes ou Apache Mesos.

Premiers pas

Installation
Lancer un conteneur

Installation sous Linux

Client
- Application Linux
Serveur
- Daemon Linux

Installation sous Linux

Dépôts Docker

# Déclarer la source
echo "deb https://apt.dockerproject.org/repo ubuntu-wily main" \
     >> /etc/apt/sources.list.d/docker.list

# Installer Docker
apt-get update
apt-get install docker-engine

Pour la précédure complète (avec Ubuntu) :

# Installer les prérequis
apt-get update
apt-get install apt-transport-https ca-certificates
apt-get install linux-image-extra-$(uname -r) # Ubuntu
apt-key adv --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv-keys 58118E89F3A912897C070ADBF76221572C52609D

# Déclarer la source
touch /etc/apt/sources.list.d/docker.list
echo "deb https://apt.dockerproject.org/repo debian-wheezy main" >> /etc/apt/sources.list.d/docker.list

# C'est bon, on peut installer Docker
apt-get update
apt-cache policy docker-engine
apt-get install docker-engine

Référence (pour les autres distributions) : https://docs.docker.com/engine/installation/linux/

Installation sous Linux

Avec sudo

sudo docker help ...

Sans sudo

sudo addgroup $USER docker

docker help ...

Le client docker communique avec le daemon via la socket /var/run/docker.sock. Cette socket appartient à l’utilisateur root et est attaché au groupe docker. Par conséquent, pour communiquer avec le daemon, il faut être root ou appartenir au groupe docker.

Si la communication se passe mal, la commande affiche le message suivant :

Cannot connect to the Docker daemon. Is 'docker daemon' running on this host?

Installation sous Linux

Serveur distant

export DOCKER_HOST=docker.sewatech.fr

Installation sous MacOS

Client
- Application MacOS
Serveur
- Linux VM

Installation sous MacOS

Docker for Mac

Homebrew

brew install docker

Homebrew Cask

brew cask install docker

Installation sous Windows

Client
- Application Windows
Serveur
- Linux VM

Installation sous Windows

Docker for Windows
- Microsoft Hyper-V
- Windows 10 Pro 64bits
- Next, next, next,…

Installation sous Windows

Windows Containers
- Windows Server 2016
- Windows 10 Anniversary Edition

Installation

Vérification de la version

docker version

Client:
 Version:      17.03.0-ce
 API version:  1.26
 Go version:   go1.7.5
 Git commit:   60ccb22
 Built:        Thu Feb 23 11:02:43 2017
 OS/Arch:      linux/amd64

Server:
 Version:      17.03.0-ce
 API version:  1.26 (minimum version 1.12)
 Go version:   go1.7.5
 Git commit:   60ccb22
 Built:        Thu Feb 23 11:02:43 2017
 OS/Arch:      linux/amd64
 Experimental: false

Démarrer un conteneur

Télécharger depuis Docker Hub

docker image pull hello-world

Démarrer

docker container run hello-world

Conteneurs

Commande run
Isolation
Cycle de vie

Run interactif

Attaché au terminal

docker container run -it debian

Téléchargement
Prompt du conteneur

root@72371fac506b:/#

Le prompt a changé. Il est maintenant sous la forme root@72371fac506b. On est sur le file system du conteneur, connecté en root. D’ailleurs, on peut le vérifier avec uname :

uname -v

Si le système hôte est déjà du Debian, ce n’est pas très impressionnant. Dans ce cas, on peut refaire la manipulation avec l’image alpine.

docker image pull alpine
docker container run -it alpine sh

Qu’on utilise l’image Debian ou Alpine, uname renvoie les mêmes informations qui sont celles de l’hôte : le conteneur utilise le kernel de la machine hôte. Par contre, avec uname -n, on obtient un nodename différent pour chaque conteneur.

Remarque : les familles de commandes docker image et docker container ont été introduites avec la version 1.13.

Isolation des conteneurs

File system

ls -l /

rm -r /bin

Jouons un peu avec le file system. Avec ls -l, on peut voir que le conteneur a la même structure de répertoire qu’une installation traditionnelle. Comme on est root on peut supprimer n’importe quel contenu.

rm -rf /

Ah ben ça va marcher beaucoup moins bien, forcément !

En revanche si on quitte le conteneur et qu’on le relance, toute la structure est rétablie.

Isolation des conteneurs

Réseau : adresse IP

alexis@Mac ~ $ ifconfig

en0       Link encap:Ethernet  HWaddr 02:42:ac:11:00:03
          inet addr:192.168.1.42  Bcast:0.0.0.0  Mask:255.255.0.0
          inet6 addr: fe80::42:acff:fe11:3/64 Scope:Link
          ...
lo        Link encap:Local Loopback
          ...

root@203f542a3fdb:/$ ifconfig

eth0      Link encap:Ethernet  HWaddr 02:42:ac:11:00:03
          inet addr:172.17.0.3  Bcast:0.0.0.0  Mask:255.255.0.0
          inet6 addr: fe80::42:acff:fe11:3/64 Scope:Link
          ...
lo        Link encap:Local Loopback
          ...

Isolation des conteneurs

Réseau : ports et sockets

alexis@Mac ~ $ netstat -pan

Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address     Foreign Address   State
tcp        0      0 127.0.1.1:53      0.0.0.0:*         LISTEN
tcp6       0      0 :::5000           :::*              LISTEN
tcp6       0      0 :::8000           :::*              LISTEN
tcp6       0      0 ::1:8000          ::1:46082         ESTABLISHED
...

root@203f542a3fdb:/$ netstat -pan

Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address     Foreign Address   State

Active UNIX domain sockets (servers and established)
Proto RefCnt Flags   Type   State     I-Node   Path

Run interactif

Sans commande

docker container run -it alpine

Avec une commande

docker container run -it alpine /bin/sh

docker container run -it debian echo "Hello World"

Run détaché

Détaché au terminal

docker container run -d httpd

Téléchargement
Prompt du host

alexis@Mac ~ $

Run détaché

Accès au conteneur

# Liste des conteneurs actifs
docker container ls

# Liste de tous les conteneurs
docker container ls -a

# Logs d'un conteneur
docker container logs <container-name>

Cycle de vie

Arrêter un conteneur
- Arrêt propre

docker container stop elegant_brahmagupta

Arrêt forcé

docker container kill elegant_brahmagupta

Cycle de vie

Cycle de vie

Supprimer un conteneur
- Par son nom

docker container rm elegant_brahmagupta

Par son id

docker container rm 72371f

Suppression automatique
- Uniquement en mode interactif

docker container run -it --rm debian

Cycle de vie

Ménage
- Conteneurs arrêtés

docker container rm $(docker container ls -f status=exited)

Conteneurs arrêtés (1.13+)

# avec confirmation
docker container prune

# sans confirmation
docker container prune -f

La version 1.13 a aussi introduit une commande de ménage plus large, qui nettoie les conteneurs, les images, les volumes et les réseaux.

docker system prune

Cycle de vie

Sortie standard

docker container logs elegant_brahmagupta

Limité à n lignes

docker container logs --tail 10 elegant_brahmagupta

Avec défilement

docker container logs --follow elegant_brahmagupta

Images

Build
Dockerfile
Système de fichiers
Gérer les images

Commande build

Dockerfile ⇒ Image
- Construction

docker image build -t sw/app .

Image locale

docker container run -d sw/app

Dockerfile

FROM httpd
MAINTAINER Alexis Hassler <alexis.hassler@sewatech.fr>

RUN apt-get update

COPY site/ /var/www/

WORKDIR /var/www/

ENTRYPOINT ["/start.sh"]
CMD ["--env=default"]
# ou
CMD ["/start.sh", "--env=default"]

Dockerfile, exécution

Paramètres de docker run
- Ajoutés à ENTRYPOINT
- En remplacement de CMD

docker container run -d sw/app --env=dev

docker container run -it debian bash

Dockerfile, échanges

EXPOSE
- ports ouverts dans le conteneur
VOLUME
- répertoires à partager

Système de fichiers en couches

Détail des couches
- Pour une image
- Taille par couche

docker image history demo/layers

IMAGE         CREATED BY                                  SIZE
23b9aa4066c0   /bin/sh -c rm tomcat85                     0 B
054d0880c62e   /bin/sh -c unzip tomcat85                  13.14 MB
6a209ff5aea1   /bin/sh -c wget http://bit.ly/tomcat85     9.9 MB
859c09d07c42   /bin/sh -c apt-get install -y wget unzip   40.8 MB
33b20b7674a7   /bin/sh -c apt-get update                  9.861 MB
73e72bf822ca   /bin/sh -c (nop)  CMD ["/bin/bash"]        0 B
<missing>      /bin/sh -c (nop) ADD file:41ea5187c50115   123 MB

Système de fichiers en couches

Image de base
- Ajouter la taille dans les critères
- Rationaliser les images de base

Systèmes nus
Busybox	1 Mo
Alpine	5 Mo
Debian	125 Mo
Ubuntu	130 Mo
CentOS	200 Mo
Fedora	200 Mo

Systèmes avec httpd
Busybox	1 Mo
Alpine	9 Mo
Debian	180 Mo
Ubuntu	225 Mo
CentOS	245 Mo
Fedora	275 Mo

Gérer les images

Liste d’images

docker image ls

Avec les images intermédiaires

docker image ls -a

Sans tag

docker image ls -f "dangling=true"

Avec tags

docker image ls -f "dangling=false"

Comme pour les listes de conteneurs, on peut ajouter l’option -q pour n’avoir que les ids.

On obtient le même résultat avec :

docker images --format "{{.ID}}"

Evidemment, l’option --format offre plus de souplesse. Par exemple, on peut demander le nom de l’image, uniquement pour les images avec tag :

docker images --format "{{.Repository}}:{{.Tag}}"

Référence : https://docs.docker.com/engine/reference/commandline/images/

Gérer les images

Supprimer une image
- Avec ses parents

docker image rm da7ff372b5067f5

Sans ses parents

docker image rm --no-prune da7ff372b5067f5

Forcer

docker image rm -f da7ff372b5067f5

Gérer les images

Ménage
- Images sans tag

docker image rm $(docker image ls -qf "dangling=true")

Images inutilisées (1.13+)

# uniquement sans tag
docker image prune

# y compris avec tag
docker image prune -a

# sans confirmation
docker image prune -f

La version 1.13 a aussi introduit une commande de ménage plus large, qui nettoie les conteneurs, les images, les volumes et les réseaux.

docker system prune

Réseau

Exposition de ports
Réseaux par défaut
Réseaux personnalisés

Exposition de ports

Association explicite

docker container run -p 8888:80 httpd

Réseaux par défaut

Réseau bridge

Pour avoir des informations détaillées sur le réseau bridge :

docker network inspect bridge

Un conteneur attaché à un réseau bridge peut communiquer avec l’hôte, le réseau LAN et éventuellement WAN. Il peut aussi communiquer avec les autres conteneurs du même réseau. Pour qu’il soit accessible depuis l’extérieur, il faut exposer les ports.

Réseaux par défaut

Réseau host

Réseaux par défaut

Réseau none

Réseaux personnalisés

Type bridge
- Isolé

Réseaux personnalisés

Conteneurs nommés

docker network create frontend

docker container run -d --net=frontend --name web              \
                     sewatech/httpd
docker container run -d --net=frontend --name app              \
                     sewatech/tomcat

$ ping web

Volumes

Partager de répertoire
Volumes nommés
Sécurité

Partage de répertoire

Volume
- Répertoire du host accessible en R/W

docker container run -d
           -v ${PWD}/web-content:/usr/local/apache2/htdocs    \
           --name web httpd

L’option -v sert à spécifier le volume. La première partie est le répertoire du host, en chemin absolu. La deuxième partie est le répertoire du conteneur, en chemin absolu.

Un volume est généralement un répertoire. Il est possible de monter un fichier unique en volume.

Un volume est monté en lecture / écriture (rw) par défaut, mais il peut être explicitement monté en lecture seule (ro) :

docker container run -v ${PWD}/data:/data:ro

Si le répertoire du conteneur n’existe pas, il est créé au démarrage.

Volumes nommés

Nom choisi

docker container run -it -v cli-data:/data --name cli debian

Nom généré

docker container run -it -v /data --name cli debian

Dans la première commande, cli-data n’est pas un répertoire en chemin relatif, c’est le nom d’un volume. Dans la deuxième commande, on ne spécifie pas de nom de volume, c’est docker qui en génère un.

Un volume nommé est monté sur un sous-répertoire de /var/lib/docker/volumes/<vol_name>/_data.

Pour connaitre le répertoire sur lequel est monté un volume :

docker container inspect -f {{.Mounts}} cli

Volumes nommés

Création de volume

docker volume create --name data-vol

Paramètres avancés

docker volume create --name data-vol              \
                     --driver local               \
                     --opt type=tmpfs             \
                     --opt device=tmpfs           \
                     --opt o=size=100m,uid=1000

Volumes nommés

Liste des volumes

docker volume ls

Liste des volumes inutilisés

docker volume ls -f 'dangling=true'

Le terme "inutilisés" est utilisé pour dire : référencés par aucun conteneur.

En plus de dangling, il y a deux autres filtres : le nom du volume et le driver.

On peut aussi inspecter un conteneur :

docker volume inspect cli-data

Volumes nommés

Suppression d’un volume

docker volume rm cli-data

Suppression des volumes du conteneur

docker container rm -v cli

Nettoyage
- Volumes inutilisés

docker volume prune

Sécurité

User mapping
- userid(container) == userid(host)
root
- User par défaut

Sécurité

Dockerfile
- Utilisateur au build
- Utilisateur par défaut au run
- Par nom

USER toto

Par uid

USER 1000

Multi-conteneurs

Docker Compose
docker-compose.yml
Principales commandes

Docker Compose

Orchestration des conteneurs locaux

docker container run sw/web
docker container run sw/db
docker container run sw/app

Rationalisation des scripts

docker container run                   \
          -p 1000:8080 -p 1001:1099    \
          -v $PWD/data:/db/data        \
          -v $PWD/log:/db/logs         \
          --net=backend                \
          --name=db                    \
          sw/db main

Docker Compose

Prérequis
- Python
Script

compose_version=1.11.2
base_url=https://github.com/docker/compose/releases/download
url=$base_url/$compose_version/docker-compose-`uname -s`-`uname -m`

curl -L $url > /usr/local/bin/docker-compose

chmod +x /usr/local/bin/docker-compose

Docker Compose

Gestionnaire de paquets de Python
- pip (>= 6)

# Debian, Ubuntu,...
apt-get -y install python-pip

# CentOS (with EPEL repository)
yum install epel-release
yum install python-pip

# Fedora
dnf install python-pip

pip install docker-compose

Docker Compose

Image docker

docker image pull docker/compose:$compose_version
docker container run --rm -it                                             \
                     -v /var/run/docker.sock:/var/run/docker.sock         \
                     -v $(pwd):$(pwd)                                     \
                     -w "$(pwd)"                                          \
                     docker/compose:$compose_version

Script run.sh

compose_version=1.11.2
base_url=https://github.com/docker/compose/releases/download
url=$base_url/$compose_version/run.sh

curl -L $url > /usr/local/bin/docker-compose

chmod +x /usr/local/bin/docker-compose

docker-compose.yml

Structure
- Services = conteneurs
- Volumes
- Réseaux

version: '2'
services:
  web:
    ...
volumes:
  log: ...
networks:
  front-tier:
    driver: bridge

docker-compose.yml

Services

services:
  web:
    image: sewatech/web
    build:
      context: .
    ports:
    - "127.0.0.1:8888:80"
    volumes:
    - web-content:/usr/local/apache2/htdocs
    networks:
    - front-tier

Principales commandes

Démarrer en mode daemon

docker-compose up -d

docker-compose up -d --force-recreate

Arrêter les conteneurs

docker-compose down

TP

Application Java
- Java 8
- Apache Tomcat
- Web Archive
Base de données
- Postgres
Reverse Proxy
- Apache httpd
Docker Compose

Introduction à Docker

@AlexisHassler

FIN