• Officielle

• Choisir son driver
  • Aufs
  • BTRFS
  • Device mapper
  • OverlayFS

• Syntaxe d'un fichier Dockerfile
• Best Practices

• Syntaxe d'un fichier Docker compose
• Info + exemples
• Completion
• Ordre de démarage

• Automatiquement lancer ses conteneur au démarrage de l'OS
• Options dockerd

• Sécurité
• Paramétre de sécurité dans docker run
• Chiffrement
• AppArmor

Activation namespace user pour remappinf des uid entre le conteneur et la machine hôte avec : userns-remap :

• https://resinfo.org/IMG/pdf/secu-docker.pdf
• https://resourcepool.io/fr/2016/09/09/francais-le-user-namespace-dans-docker/

• Plugins pour les volumes ou le réseau

• Remote API

• Lancer plusieurs process docker dans un même conteneur avec Supervisor
• Garder ses conteneurs en vie si dockerd tombe
• Format d'affichage
• Options de logging
• Exit status code
• Link

Toutes les commandes

Crée et démarre un conteneur à partir d'une image :

Options intéressantes :

• –name : donne un nom au conteneur
• –rm : efface le contener quand il se termine
• -it : mode intéractif (-i) avec pseudo TTY –t)
• -d / –detach : Lance le conteneur en backgroud
• –read-only : monte le contener en RO
• -v / –volume : Map un volume
• -p / –publish : Map un port
• -P / –publish-all : Map l’ensemble des ports de façon aléatoire
• –expose : Expose le port d'un conteneur (pour un link par exemple)

Exemples :

$ docker run --rm -v /home/gigix:/foo:ro -w /foo -i -p 127.0.0.1:80:8080 -t ubuntu bash

$ docker run -itd --network=my-net --ip=10.10.9.75 busybox

$ docker run --device=/dev/sdc:/dev/xvdc --device=/dev/sdd --device=/dev/zero:/dev/nulo -i -t ubuntu ls -l /dev/{xvdc,sdd,nulo}

$ docker run --restart=always redis

Copie la configuration des volumes d'un conteneur à l'autre :

$ docker create -v /dbdata --name dbstore training/postgres /bin/true
$ docker run -d --volumes-from dbstore --name db1 training/postgres
$ docker run -d --volumes-from dbstore --name db2 training/postgres

Link ce conteneur avec db (–link id[:alias]) :

$ docker run -t -i --rm --link db:db training/webapp /bin/bash

Crée un nouveau conteneur à partir d'une image sans le démarrer :

Similaire à docker run sauf qu'il ne démarre pas le conteneur.

$ docker create -t -i fedora bash

Interagit avec le processus du conteneur :

Pratique si un prompt se présente afin d'y répondre.

