Parámetros del comando Docker Run

Introducción

En este laboratorio se centrará exclusivamente en el comando docker run y sus distintos parámetros. El comando docker run es fundamental para trabajar con Docker, ya que permite crear e iniciar contenedores con configuraciones específicas.

Al dominar los parámetros de este comando, tendrá más control sobre sus aplicaciones en contenedores y podrá implementar y gestionar contenedores Docker con mayor eficacia.

Verá una amplia variedad de parámetros, incluidos los que sirven para asignar nombres, ejecutar contenedores en segundo plano, asignar puertos, montar volúmenes, definir variables de entorno y limitar recursos, entre otros.

Es posible que ya conozca algunos de estos parámetros y que otros sean nuevos para usted.

Ejecución básica de Docker y asignación de nombres a contenedores

En este paso, empezará por los conceptos básicos de docker run y aprenderá a asignar nombres a los contenedores.

Primero, ejecute un contenedor de Nginx básico:

docker run nginx

Este comando ejecuta un contenedor de Nginx en primer plano. Verá un flujo de registros en la terminal. Esto ocurre porque el contenedor se ejecuta en primer plano y los registros se muestran directamente.

Para detener el contenedor, pulse Ctrl+C. Es posible que tarde unos segundos en detenerse. Es normal: Docker le da tiempo para apagarse de forma controlada.

Ahora, ejecútelo en segundo plano y asígnele un nombre:

docker run -d --name my-nginx nginx

Veamos qué hace cada parte del comando:

• docker run: es el comando básico para ejecutar un contenedor.
• -d: ejecuta el contenedor en segundo plano. No verá ninguna salida en la terminal.
• --name my-nginx: asigna el nombre "my-nginx" al contenedor. Si no especifica un nombre, Docker le asigna uno aleatorio.
• nginx: es el nombre de la imagen que se usará para crear el contenedor.

Al ejecutar este comando, verá una cadena larga de caracteres: es el ID del contenedor. Docker ya lo ha iniciado en segundo plano.

Si aparece un error que indica que el nombre ya está en uso, significa que ya existe un contenedor con ese nombre. Puede elegir otro nombre o eliminar el contenedor existente (aprenderá a hacerlo en laboratorios posteriores).

Asignación de puertos

En este paso, usará el parámetro -p de docker run para asignar puertos del contenedor al host. Esto es fundamental para acceder desde el host a los servicios que se ejecutan dentro del contenedor.

Ejecute un contenedor de Nginx con un puerto asignado:

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

Veamos qué significa la parte nueva del comando:

• -p 8080:80: asigna el puerto 8080 del host al puerto 80 del contenedor. El formato es siempre host_port:container_port.

De forma predeterminada, Nginx usa el puerto 80 dentro del contenedor. Al asignarlo al puerto 8080 del host, podrá acceder a Nginx desde un navegador web en localhost:8080.

Ahora, compruebe que puede acceder a la página de bienvenida de Nginx. Para ello, usará el comando curl, que permite enviar solicitudes HTTP desde la línea de comandos:

curl --retry 5 --retry-all-errors --retry-delay 1 http://localhost:8080

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

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

Si sigue sin poder acceder a la página, compruebe lo siguiente:

• Asegúrese de que el contenedor esté en ejecución: docker ps | grep nginx-mapped
• Compruebe que el puerto esté realmente asignado: docker port nginx-mapped
• Si usa un servidor en la nube, asegúrese de que el firewall permita el tráfico por el puerto 8080.

Montaje de volúmenes

En este paso, usará el parámetro -v de docker run para montar volúmenes y compartir datos entre el host y el contenedor. Esto resulta útil para conservar datos o proporcionar archivos de configuración al contenedor.

Primero, cree una estructura de directorios sencilla en el 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 las siguientes acciones:

• Crean el directorio nginx-data dentro del directorio project de su directorio personal.
• Crean un archivo HTML sencillo llamado index.html dentro del nuevo directorio.

