Parámetros del Comando Docker Run

Introducción

En este laboratorio, nos enfocaremos 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, obtendrá un mayor control sobre sus aplicaciones contenedorizadas, mejorando su capacidad para desplegar y gestionar contenedores de Docker de manera efectiva.

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

Es posible que ya esté familiarizado con algunos de estos parámetros, mientras que otros podrían ser nuevos para usted.

Uso Básico de Docker Run y Nombrado de Contenedores

Comencemos con lo básico de docker run y exploremos cómo dar nombre a nuestros contenedores.

Primero, ejecute un contenedor Nginx básico:

docker run nginx

Este comando ejecuta un contenedor Nginx en primer plano (foreground). Verá un flujo de salida de registros (logs) en su terminal. Esto sucede porque el contenedor se está ejecutando de forma interactiva y le muestra los registros directamente.

Para detener este contenedor, presione Ctrl+C. Notará que tarda unos segundos en detenerse; esto es normal, ya que Docker le da tiempo al contenedor para cerrarse de forma ordenada.

Ahora, ejecutémoslo en modo desatendido y asignémosle un nombre:

docker run -d --name my-nginx nginx

Analicemos este comando:

• docker run: Es el comando básico para ejecutar un contenedor.
• -d: Esta opción ejecuta el contenedor en modo desatendido (detached), lo que significa que se ejecuta en segundo plano. No verá ninguna salida en su terminal.
• --name my-nginx: Esto asigna el nombre "my-nginx" al contenedor. Si no especifica un nombre, Docker asignará uno aleatorio.
• nginx: Es el nombre de la imagen que estamos utilizando para crear el contenedor.

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

Si encuentra un error que indica que el nombre ya está en uso, significa que ya tiene un contenedor con ese nombre. Puede elegir un nombre diferente o eliminar el contenedor existente (aprenderemos cómo hacerlo en laboratorios posteriores).

Mapeo de Puertos

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

Ejecute un contenedor Nginx con mapeo de puertos:

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

Analicemos las nuevas partes de este comando:

• -p 8080:80: Esto mapea el puerto 8080 de su host al puerto 80 del 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 dirigiéndonos 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 peticiones HTTP desde la línea de comandos:

curl http://localhost:8080

Debería ver el contenido HTML de la página de bienvenida de Nginx. Si no tiene instalado curl, puede instalarlo con:

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

Si aún no puede acceder a la página, aquí hay algunas cosas que debe verificar:

1. Asegúrese de que el contenedor se esté ejecutando: docker ps | grep nginx-mapped
2. Compruebe si el puerto está realmente mapeado: docker port nginx-mapped
3. Si está utilizando un servidor en la nube, asegúrese 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 increíblemente ú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 hacen lo siguiente:

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

Ahora, ejecutemos un contenedor Nginx y montemos este directorio:

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

Analicemos este comando:

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

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

curl http://localhost:8081

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

Si no ve su contenido personalizado, verifique lo siguiente:

1. Asegúrese de que el archivo ~/project/nginx-data/index.html exista en su sistema host.
2. Compruebe que el contenedor se esté ejecutando: docker ps | grep nginx-volume
3. Revise los registros de Nginx para ver si hay errores: docker logs nginx-volume

Este método de montar un directorio del host en un contenedor se llama "bind mount". Es una forma directa de compartir archivos. 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 para ambos.
4. Tenga cuidado con los permisos: el contenedor se ejecuta como root por defecto, lo que podría crear archivos que su usuario del host no pueda modificar.

Al usar este método, evitamos errores de tipo "no es un directorio" porque estamos montando una carpeta completa. Este enfoque le brinda 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 necesidad de cambiar su código fuente.

Ejecute un contenedor con variables de entorno:

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

Analicemos las nuevas partes:

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

Las variables de entorno son pares clave-valor a los que pueden acceder los procesos que se ejecutan dentro del contenedor. Muchas imágenes de Docker están diseñadas para usar variables de entorno específicas para su configuración.