Pour se détacher ⇒ CTRL-p CTRL-q (on peut le changer avec l'option –detach-keys).

$ docker attach 2d5e8999b138

Liste les images :

$ docker images --no-trunc

docker rmi $(docker images -f "dangling=true" -q)

$ docker images --digests

Affiche les différences entre le conteneur et son image :

$ docker diff 2d5e8999b138

• A : Add
• D : Delete
• C : Change

Affiche l'historique d'une image :

$ docker history gigi206/test:v1

Tag une image :

$ docker tag 0e5574283393 fedora/httpd:version1.0

$ docker tag httpd fedora/httpd:version1.0

Renomme un conteneur :

$ docker rename 2d5e8999b138 myconteneur_V1

Lance une commande dans un conteneur :

$ docker exec -it bf283346cee9 bash

Copie un fichier dans ou hors du conteneur :

docker cp foo.txt mycontainer:/foo.txt
docker cp mycontainer:/foo.txt foo.txt

Une autre méthode pour décompresser un tar dans le /tmp du conteneur :

$ cat Docker.tgz | docker exec -i 2d5e8999b138 tar xzf - -C /tmp

Affiche le journal d'évenement de docker :

$ docker events --since '2016-10-22' --filter 'container=b6a2bd1f6ea8' --filter 'event=stop'

Se connecter au docker hub :

$ docker login

$ docker login localhost:8080

Cela crée le fichier $HOME/.docker/config.json.

Se déconnecter du docker hub :

$ docker logout localhost:8080

Télécharge une image docker :

$ docker pull debian:jessie

$ docker pull ubuntu@sha256:45b23dee08af5e43a7fea6c4cf9c25ccf269ee113168c19722f87876677c5cb2

docker pull myregistry.local:5000/testing/test-image

docker pull --all-tags fedora

Envoye une image sur le hub :

$ docker push gigi206/test:v1

Recherche une image :

$ docker search --filter "stars=3" --filter "is-automated=true" --no-trunc --limit 5 debian

$ docker search --filter "is-official=true" debian

Supprime une image :

$ docker rmi localhost:5000/test/busybox@sha256:cbbf2f9a99b47fc460d422812b6a5adff7dfee951d8fa2e4a98caa0

$ docker rmi -f fd484f19954f

$ docker rmi test

Supprime un conteneur :

Supprime tous les conteneurs stoppés :

$ docker rm $(docker ps -a -q)

Supprime le lien entre webapp et redis :

$ docker rm --link /webapp/redis

Supprime le conteneur redis et ses volumes associés:

$ docker rm -v redis

Liste les conteneurs :

• -f, –filter value : Filter output based on conditions provided (default [])
  • exited=<int> an exit code of <int>
  • label=<key> or label=<key>=<value>
  • status=(created|restarting|running|paused|exited)
  • name=<string> a container's name
  • id=<ID> a container's ID
  • before=(<container-name>|<container-id>)
  • since=(<container-name>|<container-id>)
  • ancestor=(<image-name>[:tag]|<image-id>|<image@digest>)

containers created from an image or a descendant.

• –format : Pretty-print containers using a Go template
  • .ID : Container ID
  • .Image : Image ID
  • .Command : Quoted command
  • .CreatedAt : Time when the container was created.
  • .RunningFor : Elapsed time since the container was started.
  • .Ports : Exposed ports.
  • .Status : Container status.
  • .Size : Container disk size.
  • .Names : Container names.
  • .Labels : All labels assigned to the container.
  • .Label : Value of a specific label for this container. For example '{{.Label "com.docker.swarm.cpu"}}'
  • .Mounts : Names of the volumes mounted in this container.

$ docker ps -a --filter 'exited=137'

$ docker ps --format "table {{.ID}}\t{{.Labels}}"

Affiche la sortie du conteneur :

$ docker logs -f d135c332e896

Démarre un conteneur :

$ docker start -i d135c332e896

Arrête un conteneur :

$ docker stop -t 30 d135c332e896

Redémarre un conteneur :

$ docker restart -t 30 d135c332e896

Envoie un signal au conteneur (Kill par défaut) :

$ docker kill -s TERM d135c332e896

Attend jusqu'à ce que le conteneur s'arrête :

$ docker wait 2d5e8999b138

Met en pause le conteneur :

$ docker pause d135c332e896

Supprime la pause du conteneur :

$ docker unpause d135c332e896

Affiche la version de docker :

$ docker version --format '{{.Server.Version}}'

$ docker version --format '{{json .}}'

Affiche des informations sur docker :

$ docker info

Affiche le pid d'un conteneur :

$ docker top mon_conteneur

Affiche les informations d'un conteneur, image ou tâche :

$ docker inspect mon_conteneur

Crée une nouvelle image à partir d'un conteneur :

$ docker commit -m "Added json gem" -a "GigiX" b6a2bd1f6ea8 gigi206/test:v1

$ docker inspect -f "{{ .Config.Env }}" gigi206/test:v1
[HOME=/ PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin]
$ docker commit --change "ENV DEBUG true" b6a2bd1f6ea8 gigi206/test:v1

$ docker commit --change='CMD ["apachectl", "-DFOREGROUND"]' -c "EXPOSE 80" c3f279d17e0a  svendowideit/testimage:version4

Met à jour la configuration d'un conteneur :

$ docker update --cpu-shares 512 abebf7571666

Crée une nouvelle image à partir d'un Dockerfile :

On créer un fichier Dockerfile dans le répertoire courant et on lance la construction de l'image :

$ docker build -t gigi206/apache2_php5:v1 .
$ docker tag gigi206/apache2_php5:v1 gigi206/apache2_php5:latest
$ docker push gigi206/apache2_php5:lates

Exporte une image au format tar :

$ docker save localhost:5000/suse/sles12sp2 -o sles12sp2.tar

Importe une image au format tar :

$ cat exampleimage.tgz | docker import - exampleimagelocal:new

Exporte un conteneur au format tar :

$ docker export $ID | gzip -c > image.tgz

$ docker export red_panda > latest.tar

$ docker export --output="latest.tar" red_panda

Importe une image à partir d'un fichier archive (.tar, .tar.gz, .tgz, .bzip, .tar.xz, ou .txz) :

$ gzip -dc image.tgz | docker import - flat-image-name

Importe le répertoire courant en tant qu'image docker :

$ sudo tar -c . | docker import - exampleimagedir

Affiche le mapping de port d'un conteneur :

$ docker port test
7890/tcp -> 0.0.0.0:4321
9876/tcp -> 0.0.0.0:1234
$ docker port test 7890/tcp
0.0.0.0:4321

Affiche les statistiques d'un conteneur :

$ docker stats 2d5e8999b138

Network supporte l'option driver afin de spécifier un driver. Celui par défaut est bridge.

• Driver macvlan
• Driver Overlay

Affiche les réseaux disponibles :

$ docker network ls --no-trunc --filter driver=bridge

Affiche les caractéristiques d'un réseau :

$ docker network inspect bridge

Crée un nouveau réseau : Créer un réseau qui n'a pas accès aux autres machines du parc :

$ docker network create -o com.docker.network.bridge.enable_icc=false -o com.docker.network.bridge.enable_ip_masquerade=false isolated
$ docker network inspect isolated

Supprime un réseau existant :

$ docker network rm gigix

Connecte un conteneur à un nouveau réseau (en plus des réseaux existants) :

$ docker network connect gigix bf283346cee9

Déconnecte un conteneur d'un réseau :

$ docker network disconnect gigix bf283346cee9

Liste les volumes :

$ docker volume ls

Crée un nouveau volume :

$ docker volume create --driver local --opt type=btrfs --opt device=/dev/sda2 --name foo

$ docker volume create --driver local --opt type=tmpfs --opt device=tmpfs --opt o=size=100m,uid=1000 --

$ docker volume create --driver local --opt type=nfs --opt o=addr=192.168.1.1,rw --opt device=:/path/to/dir --name foo

Affiche les informations d'un volume :

$ docker volume inspect gigix

Supprime un volume :

$ docker volume rm gigix

Initialise le cluster en créant un noeud de type manager :

$ docker swarm init

Rejoint le docker swarm : Une fois que le docker_swarm_init est lancé sur le noeud manager. Il faut recopier et coller la commande pour joindre le noeud manager en tant que worker.

Génère un nouveau ticket pour joindre swarm :

$ docker swarm join-token worker

$ docker swarm join-token manager

Quitte le docker swarm :

$ docker swarm leave

A lancer à partir du worker (seulement pour un worker) !

Met à jour swarm avec de nouveaux paramètres :

$ docker swarm update --cert-expiry 720h

Gestion des noeuds swarm.

Liste les noeuds swarm :

$ docker node ls

Affiche les caractéristiques d'un noeud :

$ docker node inspect node01

Affiche les caractéristiques d'un noeud :

$ docker node inspect node01

Liste les tâches qui s’exécutent sur un noeud :

$ docker node ps node01

Passe un worker en manager :

$ docker node promote node01

Passe un manager en worker :

$ docker node promote node01

Met à jour la configuration d'un noeud :

$ docker node update --availability drain node01

Pour créer un service basé sur un fichier docker-compose.yml, il faut se mettre dans ce même répertoire que ce fichier et taper :

$ docker-compose bundle

Cela va créer le fichier .dsb (.dab). Il suffit ensuite de le déployer dans swarm :

$ docker deploy <DABFilename>

Liste les services :

$ docker service ls

Crée un service :

$ docker service create --name redis --replicas=2 redis:3.0.6

Affiche la configuration du service :

$ docker service inspect redis --pretty

Affiche les tâches d'un service :

$ docker service ps redis

Scaling pour un service :

$ docker service scale backend=3 frontend=5

Supprime un service :

$ docker service rm redis

Met à jour un service :

$ docker service update --limit-cpu 2 redis

• Fichier .dockerignore

Auteur du fichier Dockerfile :

MAINTAINER <name>

Image utilisée pour fabriquer la nouvelle image :

FROM <image>
FROM <image>:<tag>
FROM <image>@<digest>FROM <image>@<digest>

Exécute des commandes pour la création de l’image :

RUN <command>
RUN ["executable", "param1", "param2"]

Commande lancée au démarrage du conteneur :

CMD <command>
CMD ["executable", "param1", "param2"]

Si un ENTRYPOINT est définit :

CMD ["param1","param2"]

Ajoute des méta-data à une image :

LABEL "com.example.vendor"="ACME Incorporated"
LABEL com.example.label-with-value="foo"
LABEL version="1.0"
LABEL description="This text illustrates \
that label-values can span multiple lines."
LABEL multi.label1="value1" multi.label2="value2" other="value3"
LABEL multi.label1="value1" \
      multi.label2="value2" \
      other="value3"

Expose un port :

EXPOSE <port> [<port>...]

Définit des varaibles d'environnement :

ENV myName John Doe
ENV myDog Rex The Dog
ENV myCat fluffy
ENV myName="John Doe" myDog=Rex\ The\ Dog \
    myCat=fluffy

Ajoute des fichiers :

ADD <src>... <dest>
ADD ["<src>",... "<dest>"] 

ADD hom* /mydir/

Ajoute des fichiers :

COPY <src>... <dest>
COPY ["<src>",... "<dest>"] 

Permet d’exécuter la commande principale du conteneur. On peut également lui passer un script :

ENTRYPOINT ["executable", "param1", "param2"]
ENTRYPOINT command param1 param2

Ajoute un volume :

VOLUME <volume>
VOLUME ["<volume>"] 

Indique avec quel utilisateur doit être lancé CMD, RUN et ENTRYPOINT :

USER daemon

Indique le CWD pour CMD, RUN, ENTRYPOINT, COPY et ADD :

WORKDIR /path/to/workdir

Définit des variables pour les réutiliser dans le Dockerfile :

FROM busybox
USER ${user:-some_user}
ARG user
USER $user

Variables prédéfinies :

• HTTP_PROXY
• http_proxy
• HTTPS_PROXY
• https_proxy
• FTP_PROXY
• ftp_proxy
• NO_PROXY
• no_proxy

Indique un trigger à l'image qui sera lancé par un autre BUILD sur cette image :

ONBUILD ADD . /app/src
ONBUILD RUN /usr/local/bin/python-build --dir /app/src

Indique le signal à envoyer au conteneur pour son arrêt :

STOPSIGNAL signal

Vérifie la santé en lançant une commande dans le conteneur :

HEALTHCHECK [OPTIONS] CMD command
HEALTHCHECK --interval=5m --timeout=3s \
  CMD curl -f http://localhost/ || exit 1

OPTIONS :

• –interval=DURATION (default: 30s)
• –timeout=DURATION (default: 30s)
• –retries=N (default: 3)

CMD peut être un script qui peut renvoyer le code de sortie ci-dessous :

• 0: success - the container is healthy and ready for use
• 1: unhealthy - the container is not working correctly
• 2: reserved - do not use this exit code

Indique quel shell utiliser :

SHELL ["executable", "parameters"]
SHELL ["/bin/sh", "-c"]

L'outil docker-compose fait intervenir la notion de service qui représente l'ensemble des conteneurs construits à partir d'un fichier docker-compose.yml.

Construit ou reconstruit les images du service à partir du fichier docker-compose.yml.

Vérifie les images du service.

Crée et démarre le(s) conteneur(s) du service.

Options :

• -d : mode démon (détaché)
• –build : rebuild les images avant de lancer les conteneurs

[root@docker test]# docker-compose up -d
Starting test_redis_1
Starting test_web_1

Liste les conteneurs.

Crée un conteneur avec la commande et le démarre.

Lance la commande si le conteneur est démarré.

Arrête l'ensemble des conteneurs du service :

$ docker-compose stop

$ docker-compose stop web -t 30

Démarre l'ensemble des conteneurs du service :

$ docker-compose start

$ docker-compose start web

Redémarre le service.

Arrête et supprime les conteneurs, volumes et réseau.

Affiche l’équivalent du fichier ''docker-compose.yml''.

Affiche en temps réel les événements du service.

Envoie un signal pour l'ensemble des conteneurs du service.

Met en pause le service.

Sort de la pause le service.

Affiche les logs du service.

Supprime les conteneur arrêtés :

$ docker-compose rm --all

Multiplie le nombre de conteneur pour un service :

$ docker-compose scale web=2

Affiche la version de ''docker-compose''.

Construit l'image à partir d'une image existante ou d'un Dockerfile :

2 moyens :

• A partir de Dockerfile
• ou d'un dossier

build:
  context: ./dir
  dockerfile: Dockerfile-alternate
  args:
    buildno: 1

build: ./dir
image: webapp:tag

image et dockerfile sont exclusifs.

Permet de donner des arguments au Dockerfile :

build:
  context: .
  args:
    buildno: 1
    password: secret

Et dans notre Dockerfile :

ARG buildno
ARG password

RUN echo "Build number: $buildno"
RUN script-requiring-password.sh "$password"

Permet de donner des capabilities au conteneur :

cap_add:
  - ALL

cap_drop:
  - NET_ADMIN
  - SYS_ADMIN

Ecrase la commande par défaut du conteneur.

2 formats :
command: bundle exec thin -p 3000

command: [bundle, exec, thin, -p, 3000]

Définit un cgroup parent pour le conteneur :

cgroup_parent: m-executor-abcd

Définit un nom pour le conteneur :

container_name: my-web-container

Mapping des devices :

devices:
  - "/dev/ttyUSB0:/dev/ttyUSB0"

Dépendences sur l'ordre des services :

devices:
version: '2'
services:
  web:
    build: .
    depends_on:
      - db
      - redis
  redis:
    image: redis
  db:
    image: postgres

Déclare le serveur dns :

dns: 8.8.8.8
dns:
  - 8.8.8.8
  - 9.9.9.9

Déclare la search list DNS :

dns_search: example.com
dns_search:
  - dc1.example.com
  - dc2.example.com

Déclare un système de fichier tmpfs :

tmpfs: /run
tmpfs:
  - /run
  - /tmp

Ecrase l'entrypoint par défaut :

entrypoint: /code/entrypoint.sh

entrypoint:
    - php
    - -d
    - zend_extension=/usr/local/lib/php/extensions/no-debug-non-zts-20100525/xdebug.so
    - -d
    - memory_limit=-1
    - vendor/bin/phpunit

Déclare des variables d'environnement dans un fichier :

env_file: .env

env_file:
  - ./common.env
  - ./apps/web.env
  - /opt/secrets.env

# Set Rails/Rack environment
RACK_ENV=development

Déclare des variables d'environnement :

environment:
  RACK_ENV: development
  SHOW: 'true'
  SESSION_SECRET:

environment:
  - RACK_ENV=development
  - SHOW=true
  - SESSION_SECRE

Expose un port vers l’extérieur :

expose:
 - "3000"
 - "8000"

Permet de faire appel à un autre fichier yml pour déclarer un service :

extends:
  file: common.yml
  service: webapp

Lie au niveau réseau 2 conteneurs qui n'ont pas été déclarés dans le même fichier docker-compose.yml :

external_links:
 - redis_1
 - project_db_1:mysql
 - project_db_1:postgresql

Ajoute une entrée dans le fichier /etc/hosts :

extra_hosts:
 - "somehost:162.242.195.82"
 - "otherhost:50.31.209.229"

Spécifie l'image du conteneur :

image: ubuntu:14.04

Ajoute un label dans les metadata :

labels:
  com.example.description: "Accounting webapp"
  com.example.department: "Finance"
  com.example.label-with-empty-value: ""

labels:
  - "com.example.description=Accounting webapp"
  - "com.example.department=Finance"
  - "com.example.label-with-empty-value"

Lie au niveau réseau 2 conteneurs qui sont déclarés dans le même fichier docker-compose.yml :

web:
  links:
   - db
   - db:database
   - redis

Définit de quelle façon le conteneur doit envoyer ses logs :

logging:
  driver: syslog
  options:
    syslog-address: "tcp://192.168.0.42:123"

Définit le mode pour le réseau réseau :

network_mode: "bridge"
network_mode: "host"
network_mode: "none"
network_mode: "service:[service name]"
network_mode: "container:[container name/id]"

Définit les réseaux :

services:
  some-service:
    networks:
     - some-network
     - other-network

Définit les alias :

services:
  some-service:
    networks:
     - some-network
     - other-network

Spécifie une adresse ipv4 et/ou ipv6 pour un conteneur :

services:
  app:
    image: busybox
    command: ifconfig
    networks:
      app_net:
        ipv4_address: 172.16.238.10
        ipv6_address: 2001:3984:3989::10

Définit le pid mode :

pid: "host"

Définit les ports du conteneur :

ports:
 - "3000"
 - "3000-3005"
 - "8000:8000"
 - "9090-9091:8080-8081"
 - "49100:22"
 - "127.0.0.1:8001:8001"
 - "127.0.0.1:5000-5010:5000-5010"

Sécurité SeLinux :

security_opt:
  - label:user:USER
  - label:role:ROLE

Signal envoyé au conteneur pour son arrêt :

stop_signal: SIGUSR1

Paramètres ulimits :

ulimits:
  nproc: 65535
  nofile:
    soft: 20000
    hard: 40000

Mapping des volulmes :

volumes:
  # Just specify a path and let the Engine create a volume
  - /var/lib/mysql

  # Specify an absolute path mapping
  - /opt/data:/var/lib/mysql

  # Path on the host, relative to the Compose file
  - ./cache:/tmp/cache

  # User-relative path
  - ~/configs:/etc/configs/:ro

  # Named volume
  - datavolume:/var/lib/mysql

Monte les volumes définit dans un autre conteneur :

volumes_from:
 - service_name
 - service_name:ro
 - container:container_name
 - container:container_name:rw

Définit différent paramètres :

cpu_shares: 73
cpu_quota: 50000
cpuset: 0,1

user: postgresql
working_dir: /code

domainname: foo.com
hostname: foo
ipc: host
mac_address: 02:42:ac:11:65:43

mem_limit: 1000000000
memswap_limit: 2000000000
privileged: true

restart: always

read_only: true
shm_size: 64M
stdin_open: true
tty: true