Cómo usar el comando docker compose events para monitorear eventos de contenedores

DockerDockerBeginner
Practicar Ahora

💡 Este tutorial está traducido por IA desde la versión en inglés. Para ver la versión original, puedes hacer clic aquí

Introducción

En este laboratorio, aprenderás a utilizar el comando docker compose events para monitorear eventos de contenedores. Comenzaremos preparando un proyecto simple de Docker Compose, que incluye la instalación de Docker Compose y la creación de un archivo básico docker-compose.yml.

Después de la configuración, iniciarás los servicios definidos en el proyecto y observarás los eventos básicos generados. Luego, exploraremos cómo usar la bandera --json para mostrar estos eventos en un formato estructurado JSON. Finalmente, aprenderás a filtrar eventos para monitorear solo aquellos relacionados con servicios específicos dentro de tu aplicación Docker Compose.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL docker(("Docker")) -.-> docker/ContainerOperationsGroup(["Container Operations"]) docker(("Docker")) -.-> docker/ImageOperationsGroup(["Image Operations"]) docker/ContainerOperationsGroup -.-> docker/ps("List Running Containers") docker/ContainerOperationsGroup -.-> docker/start("Start Container") docker/ContainerOperationsGroup -.-> docker/stop("Stop Container") docker/ImageOperationsGroup -.-> docker/pull("Pull Image from Repository") subgraph Lab Skills docker/ps -.-> lab-555078{{"Cómo usar el comando docker compose events para monitorear eventos de contenedores"}} docker/start -.-> lab-555078{{"Cómo usar el comando docker compose events para monitorear eventos de contenedores"}} docker/stop -.-> lab-555078{{"Cómo usar el comando docker compose events para monitorear eventos de contenedores"}} docker/pull -.-> lab-555078{{"Cómo usar el comando docker compose events para monitorear eventos de contenedores"}} end

Preparar un proyecto simple de Docker Compose

En este paso, prepararemos un proyecto simple de Docker Compose. Como Docker Compose no viene preinstalado en el entorno de LabEx, primero lo instalaremos. Docker Compose es una herramienta para definir y ejecutar aplicaciones Docker con múltiples contenedores. Con Compose, usas un archivo YAML para configurar los servicios de tu aplicación. Luego, con un solo comando, creas e inicias todos los servicios desde tu configuración.

Primero, instalemos Docker Compose. Descargaremos el binario de Docker Compose y lo haremos ejecutable.

sudo curl -L "https://github.com/docker/compose/releases/download/v2.20.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

Después de la instalación, puedes verificar que se instaló correctamente revisando la versión de Docker Compose.

docker-compose --version

Deberías ver una salida similar a Docker Compose version v2.20.2.

Ahora, creemos un directorio para nuestro proyecto y accedamos a él. Crearemos un proyecto simple con un solo servicio.

mkdir ~/project/my-compose-app
cd ~/project/my-compose-app

A continuación, crearemos un archivo docker-compose.yml en este directorio. Este archivo definirá nuestro servicio. Usaremos el editor nano para crearlo y editarlo.

nano docker-compose.yml

En el editor nano, pega el siguiente contenido. Esta configuración define un servicio llamado web que utiliza la imagen nginx:latest.

version: "3.8"
services:
  web:
    image: nginx:latest
    ports:
      - "80:80"

Analicemos este archivo docker-compose.yml:

  • version: '3.8' especifica la versión del formato del archivo Docker Compose.
  • services: define los servicios que componen tu aplicación.
  • web: es el nombre de nuestro servicio.
  • image: nginx:latest especifica la imagen de Docker a usar para este servicio. En este caso, estamos usando la última versión de la imagen oficial de Nginx.
  • ports: mapea puertos entre el host y el contenedor. "80:80" mapea el puerto 80 del host al puerto 80 del contenedor.

Guarda el archivo presionando Ctrl + X, luego Y, y Enter.

Antes de iniciar el servicio, descarguemos la imagen nginx:latest. Aunque Docker Compose descargará la imagen si no está presente, hacerlo explícitamente antes puede ser útil en algunos casos.

docker pull nginx:latest

Deberías ver una salida que indica que la imagen se está descargando.

Ahora tenemos nuestro archivo docker-compose.yml listo y la imagen necesaria descargada. En el siguiente paso, iniciaremos el servicio definido en este archivo.

Iniciar los servicios y observar eventos básicos

En este paso, iniciaremos los servicios definidos en nuestro archivo docker-compose.yml y observaremos los eventos básicos generados por Docker. Los eventos de Docker son información en tiempo real sobre lo que ocurre con tu daemon de Docker y contenedores, como creación, inicio, detención y destrucción de contenedores.

