Wie man den docker node inspect-Befehl verwendet, um Knotendetails anzuzeigen

Einführung

In diesem Lab lernen Sie, wie Sie den Befehl docker node inspect verwenden, um detaillierte Informationen über Docker Swarm-Knoten (Nodes) anzuzeigen. Wir beginnen damit, einen einzelnen Knoten anhand seiner ID zu untersuchen und erkunden dann, wie Sie den aktuellen Knoten mit dem Schlüsselwort 'self' untersuchen können. Abschließend lernen Sie, wie Sie die Ausgabe formatieren können, um bestimmte Informationen anzuzeigen, und wie Sie die Knotendetails für eine bessere Lesbarkeit schön formatieren können. Diese praktische Erfahrung wird Sie mit den Fähigkeiten ausstatten, die Konfiguration und den Status Ihrer Docker Swarm-Knoten effektiv zu untersuchen und zu verstehen.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL docker(("Docker")) -.-> docker/ContainerOperationsGroup(["Container Operations"]) docker(("Docker")) -.-> docker/SystemManagementGroup(["System Management"]) docker/ContainerOperationsGroup -.-> docker/inspect("Inspect Container") docker/SystemManagementGroup -.-> docker/version("Show Docker Version") subgraph Lab Skills docker/inspect -.-> lab-555181{{"Wie man den docker node inspect-Befehl verwendet, um Knotendetails anzuzeigen"}} docker/version -.-> lab-555181{{"Wie man den docker node inspect-Befehl verwendet, um Knotendetails anzuzeigen"}} end

Einen einzelnen Knoten untersuchen

In diesem Schritt lernen wir, wie man einen einzelnen Docker-Knoten (Node) untersucht. Der Befehl docker node inspect liefert detaillierte Informationen über einen bestimmten Knoten in einem Docker Swarm.

Zunächst überprüfen wir die auf der LabEx VM installierte Docker-Version.

docker version

Sie sollten eine Ausgabe ähnlich der folgenden sehen, die darauf hinweist, dass die Docker-Version 20.10.21 ist:

Client: Docker Engine - Community
 Version:           20.10.21
 API version:       1.41
 Go version:        go1.18.9
 Git commit:        baedd2f
 Built:             Tue Oct 25 17:58:10 2022
 OS/Arch:           linux/amd64
 Context:           default
 Experimental:      true

Server: Docker Engine - Community
 Engine:
  Version:          20.10.21
  API version:      1.41 (minimum version 1.12)
  Go version:       go1.18.9
  Git commit:       305620d
  Built:            Tue Oct 25 17:56:04 2022
  OS/Arch:          linux/amd64
  Experimental:     false
 containerd:
  Version:          1.6.10
  GitCommit:        b35cd9b83c7c7b1200458f9f9f8d73288d61e58e
 runc:
  Version:          1.1.4
  GitCommit:        v1.1.4-0-g5fd4c4d
 docker-init:
  Version:          0.19.0
  GitCommit:        de40ad0

Jetzt initialisieren wir einen Docker Swarm. Dies ist erforderlich, um Knoten zum Untersuchen zu haben.

docker swarm init

Sie sollten eine Ausgabe sehen, die darauf hinweist, dass der Swarm initialisiert wurde und ein Join-Token bereitstellt:

Swarm initialized: current node (xxxxxxxxxxxx) is now a manager.

To add a worker to this swarm, run the following command:

    docker swarm join --token SWMTKN-1-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 172.17.0.2:2377

To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.

Die Ausgabe zeigt, dass der aktuelle Knoten jetzt ein Manager ist. Das xxxxxxxxxxxx ist die ID des aktuellen Knotens. Wir werden diese ID verwenden, um den Knoten zu untersuchen.

Jetzt untersuchen wir den aktuellen Knoten anhand seiner ID. Ersetzen Sie YOUR_NODE_ID durch die tatsächliche Knoten-ID aus der Ausgabe von docker swarm init.

docker node inspect YOUR_NODE_ID

Beispielsweise würde der Befehl wie folgt lauten, wenn Ihre Knoten-ID abcdef123456 wäre:

docker node inspect abcdef123456

Dieser Befehl gibt ein großes JSON-Objekt aus, das detaillierte Informationen über den Knoten enthält, einschließlich seines Status, seiner Rolle, des Hostnamens und vieles mehr.

Den aktuellen Knoten mit 'self' untersuchen

Im vorherigen Schritt haben wir einen Knoten anhand seiner spezifischen ID untersucht. Docker Swarm bietet ein praktisches Alias, self, um sich auf den aktuellen Knoten zu beziehen. Dies ist nützlich, wenn Sie den Knoten untersuchen möchten, auf dem Sie derzeit arbeiten, ohne seine ID kennen zu müssen.

