Wie man den Befehl docker network create verwendet, um Container-Netzwerke zu verwalten

Einführung

In diesem Lab lernen Sie, wie Sie Container-Netzwerke effektiv mit dem Befehl docker network create verwalten können. Wir werden verschiedene Netzwerktypen und -konfigurationen untersuchen, um zu verstehen, wie Container miteinander und mit der Außenwelt kommunizieren.

Insbesondere erhalten Sie praktische Erfahrungen bei der Erstellung einfacher Bridge-Netzwerke, der Anpassung von Bridge-Netzwerken mit bestimmten Subnetzen und Gateways sowie der Einrichtung von anschließbaren und internen Overlay-Netzwerken für Szenarien mit mehreren Hosts. Am Ende dieses Labs werden Sie ein solides Verständnis dafür haben, wie Sie verschiedene Netzwerktopologien für Ihre Docker-Container entwerfen und implementieren können.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL docker(("Docker")) -.-> docker/ContainerOperationsGroup(["Container Operations"]) docker(("Docker")) -.-> docker/NetworkOperationsGroup(["Network Operations"]) docker/ContainerOperationsGroup -.-> docker/ls("List Containers") docker/ContainerOperationsGroup -.-> docker/rm("Remove Container") docker/ContainerOperationsGroup -.-> docker/exec("Execute Command in Container") docker/ContainerOperationsGroup -.-> docker/inspect("Inspect Container") docker/NetworkOperationsGroup -.-> docker/network("Manage Networks") subgraph Lab Skills docker/ls -.-> lab-555174{{"Wie man den Befehl docker network create verwendet, um Container-Netzwerke zu verwalten"}} docker/rm -.-> lab-555174{{"Wie man den Befehl docker network create verwendet, um Container-Netzwerke zu verwalten"}} docker/exec -.-> lab-555174{{"Wie man den Befehl docker network create verwendet, um Container-Netzwerke zu verwalten"}} docker/inspect -.-> lab-555174{{"Wie man den Befehl docker network create verwendet, um Container-Netzwerke zu verwalten"}} docker/network -.-> lab-555174{{"Wie man den Befehl docker network create verwendet, um Container-Netzwerke zu verwalten"}} end

Erstellen eines einfachen Bridge-Netzwerks

In diesem Schritt lernen wir, wie man in Docker ein einfaches Bridge-Netzwerk erstellt. Ein Bridge-Netzwerk ist der Standard-Netzwerktyp für Container. Container, die an dasselbe Bridge-Netzwerk angeschlossen sind, können miteinander kommunizieren, während sie von Containern auf anderen Bridge-Netzwerken und dem Netzwerk des Hosts isoliert sind.

Zunächst listen wir die vorhandenen Docker-Netzwerke auf, um die Standard-Netzwerke zu sehen.

docker network ls

Sie sollten einige Standard-Netzwerke wie bridge, host und none sehen. Das bridge-Netzwerk ist das, mit dem wir arbeiten werden.

Jetzt erstellen wir ein neues Bridge-Netzwerk. Wir nennen es my-bridge-network.

docker network create my-bridge-network

Dieser Befehl erstellt ein neues Bridge-Netzwerk mit Standard-Einstellungen. Docker weist diesem Netzwerk automatisch ein Subnetz und ein Gateway zu.

Um zu überprüfen, ob das Netzwerk erfolgreich erstellt wurde, listen wir die Docker-Netzwerke erneut auf.

docker network ls

Sie sollten jetzt my-bridge-network in der Liste sehen.

Als Nächstes untersuchen wir das neu erstellte Netzwerk, um seine Details, einschließlich des von Docker zugewiesenen Subnetzes und Gateways, zu sehen.

docker network inspect my-bridge-network

Die Ausgabe dieses Befehls liefert detaillierte Informationen über das Netzwerk, wie seine ID, den Treiber (der bridge sein sollte) und das Subnetz und Gateway im Abschnitt IPAM.

Jetzt starten wir einen Container und verbinden ihn mit unserem neuen Netzwerk. Wir verwenden für dieses Beispiel das alpine-Image. Wenn Sie das alpine-Image nicht lokal haben, lädt Docker es automatisch herunter.

docker run -d --name container1 --network my-bridge-network alpine sleep infinity

Dieser Befehl startet einen Container namens container1 im detached-Modus (-d), verbindet ihn mit my-bridge-network (--network my-bridge-network) und lässt ihn laufen, indem er den Befehl sleep infinity ausführt.

