Tema:

Utilizando Almacenamiento Persistente en Contenedores Docker

Introducción

El almacenamiento persistente en contenedores Docker es un tema crucial para garantizar la durabilidad de los datos generados y consumidos por las aplicaciones que se ejecutan en contenedores. Aunque los contenedores son efímeros por naturaleza, muchas aplicaciones requieren mantener datos más allá del ciclo de vida de un contenedor, como bases de datos, configuraciones, archivos de usuario, y más.

En este tema exploraremos cómo Docker maneja el almacenamiento, las opciones disponibles para configurar volúmenes persistentes y montajes, así como las mejores prácticas para garantizar la integridad, escalabilidad y seguridad de los datos. Esto permitirá a los participantes comprender y aplicar estrategias de almacenamiento para soportar aplicaciones más complejas y críticas en entornos de producción.

Objetivo

Objetivo General:

Proveer a los participantes los conocimientos y habilidades necesarios para configurar y gestionar almacenamiento persistente en contenedores Docker, garantizando la durabilidad y disponibilidad de los datos en aplicaciones contenerizadas. Los participantes aprenderán a identificar las diferentes opciones de almacenamiento, implementar volúmenes y montajes en diversos escenarios, y aplicar las mejores prácticas para integrar almacenamiento persistente de manera efectiva en entornos de contenedores.

Volúmenes

Los volúmenes son el mecanismo preferido para conservar los datos generados y utilizados por los contenedores de Docker. Si bien los Bind mounts dependen de la estructura de directorios y del sistema operativo de la máquina host, los volúmenes son completamente administrados por Docker. Los volúmenes tienen varias ventajas sobre los montajes de enlace:

Es más fácil realizar copias de seguridad o migrar volúmenes que montajes enlazados.
Puede administrar volúmenes mediante los comandos CLI de Docker o la API de Docker.
Los volúmenes funcionan en contenedores de Linux y Windows.
Los volúmenes se pueden compartir de forma más segura entre varios contenedores.
Además, los volúmenes suelen ser una mejor opción que persistir los datos en la capa escribible de un contenedor, porque un volumen no aumenta el tamaño de los contenedores que lo utilizan y el contenido del volumen existe fuera del ciclo de vida de un contenedor determinado.

Creación y Administración de Volumenes

Crear un volumen:

docker volume create example-vol

Lista de volúmenes:

docker volume ls

La salida del comando anterior debe ser similar a la siguiente:

local               my-vol

Inspeccionar un volumen:

docker volume inspect example-vol

La salida del comando anterior debe ser similar a la siguiente:

[
    {
        "Driver": "local",
        "Labels": {},
        "Mountpoint": "/var/lib/docker/volumes/example-vol/_data",
        "Name": "example-vol",
        "Options": {},
        "Scope": "local"
    }
]

Eliminar un volumen:

docker volume rm example-vol

Iniciar un contenedor con un volumen

Si inicia un contenedor con un volumen que aún no existe, Docker crea el volumen por usted. El siguiente ejemplo monta el volumen demovol en /app/ del contenedor.

docker run -d \
--name demovol-container \
--mount source=demovol,target=/app \
nginx:latest

Puedes utilizar docker inspect demovol-container para verificar que Docker creó el volumen y se montó correctamente. Busque la Mountssección:

docker inspect demovol-container

La salida del comando anterior debe ser similar a la siguiente:

"Mounts": [
    {
        "Type": "volume",
        "Name": "demovol",
        "Source": "/var/lib/docker/volumes/demovol/_data",
        "Destination": "/app",
        "Driver": "local",
        "Mode": "",
        "RW": true,
        "Propagation": ""
    }
],

docker exec demovol-container df -h

Esto demuestra que el montaje es un volumen, muestra el origen y el destino correctos y que el montaje es de lectura y escritura. Detener el contenedor y eliminar el volumen.

docker stop demovol-container

docker rm demovol-container

docker volume rm demovol

Guía de Laboratorio: Usar Docker Volumes con un contenedor NGINX para un Sitio Web

