Parámetros del comando Docker Run

Introducción

En este laboratorio, nos centraremos exclusivamente en el comando docker run y sus diversos parámetros. El comando docker run es fundamental para las operaciones de Docker, ya que nos permite crear e iniciar contenedores con configuraciones específicas.

Al dominar los parámetros de este comando, tendrás un mayor control sobre tus aplicaciones contenerizadas, lo que mejorará tu capacidad para desplegar y gestionar contenedores de Docker de manera efectiva.

Cubriremos una amplia gama de parámetros, incluyendo aquellos para nombrar, modo desatendido (detached mode), mapeo de puertos, montaje de volúmenes, variables de entorno, restricciones de recursos y más.

Algunos de los parámetros ya te pueden resultar familiares, mientras que otros pueden ser nuevos para ti.

Skills Graph

Ejecución básica de Docker y nombramiento de contenedores

Comencemos con los conceptos básicos de docker run y exploremos cómo nombrar nuestros contenedores.

Primero, ejecutemos un contenedor básico de Nginx:

docker run nginx

Este comando ejecuta un contenedor de Nginx en primer plano. Verás una secuencia de registros de salida en tu terminal. Esto se debe a que el contenedor se está ejecutando en primer plano y te muestra directamente los registros.

Para detener este contenedor, presiona Ctrl+C. Puedes notar que tarda unos segundos en detenerse, lo cual es normal, ya que Docker está dando tiempo al contenedor para apagarse correctamente (gracefully).

Ahora, ejecutémoslo en modo desatendido (detached mode) y démosle un nombre:

docker run -d --name my-nginx nginx

Desglosemos este comando:

• docker run: Este es el comando básico para ejecutar un contenedor.
• -d: Esta opción ejecuta el contenedor en modo desatendido, es decir, se ejecuta en segundo plano. No verás ninguna salida en tu terminal.
• --name my-nginx: Esto asigna el nombre "my-nginx" al contenedor. Si no especificas un nombre, Docker asignará un nombre aleatorio.
• nginx: Este es el nombre de la imagen que estamos utilizando para crear el contenedor.

Después de ejecutar este comando, verás una larga cadena de caracteres. Esta es la ID del contenedor. Docker ha iniciado el contenedor en segundo plano.

Si encuentras un error que dice que el nombre ya está en uso, significa que ya tienes un contenedor con ese nombre. Puedes elegir un nombre diferente o eliminar el contenedor existente (aprenderemos cómo hacer esto en laboratorios posteriores).

Mapeo de puertos

El parámetro -p en docker run nos permite mapear puertos desde el contenedor al host. Esto es crucial para acceder a los servicios que se ejecutan dentro del contenedor desde tu máquina host.

Ejecuta un contenedor de Nginx con mapeo de puertos:

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

Desglosemos las nuevas partes de este comando:

• -p 8080:80: Esto mapea el puerto 8080 en tu host al puerto 80 en el contenedor. El formato siempre es puerto_host:puerto_contenedor.

Nginx, por defecto, se ejecuta en el puerto 80 dentro del contenedor. Al mapearlo al puerto 8080 en nuestro host, podemos acceder a él yendo a localhost:8080 en un navegador web.

Ahora, verifiquemos que la página de bienvenida de Nginx sea accesible. Usaremos el comando curl, que nos permite realizar solicitudes HTTP desde la línea de comandos:

curl http://localhost:8080

Deberías ver el contenido HTML de la página de bienvenida de Nginx. Si no tienes curl instalado, puedes instalarlo con:

sudo apt-get update && sudo apt-get install -y curl

Si todavía no puedes acceder a la página, aquí hay algunas cosas para verificar:

1. Asegúrate de que el contenedor esté en ejecución: docker ps | grep nginx-mapped
2. Verifica si el puerto está realmente mapeado: docker port nginx-mapped
3. Si estás usando un servidor en la nube, asegúrate de que el firewall permita el tráfico en el puerto 8080.

Montaje de volúmenes

El parámetro -v en docker run nos permite montar volúmenes, compartiendo datos entre el host y el contenedor. Esto es extremadamente útil para persistir datos o para proporcionar archivos de configuración al contenedor.

Comencemos creando una estructura de directorios simple en nuestro host:

mkdir -p ~/project/nginx-data
echo "<html><body><h1>Hello from mounted volume</h1></body></html>" > ~/project/nginx-data/index.html

Estos comandos realizan lo siguiente:

1. Crean un nuevo directorio nginx-data dentro de la carpeta project en tu directorio de usuario.
2. Crean un archivo HTML simple llamado index.html dentro de este nuevo directorio.

Ahora, ejecutemos un contenedor de Nginx y montemos este directorio:

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

Desglosemos este comando:

