En el episodio 435 del podcast que titulé Que le DEN a Docker, hablé sobre una herramienta que había implementado en Rust, que permitía monitorizar o vigilar todos tus contenedores, redes e imágenes que tuvieras funcionando bajo Docker. En este tiempo, la he estado utilizando, primero con Mattermost, para luego continuar Mattermost y ZincSearch. Sin embargo, por motivos que te contaré la próxima semana, la cuestión es que he decidido implementar algunos cambios, lo que me ha llevado a implementar mas publicadores, entre los que se encuentra además de ZincObserve uno para publicar con Mqtt, para el caso de que estés en el camino del IoT.

Vigilando Docker con DEN y las etiquetas

Sobre las etiquetas de Docker

Claro, puedo explicarte qué son las etiquetas de Docker, para qué se pueden utilizar y cómo usarlas.

¿Qué son las etiquetas de Docker?

En Docker, las «etiquetas» se refieren a metadatos que se pueden asociar a imágenes de contenedores y contenedores en sí. Estos metadatos son pares clave-valor que proporcionan información adicional sobre una imagen o un contenedor en particular. Las etiquetas son útiles para organizar, buscar y administrar imágenes y contenedores de manera más eficiente.

¿Para qué se pueden utilizar las etiquetas de Docker?

Las etiquetas de Docker tienen varias aplicaciones:

• Organización: Puedes usar etiquetas para categorizar y organizar imágenes y contenedores. Por ejemplo, puedes etiquetar una imagen como «desarrollo» o «producción» para indicar su entorno de uso.
• Identificación: Las etiquetas son útiles para identificar versiones específicas de imágenes o aplicaciones. Puedes etiquetar una imagen con un número de versión o un identificador único.
• Búsqueda: Facilitan la búsqueda de imágenes y contenedores relacionados. Puedes buscar imágenes basadas en sus etiquetas para encontrar rápidamente lo que necesitas.
• Gestión: Las etiquetas pueden ayudar en la gestión de ciclos de vida de contenedores e imágenes. Por ejemplo, puedes etiquetar un contenedor como «detenido» o «en ejecución» para indicar su estado actual.

¿ómo se pueden utilizar las etiquetas de Docker?

A continuación, te mostraré cómo usar etiquetas en Docker para imágenes y contenedores:

1. Etiquetar una imagen:

Puedes etiquetar una imagen durante o después de su construcción. Para etiquetar una imagen durante la construcción, puedes usar el siguiente comando:

docker build -t nombre_de_la_imagen:etiqueta .

Por ejemplo:

docker build -t mi_aplicacion:v1 .

Esto asigna la etiqueta «v1» a la imagen.

2. Etiquetar un contenedor:

Puedes etiquetar un contenedor en el momento de su creación o posteriormente usando el siguiente comando:

docker run --name nombre_del_contenedor --label clave=valor nombre_de_la_imagen

Por ejemplo:

docker run --name mi_contenedor --label ambiente=desarrollo mi_aplicacion:v1

Esto asigna la etiqueta «ambiente=desarrollo» al contenedor.

3. Listar etiquetas:

Para ver las etiquetas asociadas a imágenes o contenedores, puedes usar los siguientes comandos:

• Listar etiquetas de una imagen:

  docker image inspect --format '{{ .Config.Labels }}' nombre_de_la_imagen

• Listar etiquetas de un contenedor:

  docker inspect --format '{{ .Config.Labels }}' nombre_del_contenedor

¿Como se utilizan las etiquetas de Docker con Traefik?

Traefik es un proxy inverso y un balanceador de carga diseñado específicamente para su uso con contenedores y microservicios. Puedes utilizar las etiquetas de Docker junto con Traefik para configurar y administrar las reglas de enrutamiento de manera dinámica para tus aplicaciones en contenedores. Esto es especialmente útil cuando deseas que Traefik detecte automáticamente las rutas y configuraciones para tus servicios basados en contenedores.

Debes etiquetar tus contenedores con las etiquetas específicas que Traefik utiliza para configurar el enrutamiento. Las etiquetas de Traefik suelen comenzar con traefik. seguido de la configuración que deseas aplicar. Algunas etiquetas comunes son:

    traefik.enable=true para habilitar la administración de Traefik para un contenedor específico.
    traefik.http.routers.nombre_del_router.rule=Host("nombre_del_host") para definir una regla de enrutamiento basada en el host.
    traefik.http.services.nombre_del_servicio.loadbalancer.server.port=puerto para configurar el puerto de destino del servicio.
    traefik.docker.network=nombre_de_la_red para especificar la red Docker a la que está conectado el contenedor.

¿como se utilizan las etiquetas de docker con watchtower?

