Cómo usar el comando docker container run para gestionar contenedores

Introducción

En este laboratorio, adquirirás experiencia práctica utilizando el comando docker container run para gestionar contenedores de manera efectiva. Aprenderás a ejecutar contenedores en modo desatendido (detached mode) para su ejecución en segundo plano y asignar nombres personalizados para facilitar su identificación.

Además, explorarás cómo conectarte a contenedores en ejecución manteniendo STDIN abierto, publicar puertos del contenedor en el host para acceso externo, montar volúmenes para garantizar la persistencia de datos, y configurar contenedores estableciendo variables de entorno y añadiendo entradas de host. Estas habilidades fundamentales son esenciales para construir y gestionar aplicaciones en contenedores Docker (Dockerized applications).

Skills Graph

Ejecutar un contenedor en modo desatendido y asignarle un nombre

En este paso, aprenderás cómo ejecutar un contenedor Docker en modo desatendido (detached mode) y asignarle un nombre personalizado. Ejecutar un contenedor en modo desatendido significa que el contenedor se ejecutará en segundo plano y no verás su salida directamente en tu terminal. Asignar un nombre facilita la identificación y gestión del contenedor posteriormente.

Primero, descarguemos la imagen hello-world. Esta es una imagen muy pequeña útil para probar si Docker funciona correctamente.

docker pull hello-world

Deberías ver una salida que indica que la imagen se está descargando y luego un mensaje confirmando que se descargó exitosamente.

Ahora, ejecutemos el contenedor hello-world en modo desatendido. Usaremos el flag -d para el modo desatendido y el flag --name para asignar un nombre. Llamemos a este contenedor my-hello-world.

docker run -d --name my-hello-world hello-world

Después de ejecutar este comando, Docker imprimirá una cadena larga de caracteres, que es el ID del contenedor. Esto indica que el contenedor se ha iniciado en segundo plano.

Para verificar que el contenedor está en ejecución, puedes usar el comando docker ps. Este comando lista todos los contenedores actualmente en ejecución.

docker ps

Deberías ver una lista de contenedores en ejecución, y uno de ellos debería llamarse my-hello-world. La columna STATUS mostrará que el contenedor finalizó hace unos segundos. El contenedor hello-world está diseñado para ejecutarse brevemente, imprimir un mensaje y luego finalizar. Aunque haya finalizado, aún aparece en docker ps porque se ejecutó en modo desatendido.

Para ver todos los contenedores, incluyendo aquellos que han finalizado, puedes usar el comando docker ps -a.

docker ps -a

Esto mostrará my-hello-world en la lista, junto con su estado (Exited).

Conectarse a un contenedor en ejecución y mantener STDIN abierto

En este paso, aprenderás cómo conectarte a un contenedor en ejecución y mantener la entrada estándar (STDIN) abierta. Esto es útil para interactuar con contenedores que ejecutan procesos que esperan entrada, como una terminal (shell).

En el paso anterior, ejecutamos el contenedor hello-world, que finalizó inmediatamente. Para demostrar la conexión, necesitamos un contenedor que permanezca activo. Una forma sencilla es ejecutar una terminal interactiva en un contenedor.

Primero descarguemos la imagen ubuntu, que es una imagen base común para muchas aplicaciones.

docker pull ubuntu

Ahora, ejecutaremos un contenedor ubuntu en modo desatendido (-d), asignando un pseudo-TTY (-t) y manteniendo STDIN abierto (-i). También le asignaremos el nombre my-ubuntu. El comando que ejecutaremos dentro del contenedor es /bin/bash, la ruta al intérprete Bash.

docker run -itd --name my-ubuntu ubuntu /bin/bash

El flag -i mantiene STDIN abierto, permitiendo enviar entrada al contenedor. El flag -t asigna un pseudo-TTY, necesario para sesiones interactivas de terminal. El flag -d ejecuta el contenedor en modo desatendido.

Verás el ID del contenedor impreso en tu terminal, indicando que el contenedor se ejecuta en segundo plano.

Ahora, conectémonos al contenedor my-ubuntu usando el comando docker attach.

docker attach my-ubuntu

Tras ejecutar este comando, deberías ver el prompt del intérprete Bash dentro del contenedor Ubuntu. Ahora estás conectado a los flujos de entrada, salida y error estándar del contenedor.

Puedes interactuar con la terminal del contenedor. Por ejemplo, ejecuta el comando ls para listar archivos en el directorio actual del contenedor.

ls

Verás el contenido del directorio raíz (/) del contenedor Ubuntu.

Para desconectarte sin detener el contenedor, usa la secuencia de teclas: CTRL+p seguido de CTRL+q. Inténtalo ahora.

Volverás al prompt de tu terminal local. El contenedor sigue ejecutándose en segundo plano. Puedes verificarlo con docker ps.

docker ps

Verás my-ubuntu listado como contenedor activo.