Ahora, ejecute un contenedor de Nginx y monte este directorio:

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

Veamos qué hace cada parte del comando:

• docker run: ejecuta un contenedor nuevo.
• -d: ejecuta el contenedor en segundo plano.
• --name nginx-volume: asigna el nombre "nginx-volume" al contenedor.
• -p 8081:80: asigna el puerto 8081 del host al puerto 80 del contenedor.
• -v ~/project/nginx-data:/usr/share/nginx/html: monta el directorio nginx-data del host en el directorio /usr/share/nginx/html del contenedor. Nginx busca allí el contenido que debe servir.
• nginx: es el nombre de la imagen que se usará para crear el contenedor.

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

curl --retry 5 --retry-all-errors --retry-delay 1 http://localhost:8081

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

Si no ve el contenido personalizado, compruebe lo siguiente:

• Asegúrese de que el archivo ~/project/nginx-data/index.html exista en el host.
• Compruebe que el contenedor esté en ejecución: docker ps | grep nginx-volume
• Revise los registros de Nginx para detectar errores: docker logs nginx-volume

Este método, que consiste en montar un directorio del host en un contenedor, se llama montaje bind. Es una forma sencilla de compartir archivos entre el host y el contenedor. Tenga en cuenta estos puntos:

• La ruta del directorio del host debe ser absoluta.
• Si el directorio del host no existe, Docker lo creará automáticamente.
• Los cambios que haga en los archivos de este directorio, tanto en el host como en el contenedor, serán visibles de inmediato desde ambos.
• Tenga cuidado con los permisos: de forma predeterminada, el contenedor se ejecuta como root y podría crear archivos que su usuario del host no pueda modificar.

Con este método, evitamos el error "not a directory" porque montamos un directorio, no un archivo individual. Así tendrá más flexibilidad para añadir, eliminar o modificar archivos sin tener que volver a crear el contenedor.

Variables de entorno

En este paso, usará el parámetro -e de docker run para definir variables de entorno en el contenedor. Esto resulta útil para configurar la aplicación sin modificar su código.

Ejecute un contenedor con variables de entorno:

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

Veamos qué significan las partes nuevas:

• -e NGINX_HOST=mywebsite.com: define una variable de entorno llamada NGINX_HOST con el valor mywebsite.com.
• -e NGINX_PORT=80: define 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 en su configuración.

Compruebe las variables de entorno:

docker exec nginx-env env | grep NGINX_

Este comando realiza las siguientes acciones:

• docker exec nginx-env: indica a Docker que ejecute un comando dentro del contenedor nginx-env, que está en ejecución.
• env: muestra todas las variables de entorno.
• | grep NGINX_: filtra la salida para mostrar solo las líneas que contienen "NGINX_".

Debería ver las dos variables de entorno que definió.

Si no aparecen, compruebe lo siguiente:

• ¿Está en ejecución el contenedor? Compruébelo con docker ps | grep nginx-env
• ¿Escribió correctamente los nombres de las variables de entorno en el comando docker run?

Límites de recursos

En este paso, establecerá límites de recursos para los contenedores mediante parámetros de docker run. Esto es fundamental para gestionar el rendimiento y la estabilidad del host, sobre todo cuando se ejecutan varios contenedores.

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

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

Veamos qué significan las partes nuevas:

• --memory 256m: limita la memoria del contenedor a 256 megabytes. La «m» significa megabytes. También podría usar «g» para indicar gigabytes.
• --cpus 0.5: limita el uso del contenedor a un máximo de medio núcleo de CPU.

Estos límites impiden que el contenedor use más recursos de los especificados, lo que ayuda a evitar que un solo contenedor acapare los recursos del host.

Compruebe que los 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 (256 MB en bytes) y el segundo, 500000000 (0,5 CPU en nano-unidades).

Si obtiene otros valores, revise el comando docker run para asegurarse de haber especificado correctamente los límites.

