Sumergiéndote más en los contenedores

Introducción

Los contenedores Docker son los componentes fundamentales de la implementación de aplicaciones modernas. En este laboratorio, exploraremos técnicas avanzadas de gestión de contenedores que profundizarán su comprensión de las capacidades de Docker. Cubriremos el funcionamiento de contenedores en diferentes modos, la gestión de su ciclo de vida, la inspección de los detalles de los contenedores, el trabajo con registros (logs), la ejecución de comandos dentro de los contenedores, la copia de archivos, la configuración de variables de entorno y la limitación de los recursos de los contenedores. Al final de este laboratorio, tendrá una comprensión integral de cómo trabajar eficazmente con contenedores Docker.

Skills Graph

Ejecución de contenedores en diferentes modos

Docker te permite ejecutar contenedores en diferentes modos para adaptarse a diversos casos de uso. Exploraremos dos modos comunes: modo desatendido (detached mode) y modo interactivo (interactive mode).

Primero, ejecutemos un contenedor en modo desatendido:

docker run -d --name nginx-detached nginx

Este comando hace lo siguiente:

• -d: Ejecuta el contenedor en modo desatendido (en segundo plano)
• --name nginx-detached: Asigna el nombre "nginx-detached" al contenedor
• nginx: Especifica la imagen a utilizar (se descargará desde Docker Hub si no está disponible localmente)

Deberías ver una larga cadena de caracteres como salida, que es el ID del contenedor.

Puedes verificar el estado del contenedor ejecutando:

docker ps

Ahora, ejecutemos un contenedor en modo interactivo:

docker run -it --name ubuntu-interactive ubuntu /bin/bash

Este comando hace lo siguiente:

• -it: Ejecuta el contenedor en modo interactivo con una pseudo-TTY
• --name ubuntu-interactive: Asigna el nombre "ubuntu-interactive" al contenedor
• ubuntu: Especifica la imagen a utilizar
• /bin/bash: El comando a ejecutar dentro del contenedor (en este caso, una shell bash)

Ahora deberías estar dentro del contenedor Ubuntu. Puedes salir del contenedor escribiendo exit.

Listemos nuestros contenedores en ejecución:

docker ps

Deberías ver el contenedor nginx-detached en ejecución, pero no el contenedor ubuntu-interactive (porque lo salimos).

Gestión del ciclo de vida de los contenedores

Comprender cómo iniciar, detener y reiniciar contenedores es crucial para una gestión eficaz de los contenedores.

Empecemos deteniendo el contenedor nginx-detached:

docker stop nginx-detached

Ahora, veamos el estado de nuestros contenedores:

docker ps -a

Deberías ver que el contenedor nginx-detached ahora está en estado "Exited" (Detenido).

Vamos a iniciarlo nuevamente:

docker start nginx-detached

Verifiquemos el estado una vez más:

docker ps

Deberías ver que el contenedor nginx-detached ahora está en estado "Up" (En ejecución).

También podemos reiniciar un contenedor en ejecución:

docker restart nginx-detached

Para ver el estado actual de nuestros contenedores, incluyendo los detenidos, use:

docker ps -a

Deberías ver listados tanto el contenedor nginx-detached como el ubuntu-interactive, con su estado actual.

Vamos a eliminar el contenedor detenido ubuntu-interactive:

docker rm ubuntu-interactive

Y verifiquemos que se haya eliminado:

docker ps -a

Ya no deberías ver el contenedor ubuntu-interactive en la lista.

Inspección de detalles de contenedores

Docker ofrece herramientas poderosas para inspeccionar los detalles de tus contenedores. Vamos a explorarlas.

Para obtener información detallada sobre un contenedor, utiliza el comando inspect:

docker inspect nginx-detached

Este comando devuelve una matriz JSON con información detallada sobre el contenedor. Puede resultar abrumador, así que usemos un filtro para obtener información específica.

Para obtener la dirección IP del contenedor:

docker inspect -f '{{range.NetworkSettings.Networks}}{{.IPAddress}}{{end}}' nginx-detached