Watchtower es una herramienta que automatiza la actualización de contenedores Docker cuando nuevas imágenes estén disponibles en el registro de contenedores. Puedes utilizar etiquetas de Docker junto con Watchtower para especificar cómo y cuándo deseas que Watchtower actualice tus contenedores. A continuación, te mostraré cómo hacerlo:

1. Ejecuta Watchtower: Primero, asegúrate de tener Watchtower en ejecución en tu entorno Docker. Puedes ejecutarlo como un contenedor independiente con un comando como este:

   docker run -d --name watchtower -v /var/run/docker.sock:/var/run/docker.sock containrrr/watchtower

Esto inicia Watchtower como un contenedor que tiene acceso al socket de Docker para supervisar los contenedores y las imágenes.

2. Etiqueta tus contenedores: Para controlar cómo Watchtower actualiza tus contenedores, puedes etiquetarlos con las siguientes etiquetas específicas:

• com.centurylinklabs.watchtower.enable (obligatorio): Debes establecer esta etiqueta en «true» para habilitar Watchtower para un contenedor específico.
• com.centurylinklabs.watchtower.schedule (opcional): Puedes utilizar esta etiqueta para especificar cuándo Watchtower debe buscar actualizaciones de imágenes. Puedes definir un horario en formato Cron para programar las actualizaciones. Por ejemplo, para etiquetar un contenedor que debe actualizarse todos los días a las 2 a.m., puedes usar estas etiquetas:

   docker run -d \
     --name mi_contenedor \
     --label com.centurylinklabs.watchtower.enable=true \
     --label com.centurylinklabs.watchtower.schedule="0 2 * * *"
     mi_imagen

3. Controla la actualización de los contenedores: Watchtower ahora supervisará los contenedores que tienen la etiqueta com.centurylinklabs.watchtower.enable establecida en «true» y seguirá el horario especificado en la etiqueta com.centurylinklabs.watchtower.schedule. Cuando Watchtower detecte una nueva versión de la imagen, actualizará automáticamente el contenedor. Ten en cuenta que Watchtower también admite otras etiquetas y opciones avanzadas para personalizar aún más el comportamiento de actualización, como com.centurylinklabs.watchtower.stop-signal para especificar la señal de parada y com.centurylinklabs.watchtower.pull.mode para definir cómo se deben obtener las nuevas imágenes (por ejemplo, «always» para siempre obtener la última imagen).

Con estas etiquetas, puedes automatizar la actualización de tus contenedores Docker utilizando Watchtower según tus necesidades específicas. Watchtower se encargará de mantener tus aplicaciones actualizadas sin que tengas que intervenir manualmente en cada contenedor.

docker run -d \
  --name mi_contenedor \
  --label traefik.enable=true \
  --label traefik.http.routers.mi_router.rule=Host("miapp.com") \
  --label traefik.http.services.mi_servicio.loadbalancer.server.port=80 \
  mi_imagen_de_nginx

Por ejemplo, para etiquetar un contenedor de Nginx para que Traefik lo enrutamiento según el nombre de host «miapp.com» en el puerto 80, puedes usar estas etiquetas:

La nueva versión de DEN

DEN es una herramienta implementada en Rust, que te permite estar informado de todos los eventos que se producen en tus contenedores, imágenes, volúmenes, redes, etc de Docker. ¿Como te mantiene informado? Para mantenerte informado utiliza diferentes publicadores. Así cuando se produce cualquier evento, te notifica mediante estos publicadores. Por ejemplo, tienes los siguientes notificadores,

• Discord
• Slack
• Telegram
• Mattermost
• ZincObserve
• Matrix
• Rabbitmq
• Mosquitto

Es posible definir un mensaje particularizado para cada evento que se produce, y para ello utiliza jinja2, que me has oído hablar en los últimos podcast. La configuración de DEN, es algo similar a la que te muestro a continuación,

settings:
  # Log verbosity <debug, info (default), warn, error>
  logging: debug
  # if `monitorize_always=true` all container are monitorized except has the
  # label `es.atareao.den.monitorize=false`
  # if `monitorize_always=false` only container with the following label
  # `es.atareao.den.monitorize=true` will be monitorized
  monitorize_always: true