Um zu überprüfen, ob der Container läuft und mit dem richtigen Netzwerk verbunden ist, können Sie den Container untersuchen.

docker inspect container1

In der Ausgabe suchen Sie nach dem Abschnitt Networks. Sie sollten my-bridge-network aufgeführt sehen, zusammen mit der IP-Adresse, die dem Container innerhalb dieses Netzwerks zugewiesen wurde.

Schließlich starten wir einen weiteren Container und verbinden ihn mit demselben Netzwerk, um die Kommunikation zwischen ihnen zu demonstrieren.

docker run -d --name container2 --network my-bridge-network alpine sleep infinity

Jetzt sind sowohl container1 als auch container2 mit my-bridge-network verbunden. Sie sollten in der Lage sein, miteinander zu kommunizieren, indem sie ihre Containernamen oder IP-Adressen innerhalb des Netzwerks verwenden.

Um die Kommunikation zu testen, können wir einen Befehl in container1 ausführen, um container2 zu pingen. Zunächst müssen wir das iputils-Paket in den Alpine-Containern installieren, um den ping-Befehl zu verwenden.

docker exec container1 apk add --no-cache iputils
docker exec container2 apk add --no-cache iputils

Jetzt pingen wir container2 von container1 aus.

docker exec container1 ping -c 3 container2

Sie sollten erfolgreiche Ping-Antworten sehen, was darauf hinweist, dass die beiden Container auf demselben Bridge-Netzwerk kommunizieren können.

Erstellen eines Bridge-Netzwerks mit benutzerdefiniertem Subnetz und Gateway

Im vorherigen Schritt haben wir ein Bridge-Netzwerk mit Standard-Einstellungen erstellt. Docker hat automatisch ein Subnetz und ein Gateway zugewiesen. In diesem Schritt lernen wir, wie man ein Bridge-Netzwerk erstellt und sein eigenes Subnetz und Gateway angibt. Dies gibt Ihnen mehr Kontrolle über die Netzwerkkonfiguration für Ihre Container.

Zunächst entfernen wir die Container und das Netzwerk, die im vorherigen Schritt erstellt wurden, um von vorne anzufangen.

docker stop container1 container2
docker rm container1 container2
docker network rm my-bridge-network

Jetzt erstellen wir ein neues Bridge-Netzwerk namens custom-bridge-network und geben ein benutzerdefiniertes Subnetz und Gateway mit den Flags --subnet und --gateway an. Wir verwenden das Subnetz 172.20.0.0/16 und das Gateway 172.20.0.1.

docker network create \
  --driver bridge \
  --subnet 172.20.0.0/16 \
  --gateway 172.20.0.1 \
  custom-bridge-network

Das Flag --driver bridge gibt explizit den Bridge-Treiber an, obwohl dies der Standard ist. Das Flag --subnet definiert den IP-Adressbereich für das Netzwerk, und das Flag --gateway setzt die Gateway-IP-Adresse für Container, die an dieses Netzwerk angeschlossen sind.

Um zu überprüfen, ob das Netzwerk mit dem angegebenen Subnetz und Gateway erstellt wurde, untersuchen wir das Netzwerk.

docker network inspect custom-bridge-network

In der Ausgabe suchen Sie unter dem Abschnitt IPAM. Sie sollten die Felder Subnet und Gateway sehen, die mit den von Ihnen angegebenen Werten (172.20.0.0/16 und 172.20.0.1) übereinstimmen.

Jetzt starten wir einen Container und verbinden ihn mit unserem neuen Netzwerk. Wir verwenden erneut das alpine-Image.

docker run -d --name custom-container1 --network custom-bridge-network alpine sleep infinity

Dieser Befehl startet einen Container namens custom-container1 und verbindet ihn mit custom-bridge-network. Docker wird diesem Container eine IP-Adresse aus dem angegebenen Subnetz (172.20.0.0/16) zuweisen.

Um die IP-Adresse des Containers innerhalb des benutzerdefinierten Netzwerks zu überprüfen, untersuchen wir den Container.

docker inspect custom-container1

In der Ausgabe, unter dem Abschnitt Networks für custom-bridge-network, sollten Sie eine IpAddress sehen, die in den Bereich 172.20.0.0/16 fällt.

Lassen Sie uns einen weiteren Container auf demselben Netzwerk starten.