En esta guía, configuraremos un contenedor NGINX para servir un sitio web sencillo utilizando un Docker Volume. Veremos cómo persistir los datos del sitio, de manera que estos permanezcan disponibles incluso si el contenedor se elimina y se recrea.

Paso 1: Crear un Docker Volume

Primero, crearemos un volumen en Docker para almacenar los datos del sitio web de forma persistente.

docker volume create webdata

Este comando crea un volumen llamado webdata, que usaremos para almacenar los archivos de nuestro sitio web.

Paso 2: Crear el contenido del sitio web

Crea un archivo index.html localmente para usarlo como contenido del sitio web.

Crea una carpeta temporal:
```
mkdir ~/nginx-site
```

Crea un archivo index.html dentro de esta carpeta:

echo "<h1>Bienvenido a mi sitio web</h1>" > ~/nginx-site/index.html

Paso 3: Iniciar el contenedor NGINX con el volumen

Montaremos el volumen webdata en el contenedor para que sirva los archivos del sitio web.

docker run -d \
  --name nginx-container \
  -p 8080:80 \
  -v webdata:/usr/share/nginx/html \
  nginx

Este comando: - Inicia un contenedor NGINX en segundo plano (-d). - Lo expone en el puerto 8080 de tu máquina host. - Monta el volumen webdata en el directorio /usr/share/nginx/html, que es donde NGINX busca los archivos a servir.

Paso 4: Copiar el contenido del sitio al volumen

Los volúmenes se encuentran vacíos al principio, por lo que necesitamos copiar el archivo index.html creado en el Paso 2 al volumen.

Usa un contenedor temporal para copiar el archivo al volumen:

docker run --rm \
  -v ~/nginx-site:/site \
  -v webdata:/usr/share/nginx/html \
  busybox cp /site/index.html /usr/share/nginx/html/

Verifica que el archivo se haya copiado al volumen:

docker run --rm \
  -v webdata:/data \
  busybox ls /data

Deberías ver el archivo index.html listado.

Paso 5: Probar el sitio web

Utilizar el siguiente comando:

curl http://localhost:8080

Deberías ver el mensaje:
"Bienvenido a mi sitio web"

Paso 6: Eliminar el contenedor y recrearlo

Elimina el contenedor NGINX actual:
```
docker rm -f nginx-container
```

Vuelve a crear el contenedor usando el volumen persistente:

docker run -d \
  --name nginx-container \
  -p 8080:80 \
  -v webdata:/usr/share/nginx/html \
  nginx

Verifica nuevamente el sitio web:
```
curl http://localhost:8080
```

El sitio web debería seguir mostrándose, confirmando que los datos se han mantenido en el volumen.

Paso 7: Limpieza

Si ya no necesitas este entorno, puedes eliminar el contenedor y el volumen.

Eliminar el contenedor:
```
docker rm -f nginx-container
```
Eliminar el volumen:
```
docker volume rm webdata
```
Eliminar la carpeta temporal:
```
rm -Rf ~/nginx-site
```

Conclusión

¡Y eso es todo! Has configurado un contenedor NGINX con un volumen persistente, probado la persistencia de datos al eliminar y recrear el contenedor, y aprendido cómo gestionar volúmenes en Docker.

Guía de Laboratorio: Utilizando almacenamiento persistente en Data Base Container

La presente guía descubre y aplica el uso de volúmenes compartidos para persistir data de importancia en contenedores.