Puede verificar las variables de entorno:

docker exec nginx-env env | grep NGINX_

Este comando hace lo siguiente:

• docker exec nginx-env: Indica a Docker que ejecute un comando en el contenedor nginx-env que está en funcionamiento.
• env: Este comando imprime todas las variables de entorno.
• | grep NGINX_: Filtra la salida para mostrar solo las líneas que contienen "NGINX_".

Debería ver sus dos variables de entorno listadas.

Si no ve las variables de entorno, verifique:

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

Restricciones de Recursos

Docker le 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 su sistema host, especialmente cuando se ejecutan múltiples contenedores.

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

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

Analicemos las nuevas partes:

• --memory 256m: Limita el contenedor a 256 megabytes de memoria. La 'm' representa megabytes. También podría usar 'g' para gigabytes.
• --cpus 0.5: 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 ayuda a evitar que un solo contenedor monopolice los recursos del host.

Puede verificar que estos límites se aplicaron correctamente:

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

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

Si ve valores diferentes, revise su comando docker run para asegurarse de que especificó los límites correctamente.

Nota: Establecer límites de recursos demasiado bajos puede causar que el contenedor funcione mal o incluso se bloquee. Si tiene problemas con su contenedor, intente aumentar estos límites.

Configuración de Red

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

Primero, cree una red de tipo bridge personalizada:

docker network create my-custom-network

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

Ahora, ejecute 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 (hostnames). Esto facilita la vinculación de servicios.

Si recibe un error indicando que la red no existe, asegúrese de haber creado la red correctamente con el comando docker network create.

Políticas de Reinicio

El parámetro --restart en docker run le permite especificar una política de reinicio para el contenedor. Esto es útil para asegurar que sus contenedores permanezcan en ejecución, incluso si fallan o si el demonio de Docker se reinicia.

Ejecute 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: El valor por defecto. No reinicia el contenedor automáticamente.
• on-failure: Reinicia solo si el contenedor termina con un estado de salida distinto de cero.
• always: Siempre reinicia el contenedor independientemente del estado de salida.

Puede verificar la política de reinicio:

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

La salida debería ser unless-stopped.

Si no ve la salida esperada, revise su comando docker run para asegurarse de haber especificado la política correctamente.

Directorio de Trabajo y Comandos

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

El parámetro -w en docker run establece el directorio de trabajo dentro del contenedor, y puede 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 "mkdir -p /app && touch newfile.txt && nginx -g 'daemon off;'"

Analicemos este comando:

• -d: Ejecuta el contenedor en modo desatendido (en segundo plano).
• --name nginx-custom: Nombra al 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.
  • mkdir -p /app: Crea el directorio /app si no existe.
  • &&: Ejecuta el siguiente comando si el anterior tuvo éxito.
  • 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 se está ejecutando y que el archivo fue creado:

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

El primer comando debería mostrar que el contenedor está en ejecución, y el segundo debería 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 básica y nombrado de contenedores.
2. Mapeo de puertos para acceder a los servicios del contenedor desde el host.
3. Montaje de volúmenes para compartir datos entre el host y el contenedor.
4. Configuración de variables de entorno para la personalización del contenedor.
5. Aplicación de restricciones de recursos para limitar el consumo de memoria y CPU.
6. Configuración de red para la comunicación entre contenedores.
7. Políticas de reinicio para mejorar la fiabilidad de los contenedores.
8. Especificación del directorio de trabajo y comandos personalizados al inicio.

Estos parámetros de docker run proporcionan herramientas potentes para configurar y gestionar sus contenedores de Docker. Al dominar estas opciones, podrá crear despliegues de contenedores más sofisticados y adaptados a sus necesidades. Podrá controlar cómo interactúan los contenedores con el sistema host, qué recursos pueden consumir y cómo se comportan en diferentes escenarios.