Cómo usar el comando docker compose cp para copiar archivos

Introducción

En este laboratorio, aprenderás a utilizar el comando docker compose cp para copiar archivos y directorios entre un contenedor de servicio y el sistema de archivos local. Comenzaremos configurando un proyecto simple de Docker Compose, incluyendo la instalación de Docker Compose y la creación de un archivo básico docker-compose.yml con un servicio basado en la imagen de Ubuntu.

Después de configurar el proyecto, practicarás copiando un archivo desde el contenedor de servicio a tu máquina local, y luego copiando un archivo desde tu máquina local al contenedor de servicio. Finalmente, aprenderás cómo copiar un directorio completo desde el contenedor de servicio al sistema de archivos local, demostrando la flexibilidad del comando docker compose cp para gestionar datos en tus entornos de Docker Compose.

Skills Graph

Preparar un proyecto simple de Docker Compose

En este paso, prepararemos un proyecto simple de Docker Compose. Como Docker Compose no viene preinstalado en el entorno de LabEx, primero lo instalaremos. Docker Compose es una herramienta para definir y ejecutar aplicaciones Docker con múltiples contenedores. Con Compose, usas un archivo YAML para configurar los servicios de tu aplicación. Luego, con un solo comando, creas e inicias todos los servicios desde tu configuración.

Primero, instalemos Docker Compose. Descargaremos el binario de Docker Compose y lo haremos ejecutable.

sudo curl -L "https://github.com/docker/compose/releases/download/v2.20.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

Ahora, verifiquemos la instalación comprobando la versión de Docker Compose.

docker-compose --version

Deberías ver una salida similar a Docker Compose version v2.20.2.

A continuación, crearemos un proyecto simple de Docker Compose. Crearemos un directorio para nuestro proyecto y luego un archivo docker-compose.yml dentro de él. Este archivo definirá un servicio simple usando la imagen ubuntu.

mkdir ~/project/my-compose-app
cd ~/project/my-compose-app
nano docker-compose.yml

En el editor nano, pega el siguiente contenido en el archivo docker-compose.yml:

version: "3.8"
services:
  my-service:
    image: ubuntu:latest
    command: tail -f /dev/null

Presiona Ctrl + X, luego Y, y Enter para guardar y salir del editor.

Analicemos el archivo docker-compose.yml:

• version: '3.8' especifica la versión del formato del archivo Docker Compose.
• services: define los servicios que componen tu aplicación.
• my-service: es el nombre de nuestro servicio.
• image: ubuntu:latest especifica la imagen Docker a usar para este servicio. Usamos la última versión de la imagen Ubuntu.
• command: tail -f /dev/null es el comando que se ejecutará cuando el contenedor inicie. Este comando mantiene el contenedor ejecutándose indefinidamente sin consumir recursos significativos, lo cual es útil para pruebas y depuración.

Antes de iniciar el servicio, necesitamos descargar la imagen ubuntu:latest.

docker pull ubuntu:latest

Ahora, podemos iniciar el servicio usando el comando docker-compose up. La bandera -d ejecuta los contenedores en modo detached (separado), lo que significa que correrán en segundo plano.

docker-compose up -d

Deberías ver una salida indicando que el servicio está siendo creado e iniciado.

Finalmente, verifiquemos el estado del servicio en ejecución usando el comando docker-compose ps.

docker-compose ps

Deberías ver una salida mostrando que el contenedor my-service está en ejecución.

Copiar un archivo de un contenedor de servicio al sistema de archivos local

En este paso, aprenderemos cómo copiar un archivo desde un contenedor Docker en ejecución a tu sistema de archivos local. Esta es una tarea común cuando necesitas recuperar logs, archivos de configuración u otros datos generados dentro de un contenedor.

Usaremos el comando docker cp para este propósito. El comando docker cp copia archivos/directorios entre un contenedor y el sistema de archivos local. La sintaxis es docker cp <container>:<src_path> <dest_path> para copiar desde un contenedor al sistema de archivos local, y docker cp <src_path> <container>:<dest_path> para copiar desde el sistema de archivos local a un contenedor.

Primero, creemos un archivo simple dentro de nuestro contenedor my-service en ejecución. Usaremos el comando docker exec para ejecutar un comando dentro del contenedor. El comando docker exec ejecuta un nuevo comando en un contenedor en ejecución.

Asegúrate de estar en el directorio ~/project/my-compose-app.

cd ~/project/my-compose-app
docker-compose exec my-service bash -c "echo 'This is a test file inside the container.' > /tmp/container_file.txt"

Este comando ejecuta un shell bash dentro del contenedor my-service y luego ejecuta el comando echo para crear un archivo llamado /tmp/container_file.txt con cierto contenido.

Ahora, copiemos este archivo del contenedor a nuestro sistema de archivos local. Lo copiaremos al directorio actual (~/project/my-compose-app).

docker-compose cp my-service:/tmp/container_file.txt .