Si presionaras simplemente CTRL+c mientras estás conectado, enviarías una señal al proceso interno (el intérprete Bash), lo que probablemente detendría el contenedor. Usar CTRL+p seguido de CTRL+q es la forma estándar de desconectarse sin detener el contenedor.

Publicar puertos del contenedor en el host

En este paso, aprenderás cómo publicar puertos desde un contenedor Docker hacia la máquina host. Esto te permitirá acceder a servicios ejecutándose dentro del contenedor desde la red de tu host.

Primero, detengamos y eliminemos el contenedor my-ubuntu del paso anterior para evitar conflictos.

docker stop my-ubuntu
docker rm my-ubuntu

Deberías ver el nombre del contenedor impreso después de cada comando, confirmando que fue detenido y eliminado.

Ahora, ejecutaremos un servidor web simple dentro de un contenedor y publicaremos su puerto en el host. Usaremos la imagen nginx, que es un servidor web popular.

Descarguemos la imagen nginx.

docker pull nginx

Ahora, ejecutaremos un contenedor nginx en modo desatendido (-d) y publicaremos el puerto 80 dentro del contenedor al puerto 8080 en la máquina host. Usaremos el flag -p para publicación de puertos, en el formato puerto_host:puerto_contenedor. También le asignaremos el nombre my-nginx.

docker run -d --name my-nginx -p 8080:80 nginx

La parte -p 8080:80 mapea el puerto 80 dentro del contenedor (donde Nginx escucha por defecto) al puerto 8080 en tu máquina host.

Deberías ver el ID del contenedor impreso, indicando que el contenedor se está ejecutando en segundo plano.

Para verificar que el puerto se publicó correctamente y el servidor web es accesible, puedes usar el comando curl en tu máquina host para acceder a localhost en el puerto 8080.

curl http://localhost:8080

Deberías ver la página HTML de bienvenida predeterminada de Nginx en la salida de tu terminal. Esto confirma que puedes acceder al servidor web Nginx ejecutándose dentro del contenedor a través del puerto 8080 en tu host.

También puedes usar docker ps para ver el contenedor en ejecución y sus puertos publicados.

docker ps

En la salida, deberías ver my-nginx listado, y en la columna PORTS deberías ver 0.0.0.0:8080->80/tcp, indicando que el puerto 80 dentro del contenedor está mapeado al puerto 8080 en todas las interfaces del host.

Montar un volumen para persistir datos

En este paso, aprenderás cómo usar volúmenes de Docker para conservar datos generados y utilizados por contenedores Docker. Por defecto, los datos dentro de un contenedor son efímeros; se pierden cuando el contenedor se elimina. Los volúmenes proporcionan una forma de almacenar datos fuera del sistema de archivos del contenedor, permitiendo que persistan incluso después de que el contenedor se detenga o elimine.

Primero, detengamos y eliminemos el contenedor my-nginx del paso anterior.

docker stop my-nginx
docker rm my-nginx

Ahora, crearemos un volumen de Docker. Los volúmenes son administrados por Docker y se almacenan en un área dedicada de la máquina host.

docker volume create my-volume

Deberías ver el nombre del volumen (my-volume) impreso, confirmando que fue creado.

Puedes listar los volúmenes existentes usando el comando docker volume ls.

docker volume ls

Deberías ver my-volume en la lista de volúmenes.

Ahora, ejecutaremos un nuevo contenedor nginx y montaremos el volumen my-volume en el directorio webroot predeterminado de Nginx dentro del contenedor, que es /usr/share/nginx/html. Esto significa que cualquier archivo colocado en /usr/share/nginx/html dentro del contenedor se almacenará realmente en my-volume en el host.

Ejecutaremos el contenedor en modo desatendido (-d), publicaremos el puerto 80 del contenedor al puerto 8081 en el host (-p 8081:80), le asignaremos un nombre (my-nginx-volume), y usaremos el flag -v para montar el volumen. El formato para montar un volumen con nombre es nombre_volumen:ruta_contenedor.

docker run -d --name my-nginx-volume -p 8081:80 -v my-volume:/usr/share/nginx/html nginx

Deberías ver el ID del contenedor impreso, indicando que el contenedor está en ejecución.

Ahora, coloquemos un archivo HTML simple en el volumen montado. Podemos hacer esto ejecutando un comando dentro del contenedor usando docker exec. Crearemos un archivo llamado index.html en /usr/share/nginx/html con contenido simple.

docker exec my-nginx-volume sh -c 'echo "<h1>¡Hola desde el volumen!</h1>" > /usr/share/nginx/html/index.html'

Este comando ejecuta un shell (sh -c) dentro del contenedor my-nginx-volume y ejecuta el comando echo para crear el archivo index.html.

Ahora, accedamos al servidor web en el puerto 8081 del host para ver el contenido del archivo index.html que acabamos de crear.

curl http://localhost:8081

Deberías ver <h1>¡Hola desde el volumen!</h1> en la salida. Esto confirma que el archivo creado dentro del contenedor está siendo servido por Nginx, y como fue escrito en el volumen montado, los datos son persistentes.

