Cómo usar el comando docker volume create para gestionar datos

DockerDockerBeginner
Practicar Ahora

💡 Este tutorial está traducido por IA desde la versión en inglés. Para ver la versión original, puedes hacer clic aquí

Introducción

En este laboratorio, aprenderá cómo gestionar de manera efectiva la persistencia de datos en Docker utilizando el comando docker volume create. Exploraremos el proceso fundamental de creación de volúmenes básicos, que son el método preferido para almacenar datos de contenedores debido a su naturaleza gestionada por Docker y su facilidad de copia de seguridad/migración en comparación con los montajes de enlace (bind mounts).

Basándonos en los conceptos básicos, luego profundizará en la creación de volúmenes con controladores (drivers) y opciones específicas para adaptar su comportamiento. Además, el laboratorio lo guiará a través de la creación de volúmenes locales con opciones de montaje personalizadas y demostrará cómo aprovechar NFS para crear volúmenes locales, brindando flexibilidad para diversos escenarios de almacenamiento de datos.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL docker(("Docker")) -.-> docker/ImageOperationsGroup(["Image Operations"]) docker(("Docker")) -.-> docker/VolumeOperationsGroup(["Volume Operations"]) docker(("Docker")) -.-> docker/ContainerOperationsGroup(["Container Operations"]) docker/ContainerOperationsGroup -.-> docker/exec("Execute Command in Container") docker/ContainerOperationsGroup -.-> docker/inspect("Inspect Container") docker/ContainerOperationsGroup -.-> docker/create("Create Container") docker/ImageOperationsGroup -.-> docker/pull("Pull Image from Repository") docker/VolumeOperationsGroup -.-> docker/volume("Manage Volumes") subgraph Lab Skills docker/exec -.-> lab-555258{{"Cómo usar el comando docker volume create para gestionar datos"}} docker/inspect -.-> lab-555258{{"Cómo usar el comando docker volume create para gestionar datos"}} docker/create -.-> lab-555258{{"Cómo usar el comando docker volume create para gestionar datos"}} docker/pull -.-> lab-555258{{"Cómo usar el comando docker volume create para gestionar datos"}} docker/volume -.-> lab-555258{{"Cómo usar el comando docker volume create para gestionar datos"}} end

Crear un volumen básico

En este paso, aprenderá cómo crear un volumen básico de Docker. Los volúmenes son la forma preferida de persistir los datos generados y utilizados por los contenedores de Docker. Si bien los montajes de enlace (bind mounts) también son una opción, los volúmenes son gestionados por Docker y generalmente son más fáciles de respaldar o migrar.

Primero, creemos un volumen simple utilizando el comando docker volume create. Nombraremos este volumen myvolume.

docker volume create myvolume

Debería ver el nombre del volumen impreso en la consola, lo que confirma su creación.

Ahora, inspeccionemos el volumen para ver sus detalles utilizando el comando docker volume inspect. Esto nos mostrará información como el controlador (driver) del volumen, el punto de montaje (mountpoint) y el alcance (scope).

docker volume inspect myvolume

La salida proporcionará detalles sobre el volumen. Presta atención al campo Mountpoint, que muestra la ubicación en la máquina host donde se almacenan los datos del volumen. Docker gestiona esta ubicación y, en general, se debe evitar modificar archivos directamente en este directorio.

A continuación, ejecutaremos un contenedor y adjuntaremos este volumen a él. Utilizaremos la imagen ubuntu y montaremos myvolume en el directorio /app dentro del contenedor. También ejecutaremos un comando simple para escribir algunos datos en un archivo dentro del volumen montado.

Primero, descarga la imagen ubuntu si no la tienes localmente.

docker pull ubuntu

Ahora, ejecuta el contenedor y escribe datos en el volumen.

docker run -d --name mycontainer -v myvolume:/app ubuntu bash -c "echo 'Hello from the volume!' > /app/greeting.txt && tail -f /dev/null"

Desglosemos este comando:

  • docker run -d: Ejecuta el contenedor en modo desatendido (en segundo plano).
  • --name mycontainer: Asigna el nombre mycontainer al contenedor.
  • -v myvolume:/app: Monta el volumen llamado myvolume en el directorio /app dentro del contenedor.
  • ubuntu: Especifica la imagen a utilizar.
  • bash -c "echo 'Hello from the volume!' > /app/greeting.txt && tail -f /dev/null": Ejecuta un comando de bash dentro del contenedor. Escribe la cadena "Hello from the volume!" en un archivo llamado greeting.txt en el directorio /app (que es el volumen montado) y luego ejecuta tail -f /dev/null para mantener el contenedor en ejecución.

