Compartir comentarios
Las respuestas se generan en base a la documentación.

Compartir archivos locales con contenedores

Tabla de contenidos

Explicación

Cada contenedor tiene todo lo que necesita para funcionar sin depender de ninguna dependencia preinstalada en la máquina host. Dado que los contenedores se ejecutan de forma aislada, tienen una influencia mínima en el host y en otros contenedores. Este aislamiento tiene una gran ventaja: los contenedores minimizan los conflictos con el sistema host y otros contenedores. Sin embargo, este aislamiento también significa que los contenedores no pueden acceder directamente a los datos en la máquina host de forma predeterminada.

Considera un escenario en el que tienes un contenedor de aplicación web que requiere acceso a los ajustes de configuración almacenados en un archivo de tu sistema host. Este archivo puede contener datos confidenciales como credenciales de base de datos o claves de API. Almacenar dicha información confidencial directamente dentro de la imagen del contenedor plantea riesgos de seguridad, especialmente al compartir la imagen. Para abordar este desafío, Docker ofrece opciones de almacenamiento que cierran la brecha entre el aislamiento del contenedor y los datos de tu máquina host.

Docker ofrece dos opciones principales de almacenamiento para persistir datos y compartir archivos entre la máquina host y los contenedores: volúmenes y montajes de unión (bind mounts).

Volúmenes frente a montajes de unión

Si deseas asegurarte de que los datos generados o modificados dentro del contenedor persistan incluso después de que el contenedor deje de ejecutarse, optarías por un volumen. Consulta Persistir datos del contenedor para obtener más información sobre los volúmenes y sus casos de uso.

Si tienes archivos o directorios específicos en tu sistema host que deseas compartir directamente con tu contenedor, como archivos de configuración o código de desarrollo, entonces utilizarías un montaje de unión (bind mount). Es como abrir un portal directo entre tu host y el contenedor para compartir. Los montajes de unión son ideales para entornos de desarrollo donde el acceso a archivos en tiempo real y el intercambio entre el host y el contenedor son cruciales.

Compartir archivos entre un host y un contenedor

Tanto la bandera -v (o --volume) como la bandera --mount utilizadas con el comando docker run te permiten compartir archivos o directorios entre tu máquina local (host) y un contenedor de Docker. Sin embargo, existen algunas diferencias clave en su comportamiento y uso.

La bandera -v es más sencilla y conveniente para operaciones básicas de volumen o montaje de unión. Si la ubicación del host no existe al usar -v o --volume, se creará automáticamente un directorio.

Imagina que eres un desarrollador que trabaja en un proyecto. Tienes un directorio de origen en tu máquina de desarrollo donde reside tu código. Cuando compilas o construyes tu código, los artefactos generados (código compilado, ejecutables, imágenes, etc.) se guardan en un subdirectorio separado dentro de tu directorio de origen. En los siguientes ejemplos, este subdirectorio es /HOST/PATH. Ahora deseas que estos artefactos de compilación sean accesibles dentro de un contenedor de Docker que ejecuta tu aplicación. Además, deseas que el contenedor acceda automáticamente a los artefactos de compilación más recientes cada vez que reconstruyas tu código.

Aquí tienes una forma de usar docker run para iniciar un contenedor utilizando un montaje de unión y asignarlo a la ubicación del archivo del contenedor.

$ docker run -v /HOST/PATH:/CONTAINER/PATH -it nginx

La bandera --mount ofrece funciones más avanzadas y un control granular, lo que la hace adecuada para escenarios de montaje complejos o implementaciones de producción. De forma predeterminada, si utilizas --mount para montar en unión un archivo o directorio que aún no existe en el host de Docker, el comando docker run no lo crea automáticamente por ti, sino que genera un error.

$ docker run --mount type=bind,source=/HOST/PATH,target=/CONTAINER/PATH,readonly nginx
Note

Docker recomienda utilizar la sintaxis --mount en lugar de -v. Proporciona un mejor control sobre el proceso de montaje y evita posibles problemas con directorios faltantes.

Permisos de archivos para el acceso de Docker a archivos del host

Al utilizar montajes de unión, es crucial asegurarse de que Docker tenga los permisos necesarios para acceder al directorio del host. Para otorgar acceso de lectura/escritura, puedes usar la bandera :ro (solo lectura) o :rw (lectura y escritura) con la bandera -v o --mount durante la creación del contenedor. Por ejemplo, el siguiente comando otorga permiso de acceso de lectura y escritura.

$ docker run -v HOST-DIRECTORY:/CONTAINER-DIRECTORY:rw nginx

Los montajes de unión de solo lectura permiten que el contenedor aceda a los archivos montados en el host para lectura, pero no puede cambiarlos ni eliminarlos. Con los montajes de unión de lectura y escritura, los contenedores pueden modificar o eliminar los archivos montados, y estos cambios o eliminaciones también se reflejarán en el sistema host. Los montajes de unión de solo lectura garantizan que los archivos del host no puedan ser modificados o eliminados accidentalmente por un contenedor.