Primero, asegúrate de estar en el directorio ~/project/my-compose-app donde creaste el archivo docker-compose.yml en el paso anterior.

cd ~/project/my-compose-app

Ahora, usaremos el comando docker-compose up para iniciar el servicio. La bandera -d ejecuta los contenedores en modo detached (desacoplado), lo que significa que se ejecutarán en segundo plano sin bloquear tu terminal.

docker-compose up -d

Deberías ver una salida que indica que se están creando e iniciando la red y el contenedor del servicio web.

[+] Running 2/2
 ⠿ Network my-compose-app_default  Created
 ⠿ Container my-compose-app-web-1  Started

Para observar los eventos básicos de Docker, usaremos el comando docker events. Este comando transmite eventos desde el daemon de Docker.

docker events

Verás un flujo continuo de eventos relacionados con tu entorno Docker. Como acabamos de iniciar un contenedor, deberías ver eventos relacionados con la creación, inicio y potencialmente otras acciones relacionadas con el contenedor my-compose-app-web-1. La salida será similar a esta (los tiempos y detalles específicos variarán):

2023-10-27T10:00:00.123456789Z container create 1234567890abcdef... (image=nginx:latest, name=my-compose-app-web-1, ...)
2023-10-27T10:00:01.987654321Z container start 1234567890abcdef... (image=nginx:latest, name=my-compose-app-web-1, ...)
...

El comando docker events seguirá ejecutándose y mostrando nuevos eventos a medida que ocurran. Para detener el comando y volver al prompt de tu terminal, presiona Ctrl + C.

También puedes observar el contenedor en ejecución usando el comando docker ps.

docker ps

Deberías ver el contenedor my-compose-app-web-1 listado con un estado de Up.

CONTAINER ID   IMAGE          COMMAND                  CREATED          STATUS          PORTS                               NAMES
...            nginx:latest   "nginx -g 'daemon off"   About a minute ago   Up About a minute   0.0.0.0:80->80/tcp, :::80->80/tcp   my-compose-app-web-1

En este paso, iniciamos exitosamente nuestro servicio Docker Compose y observamos los eventos básicos generados por Docker. En el siguiente paso, exploraremos cómo mostrar estos eventos en formato JSON.

Usar el flag --json para mostrar eventos en formato JSON

En este paso, aprenderemos cómo mostrar eventos de Docker en formato JSON usando el flag --json con el comando docker events. Mostrar eventos en formato JSON es útil para procesamiento programático e integración con otras herramientas.

Primero, asegúrate de estar en el directorio ~/project/my-compose-app.

cd ~/project/my-compose-app

Ahora, ejecutemos el comando docker events con el flag --json. Esto mostrará los eventos en formato JSON.

docker events --json

Verás un flujo continuo de objetos JSON, donde cada objeto representa un evento de Docker. La salida será similar a esta (los detalles variarán):

{"status":"create","id":"1234567890abcdef...","from":"nginx:latest","Type":"container","Action":"create","Actor":{"ID":"1234567890abcdef...","Attributes":{"image":"nginx:latest","name":"my-compose-app-web-1"}},"scope":"local","time":1678886400,"timeNano":1678886400123456789}
{"status":"start","id":"1234567890abcdef...","from":"nginx:latest","Type":"container","Action":"start","Actor":{"ID":"1234567890abcdef...","Attributes":{"image":"nginx:latest","name":"my-compose-app-web-1"}},"scope":"local","time":1678886401,"timeNano":1678886401987654321}
...

Cada línea es un objeto JSON válido que contiene información detallada sobre el evento, como el status del evento, el id del objeto afectado, Type, Action, y detalles del Actor incluyendo Attributes como el nombre de la imagen y el nombre del contenedor.

Para demostrar cómo capturar estos eventos, detengamos y luego iniciemos nuevamente el servicio web mientras el comando docker events --json se ejecuta en otra terminal o en segundo plano. Como estamos usando una sola terminal en este laboratorio, primero detendremos el comando docker events --json presionando Ctrl + C.

Ahora, detengamos el servicio web.

docker-compose stop web

Deberías ver una salida que indica que el contenedor web se está deteniendo.

[+] Stopping 1/1
 ⠿ Container my-compose-app-web-1  Stopped

Ahora, ejecutemos docker events --json en segundo plano y luego iniciemos el servicio nuevamente. Usaremos el símbolo & para ejecutar el comando en segundo plano.

docker events --json &

Verás un ID de proceso (PID) impreso, indicando que el comando se está ejecutando en segundo plano.

Ahora, inicia el servicio web nuevamente.

docker-compose start web

Deberías ver una salida que indica que el contenedor web se está iniciando.