Para demostrar la persistencia, detengamos y eliminemos el contenedor my-nginx-volume.

docker stop my-nginx-volume
docker rm my-nginx-volume

Ahora, ejecutemos un nuevo contenedor, montando el mismo volumen. Llamaremos a este nuevo contenedor my-nginx-volume-new y publicaremos su puerto 80 al puerto 8082 del host.

docker run -d --name my-nginx-volume-new -p 8082:80 -v my-volume:/usr/share/nginx/html nginx

El nuevo contenedor está en ejecución y está usando el mismo my-volume. Accedamos al servidor web en el puerto 8082.

curl http://localhost:8082

Deberías seguir viendo <h1>¡Hola desde el volumen!</h1> en la salida. Esto ocurre porque el archivo index.html se almacenó en my-volume, que persistió incluso después de eliminar el contenedor original. El nuevo contenedor, al montar el mismo volumen, tiene acceso a los datos escritos previamente.

Esto demuestra el poder de los volúmenes para persistir datos independientemente del ciclo de vida del contenedor.

Configurar variables de entorno y añadir entradas de host

En este paso, aprenderás cómo establecer variables de entorno para un contenedor Docker y cómo añadir entradas personalizadas al archivo /etc/hosts de un contenedor. Las variables de entorno son una forma común de configurar aplicaciones que se ejecutan dentro de contenedores, y añadir entradas de host puede ser útil para descubrimiento de servicios o anular la resolución DNS dentro del contenedor.

Primero, detengamos y eliminemos el contenedor my-nginx-volume-new del paso anterior.

docker stop my-nginx-volume-new
docker rm my-nginx-volume-new

Ahora, ejecutaremos un contenedor simple y estableceremos una variable de entorno. Usaremos nuevamente la imagen ubuntu y ejecutaremos un comando que imprima el valor de una variable de entorno. Estableceremos una variable de entorno llamada MY_VARIABLE con el valor hello_docker. Usamos el flag -e para establecer variables de entorno, en el formato NOMBRE_VARIABLE=valor.

docker run --rm -e MY_VARIABLE=hello_docker ubuntu env | grep MY_VARIABLE

En este comando:

• --rm elimina automáticamente el contenedor cuando finaliza.
• -e MY_VARIABLE=hello_docker establece la variable de entorno MY_VARIABLE a hello_docker dentro del contenedor.
• ubuntu es la imagen que estamos usando.
• env es el comando ejecutado dentro del contenedor para imprimir todas las variables de entorno.
• | grep MY_VARIABLE filtra la salida para mostrar solo la línea que contiene MY_VARIABLE.

Deberías ver MY_VARIABLE=hello_docker impreso en la salida de tu terminal. Esto confirma que la variable de entorno se estableció correctamente dentro del contenedor.

A continuación, aprendamos cómo añadir entradas de host personalizadas al archivo /etc/hosts de un contenedor. Esto puede ser útil si necesitas que un contenedor resuelva un nombre de host específico a una dirección IP específica sin depender de DNS externo. Usamos el flag --add-host para esto, en el formato nombre_host:dirección_ip.

Ejecutaremos otro contenedor ubuntu y añadiremos una entrada de host que mapee el nombre de host my-service a la dirección IP 192.168.1.100. Luego usaremos el comando cat para mostrar el contenido del archivo /etc/hosts dentro del contenedor y usaremos grep para verificar nuestra entrada añadida.

docker run --rm --add-host my-service:192.168.1.100 ubuntu cat /etc/hosts | grep my-service

En este comando:

• --rm elimina el contenedor después de que finaliza.
• --add-host my-service:192.168.1.100 añade una entrada al archivo /etc/hosts del contenedor mapeando my-service a 192.168.1.100.
• ubuntu es la imagen.
• cat /etc/hosts es el comando ejecutado dentro del contenedor para imprimir el archivo hosts.
• | grep my-service filtra la salida para encontrar la línea con my-service.

Deberías ver una salida similar a 192.168.1.100 my-service en tu terminal. Esto confirma que la entrada de host personalizada fue añadida al archivo /etc/hosts del contenedor.

Puedes combinar el establecimiento de variables de entorno y la adición de entradas de host en un solo comando docker run si es necesario.

Resumen

En este laboratorio, aprendiste a utilizar el comando docker run para gestionar contenedores. Comenzaste ejecutando un contenedor en modo desatendido usando el flag -d y asignándole un nombre personalizado con el flag --name, verificando su estado con docker ps y docker ps -a.

Luego exploraste cómo conectarte a un contenedor en ejecución manteniendo STDIN abierto, publicar puertos del contenedor en el host usando el flag -p para accesibilidad en red, montar un volumen con el flag -v para garantizar la persistencia de datos más allá del ciclo de vida del contenedor, y configurar el entorno del contenedor estableciendo variables de entorno con el flag -e y añadiendo entradas de host mediante el flag --add-host.