Wie man den docker compose events Befehl zur Überwachung von Container-Ereignissen verwendet

Einführung

In diesem Lab lernen Sie, wie Sie den Befehl docker compose events verwenden, um Container-Ereignisse zu überwachen. Wir beginnen mit der Vorbereitung eines einfachen Docker Compose-Projekts, einschließlich der Installation von Docker Compose und der Erstellung einer grundlegenden docker-compose.yml-Datei.

Nach dem Setup starten Sie die im Projekt definierten Dienste und beobachten die generierten Basisereignisse. Anschließend untersuchen wir, wie Sie das Flag --json verwenden können, um diese Ereignisse in einem strukturierten JSON-Format auszugeben. Abschließend lernen Sie, wie Sie Ereignisse filtern, um nur diejenigen zu überwachen, die mit bestimmten Diensten innerhalb Ihrer Docker Compose-Anwendung zusammenhängen.

Skills Graph

Ein einfaches Docker Compose-Projekt vorbereiten

In diesem Schritt bereiten wir ein einfaches Docker Compose-Projekt vor. Da Docker Compose in der LabEx-Umgebung nicht vorinstalliert ist, werden wir es zunächst installieren. Docker Compose ist ein Tool zum Definieren und Ausführen von Multi-Container-Docker-Anwendungen. Mit Compose verwenden Sie eine YAML-Datei, um die Dienste Ihrer Anwendung zu konfigurieren. Anschließend können Sie mit einem einzigen Befehl alle Dienste aus Ihrer Konfiguration erstellen und starten.

Zuerst installieren wir Docker Compose. Wir laden die Docker Compose-Binary herunter und machen sie ausführbar.

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

Nach der Installation können Sie die Installation überprüfen, indem Sie die Version von Docker Compose anzeigen lassen.

docker-compose --version

Sie sollten eine Ausgabe ähnlich zu Docker Compose version v2.20.2 sehen.

Nun erstellen wir ein Verzeichnis für unser Projekt und wechseln hinein. Wir erstellen ein einfaches Projekt mit einem einzelnen Dienst.

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

Als nächstes erstellen wir in diesem Verzeichnis eine docker-compose.yml-Datei. Diese Datei definiert unseren Dienst. Wir verwenden den nano-Editor, um die Datei zu erstellen und zu bearbeiten.

nano docker-compose.yml

Fügen Sie im nano-Editor folgenden Inhalt ein. Diese Konfiguration definiert einen Dienst namens web, der das Image nginx:latest verwendet.

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

Lassen Sie uns diese docker-compose.yml-Datei aufschlüsseln:

• version: '3.8' gibt die Version des Docker Compose-Dateiformats an.
• services: definiert die Dienste, aus denen Ihre Anwendung besteht.
• web: ist der Name unseres Dienstes.
• image: nginx:latest spezifiziert das Docker-Image, das für diesen Dienst verwendet wird. In diesem Fall verwenden wir die neueste Version des offiziellen Nginx-Images.
• ports: bildet Ports zwischen dem Host und dem Container ab. "80:80" bildet Port 80 auf dem Host auf Port 80 im Container ab.

Speichern Sie die Datei mit Strg + X, dann Y und Enter.

Bevor wir den Dienst starten, laden wir das nginx:latest-Image. Obwohl Docker Compose das Image automatisch lädt, falls es nicht vorhanden ist, kann es manchmal hilfreich sein, es vorab explizit zu pullen.

docker pull nginx:latest

Sie sollten eine Ausgabe sehen, die anzeigt, dass das Image heruntergeladen wird.

Nun haben wir unsere docker-compose.yml-Datei vorbereitet und das benötigte Image heruntergeladen. Im nächsten Schritt starten wir den in dieser Datei definierten Dienst.

Dienste starten und grundlegende Ereignisse beobachten

In diesem Schritt starten wir die in unserer docker-compose.yml-Datei definierten Dienste und beobachten die von Docker generierten Basisereignisse. Docker-Ereignisse sind Echtzeitinformationen über Aktivitäten Ihres Docker-Daemons und Ihrer Container, wie z.B. Container-Erstellung, Start, Stopp und Zerstörung.

Stellen Sie zunächst sicher, dass Sie sich im Verzeichnis ~/project/my-compose-app befinden, in dem Sie im vorherigen Schritt die docker-compose.yml-Datei erstellt haben.

cd ~/project/my-compose-app

Nun verwenden wir den Befehl docker-compose up, um den Dienst zu starten. Das Flag -d führt die Container im Detached-Modus aus, was bedeutet, dass sie im Hintergrund laufen und Ihr Terminal nicht blockieren.