Para verificar que los datos se hayan escrito en el volumen, podemos ejecutar un comando dentro del contenedor en ejecución para leer el archivo.

docker exec mycontainer cat /app/greeting.txt

Debería ver la salida "Hello from the volume!", lo que confirma que los datos se escribieron correctamente en el volumen desde dentro del contenedor.

Finalmente, detengamos y eliminemos el contenedor. El volumen persistirá incluso después de que se elimine el contenedor.

docker stop mycontainer
docker rm mycontainer

Crear un volumen con un controlador (driver) y opciones específicas

En este paso, aprenderá cómo crear un volumen de Docker utilizando un controlador (driver) específico y proporcionando opciones específicas del controlador. Si bien el controlador local predeterminado es suficiente para muchos casos de uso, Docker admite varios controladores de volumen para diferentes backends de almacenamiento, como almacenamiento en red o almacenamiento en la nube.

Seguiremos utilizando el controlador local, pero demostraremos cómo especificarlo explícitamente y pasar opciones. El controlador local admite opciones como type, device y o para especificar el tipo de sistema de archivos, el dispositivo a montar y las opciones de montaje, respectivamente.

Creemos un volumen llamado myvolume2 utilizando el controlador local y especifiquemos algunas opciones. Para este ejemplo, utilizaremos el tipo de sistema de archivos tmpfs, que almacena datos en memoria. Esto es útil para datos temporales que no necesitan persistir después de reinicios del host.

docker volume create --driver local --opt type=tmpfs --opt device=tmpfs --opt o=size=100m myvolume2

Desglosemos este comando:

  • docker volume create: El comando para crear un volumen.
  • --driver local: Especifica explícitamente el controlador de volumen local.
  • --opt type=tmpfs: Pasa la opción type=tmpfs al controlador, especificando el tipo de sistema de archivos.
  • --opt device=tmpfs: Pasa la opción device=tmpfs al controlador, especificando el dispositivo. Para tmpfs, el dispositivo también es tmpfs.
  • --opt o=size=100m: Pasa la opción o=size=100m al controlador. La opción o se utiliza para pasar opciones de montaje. En este caso, estamos estableciendo el tamaño máximo del volumen tmpfs en 100 megabytes.
  • myvolume2: El nombre del volumen a crear.

Debería ver el nombre del volumen impreso en la consola una vez que se haya creado correctamente.

Ahora, inspeccionemos el volumen para ver el controlador y las opciones que se aplicaron.

docker volume inspect myvolume2

En la salida, debería ver el campo Driver establecido en local y el campo Options enumerando las opciones que proporcionamos (type=tmpfs, device=tmpfs, o=size=100m). El Mountpoint mostrará dónde se monta este volumen tmpfs en el host.

A continuación, ejecutaremos un contenedor y adjuntaremos este nuevo volumen a él. Utilizaremos la imagen ubuntu nuevamente y montaremos myvolume2 en el directorio /data dentro del contenedor.

Primero, descarga la imagen ubuntu si no la tienes localmente (aunque probablemente la tengas del paso anterior).

docker pull ubuntu

Ahora, ejecuta el contenedor y adjunta el volumen.

docker run -d --name mycontainer2 -v myvolume2:/data ubuntu tail -f /dev/null

Este comando ejecuta un contenedor ubuntu llamado mycontainer2 en modo desatendido y monta myvolume2 en /data. tail -f /dev/null mantiene el contenedor en ejecución.

Dado que myvolume2 es un volumen tmpfs, cualquier dato escrito en /data dentro del contenedor se almacenará en memoria y no persistirá después de que se detenga y elimine el contenedor, o si se reinicia el host.

Detengamos y eliminemos el contenedor.

docker stop mycontainer2
docker rm mycontainer2

El volumen myvolume2 todavía existe, pero su contenido (si se escribió alguno) se ha perdido porque es un volumen tmpfs.

Crear un volumen local con opciones de montaje

En este paso, aprenderá cómo crear un volumen local de Docker y especificar opciones de montaje. Las opciones de montaje le permiten controlar cómo se monta el sistema de archivos, como establecer permisos, habilitar características específicas o optimizar el rendimiento.

