Docker installieren unter Ubuntu/Debian

Einführung

In diesem Tutorial wird erklärt, wie man Docker CE (Community Edition) installiert, einen ersten Container erstellt und wie man Docker wieder deinstalliert.

Wenn Sie einen neuen Hetzner Cloud Server erstellen und die Hetzner Cloud App Docker auswählen, wird docker-ce automatisch für Sie auf dem Server vorinstalliert.

Container

Mit Containern ist es möglich Programme in einer isolierten Umgebung auf dem System laufen zu lassen. Das heißt innerhalb eines Containers kann man von einem bestimmten Programm beispielsweise eine andere Version laufen lassen, als sie bereits auf dem Host verfügbar ist. Durch diese Unabhängigkeit ist es möglich in einem Container ganze Umgebungen mit Programmen und deren Abhängigkeiten einzurichten und diese mittels Docker Images mit anderen Docker-Benutzern zu teilen, ohne dass deren Betriebssystem oder bereits installierte Programme eine Rolle spielen. Unter Linux kann eine solche Isolierung mithilfe von Cgroups und sogenannten Namespaces geschaffen werden. Mit Cgroups wird kontrolliert, welche Ressourcen ein Prozess verwenden kann (z. B. CPU). Mit Namespaces wird beeinflusst, was ein Prozess sehen kann.

Bereits bevor ein Benutzer einen Container erstellt, sind Cgroups und Namespaces auf dem System vorhanden. Jedes Namespace enthält bestimmte Informationen zu einem Thema (Einhängepunkte, Prozess-ID, ...). Sobald auf einem System ein neuer Prozess gestartet wird, wird diesem ein Namespace zu jeder Information zugewiesen. Wenn zu einer Information zwei Namespaces verfügbar sind, kann der Benutzer festlegen, welches der beiden Namespaces dem Prozess zugewiesen werden soll. Diese Möglichkeit ist im Grunde das, worauf Docker aufbaut. Für jeden Docker Container werden neue Namespaces erstellt, die vom Benutzer mit eigenen Konfigurationen und Regeln eingerichtet werden können, wie beispielsweise eigene Einhängepunkte oder eigene Netzwerkeinstellungen.

Wichtige Namespaces und deren Zweck erklärt:

• PID - Process-ID Namespace

  Sobald auf einem System ein neuer Prozess gestartet wird, erhält dieser eine individuelle Identifikationsnummer. Innerhalb eines PID Namespaces beginnt die Nummerierung immer bei 1 und ist aufsteigend. Zusätzlich werden innerhalb eines PID Namespaces nur die Prozesse gesehen, die auch innerhalb dieses Namespaces gestartet wurden. Das Erstellen eines neuen PID Namespaces ist ein eigener Prozess, der innerhalb eines existierenden PID Namespaces gestartet werden muss. Das neu erstellte PID Namespace wird dadurch zum "Tochter"-Namespace von dem PID Namespace, in dem es erstellt wurde ("Mutter"-Namespace). Ein "Mutter"-Namespace kann neben den eigenen Prozessen auch alle Prozesse sehen, die im "Tochter"-Namespace gestartet werden.

  Ein PID Namespace existiert nur solange mindestens ein laufender Prozess ausgeführt wird. Sobald der letzte Prozess innerhalb eines PID Namespaces beendet wird, wird das dazugehörige PID Namespace automatisch vom System gelöscht.

• UTS - Unix-Timesharing-System Namespace

  Hiermit ist es möglich einem oder mehreren Prozessen einen eigenen Hostnamen zu vergeben. Ein eigener Hostname kann beispielsweise bei Logdateien hilfreich sein, in welchen mitunter auch Hostnamen angegeben werden. In Bezug auf Docker Container helfen unterschiedliche Hostnamen vor allem auch dabei den Überblick zu behalten. Denn in der Befehlseingabe wird neben dem Benutzernamen auch der Hostname angegeben. Wenn der Host und der Container unterschiedliche Hostnamen besitzen, lässt sich in der Befehlseingabe erkennen, ob der nächste Befehl auf dem Host ausgeführt wird oder auf dem Container.