docker run -d --name custom-container2 --network custom-bridge-network alpine sleep infinity

Jetzt befinden sich sowohl custom-container1 als auch custom-container2 im custom-bridge-network und sollten in der Lage sein, miteinander zu kommunizieren.

Wie im vorherigen Schritt benötigen wir iputils, um zu pingen.

docker exec custom-container1 apk add --no-cache iputils
docker exec custom-container2 apk add --no-cache iputils

Testen Sie die Kommunikation, indem Sie custom-container2 von custom-container1 aus pingen.

docker exec custom-container1 ping -c 3 custom-container2

Sie sollten erfolgreiche Ping-Antworten sehen, was die Kommunikation innerhalb des benutzerdefinierten Bridge-Netzwerks bestätigt.

Erstellen eines anschließbaren Overlay-Netzwerks für die Kommunikation zwischen mehreren Hosts

Bridge-Netzwerke eignen sich für die Kommunikation zwischen Containern auf demselben Docker-Host. Für die Kommunikation zwischen Containern, die auf verschiedenen Docker-Hosts laufen, benötigen Sie jedoch ein Overlay-Netzwerk. Overlay-Netzwerke werden von Docker Swarm erstellt und verwaltet.

In diesem Schritt werden wir ein anschließbares Overlay-Netzwerk erstellen. Ein anschließbares Overlay-Netzwerk ermöglicht es eigenständigen Containern (die nicht Teil eines Swarm-Services sind), sich daran anzuschließen und über verschiedene Docker-Hosts hinweg zu kommunizieren.

Zunächst müssen wir Docker Swarm auf diesem Host initialisieren. Dies ist erforderlich, um Overlay-Netzwerke zu erstellen und zu verwalten.

docker swarm init --advertise-addr $(hostname -I | awk '{print $1}')

Dieser Befehl initialisiert das Swarm und setzt die Anzeigeadresse auf die IP-Adresse des Hosts. Die Ausgabe zeigt, dass der aktuelle Knoten jetzt ein Swarm-Manager ist.

Nachdem Swarm initialisiert ist, können wir ein anschließbares Overlay-Netzwerk erstellen. Wir nennen es my-overlay-network. Das Flag --attachable ist entscheidend, um es eigenständigen Containern zu ermöglichen, sich anzuschließen.

docker network create \
  --driver overlay \
  --attachable \
  my-overlay-network

Das Flag --driver overlay gibt an, dass wir ein Overlay-Netzwerk erstellen. Das Flag --attachable macht das Netzwerk für eigenständige Container verfügbar.

Um zu überprüfen, ob das Overlay-Netzwerk erstellt wurde, listen wir die Docker-Netzwerke auf.

docker network ls

Sie sollten my-overlay-network in der Liste sehen, und sein Treiber sollte overlay sein.

Jetzt starten wir einen eigenständigen Container und verbinden ihn mit unserem neuen Overlay-Netzwerk. Wir verwenden das alpine-Image.

docker run -d --name overlay-container1 --network my-overlay-network alpine sleep infinity

Dieser Befehl startet einen Container namens overlay-container1 und verbindet ihn mit my-overlay-network.

Um zu überprüfen, ob der Container mit dem Overlay-Netzwerk verbunden ist, untersuchen wir den Container.

docker inspect overlay-container1

In der Ausgabe suchen Sie nach dem Abschnitt Networks. Sie sollten my-overlay-network aufgeführt sehen.

Da dies eine Single-Host-Umgebung ist, können wir die Kommunikation zwischen mehreren Hosts nicht vollständig demonstrieren. Das Netzwerk ist jedoch so konfiguriert, dass dies möglich ist, wenn Sie mehrere Swarm-Knoten hätten.

Lassen Sie uns einen weiteren Container auf demselben Overlay-Netzwerk auf diesem einzelnen Host starten.

docker run -d --name overlay-container2 --network my-overlay-network alpine sleep infinity

Jetzt befinden sich sowohl overlay-container1 als auch overlay-container2 im my-overlay-network und sollten in der Lage sein, miteinander zu kommunizieren.

Installieren Sie iputils in den Containern für das Pingen.

docker exec overlay-container1 apk add --no-cache iputils
docker exec overlay-container2 apk add --no-cache iputils

Testen Sie die Kommunikation, indem Sie overlay-container2 von overlay-container1 aus pingen.

docker exec overlay-container1 ping -c 3 overlay-container2

