====== Docker ======
===== Doc =====
  * [[https://docs.docker.com/engine/getstarted/|Officielle]]

===== Driver de stockage =====
  * [[https://docs.docker.com/engine/userguide/storagedriver/selectadriver/|Choisir son driver]]
    * [[https://docs.docker.com/engine/userguide/storagedriver/aufs-driver/|Aufs]]
    * [[https://docs.docker.com/engine/userguide/storagedriver/btrfs-driver/|BTRFS]]
    * [[https://docs.docker.com/engine/userguide/storagedriver/device-mapper-driver/|Device mapper]]
    * [[https://docs.docker.com/engine/userguide/storagedriver/overlayfs-driver/|OverlayFS]]
===== Dockerfile =====
  * [[https://docs.docker.com/engine/reference/builder/|Syntaxe d'un fichier Dockerfile]]
  * [[https://docs.docker.com/engine/userguide/eng-image/dockerfile_best-practices/|Best Practices]]

===== docker-compose =====
  * [[https://docs.docker.com/compose/compose-file/|Syntaxe d'un fichier Docker compose]]
  * [[https://docs.docker.com/compose/|Info + exemples]]
  * [[https://docs.docker.com/compose/completion/|Completion]]
  * [[https://docs.docker.com/compose/startup-order/|Ordre de démarage]]


===== Systemd =====
  * [[https://docs.docker.com/engine/admin/host_integration/#/systemd|Automatiquement lancer ses conteneur au démarrage de l'OS]]
  * [[https://docs.docker.com/engine/admin/systemd/|Options dockerd]]

===== Sécurité =====
  * [[https://docs.docker.com/engine/security/security/|Sécurité]]
  * [[https://docs.docker.com/engine/reference/run/#/security-configuration|Paramétre de sécurité dans docker run]]
  * [[https://docs.docker.com/engine/security/https/|Chiffrement]]
  * [[https://docs.docker.com/engine/security/apparmor/|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 =====
  * [[https://docs.docker.com/engine/extend/legacy_plugins/|Plugins pour les volumes ou le réseau]]

===== API =====
  * [[https://docs.docker.com/engine/reference/api/docker_remote_api/|Remote API]]

===== Autres =====
  * [[https://docs.docker.com/engine/admin/using_supervisord/|Lancer plusieurs process docker dans un même conteneur avec Supervisor]]
  * [[https://docs.docker.com/engine/admin/live-restore/|Garder ses conteneurs en vie si dockerd tombe]]
  * [[https://docs.docker.com/engine/admin/formatting/|Format d'affichage]]
  * [[https://docs.docker.com/engine/admin/logging/overview/|Options de logging]]
  * [[https://docs.docker.com/engine/reference/run/#/exit-status|Exit status code]]
  * [[https://docs.docker.com/engine/userguide/networking/default_network/dockerlinks/|Link]]

===== Commandes docker =====
[[https://docs.docker.com/engine/reference/commandline/|Toutes les commandes]]

==== docker run ====
[[https://docs.docker.com/engine/reference/commandline/run/|Crée et démarre un conteneur à partir d'une image]] :

<note>
Utilisation avancée de [[https://docs.docker.com/engine/reference/run/|docker run]].
</note>

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 :__**
<xtermrtf>
$ docker run --rm -v /home/gigix:/foo:ro -w /foo -i -p 127.0.0.1:80:8080 -t ubuntu bash
</xtermrtf>

<xtermrtf>
$ docker run -itd --network=my-net --ip=10.10.9.75 busybox
</xtermrtf>

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

<xtermrtf>
$ docker run --restart=always redis
</xtermrtf>

Copie la configuration des volumes d'un conteneur à l'autre :
<xtermrtf>
$ 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
</xtermrtf>

Link ce conteneur avec db (''--link id[:alias]'') :
<xtermrtf>
$ docker run -t -i --rm --link db:db training/webapp /bin/bash
</xtermrtf>

==== docker create ====
[[https://docs.docker.com/engine/reference/commandline/create/|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.

<xtermrtf>
$ docker create -t -i fedora bash
</xtermrtf>

==== docker attach ====
[[https://docs.docker.com/engine/reference/commandline/attach/|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'').

<xtermrtf>
$ docker attach 2d5e8999b138
</xtermrtf>

==== docker images ====
[[https://docs.docker.com/engine/reference/commandline/images/|Liste les images]] :

<xtermrtf>
$ docker images --no-trunc
</xtermrtf>

<xtermrtf>
docker rmi $(docker images -f "dangling=true" -q)
</xtermrtf>

<xtermrtf>
$ docker images --digests
</xtermrtf>

==== docker diff ====
[[https://docs.docker.com/engine/reference/commandline/diff/|Affiche les différences entre le conteneur et son image]] :

<xtermrtf>
$ docker diff 2d5e8999b138
</xtermrtf>

  * **A** : Add
  * **D** : Delete
  * **C** : Change

==== docker history ====
[[https://docs.docker.com/engine/reference/commandline/history/|Affiche l'historique d'une image]] :

<xtermrtf>
$ docker history gigi206/test:v1
</xtermrtf>

==== docker tag ====
[[https://docs.docker.com/engine/reference/commandline/tag/|Tag une image]] :
<xtermrtf>
$ docker tag 0e5574283393 fedora/httpd:version1.0
</xtermrtf>

<xtermrtf>
$ docker tag httpd fedora/httpd:version1.0
</xtermrtf>

==== docker rename ====
[[https://docs.docker.com/engine/reference/commandline/rename/|Renomme un conteneur]] :
<xtermrtf>
$ docker rename 2d5e8999b138 myconteneur_V1
</xtermrtf>

==== docker exec ====
[[https://docs.docker.com/engine/reference/commandline/exec/|Lance une commande dans un conteneur]] :
<xtermrtf>
$ docker exec -it bf283346cee9 bash
</xtermrtf>

==== docker cp ====
[[https://docs.docker.com/engine/reference/commandline/cp/|Copie un fichier dans ou hors du conteneur]] :

<xtermrtf>
docker cp foo.txt mycontainer:/foo.txt
docker cp mycontainer:/foo.txt foo.txt
</xtermrtf>

Une autre méthode pour décompresser un tar dans le ''/tmp'' du conteneur :
<xtermrtf>
$ cat Docker.tgz | docker exec -i 2d5e8999b138 tar xzf - -C /tmp
</xtermrtf>

==== docker events ====
[[https://docs.docker.com/engine/reference/commandline/events/|Affiche le journal d'évenement de docker]] :

<xtermrtf>
$ docker events --since '2016-10-22' --filter 'container=b6a2bd1f6ea8' --filter 'event=stop'
</xtermrtf>

==== docker login ====
[[https://docs.docker.com/engine/reference/commandline/login/|Se connecter au docker hub]] :
<xtermrtf>
$ docker login
</xtermrtf>

<xtermrtf>
$ docker login localhost:8080
</xtermrtf>

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

==== docker logout ====
[[https://docs.docker.com/engine/reference/commandline/logout/|Se déconnecter du docker hub]] :
<xtermrtf>
$ docker logout localhost:8080
</xtermrtf>

==== docker pull ====
[[https://docs.docker.com/engine/reference/commandline/pull/|Télécharge une image docker]] :
<xtermrtf>
$ docker pull debian:jessie
</xtermrtf>

<xtermrtf>
$ docker pull ubuntu@sha256:45b23dee08af5e43a7fea6c4cf9c25ccf269ee113168c19722f87876677c5cb2
</xtermrtf>

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

<xtermrtf>
docker pull --all-tags fedora
</xtermrtf>

==== docker push ====
[[https://docs.docker.com/engine/reference/commandline/push/|Envoye une image sur le hub]] :

<xtermrtf>
$ docker push gigi206/test:v1
</xtermrtf>

==== docker search  ====
[[https://docs.docker.com/engine/reference/commandline/search/|Recherche une image]] :
<xtermrtf>
$ docker search --filter "stars=3" --filter "is-automated=true" --no-trunc --limit 5 debian
</xtermrtf>

<xtermrtf>
$ docker search --filter "is-official=true" debian
</xtermrtf>

==== docker rmi ====
[[https://docs.docker.com/engine/reference/commandline/rmi/|Supprime une image]] :

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

<xtermrtf>
$ docker rmi -f fd484f19954f
</xtermrtf>

<xtermrtf>
$ docker rmi test
</xtermrtf>

==== docker rm ====
[[https://docs.docker.com/engine/reference/commandline/rm/|Supprime un conteneur]] :

Supprime tous les conteneurs stoppés :
<xtermrtf>
$ docker rm $(docker ps -a -q)
</xtermrtf>

Supprime le lien entre webapp et redis :
<xtermrtf>
$ docker rm --link /webapp/redis
</xtermrtf>

Supprime le conteneur redis et ses volumes associés:
<xtermrtf>
$ docker rm -v redis
</xtermrtf>

==== docker ps ====
[[https://docs.docker.com/engine/reference/commandline/ps/|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 <nowiki>'{{.Label "com.docker.swarm.cpu"}}'</nowiki>
    * **.Mounts** : Names of the volumes mounted in this container.

<xtermrtf>
$ docker ps -a --filter 'exited=137'
</xtermrtf>

<xtermrtf>
$ docker ps --format "table {{.ID}}\t{{.Labels}}"
</xtermrtf>

==== docker logs ====
[[https://docs.docker.com/engine/reference/commandline/logs/|Affiche la sortie du conteneur]] :

<xtermrtf>
$ docker logs -f d135c332e896
</xtermrtf>

==== docker start ====
[[https://docs.docker.com/engine/reference/commandline/start/|Démarre un conteneur]] :

<xtermrtf>
$ docker start -i d135c332e896
</xtermrtf>

==== docker stop ====
[[https://docs.docker.com/engine/reference/commandline/stop/|Arrête un conteneur]] :

<xtermrtf>
$ docker stop -t 30 d135c332e896
</xtermrtf>

==== docker restart ====
[[https://docs.docker.com/engine/reference/commandline/restart/|Redémarre un conteneur]] :

<xtermrtf>
$ docker restart -t 30 d135c332e896
</xtermrtf>

==== docker kill ====
[[https://docs.docker.com/engine/reference/commandline/kill/|Envoie un signal au conteneur (Kill par défaut)]] :

<xtermrtf>
$ docker kill -s TERM d135c332e896
</xtermrtf>

==== docker wait ====
[[https://docs.docker.com/engine/reference/commandline/wait/|Attend jusqu'à ce que le conteneur s'arrête]] :

<xtermrtf>
$ docker wait 2d5e8999b138
</xtermrtf>

==== docker pause ====
[[https://docs.docker.com/engine/reference/commandline/pause/|Met en pause le conteneur]] :

<xtermrtf>
$ docker pause d135c332e896
</xtermrtf>

==== docker unpause ====
[[https://docs.docker.com/engine/reference/commandline/unpause/|Supprime la pause du conteneur]] :

<xtermrtf>
$ docker unpause d135c332e896
</xtermrtf>

==== docker version ====
[[https://docs.docker.com/engine/reference/commandline/version/|Affiche la version de docker]] :

<xtermrtf>
$ docker version --format '{{.Server.Version}}'
</xtermrtf>

<xtermrtf>
$ docker version --format '{{json .}}'
</xtermrtf>

==== docker info ====
[[https://docs.docker.com/engine/reference/commandline/info/|Affiche des informations sur docker]] :

<xtermrtf>
$ docker info
</xtermrtf>

==== docker top ====
[[https://docs.docker.com/engine/reference/commandline/top/|Affiche le pid d'un conteneur]] :

<xtermrtf>
$ docker top mon_conteneur
</xtermrtf>

==== docker inspect ====
[[https://docs.docker.com/engine/reference/commandline/inspect/|Affiche les informations d'un conteneur, image ou tâche]] :

<xtermrtf>
$ docker inspect mon_conteneur
</xtermrtf>

==== docker commit ====
[[https://docs.docker.com/engine/reference/commandline/commit/|Crée une nouvelle image à partir d'un conteneur]] :

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

<xtermrtf>
$ 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
</xtermrtf>

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

==== docker update ====
[[https://docs.docker.com/engine/reference/commandline/update/|Met à jour la configuration d'un conteneur]] :

<xtermrtf>
$ docker update --cpu-shares 512 abebf7571666
</xtermrtf>

==== docker build ====
[[https://docs.docker.com/engine/reference/commandline/build/|Crée une nouvelle image à partir d'un Dockerfile]] :

On créer un fichier [[#dockerfile|Dockerfile]] dans le répertoire courant et on lance la construction de l'image :
<xtermrtf>
$ docker build -t gigi206/apache2_php5:v1 .
$ docker tag gigi206/apache2_php5:v1 gigi206/apache2_php5:latest
$ docker push gigi206/apache2_php5:lates
</xtermrtf>

==== docker save ====
[[https://docs.docker.com/engine/reference/commandline/save/|Exporte une image au format tar]] :
<xtermrtf>
$ docker save localhost:5000/suse/sles12sp2 -o sles12sp2.tar
</xtermrtf>

==== docker load ====
[[https://docs.docker.com/engine/reference/commandline/load/|Importe une image au format tar]] :
<xtermrtf>
$ cat exampleimage.tgz | docker import - exampleimagelocal:new
</xtermrtf>

==== docker export ====
[[https://docs.docker.com/engine/reference/commandline/export/|Exporte un conteneur au format tar]] :

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

<xtermrtf>
$ docker export red_panda > latest.tar
</xtermrtf>

<xtermrtf>
$ docker export --output="latest.tar" red_panda
</xtermrtf>

==== docker import ====
[[https://docs.docker.com/engine/reference/commandline/import/|Importe une image à partir d'un fichier archive  (.tar, .tar.gz, .tgz, .bzip, .tar.xz, ou .txz)]] :

<xtermrtf>
$ gzip -dc image.tgz | docker import - flat-image-name
</xtermrtf>

Importe le répertoire courant en tant qu'image docker :
<xtermrtf>
$ sudo tar -c . | docker import - exampleimagedir
</xtermrtf>

==== docker port ====
[[https://docs.docker.com/engine/reference/commandline/port/|Affiche le mapping de port d'un conteneur]] :

<xtermrtf>
$ 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
</xtermrtf>

==== docker stats ====
[[https://docs.docker.com/engine/reference/commandline/stats/|Affiche les statistiques d'un conteneur]] :

<xtermrtf>
$ docker stats 2d5e8999b138
</xtermrtf>
==== docker network ====
=== docker network driver ===
Network supporte l'option ''driver'' afin de spécifier un driver. Celui par défaut est ''bridge''.
  * [[https://docs.docker.com/engine/userguide/networking/get-started-macvlan/|Driver macvlan]]
  * [[https://docs.docker.com/engine/userguide/networking/get-started-overlay/|Driver Overlay]]

=== docker network ls ===
[[https://docs.docker.com/engine/reference/commandline/network_ls/|Affiche les réseaux disponibles]] :

<xtermrtf>
$ docker network ls --no-trunc --filter driver=bridge
</xtermrtf>

=== docker network inspect ===
[[https://docs.docker.com/engine/reference/commandline/network_inspect/|Affiche les caractéristiques d'un réseau]] :
<xtermrtf>
$ docker network inspect bridge
</xtermrtf>

=== docker network create ===
[[https://docs.docker.com/engine/reference/commandline/network_create/|Crée un nouveau réseau]] :
Créer un réseau qui n'a pas accès aux autres machines du parc :
<xtermrtf>
$ 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
</xtermrtf>

=== docker network rm ===
[[https://docs.docker.com/engine/reference/commandline/network_rm/|Supprime un réseau existant]] :
<xtermrtf>
$ docker network rm gigix
</xtermrtf>

=== docker network connect ===
[[https://docs.docker.com/engine/reference/commandline/network_connect/|Connecte un conteneur à un nouveau réseau]]  (en plus des réseaux existants) :
<xtermrtf>
$ docker network connect gigix bf283346cee9
</xtermrtf>

=== docker network disconnect ===
[[https://docs.docker.com/engine/reference/commandline/network_disconnect/|Déconnecte un conteneur d'un réseau]] :
<xtermrtf>
$ docker network disconnect gigix bf283346cee9
</xtermrtf>

==== docker volume ====
=== docker volume ls ===
[[https://docs.docker.com/engine/reference/commandline/volume_ls/|Liste les volumes]] :

<xtermrtf>
$ docker volume ls
</xtermrtf>

=== docker volume create ===
[[https://docs.docker.com/engine/reference/commandline/volume_create/|Crée un nouveau volume]] :
<note>
Il existe des plugins additionnel pour drivers Netapp par exemple.
</note>

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

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

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

=== docker volume inspect ===
[[https://docs.docker.com/engine/reference/commandline/volume_inspect/|Affiche les informations d'un volume]] :

<xtermrtf>
$ docker volume inspect gigix
</xtermrtf>

=== docker volume rm ===
[[https://docs.docker.com/engine/reference/commandline/volume_rm/|Supprime un volume]] :

<xtermrtf>
$ docker volume rm gigix
</xtermrtf>

===== Commandes docker swarm =====
==== docker swarm ====
=== docker swarm init ===
[[https://docs.docker.com/engine/reference/commandline/swarm_init/|Initialise le cluster]] en créant un noeud de type ''manager'' :
<xtermrtf>
$ docker swarm init
</xtermrtf>

=== docker swarm join ===
[[https://docs.docker.com/engine/reference/commandline/swarm_join/|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.

=== docker swarm join-token ===
[[https://docs.docker.com/engine/reference/commandline/swarm_join-token/|Génère un nouveau ticket pour joindre swarm]] :
<xtermrtf>
$ docker swarm join-token worker
</xtermrtf>

<xtermrtf>
$ docker swarm join-token manager
</xtermrtf>

=== docker swarm leave ===
[[https://docs.docker.com/engine/reference/commandline/swarm_leave/|Quitte le docker swarm]] :
<xtermrtf>
$ docker swarm leave
</xtermrtf>

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

=== docker swarm update ===
[[https://docs.docker.com/engine/reference/commandline/swarm_update/|Met à jour swarm avec de nouveaux paramètres]] :
<xtermrtf>
$ docker swarm update --cert-expiry 720h
</xtermrtf>

==== docker node ====
Gestion des noeuds swarm.

=== docker node ls ===
[[https://docs.docker.com/engine/reference/commandline/node_ls/|Liste les noeuds swarm]] :
<xtermrtf>
$ docker node ls
</xtermrtf>

=== docker node inspect ===
[[https://docs.docker.com/engine/reference/commandline/node_inspect/|Affiche les caractéristiques d'un noeud]] :
<xtermrtf>
$ docker node inspect node01
</xtermrtf>

=== docker node inspect ===
[[https://docs.docker.com/engine/reference/commandline/node_inspect/|Affiche les caractéristiques d'un noeud]] :
<xtermrtf>
$ docker node inspect node01
</xtermrtf>

=== docker node ps ===
[[https://docs.docker.com/engine/reference/commandline/node_ps/|Liste les tâches qui s’exécutent sur un noeud]] :
<xtermrtf>
$ docker node ps node01
</xtermrtf>

=== docker node promote ===
[[https://docs.docker.com/engine/reference/commandline/node_promote/|Passe un worker en manager]] :
<xtermrtf>
$ docker node promote node01
</xtermrtf>

=== docker node demote ===
[[https://docs.docker.com/engine/reference/commandline/node_demote/|Passe un manager en worker]] :
<xtermrtf>
$ docker node promote node01
</xtermrtf>

=== docker node update ===
[[https://docs.docker.com/engine/reference/commandline/node_demote/|Met à jour la configuration d'un noeud]] :
<xtermrtf>
$ docker node update --availability drain node01
</xtermrtf>

==== docker service ====
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 :
<xtermrtf>
$ docker-compose bundle
</xtermrtf>

Cela va créer le fichier **.dsb (.dab)**. Il suffit ensuite de le déployer dans swarm :
<xtermrtf>
$ docker deploy <DABFilename>
</xtermrtf>

=== docker service ls ===
[[https://docs.docker.com/engine/reference/commandline/service_ls/|Liste les services]] :
<xtermrtf>
$ docker service ls
</xtermrtf>

=== docker service create ===
[[https://docs.docker.com/engine/reference/commandline/service_create/|Crée un service]] :
<xtermrtf>
$ docker service create --name redis --replicas=2 redis:3.0.6
</xtermrtf>

=== docker service inspect ===
[[https://docs.docker.com/engine/reference/commandline/service_inspect/|Affiche la configuration du service]] :
<xtermrtf>
$ docker service inspect redis --pretty
</xtermrtf>

=== docker service ps ===
[[https://docs.docker.com/engine/reference/commandline/service_ps/|Affiche les tâches d'un service]] :
<xtermrtf>
$ docker service ps redis
</xtermrtf>

=== docker service scale ===
[[https://docs.docker.com/engine/reference/commandline/service_scale/|Scaling pour un service]] :
<xtermrtf>
$ docker service scale backend=3 frontend=5
</xtermrtf>

=== docker service rm ===
[[https://docs.docker.com/engine/reference/commandline/service_rm/|Supprime un service]] :
<xtermrtf>
$ docker service rm redis
</xtermrtf>

=== docker service update ===
[[https://docs.docker.com/engine/reference/commandline/service_update/|Met à jour un service]] :
<xtermrtf>
$ docker service update --limit-cpu 2 redis
</xtermrtf>

===== Dockerfile =====
  * [[https://docs.docker.com/engine/reference/builder/#/dockerignore-file|Fichier .dockerignore]]

==== FROM ====
[[https://docs.docker.com/engine/reference/builder/#/from|Auteur du fichier Dockerfile]] :
<xtermrtf>
MAINTAINER <name>
</xtermrtf>

==== MAINTAINER ====
[[https://docs.docker.com/engine/reference/builder/#/maintainer|Image utilisée pour fabriquer la nouvelle image]] :
<xtermrtf>
FROM <image>
FROM <image>:<tag>
FROM <image>@<digest>FROM <image>@<digest>
</xtermrtf>

==== RUN ====
[[https://docs.docker.com/engine/reference/builder/#/run|Exécute des commandes pour la création de l’image]] :
<xtermrtf>
RUN <command>
RUN ["executable", "param1", "param2"]
</xtermrtf>

==== CMD ====
[[https://docs.docker.com/engine/reference/builder/#/cmd|Commande lancée au démarrage du conteneur]] :
<xtermrtf>
CMD <command>
CMD ["executable", "param1", "param2"]
</xtermrtf>

Si un [[#ENTRYPOINT]] est définit :
<xtermrtf>
CMD ["param1","param2"]
</xtermrtf>

==== LABEL ====
[[https://docs.docker.com/engine/reference/builder/#/label|Ajoute des méta-data à une image]] :
<xtermrtf>
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"
</xtermrtf>

==== EXPOSE ====
[[https://docs.docker.com/engine/reference/builder/#/expose|Expose un port]] :
<xtermrtf>
EXPOSE <port> [<port>...]
</xtermrtf>

==== ENV ====
[[https://docs.docker.com/engine/reference/builder/#/env|Définit des varaibles d'environnement]] :
<xtermrtf>
ENV myName John Doe
ENV myDog Rex The Dog
ENV myCat fluffy
ENV myName="John Doe" myDog=Rex\ The\ Dog \
    myCat=fluffy
</xtermrtf>

==== ADD ====
[[https://docs.docker.com/engine/reference/builder/#/add|Ajoute des fichiers]] :
<xtermrtf>
ADD <src>... <dest>
ADD ["<src>",... "<dest>"] 
</xtermrtf>

<xtermrtf>
ADD hom* /mydir/
</xtermrtf>

<note info>
''ADD'' peut pour la source prendre des URLS (http/https) et des archives qu'il décompressera dans la destination. Voir aussi [[#COPY]]
</note>

==== COPY ====
[[https://docs.docker.com/engine/reference/builder/#/copy|Ajoute des fichiers]] :
<xtermrtf>
COPY <src>... <dest>
COPY ["<src>",... "<dest>"] 
</xtermrtf>

<note info>
A la différence de [[#ADD]], ''COPY'' ne supporte pas les URLS en source et ne décompressera pas les archives.
</note>

==== ENTRYPOINT ====
[[https://docs.docker.com/engine/reference/builder/#/entrypoint|Permet d’exécuter la commande principale du conteneur. On peut également lui passer un script]] :
<xtermrtf>
ENTRYPOINT ["executable", "param1", "param2"]
ENTRYPOINT command param1 param2
</xtermrtf>

<note info>
Si l'on définit également [[#CMD]] alors qu'un ''ENTRYPOINT'' est définit alors ce qui est déclaré dans ''CMD'' sera passé en argument à ''ENTRYPOINT''.
</note>

==== VOLUME ====
[[https://docs.docker.com/engine/reference/builder/#/volume|Ajoute un volume]] :
<xtermrtf>
VOLUME <volume>
VOLUME ["<volume>"] 
</xtermrtf>

==== USER ====
[[https://docs.docker.com/engine/reference/builder/#/user|Indique avec quel utilisateur doit être lancé CMD, RUN et ENTRYPOINT]] :
<xtermrtf>
USER daemon
</xtermrtf>

==== WORKDIR ====
[[https://docs.docker.com/engine/reference/builder/#/workdir|Indique le CWD pour CMD, RUN, ENTRYPOINT, COPY et ADD]] :
<xtermrtf>
WORKDIR /path/to/workdir
</xtermrtf>

==== ARG ====
[[https://docs.docker.com/engine/reference/builder/#/arg|Définit des variables pour les réutiliser dans le Dockerfile]] :
<xtermrtf>
FROM busybox
USER ${user:-some_user}
ARG user
USER $user
</xtermrtf>

Variables prédéfinies :
  * HTTP_PROXY
  * http_proxy
  * HTTPS_PROXY
  * https_proxy
  * FTP_PROXY
  * ftp_proxy
  * NO_PROXY
  * no_proxy

==== ONBUILD ====
[[https://docs.docker.com/engine/reference/builder/#/onbuild|Indique un trigger à l'image qui sera lancé par un autre  BUILD sur cette image]] :
<xtermrtf>
ONBUILD ADD . /app/src
ONBUILD RUN /usr/local/bin/python-build --dir /app/src
</xtermrtf>

<note>
Pratique pour lancer une commande sur notre image si elle a été forkée...
</note>
==== STOPSIGNAL ====
[[https://docs.docker.com/engine/reference/builder/#/stopsignal|Indique le signal à envoyer au conteneur pour son arrêt]] :
<xtermrtf>
STOPSIGNAL signal
</xtermrtf>

==== HEALTHCHECK ====
[[https://docs.docker.com/engine/reference/builder/#/healthcheck|Vérifie la santé en lançant une commande dans le conteneur]] :
<xtermrtf>
HEALTHCHECK [OPTIONS] CMD command
HEALTHCHECK --interval=5m --timeout=3s \
  CMD curl -f http://localhost/ || exit 1
</xtermrtf>

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

==== SHELL ====
[[https://docs.docker.com/engine/reference/builder/#/shell|Indique quel shell utiliser]] :
<xtermrtf>
SHELL ["executable", "parameters"]
SHELL ["/bin/sh", "-c"]
</xtermrtf>

===== docker-compose =====
==== Commandes docker-compose ====
L'outil [[https://docs.docker.com/compose/reference/overview/|docker-compose]] fait intervenir la notion de service qui représente l'ensemble des conteneurs construits à partir d'un fichier ''docker-compose.yml''.

=== docker-compose build ===
[[https://docs.docker.com/compose/reference/build/|Construit ou reconstruit les images du service à partir du fichier]] ''docker-compose.yml''.

=== docker-compose pull ===
[[https://docs.docker.com/compose/reference/pull/|Vérifie les images du service.]]

=== docker-compose up ===
[[https://docs.docker.com/compose/reference/up/|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

<xtermrtf>
[root@docker test]# docker-compose up -d
Starting test_redis_1
Starting test_web_1
</xtermrtf>

=== docker-compose ps ===
[[https://docs.docker.com/compose/reference/up/|Liste les conteneurs.]]

=== docker-compose run ===
[[https://docs.docker.com/compose/reference/run/|Crée un conteneur avec la commande et le démarre.]]

=== docker-compose exec ===
[[https://docs.docker.com/compose/reference/exec/|Lance la commande si le conteneur est démarré.]]

=== docker-compose stop ===
[[https://docs.docker.com/compose/reference/stop/|Arrête l'ensemble des conteneurs du service]] :
<xtermrtf>
$ docker-compose stop
</xtermrtf>

<xtermrtf>
$ docker-compose stop web -t 30
</xtermrtf>

=== docker-compose start ===
[[https://docs.docker.com/compose/reference/start/|Démarre l'ensemble des conteneurs du service]] :
<xtermrtf>
$ docker-compose start
</xtermrtf>

<xtermrtf>
$ docker-compose start web
</xtermrtf>

=== docker-compose restart ===
[[https://docs.docker.com/compose/reference/restart/|Redémarre le service.]]

=== docker-compose down ===
[[https://docs.docker.com/compose/reference/down/|Arrête et supprime les conteneurs, volumes et réseau.]]

=== docker-compose config ===
[[https://docs.docker.com/compose/reference/config/|Affiche l’équivalent du fichier ''docker-compose.yml''.]]

=== docker-compose events ===
[[https://docs.docker.com/compose/reference/events/|Affiche en temps réel les événements du service.]]

=== docker-compose kill ===
[[https://docs.docker.com/compose/reference/kill/|Envoie un signal pour l'ensemble des conteneurs du service.]]

=== docker-compose pause ===
[[https://docs.docker.com/compose/reference/pause/|Met en pause le service.]]

=== docker-compose unpause ===
[[https://docs.docker.com/compose/reference/unpause/|Sort de la pause le service.]]

=== docker-compose logs ===
[[https://docs.docker.com/compose/reference/logs/|Affiche les logs du service.]]

=== docker-compose rm ===
[[https://docs.docker.com/compose/reference/rm/|Supprime les conteneur arrêtés]] :
<xtermrtf>
$ docker-compose rm --all
</xtermrtf>

=== docker-compose scale ===
[[https://docs.docker.com/compose/reference/scale/|Multiplie le nombre de conteneur pour un service]] :
<xtermrtf>
$ docker-compose scale web=2
</xtermrtf>

=== docker-compose version ===
[[https://docs.docker.com/compose/reference/version/|Affiche la version de ''docker-compose''.]]

==== Syntaxe docker-compose.yml ====
=== build ===
[[https://docs.docker.com/compose/compose-file/#/build|Construit l'image à partir d'une image existante ou d'un Dockerfile]] :

2 moyens :
  * A partir de Dockerfile
  * ou d'un dossier

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

<xtermrtf>
build: ./dir
image: webapp:tag
</xtermrtf>

''image'' et ''dockerfile'' sont exclusifs.

=== args ===
[[https://docs.docker.com/compose/compose-file/#/args|Permet de donner des arguments au Dockerfile]] :
<xtermrtf>
build:
  context: .
  args:
    buildno: 1
    password: secret
</xtermrtf>

Et dans notre ''Dockerfile'' :
<xtermrtf>
ARG buildno
ARG password

RUN echo "Build number: $buildno"
RUN script-requiring-password.sh "$password"
</xtermrtf>

=== capadd-capdrop ===
[[https://docs.docker.com/compose/compose-file/#/capadd-capdrop|Permet de donner des capabilities au conteneur]] :
<xtermrtf>
cap_add:
  - ALL

cap_drop:
  - NET_ADMIN
  - SYS_ADMIN
</xtermrtf>

=== command ===
[[https://docs.docker.com/compose/compose-file/#/command|Ecrase la commande par défaut du conteneur]].
<xtermrtf>
2 formats :
command: bundle exec thin -p 3000
</xtermrtf>

<xtermrtf>
command: [bundle, exec, thin, -p, 3000]
</xtermrtf>

=== cgroup_parent ===
[[https://docs.docker.com/compose/compose-file/#/cgroupparent|Définit un cgroup parent pour le conteneur]] :
<xtermrtf>
cgroup_parent: m-executor-abcd
</xtermrtf>

=== container_name ===
[[https://docs.docker.com/compose/compose-file/#/containername|Définit un nom pour le conteneur]] :
<xtermrtf>
container_name: my-web-container
</xtermrtf>

=== devices ===
[[https://docs.docker.com/compose/compose-file/#/devices|Mapping des devices]] :
<xtermrtf>
devices:
  - "/dev/ttyUSB0:/dev/ttyUSB0"
</xtermrtf>

=== depends_on ===
[[https://docs.docker.com/compose/compose-file/#/dependson|Dépendences sur l'ordre des services]] :
<xtermrtf>
devices:
version: '2'
services:
  web:
    build: .
    depends_on:
      - db
      - redis
  redis:
    image: redis
  db:
    image: postgres
</xtermrtf>

<note info>
''depends_on'' n'attendra pas dans l'exemple ci-dessus que ''db'' et ''redis'' soient démarrés. Pour attendre [[https://docs.docker.com/compose/startup-order/|cf cette page]].
</note>

=== dns ===
[[https://docs.docker.com/compose/compose-file/#/dns|Déclare le serveur dns]] :
<xtermrtf>
dns: 8.8.8.8
dns:
  - 8.8.8.8
  - 9.9.9.9
</xtermrtf>

=== dns_search ===
[[https://docs.docker.com/compose/compose-file/#/dnssearch|Déclare la search list DNS]] :
<xtermrtf>
dns_search: example.com
dns_search:
  - dc1.example.com
  - dc2.example.com
</xtermrtf>

=== tmpfs ===
[[https://docs.docker.com/compose/compose-file/#/tmpfs|Déclare un système de fichier tmpfs]] :
<xtermrtf>
tmpfs: /run
tmpfs:
  - /run
  - /tmp
</xtermrtf>

=== entrypoint ===
[[https://docs.docker.com/compose/compose-file/#/entrypoint|Ecrase l'entrypoint par défaut]] :
<xtermrtf>
entrypoint: /code/entrypoint.sh
</xtermrtf>

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

=== env_file ===
[[https://docs.docker.com/compose/compose-file/#/envfile|Déclare des variables d'environnement dans un fichier]] :
<xtermrtf>
env_file: .env

env_file:
  - ./common.env
  - ./apps/web.env
  - /opt/secrets.env
</xtermrtf>

<code>
# Set Rails/Rack environment
RACK_ENV=development
</code>

<note info>
Si vous spécifier l'option [[#build]], les variables définies dans votre fichier d'environnement ne seront pas prises en compte. Dans ce cas, utilisez l'option [[#args]] à la place dans les sous-options de [[#build]].
</note>

=== environment ===
[[https://docs.docker.com/compose/compose-file/#/environment|Déclare des variables d'environnement]] :
<xtermrtf>
environment:
  RACK_ENV: development
  SHOW: 'true'
  SESSION_SECRET:

environment:
  - RACK_ENV=development
  - SHOW=true
  - SESSION_SECRE
</xtermrtf>

<note info>
Si vous spécifier l'option [[#build]], les variables d'environnement définies ne seront pas prises en compte. Dans ce cas, utilisez l'option [[#args]] à la place dans les sous-options de [[#build]].
</note>

=== expose ===
[[https://docs.docker.com/compose/compose-file/#/expose|Expose un port vers l’extérieur]] :
<xtermrtf>
expose:
 - "3000"
 - "8000"
</xtermrtf>

<note info>
Voir également [[#ports]].
</note>

=== extends ===
[[https://docs.docker.com/compose/compose-file/#/extends|Permet de faire appel à un autre fichier yml pour déclarer un service]] :
<xtermrtf>
extends:
  file: common.yml
  service: webapp
</xtermrtf>

<note info>
''file'' peut être défini par un chemin relatif ou absolu.
</note>

=== external_links ===
[[https://docs.docker.com/compose/compose-file/#/externallinks|Lie au niveau réseau 2 conteneurs qui n'ont pas été déclarés dans le même fichier docker-compose.yml]] :
<xtermrtf>
external_links:
 - redis_1
 - project_db_1:mysql
 - project_db_1:postgresql
</xtermrtf>

<note info>
Voir aussi [[#links]]
</note>

=== extra_hosts ===
[[https://docs.docker.com/compose/compose-file/#/extrahosts|Ajoute une entrée dans le fichier /etc/hosts]] :
<xtermrtf>
extra_hosts:
 - "somehost:162.242.195.82"
 - "otherhost:50.31.209.229"
</xtermrtf>

=== image ===
[[https://docs.docker.com/compose/compose-file/#/image|Spécifie l'image du conteneur]] :
<xtermrtf>
image: ubuntu:14.04
</xtermrtf>

=== labels ===
[[https://docs.docker.com/compose/compose-file/#/labels|Ajoute un label dans les metadata]] :
<xtermrtf>
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"
</xtermrtf>

=== links ===
[[https://docs.docker.com/compose/compose-file/#/links|Lie au niveau réseau 2 conteneurs qui sont déclarés dans le même fichier docker-compose.yml]] :
<xtermrtf>
web:
  links:
   - db
   - db:database
   - redis
</xtermrtf>

<note info>
Voir aussi [[#external_links]]. Les conteneurs liés doivent posséder au moins un réseau en commun pour communiquer.
</note>

=== logging ===
[[https://docs.docker.com/compose/compose-file/#/logging|Définit de quelle façon le conteneur doit envoyer ses logs]] :
<xtermrtf>
logging:
  driver: syslog
  options:
    syslog-address: "tcp://192.168.0.42:123"
</xtermrtf>

<note info>
[[https://docs.docker.com/engine/admin/logging/overview/|Liste des drivers disponibles]].
</note>

=== network_mode ===
[[https://docs.docker.com/compose/compose-file/#/networkmode|Définit le mode pour le réseau réseau]] :
<xtermrtf>
network_mode: "bridge"
network_mode: "host"
network_mode: "none"
network_mode: "service:[service name]"
network_mode: "container:[container name/id]"
</xtermrtf>

=== networks ===
[[https://docs.docker.com/compose/compose-file/#/networks|Définit les réseaux]] :
<xtermrtf>
services:
  some-service:
    networks:
     - some-network
     - other-network
</xtermrtf>

=== aliases ===
[[https://docs.docker.com/compose/compose-file/#/aliases|Définit les alias]] :
<xtermrtf>
services:
  some-service:
    networks:
     - some-network
     - other-network
</xtermrtf>

=== ipv4_address, ipv6_address ===
[[https://docs.docker.com/compose/compose-file/#/ipv4address-ipv6address|Spécifie une adresse ipv4 et/ou ipv6 pour un conteneur]] :
<xtermrtf>
services:
  app:
    image: busybox
    command: ifconfig
    networks:
      app_net:
        ipv4_address: 172.16.238.10
        ipv6_address: 2001:3984:3989::10
</xtermrtf>

=== pid ===
[[https://docs.docker.com/compose/compose-file/#/pid|Définit le pid mode]] :
<xtermrtf>
pid: "host"
</xtermrtf>

<note info>
[[https://docs.docker.com/engine/reference/run/#pid-settings---pid|Voir les pid mode]].
</note>

=== ports ===
[[https://docs.docker.com/compose/compose-file/#/ports|Définit les ports du conteneur]] :
<xtermrtf>
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"
</xtermrtf>

<note info>
Voir également [[#expose]].
</note>

=== security_opt ===
[[https://docs.docker.com/compose/compose-file/#/securityopt|Sécurité SeLinux]] :
<xtermrtf>
security_opt:
  - label:user:USER
  - label:role:ROLE
</xtermrtf>

=== stop_signal ===
[[https://docs.docker.com/compose/compose-file/#/stopsignal|Signal envoyé au conteneur pour son arrêt]] :
<xtermrtf>
stop_signal: SIGUSR1
</xtermrtf>

=== ulimits ===
[[https://docs.docker.com/compose/compose-file/#/ulimits|Paramètres ulimits]] :
<xtermrtf>
ulimits:
  nproc: 65535
  nofile:
    soft: 20000
    hard: 40000
</xtermrtf>

=== volumes, volume_driver ===
[[https://docs.docker.com/compose/compose-file/#/volumes-volumedriver|Mapping des volulmes]] :
<xtermrtf>
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
</xtermrtf>

=== volumes_from ===
[[https://docs.docker.com/compose/compose-file/#/volumesfrom|Monte les volumes définit dans un autre conteneur]] :
<xtermrtf>
volumes_from:
 - service_name
 - service_name:ro
 - container:container_name
 - container:container_name:rw
</xtermrtf>

=== cpu_shares, cpu_quota, cpuset, domainname, hostname, ipc, mac_address, mem_limit, memswap_limit, privileged, read_only, restart, shm_size, stdin_open, tty, user, working_dir ===
[[https://docs.docker.com/compose/compose-file/#/cpushares-cpuquota-cpuset-domainname-hostname-ipc-macaddress-memlimit-memswaplimit-privileged-readonly-restart-shmsize-stdinopen-tty-user-workingdir|Définit différent paramètres]] :
<xtermrtf>
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
</xtermrtf>