Lassen Sie uns das Alias self verwenden, um den aktuellen Knoten zu untersuchen.

docker node inspect self

Dieser Befehl erzeugt die gleiche detaillierte JSON-Ausgabe wie das Untersuchen des Knotens anhand seiner ID. Die Verwendung von self macht Ihre Befehle portabler und einfacher zu verwenden, insbesondere in Skripten oder wenn Sie die Knoten-ID nicht sofort zur Hand haben.

Die Ausgabe wird ein großes JSON-Objekt sein, ähnlich dem, was Sie im vorherigen Schritt gesehen haben. Dieses JSON enthält alle Konfigurations- und Statusinformationen für den aktuellen Knoten.

Die Ausgabe formatieren, um spezifische Informationen anzuzeigen

In den vorherigen Schritten haben wir gesehen, dass docker node inspect ein großes JSON-Objekt ausgibt. Oft benötigen Sie nur bestimmte Informationen aus dieser Ausgabe. Docker bietet die Option --format, um spezifische Daten mithilfe des Go-Pakets text/template zu extrahieren und zu formatieren.

Lassen Sie uns die Option --format verwenden, um nur den Hostnamen des aktuellen Knotens anzuzeigen. Der Hostname befindet sich im JSON-Ausgabeobjekt unter dem Pfad .Description.Hostname.

docker node inspect --format '{{ .Description.Hostname }}' self

Dieser Befehl gibt nur den Hostnamen des aktuellen Knotens aus. Der Teil {{ .Description.Hostname }} ist die Go-Template-Syntax, um auf das Hostname-Feld innerhalb des Description-Objekts der JSON-Ausgabe zuzugreifen.

Jetzt versuchen wir, die Knoten-ID (Node ID) und die Verfügbarkeit (Availability) des Knotens anzuzeigen. Die Knoten-ID befindet sich unter dem Pfad .ID, und die Verfügbarkeit unter dem Pfad .Spec.Availability. Wir können mehrere Felder in der Formatzeichenkette kombinieren.

docker node inspect --format 'ID: {{ .ID }}, Availability: {{ .Spec.Availability }}' self

Dieser Befehl gibt die Knoten-ID und ihre Verfügbarkeit in einem lesbareren Format aus. Sie können diese Technik verwenden, um jedes Feld aus der JSON-Ausgabe von docker node inspect zu extrahieren.

Die Knoteninformationen schön formatieren

In den vorherigen Schritten haben wir die rohe JSON-Ausgabe gesehen und gelernt, wie man spezifische Felder extrahiert. Manchmal möchte man eine besser lesbare, strukturierte Ausgabe der Knoteninformationen, ohne die rohe JSON selbst analysieren zu müssen. Der Befehl docker node inspect bietet hierfür die Option --pretty.

Lassen Sie uns die Option --pretty verwenden, um die Knoteninformationen in einem lesbareren Format anzuzeigen.

docker node inspect --pretty self

Dieser Befehl gibt eine formatierte Zusammenfassung der Knoteninformationen aus, einschließlich seiner ID, seines Hostnamens, seines Status, seiner Verfügbarkeit und seiner Rolle. Diese Ausgabe ist im Vergleich zur rohen JSON viel einfacher zu lesen und auf einen Blick zu verstehen.

Die Ausgabe sieht in etwa so aus:

ID:             abcdef123456
Hostname:       labex-vm
Status:         Ready
Availability:   Active
Manager Status:
  Address:      172.17.0.2:2377
  Reachability: Reachable
  Leader:       Yes
Platform:
  Architecture: x86_64
  OS:           linux
Resources:
  NanoCPUs:     2000000000
  MemoryBytes:  4177903616
Engine Version: 20.10.21

Diese schön formatierte Ausgabe ist sehr nützlich, um schnell den Status und die wichtigsten Details eines Knotens in Ihrem Docker Swarm zu überprüfen.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man den Befehl docker node inspect verwendet, um detaillierte Informationen über Docker Swarm-Knoten (Knoten in einem Docker Swarm-Cluster) anzuzeigen. Wir haben begonnen, indem wir einen einzelnen Knoten anhand seiner ID nach der Initialisierung eines Docker Swarm untersucht haben.

Anschließend haben wir untersucht, wie man den aktuellen Knoten mithilfe des Alias 'self' untersucht. Schließlich haben wir gelernt, wie man die Ausgabe formatiert, um spezifische Informationen anzuzeigen, und wie man die Knotendetails schön formatieren kann, um sie besser lesbar zu machen.