[+] Starting 1/1
 ⠿ Container my-compose-app-web-1  Started

El comando docker events --json ejecutándose en segundo plano capturará los eventos stop y start. Para ver la salida del proceso en segundo plano, podrías necesitar traerlo al primer plano usando el comando fg, o revisar la salida de la terminal después de que el proceso en segundo plano se detenga. Sin embargo, para el propósito de este paso, simplemente ejecutar el comando con --json es suficiente para entender el formato.

Para detener el proceso en segundo plano docker events --json, puedes usar el comando jobs para listar trabajos en segundo plano y luego kill %<job_number>. Alternativamente, puedes encontrar el ID del proceso usando ps aux | grep 'docker events --json' y usar el comando kill con el PID. Una forma más simple en este contexto es simplemente continuar al siguiente paso, ya que el proceso en segundo plano no interferirá significativamente.

En este paso, usamos exitosamente el flag --json para ver eventos de Docker en un formato JSON estructurado, lo cual es valioso para automatización y análisis.

Filtrar eventos para servicios específicos

En este paso, aprenderemos cómo filtrar eventos de Docker para ver solo aquellos relacionados con servicios o contenedores específicos. Esto es muy útil en entornos con muchos contenedores donde solo deseas monitorear eventos para una aplicación o servicio particular.

El comando docker events soporta filtrado usando el flag --filter. Puedes filtrar por varios criterios como container, image, event, label, etc.

Primero, asegúrate de estar en el directorio ~/project/my-compose-app.

cd ~/project/my-compose-app

Nuestro servicio se llama web en el archivo docker-compose.yml, y el nombre del contenedor generado por Docker Compose típicamente sigue el formato <nombre_proyecto>_<nombre_servicio>_<número_instancia>. En nuestro caso, el nombre del proyecto es my-compose-app (derivado del nombre del directorio), el nombre del servicio es web, y el número de instancia es 1. Por lo tanto, el nombre del contenedor es my-compose-app-web-1.

Filtremos los eventos para mostrar solo aquellos relacionados con nuestro contenedor web. Podemos usar el filtro container con el nombre del contenedor.

docker events --filter container=my-compose-app-web-1

Este comando ahora solo mostrará eventos donde el objeto afectado sea el contenedor llamado my-compose-app-web-1. Para ver esto en acción, detengamos e iniciemos nuevamente el servicio web mientras este comando se ejecuta.

Primero, detén el comando docker events presionando Ctrl + C.

Ahora, ejecuta el comando docker events filtrado en segundo plano.

docker events --filter container=my-compose-app-web-1 &

Verás el ID del proceso en segundo plano.

Ahora, detén el servicio web usando Docker Compose.

docker-compose stop web

Deberías ver una salida indicando que el contenedor se está deteniendo. El comando docker events en segundo plano debería capturar el evento stop para el contenedor my-compose-app-web-1.

Luego, inicia el servicio web nuevamente.

docker-compose start web

Deberías ver una salida indicando que el contenedor se está iniciando. El comando docker events en segundo plano debería capturar el evento start para el contenedor my-compose-app-web-1.

También puedes filtrar por otros criterios. Por ejemplo, para filtrar eventos por imagen, podrías usar --filter image=nginx:latest.

Para detener el proceso docker events en segundo plano, puedes usar jobs y kill %<número_trabajo> o encontrar el PID y usar kill <PID>. Para este laboratorio, puedes simplemente continuar.

Finalmente, limpiemos el contenedor en ejecución y la red creada por Docker Compose.

docker-compose down

Este comando detendrá y eliminará los contenedores, redes y volúmenes definidos en el archivo docker-compose.yml.

[+] Running 2/1
 ⠿ Container my-compose-app-web-1  Removed
 ⠿ Network my-compose-app_default  Removed

En este paso, aprendimos cómo filtrar eventos de Docker usando el flag --filter, lo cual es esencial para monitorear componentes específicos en un entorno Docker ocupado. También limpiamos los recursos creados durante el laboratorio.

Resumen

En este laboratorio, aprendimos a utilizar el comando docker compose events para monitorear eventos de contenedores. Comenzamos preparando un proyecto simple de Docker Compose, lo que incluyó la instalación de Docker Compose y la creación de un archivo docker-compose.yml definiendo un servicio básico de Nginx.

Después de configurar el proyecto, iniciamos los servicios y observamos los eventos básicos generados por Docker Compose. Luego exploramos cómo mostrar estos eventos en formato JSON usando el flag --json para facilitar su análisis y procesamiento. Finalmente, aprendimos a filtrar los eventos para monitorear solo aquellos relacionados con servicios específicos dentro de nuestro proyecto de Docker Compose.