docker-compose up -d

Sie sollten eine Ausgabe sehen, die anzeigt, dass das Netzwerk und der web-Service-Container erstellt und gestartet werden.

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

Um die grundlegenden Docker-Ereignisse zu beobachten, verwenden wir den Befehl docker events. Dieser Befehl streamt Ereignisse vom Docker-Daemon.

docker events

Sie sehen einen kontinuierlichen Strom von Ereignissen, die mit Ihrer Docker-Umgebung zusammenhängen. Da wir gerade einen Container gestartet haben, sollten Sie Ereignisse im Zusammenhang mit der Erstellung, dem Start und möglicherweise anderen Aktionen des my-compose-app-web-1-Containers sehen. Die Ausgabe sieht etwa so aus (Zeitstempel und spezifische Details variieren):

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, ...)
...

Der Befehl docker events läuft weiter und zeigt neue Ereignisse an, sobald sie auftreten. Drücken Sie Strg + C, um den Befehl zu beenden und zur Terminal-Eingabeaufforderung zurückzukehren.

Sie können den laufenden Container auch mit dem Befehl docker ps beobachten.

docker ps

Sie sollten den Container my-compose-app-web-1 mit dem Status Up sehen.

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

In diesem Schritt haben wir unseren Docker Compose-Dienst erfolgreich gestartet und die grundlegenden von Docker generierten Ereignisse beobachtet. Im nächsten Schritt untersuchen wir, wie wir diese Ereignisse im JSON-Format ausgeben können.

Das --json-Flag verwenden, um Ereignisse im JSON-Format auszugeben

In diesem Schritt lernen wir, wie Docker-Ereignisse im JSON-Format mit dem --json-Flag des docker events-Befehls ausgegeben werden können. Die Ausgabe von Ereignissen im JSON-Format ist nützlich für die programmatische Verarbeitung und Integration mit anderen Tools.

Stellen Sie zunächst sicher, dass Sie sich im Verzeichnis ~/project/my-compose-app befinden.

cd ~/project/my-compose-app

Nun führen wir den docker events-Befehl mit dem --json-Flag aus. Dadurch werden die Ereignisse im JSON-Format gestreamt.

docker events --json

Sie sehen einen kontinuierlichen Strom von JSON-Objekten, wobei jedes Objekt ein Docker-Ereignis repräsentiert. Die Ausgabe sieht ähnlich wie folgt aus (Details variieren):