Uso compartido de archivos sincronizado (Synchronized File Share)

A medida que tu base de código crece, los métodos tradicionales para compartir archivos, como los montajes de unión, pueden volverse ineficientes o lentos, especialmente en entornos de desarrollo donde es necesario el acceso frecuente a los archivos. Synchronized file shares (uso compartido de archivos sincronizado) mejoran el rendimiento de los montajes de unión al aprovechar las cachés sincronizadas del sistema de archivos. Esta optimización garantiza que el acceso a los archivos entre el host y la máquina virtual (VM) sea rápido y eficiente.

Pruébalo

En esta guía práctica, practicarás cómo crear y utilizar un montaje de unión para compartir archivos entre un host y un contenedor.

Ejecutar un contenedor

  1. Descarga e instala Docker Desktop.

  2. Inicia un contenedor utilizando la imagen de httpd con el siguiente comando:

    $ docker run -d -p 8080:80 --name my_site httpd:2.4

    Esto iniciará el servicio httpd en segundo plano y publicará la página web en el puerto 8080 del host.

  3. Abre el navegador y accede a http://localhost:8080 o utiliza el comando curl para verificar si está funcionando correctamente o no.

    $ curl localhost:8080

Usar un montaje de unión

Utilizando un montaje de unión, puedes asignar el archivo de configuración en tu computadora host a una ubicación específica dentro del contenedor. En este ejemplo, verás cómo cambiar la apariencia y el estilo de la página web mediante un montaje de unión:

  1. Elimina el contenedor existente utilizando el Panel de Docker Desktop:

    Una captura de pantalla del Panel de Docker Desktop que muestra cómo eliminar el contenedor httpd

  2. Crea un nuevo directorio llamado public_html en tu sistema host.

    $ mkdir public_html

  3. Navega al directorio recién creado public_html y crea un archivo llamado index.html con el siguiente contenido. Este es un documento HTML básico que crea una página web simple que te da la bienvenida con una ballena amigable.

    <!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <title>My Website with a Whale & Docker!</title>
  </head>
  <body>
    <h1>Whalecome!!</h1>
    <p>Look! There's a friendly whale greeting you!</p>
    <pre id="docker-art">
   ##         .
  ## ## ##        ==
 ## ## ## ## ##    ===
 /"""""""""""""""""\___/ ===
{                       /  ===-
\______ O           __/
\    \         __/
 \____\_______/

Hello from Docker!
</pre
    >
  </body>
</html>

  4. Es hora de ejecutar el contenedor. Los ejemplos de --mount y -v producen el mismo resultado. No puedes ejecutarlos ambos a menos que elimines el contenedor my_site después de ejecutar el primero.

    $ docker run -d --name my_site -p 8080:80 -v .:/usr/local/apache2/htdocs/ httpd:2.4

    $ docker run -d --name my_site -p 8080:80 --mount type=bind,source=./,target=/usr/local/apache2/htdocs/ httpd:2.4
    Tip

    Al utilizar la bandera -v o --mount en Windows PowerShell, debes proporcionar la ruta absoluta de tu directorio en lugar de simplemente ./. Esto se debe a que PowerShell maneja las rutas relativas de manera diferente a bash (comúnmente utilizado en entornos Mac y Linux).

    Con todo funcionando, deberías poder acceder al sitio a través de http://localhost:8080 y encontrar una nueva página web que te da la bienvenida con una ballena amigable.

Acceder al archivo en el Panel de Docker Desktop

  1. Puedes ver los archivos montados dentro de un contenedor seleccionando la pestaña Files del contenedor y luego seleccionando un archivo dentro del directorio /usr/local/apache2/htdocs/. Luego, selecciona Open file editor.

    Una captura de pantalla del Panel de Docker Desktop que muestra los archivos montados dentro de un contenedor

  2. Elimina el archivo en el host y verifica que el archivo también se haya eliminado en el contenedor. Verás que los archivos ya no existen bajo Files en el Panel de Docker Desktop.

    Una captura de pantalla del Panel de Docker Desktop que muestra los archivos eliminados dentro de un contenedor

  3. Recrea el archivo HTML en el sistema host y observa cómo el archivo vuelve a aparecer bajo la pestaña Files bajo Containers en el Panel de Docker Desktop. Para este momento, también podrás acceder al sitio.

Detener el contenedor

El contenedor continúa ejecutándose hasta que lo detengas.

  1. Ve a la vista de Containers en el Panel de Docker Desktop.

  2. Localiza el contenedor que deseas detener.

  3. Selecciona la acción Stop en la columna Actions.

Recursos adicionales

Los siguientes recursos te ayudarán a aprender más sobre los montajes de unión:

Siguientes pasos

Ahora que has aprendido a compartir archivos locales con contenedores, es hora de aprender sobre aplicaciones multicontenedor.

Aplicaciones multicontenedor