• NET - Network Namespace

  Hiermit ist es möglich einem oder mehreren Prozessen eine eigene Netzwerkschnittstelle zuzuweisen. Jede Schnittstelle (bzw. jedes NET Namespace) besitzt eigene Firewallregeln und eigene Routingtabellen. NET Namespaces, die auf demselben Host laufen, sind nicht automatisch miteinander verbunden. Die Netzwerkeinstellungen müssen daher erst entsprechend eingerichtet werden, bevor eine Kommunikation zwischen zwei verschiedenen NET Namespaces möglich ist.

• MNT - Mount Namespace

  Hiermit ist es möglich einem oder mehreren Prozessen ein eigenes Dateiverzeichnis mit eigenen Einhängepunkten zuzuweisen.

Namespaces werden pro Prozess zugewiesen. Für Container 1 bedeutet das, dass den Prozessen 6, 7 und 8 (Prozessbaum PID 1) jeweils die Namespaces UTS 2, PID 2, NET 2 und MNT 2 zugewiesen sind.
Mit ls -al /proc/self/ns können Sie sich die Namespaces Ihres aktuellen Prozesses anzeigen lassen. Wenn Sie diesen Befehl auf Ihrem Host ausführen, sollten die Namespaces eine andere ID Besitzen als innerhalb eines Docker Containers.

Voraussetzungen

• Grundlegende Kenntnisse über Server
• Zugriff auf den root-Benutzer oder einen Benutzer mit sudo-Rechten
• Kommandozeile
• Dieses Tutorial wurde anhand von Ubuntu 22.04 und Debian 12 erstellt, es sollte aber auch für ältere Versionen verwendet werden können.

Beispiel-Benennungen

• Benutzername: holu

Beachten Sie, dass in allen Beispiel-Befehlen holu mit dem eigenen Benutzernamen ersetzt werden muss.

Alle Docker-bezogenen Informationen, die in diesem Tutorial erwähnt werden, basieren auf dem Stand von Ende 2023.

Schritt 1 - Docker Engine installieren

Um Docker nutzen zu können, muss zunächst das entsprechende Programm installiert werden. Dafür können Sie ein Paket nutzen. Ein Paket ist im Vergleich zu einem Source-Code bereits vorkompiliert und beinhaltet Skripte anhand welcher die Installation des Programms und aller vorausgesetzten Abhängigkeiten automatisch ausgeführt wird.

In den meisten Fällen, wird ein Programmpaket direkt von dem entsprechenden Programm-Anbieter bereitgestellt. Manchmal gibt es aber mehr als nur eins, wie im Fall von Docker. Ein Paket zur Installation von Docker Engine wird sowohl von Docker Inc. angeboten als auch von Debian und Ubuntu. Die Pakete selbst sind über Archive verfügbar, welche auch als Paket-Repositories bekannt sind. Die Unterschiede der Pakete werden untenstehend genauer erklärt.

Für Pakete können Sie den apt-Befehl verwenden. Mit diesem Befehl wird über HTTP auf das Repository zugegriffen und das Paket heruntergeladen. Sobald das Paket auf dem System ist, wird es mittels eines GPG-Keys verifiziert. Erst nachdem sichergestellt wurde, dass das Paket nicht von außerhalb modifiziert wurde, wird dieses Paket genutzt, um das gewünschte Programm zu installieren. Wie die meisten Paket-Archive, ist das Debian/Ubuntu Repository über HTTP erreichbar. Das Docker Repository ist hingegen über HTTPS erreichbar. HTTPS wird von apt nicht automatisch unterstützt. Damit über apt auf das Docker-Repository zugegriffen werden kann, muss daher eine apt-Erweiterung installiert werden.

Zusammengefasst bedeutet das:

