Wie man den Befehl docker volume create zur Datenverwaltung verwendet

DockerDockerBeginner
Jetzt üben

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

In diesem Lab lernen Sie, wie Sie die Datenpersistenz in Docker effektiv mit dem Befehl docker volume create verwalten können. Wir werden den grundlegenden Prozess der Erstellung einfacher Volumes (Datenträger) untersuchen. Volumes sind die bevorzugte Methode zur Speicherung von Containerdaten, da sie von Docker verwaltet werden und im Vergleich zu Bind-Mounts (Verknüpfungsbereichen) einfacher gesichert und migriert werden können.

Basierend auf diesen Grundlagen werden Sie dann die Erstellung von Volumes mit bestimmten Treibern (Drivers) und Optionen untersuchen, um ihr Verhalten anzupassen. Darüber hinaus wird das Lab Sie durch die Erstellung von lokalen Volumes mit benutzerdefinierten Mount-Optionen führen und zeigen, wie Sie NFS (Network File System) nutzen können, um lokale Volumes zu erstellen. Dies bietet Flexibilität für verschiedene Datenlagerszenarien.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL docker(("Docker")) -.-> docker/VolumeOperationsGroup(["Volume Operations"]) docker(("Docker")) -.-> docker/ContainerOperationsGroup(["Container Operations"]) docker(("Docker")) -.-> docker/ImageOperationsGroup(["Image Operations"]) docker/ContainerOperationsGroup -.-> docker/exec("Execute Command in Container") docker/ContainerOperationsGroup -.-> docker/inspect("Inspect Container") docker/ContainerOperationsGroup -.-> docker/create("Create Container") docker/ImageOperationsGroup -.-> docker/pull("Pull Image from Repository") docker/VolumeOperationsGroup -.-> docker/volume("Manage Volumes") subgraph Lab Skills docker/exec -.-> lab-555258{{"Wie man den Befehl docker volume create zur Datenverwaltung verwendet"}} docker/inspect -.-> lab-555258{{"Wie man den Befehl docker volume create zur Datenverwaltung verwendet"}} docker/create -.-> lab-555258{{"Wie man den Befehl docker volume create zur Datenverwaltung verwendet"}} docker/pull -.-> lab-555258{{"Wie man den Befehl docker volume create zur Datenverwaltung verwendet"}} docker/volume -.-> lab-555258{{"Wie man den Befehl docker volume create zur Datenverwaltung verwendet"}} end

Ein einfaches Volume erstellen

In diesem Schritt lernen Sie, wie Sie ein einfaches Docker-Volume (Datenträger) erstellen können. Volumes sind die bevorzugte Methode, um Daten zu speichern, die von Docker-Containern erzeugt und verwendet werden. Während Bind-Mounts (Verknüpfungsbereiche) ebenfalls eine Option sind, werden Volumes von Docker verwaltet und sind im Allgemeinen einfacher zu sichern oder zu migrieren.

Zunächst erstellen wir ein einfaches Volume mit dem Befehl docker volume create. Wir werden dieses Volume myvolume nennen.

docker volume create myvolume

Sie sollten den Namen des Volumes in der Konsole sehen, was die erfolgreiche Erstellung bestätigt.

Nun untersuchen wir das Volume genauer, um seine Details anzuzeigen. Dazu verwenden wir den Befehl docker volume inspect. Dadurch werden uns Informationen wie der Treiber (Driver) des Volumes, der Mountpunkt (Mountpoint) und der Geltungsbereich (Scope) angezeigt.

docker volume inspect myvolume

Die Ausgabe enthält Details über das Volume. Achten Sie besonders auf das Feld Mountpoint, das den Speicherort auf dem Host-Rechner anzeigt, an dem die Daten des Volumes gespeichert sind. Docker verwaltet diesen Speicherort, und Sie sollten im Allgemeinen vermeiden, Dateien direkt in diesem Verzeichnis zu ändern.

Als Nächstes führen wir einen Container aus und binden das Volume an ihn. Wir verwenden das ubuntu-Image und montieren myvolume in das Verzeichnis /app innerhalb des Containers. Wir führen auch einen einfachen Befehl aus, um einige Daten in eine Datei innerhalb des gemounteten Volumes zu schreiben.

