Docker Engine registra un evento ogni volta che il demone esegue azioni significative. È possibile accedere al registro eventi per identificare quando si è verificata un'azione e tenere traccia delle modifiche agli oggetti nel tempo.

In questo articolo, spiegheremo cosa viene acquisito come eventi e quando potresti volerli visualizzare. Mostreremo quindi come monitorare gli eventi in tempo reale utilizzando la Docker CLI e l'API REST.

Cosa sono gli eventi Docker?

Gli eventi Docker descrivono le attività svolte dal tuo demone Docker. La maggior parte delle interazioni con oggetti come contenitori, immagini, volumi e reti registra un evento, creando un registro che è possibile utilizzare per esaminare le modifiche precedenti.

Esistono diversi tipi di eventi che identificano cambiamenti specifici nel tuo ambiente:

• Creazione e rimozione di contenitori
• Stati del controllo dello stato del contenitore
• Comandi eseguiti all'interno di container con docker exec
• Tirare e spingere le immagini
• Creazione, distruzione, montaggio e smontaggio di volumi
• Abilitazione e disabilitazione dei plugin del demone Docker

È possibile visualizzare l'elenco completo nella documentazione di Docker.

Ogni evento registrato include un timestamp e l'ID dell'oggetto interessato. Puoi utilizzare queste informazioni per assemblare una cronologia delle modifiche al tuo ambiente, indipendentemente dal fatto che tu abbia osservato o meno i loro trigger originali.

Gli eventi archiviati possono anche aiutare a diagnosticare problemi come errori imprevisti del contenitore. La visualizzazione del registro consente di identificare l'ora precisa in cui un container si è fermato, fornendo un punto dati che è possibile correlare con gli altri registri. Gli eventi possono stabilire quando i controlli di integrità di un container hanno iniziato a fallire, restringendo il periodo di interesse quando è necessario ispezionare i servizi esterni per determinare la causa principale di un problema.

Streaming di eventi Docker con Docker CLI

Il comando Docker docker events CLI trasmette gli eventi dal tuo demone Docker alla finestra del tuo terminale. Gli eventi appariranno in tempo reale fino a quando non terminerai il processo premendo la combinazione di tasti Ctrl+C.

L'esecuzione del comando senza argomenti non mostrerà alcun output per cominciare. Viene visualizzata solo la nuova attività, quindi l'output rimane vuoto finché non si verifica un evento. Puoi provocarne uno avviando un nuovo contenitore in una shell diversa:

 $ docker run --rm ciao-mondo

Ora dovrebbero apparire diversi eventi nella finestra del terminale che esegue il comando docker events :

 2022-05-31T15:20:00.267970018+01:00 image pull hello-world:latest (name=hello-world)
2022-05-31T15:20:00.347054862+01:00 container create 4a6c8d34a183363db5dbfdcc3cab4c82c4a341d719df56ec2e7f879ee8f02378 (image=hello-world, name=nifty_morse)
2022-05-31T15:20:00.347805277+01:00 contenitore allegare 4a6c8d34a183363db5dbfdcc3cab4c82c4a341d719df56ec2e7f879ee8f02378 (image=hello-world, name=nifty_morse)
2022-05-31T15:20:00.621070053+01:00 inizio container 4a6c8d34a183363db5dbfdcc3cab4c82c4a341d719df56ec2e7f879ee8f02378 (image=hello-world, name=nifty_morse)
...

Ogni evento viene visualizzato su una propria riga. Viene visualizzato prima il timestamp dell'evento, seguito dal tipo di oggetto interessato (come image o container ) e quindi dall'azione eseguita (come create , attach e start ). Il resto del messaggio contiene utili metadati sull'oggetto. L'esempio sopra rivela che l'immagine hello-world:latest è stata estratta e da essa è stato creato un contenitore.

Formattazione dell'output

L'elenco degli eventi grezzo è spesso ingombrante. Puoi riformattare l'output usando il flag --format che accetta una stringa modello Go:

 $ eventi docker --format '{{ .Time }} {{ .Action }} {{ .Type}} {{ .ID }}'

L'esecuzione di questo esempio produrrà un output simile al seguente:

 1654006800 pull image hello-world:latest
1654006800 crea contenitore 4a6c8d34a183363db5dbfdcc3cab4c82c4a341d719df56ec2e7f879ee8f02378
1654006800 allegare contenitore 4a6c8d34a183363db5dbfdcc3cab4c82c4a341d719df56ec2e7f879ee8f02378
1654006800 avviare il contenitore 4a6c8d34a183363db5dbfdcc3cab4c82c4a341d719df56ec2e7f879ee8f02378

Puoi ottenere eventi rappresentati come oggetti JSON utilizzando {{ json . }} {{ json . }} come stringa del modello:

 $ eventi docker --format '{{ json . }}' | jq
{
  "stato": "crea",
  "id": "4a6c8d34a183363db5dbfdcc3cab4c82c4a341d719df56ec2e7f879ee8f02378",
  "da": "ciao-mondo",
  "Tipo": "contenitore",
  "Azione": "crea",
  "Attore": {
    "ID": "4a6c8d34a183363db5dbfdcc3cab4c82c4a341d719df56ec2e7f879ee8f02378",
    "Attributi": {
      "image": "ciao-mondo",
      "nome": "nifty_morse"
    }
  },
  "ambito": "locale",
  "tempo": 1654006800,
  "timeNano": 1654006800347054800
}

Qui il JSON grezzo viene passato attraverso jq , quindi è abbastanza stampato nel tuo terminale. Ciò semplifica la scansione delle informazioni.

