Docker containers

El comando docker run

El comando docker run es la herramienta fundamental para crear y ejecutar contenedores a partir de las imágenes Docker que hemos descargado previamente. Este comando combina la creación de un nuevo contenedor con su inicio inmediato, permitiéndonos transformar una imagen estática en un entorno ejecutable.

Sintaxis básica

La estructura básica del comando docker run sigue este patrón:

docker run [OPCIONES] IMAGEN [COMANDO] [ARG...]

En su forma más simple, podemos ejecutar un contenedor especificando únicamente la imagen:

docker run nginx

Este comando descarga la imagen nginx (si no está disponible localmente) y crea un contenedor que ejecuta el servidor web Nginx en primer plano.

Modos de ejecución

Docker run ofrece dos modos principales de ejecución que determinan cómo interactúa el contenedor con nuestra terminal.

Modo foreground (primer plano):

docker run nginx

En este modo, el contenedor se ejecuta en primer plano y bloquea la terminal. Veremos la salida del proceso principal del contenedor directamente en nuestra consola.

Modo detached (segundo plano):

docker run -d nginx

La opción -d (detached) ejecuta el contenedor en segundo plano, liberando la terminal y devolviendo el ID del contenedor creado. Este es el modo más común para servicios y aplicaciones web.

Asignación de nombres

Por defecto, Docker asigna nombres aleatorios a los contenedores. Podemos especificar un nombre personalizado usando la opción --name:

docker run -d --name mi-servidor-web nginx

Esto facilita la identificación y gestión del contenedor, especialmente cuando trabajamos con múltiples instancias.

Publicación de puertos

Los contenedores ejecutan aplicaciones que pueden escuchar en puertos específicos. Para acceder a estos servicios desde nuestro host, necesitamos mapear los puertos del contenedor:

docker run -d -p 8080:80 --name web-server nginx

La sintaxis -p HOST_PORT:CONTAINER_PORT mapea el puerto 8080 del host al puerto 80 del contenedor. Ahora podemos acceder al servidor Nginx navegando a http://localhost:8080.

Para mapear múltiples puertos:

docker run -d -p 8080:80 -p 8443:443 --name web-server nginx

Variables de entorno

Muchas aplicaciones requieren configuración a través de variables de entorno. Usamos la opción -e para definirlas:

docker run -d -e MYSQL_ROOT_PASSWORD=mi-password --name mysql-db mysql:8.0

Para múltiples variables de entorno:

docker run -d \
  -e MYSQL_ROOT_PASSWORD=mi-password \
  -e MYSQL_DATABASE=mi-app \
  -e MYSQL_USER=usuario \
  -e MYSQL_PASSWORD=password \
  --name mysql-db mysql:8.0

Modo interactivo

Para contenedores que requieren interacción directa, combinamos las opciones -i (interactivo) y -t (pseudo-terminal):

docker run -it ubuntu:22.04 bash

Esto nos proporciona una sesión bash interactiva dentro del contenedor Ubuntu, permitiéndonos ejecutar comandos como si estuviéramos en un sistema Linux completo.

Eliminación automática

La opción --rm elimina automáticamente el contenedor cuando termina su ejecución:

docker run --rm -it ubuntu:22.04 bash

Esto es especialmente útil para tareas temporales o pruebas, evitando acumular contenedores detenidos innecesarios.

Ejemplo práctico completo

Combinando las opciones más comunes, podemos crear un servidor web completo:

docker run -d \
  --name servidor-nginx \
  -p 8080:80 \
  -e NGINX_HOST=localhost \
  nginx:latest

Este comando:

• Ejecuta en segundo plano (-d) un contenedor Nginx
• Asigna el nombre servidor-nginx
• Mapea el puerto 8080 del host al 80 del contenedor
• Configura una variable de entorno para el host
• Utiliza la última versión de la imagen nginx

Especificación de comandos personalizados

Podemos sobrescribir el comando predeterminado de una imagen especificando uno alternativo:

docker run -it ubuntu:22.04 /bin/sh