Zuerst laden Sie das ubuntu-Image herunter, wenn Sie es nicht lokal haben.

docker pull ubuntu

Jetzt führen Sie den Container aus und schreiben Daten in das Volume.

docker run -d --name mycontainer -v myvolume:/app ubuntu bash -c "echo 'Hello from the volume!' > /app/greeting.txt && tail -f /dev/null"

Lassen Sie uns diesen Befehl analysieren:

  • docker run -d: Führt den Container im detached-Modus (im Hintergrund) aus.
  • --name mycontainer: Weist dem Container den Namen mycontainer zu.
  • -v myvolume:/app: Bindet das Volume namens myvolume an das Verzeichnis /app innerhalb des Containers.
  • ubuntu: Gibt das zu verwendende Image an.
  • bash -c "echo 'Hello from the volume!' > /app/greeting.txt && tail -f /dev/null": Führt einen Bash-Befehl innerhalb des Containers aus. Es schreibt die Zeichenfolge "Hello from the volume!" in eine Datei namens greeting.txt im Verzeichnis /app (das gemountete Volume) und führt dann tail -f /dev/null aus, um den Container am Laufen zu halten.

Um zu überprüfen, ob die Daten in das Volume geschrieben wurden, können wir einen Befehl innerhalb des laufenden Containers ausführen, um die Datei zu lesen.

docker exec mycontainer cat /app/greeting.txt

Sie sollten die Ausgabe "Hello from the volume!" sehen, was bestätigt, dass die Daten erfolgreich aus dem Container heraus in das Volume geschrieben wurden.

Abschließend stoppen und entfernen wir den Container. Das Volume bleibt auch nach der Entfernung des Containers bestehen.

docker stop mycontainer
docker rm mycontainer

Ein Volume mit einem bestimmten Treiber und Optionen erstellen

In diesem Schritt lernen Sie, wie Sie ein Docker-Volume (Datenträger) mit einem bestimmten Treiber (Driver) und treiberspezifischen Optionen erstellen können. Während der Standardtreiber local für viele Anwendungsfälle ausreicht, unterstützt Docker verschiedene Volumetreiber für unterschiedliche Speicher-Backends, wie z. B. Netzwerkspeicher oder Cloud-Speicher.

Wir werden weiterhin den local-Treiber verwenden, aber zeigen, wie man ihn explizit angibt und Optionen übergibt. Der local-Treiber unterstützt Optionen wie type, device und o, um jeweils den Dateisystemtyp, das zu montierende Gerät und die Mount-Optionen anzugeben.

Erstellen wir ein Volume namens myvolume2 mit dem local-Treiber und geben einige Optionen an. In diesem Beispiel verwenden wir den Dateisystemtyp tmpfs, der Daten im Arbeitsspeicher speichert. Dies ist nützlich für temporäre Daten, die nicht über einen Neustart des Hosts hinweg persistent sein müssen.

docker volume create --driver local --opt type=tmpfs --opt device=tmpfs --opt o=size=100m myvolume2

Lassen Sie uns diesen Befehl analysieren:

  • docker volume create: Der Befehl zum Erstellen eines Volumes.
  • --driver local: Gibt explizit den local-Volumetreiber an.
  • --opt type=tmpfs: Übergibt die Option type=tmpfs an den Treiber, um den Dateisystemtyp anzugeben.
  • --opt device=tmpfs: Übergibt die Option device=tmpfs an den Treiber, um das Gerät anzugeben. Bei tmpfs ist das Gerät ebenfalls tmpfs.
  • --opt o=size=100m: Übergibt die Option o=size=100m an den Treiber. Die Option o wird verwendet, um Mount-Optionen zu übergeben. In diesem Fall setzen wir die maximale Größe des tmpfs-Volumes auf 100 Megabyte.
  • myvolume2: Der Name des zu erstellenden Volumes.

Nach erfolgreicher Erstellung sollte der Name des Volumes in der Konsole angezeigt werden.

Nun untersuchen wir das Volume, um den verwendeten Treiber und die angegebenen Optionen anzuzeigen.

docker volume inspect myvolume2