Nota: si establece límites de recursos demasiado bajos, el contenedor podría funcionar mal o incluso bloquearse. Si tiene problemas con el contenedor, pruebe a aumentar estos límites.

Configuración de red

En este paso, usará el parámetro --network de docker run para conectar un contenedor a una red. Esto resulta útil para permitir la comunicación entre contenedores y aislar grupos de contenedores.

Primero, cree una red bridge personalizada:

docker network create my-custom-network

Este comando 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 acaba de crear.

Los contenedores de una misma red pueden comunicarse entre sí usando sus nombres de contenedor como nombres de host. Así resulta fácil conectar servicios entre sí.

Si aparece un error que indica que la red no existe, asegúrese de haberla creado correctamente con el comando docker network create.

Políticas de reinicio

En este paso, usará el parámetro --restart de docker run para definir una política de reinicio para el contenedor. Esto ayuda a mantener los contenedores en ejecución si se bloquean o si se reinicia el daemon de Docker.

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". Esto significa que el contenedor se reiniciará automáticamente, a menos que un usuario lo detenga explícitamente.

Otras políticas de reinicio son:

• no: opción predeterminada. No reinicia el contenedor automáticamente.
• on-failure: reinicia el contenedor solo si termina con un estado distinto de cero.
• always: reinicia siempre el contenedor, independientemente del estado de salida.

Compruebe la política de reinicio:

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

El comando debería mostrar unless-stopped.

Si no obtiene el resultado esperado, revise el comando docker run para asegurarse de haber especificado correctamente la política de reinicio.

Directorio de trabajo y comando

En este paso, aprenderá a definir un directorio de trabajo dentro de un contenedor y a ejecutar comandos personalizados cuando este se inicia.

El parámetro -w de docker run define el directorio de trabajo dentro del contenedor. También puede especificar un comando para que se ejecute después del nombre de la imagen.

Combine estos conceptos:

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

Veamos qué hace cada parte del comando:

• -d: ejecuta el contenedor en segundo plano.
• --name nginx-custom: asigna el nombre "nginx-custom" al contenedor.
• -w /app: establece /app como directorio de trabajo dentro del contenedor.
• nginx: es el nombre de la imagen que se usará.
• sh -c "...": ejecuta un comando de shell.
  • mkdir -p /app: crea el directorio /app si aún no existe.
  • &&: ejecuta el siguiente comando solo si el anterior se ejecutó correctamente.
  • touch newfile.txt: crea un archivo vacío llamado newfile.txt.
  • &&: ejecuta el siguiente comando solo si el anterior se ejecutó correctamente.
  • nginx -g 'daemon off;': inicia Nginx en primer plano para mantener el contenedor en ejecución.

Ahora, compruebe que el contenedor esté en ejecución y que se haya creado el archivo:

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. El segundo debería mostrar los detalles del archivo newfile.txt en el directorio /app del contenedor.

Resumen

En este laboratorio, hemos explorado en profundidad el comando docker run y sus distintos parámetros y opciones. Hemos visto cómo:

1. Ejecutar contenedores y asignarles nombres
2. Asignar puertos para acceder desde el host a los servicios de los contenedores
3. Montar volúmenes para compartir datos entre el host y los contenedores
4. Definir variables de entorno para configurar contenedores
5. Aplicar límites de recursos para restringir el uso de recursos de los contenedores
6. Configurar redes para permitir la comunicación entre contenedores
7. Definir políticas de reinicio para mejorar la fiabilidad de los contenedores
8. Especificar el directorio de trabajo y el comando que se ejecutará al iniciar un contenedor

Estos parámetros de docker run son herramientas potentes para configurar y gestionar contenedores Docker. Al dominar estas opciones, podrá crear implementaciones de contenedores más sofisticadas y adaptadas a sus necesidades. Podrá controlar cómo interactúan los contenedores con el host, qué recursos pueden consumir y cómo se comportan en distintas situaciones.