Sie sollten erfolgreiche Ping-Antworten sehen, was die Kommunikation innerhalb des Overlay-Netzwerks auf diesem einzelnen Host bestätigt.

Erstellen eines internen Overlay-Netzwerks

Im vorherigen Schritt haben wir ein anschließbares Overlay-Netzwerk erstellt, das es eigenständigen Containern ermöglicht, sich anzuschließen. In diesem Schritt werden wir ein internes Overlay-Netzwerk erstellen. Interne Netzwerke sind von externen Netzwerken isoliert, was bedeutet, dass Container in einem internen Netzwerk nicht mit der Außenwelt (einschließlich des Netzwerks des Docker-Hosts) kommunizieren können, es sei denn, dies ist ausdrücklich erlaubt. Dies ist nützlich für die Erstellung isolierter Servicenetze innerhalb eines Swarms.

Zunächst bereinigen wir die Container und das Netzwerk aus dem vorherigen Schritt.

docker stop overlay-container1 overlay-container2
docker rm overlay-container1 overlay-container2
docker network rm my-overlay-network

Jetzt erstellen wir ein internes Overlay-Netzwerk namens my-internal-network. Hierfür verwenden wir das Flag --internal.

docker network create \
  --driver overlay \
  --internal \
  my-internal-network

Das Flag --internal stellt sicher, dass Container, die mit diesem Netzwerk verbunden sind, nicht mit externen Netzwerken kommunizieren können.

Um zu überprüfen, ob das interne Overlay-Netzwerk erstellt wurde, listen wir die Docker-Netzwerke auf.

docker network ls

Sie sollten my-internal-network in der Liste mit dem overlay-Treiber sehen.

Jetzt starten wir einen Container und verbinden ihn mit unserem neuen internen Netzwerk. Wir verwenden das alpine-Image.

docker run -d --name internal-container1 --network my-internal-network alpine sleep infinity

Dieser Befehl startet einen Container namens internal-container1 und verbindet ihn mit my-internal-network.

Um zu überprüfen, ob der Container mit dem internen Netzwerk verbunden ist, untersuchen wir den Container.

docker inspect internal-container1

In der Ausgabe suchen Sie nach dem Abschnitt Networks. Sie sollten my-internal-network aufgeführt sehen.

Lassen Sie uns einen weiteren Container auf demselben internen Netzwerk starten.

docker run -d --name internal-container2 --network my-internal-network alpine sleep infinity

Jetzt befinden sich sowohl internal-container1 als auch internal-container2 im my-internal-network. Sie sollten in der Lage sein, miteinander zu kommunizieren, aber nicht mit der Außenwelt.

Installieren Sie iputils in den Containern für das Pingen.

docker exec internal-container1 apk add --no-cache iputils
docker exec internal-container2 apk add --no-cache iputils

Testen Sie die Kommunikation, indem Sie internal-container2 von internal-container1 aus pingen.

docker exec internal-container1 ping -c 3 internal-container2

Sie sollten erfolgreiche Ping-Antworten sehen, was die Kommunikation innerhalb des internen Overlay-Netzwerks bestätigt.

Jetzt versuchen wir, von internal-container1 aus eine externe Adresse wie google.com zu pingen.

docker exec internal-container1 ping -c 3 google.com

Dieser Ping sollte fehlschlagen, da das interne Netzwerk von externen Netzwerken isoliert ist.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man den Befehl docker network create verwendet, um Container-Netzwerke zu verwalten. Wir begannen damit, ein einfaches Bridge-Netzwerk zu erstellen, das der Standard-Netzwerktyp für Container ist, und überprüften seine Erstellung und Details mit docker network ls und docker network inspect. Anschließend haben wir gezeigt, wie man einen Container mit diesem neu erstellten Netzwerk verbindet.

Basierend auf dem einfachen Bridge-Netzwerk haben wir die Erstellung eines Bridge-Netzwerks mit einem benutzerdefinierten Subnetz und Gateway untersucht, um mehr Kontrolle über die IP-Adressierung des Netzwerks zu haben. Schließlich haben wir uns der Erstellung von Overlay-Netzwerken gewidmet, insbesondere eines anschließbaren Overlay-Netzwerks für die Kommunikation zwischen mehreren Hosts und eines internen Overlay-Netzwerks für isolierte Kommunikation innerhalb eines Swarms. Dies zeigt die Vielseitigkeit der Docker-Netzwerke für verschiedene Bereitstellungsszenarien auf.