Wie man den docker compose logs Befehl zur Anzeige von Container-Ausgaben verwendet

Einführung

In diesem Lab lernen Sie, wie Sie den Befehl docker logs effektiv nutzen können, um die Ausgabe Ihrer Docker-Container anzuzeigen. Wir beginnen damit, grundlegende Logs eines laufenden Containers zu betrachten.

Aufbauend auf diesen Grundlagen werden Sie dann untersuchen, wie Sie Container-Logs in Echtzeit verfolgen können, was für die Überwachung und Fehlerbehebung aktiver Prozesse entscheidend ist. Abschließend lernen Sie, wie Sie Ihre Log-Anzeige verbessern können, indem Sie Zeitstempel einbeziehen, die Anzahl der anzuzeigenden Zeilen vom Ende der Logs festlegen und Logs basierend auf einem Zeitraum filtern.

Skills Graph

Dienste starten und grundlegende Logs anzeigen

In diesem Schritt lernen Sie, wie Sie einen Docker-Container starten und seine grundlegenden Logs anzeigen können. Logs sind entscheidend, um zu verstehen, was innerhalb eines Containers geschieht, Probleme zu debuggen und sein Verhalten zu überwachen.

Zuerst laden wir ein einfaches Nginx-Image von Docker Hub. Dieses Image wird verwendet, um einen Web-Server-Container auszuführen.

docker pull nginx:latest

Sie sollten eine Ausgabe sehen, die anzeigt, dass das Image heruntergeladen wird. Sobald der Download abgeschlossen ist, können Sie überprüfen, ob das Image lokal verfügbar ist, indem Sie die Images auflisten:

docker images

Nun starten wir einen Container basierend auf dem Nginx-Image. Wir führen ihn im Detached-Modus (-d) aus, sodass er im Hintergrund läuft, und geben ihm den Namen my-nginx.

docker run -d --name my-nginx nginx

Die Ausgabe dieses Befehls ist die Container-ID. Dies bedeutet, dass der Container erfolgreich im Hintergrund gestartet wurde.

Um die grundlegenden Logs des my-nginx-Containers anzuzeigen, verwenden wir den Befehl docker logs gefolgt vom Container-Namen oder der ID.

docker logs my-nginx

Sie sehen die Standardausgabe und Standardfehler-Streams des Nginx-Prozesses, der innerhalb des Containers läuft. Diese Logs enthalten typischerweise Informationen über den Start des Nginx-Servers und die Bearbeitung von Anfragen.

Logs in Echtzeit verfolgen

Im vorherigen Schritt haben wir die Logs eines Containers nach seinem Start betrachtet. Manchmal ist es jedoch notwendig, Logs in Echtzeit zu verfolgen, während sie generiert werden. Dies ist besonders nützlich für Debugging-Zwecke oder zur Überwachung aktiver Prozesse.

Um die Logs eines Containers in Echtzeit zu verfolgen, verwenden wir den Befehl docker logs mit der Option -f (oder --follow). Dadurch bleibt das Terminal geöffnet und zeigt neue Log-Einträge an, sobald sie erscheinen.

Lassen Sie uns die Logs unseres my-nginx-Containers verfolgen:

docker logs -f my-nginx

Der Befehl zeigt zunächst die aktuellen Logs an und wartet dann auf neue Einträge. Da unser Nginx-Container läuft, aber keine aktiven Anfragen bearbeitet, werden Sie möglicherweise nicht sofort neue Logs sehen.

Um neue Log-Einträge zu generieren, können wir eine Anfrage an den im Container laufenden Nginx-Webserver senden. Standardmäßig lauscht Nginx auf Port 80. Obwohl wir den Port im docker run-Befehl nicht dem Host zugeordnet haben, können wir dennoch intern vom Host aus auf das Containernetzwerk mit curl zugreifen.

Öffnen Sie einen neuen Terminal-Tab in der LabEx-Umgebung. Führen Sie in diesem neuen Tab folgenden Befehl aus, um eine Anfrage an den Nginx-Container zu senden:

curl http://localhost:80

Sie sollten die HTML-Ausgabe der standardmäßigen Nginx-Willkommensseite im neuen Terminal-Tab sehen.

Wechseln Sie nun zurück zum Terminal-Tab, in dem Sie die Logs verfolgen (docker logs -f my-nginx). Sie sollten neue Log-Einträge sehen, die anzeigen, dass Nginx die Anfrage von curl verarbeitet hat. Diese Einträge enthalten typischerweise Informationen über die Client-IP, die Anfragemethode, den angeforderten Pfad und den HTTP-Statuscode.

Um das Verfolgen der Logs zu beenden, drücken Sie Strg+C im Terminal, in dem docker logs -f ausgeführt wird.

Logs mit Zeitstempeln und spezifischem Tail anzeigen