• Paket wird aus Repository (Paket-Archiv) heruntergeladen
• Paket wird mit GPG-Key verifiziert
• Docker wird über das Paket installiert

Damit diese Schritte durchgeführt werden können, müssen auf dem System folgende Informationen hinterlegt sein:

• URL des Repositories
  • Docker Debian/Ubuntu
  • Debian AMD/ARM, Ubuntu AMD / ARM
• GPG-Key des Repositories
  • Docker Debian / Ubuntu
  • Debian, Ubuntu AMD / ARM

Das Repository und der entsprechende GPG-Key von Debian bzw. Ubuntu sind automatisch auf dem System hinterlegt.

Das Repository und der entsprechende GPG-Key von externen Anbietern, wie beispielsweise Docker, müssen manuell hinterlegt werden.

Bei der Installation von Docker Engine können Sie wählen zwischen docker.io (Debian/Ubuntu) und docker-ce (Docker).

Da das Repository und der entsprechende GPG-Key von Debian/Ubuntu bereits auf dem System hinterlegt sind, kann das docker.io-Paket direkt installiert werden. Für docker-ce müssen vor der Installation zunächst die nötigen Informationen hinterlegt werden.

Diese Optionen werden untenstehend im Detail erklärt:

• Option 1 - docker.io installieren - Für einen schnellen Start

  Schritte:

  • Docker installieren

• Option 2 - docker-ce installieren

  Schritte:

  • Dockers offiziellen GPG-Key hinterlegen
  • Docker-Repository hinterlegen
  • HTTPS-Erweiterung von apt installieren
  • Docker installieren

Da das docker.io-Paket direkt heruntergeladen werden kann, eignet sich dieses besonders für einen schnellen Start. Sollten Sie Docker auch über dieses Tutorial hinaus noch verwenden wollen, ist es sinnvoll die Unterschiede der beiden Optionen zu verstehen. Folgend werden diese daher kurz erläutert.

Unterschied zwischen docker.io und docker-ce

Im Überblick:

Zusammengefasst gibt es zwischen diesen beiden Optionen zwei Wesentliche Unterschiede:

1. Anbieter

   • docker-ce ist das offizielle Software-Paket von Docker Inc.. Docker Engine wird hier direkt aus dem entsprechenden Source Repository installiert.
     
     Updates werden regelmäßig durchgeführt und sind direkt verfügbar.

   • docker.io ist ein Software-Paket, das von Debian/Ubuntu bereitgestellt wird. Docker Engine wird hier nicht direkt aus dem entsprechenden Source Repository (Upstream) installiert. Stattdessen besitzt das Software-Paket ein eigenes Debian/Ubuntu Package Repository (Downstream), welches Docker Engine beinhaltet. Dazu wurde der Source Code von Docker Engine aus dem Upstream übernommen und angepasst.
     
     Updates aus dem Source Repository (Upstream) können im Package Repository (Downstream) von docker.io erst nachträglich übernommen werden. Dadurch ist die aktuellste Version von Docker Engine über docker.io oftmals erst verspätet verfügbar.

   Welche Version tatsächlich gerade jeweils verfügbar ist, kann mit apt-cache policy (Ubuntu) bzw. apt list (Debian) geprüft werden:

   sudo apt update
   apt-cache policy docker.io
   apt-cache policy docker-ce

   Beachten Sie, dass apt-cache policy bei Debian mit apt list ersetzt werden muss und dass die verfügbaren Versionen von docker-ce nur angezeigt werden können, wenn das Docker-Repository bereits hinterlegt wurde, siehe Option 2 - docker-ce installieren.

   In der offiziellen Dokumentation von Docker können Sie die jeweils aktuellste verfügbare Docker Engine Version von docker.io und docker-ce miteinander vergleichen.

