Docker

Docker és una plataforma de contenidors, una alternativa interessant a la virtualització. Un contenidor comparteix el kernel del sistema operatiu però disposa dels seus propis recursos de sistema de fitxers (similar a un chroot), espai de memòria i temps de microprocessador.

Conceptes bàsics

Referència bàsica: https://docs.docker.com/engine/userguide/

Imatge: sistema base del què partim per crear nous containers. No son més que un seguit d'arxius dels què disposarà el container quan es posi en marxa. Per crear una imatge podem fer-ho de diverses formes:

• Descarregar-la de Docker Hub (docker.com) amb docker run <img:versio> (si no la tenim la descarregarà automàticament).
• Generar-la amb un Dockerfile a partir d'una imatge prèvia (automated)
• Generar-la de forma binària a partir d'un TAR (serà el sistema d'arxius base)

Container: subsistema que corre comandes o serveis. El generem a partir d'una imatge base.

• El sistema el "bateja" quan l'inicia amb nom i cognom (a l'estil "fervent_aryabhata", "drunk_sammet", etc.).
• El container només està actiu mentre executa alguna comanda o servei, si no, es para.
• Es pot reactivar en background amb un start, i podem attachar-nos o desatachar-nos de la shell que hem obert inicialment.

Volum: directori a compartir entre la màquina amfitriona i el container.

• També pot ser un device (p.ex. /dev/snd o /dev/sda , però es tracta diferent en el settings).

Quick reference

ULL!

• <img> és una imatge base (p.ex. debian, wordpress, centos, etc.)
• <nom> és un container prèviament creat (p.ex. "fervent_aryabhata", "drunk_sammet", etc.)

Creació de containers

Per arrencar una shell en un nou container (podem posar qualsevol comanda enlloc de la shell):

$ docker run -ti <img> /bin/bash

"-ti" = (t)erminal (i)nteractive

Per arrencar un container i deixar-lo en background:

$ docker run -d <img>

Per executar una comanda en un container en marxa:

$ docer exec <nom> <cmd>

Per arrencar un container (prèviament creat) en background:

$ docker start <nom>

Parar un container:

$ docker stop <nom>

Gestió de containers

Llistat d'instàncies creades localment (sense -a les que estan en execució):

$ docker ps -a

Per desatachar-nos d'un contenidor sense parar-lo:

CTRL + P + Q

Per attachar-nos a un contenidor en marxa:

$ docker attach <nom>

Per eliminar un container:

$ docker rm <nom>

Per llistar totes les instàncies i eliminar-les:

$ docker ps -aq | xargs docker rm

Info:

$ docker inspect <nom>

Renombrar:

$ docker rename <nom_antic> <nom_nou>

Gestió d'imatges

Llistat d'imatges disponibles en local:

$ docker images

Cerca d'imatges al repositori de Docker.com:

$ docker search <cadena>

Descarregar una imatge (sense arrencar cap container):

$ docker pull <img:versió>

