Activation namespace user pour remappinf des uid entre le conteneur et la machine hôte avec : userns-remap :
Crée et démarre un conteneur à partir d'une image :
Options intéressantes :
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
$ 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
$ docker tag 0e5574283393 fedora/httpd:version1.0
$ docker tag httpd fedora/httpd:version1.0
$ 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'
$ 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
$ docker pull debian:jessie
$ docker pull ubuntu@sha256:45b23dee08af5e43a7fea6c4cf9c25ccf269ee113168c19722f87876677c5cb2
docker pull myregistry.local:5000/testing/test-image
docker pull --all-tags fedora
$ docker search --filter "stars=3" --filter "is-automated=true" --no-trunc --limit 5 debian
$ docker search --filter "is-official=true" debian
$ docker rmi localhost:5000/test/busybox@sha256:cbbf2f9a99b47fc460d422812b6a5adff7dfee951d8fa2e4a98caa0
$ docker rmi -f fd484f19954f
$ docker rmi test
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
containers created from an image or a descendant.
$ docker ps -a --filter 'exited=137'
$ docker ps --format "table {{.ID}}\t{{.Labels}}"
Affiche la version de docker :
$ docker version --format '{{.Server.Version}}'
$ docker version --format '{{json .}}'
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
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
Network supporte l'option driver
afin de spécifier un driver. Celui par défaut est 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
$ 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
$ 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
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
$ 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.
$ 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
$ docker node promote node01
$ 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>
$ docker service ls
$ 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
$ docker service scale backend=3 frontend=5
$ docker service rm redis
$ docker service update --limit-cpu 2 redis
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 <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
ADD <src>... <dest> ADD ["<src>",... "<dest>"]
ADD hom* /mydir/
ADD
peut pour la source prendre des URLS (http/https) et des archives qu'il décompressera dans la destination. Voir aussi COPY
COPY <src>... <dest> COPY ["<src>",... "<dest>"]
COPY
ne supporte pas les URLS en source et ne décompressera pas les archives.
Permet d’exécuter la commande principale du conteneur. On peut également lui passer un script :
ENTRYPOINT ["executable", "param1", "param2"] ENTRYPOINT command param1 param2
ENTRYPOINT
est définit alors ce qui est déclaré dans CMD
sera passé en argument à ENTRYPOINT
.
VOLUME <volume> VOLUME ["<volume>"]
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 :
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 :
CMD
peut être un script qui peut renvoyer le code de sortie ci-dessous :
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
.
Crée et démarre le(s) conteneur(s) du service.
Options :
[root@docker test]# docker-compose up -d Starting test_redis_1 Starting test_web_1
Supprime les conteneur arrêtés :
$ docker-compose rm --all
Multiplie le nombre de conteneur pour un service :
$ docker-compose scale web=2
Construit l'image à partir d'une image existante ou d'un Dockerfile :
2 moyens :
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
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
depends_on
n'attendra pas dans l'exemple ci-dessus que db
et redis
soient démarrés. Pour attendre cf cette page.
dns: 8.8.8.8 dns: - 8.8.8.8 - 9.9.9.9
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
Permet de faire appel à un autre fichier yml pour déclarer un service :
extends: file: common.yml service: webapp
file
peut être défini par un chemin relatif ou absolu.
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]"
services: some-service: networks: - some-network - other-network
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 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"
security_opt: - label:user:USER - label:role:ROLE
Signal envoyé au conteneur pour son arrêt :
stop_signal: SIGUSR1
ulimits: nproc: 65535 nofile: soft: 20000 hard: 40000
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