objects:
  #  https://docs.docker.com/engine/reference/commandline/events/
  - name: container
    monitorize: true
    # attach, commit, copy, create, destroy, detach, die, exec_create,
    # exec_detach, exec_die, exec_start, export, health_status, kill, oom,
    # pause, rename, resize, restart, start, stop, top, unpause, update
    events:
      - name: 'health_status: unhealthy'
        message: "📦🤒 Container unhealty
            DateTime: {{ timestamp|datetimeformat(format='iso') }}\n
            Hostname: {{hostname}}\n
            Container: {{container}}\n
            Image: {{image}}"
      - name: destroy
        message: "📦💥 Destroyed container\n
            DateTime: {{ timestamp|datetimeformat(format='iso') }}\n
            Hostname: {{hostname}}\n
            Container: {{container}}\n
            Image: {{image}}"
      - name: stop
        message: "📦✋ Stopped container
            DateTime: {{ timestamp|datetimeformat(format='iso') }}\n
            Hostname: **{{hostname}}**\n
            Container: **{{container}}**\n
            Image: **{{image}}**"
      - name: start
        message: "📦🏁 Started container\n
            DateTime: {{ timestamp|datetimeformat(format='iso') }}\n
            Hostname: **{{hostname}}**\n
            Container: **{{container}}**\n
            Image: **{{image}}**"
      - name: create
        message: "### 📦🆕 Created container\n
            * DateTime: {{ timestamp|datetimeformat(format='iso') }}\n
            * Hostname: **{{hostname}}**\n
            * Container: **{{container}}**\n
            * Image: **{{image}}**"
      - name: die
        message: "📦☠️  Died container\n
            DateTime: {{ timestamp|datetimeformat(format='iso') }}\n
            Hostname: {{hostname}}\n
            Container: {{container}}\n
            Image: {{image}}"
  - name: image
    monitorize: true
    # delete, import, load, pull, push, save, tag, untag
    events:
      - name: delete
        message: Deleted image
  - name: plugin
    monitorize: false
    # enable, disable, install, remove
    events: []
  - name: volume
    monitorize: true
    # create, destroy, mount, unmount
    events:
      - name: destroy
        message: "🥃💥 Volume destroyed
            DateTime: {{ timestamp|datetimeformat(format='iso') }}\n
            Hostname: {{hostname}}\n
            Volume: {{volume}}"
      - name: create
        message: "🥃🆕 Volume created \n
            DateTime: {{now | date(format='%H:%M:%S %d-%m-%Y', timezone='Europe/Madrid')}}\n
            Hostname: {{hostname}}\n
            Volume: {{volume}}"
  - name: network
    monitorize: true
    # create, connect, destroy, disconnect, remove
    events:
      - name: destroy
        message: "🕸️💥 Network destroyed\n
            DateTime: {{ timestamp|datetimeformat(format='iso') }}\n
            Hostname: {{hostname}}\n
            Network: {{network}}"
  - name: daemon
    monitorize: false
    # reload
    events: []
  - name: service
    monitorize: false
    # create, remove, update
    events: []
  - name: node
    monitorize: false
    # create, remove, update
    events: []
  - name: secret
    monitorize: false
    # create, remove, update
    events: []
  - name: config
    monitorize: false
    # create, remove, update
    events: []

publishers: ## Available publishers
  - service: slack
    enabled: false
    config:
      url: https://hooks.slack.com/services/<your_uuid>
  - service: discord
    enabled: false
    config:
      url: https://discordapp.com/api/webhooks/<your_uuid>
  - service: mattermost
    enabled: false
    config:
      url: https://mm.tusitio.como
      token: xxxxxxxxxxxxxxxxxxxx
      channel_id: xxxxxxxxxxxxxxxxxxx
  - service: telegram
    enabled: false
    config:
      url: https://api.telegram.org
      token:
      chat_id:
  - service: zinc
    enabled: true
    config:
      url: https://zincobserve.tusitio.como
      token: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
      index: docker
  - service: matrix
    enabled: false
    config:
      url: matrix.tusitio.como
      token: xxxxxxxxxxxxxxxxxxxxxxxxxxx
      room: "!xxxxxxxxxxxxxxxxxxxxxxxx"
  - service: mosquitto
    enabled: true
    config:
      user: guest
      password: guest
      host: localhost
      port: 1883
      topic: bonzo/dog
  - service: rabbitmq
    enabled: false
    config:
      user: guest
      password: guest
      host: localhost
      port: 5672
      queue: docker

Para utilizar DEN con docker-compose.yml, simplemente tienes que hacer uso de este archivo,

version: "3.7"

services:
  den:
    image: atareao/den:latest
    container_name: den
    init: true
    restart: unless-stopped
    hostname: co1
    volumes:
      - ./config.yml:/app/config.yml
      - /var/run/docker.sock:/var/run/docker.sock

Si utilizas la opción monitorize_always=true en el config.yml, se monitorizan todos los contenedores, excepto aquellos que tengas con la etiqueta es.atareao.den.monitorize=false. Mientras que si la configuración es al revés, solo se monitorizaran aquellos que es.atareao.den.monitorize=true

---

Espero que te haya gustado este nuevo episodio del podcast. Si puedes, te agradecería una valoración en iVoox y/o en Apple Podcast.