Para ver el estado actual del contenedor:

docker inspect -f '{{.State.Status}}' nginx-detached

Estos comandos utilizan plantillas de Go para filtrar la salida. La opción -f nos permite especificar una plantilla de formato.

También veamos las asignaciones de puertos:

docker port nginx-detached

La asignación de puertos permite que los contenedores se comuniquen con el sistema host o con redes externas. Asigna un puerto en el sistema host a un puerto dentro del contenedor. Esto es crucial para acceder a los servicios que se ejecutan dentro de los contenedores desde fuera del entorno Docker.

Si no se asignan puertos, este comando no producirá ninguna salida. En nuestro caso, no hemos asignado explícitamente ningún puerto para el contenedor nginx-detached, así que probablemente no verás ninguna salida.

Para demostrar la asignación de puertos, creemos un nuevo contenedor Nginx con una asignación de puertos:

docker run -d --name nginx-with-port -p 8080:80 nginx

Este comando asigna el puerto 8080 del host al puerto 80 del contenedor. Ahora, si comprobamos las asignaciones de puertos:

docker port nginx-with-port

Deberías ver una salida similar a:

80/tcp -> 0.0.0.0:8080

Esto significa que el tráfico al puerto 8080 de tu máquina host se reenviará al puerto 80 del contenedor, donde Nginx está escuchando.

Trabajo con registros (logs) de contenedores

Acceder y entender los registros de los contenedores es crucial para solucionar problemas y monitorear tus aplicaciones.

Veamos los registros de nuestro contenedor Nginx:

docker logs nginx-detached

Esto muestra todos los registros desde el inicio del contenedor. Para ver solo los registros más recientes, puedes usar la opción --tail:

docker logs --tail 10 nginx-detached

Esto muestra solo las últimas 10 líneas de registro.

Para seguir los registros en tiempo real (como tail -f), usa la opción -f:

docker logs -f nginx-detached

Esto continuará transmitiendo nuevas entradas de registro a medida que se generen. Presiona Ctrl+C para salir de la transmisión de registros.

También puedes obtener marcas de tiempo para tus entradas de registro:

docker logs --timestamps nginx-detached

Esto puede ser especialmente útil para depurar problemas sensibles al tiempo.

Ejecución de comandos en contenedores en ejecución

Docker te permite ejecutar comandos dentro de un contenedor en ejecución, lo cual es increíblemente útil para la depuración y el mantenimiento.

Comencemos ejecutando un comando simple en nuestro contenedor Nginx:

docker exec nginx-detached echo "Hello from inside the container"

Deberías ver impreso en tu terminal "Hello from inside the container".

Ahora, obtengamos una shell interactiva dentro del contenedor:

docker exec -it nginx-detached /bin/bash

Ahora estás dentro del contenedor. Exploremos un poco:

ls /etc/nginx
cat /etc/nginx/nginx.conf
exit

Estos comandos listan el contenido del directorio de configuración de Nginx y muestran el archivo de configuración principal de Nginx. El comando exit te devuelve a la shell de tu sistema host.

Copia de archivos hacia y desde contenedores

Docker ofrece una forma de copiar archivos entre tu sistema host y los contenedores. Esto es útil para tareas como actualizar archivos de configuración o recuperar registros (logs).

Primero, creemos un sencillo archivo HTML en nuestro sistema host:

echo "<html><body><h1>Hello from host</h1></body></html>" > hello.html

Ahora, copiemos este archivo a nuestro contenedor Nginx:

docker cp hello.html nginx-detached:/usr/share/nginx/html/hello.html

Podemos verificar que el archivo se haya copiado ejecutando un comando en el contenedor:

docker exec nginx-detached cat /usr/share/nginx/html/hello.html

Deberías ver el contenido del archivo HTML.

Ahora, copiemos un archivo del contenedor a nuestro host:

docker cp nginx-detached:/etc/nginx/nginx.conf./nginx.conf

Esto copia el archivo de configuración de Nginx desde el contenedor al directorio actual de nuestro host.