Ingresar al servidor qué contiene al ambiente de laboratorio con credenciales de administración
Crear un directorio
```
sudo mkdir -pv /var/local/mysql
```
Cambiar uid y gid de forma recursiva al directorio
```
sudo chown -Rv 999:999 /var/local/mysql
```
Descargar imagen mariadb:10.7
```
sudo docker pull mariadb:10.7
```
Levantar el contenedor con la imagen de mariadb:10.7 con los siguientes parámetros (listados con - nombre completo pero, en comando abreviados):
- name=persist-db
- remove=true
- volume=/var/local/mysql:/var/lib/mysql
- environment=MYSQL_USER=user1
- environment=MYSQL_PASSWORD=demo
- environment=MYSQL_DATABASE=inventory
- environment=MYSQL_ROOT_PASSWORD=demo
```
sudo docker run --name persist-db \
-v /var/local/mysql:/var/lib/mysql \
-e MYSQL_USER=user1 \
-e MYSQL_PASSWORD=demo \
-e MYSQL_DATABASE=inventory \
-e MYSQL_ROOT_PASSWORD=demo -d mariadb:10.7
```
Listar los contenedores activos
```
sudo docker ps
```

Aplicar formato a la lista de contenedores

sudo docker ps --format="\nNAME: {{.Names}} | STATUS: {{.Status}} | IMAGE: {{.Image}}\n"

Listar contenido de directorio local
```
ls -l /var/local/mysql
```

Cambios en data

Ingrese al contenedor persist-db y agregue una tabla y un registro en la base de datos creada de mariadb

sudo docker exec -it persist-db bash

mysql -u user1 -pdemo -D inventory

CREATE TABLE customers(id INT, first_name VARCHAR(50), last_name VARCHAR (50), email VARCHAR(100));
INSERT INTO customers VALUES(1, 'Anne', 'Ketchmar', 'annek@noanswer.org');
exit

exit

Detenga el contenedor
```
sudo docker stop persist-db
```
Vea el contenido de la carpeta /var/local/mysql
```
ls -l /var/local/mysql
```
Vuelva a iniciar el contenedor
```
sudo docker start persist-db
```

Revise que el record de la tabla customers exista

sudo docker exec -it persist-db bash

mysql -u user1 -pdemo -D inventory

SELECT * FROM customers;
exit

exit

Detenga y elimine el contenedor

sudo docker stop persist-db

sudo docker rm persist-db

Verifique que la carpeta /var/local/mysql aun exista en la máquina
```
ls -l /var/local/mysql
```

Cree otro contenedor de mariadb

sudo docker run --name persist-db \
-v /var/local/mysql:/var/lib/mysql \
-e MYSQL_USER=user1 \
-e MYSQL_PASSWORD=demo \
-e MYSQL_DATABASE=inventory \
-e MYSQL_ROOT_PASSWORD=demo -d mariadb:10.7

Verifique que la tabla customers exista

sudo docker exec -it persist-db bash

mysql -u user1 -pdemo -D inventory

SELECT * FROM customers;
exit

exit

Cree una carpeta en /var/local/mysql llamada custom-dir
```
sudo mkdir /var/local/mysql/custom-dir
```
Ejecute dentro del contenedor el comando para listar los archivos dentro del directorio /var/lib/mysql
```
sudo docker exec -it persist-db ls -l /var/lib/mysql
```
Observe que el directorio custom-dir existe dentro del contenedor
Acceda al contenedor abriendo una terminal bash con docker
```
sudo docker exec -it persist-db bash
```
Cree un archivo vacío dentro de la carpeta custom-dir
```
touch /var/lib/mysql/custom-dir/example.txt
```
Salga de la terminal del contenedor
```
exit
```
Verifique los archivos del directorio custom-dir en su máquina
```
ls -l /var/local/mysql/custom-dir
```
Observe que ahora existe el archivo example.txt

Agregue el siguiente contenido al archivo example.txt

sudo vi /var/local/mysql/custom-dir/example.txt

# Este archivo no afecta al funcionamiento de MariaDB
# Su contenido no se lee por ningún servicio
Uso: Prueba de almacenamiento persistente en Docker

Guarde los cambios

Verifique en el contenedor de mariadb el contenido del archivo example.txt

sudo docker exec -it persist-db cat /var/lib/mysql/custom-dir/example.txt

Limpieza de ambiente

Limpiar el ambiente ejecutando

sudo docker stop persist-db
sudo docker rm persist-db
sudo rm -r /var/local/mysql
sudo docker image rm mariadb:10.7