In den vorherigen Schritten haben wir grundlegende Logs betrachtet und Logs in Echtzeit verfolgt. Die Standardausgabe von docker logs enthält jedoch keine Zeitstempel, was die Zuordnung von Ereignissen oder das Verständnis der zeitlichen Abfolge von Log-Einträgen erschweren kann. Außerdem benötigt man manchmal nur die neuesten Log-Einträge.

Um Zeitstempel in der Log-Ausgabe einzubinden, verwenden wir die Option -t (oder --timestamps) mit dem docker logs-Befehl.

Lassen Sie uns die Logs unseres my-nginx-Containers mit Zeitstempeln anzeigen:

docker logs -t my-nginx

Sie sehen nun einen Zeitstempel vor jedem Log-Eintrag, der angibt, wann dieser Eintrag vom Container generiert wurde. Dies ist sehr hilfreich für Debugging und Analyse.

Manchmal interessieren nur die neuesten Log-Einträge, ähnlich wie beim tail-Befehl in Linux. Der docker logs-Befehl bietet dafür die Option --tail. Sie können die Anzahl der Zeilen angeben, die Sie vom Ende der Logs sehen möchten.

Um beispielsweise nur die letzten 5 Log-Einträge des my-nginx-Containers anzuzeigen:

docker logs --tail 5 my-nginx

Dies gibt nur die letzten 5 Zeilen der Container-Logs aus. Sie können --tail mit -t kombinieren, um die letzten Einträge mit Zeitstempeln zu sehen.

docker logs -t --tail 5 my-nginx

Dieser Befehl zeigt die letzten 5 Log-Einträge mit ihren jeweiligen Zeitstempeln an.

Logs nach Zeitraum filtern

Zusätzlich zur Anzeige aller Logs oder nur der neuesten Einträge können Sie Container-Logs auch nach einem bestimmten Zeitraum filtern. Dies ist besonders nützlich, wenn Sie Ereignisse untersuchen, die während eines bestimmten Zeitfensters aufgetreten sind.

Der docker logs-Befehl bietet die Optionen --since und --until zur Zeitfilterung von Logs. Diese Optionen akzeptieren verschiedene Zeitformate, darunter RFC3339-Zeitstempel, Unix-Zeitstempel oder relative Zeitangaben (z.B. 10m für 10 Minuten, 1h für 1 Stunde).

Lassen Sie uns die Log-Filterung testen. Zuerst müssen wir Logs zu verschiedenen Zeitpunkten generieren. Dies können wir durch erneute curl-Anfragen an den Nginx-Container erreichen.

Öffnen Sie einen neuen Terminal-Tab und führen Sie den curl-Befehl mehrmals mit kurzen Pausen dazwischen aus.

curl http://localhost:80
sleep 5
curl http://localhost:80
sleep 5
curl http://localhost:80

Nun zeigen wir die Logs des my-nginx-Containers mit Zeitstempeln an, um die Zeitpunkte dieser Anfragen zu sehen.

docker logs -t my-nginx

Beachten Sie die Zeitstempel der durch die curl-Befehle generierten Log-Einträge.

Um Logs ab einem bestimmten Zeitpunkt zu filtern, können Sie die Option --since verwenden. Beispielsweise, um Logs der letzten Minute anzuzeigen:

docker logs --since 1m my-nginx

Dieser Befehl zeigt alle Log-Einträge des my-nginx-Containers an, die in der letzten Minute generiert wurden.

Sie können Logs auch bis zu einem bestimmten Zeitpunkt filtern, indem Sie die Option --until verwenden. Beispielsweise, um Logs anzuzeigen, die vor mehr als einer Minute generiert wurden:

docker logs --until 1m my-nginx

Dieser Befehl zeigt alle Log-Einträge des my-nginx-Containers an, die vor mehr als einer Minute generiert wurden.

Sie können --since und --until kombinieren, um Logs innerhalb eines bestimmten Zeitfensters anzuzeigen. Beispielsweise, um Logs zwischen vor 5 Minuten und vor 1 Minute anzuzeigen:

docker logs --since 5m --until 1m my-nginx

Beachten Sie, dass die genaue Ausgabe davon abhängt, wann Sie die curl-Befehle ausgeführt haben und wann Sie die docker logs-Befehle ausführen.

Zusammenfassung

In diesem Lab haben wir die grundlegenden Schritte zur Verwendung des docker logs-Befehls gelernt, um die Ausgabe von Containern anzuzeigen. Wir begannen damit, ein Docker-Image zu pullen und einen Container im Detached-Modus auszuführen. Anschließend haben wir untersucht, wie die grundlegenden Logs des laufenden Containers angezeigt werden können, die Einblicke in dessen Start und Aktivitäten geben.

Darüber hinaus haben wir unser Verständnis vertieft, indem wir gelernt haben, wie Container-Logs in Echtzeit mit der Option -f verfolgt werden können. Dies ermöglicht die kontinuierliche Überwachung von Log-Streams, während sie generiert werden. Diese Echtzeit-Protokollierung ist entscheidend für das Debugging und die Beobachtung des dynamischen Verhaltens von Containern.