O ejecutar comandos específicos:

docker run --rm ubuntu:22.04 ls -la /

Esto ejecuta el comando ls -la / dentro del contenedor Ubuntu y termina inmediatamente, mostrando el contenido del directorio raíz.

El comando docker run es la puerta de entrada al mundo de los contenedores Docker, proporcionando la flexibilidad necesaria para ejecutar aplicaciones en entornos aislados y reproducibles. Una vez que dominamos estas opciones fundamentales, podemos crear y configurar contenedores para prácticamente cualquier aplicación o servicio.

Ciclo de vida de un contenedor

Un contenedor Docker pasa por diferentes estados durante su existencia, desde su creación hasta su eliminación. 

Comprender este ciclo de vida y saber cómo gestionar cada estado es fundamental para trabajar eficazmente con contenedores en entornos de desarrollo y producción.

Estados del ciclo de vida

Los contenedores Docker pueden encontrarse en varios estados principales:

• Created: El contenedor ha sido creado pero no se ha iniciado
• Running: El contenedor está ejecutándose activamente
• Paused: El contenedor está pausado temporalmente
• Stopped/Exited: El contenedor se ha detenido
• Dead: El contenedor ha terminado de forma anormal

Visualizar contenedores activos

El comando docker ps nos permite listar los contenedores que están ejecutándose en nuestro sistema:

docker ps

Este comando muestra información esencial de cada contenedor activo:

• CONTAINER ID: Identificador único corto del contenedor
• IMAGE: Imagen utilizada para crear el contenedor
• COMMAND: Comando que ejecuta el contenedor
• CREATED: Tiempo transcurrido desde la creación
• STATUS: Estado actual del contenedor
• PORTS: Mapeo de puertos configurado
• NAMES: Nombre asignado al contenedor

Para ver contenedores con formato personalizado:

docker ps --format "table {{.Names}}\t{{.Image}}\t{{.Status}}\t{{.Ports}}"

Listar todos los contenedores

Para visualizar todos los contenedores, incluidos los detenidos, utilizamos la opción -a (all):

docker ps -a

Este comando es especialmente útil para identificar contenedores que han terminado su ejecución o que están detenidos y pueden necesitar limpieza.

También podemos usar filtros para buscar contenedores específicos:

docker ps -a --filter "name=nginx"
docker ps -a --filter "status=exited"

Detener contenedores

Para detener un contenedor en ejecución, usamos el comando docker stop:

docker stop mi-servidor-web

También podemos usar el ID del contenedor:

docker stop a1b2c3d4e5f6

Docker envía una señal SIGTERM al proceso principal del contenedor, permitiéndole terminar de forma controlada. Si el proceso no responde en 10 segundos, Docker envía una señal SIGKILL.

Para detener múltiples contenedores simultáneamente:

docker stop servidor-web base-datos cache-redis

Iniciar contenedores detenidos

Un contenedor detenido puede reiniciarse utilizando el comando docker start:

docker start mi-servidor-web

A diferencia de docker run, que crea un nuevo contenedor, docker start reutiliza un contenedor existente con toda su configuración original.

Para iniciar múltiples contenedores:

docker start servidor-web base-datos

Si queremos ver la salida del contenedor al iniciarlo:

docker start -a mi-servidor-web

Reiniciar contenedores

El comando docker restart combina las operaciones de stop y start en una sola acción:

docker restart mi-servidor-web

Este comando es útil cuando necesitamos aplicar cambios de configuración o resolver problemas temporales sin recrear el contenedor.

Para reiniciar con un tiempo de espera personalizado:

docker restart -t 30 mi-servidor-web

Pausar y reanudar contenedores

Docker permite pausar temporalmente la ejecución de un contenedor sin detenerlo completamente:

docker pause mi-servidor-web

Un contenedor pausado mantiene su estado en memoria pero no consume recursos de CPU. Para reanudarlo:

docker unpause mi-servidor-web

Esta funcionalidad es útil para liberar recursos temporalmente sin perder el estado de la aplicación.