2. Pakete

   Programme wie Docker sind sehr komplex und bauen sich oftmals aus mehreren Programmen auf, deren Fokus jeweils auf einer anderen Aufgabe liegt. Für manche Aufgaben gibt es bereits passende Lösungen, die von Drittanbietern entwickelt, getestet und optimiert wurden. In vielen Fällen ist es sinnvoll auf diese Programme zurückzugreifen und diese in das eigene Produkt einzubauen. Auch Docker bildet hier keine Ausnahme.

   Die Art und Weise, wie ein solches Drittanbieter-Programm in Docker integriert wird, unterscheidet sich zwischen dem docker-ce-Paket und dem docker.io-Paket.

   • docker.io
     Das Paket enthält Informationen darüber, welche zusätzlichen Pakete benötigt werden, damit das Programm fehlerfrei laufen kann. Diese zusätzlichen Pakete heißen Abhängigkeiten. In den meisten Fällen werden Abhängigkeiten automatisch heruntergeladen und installiert, bevor das eigentlich angeforderte Programm installiert wird. Sobald es zu einem der zusätzlichen Pakete ein Update gibt, kann dieses direkt ausgeführt werden.

   • docker-ce
     Externe Programme werden teils nicht als eigenes Paket installiert. Stattdessen sind diese Programme direkt im containerd.io-Paket von Docker enthalten. Wenn es zu einem dieser im Paket enthaltenen Programme ein Update gibt, ist es nicht möglich die Aktualisierung direkt zu übernehmen. Erst wenn für das gesamte containnerd.io-Paket ein neues Update verfügbar ist, erhält man schließlich auch für die darin enthaltenen Programme die neueste Version.

   Diese verschiedenen Ansätze sieht man beispielsweise an den Programmen containerd und runc.

   Mit docker.io von Debian/Ubuntu werden neben dem docker.io-Paket automatisch auch ein containerd-Paket und ein runc-Paket installiert. Sobald für containerd oder runc ein neues Update verfügbar ist, kann das entsprechende Paket unabhängig von Docker aktualisiert werden.
   Zusätzlich sind containerd und runc als eigene Pakete auch für alle anderen Programme auf dem System verfügbar, unabhängig von Docker.

   Das docker-ce-Paket von Docker Inc. hängt im Vergleich dazu nicht von den beiden Paketen containerd und runc selbst ab, sondern von dem Docker-eigenen Paket containerd.io. containerd und runc sind direkt im containerd.io-Paket enthalten. Die neuesten Versionen von containerd und runc sind damit erst verfügbar, wenn das gesamte containerd.io-Paket sein nächstes Update erhält.
   Zusätzlich sind containerd und runc hier nur für Docker verfügbar. Sollten auch andere Pakete auf dem System von containerd oder runc abhängen, muss containerd bzw. runc für diese Pakete zusätzlich installiert werden. Dadurch kann es vorkommen, dass Sie containerd bzw. runc am Ende doppelt oder mehrfach auf Ihrem System haben. Dieser Ansatz kann beispielsweise auch sinnvoll sein, wenn die betroffenen Pakete jeweils von unterschiedlichen Versionen von containerd bzw. runc abhängen.

   Im Überblick:

   Ausführbare Befehle	docker.io	docker-ce
   runc	runc-Paket	containerd.io-Paket
   containerd	containerd-Paket	containerd.io-Paket
   dockerd, docker-init, docker-proxy	docker.io-Paket	docker-ce-Paket
   docker	docker.io-Paket	docker-ce-cli-Paket

   Die obenstehende Tabelle zeigt, dass docker.io für jedes Programm, das von einem anderen Anbieter stammt, ein eigenes Paket verwendet. Die beiden Pakete von Docker, wurden hier in einem Debian/Ubuntu-Paket zusammengefasst.

   Auch docker-ce verwendet mehrere Pakete. Hier wird aber ein Paket für Programme von externen Anbietern verwendet (containerd.io), ein Paket für Docker selbst (docker-ce) und ein Paket für das Docker Kommandozeilen-Tool (docker-ce-cli). Das containerd.io-Paket enthält zwei Programme von zwei unterschiedlichen Anbietern. Sobald einer der Anbieter ein neues Update herausgibt, wird das entsprechende Programm erst aktualisiert, wenn das gesamte containerd.io-Paket sein nächstes Update erhält.