• docker run: Este es el comando para ejecutar un nuevo contenedor.
• -d: Esto ejecuta el contenedor en modo desatendido (en segundo plano).
• --name nginx-volume: Esto asigna el nombre "nginx-volume" a nuestro contenedor.
• -p 8081:80: Esto mapea el puerto 8081 en el host al puerto 80 en el contenedor.
• -v ~/project/nginx-data:/usr/share/nginx/html: Esto monta el directorio nginx-data de nuestro host al directorio /usr/share/nginx/html en el contenedor. Aquí es donde Nginx busca el contenido para servir.
• nginx: Este es el nombre de la imagen que estamos utilizando para crear el contenedor.

Ahora, verifiquemos que se esté sirviendo la página personalizada:

curl http://localhost:8081

Deberías ver el contenido de tu archivo HTML personalizado: "Hello from mounted volume!"

Si no ves tu contenido personalizado, aquí hay algunas cosas para verificar:

1. Asegúrate de que el archivo ~/project/nginx-data/index.html exista en tu sistema host.
2. Verifica que el contenedor esté en ejecución: docker ps | grep nginx-volume
3. Verifica los registros de Nginx en busca de errores: docker logs nginx-volume

Este método de montar un directorio del host en un contenedor se llama montaje enlazado (bind mount). Es una forma sencilla de compartir archivos entre el host y el contenedor. Aquí hay algunos puntos clave a recordar:

1. La ruta del directorio del host debe ser una ruta absoluta.
2. Si el directorio del host no existe, Docker lo creará automáticamente.
3. Cualquier cambio realizado en los archivos de este directorio (ya sea en el host o en el contenedor) será visible inmediatamente tanto para el host como para el contenedor.
4. Ten cuidado con los permisos: el contenedor se ejecuta como root por defecto, lo que podría crear archivos que tu usuario del host no puede modificar.

Al utilizar este método, evitamos el error "not a directory" porque estamos montando un directorio, no un solo archivo. Este enfoque te da más flexibilidad para agregar, eliminar o modificar archivos sin tener que recrear el contenedor.

Variables de entorno

El parámetro -e en docker run nos permite establecer variables de entorno en el contenedor. Esto es útil para configurar la aplicación que se ejecuta en el contenedor sin cambiar su código.

Ejecuta un contenedor con variables de entorno:

docker run -d --name nginx-env -e NGINX_HOST=mywebsite.com -e NGINX_PORT=80 nginx

Desglosemos las nuevas partes:

• -e NGINX_HOST=mywebsite.com: Esto establece una variable de entorno llamada NGINX_HOST con el valor mywebsite.com.
• -e NGINX_PORT=80: Esto establece otra variable de entorno NGINX_PORT con el valor 80.

Las variables de entorno son un par clave-valor que pueden ser accedidas por los procesos que se ejecutan dentro del contenedor. Muchas imágenes de Docker están diseñadas para utilizar variables de entorno específicas para la configuración.

Puedes verificar las variables de entorno:

docker exec nginx-env env | grep NGINX_

Este comando hace lo siguiente:

• docker exec nginx-env: Esto le dice a Docker que ejecute un comando en el contenedor nginx-env en ejecución.
• env: Este comando imprime todas las variables de entorno.
• | grep NGINX_: Esto filtra la salida para mostrar solo las líneas que contengan "NGINX_".

Deberías ver tus dos variables de entorno listadas.

Si no ves las variables de entorno, verifica:

1. ¿Está el contenedor en ejecución? Verifícalo con docker ps | grep nginx-env
2. ¿Has escrito correctamente los nombres de las variables de entorno en tu comando docker run?

Restricciones de recursos

Docker te permite establecer restricciones de recursos en los contenedores utilizando varios parámetros en docker run. Esto es crucial para gestionar el rendimiento y la estabilidad de tu sistema host, especialmente cuando se ejecutan múltiples contenedores.

Ejecuta un contenedor con límites de memoria y CPU:

docker run -d --name nginx-limited --memory 256m --cpus 0.5 nginx

Desglosemos las nuevas partes:

• --memory 256m: Esto limita el contenedor a 256 megabytes de memoria. La 'm' significa megabytes. También podrías usar 'g' para gigabytes.
• --cpus 0.5: Esto limita el contenedor para que use como máximo la mitad de un núcleo de CPU.

Estos límites evitan que el contenedor utilice más recursos de los especificados, lo que puede ayudar a prevenir que un solo contenedor monopolicie los recursos del host.

Puedes verificar que estos límites se hayan aplicado correctamente:

docker inspect -f '{{.HostConfig.Memory}}' nginx-limited
docker inspect -f '{{.HostConfig.NanoCpus}}' nginx-limited

El primer comando debería mostrar 268435456 (256MB en bytes), y el segundo debería mostrar 500000000 (0.5 CPU en nano-unidades).