Crearemos un volumen local llamado myvolume3 y usaremos la opción o para especificar opciones de montaje. Para este ejemplo, estableceremos las opciones uid y gid para garantizar que los archivos creados en el volumen por un contenedor sean propiedad de un usuario y grupo específicos en el host. Esto puede ser útil para gestionar permisos al compartir datos entre contenedores y el host.

Primero, creemos un directorio en el host que usaremos como origen para nuestro volumen. Esto no es estrictamente necesario para un volumen local estándar, pero ayuda a ilustrar cómo las opciones de montaje pueden afectar el sistema de archivos subyacente.

mkdir -p ~/project/myvolumedata

Ahora, creemos el volumen myvolume3 utilizando el controlador local y especifiquemos la opción o con uid y gid. Usaremos el ID de usuario y grupo del usuario labex actual. Puedes encontrar tu ID de usuario y grupo utilizando los comandos id -u e id -g.

USER_ID=$(id -u)
GROUP_ID=$(id -g)
docker volume create --driver local --opt type=none --opt device=/home/labex/project/myvolumedata --opt o=bind,uid=$USER_ID,gid=$GROUP_ID myvolume3

Desglosemos este comando:

  • docker volume create: El comando para crear un volumen.
  • --driver local: Especifica el controlador de volumen local.
  • --opt type=none: Especifica que no se debe crear automáticamente un tipo de sistema de archivos. Estamos enlazando a un directorio existente.
  • --opt device=/home/labex/project/myvolumedata: Especifica el dispositivo a montar, que es el directorio que creamos en el host. Tenga en cuenta el uso de la ruta absoluta /home/labex/project/myvolumedata.
  • --opt o=bind,uid=$USER_ID,gid=$GROUP_ID: Pasa las opciones de montaje.
    • bind: Especifica un montaje enlazado (bind mount), vinculando el volumen al dispositivo especificado (nuestro directorio del host).
    • uid=$USER_ID: Establece el ID de usuario para los archivos creados en el volumen al ID del usuario actual.
    • gid=$GROUP_ID: Establece el ID de grupo para los archivos creados en el volumen al ID de grupo del usuario actual.
  • myvolume3: El nombre del volumen.

Debería ver el nombre del volumen impreso en la consola.

Ahora, inspeccionemos el volumen para ver las opciones.

docker volume inspect myvolume3

En la salida, debería ver el Driver como local, las Options incluyendo type=none, device=/home/labex/project/myvolumedata y o=bind,uid=...,gid=... (con tus IDs de usuario y grupo). El Mountpoint será el mismo que la ruta del device.

A continuación, ejecutaremos un contenedor y adjuntaremos este volumen. Usaremos la imagen ubuntu y montaremos myvolume3 en /app dentro del contenedor. Luego, crearemos un archivo dentro del directorio /app del contenedor y comprobaremos su propiedad en el host.

Primero, descarga la imagen ubuntu si es necesario.

docker pull ubuntu

Ahora, ejecuta el contenedor y crea un archivo en el volumen montado.

docker run --rm -v myvolume3:/app ubuntu bash -c "echo 'Testing ownership' > /app/testfile.txt && ls -l /app/testfile.txt"

Este comando ejecuta un contenedor ubuntu, monta myvolume3 en /app, escribe "Testing ownership" en /app/testfile.txt y luego lista los detalles del archivo dentro del contenedor. Debería ver el archivo listado con propiedad de root dentro del contenedor, ya que los contenedores generalmente se ejecutan como root por defecto.

Ahora, comprobemos la propiedad del archivo en la máquina host en el directorio ~/project/myvolumedata.

ls -l ~/project/myvolumedata/testfile.txt

Debería ver que el archivo testfile.txt es propiedad del usuario y grupo labex en el host, gracias a las opciones de montaje uid y gid que especificamos al crear el volumen.

Finalmente, limpiemos el directorio creado.

rm -rf ~/project/myvolumedata

Crear un volumen local utilizando NFS

En este paso, aprenderá cómo crear un volumen local de Docker que utiliza un recurso compartido NFS como almacenamiento backend. Esto permite que los contenedores almacenen datos en un dispositivo de almacenamiento conectado a la red, lo que hace que los datos sean accesibles desde múltiples hosts y proporciona una solución de almacenamiento centralizada.