Option 1 - docker.io installieren

Wie zuvor bereits erklärt müssen sowohl das entsprechende Repository als auch der dazugehörige GPG-Key auf dem System hinterlegt sein, damit ein Paket installiert werden kann. Das offizielle Repository des Betriebssystems ist automatisch hinterlegt und kann bei Interesse hier eingesehen werden:

• Repository: cat /etc/apt/sources.list
• GPG-Key: ls /usr/share/keyrings

Führen Sie folgende Schritte durch, um docker.io zu installieren:

sudo apt update
sudo apt install docker.io

Das Paket docker.io sollte nun installiert sein. Als Nächstes können Sie mit Schritt 2 - Benutzer der Docker Gruppe hinzufügen fortfahren.

Option 2 - docker-ce installieren

Wie zuvor bereits erklärt, müssen zwei bestimmte Informationen hinterlegt werden, bevor ein Paket installiert werden kann. Das Docker-Repository, aus welchem das Paket heruntergeladen werden soll und der dazugehörige Docker-GPG-Key (Debian / Ubuntu).

Führen Sie daher folgende Schritte durch:

• Dockers offiziellen GPG-Key hinterlegen

  Mit dem apt-Befehl werden Pakete erst aus dem Repository heruntergeladen und anschließend über eine GPG-Signatur verifiziert. Der GPG-Key besteht aus zwei Teilen, einem privaten Key und einem öffentlichen Key. Sie benötigen den öffentlichen Key. Um diesen hinzuzufügen, kann der gpg-Befehl genutzt werden. Dieser ist im gnupg-Paket enthalten.

  • Falls gnupg noch nicht installiert ist, installieren Sie es jetzt:

    sudo apt update
    sudo apt install gnupg

  • GPG-Key bei Ubuntu hinterlegen:

    curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

  • GPG-Key bei Debian hinterlegen:

    curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

  Mit dem vorangehenden Befehl wird der GPG-Key aus dem Docker-Repository unter https://download.docker.com heruntergeladen und anschließend lokal mit dem Namen docker-archive-keyring.gpg unter dem Pfad /usr/share/keyrings gespeichert.

  Sobald der GPG-Key heruntergeladen und gespeichert wurde, können Sie sich diesen listen lassen:

  ls -al /usr/share/keyrings

  Output:

  drwxr-xr-x  2 root root 4096 May 17 08:49 .
  drwxr-xr-x 99 root root 4096 May 17 08:37 ..
  -rw-r--r--  1 root root 2760 May 17 08:49 docker-archive-keyring.gpg