El comando docker-compose cp es similar a docker cp, pero funciona con nombres de servicio definidos en tu archivo docker-compose.yml. my-service es el nombre de nuestro servicio, /tmp/container_file.txt es la ruta del archivo dentro del contenedor, y . representa el directorio actual en nuestro sistema de archivos local.

Después de ejecutar el comando, deberías ver el archivo container_file.txt en tu directorio ~/project/my-compose-app. Verifiquemos su existencia y contenido.

ls container_file.txt
cat container_file.txt

Deberías ver el nombre del archivo listado y el contenido "This is a test file inside the container." impreso en la consola.

Copiar un archivo del sistema de archivos local a un contenedor de servicio

En este paso, aprenderemos cómo copiar un archivo desde tu sistema de archivos local a un contenedor Docker en ejecución. Esto es útil cuando necesitas agregar archivos de configuración, scripts u otros datos a un contenedor después de que ha sido iniciado.

Nuevamente usaremos el comando docker cp, pero esta vez en la dirección opuesta: docker cp <src_path> <container>:<dest_path>.

Primero, creemos un archivo simple en nuestro sistema de archivos local dentro del directorio ~/project/my-compose-app.

cd ~/project/my-compose-app
echo "This file is from the local filesystem." > local_file.txt

Ahora, copiemos este local_file.txt desde nuestro sistema de archivos local al directorio /tmp/ dentro del contenedor my-service.

docker-compose cp local_file.txt my-service:/tmp/

Aquí se usa el comando docker-compose cp. local_file.txt es la ruta del archivo en nuestro sistema de archivos local, my-service es el nombre de nuestro servicio, y /tmp/ es el directorio destino dentro del contenedor.

Para verificar que el archivo se copió correctamente, ejecutaremos un comando dentro del contenedor para comprobar el archivo y mostrar su contenido.

docker-compose exec my-service cat /tmp/local_file.txt

Este comando ejecuta cat /tmp/local_file.txt dentro del contenedor my-service. Deberías ver el contenido "This file is from the local filesystem." impreso en tu consola, confirmando que el archivo se copió correctamente.

Copiar un directorio de un contenedor de servicio al sistema de archivos local

En este paso, aprenderemos cómo copiar un directorio completo desde un contenedor Docker en ejecución a tu sistema de archivos local. Esto es útil para recuperar directorios de salida de aplicaciones, directorios de logs o cualquier otra estructura de directorios generada dentro del contenedor.

Usaremos nuevamente el comando docker cp, similar a copiar un archivo, pero especificando una ruta de directorio.

Primero, creemos un directorio y algunos archivos dentro de él en nuestro contenedor my-service en ejecución. Usaremos docker-compose exec para ejecutar comandos dentro del contenedor.

Asegúrate de estar en el directorio ~/project/my-compose-app.

cd ~/project/my-compose-app
docker-compose exec my-service bash -c "mkdir /tmp/container_dir && echo 'File 1' > /tmp/container_dir/file1.txt && echo 'File 2' > /tmp/container_dir/file2.txt"

Este comando crea un directorio llamado /tmp/container_dir dentro del contenedor my-service y luego crea dos archivos, file1.txt y file2.txt, dentro de ese directorio.

Ahora, copiemos este directorio completo desde el contenedor a nuestro sistema de archivos local. Lo copiaremos al directorio actual (~/project/my-compose-app).

docker-compose cp my-service:/tmp/container_dir .

Aquí se usa el comando docker-compose cp. my-service es el nombre de nuestro servicio, /tmp/container_dir es la ruta al directorio dentro del contenedor, y . representa el directorio actual en nuestro sistema de archivos local.

Después de ejecutar el comando, deberías ver un nuevo directorio llamado container_dir en tu directorio ~/project/my-compose-app. Verifiquemos su existencia y listemos su contenido.

ls container_dir
ls container_dir/file1.txt container_dir/file2.txt

Deberías ver listado el container_dir, y luego los nombres de los dos archivos dentro de él (file1.txt y file2.txt).

Finalmente, limpiemos los servicios de Docker Compose que iniciamos.

docker-compose down

Este comando detiene y elimina los contenedores, redes y volúmenes creados por docker-compose up.

Resumen

En este laboratorio, aprendimos a utilizar el comando docker compose cp para copiar archivos y directorios entre un contenedor de servicio y el sistema de archivos local. Comenzamos preparando un proyecto simple de Docker Compose, lo que incluyó instalar Docker Compose y crear un archivo docker-compose.yml definiendo un servicio básico utilizando la imagen de Ubuntu.

Tras configurar el proyecto, practicamos copiando un archivo desde el contenedor de servicio al sistema de archivos local, copiando un archivo desde el sistema de archivos local al contenedor de servicio, y finalmente copiando un directorio completo desde el contenedor de servicio al sistema de archivos local. Estos pasos demostraron la aplicación práctica del comando docker compose cp para gestionar la transferencia de datos en un entorno de Docker Compose.