Para utilizar NFS con el controlador de volumen local, debe especificar la dirección del servidor NFS y la ruta al directorio compartido utilizando la opción device, y el tipo de sistema de archivos como nfs utilizando la opción type. También debe proporcionar las opciones de montaje adecuadas utilizando la opción o.

Para este entorno de laboratorio, simularemos un recurso compartido NFS utilizando la dirección de bucle invertido 127.0.0.1 y un directorio en el host. Nota: En un escenario del mundo real, reemplazaría 127.0.0.1 con la dirección IP real o el nombre de host de su servidor NFS y /path/to/nfs/share con la ruta exportada en el servidor NFS.

Primero, creemos un directorio en el host que actuará como nuestro recurso compartido NFS simulado.

mkdir -p ~/project/nfs_share

Ahora, creemos el volumen myvolume4 utilizando el controlador local con opciones de NFS.

sudo docker volume create --driver local --opt type=nfs --opt device=127.0.0.1:/home/labex/project/nfs_share --opt o=addr=127.0.0.1,rw myvolume4

Desglosemos este comando:

  • sudo docker volume create: Usamos sudo porque la creación de volúmenes NFS a menudo requiere privilegios de root para realizar la operación de montaje en el host.
  • --driver local: Especifica el controlador de volumen local.
  • --opt type=nfs: Especifica el tipo de sistema de archivos como NFS.
  • --opt device=127.0.0.1:/home/labex/project/nfs_share: Especifica el dispositivo NFS. Esto está en el formato nfs_server_address:/exported_path. Estamos utilizando la dirección de bucle invertido y el directorio que acabamos de crear. Tenga en cuenta el uso de la ruta absoluta /home/labex/project/nfs_share.
  • --opt o=addr=127.0.0.1,rw: Pasa opciones de montaje al cliente NFS.
    • addr=127.0.0.1: Especifica la dirección del servidor NFS.
    • rw: Monta el recurso compartido con permisos de lectura y escritura.
  • myvolume4: El nombre del volumen.

Debería ver el nombre del volumen impreso en la consola una vez que se haya creado correctamente.

Ahora, inspeccionemos el volumen para ver los detalles específicos de NFS.

docker volume inspect myvolume4

En la salida, debería ver el Driver como local, y las Options deberían incluir type=nfs, device=127.0.0.1:/home/labex/project/nfs_share y o=addr=127.0.0.1,rw. El Mountpoint mostrará dónde se monta este volumen NFS en el host por Docker.

A continuación, ejecutaremos un contenedor y adjuntaremos este volumen NFS. Usaremos la imagen ubuntu y montaremos myvolume4 en /data dentro del contenedor. Luego, crearemos un archivo dentro del directorio /data del contenedor y verificaremos su existencia en el recurso compartido NFS simulado del host.

Primero, descarga la imagen ubuntu si es necesario.

docker pull ubuntu

Ahora, ejecuta el contenedor y crea un archivo en el volumen montado.

docker run --rm -v myvolume4:/data ubuntu bash -c "echo 'Data on NFS' > /data/nfs_test.txt && ls -l /data/nfs_test.txt"

Este comando ejecuta un contenedor ubuntu, monta myvolume4 en /data, escribe "Data on NFS" en /data/nfs_test.txt y lista los detalles del archivo dentro del contenedor.

Ahora, comprobemos la existencia del archivo en la máquina host en el directorio ~/project/nfs_share.

ls -l ~/project/nfs_share/nfs_test.txt

Debería ver el archivo nfs_test.txt listado, lo que confirma que los datos escritos dentro del contenedor utilizando el volumen NFS están presentes en el recurso compartido NFS simulado del host.

Finalmente, limpiemos el directorio creado.

rm -rf ~/project/nfs_share

Resumen

En este laboratorio, aprendiste cómo crear y gestionar volúmenes de Docker utilizando el comando docker volume create. Comenzaste creando un volumen básico e inspeccionando sus detalles, comprendiendo cómo Docker gestiona la ubicación de almacenamiento de datos. Luego, practicaste adjuntar este volumen a un contenedor y escribir datos en él, demostrando cómo los volúmenes proporcionan almacenamiento persistente para los datos de los contenedores. El laboratorio también cubrió la creación de volúmenes con controladores y opciones específicas, incluyendo volúmenes locales con opciones de montaje y volúmenes locales que utilizan NFS, mostrando la flexibilidad y los diversos casos de uso de los volúmenes de Docker para diferentes necesidades de almacenamiento.