• Docker-Repository hinterlegen

  Damit APT auf das Repository zugreifen kann, muss dieses unter dem Pfad hinterlegt werden, über den APT alle verfügbaren Repositories verwaltet:

  • /etc/apt/sources.list.d

  Hinterlegen Sie das Docker Repository auf dem System:

  • Ubuntu:

    echo \
      "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu \
      $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

  • Debian:

    echo \
      "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/debian \
      $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

  Die Informationen der Variablen können alternativ auch direkt angegeben werden:
  Geben Sie dpkg --print-architecture bzw. lsb_release -cs in Ihrer Kommandozeile ein und ersetzen Sie die gesamte Variable im obenstehenden Befehl mit dem Output.

  Mit dem eben ausgeführten Befehl wird eine neue Datei namens docker.list unter dem Pfad /etc/apt/sources.list.d erstellt. Der im Befehl in Anführungszeichen angegebene Text wird der neuen Datei als erste Zeile hinzugefügt. Die Variablen $(dpkg --print-architecture) und $(lsb_release -cs) werden in der neuen Datei automatisch mit den tatsächlichen Informationen ersetzt.

  Mit cat können Sie sich anzeigen lassen, was in der neuen docker.list-Datei steht:

  cat /etc/apt/sources.list.d/docker.list

  Beispiel-Output:

  deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu jammy stable

  Der Text lässt sich wie folgt gliedern:

  <Archiv-Typ> [<Architektur> <GPG-Key>] <Repository-URL> <Version> <Updates>

  • Archiv-Typ: Gibt an, was über das Repository heruntergeladen werden kann (deb, deb-src). Mit deb-scr kann man beispielsweise einen Tarball herunterladen. Mit deb kann man ein deb-Paket (z. B. docker-ce) herunterladen.

  • Architektur: Möglich sind beispielsweise amd64 oder armhf. Wenn Sie in Ihrer Kommandozeile den Befehl dpkg --print-architecture ausführen, wird Ihnen die Architektur Ihres Geräts angezeigt.

  • GPG-Key: Der Pfad unter welchem der GPG-Key zuvor hinterlegt wurde.

  • Repository-URL: Die URL, über welche auf das Repository zugegriffen werden kann.

  • Version: Die Version des Betriebssystems. Neben einer Versionsnummer (z. B. 22.04), haben die verschiedenen Versionen auch einen sogenannten Codenamen (z. B. Focal Fossa). Dieser Codename wird hier angegeben. Wenn Sie in Ihrer Kommandozeile den Befehl lsb_release -cs ausführen, wird Ihnen die Version Ihres Betriebssystems angezeigt.

  • Updates: Möglich sind z. B. stable oder test. Bei stable werden regelmäßig allgemein verfügbare Updates durchgeführt. Bei test werden Updates durchgeführt, die noch nicht allgemein verfügbar sind, aber bereits getestet werden können.

• HTTPS-Erweiterung von apt installieren

  Mit dem apt-Befehl werden Pakete per Default über HTTP heruntergeladen. Docker stellt seine Pakete allerdings über HTTPS bereit.

  Das s bei HTTPS steht für secure und deutet darauf hin, dass eine Seite über ein TLS/SSL-Zertifikat verfügt. Mit einem solchen Zertifikat wird gewährleistet, dass der gesamte Datenverkehr zwischen dem Client, der auf diese Seite zugreift, und dem Server, auf dem diese Seite gehostet wird, verschlüsselt ist. TSL/SSL-Zertifikate werden von einer Zertifizierungsstelle (CA - certificate authority) ausgestellt. Bevor eine Verbindung zu einer HTTPS-Seite hergestellt wird, überprüft der Client über die Zertifizierungsstelle, ob das Zertifikat legitim ist. Meist ist der Client ein Browser, in diesem Fall ist der Client aber die Kommandozeile.

  Damit über HTTPS kommuniziert werden kann, muss apt folgende Voraussetzungen erfüllen:

  • HTTPS unterstützen (apt-transport-https)
  • HTTP/HTTPS-Datenaustausch über Kommandozeile unterstützen (curl)
  • Über eine Liste bekannter Zertifizierungsstellen verfügen (ca-certificates)

  apt Versionen ab 1.5 erfüllen diese Voraussetzungen automatisch. Nur für ältere Versionen müssen die obengenannten Pakete zusätzlich installiert werden.

  Installieren Sie nun die obengenannten Pakete, damit apt ein Paket aus einem HTTPS-Repository herunterladen kann:

  sudo apt install apt-transport-https ca-certificates curl

  Da curl auch benötigt wird, um Pakete über HTTP mittels der Kommandozeile herunterzuladen, ist es wahrscheinlich das dieses Tool bereits installiert ist. In diesem Fall wird die Installation automatisch übersprungen.