Crear una nova imatge a partir de Dockerfile (l'anomenem amb -t <tag>):

$ docker build -t <img:versió> <path-to-Dockerfile>

Crear una imatge "binària" (ens donarà el hash de la imatge):

$ docker commit <nom> [<repo>:<tag>]

Per nombrar amb un tag la imatge creada (si no ho hem fet abans):

$ docker tag <hash> <tag>

Gestió de volums i devices

Podem muntar a l'arrencada del container al fer "run":

• Carpetes del filesystem de l'amfitrió amb

  -v <carpeta>:<mount_point>

• Carpetes persistents per tots els containers amb:

  -v <alias>:<mount_point>

• Devices amb

  --device <dev>:<mount_point>

Veure volums actuals:

$ docker volumes ls

Exemples:

$ docker run --device /dev/snd:/dev/snd -v ~/Baixades:/downloads -it debian /bin/bash

Crear un Dockerfile

S'ha de nombrar exactament així, Dockerfile.

Referència: https://docs.docker.com/engine/reference/builder/

Exemple bàsic:

FROM library/debian
MAINTAINER Enric Mieza <[email protected]>

RUN apt-get update && \
apt-get install -y mplayer && \
apt-get clean && apt-get autoclean && \
rm -rf /var/lib/apt/lists/*

VOLUME ["/tmp:/vol1"]

Dintre de RUN posem les comandes per inicialitzar la màquina (típicament instal·lar paquets).

Amb VOLUME podem muntar devices i volums de la màquina amfitriona.

Imatge binària i comparació amb chroot

Un contenidor Docker es pot crear a partir d'una imatge "binària" basada en una col·lecció d'arxius executables que vulguem utilitzar en el nostre contenidor. Com que el kernel és el de la màquina amfitriona, només cal que afegim els binaris i les llibreries que ens calen per executar el servei o aplicació desitjada (que de passada augmenta la seguretat).

Així, doncs, per fer una imatge només cal que fem un arxiu TAR amb les comandes que requerim. Per exemple, si desitjem tenir un contenidor que pugui executar scripts bash, només caldrà el binari /bin/bash i les llibreries de les que tingui dependències.

Per saber quin és l'executable del bash podem fer:

$ which bash

I per saber de quines llibreries dinàmiques (shared objects) depèn, només caldrà fer:

$ ldd /bin/bash

En la meva Ubuntu 14.04 em surt:

	linux-vdso.so.1 =>  (0x00007ffe58b43000)
	libtinfo.so.5 => /lib/x86_64-linux-gnu/libtinfo.so.5 (0x00007f6c1106d000)
	libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2 (0x00007f6c10e69000)
	libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f6c10aa4000)
	/lib64/ld-linux-x86-64.so.2 (0x00007f6c11296000)

Així, per crear la nostra imatge per a bash scripts només caldrà posar tots aquests arxius en un directori (on se suposa que tindríem l'arrel), dins dels seus pertinents subdirectoris (/bin, /lib, etc.)

Comprimim amb TAR i importem l'invent dins de Docker.

...TODO...

Desplegament de Wordpress amb MySQL

Utiltizarem les imatges oficials:

• https://hub.docker.com/_/mysql/
• https://hub.docker.com/_/wordpress/

Ull, haurem de crear els volums persistents si volem que quan parem els contenidors tot continui funcionant. En particular caldrà muntar:

• /var/lib/mysql a la màquina MySQL
• /var/lib/html a la màquina Wordpress (és una apache2 en debian)

Arranquem MySQL:

$ docker run --name mysql1 -ti -e MYSQL_ROOT_PASSWORD=wordpress -v mysqldata:/var/lib/mysql mysql

Arranquem Wordpress:

$ docker run --name wp1 -e WORDPRESS_DB_USER=root -e WORDPRESS_DB_PASSWORD=wordpress -e WORDPRESS_DB_NAME=wp1 -v wpdata:/var/www/html --link mysql1:mysql -ti wordpress

Fent desplegaments més segurs

Si volem afegir seguretat, hauríem d'arrencar els serveis amb un usuari particular, per exemple, mysql:

$ docker run --name mysql1 -ti -e MYSQL_ROOT_PASSWORD=wordpress -v mysqldata:/var/lib/mysql --user=mysql mysql

En alguns casos (no en MySQL però en d'altres sí) l'usuari no podrà escriure a alguns llocs del sistema d'arxius. Es pot solventar creant volums per als serveis clau

Docker Compose

Ens facilita configurar sistemes de contenidors, els seus enllaços, ports, volums, etc.

Docker compose: https://docs.docker.com/compose/

• Comença per la instal·lació
• Segueix el tutorial del "getting started"
• Segueix amb el de "Wordpress"

Cal crear prèviament un arxiu docker-compose.yml amb la configuració del sistema. Totes les comandes cal cridar-les dins del directori on hi ha l'arxiu.

Arrencar en mode dimoni:

$ docker-compose up -d

Parar el sistema:

$ docker-compose down

També es pot fer start/stop.

Per saber què hi ha en marxa:

$ docker-compose ps

Per esborrar un sistema de contenidors

$ docker-compose rm

Escalant

Per escalar podem arrencar diversos contenidors. A l'exemple de Wordpress (caldria treure el mapeig dels ports perquè si no, dona error):

$ docker-compose down
$ sudo rm -rf .data
$ docker-compose up -d
$ docker-compose scale wordpress=3 db=1

Ara pots accedir a qualsevol de les 3 màquines amb wordpress, instal·lar-ho i veure que des de les altres màquines també funciona. Típicament:

http://172.21.0.3/

Per estar segur mira't la IP de les màquines que tinguis (a l'exemple es diu composerwp2_wordpress_1):

$ docker-compose ps
$ docker inspect composerwp2_wordpress_1 | grep IPAddress

Si tens problemes comprova això:

• buida la caché del teu navegador abans d'accedir a la URL (típicament es queda la redirecció permanent de l'anterior instal·lació).
• destrueix la instal·lació anterior (down) i els directoris .data que s'hagin creat.

Docker Machine i Swarm

Docker Machine gestiona l'accés remot a un servidor docker. Enlloc de treballar en local podrem treballar sobre la màquina virtual remota. Té drivers pels diversos sistemes de virtualització més coneguts (VMware, Virtualbox, Xen, etc.) i un driver genèric.

El típic us és:

$ docker-machine create -d virtualbox <nom_maquina>

Veure les màquines disponibles:

$ docker-machine ls

Arrencar una màquina ja creada:

$ docker-machine start <nom_maquina>

Aturar-la:

$ docker-machine stop <nom_maquina>

Això crearà una màquina virtual sobre el nostre virtualbox, instal·larà el SO Linux i els paquets necessaris per tenir un servidor de Docker, a més de les claus SSH per poder accedir remotament des de la màquina local de forma còmoda.

Swarm

https://docs.docker.com/swarm/provision-with-machine/

Podem gestionar contenidors que han de treballar plegats, però sobre diferents màquines (virtuals o no). Té diverses estratègies de repartiment. Necessitem un token proveït per hub.docker.com per tal de sincronitzar tots els contenidors.

Seguint el tutorial de swarm podrem crear un seguit de nodes als quals podrem assignar contenidors. L'estratègia per defecte és rotatòria.

La principal dificultat del swarm és que si volem desplegar un cluster en què els nodes han de comunicar-se entre sí necessitarem una xarxa overlay que ens agrupi les diferents màquines on tenim els contenidors. Per aquesta xarxa ens serà imprescindible disposar d'una base de dades key/value (datastore) del tipus etcd, consul o similars.

Utilitzarem Consul. És un paquet de serveis que inclou DNS, datastore, ACLs entre d'altres. Referències:

• http://consul.io
• Docker de Consul: https://hub.docker.com/r/progrium/consul/

Les passes a realitzar serien:

1. Crear datastore Consul. Per HA caldria replicar-la, però per provar podem fer una sola instància en un contenidor local.
2. Crear overlay network per comunicar nodes.
3. Crear swarm amb el docker-machine
4. Configurar swarm per comunicar-se a través de la xarxa overlay.