{"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}
...

Jede Zeile ist ein gültiges JSON-Objekt mit detaillierten Informationen über das Ereignis, wie den Ereignis-status, die id des betroffenen Objekts, Type, Action und Actor-Details einschließlich Attributes wie Image-Name und Container-Name.

Um das Erfassen dieser Ereignisse zu demonstrieren, stoppen und starten wir den web-Service erneut, während der docker events --json-Befehl in einem anderen Terminal oder im Hintergrund läuft. Da wir in diesem Lab ein einzelnes Terminal verwenden, stoppen wir zunächst den docker events --json-Befehl mit Strg + C.

Nun stoppen wir den web-Service.

docker-compose stop web

Sie sollten eine Ausgabe sehen, die anzeigt, dass der web-Container gestoppt wird.

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

Nun führen wir docker events --json im Hintergrund aus und starten den Service erneut. Wir verwenden das &-Symbol, um den Befehl im Hintergrund auszuführen.

docker events --json &

Sie sehen eine Prozess-ID (PID), die anzeigt, dass der Befehl im Hintergrund läuft.

Nun starten wir den web-Service erneut.

docker-compose start web

Sie sollten eine Ausgabe sehen, die anzeigt, dass der web-Container gestartet wird.

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

Der im Hintergrund laufende docker events --json-Befehl erfasst die stop- und start-Ereignisse. Um die Ausgabe des Hintergrundprozesses zu sehen, müssen Sie ihn möglicherweise mit dem fg-Befehl in den Vordergrund holen oder die Terminalausgabe nach dem Stoppen des Hintergrundprozesses überprüfen. Für diesen Schritt reicht es jedoch aus, den Befehl mit --json auszuführen, um das Format zu verstehen.

Um den Hintergrundprozess docker events --json zu stoppen, können Sie den jobs-Befehl verwenden, um Hintergrundjobs aufzulisten, und dann kill %<job_number>. Alternativ können Sie die Prozess-ID mit ps aux | grep 'docker events --json' finden und den kill-Befehl mit der PID verwenden. Einfacher ist es in diesem Kontext, einfach mit dem nächsten Schritt fortzufahren, da der Hintergrundprozess nicht wesentlich stört.

In diesem Schritt haben wir erfolgreich das --json-Flag verwendet, um Docker-Ereignisse in einem strukturierten JSON-Format anzuzeigen, was für Automatisierung und Analyse wertvoll ist.

Ereignisse für bestimmte Dienste filtern

In diesem Schritt lernen wir, wie Docker-Ereignisse gefiltert werden können, um nur Ereignisse anzuzeigen, die mit bestimmten Diensten oder Containern zusammenhängen. Dies ist besonders nützlich in Umgebungen mit vielen Containern, in denen Sie nur Ereignisse für eine bestimmte Anwendung oder einen bestimmten Dienst überwachen möchten.

Der docker events-Befehl unterstützt Filterung mit dem --filter-Flag. Sie können nach verschiedenen Kriterien filtern, wie z.B. container, image, event, label usw.

Stellen Sie zunächst sicher, dass Sie sich im Verzeichnis ~/project/my-compose-app befinden.

cd ~/project/my-compose-app

Unser Dienst heißt web in der docker-compose.yml-Datei, und der von Docker Compose generierte Containername folgt typischerweise dem Format <Projektname>_<Dienstname>_<Instanznummer>. In unserem Fall ist der Projektname my-compose-app (abgeleitet vom Verzeichnisnamen), der Dienstname ist web und die Instanznummer ist 1. Daher lautet der Containername my-compose-app-web-1.

Filtern wir die Ereignisse, um nur diejenigen anzuzeigen, die mit unserem web-Container zusammenhängen. Wir können den container-Filter mit dem Containernamen verwenden.

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

Dieser Befehl zeigt nun nur Ereignisse an, bei denen das betroffene Objekt der Container mit dem Namen my-compose-app-web-1 ist. Um dies in Aktion zu sehen, stoppen und starten wir den web-Dienst erneut, während dieser Befehl läuft.

Stoppen Sie zunächst den docker events-Befehl mit Strg + C.

Führen Sie nun den gefilterten docker events-Befehl im Hintergrund aus.

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

Sie sehen die Hintergrundprozess-ID.

Stoppen Sie nun den web-Dienst mit Docker Compose.

docker-compose stop web

Sie sollten eine Ausgabe sehen, die anzeigt, dass der Container gestoppt wird. Der Hintergrundbefehl docker events sollte das stop-Ereignis für den my-compose-app-web-1-Container erfassen.

Starten Sie nun den web-Dienst erneut.

docker-compose start web

Sie sollten eine Ausgabe sehen, die anzeigt, dass der Container gestartet wird. Der Hintergrundbefehl docker events sollte das start-Ereignis für den my-compose-app-web-1-Container erfassen.

Sie können auch nach anderen Kriterien filtern. Zum Beispiel könnten Sie mit --filter image=nginx:latest nach Ereignissen filtern, die mit einem bestimmten Image zusammenhängen.

Um den Hintergrundprozess docker events zu stoppen, können Sie jobs und kill %<Jobnummer> verwenden oder die PID finden und kill <PID> nutzen. Für dieses Lab können Sie einfach fortfahren.

Abschließend bereinigen wir den laufenden Container und das von Docker Compose erstellte Netzwerk.

docker-compose down

Dieser Befehl stoppt und entfernt die Container, Netzwerke und Volumes, die in der docker-compose.yml-Datei definiert sind.

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

In diesem Schritt haben wir gelernt, wie Docker-Ereignisse mit dem --filter-Flag gefiltert werden können, was für die Überwachung spezifischer Komponenten in einer umfangreichen Docker-Umgebung essentiell ist. Wir haben außerdem die während des Labs erstellten Ressourcen bereinigt.

Zusammenfassung

In diesem Lab haben wir gelernt, wie der Befehl docker compose events verwendet wird, um Container-Ereignisse zu überwachen. Wir begannen mit der Vorbereitung eines einfachen Docker Compose-Projekts, was die Installation von Docker Compose und die Erstellung einer docker-compose.yml-Datei mit einem grundlegenden Nginx-Service beinhaltete.

Nach dem Projekt-Setup starteten wir die Services und beobachteten die grundlegenden von Docker Compose generierten Ereignisse. Anschließend untersuchten wir, wie diese Ereignisse im JSON-Format mit dem --json-Flag ausgegeben werden können, um die Analyse und Verarbeitung zu vereinfachen. Abschließend lernten wir, wie die Ereignisse gefiltert werden können, um nur diejenigen zu überwachen, die mit bestimmten Services innerhalb unseres Docker Compose-Projekts zusammenhängen.