• Docker installieren

  Mit dem apt-Befehl, werden Pakete per Default von einer HTTP-Seite heruntergeladen und anschließend über eine GPG-Signatur verifiziert.

  Durch die vorherigen Schritte haben Sie:

  • Dockers offiziellen GPG-Key hinterlegt
  • Das Docker-Repository (HTTPS-URL) hinterlegt
  • Eingerichtet, dass apt auch HTTPS unterstützt

  Nun können Sie das Docker-Paket installieren:

  sudo apt update
  sudo apt install docker-ce docker-ce-cli containerd.io

Wenn Sie die vorangegangenen Schritte künftig nicht mehr manuell ausführen wollen, können Sie auch eine der folgenden Optionen nutzen:

• Hetzner Cloud App Docker
• Docker Convenience Script Ubuntu / Debian

Schritt 2 - Benutzer der Docker-Gruppe hinzufügen

Bevor Sie mit Docker loslegen, sollten Sie Ihren Benutzer der Docker-Gruppe hinzufügen. Denn beim Erstellen oder Modifizieren eines Docker Containers werden zwei wesentliche Bestandteile benötigt, das Kommandozeilen-Tool von Docker docker, welches vom Benutzer zum Ausführen von Befehlen genutzt wird, und der Docker Daemon, welcher die Befehle entgegennimmt und anschließend die entsprechenden Prozesse startet. Die Kommunikation zwischen docker und dem Docker Daemon findet nicht direkt statt, stattdessen dient das Docker Daemon Socket als Kommunikationsschnittstelle zwischen diesen beiden Programmen. Das heißt, alle docker-Befehle, die in der Kommandozeile ausgeführt werden, werden über das Docker Daemon Socket an den Docker Daemon übermittelt. Nutzen Sie ls -al /var/run/docker.sock, um sich die Berechtigungen des Docker Daemon Sockets anzeigen zu lassen:

srw-rw---- 1 root docker 0 May 17 11:29 /run/docker.sock

<Rechte> <hard-link-count> <Besitzer> <Gruppe> <Bytes> <bearbeitet> <Name>

Spalte 3 gibt den Besitzer des Sockets an, in diesem Fall root. Spalte 4 gibt die Gruppe des Sockets an, in diesem Fall docker. Aus Spalte 1 kann man ablesen, welche Rechte diese besitzen.

Die Rechte des Docker Daemon Socket zeigen, dass der Besitzer root und die Gruppe docker jeweils Lese- und Schreibrechte (rw-) besitzen und dass alle anderen Benutzer auf dem Server keine Rechte (---) besitzen.

Wenn Sie den docker-Befehl ausführen, ohne ein sudo davor zu setzen und ohne dass Ihr Benutzer der Docker-Gruppe hinzugefügt wurde, wird es beim Ausführen des Befehls vermutlich zu einer Fehlermeldung wie dieser kommen:

ERROR: Got permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.sock

Da die Docker-Gruppe Lese- und Schreibrechte besitzt, wird diese Fehlermeldung nicht angezeigt, wenn Ihr Benutzer dieser Gruppe hinzugefügt wurde. Die Docker-Gruppe wurde bei der Installation von Docker automatisch miterstellt.

• Fügen Sie Ihren Benutzer der Docker-Gruppe hinzu:

  sudo usermod -aG docker holu

  Beachten Sie, dass holu mit dem eigenen Benutzernamen ersetzt werden muss. Denken Sie außerdem immer daran das -a (append) mitanzugeben. Damit wird verhindert, dass der Benutzer aus allen anderen Gruppen entfernt wird, die nicht nach der -G-Option angegeben sind.

• Überprüfen Sie, ob Ihr Benutzer der Docker-Gruppe hinzugefügt wurde:

  groups holu

  Beachten Sie, dass holu mit dem eigenen Benutzernamen ersetzt werden muss.

  Output:

  holu : holu docker

  Falls die Gruppe noch nicht angezeigt wird, müssen Sie sich eventuell erst neu mit dem Server verbinden. Anschließend sollte es sich aktualisiert haben. Alternativ können Sie zum Aktualisieren auch diesen Befehl verwenden:

  su - holu