In der Ausgabe sollten Sie sehen, dass das Feld Driver auf local gesetzt ist und das Feld Options die von uns angegebenen Optionen auflistet (type=tmpfs, device=tmpfs, o=size=100m). Das Feld Mountpoint zeigt, wo dieses tmpfs-Volume auf dem Host montiert ist.

Als Nächstes führen wir einen Container aus und binden dieses neue Volume an ihn. Wir verwenden erneut das ubuntu-Image und montieren myvolume2 in das Verzeichnis /data innerhalb des Containers.

Zuerst laden Sie das ubuntu-Image herunter, wenn Sie es nicht lokal haben (was Sie wahrscheinlich aus dem vorherigen Schritt haben).

docker pull ubuntu

Jetzt führen Sie den Container aus und binden das Volume an ihn.

docker run -d --name mycontainer2 -v myvolume2:/data ubuntu tail -f /dev/null

Dieser Befehl führt einen ubuntu-Container namens mycontainer2 im detached-Modus aus und bindet myvolume2 an /data. tail -f /dev/null hält den Container am Laufen.

Da myvolume2 ein tmpfs-Volume ist, werden alle Daten, die in /data innerhalb des Containers geschrieben werden, im Arbeitsspeicher gespeichert und gehen verloren, wenn der Container gestoppt und entfernt wird oder wenn der Host neu gestartet wird.

Lassen Sie uns den Container stoppen und entfernen.

docker stop mycontainer2
docker rm mycontainer2

Das Volume myvolume2 existiert weiterhin, aber seine Inhalte (falls welche geschrieben wurden) sind weg, da es sich um ein tmpfs-Volume handelt.

Ein lokales Volume mit Mount-Optionen erstellen

In diesem Schritt lernen Sie, wie Sie ein lokales Docker-Volume (Datenträger) erstellen und Mount-Optionen angeben können. Mount-Optionen ermöglichen es Ihnen, zu steuern, wie das Dateisystem gemountet wird, z. B. indem Sie Berechtigungen festlegen, bestimmte Funktionen aktivieren oder die Leistung optimieren.

Wir werden ein lokales Volume namens myvolume3 erstellen und die Option o verwenden, um Mount-Optionen anzugeben. In diesem Beispiel werden wir die Optionen uid und gid festlegen, um sicherzustellen, dass Dateien, die von einem Container im Volume erstellt werden, von einem bestimmten Benutzer und einer bestimmten Gruppe auf dem Host besessen werden. Dies kann nützlich sein, um Berechtigungen zu verwalten, wenn Daten zwischen Containern und dem Host geteilt werden.

Zunächst erstellen wir ein Verzeichnis auf dem Host, das wir als Quelle für unser Volume verwenden werden. Dies ist für ein Standard-lokales Volume nicht unbedingt erforderlich, aber es hilft, zu veranschaulichen, wie Mount-Optionen das zugrunde liegende Dateisystem beeinflussen können.

mkdir -p ~/project/myvolumedata

Jetzt erstellen wir das Volume myvolume3 mit dem local-Treiber und geben die Option o mit uid und gid an. Wir verwenden die Benutzer- und Gruppen-ID des aktuellen labex-Benutzers. Sie können Ihre Benutzer- und Gruppen-ID mit den Befehlen id -u und id -g ermitteln.

USER_ID=$(id -u)
GROUP_ID=$(id -g)
docker volume create --driver local --opt type=none --opt device=/home/labex/project/myvolumedata --opt o=bind,uid=$USER_ID,gid=$GROUP_ID myvolume3

Lassen Sie uns diesen Befehl analysieren:

  • docker volume create: Der Befehl zum Erstellen eines Volumes.
  • --driver local: Gibt den local-Volumetreiber an.
  • --opt type=none: Gibt an, dass kein Dateisystemtyp automatisch erstellt werden soll. Wir binden an ein vorhandenes Verzeichnis.
  • --opt device=/home/labex/project/myvolumedata: Gibt das zu montierende Gerät an, das das von uns auf dem Host erstellte Verzeichnis ist. Beachten Sie die Verwendung des absoluten Pfads /home/labex/project/myvolumedata.
  • --opt o=bind,uid=$USER_ID,gid=$GROUP_ID: Übergibt die Mount-Optionen.
    • bind: Gibt einen Bind-Mount (Verknüpfungsbereich) an, der das Volume mit dem angegebenen Gerät (unserem Host-Verzeichnis) verknüpft.
    • uid=$USER_ID: Setzt die Benutzer-ID für Dateien, die im Volume erstellt werden, auf die ID des aktuellen Benutzers.
    • gid=$GROUP_ID: Setzt die Gruppen-ID für Dateien, die im Volume erstellt werden, auf die Gruppen-ID des aktuellen Benutzers.
  • myvolume3: Der Name des Volumes.