Eliminar contenedores

Para eliminar un contenedor detenido:

docker rm mi-servidor-web

Los contenedores en ejecución deben detenerse primero, o podemos forzar su eliminación:

docker rm -f mi-servidor-web

Para eliminar múltiples contenedores:

docker rm contenedor1 contenedor2 contenedor3

Limpieza automática

Para eliminar todos los contenedores detenidos de una vez:

docker container prune

Este comando solicita confirmación antes de proceder. Para ejecutarlo sin confirmación:

docker container prune -f

Obtener información detallada

El comando docker inspect proporciona información completa sobre un contenedor:

docker inspect mi-servidor-web

Esto devuelve un JSON con toda la configuración, estado, redes y volúmenes del contenedor.

Para extraer información específica:

docker inspect --format='{{.State.Status}}' mi-servidor-web
docker inspect --format='{{.NetworkSettings.IPAddress}}' mi-servidor-web

Ejemplo práctico de gestión

Veamos un flujo completo de gestión de contenedores:

1. Crear y ejecutar un servidor Nginx:

docker run -d -p 8080:80 --name web-server nginx

2. Verificar que está ejecutándose:

docker ps

3. Detener el servidor temporalmente:

docker stop web-server

4. Verificar el estado:

docker ps -a

5. Reiniciar el servidor:

docker start web-server

6. Reiniciar completamente:

docker restart web-server

7. Limpiar cuando termine:

docker stop web-server
docker rm web-server

Gestión eficiente con múltiples contenedores

Cuando trabajamos con varios contenedores, podemos usar patrones para gestionarlos eficientemente:

Detener todos los contenedores:

docker stop $(docker ps -q)

Eliminar todos los contenedores detenidos:

docker rm $(docker ps -a -q -f status=exited)

Ver solo los nombres de contenedores activos:

docker ps --format "table {{.Names}}\t{{.Status}}"

La gestión del ciclo de vida de contenedores es una habilidad esencial que nos permite mantener un entorno Docker organizado y eficiente. Estos comandos forman la base para operaciones más avanzadas y son fundamentales en cualquier flujo de trabajo con contenedores.

Docker exec

docker exec es un comando que te permite ejecutar comandos dentro de un contenedor de Docker que ya está corriendo. Es muy útil para depuración, mantenimiento, inspección de archivos, o para ejecutar tareas adicionales en un contenedor en ejecución.

Sintaxis básica:

docker exec [OPCIONES] CONTENEDOR COMANDO [ARG...]

Opciones más comunes:

• -i: Mantiene STDIN abierto (interactivo)
• -t: Asigna una pseudo-TTY (terminal)
• -d: Ejecuta en modo detached (segundo plano)
• -u: Especifica el usuario
• -w: Especifica el directorio de trabajo

Ejemplo práctico:

Supongamos que tienes un contenedor web corriendo:

# 1. Crear y ejecutar un contenedor nginx
docker run -d --name mi-nginx -p 8080:80 nginx

# 2. Verificar que está corriendo
docker ps

# 3. Acceder al contenedor de forma interactiva
docker exec -it mi-nginx bash

# 4. Una vez dentro del contenedor, puedes explorar
ls -la
cd /usr/share/nginx/html
cat index.html

# 5. Salir del contenedor
exit

Otros ejemplos útiles:

# Ejecutar un comando específico sin entrar al contenedor
docker exec mi-nginx ls -la /etc/nginx

# Ejecutar como root (útil si el contenedor corre con otro usuario)
docker exec -u root mi-nginx apt-get update

# Ejecutar en segundo plano
docker exec -d mi-nginx nginx -s reload

# Acceder con un shell específico
docker exec -it mi-nginx /bin/sh

Diferencia con docker run:

• docker run: Crea y ejecuta un nuevo contenedor.
• docker exec: Ejecuta comandos en un contenedor existente que ya está corriendo, es especialmente útil para tareas de administración, debugging, y para acceder a contenedores que están corriendo servicios en producción.