Puedes verificar que el archivo se haya copiado:

ls -l nginx.conf

Deberías ver listado el archivo nginx.conf.

Configuración de variables de entorno en contenedores

Las variables de entorno son una forma clave de configurar aplicaciones que se ejecutan en contenedores. Exploremos cómo configurarlas y utilizarlas.

Primero, ejecutemos un nuevo contenedor con una variable de entorno:

docker run --name env-test -e MY_VAR="Hello, Environment" -d ubuntu sleep infinity

Este comando realiza lo siguiente:

• --name env-test: Asigna el nombre "env-test" al contenedor.
• -e MY_VAR="Hello, Environment": Configura una variable de entorno llamada MY_VAR.
• -d: Ejecuta el contenedor en modo desatendido (detached mode).
• ubuntu: Utiliza la imagen de Ubuntu.
• sleep infinity: Mantiene el contenedor en ejecución indefinidamente.

Ahora, verifiquemos que se haya configurado nuestra variable de entorno:

docker exec env-test env | grep MY_VAR

Deberías ver MY_VAR=Hello, Environment! en la salida.

También podemos configurar variables de entorno utilizando un archivo. Crea un archivo llamado env_file con el siguiente contenido.

Puedes usar nano o vim para crear el archivo:

nano env_file

ANOTHER_VAR=From a file
YET_ANOTHER_VAR=Also from the file

Sal del editor y guarda el archivo presionando Ctrl+X, luego Y y Enter.

Ahora, iniciemos otro contenedor utilizando este archivo:

docker run --name env-file-test --env-file env_file -d ubuntu sleep infinity

Verifica las variables de entorno en este nuevo contenedor:

docker exec env-file-test env | grep -E "ANOTHER_VAR|YET_ANOTHER_VAR"

Deberías ver ambas variables del archivo en la salida.

Limitación de recursos de contenedores

Docker te permite limitar los recursos (CPU y memoria) que un contenedor puede utilizar. Esto es crucial para gestionar la asignación de recursos en entornos de múltiples contenedores.

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

docker run --name limited-nginx -d --memory=512m --cpus=0.5 nginx

Este comando hace lo siguiente:

• --name limited-nginx: Asigna el nombre "limited-nginx" al contenedor.
• -d: Ejecuta el contenedor en modo desatendido (detached mode).
• --memory=512m: Limita el contenedor a 512 megabytes de memoria.
• --cpus=0.5: Limita el contenedor para que utilice como máximo la mitad de un núcleo de CPU.
• nginx: Utiliza la imagen de Nginx.

Podemos verificar estos límites utilizando el comando inspect:

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

El primer comando mostrará 536870912 (512MB en bytes), y el segundo mostrará 500000000 (0.5 CPU en nano-unidades).

Para ver cómo estos límites afectan al contenedor en tiempo real, podemos utilizar el comando stats:

docker stats limited-nginx

Esto mostrará una transmisión en vivo de las estadísticas de uso de recursos. Presiona Ctrl+C para salir de la vista de estadísticas.

Resumen

En este laboratorio, hemos explorado técnicas avanzadas de gestión de contenedores en Docker. Hemos aprendido cómo ejecutar contenedores en diferentes modos, gestionar su ciclo de vida, inspeccionar los detalles de los contenedores, trabajar con registros (logs), ejecutar comandos dentro de los contenedores, copiar archivos, configurar variables de entorno y limitar los recursos de los contenedores. Estas habilidades forman una base sólida para trabajar con contenedores Docker en escenarios más complejos.

Recuerda, una gestión efectiva de contenedores es crucial para construir aplicaciones contenerizadas escalables y mantenibles. A medida que continúes tu viaje con Docker, encontrarás que estas habilidades son invaluable para depurar, optimizar y gestionar tus entornos contenerizados.

Sigue practicando estos comandos y explorando las capacidades de Docker. Cuanto más trabajes con contenedores, más cómodo y competente te sentirás. ¡Que disfrutes contenerizando!