Sie sollten den Namen des Volumes in der Konsole sehen.

Nun untersuchen wir das Volume, um die Optionen anzuzeigen.

docker volume inspect myvolume3

In der Ausgabe sollten Sie sehen, dass der Driver auf local gesetzt ist und die Options type=none, device=/home/labex/project/myvolumedata und o=bind,uid=...,gid=... (mit Ihren Benutzer- und Gruppen-IDs) enthalten. Der Mountpoint wird der gleiche wie der device-Pfad sein.

Als Nächstes führen wir einen Container aus und binden dieses Volume an ihn. Wir verwenden das ubuntu-Image und montieren myvolume3 in das Verzeichnis /app innerhalb des Containers. Dann erstellen wir eine Datei im Verzeichnis /app des Containers und überprüfen ihre Besitzverhältnisse auf dem Host.

Zuerst laden Sie das ubuntu-Image herunter, wenn erforderlich.

docker pull ubuntu

Jetzt führen Sie den Container aus und erstellen eine Datei im gemounteten Volume.

docker run --rm -v myvolume3:/app ubuntu bash -c "echo 'Testing ownership' > /app/testfile.txt && ls -l /app/testfile.txt"

Dieser Befehl führt einen ubuntu-Container aus, bindet myvolume3 an /app, schreibt "Testing ownership" in /app/testfile.txt und listet dann die Dateidetails innerhalb des Containers auf. Sie sollten sehen, dass die Datei innerhalb des Containers als Eigentum von root aufgelistet wird, da Container standardmäßig typischerweise als root ausgeführt werden.

Jetzt überprüfen wir die Besitzverhältnisse der Datei auf dem Host-Rechner im Verzeichnis ~/project/myvolumedata.

ls -l ~/project/myvolumedata/testfile.txt

Sie sollten sehen, dass die Datei testfile.txt auf dem Host vom labex-Benutzer und der labex-Gruppe besessen wird, dank der uid- und gid-Mount-Optionen, die wir beim Erstellen des Volumes angegeben haben.

Abschließend bereinigen wir das erstellte Verzeichnis.

rm -rf ~/project/myvolumedata

Ein lokales Volume mit NFS erstellen

In diesem Schritt lernen Sie, wie Sie ein lokales Docker-Volume (Datenträger) erstellen können, das eine NFS-Freigabe (Network File System) als Backend-Speicher verwendet. Dadurch können Container Daten auf einem netzwerkgebundenen Speichergerät speichern, was die Daten von mehreren Hosts aus zugänglich macht und eine zentrale Speicherlösung bietet.

Um NFS mit dem local-Volumetreiber zu verwenden, müssen Sie die Adresse des NFS-Servers und den Pfad zum freigegebenen Verzeichnis mit der Option device angeben und den Dateisystemtyp als nfs mit der Option type festlegen. Sie müssen auch geeignete Mount-Optionen mit der Option o angeben.

Für diese Lab-Umgebung werden wir eine NFS-Freigabe simulieren, indem wir die Loopback-Adresse 127.0.0.1 und ein Verzeichnis auf dem Host verwenden. Hinweis: In einer realen Umgebung würden Sie 127.0.0.1 durch die tatsächliche IP-Adresse oder den Hostnamen Ihres NFS-Servers und /path/to/nfs/share durch den exportierten Pfad auf dem NFS-Server ersetzen.

Zunächst erstellen wir ein Verzeichnis auf dem Host, das als unsere simulierte NFS-Freigabe fungieren wird.

mkdir -p ~/project/nfs_share

