====== Docker ======

Herramienta que permite desplegar aplicaciones en contenedores de forma rápida y portable.

  * [[https://www.docker.com/|Web oficial]]

Utiliza contenedores e imágenes. En las imágenes se define toda la configuración del software, bibliotecas, etc., todo lo que necesita la aplicación para funcionar. En un contenedor se vuelve realidad.

  * Aplicaciones de bolsillo
  * Desplegar y escalar aplicaciones
  * Destruir y recrear.

Ejemplo de uso:

<code>
docker run -d -p 80:80 --name web httpd
</code>

Para eliminarlo:

<code>
docker rm -fv web
</code>

===== Arquitectura de Docker =====

{{ :informatica:sistemas_operativos:virtualizacion:docker:docker-arquitectura.jpg?nolink |}}

===== Imágenes =====

Una imagen es un paquete que contiene toda la configuración necesaria para que funcione el servicio/aplicación.

Las imágenes se componen de capas y son de solo lectura. En la primera capa definimos qué sistema operativo tendremos en la imagen.

Las capas se definen través de un fichero ''Dockerfile'':

<code yaml>
FROM centos:7
# Instalación del servidor web Apache
RUN yum -y install httpd

# Definimos el comando que ejecutará Apache. Es importante que se ejecute en primer plano o el contenedor finalizará en el momento en que se haya ejecutado lo que hay en ''CMD''
CMD ["apachectl", "-DFOREGROUND"]
</code>

<WRAP center round tip 60%>
Cuando no se especifica una etiqueta/tag, por defecto se descarga la ''latest''
</WRAP>

==== Imágenes oficiales ====

Las imágenes se alojan en el [[https://hub.docker.com/|Docker Hub]]

Para descargarlas:

<code>
docker pull nombre-imagen
</code>

Para saber las imágenes que tenemos descargadas o en el sistema:

<code>
docker images
</code>

Para eliminar una imagen:

<code>
docker rmi nombre-imagen|identificador-imagen
</code>

==== Imágenes propias ====

Creamos un fichero ''Dockerfile'':

<code yaml>
FROM centos:latest
RUN yum -y install httpd
</code>

Para convertirla en imagen:

<code>
docker build --tag nombre-nueva-imagen .
</code>

Para ver las capas que se crearon en una imagen:

<code>
docker history -H nombre-imagen
</code>

==== Operaciones ====

Eliminar imágenes:

<code>
docker rmi nombre-imagen
</code>

Imágenes huérfanas:

<code>
docker images -f dangling=true
</code>

Y para eliminarlas:

<code>
docker images -f dangling=true -q | xargs docker rmi
</code>

<WRAP center round tip 60%>
Para eliminar las imágenes que no están en uso ni referenciadas también se puede utilizar ''docker image prune''
</WRAP>

==== Dockerfile ====

Fichero para la creación de imágenes.

  * ''FROM'': imagen de base
  * ''RUN'': cualquier comando disponible en Linux
  * ''COPY'': copia archivos desde la máquina local hacia la imagen (opción recomendada por Docker).
  * ''ADD'': copia archivos desde la máquina local o remota (se puede indicar una URL) hacia la imagen.
  * ''ENV'': variables de entorno
  * ''WORKDIR'': directorio actual de trabajo en la imagen
  * ''EXPOSE'': puerto que se expondrá desde el contenedor.
  * ''LABEL'': etiquetas para mostrar alguna información, metadatos.
  * ''USER'': indica el usuario que ejecutará la tarea (por defecto es root)
  * ''VOLUME'': permite indicar qué datos serán persistentes en la creación del contenedor (volúmenes anónimos).
  * ''CMD'': comando o script para mantener un contenedor en ejecución

<code>
FROM centos

LABEL version=1.0
LABEL description="This is an apache imagen"
LABEL vendor=yo

RUN yum install httpd -y

WORKDIR /var/www

# No ponemos /var/www/html como destino de la copia porque
# con WORKDIR nos hemos posicionado en /var/www, así que solo
# quedaría indicar html
COPY app html/

# variable valor
ENV contenido prueba

RUN echo "$contenido" > /var/www/html/prueba.html

RUN useradd pepito

# A partir de aquí, todo lo que se ejecuté, será por el 
# usuario pepito
USER pepito

RUN echo "$(whoami)" > /tmp/user.html

# Volvemos a ser root
USER root

RUN cp /tmp/user.html /var/www/html/user.html
CMD apachectl -DFOREGROUND
</code>

<WRAP center round info 60%>
En ''CMD'' solo se puede indicar un comando, así que si necesitamos más, habría que crear un script con todo lo necesario y luego colocar ese script en ''CMD''
</WRAP>


Con el Dockerfile creado, para crear la nueva imagen a partir de él:

<code>
docker build -t apache .
</code>

Si nuestro Dockerfile tiene otro nombre, hay que indicarlo a la hora de crear la imagen:

<code>
docker build -t prueba -f mi-dockerfile .
</code>
==== .dockerignore ====

Fichero que permite ignorar cualquier cosa que esté en el directorio actual y no incluirlo en una imagen:

<code>
fichero-ignorado
</code>

==== Multi-Stage Build ====

Permite utilizar varios ''FROM'' en el Dockerfile:

<code>
# La imagen de centos ya ocupa unos 200 MB
FROM centos as test

RUN fallocate -l 10M /opt/file1

RUN fallocate -l 20M /opt/file2

RUN fallocate -l 30M /opt/file3

# La imagen de alpine son poco más de 4 MB
FROM alpine

COPY --from=test /opt/file2 /opt/file
</code>

Cuando se cree la imagen, tendrá el tamaño de la imagen ''alpine'' y el fichero que hemos copiado de la anterior imagen
==== Buenas prácticas ====

  * Un contenedor por servicio
  * ''.dockerignore''
  * Pocas capas
  * Multilínea (''\'') para facilitar la lectura
  * Varios argumentos en una sola capa
  * No instalar paquetes innecesarios
  * Utilizar labels para añadir metadatos a la imagen
===== Contenedores =====

Sería la siguiente capa de una imagen. Ejecución de la imagen.  Es de lectura y escritura. Podemos modificar cosas en el contenedor, pero no en la imagen.

Un contenedor contiene:

  * Imagen
  * Volúmenes
  * Redes

==== Creación ====

Para crear un contenedor:

<code>
docker run -d -p 80:80 --name mi-contenedor imagen
</code>

  * ''-d'': ejecuta el contenedor en segundo plano.
  * ''-p'': puerto local:puerto de la imagen
  * ''%%--%%name'': nombre que tendrá el contenedor

Podemos ver los contenedores en ejecución:

<code>
docker ps
</code>

Si queremos ver también los que se han detenido o finalizado:

<code>
docker ps -a
</code>

==== Eliminar ====

<code>
docker rm -f nombre-contenedor
</code>

Si queremos eliminar todos a la vez:

<code>
docker rm -fv $(docker ps -aq)
</code>

<WRAP center round tip 60%>
También se pueden eliminar los contenedores detenidos con ''docker container prune''
</WRAP>

==== Renombrar ====

<code>
docker rename nombre-antiguo nombre-nuevo
</code>

==== Detener ====

<code>
docker stop nombre-contenedor|id-contenedor
</code>

==== Iniciar ====

<code>
docker start nombre-contenedor|id-contenedor
</code>

==== Entrar en el contenedor ====

<code>
docker exec -it contenedor bash
</code>

Si queremos entrar como cierto usuario:

<code>
docker exec -u root -it contenedor bash
</code>

<WRAP center round important 60%>
El usuario tiene que existir en la imagen o en el contenedor.
</WRAP>

==== Variables de entorno ====

Si queremos especificar variables de entorno a la hora de crear un contenedor:

<code>
docker run -d -e "prueba:1234" --name mi-contenedor imagen
</code>

Es útil para imágenes que ya tienen definidas algunas variables:

<code>
docker run -d -e "MYSQL_ROOT_PASSWORD=123456" mysql
</code>

==== Copiar archivos ====

Si queremos copiar archivos desde nuestro equipo local hacia el contenedor:

<code>
docker cp fichero1 mi-contenedor:/ruta/contenedor/fichero1
</code>

Para copiar desde el contenedor a nuestra máquina:

<code>
docker cp mi-contenedor:/ruta/contenedor/fichero1 fichero1
</code>

==== Eliminar contenedores automáticamente ====

Para indicar que el contenedor que queremos crear es temporal y que al finalizar, lo borre:

<code>
docker run --rm -ti --name mi-contenedor imagen bash
</code>

Cuando salgamos del terminal bash del contenedor, Docker lo eliminará.
==== Recursos consumidos ====

<code>
docker stats nombre-contenedor|id-contenedor
</code>

Ejemplo de salida:

<code>
CONTAINER ID        NAME                CPU %               MEM USAGE / LIMIT     MEM %               NET I/O             BLOCK I/O           PIDS
9aa067025bbe        cloud.tempwin.net   0.00%               121.2MiB / 7.791GiB   1.52%               669MB / 375MB       0B / 0B             146
</code>

Para limitar el uso de RAM que podrá hacer un contenedor:

<code>
docker run -d --memory "1gb" --name mi-contenedor imagen
</code>

Para limitar el número de CPUs:

<code>
docker run -d --cpuset-cpus 0-1 --name mi-contendor imagen
</code>

Le hemos indicado que ese contenedor solo podrá usar la CPU 0 y la CPU 1

==== Registros ====

Para centrarnos en los registros de un único servicio:

<code>
docker logs -t -f <name-of-service>
</code>
===== Volúmenes =====

Herramienta para almacenar datos del contenedor de forma persistente en nuestra máquina local.

==== Volúmenes de host ====

Residen en una carpeta del sistema de ficheros de la máquina local

<code>
docker run -d -v /opt/mysql:/var/lib/mysql -p 3306:3306 --name mi-contenedor mysql
</code>

De esa manera indicamos que el directorio ''/var/lib/mysql'' del contenedor va a estar disponible desde el directorio ''/opt/mysql'' de la máquina local.

==== Volúmenes anónimos ====

<code>
docker run -d -v /var/lib/mysql -p 3306:3306 --name mi-contenedor mysql
</code>

Al no definir en qué carpeta quedará asociada la del contenedor, Docker le dará una al azar.

<WRAP center round important 60%>
No es recomendable utilizar este tipo de volúmenes ya que, además de tener nombres difíciles de memorizar, en el momento de eliminar el contenedor, Docker borrará el volumen también.
</WRAP>

==== Volúmenes nombrados ====

Volúmenes creados por el usuario.

Para crear un volumen llamado ''mysql-data'':

<code>
docker volume create mysql-data
</code>

Para eliminarlo:

<code>
docker volume rm mysql-data
</code>

Para asociarlo a un contenedor:

<code>
docker run -d --name mi-contenedor -v mysql-data:/var/lib/mysq -p 3306:3306 mysql
</code>

<WRAP center round tip 60%>
La ventaja de este tipo de volúmenes es que no se borran al eliminar el contenedor
</WRAP>

==== Volúmenes huérfanos ====

Se llaman volúmenes //dangling//, no están referenciados por ningún contenedor. Para encontrarlos:

<code>
docker volume ls -f dangling=true
</code>

Para borrarlos todos de una vez:

<code>
docker volume ls -f dangling=true -q | xargs docker volume rm
</code>

  * ''-q'': muestra el identificador del volumen

===== Redes =====

Con la instalación de Docker se crea una nueva interfaz de red:

<code>
$ ip a | grep docker

11: docker0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN group default
    inet 172.17.0.1/16 brd 172.17.255.255 scope global docker0
</code>

Todos los contenedores que creemos, estarán dentro de esa red:

<code>
docker inspect nombre|id-contenedor
</code>

Consultamos el valor //IPAddress// para saber la IP que usa el contenedor

La red por defecto se llama **bridge**

Para ver todas las redes:

<code>
docker network ls
</code>
==== Tipos ====

  * **Bridge**
  * **Host**: la red de la propia máquina
  * **None**: los contenedores que se metan ahí no tendrán red
  * **Overlay**

==== Creación ====

<code>
docker network create nombre-red
</code>

Podemos configurar la subred:


<code>
docker network create --subnet 172.120.0.0/24 --gateway 172.120.0.1 nombre-red 
</code>

==== Inspeccionar ====

<code>
docker network inspect nombre-red
</code>
==== Eliminación ====

<code>
docker network rm nombre-red
</code>

<WRAP center round important 60%>
Para poder eliminar una red, no debe haber ningún contendor que esté usándola
</WRAP>

==== Asignación ====

Si queremos crear un contenedor en una determinada red:

<code>
docker run --network nombre-red -d --name mi-contenedor centos
</code>

<WRAP center round tip 60%>
En las redes creadas por el usuario, podemos ver los contenedores por su nombre.
</WRAP>


<WRAP center round important 60%>
Esto no es posible en la red por defecto de Docker, solo se podría por IP
</WRAP>

==== Asignar IP ====

<code>
docker run --network mi-red --ip 172.120.0.10 -d --name mi-contendor imagen
</code>
==== Conectar contenedor distintas redes ====

<code>
docker network connect nombre-red contenedor
</code>

De esa manera, indicamos a Docker que ''contenedor'' también está en la red ''nombre-red''

Si queremos desconectarlo de cierta red:

<code>
docker network disconnect nombre-red contenedor
</code>
===== Docker Compose =====

Herramienta que ayuda a crear aplicaciones multicontenedor. Aplicaciones como aplicaciones web utilizan bases de datos, algún lenguaje de programación y servidor web. Crearíamos un contenedor por cada elemento necesario. En lugar de hacerlo por separado, Docker Compose nos permite definirlo en un único archivo de texto y él gestionará la creación de contenedores, volúmenes, redes, etc.

==== Instalación ====

<WRAP center round todo 60%>
Actualizar el proceso de instalación manual, el que aquí se muestra está desfasado
</WRAP>


<code>
sudo curl -L "https://github.com/docker/compose/releases/download/1.27.4/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
</code>

Y le damos permisos de ejecución:

<code>
sudo chmod +x /usr/local/bin/docker-compose
</code>

  * [[https://docs.docker.com/compose/install/|Documentación oficial]]
  * [[https://github.com/docker/compose|Repositorio oficial]]

==== Uso ====

El fichero de configuración de Docker Compose se llama ''docker-compose.yml''. El fichero se compone de 4 bloques:

<code yaml>
# Obligatorias:
version:
services:

# Opcionales:
volumes:
networks:
</code>

<code>
docker run -d --name nginx -p 80:80 nginx
</code>

Traducido al ''docker-compose.yml'':

<code>
version: '3'
services:
  web:
    image: nginx
    container_name: nginx
    ports:
      - "80:80"   
</code>

<WRAP center round info 60%>
En Docker Compose, los contenedores que se crean se ejecutan en segundo plano, como cuando indicamos la opción ''-d''
</WRAP>

Para arrancar todo lo definido en el fichero ''docker-compose.yml'':

<code>
docker-compose up -d
</code>

Si queremos darle un nombre, en lugar del que defina Docker Compose, lo lanzaremos así:

<code>
docker-compose -p nombre-proyecto up -d
</code>

Si utilizamos un Docker Compose diferentes al esperado (''docker-compose.yml''), añadimos la opción ''-f'':

<code>
docker-compose -f docker-compose-mysql.yml up -d
</code>

=== Eliminar contenedores ===

<code>
docker-compose down
</code>

=== Variables de entorno ===

Podemos definirlas desde el propio fichero ''docker-compose.yml'':

<code yaml>
version: '3'
services:
  web:
    image: mysql
    container_name: mysql
    ports:
      - "3306:3306"   
    environment:
      - "MYSQL_ROOT_PASSWORD=abc123."
</code>

O en un fichero externo, por ejemplo, en ''.env'':

<code>
MYSQL_ROOT_PASSWORD=abc123.
MYSQL_USER=pepito
</code>

Y luego hacemos referencia a él desde ''docker-compose.yaml'':

<code yaml>
version: '3'
services:
  web:
    image: mysql
    container_name: mysql
    ports:
      - "3306:3306"   
    env_file: .env
</code>

=== Volúmenes ===

Volúmenes nombrados:

<code yaml>
version: 3
services:
  web:
    image: nginx
    container_name: nginx
    ports:
      - "80:80"   
    volumes:
      - "mi-volumen:/usr/share/nginx/html"
volumes:
  mi-volumen:
</code>

Para definir un volumen de host:

<code yaml>
version: 3
services:
  web:
    image: nginx
    container_name: nginx
    ports:
      - "80:80"   
    volumes:
      - "/mi/ruta/:/usr/share/nginx/html"
</code>

=== Políticas de reinicio ===

<code yaml>
version: '3'
services:
  servicio:
    ...
    restart: no
</code>

Por defecto, Docker Compose no reinicia los contenedores si se han detenido.

Otras opciones:

  * ''always'': el contenedor siempre se reiniciará
  * ''on-failure'': el contenedor se reinicia si hubo un fallo
  * ''unless-stopped'': el contenedor se reinicia solo si no ha sido detenido
===== Administración =====

==== Docker root dir ====

El directorio raíz de Docker (//Docker Root Dir//) es por defecto ''/var/lib/docker''. Podemos saberlo:

<code>
docker info | grep -i "root"
</code>

Antes de hacer ningún cambio, detenemos el servicio de Docker:

<code>
systemctl stop docker
</code>

Para indicar un nuevo directorio, vamos a ''/lib/systemd/system/docker.service'':

<code>
ExecStart=/usr/bin/dockerd --data-root /nuevo/docker-root-dir
</code>

Recargamos la nueva configuración:

<code>
systemctl daemon-reload
</code>

Y reiniciamos el servicio de Docker:

<code>
systemctl restart docker
</code>