Quando crei stringhe di formato personalizzate, puoi utilizzare le proprietà nell'output JSON come riferimento per i segnaposto supportati. Nella maggior parte dei casi dovrai mettere in maiuscolo la prima lettera di ogni proprietà, ad esempio time to {{ .Time }} .

Filtraggio di eventi

Il registro eventi per un demone Docker occupato può diventare rapidamente rumoroso. Puoi restringere gli eventi a un'azione, un oggetto o un tipo di oggetto specifico con il flag --filter :

• docker events --filter type=container – Ottieni tutti gli eventi correlati ai contenitori.
• docker events --filter event=create – Ottieni eventi di creazione del contenitore.
• docker events --filter container=demo-container – Ottieni tutti gli eventi salvati per il container chiamato demo-container (puoi fare riferimento all'ID o al nome del container).

Oltre al container , puoi filtrare in base a tutti i nomi dei tipi di oggetti supportati come image , network e volume .

Sono supportati più filtri quando si ripete il flag --filter . I filtri distinti vengono interpretati come condizioni AND logiche; usi multipli dello stesso filtro diventano clausole OR . Ecco un esempio che mostra l'evento create sia per il app-container api-container :

 $ eventi della finestra mobile \
    --filter container=app-contenitore
    --filter container=api-contenitore
    --filter evento=crea

Accesso agli eventi storici

Per impostazione predefinita docker events mostrano solo gli eventi archiviati dall'esecuzione del comando. Puoi includere eventi storici aggiungendo il flag --since . Questo accetta un'espressione temporale leggibile dall'uomo o un timestamp assoluto:

 $ eventi docker --da 1 ora
$ eventi docker --da '2021-05-01T16:00:00'

Gli eventi registrati dopo l'orario stabilito verranno immediatamente visualizzati nel tuo terminale. I nuovi eventi continueranno a essere visualizzati in tempo reale mentre vengono registrati.

Puoi escludere eventi dopo un determinato periodo di tempo con il flag --until . Funziona in modo simile a --since . L'uso --until disabiliterà lo streaming in tempo reale di nuovi eventi perché non rientrerebbero nel periodo di tempo richiesto.

Streaming di eventi Docker dall'API REST di Daemon

Un altro modo per accedere agli eventi archiviati è tramite l'API REST del demone Docker. Puoi utilizzare l'endpoint /events per eseguire lo streaming di eventi in tempo reale dopo aver abilitato l'API sul tuo host Docker. Gli eventi verranno restituiti in formato JSON:

 $ curl http://127.0.0.1:2375/v1.41/events
{
  "Tipo": "contenitore",
  "Azione": "crea",
  "Attore": {
    "ID": "4a6c8d34a183363db5dbfdcc3cab4c82c4a341d719df56ec2e7f879ee8f02378",
    "Attributi": {
      "image": "ciao-mondo",
      "nome": "nifty_morse"
    }
  },
  "ambito": "locale",
  "tempo": 1654006800,
  "timeNano": 1654006800347054800
}

L'endpoint API supporta i parametri filter , since e until che hanno gli stessi comportamenti delle loro controparti CLI. Ecco come recuperare tutti gli eventi di creazione di container registrati nell'ultima ora:

 $ curl http://127.0.0.1:2375/v1.41/events?since=1h&filters={'type':'container','action':'create'}

Invio di eventi a un servizio esterno

Docker non dispone di un modo integrato per inviare eventi a un servizio esterno. Questo potrebbe essere utile se desideri che tutte le tue creazioni di container vengano registrate in una piattaforma di monitoraggio o auditing esistente.

È possibile configurare la propria soluzione creando un servizio di sistema che esegue continuamente docker events . Dovrebbe inviare ogni nuova riga di output al tuo sistema esterno.

Per prima cosa scrivi uno script Bash che implementi la funzionalità di cui hai bisogno:

 #!/bin/bash
eventi docker --format '{{ .Time }} {{ .Action }} {{ .Type }} {{ .ID }}' | durante la lettura dell'evento
fare
    ricciolo \
        -X POST \
        -H "Tipo di contenuto: application/json" \
        -d '{"evento": "$evento"}' \
        https://example.com/events
fatto

Ora crea una nuova unità di servizio systemd in /etc/systemd/system/docker-events.service :

 [Unità]
Description=Servizio di monitoraggio eventi Docker personalizzato

[Servizio]
Tipo = biforcazione
ExecStart=/usr/local/bin/docker-events.sh

[Installare]
WantedBy=multiutente.target

Infine ricarica systemd per caricare il tuo servizio, quindi avvia e abilita l'unità:

 $ sudo systemctl daemon-reload
$ sudo systemctl avvia docker-events
$ sudo systemctl abilita gli eventi docker

Il tuo servizio ora trasmetterà in streaming ogni nuovo evento alla tua piattaforma di monitoraggio. L'abilitazione del servizio ne configura l'avvio automatico ogni volta che l'host si riavvia.

Riepilogo

Gli eventi Docker vengono creati ogni volta che il demone modifica gli oggetti nell'ambiente. Lo streaming del registro eventi consente di monitorare l'attività del demone in tempo reale. Questo può aiutarti a eseguire il debug dei problemi, controllare le modifiche e garantire la conformità.

Poiché gli eventi vengono recuperati direttamente dal server Docker, non dovrebbero essere considerati affidabili se sarà necessario recuperare informazioni in futuro. Vengono conservate solo 1.000 voci su base continuativa e non puoi accedere agli eventi tramite il filesystem del tuo host Docker. Il meccanismo è più adatto per attività rapide ad hoc in cui stai cercando informazioni specifiche relative a un'attività recente. Per la conservazione a lungo termine è necessario utilizzare il proprio servizio di sistema per inviare eventi a un repository esterno.