Jetzt erstellen wir das Volume myvolume4 mit dem local-Treiber und NFS-Optionen.

sudo docker volume create --driver local --opt type=nfs --opt device=127.0.0.1:/home/labex/project/nfs_share --opt o=addr=127.0.0.1,rw myvolume4

Lassen Sie uns diesen Befehl analysieren:

  • sudo docker volume create: Wir verwenden sudo, da die Erstellung von NFS-Volumes oft Root-Rechte erfordert, um die Mount-Operation auf dem Host auszuführen.
  • --driver local: Gibt den local-Volumetreiber an.
  • --opt type=nfs: Gibt den Dateisystemtyp als NFS an.
  • --opt device=127.0.0.1:/home/labex/project/nfs_share: Gibt das NFS-Gerät an. Dies ist im Format nfs_server_address:/exported_path. Wir verwenden die Loopback-Adresse und das von uns gerade erstellte Verzeichnis. Beachten Sie die Verwendung des absoluten Pfads /home/labex/project/nfs_share.
  • --opt o=addr=127.0.0.1,rw: Übergibt Mount-Optionen an den NFS-Client.
    • addr=127.0.0.1: Gibt die Adresse des NFS-Servers an.
    • rw: Mountet die Freigabe mit Lese- und Schreibberechtigungen.
  • myvolume4: Der Name des Volumes.

Nach erfolgreicher Erstellung sollte der Name des Volumes in der Konsole angezeigt werden.

Nun untersuchen wir das Volume, um die NFS-spezifischen Details anzuzeigen.

docker volume inspect myvolume4

In der Ausgabe sollten Sie sehen, dass der Driver auf local gesetzt ist und die Options type=nfs, device=127.0.0.1:/home/labex/project/nfs_share und o=addr=127.0.0.1,rw enthalten. Der Mountpoint zeigt, wo dieses NFS-Volume von Docker auf dem Host montiert ist.

Als Nächstes führen wir einen Container aus und binden dieses NFS-Volume an ihn. Wir verwenden das ubuntu-Image und montieren myvolume4 in das Verzeichnis /data innerhalb des Containers. Dann erstellen wir eine Datei im Verzeichnis /data des Containers und überprüfen ihre Existenz auf der simulierten NFS-Freigabe des Hosts.

Zuerst laden Sie das ubuntu-Image herunter, wenn erforderlich.

docker pull ubuntu

Jetzt führen Sie den Container aus und erstellen eine Datei im gemounteten Volume.

docker run --rm -v myvolume4:/data ubuntu bash -c "echo 'Data on NFS' > /data/nfs_test.txt && ls -l /data/nfs_test.txt"

Dieser Befehl führt einen ubuntu-Container aus, bindet myvolume4 an /data, schreibt "Data on NFS" in /data/nfs_test.txt und listet dann die Dateidetails innerhalb des Containers auf.

Jetzt überprüfen wir die Existenz der Datei auf dem Host-Rechner im Verzeichnis ~/project/nfs_share.

ls -l ~/project/nfs_share/nfs_test.txt

Sie sollten die Datei nfs_test.txt aufgelistet sehen, was bestätigt, dass die Daten, die im Container mithilfe des NFS-Volumes geschrieben wurden, auf der simulierten NFS-Freigabe des Hosts vorhanden sind.

Abschließend bereinigen wir das erstellte Verzeichnis.

rm -rf ~/project/nfs_share

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie Docker-Volumes (Datenträger) mit dem Befehl docker volume create erstellen und verwalten können. Sie haben zunächst ein einfaches Volume erstellt und seine Details untersucht, um zu verstehen, wie Docker den Speicherort der Daten verwaltet. Anschließend haben Sie geübt, dieses Volume an einen Container anzubinden und Daten darin zu schreiben, was zeigt, wie Volumes einen dauerhaften Speicher für Containerdaten bieten. Das Lab hat auch die Erstellung von Volumes mit bestimmten Treibern und Optionen behandelt, einschließlich lokaler Volumes mit Mount-Optionen und lokaler Volumes, die NFS (Network File System) verwenden. Dies zeigt die Flexibilität und die verschiedenen Anwendungsfälle von Docker-Volumes für unterschiedliche Speicheranforderungen auf.