Solange Ihr Benutzer in der Docker-Gruppe ist, können Sie docker auch ohne sudo-Rechte verwenden.

Sollten Sie Ihren Benutzer nicht der Docker-Gruppe hinzufügen, denken Sie daran in den folgenden Schritten vor jeden docker-Befehl ein sudo zu setzen.

Schritt 3 - Test-Container erstellen

Nun da Ihr Benutzer der Docker-Gruppe hinzugefügt wurde, können Sie ohne sudo-Rechte Ihren ersten Container erstellen und testen ob die Installation von Docker Engine erfolgreich war.

• Docker testen

  Prüfen Sie zunächst, ob Sie den docker-Befehl verwenden können.

  docker -v

  Als Output sollte Ihnen nun die Version angezeigt werden, die von Docker installiert wurde. Wenn der Befehl erfolgreich ausgeführt wurde, können Sie als nächstes einen Container erstellen.

• Container erstellen

  Docker Container werden aus einem sogenannten Docker Image erstellt, welches bestimmt was der Container genau enthalten soll. Ein solches Image kann man sich entweder selbst über eine Dockerfile erstellen oder man importiert sich ein fertiges Image von Docker Hub. Um zu testen, ob die Installation von Docker Engine erfolgreich war, genügt es vorerst ein fertiges Image von Docker Hub zu importieren. Dabei gibt es im Allgemeinen zwei mögliche Befehle, docker pull und docker run.

  • Mit docker pull <image-name> ist es möglich ein beliebiges Image von Docker Hub zu importieren. Mit diesem Befehl wird noch kein Container erstellt.
  • Mit docker run <image-name> ist es möglich einen Container aus einem Image zu erstellen. Das im Befehl angegebene Image wird erst auf dem System gesucht. Wenn es dort nicht gefunden wird, wird die Suche anschließend auf Docker Hub fortgesetzt. Wenn dort ein passendes Image gefunden wird, wird es automatisch importiert. Anschließend wird aus diesem Image der neue Container erstellt.

  Sie können also entweder erst docker pull nutzen, um das Image von Docker Hub zu importieren und daraus anschließend mit docker run einen oder mehrere neue Container erstellen oder Sie nutzen direkt docker run und führen damit beide Schritte mit einem Befehl aus:

  docker run hello-world

  Output:

  Unable to find image 'hello-world:latest' locally
  latest: Pulling from library/hello-world
  
  ...
  
  Hello from Docker!
  This message shows that your installation appears to be working correctly.
  
  ...

  Im Output ist zu sehen, dass ein Image namens 'hello-world' wie zuvor erwähnt erst auf dem System gesucht wurde. Nachdem keines gefunden wurde, wurde es automatisch von Docker Hub importiert. Sobald das Image auf dem System war, wurde daraus der neue Container erstellt.

• Docker Image und Docker Container listen lassen

  Das importierte Image anzeigen lassen:

  docker image ls

  Den neuen Container anzeigen lassen:

  docker container ls -a

  Mit -a wird angegeben, dass alle Container angezeigt werden sollen. Also auch Container, die momentan gestoppt sind. Der hello-world-Container besitzt nach dem Anzeigen der oberen Nachricht keine laufenden Prozesse mehr, weshalb dieser wie in der Einleitung erklärt, automatisch gestoppt wurde.

Schritt 4 - Docker Engine deinstallieren

• docker.io deinstallieren

  sudo apt remove docker.io

• docker-ce deinstallieren

  sudo apt purge docker-ce docker-ce-cli containerd.io

Ergebnis

Im vorangegangenen Tutorial haben Sie gelernt wie Sie das Paket docker-ce oder docker.io installieren, Ihren Benutzer der Docker-Gruppe hinzufügen und wie Sie einen ersten Test-Container erstellen, um zu prüfen ob die Installation erfolgreich war. Als nächstes können Sie beispielsweise das Tutorial "Docker Image und Container erstellen" nutzen.

License: MIT