Si ves valores diferentes, revisa tu comando docker run para asegurarte de que hayas especificado los límites correctamente.

Nota: Establecer los límites de recursos demasiado bajos puede hacer que el contenedor tenga un rendimiento deficiente o incluso se bloquee. Si estás teniendo problemas con tu contenedor, intenta aumentar estos límites.

Configuración de red

El parámetro --network en docker run te permite conectar un contenedor a una red. Esto es útil para la comunicación entre contenedores y para aislar grupos de contenedores.

Primero, crea una red de puente (bridge network) personalizada:

docker network create my-custom-network

Esto crea una nueva red de puente llamada my-custom-network. Las redes de puente son el tipo de red más común en Docker.

Ahora, ejecuta un contenedor conectado a esta red:

docker run -d --name nginx-networked --network my-custom-network nginx

La opción --network my-custom-network conecta el contenedor a la red que acabamos de crear.

Los contenedores en la misma red pueden comunicarse entre sí utilizando sus nombres de contenedor como nombres de host. Esto facilita la conexión de servicios entre sí.

Si obtienes un error que dice que la red no existe, asegúrate de haber creado la red correctamente con el comando docker network create.

Políticas de reinicio

El parámetro --restart en docker run te permite especificar una política de reinicio para el contenedor. Esto es útil para garantizar que tus contenedores sigan en ejecución, incluso si se bloquean o si el demonio de Docker se reinicia.

Ejecuta un contenedor con una política de reinicio:

docker run -d --name nginx-restart --restart unless-stopped nginx

La opción --restart unless-stopped establece la política de reinicio en "unless-stopped", lo que significa que el contenedor se reiniciará automáticamente a menos que el usuario lo detenga explícitamente.

Otras políticas de reinicio incluyen:

• no: La predeterminada. No reinicie automáticamente el contenedor.
• on-failure: Reinicie solo si el contenedor sale con un estado distinto de cero.
• always: Siempre reinicie el contenedor independientemente del estado de salida.

Puedes verificar la política de reinicio:

docker inspect -f '{{.HostConfig.RestartPolicy.Name}}' nginx-restart

Esto debería mostrar unless-stopped.

Si no ves la salida esperada, revisa tu comando docker run para asegurarte de que hayas especificado correctamente la política de reinicio.

Directorio de trabajo y comando

En este paso, exploraremos cómo establecer un directorio de trabajo dentro de un contenedor y ejecutar comandos personalizados cuando un contenedor se inicia.

El parámetro -w en docker run establece el directorio de trabajo dentro del contenedor, y puedes especificar un comando para ejecutar después del nombre de la imagen.

Combinemos estos conceptos:

docker run -d --name nginx-custom -w /app nginx sh -c "touch newfile.txt && nginx -g 'daemon off;'"

Desglosemos este comando:

• -d: Ejecuta el contenedor en modo desatendido (en segundo plano).
• --name nginx-custom: Nombrar el contenedor "nginx-custom".
• -w /app: Establece el directorio de trabajo dentro del contenedor en /app.
• nginx: El nombre de la imagen a utilizar.
• sh -c "...": Ejecuta un comando de shell.
  • touch newfile.txt: Crea un archivo vacío llamado newfile.txt.
  • &&: Ejecuta el siguiente comando si el anterior tuvo éxito.
  • nginx -g 'daemon off;': Inicia Nginx en primer plano, manteniendo el contenedor en ejecución.

Ahora, verifiquemos que el contenedor está en ejecución y que el archivo se ha creado:

docker ps | grep nginx-custom
docker exec nginx-custom ls -l /app/newfile.txt

El primer comando debe mostrar que el contenedor está en ejecución, y el segundo comando debe listar los detalles del archivo newfile.txt en el directorio /app del contenedor.

Resumen

En este laboratorio, hemos profundizado en el comando docker run, explorando sus diversos parámetros y opciones. Hemos cubierto:

1. Ejecución y nomenclatura básicas de contenedores
2. Mapeo de puertos para acceder a los servicios de los contenedores desde el host
3. Montaje de volúmenes para compartir datos entre el host y el contenedor
4. Establecimiento de variables de entorno para la configuración del contenedor
5. Aplicación de restricciones de recursos para limitar el uso de recursos del contenedor
6. Configuración de red para la comunicación entre contenedores
7. Políticas de reinicio para la confiabilidad del contenedor
8. Especificación del directorio de trabajo y del comando para el inicio del contenedor

Estos parámetros de docker run proporcionan herramientas poderosas para configurar y gestionar tus contenedores Docker. Al dominar estas opciones, puedes crear implementaciones de contenedores más sofisticadas y personalizadas. Puedes controlar cómo interactúan los contenedores con el sistema host, qué recursos pueden consumir y cómo se comportan en diferentes escenarios.