Docker-Tutorial: Installation und Betrieb der Container-Plattform

„Build, Ship and Run Any App, Anywhere“ – unter diesem Motto bewirbt die quelloffene Container-Plattform Docker eine flexible, ressourcensparende Alternative zur Emulation von Hardware-Komponenten auf Basis virtueller Maschinen (VMs). In unserem Docker-Tutorial für Einsteiger gehen wir den Unterschieden beider Virtualisierungstechniken auf den Grund und stellen Ihnen das Open-Source-Projekt Docker anhand übersichtlicher Schritt-für-Schritt-Anleitungen vor.

vServer (VPS) von IONOS

Günstige und starke VPS für Webserver, Mailserver und eigene Anwendungen mit persönlichem Berater und 24/7 Support. Bereits ab 5€/Monat! inkl.Performance-Upgrade 2019!

100 % SSD-Speicher
Bereit in 55 Sek.
SSL Zertifikat

Während die klassische Hardware-Virtualisierung darauf beruht, mehrere Gastsysteme auf einem gemeinsamen Host-System zu starten, werden Anwendungen bei Docker mithilfe sogenannter Container als isolierte Prozesse auf ein und demselben System ausgeführt. Man spricht bei der containerbasierten Virtualisierungdaher auch von einer Operating-System-Level-Virtualisierung.

Folgende Grafik zeigt die wesentlichen Unterschiede im architektonischen Aufbau beider Virtualisierungstechniken:

Beide Techniken bieten Entwicklern und Systemadministratoren die Möglichkeit, verschiedene Anwendungen mit unterschiedlichen Anforderungen parallel auf ein und demselben physischen System einzusetzen. Große Unterschiede finden sich jedoch in Bezug auf Ressourcenverbrauch und Portabilität.

Container: Virtualisierung mit minimalem Overhead

Werden Anwendungen im Rahmen klassischer Hardware-Virtualisierung gekapselt, erfolgt dies mithilfe eines sogenannten Hypervisors. Dieser fungiert als abstrahierende Schicht zwischen dem Hostsystem und den virtuellen Gastsystemen. Jedes Gastsystem wird dabei als komplette Maschine mit separatem Betriebssystem-Kernel realisiert. Die Hardware-Ressourcen des Host-Systems (CPU, Speicher, Festplattenplatz, verfügbare Peripherie) werden vom Hypervisor anteilig zugewiesen.

Bei der containerbasierten Virtualisierung hingegen wird kein komplettes Gastsystem nachgebildet. Stattdessen werden Anwendungen in Containern gestartet. Diese teilen sich zwar denselben Kernel, nämlich den des Hostsystems, laufen jedoch als isolierte Prozesse im User-Space.

Tipp

Moderne Betriebssysteme teilen virtuellen Speicher in der Regel in zwei getrennte Bereiche: Kernel-Space und User-Space. Während der Kernel-Space ausschließlich für den Betrieb des Kernels und anderer Kernkomponenten des Betriebssystems reserviert ist, stellt der User-Space den Speicherbereich dar, der Anwendungen zur Verfügung steht. Die strikte Trennung zwischen Kernel- und User-Space dient in erster Linie dem Schutz des Systems vor schädlichen oder fehlerhaften Anwendungen.

Der große Vorteil containerbasierter Virtualisierung liegt somit darin, dass sich Anwendungen mit unterschiedlichen Anforderungen isoliert voneinander ausführen lassen, ohne dass dafür der Overhead eines separaten Gastsystems in Kauf genommen werden muss. Dabei macht sich die Container-Technologie zwei Grundfunktionen des Linux-Kernels zunutze: Control Groups (Cgroups) und Kernel-Namespaces.

  • Cgroups limitieren den Zugriff von Prozessen auf Speicher-, CPU- und I/O-Ressourcen und verhindern so, dass der Ressourcenbedarf eines Prozesses andere laufende Prozesse beeinträchtigt.
  • Namespaces (Namensräume)beschränken einen Prozess und dessen Kindprozesse auf einen bestimmten Ausschnitt des zugrundeliegenden Systems. Um Prozesse zu kapseln, nutzt Docker Namespaces in fünf verschiedenen Bereichen:
    • Systemidentifikation (UTS): Bei der containerbasierten Virtualisierung kommen UTS-Namespaces zum Einsatz, um Containern eigene Host- und Domain-Namen zuzuweisen.
    • Prozess-IDs (PID): Jeder Docker-Container verwendet einen eigenen Namensraum für Prozess-IDs. Prozesse, die außerhalb eines Containers laufen, sind innerhalb des Containers nicht sichtbar. Somit können durch Container gekapselte Prozesse auf demselben Host-System die gleiche PID besitzen, ohne dass es zu Konflikten kommt.
    • Interprozess-Kommunikation (IPC): IPC-Namespaces isolieren Prozesse in einem Container in der Art, dass die Kommunikation mit Prozessen außerhalb des Containers unterbunden wird.
    • Netzwerkressourcen (NET): Mit Netzwerk-Namespaces lassen sich jedem Container separate Netzwerkressourcen wie IP-Adressen oder Routing-Tabellen zuweisen.
    • Mountpoints des Dateisystems (MNT): Dank Mount-Namespaces sieht ein isolierter Prozess nie das gesamte Dateisystem des Hosts, sondern lediglich einen kleinen Ausschnitt davon – in der Regel ein speziell für diesen Container angelegtes Image.

Bis Version 0.8.1 basierte die Prozessisolation bei Docker auf Linux-Containern (LXC). Seit Version 0.9 steht Anwendern das selbstentwickelte Container-Format Libcontainer zur Verfügung. Dieses ermöglicht es, Docker plattformübergreifend einzusetzen und ein und denselben Container auf verschiedenen Hostsystemen laufen zu lassen.Damit wurde es auch möglich, eine Docker-Version für Windows und macOS anzubieten.

Skalierbarkeit, Hochverfügbarkeit und Portabilität

Die Container-Technologie stellt nicht nur eine ressourcensparende Alternative zur klassischen Hardware-Virtualisierung dar. Software-Container ermöglichen es auch, Anwendungen plattformübergreifend und in unterschiedlichen Infrastrukturen einzusetzen, ohne dass diese speziell an die Hard- oder Software-Konfigurationen der jeweiligen Hostsysteme angepasst werden müssen.

Als portable Abbilder von Software-Containern kommen bei Docker sogenannte Images zum Einsatz. Container-Images beinhalten einzelne Anwendungen inklusive aller Bibliotheken, Binär- und Konfigurationsdateien, die für die Laufzeit der gekapselten Anwendungsprozesse benötigt werden, und stellen somit nur noch minimale Anforderungen an das jeweilige Hostsystem. So lässt sich ein Anwendungs-Container ohne weitere Konfiguration zwischen verschiedenen Linux-, Windows-, oder macOS-Systemen verschieben, sofern die Docker-Plattform als abstrahierende Schicht installiert wurde. Docker ist somit die ideale Grundlage, um skalierbare, hochverfügbare Software-Architekturen zu realisieren. Auf Produktivsystemen kommt Docker bei Firmen wie Spotify, Google, eBay oder Zalando zum Einsatz.

Dedicated Server von IONOS

Hardware trifft Cloud: Dedicated Server mit Cloud-Integration und mit minutengenauer Abrechnung, inklusive persönlichem Berater!

24/7 Support
Unbegrenzter Traffic
SSL Zertifikat

Docker: Aufbau und Funktionen

Docker ist das bekannteste Software-Projekt, das Anwendern eine auf Containern basierende Virtualisierungstechnologie zur Verfügung stellt. Die quelloffene Plattform setzt dabei auf drei grundlegende Komponenten: Um Container auszuführen, brauchen Anwender lediglich die Docker-Engine sowie spezielle Docker-Images, die sich über das Docker-Hub beziehen oder selbst erstellen lassen.

Docker Images

Ähnlich wie virtuelle Maschinen basieren Docker-Container auf Images. Bei einem Image handelt es sich um eine schreibgeschützte Vorlage, die sämtliche Instruktionen beinhaltet, die die Docker-Engine benötigt, um einen Container zu erzeugen. Als portables Abbild eines Containers wird ein Docker-Image in Form einer Textdatei beschrieben – man spricht von einem Dockerfile. Soll ein Container auf einem System gestartet werden, wird zunächst ein Paket mit dem jeweiligen Image geladen – sofern dieses nicht lokal vorliegt. Das geladene Image stellt das für die Laufzeit benötigte Dateisystem inklusive aller Parameter bereit. Ein Container kann als laufender Prozess eines Images betrachtet werden.

Das Docker-Hub

Das Docker-Hub ist eine cloudbasierte Registry für Software-Repositorys – mit anderen Worten: eine Art Bibliothek für Docker-Images. Der Onlinedienst teilt sich in einen öffentlichen und einen privaten Bereich auf. Der öffentliche Bereich bietet Nutzern die Möglichkeit, selbst entwickelte Images hochzuladen und mit der Community zu teilen. Hier stehen eine Reihe offizieller Images vom Docker-Entwicklerteam und etablierten Open-Source-Projekten zur Verfügung. Images, die in einen privaten Bereich der Registry hochgeladen werden, sind nicht öffentlich zugänglich und können so beispielsweise firmenintern oder im eigenen Freundes- und Bekanntenkreis geteilt werden. Das Docker-Hub erreichen Sie unter hub.docker.com.

Die Docker-Engine

Das Herzstück des Docker-Projekts ist die Docker-Engine. Dabei handelt es sich um eine quelloffene Client-Server-Anwendung, die Nutzern in der aktuellen Version auf allen etablierten Plattformen zur Verfügung steht.

Die Grundarchitektur der Docker-Engine lässt sich in drei Komponenten aufteilen: Einen Daemon mit Server-Funktionen, eine Programmierschnittstelle (API) auf Basis des Programmierparadigmas REST (Representational State Transfer) und das Terminal des Betriebssystems (Command-Line Interface, CLI) als Benutzerschnittstelle (Client).

  • Der Docker-Daemon: Als Server kommt bei der Docker-Engine ein Daemon-Prozess zum Einsatz. Der Docker-Daemon läuft im Hintergrund auf dem Hostsystem und dient der zentralen Steuerung der Docker-Engine. In dieser Funktion erstellt und verwaltet er sämtliche Images, Container oder Netzwerke.
  • Die REST-API: Die REST-API spezifiziert eine Reihe von Schnittstellen, die es anderen Programmen ermöglichen, mit dem Docker-Daemon zu kommunizieren und diesem Anweisungen zu geben. Eines dieser Programme ist das Terminal des Betriebssystems.
  • Das Terminal: Als Clientprogramm nutzt Docker das Terminal des Betriebssystems. Dieses interagiert mit dem Docker-Daemon über die REST-API und ermöglicht es Anwendern, diesen durch Skripte oder Benutzereingaben zu steuern.

Mit Docker starten, stoppen und verwalten Anwender Software-Container direkt aus dem Terminal heraus. Die Ansprache des Daemon erfolgt über das Kommando docker und Anweisungen wie build (erstelle), pull (lade herunter) oder run (starte). Client und Server können sich dabei auf dem gleichen System befinden. Alternativ steht Anwendern die Möglichkeit offen, einen Docker-Daemon auf einem anderen System anzusprechen. Je nachdem, welche Art von Verbindung aufgebaut werden soll, erfolgt die Kommunikation zwischen Client und Server über die REST-API, über UNIX-Sockets oder eine Netzwerkschnittstelle.

Folgende Grafik veranschaulicht das Zusammenspiel der einzelnen Docker-Komponenten am Beispiel der Kommandos docker build, docker pull und docker run:

Das Kommando docker build weist den Docker-Daemon an, ein Image zu erstellen (gepunktete Linie). Dazu muss ein entsprechendes Dockerfile vorliegen. Soll das Image nicht selbst erstellt, sondern aus einem Repository im Docker-Hub geladen werden, kommt das Kommando docker pull zum Einsatz (gestrichelte Linie). Wird der Docker-Daemon via docker run angewiesen, einen Container zu starten, prüft das Hintergrundprogramm zunächst, ob das entsprechende Container-Image lokal vorliegt. Ist dies der Fall, wird der Container ausgeführt (durchgezogene Linie). Kann der Daemon das Image nicht finden, leitet dieser automatisch ein Pulling aus dem Repository ein.

Die Installation der Docker-Engine

Während Docker anfangs ausschließlich auf Linux-Distributionen zum Einsatz kam, zeichnet sich die aktuelle Version der Container-Engine durch eine weitgehende Plattformunabhängigkeit aus. Installationspakete finden sich für Microsoft Windows und macOS sowie für Cloud-Dienste wie Amazon Web Services (AWS)‎ und Microsoft Azure. Zu den unterstützten Linux-Distributionen gehören:

  • CentOS
  • Debian
  • Fedora
  • Oracle Linux
  • Red Hat Enterprise Linux
  • Ubuntu
  • openSUSE
  • SUSE Linux Enterprise

Zudem finden sich von Communitys gepflegte Docker-Distributionen für:

  • Arch Linux
  • CRUX Linux
  • Gentoo Linux

Im Folgenden veranschaulichen wir den Installationsprozess der Docker-Engine am Beispiel der beliebten Linux-Distribution Ubuntu. Ausführliche Installationshinweise zu den anderen Plattformen  finden sie in der englischsprachigen Docker-Dokumentation.

Je nachdem, welche Anforderungen und Voraussetzungen zu erfüllen sind, stehen ihnen drei unterschiedliche Wege offen, die Container-Plattform Docker auf Ihrem Ubuntu-System zu installieren:

  • Manuelle Installation via DEB-Paket
  • Installation aus dem Docker-Repository
  • Installation aus dem Ubuntu-Repository

Zuvor sollten Sie jedoch einen Blick in die Systemvoraussetzungen der Docker-Engine werfen.

Systemvoraussetzungen

Um die aktuelle Version von Docker auf Ihrer Ubuntu-Distribution zu installieren, benötigen Sie die 64-Bit-Variante einer der folgenden Ubuntu-Versionen:

  • Yakkety 16.10
  • Xenial 16.04 (LTS)
  • Trusty 14.04 (LTS)
Tipp

Auf Produktivsystemen empfehlen wir den Einsatz von Software-Produkten mit Langzeitunterstützung („Long-term support“, LTS). Diese werden vom Anbieter auch dann noch mit Updates versorgt, wenn bereits eine Nachfolgerversion auf dem Markt ist.

Vor der Docker-Installation

Das folgende Tutorial basiert auf der Ubuntu-Version Xenial 16.04 (LTS). Bei Yakkety 16.10 folgt der Installationsprozess denselben Schritten. Nutzern von Trusty 14.04 (LTS) wird vor der Docker-Installation die Installation der linux-image-extra-* packages empfohlen. Diese ermöglichen der Docker-Engine den Zugriff auf die AUFS-Speichertreiber.

Eine bequeme Methode, ein Linux-System mit Updates zu versorgen, bietet der integrierte Paket-Manager APT(Advanced Packaging Tool). Um die Zusatzpakete für Trusty 14.04 zu installieren, führen Sie folgende Schritte durch:

1. Terminal aufrufen: Starten Sie Ubuntu und öffnen Sie das Terminal – beispielsweise über die Tastenkombination [STRG] + [ALT] + [T].

2. Paketlisten aktualisieren: Geben Sie folgenden Befehl ein, um den lokalen Paket-Index Ihres Betriebssystems zu aktualisieren. Bestätigen Sie Ihre Eingabe mit der [ENTER]-Taste.

$ sudo apt-get update
Achtung

Der Befehl apt-get update installiert keinen neuen Pakete. Stattdessen werden lokal vorliegenden Paketbeschreibungen aktualisiert.

Der Zusatz sudo ermöglicht Ihnen, Befehle als Administrator (Superuser „root“) auszuführen. U. U. erfordert die Ausführung bestimmter Befehle Root-Rechte. In diesem Fall fordert Ubuntu Sie zur Eingabe des Administrator-Passworts auf. Alternativ haben Sie die Möglichkeit, via sudo -s dauerhaft in die Administrator-Rolle zu wechseln.

Tipp

Um die Container-Plattform Docker zu installieren, benötigen Sie Root-Rechte für das jeweilige Host-System.

Haben Sie sich per Passwort als Root-User ausgewiesen, startet Ubuntu den Update-Prozess. Der Status wird Ihnen im Terminal angezeigt.

3. Zusatzpakete installieren: Wurden alle Paketbeschreibungen aktualisiert, können Sie zur Installation neuer Pakete übergehen. Der Paket-Manager APT stellt dazu den Befehl apt-get install "PaketName" zur Verfügung. Um die empfohlenen Zusatzpakete für Trusty 14.04 aus dem Ubuntu-Repository zu laden und auf Ihrem System zu installieren, geben Sie folgenden Befehl ins Terminal ein und bestätigen Sie mit [ENTER].

$ sudo apt-get install -y --no-install-recommends \
    linux-image-extra-$(uname -r) \
    linux-image-extra-virtual
Tipp

Verwenden Sie Befehle mit der Option -y, werden alle interaktiven Fragen automatisch mit „Ja“ beantwortet. Die Option --no-install-recommends hindert Ubuntu daran, empfohlene Pakete automatisch zu installieren.

Nachdem die Zusatzpakete fürTrusty 14.04 heruntergeladen wurden, stehen Ihnen alle Funktionen der Docker-Plattform auch auf dieser Ubuntu-Version zur Verfügung.

Sie wissen nicht, um welche Ubuntu-Version es sich bei Ihrem System handelt? Oder Sie sind sich nicht sicher, ob Sie die für eine Docker-Installation benötigte 64-Bit-Architektur zur Verfügung stellen können? Kernel-Version und Systemarchitektur lassen sich im Ubuntu-Terminal mithilfe des folgenden Befehls ermitteln:

$ sudo uname -rm 

Die jeweilige Ubuntu-Version, den Release sowie den Spitznamen lassen Sie sich durch folgende Eingabe ausgeben:

$ sudo lsb_release –a

Manuelle Installation via DEB-Paket

Prinzipiell lässt sich Docker als DEB-Paket herunterladen und manuell installieren. Das benötigte Installations-Paket steht unter folgender URL zur Verfügung:

https://apt.dockerproject.org/repo/pool/main/d/docker-engine/

Laden Sie die DEB-Datei der gewünschten Ubuntu-Version herunter und starten Sie den Installationsprozess mit diesem Befehl über das Ubuntu-Terminal:

$ sudo dpkg -i /path/to/package.deb 
Tipp

Passen Sie den Platzhalter /path/to/ so an, dass der Dateipfad auf den Speicherort verweist, an dem Sie das DEB-Paket abgelegt haben.

Im Fall einer manuellen Installation müssen auch alle Software-Aktualisierungen manuell erfolgen. Die Docker-Dokumentation empfiehlt daher den Weg über das Docker-eigene Repository. Dieses ermöglicht es, die Container-Plattform bequem aus dem Ubuntu-Terminal heraus zu installieren und auf dem neuesten Stand zu halten.

Im Folgenden veranschaulichen wir die Docker-Installation gemäß der empfohlenen Vorgehensweise.

Installation aus dem Docker-Repository

Der empfohlene Weg zur eigenen Container-Plattform sieht die Installation aus dem Docker-Repository vor. Wir zeigen Ihnen, wie Sie Ihr System so konfigurieren, dass der Paket-Manager APT via HTTPS auf das Docker-Repository zugreifen kann.

1. Pakete installieren: Geben Sie folgenden Befehl ein, um die für den Zugriff auf das Docker-Repository benötigen Pakete zu installieren:

$ sudo apt-get install -y --no-install-recommends \
    apt-transport-https \
    ca-certificates \
    curl \
    software-properties-common

2. GPG-Schlüssel hinzufügen: Fügen Sie Dockers offiziellen GPG-Schlüssel hinzu.

$ curl -fsSL https://apt.dockerproject.org/gpg | sudo apt-key add -

3. GPG-Schlüssel verifizieren: Stellen Sie sicher, dass der GPG-Schlüssel mit folgender ID übereinstimmt: 5811 8E89 F3A9 1289 7C07 0ADB F762 2157 2C52 609D. Nutzen Sie dazu nachstehenden Befehl:

$ apt-key fingerprint 58118E89F3A912897C070ADBF76221572C52609D

Im Terminal erscheint die Ausgabe:

pub   4096R/2C52609D 2015-07-14
        Key fingerprint = 5811 8E89 F3A9 1289 7C07  0ADB F762 2157 2C52 609D
uid                  Docker Release Tool (releasedocker) <docker@docker.com>

4. Docker-Repository konfigurieren: Geben Sie folgenden Befehl ein, um den Zugriff auf das stabile Docker-Repository sicherzustellen:

$ sudo add-apt-repository \
       "deb https://apt.dockerproject.org/repo/ \
       ubuntu-$(lsb_release -cs) \
       main"

Ihr System ist nun vollständig für die Installation der Container-Plattform aus dem Docker-Repository vorkonfiguriert.

Tipp

Alternativ zum stabilen Repository können Sie auch Dockers Test-Repository nutzen. Rufen Sie dazu die Datei /etc/apt/sources.list auf und ersetzen Sie das Wort main durch testing. Auf Produktivsystemen ist ein Einsatz des Test-Repositorys nicht zu empfehlen.

5. Paket-Index aktualisieren: Bevor Sie mit der Installation der Docker-Engine fortfahren, empfiehlt es sich, den Paket-Index Ihres Betriebssystems abermals zu aktualisieren. Nutzen Sie dazu erneut den Befehl:

$ sudo apt-get update

6. Docker-Installation aus dem Repository: Um die Docker-Engine aus dem Docker-Repository zu laden und auf Ihrem Ubuntu-System zu installieren, stehen Ihnen zwei Möglichkeiten offen.Möchten Sie die aktuellste Version der Docker-Engine laden, verwenden Sie den Befehl:

$ sudo apt-get -y install docker-engine

Die Container-Plattform ist einsatzbereit, sobald der Installationsprozess abgeschlossen ist.

Der Docker-Daemon startet automatisch. Befand sich vor der Docker-Installation eine ältere Version der Container-Plattform auf Ihrem System, wurde diese durch die neu installierte Software ersetzt.

Alternativ zur aktuellsten Version kann auch eine beliebige ältere Version der Docker-Engine installiert werden. Sinnvoll ist dies beispielsweise bei einem Einsatz auf Produktivsystemen. Hier ziehen Anwender etablierte Releases mit guten Erfahrungswerten neueren Software-Versionen mitunter vor.

Eine Übersicht der verfügbaren Docker-Versionen für Ihr System erhalten Sie mit folgendem Befehl:

$ apt-cache madison docker-engine

Um eine spezielle Docker-Version zu installieren, ergänzen Sie den Installationsbefehl lediglich um den jeweiligen Versions-String (z. B. 1.12.5-0), indem Sie diesen durch ein Gleichheitszeichen abgetrennt an den Paketnamen (in diesem Fall docker-engine) anhängen.

$ sudo apt-get -y install docker-engine=<VERSION_STRING>

Installation aus dem Ubuntu-Repository

Nutzer, die nicht auf das Docker-Repository zurückgreifen möchten, haben zudem die Möglichkeit, die Container-Plattform aus dem betriebssystemeigenen Repository zu laden.

Nutzen Sie folgenden Kommandozeilenbefehl, um ein von der Ubuntu-Community bereitgestelltes Docker-Paket zu installieren:

$ sudo apt-get install -y docker.io
Tipp

Das Installationspaket der Container-Plattform „docker.io“ sollte nicht mit dem Paket „docker“, einem System-Tray für KDE3/GNOME2-Docklet-Applications verwechselt werden.

Testlauf

Nachdem Sie den Installationsprozess erfolgreich abgeschlossen haben, sollten Sie sicherstellen, dass die Container-Plattform einwandfrei funktioniert. Das Entwicklerteam stellt dazu einen einfachen hello-world-Container zur Verfügung. Überprüfen Sie Ihre Docker-Installation, indem Sie folgenden Befehl in das Ubuntu-Terminal eingeben und mit [ENTER] bestätigen:

$ sudo docker run hello-world 
Achtung

Der Docker-Daemon ist an einen Unix-Socket (sprich an einen vom Betriebssystem bereitgestellten Kommunikationsendpunkt) gebunden, der in der Standardeinstellung dem Root-User zugeschrieben ist. Andere Benutzer können Docker-Befehle daher nur mithilfe des Zusatzes sudo verwenden. Dies lässt sich ändern, indem Sie eine Unix-Gruppe mit dem Namen docker erstellen und die gewünschten Benutzer hinzufügen. Weitere Informationen dazu finden Sie in der Dokumentation des Docker-Projekts.

Der Befehl docker run weist den Docker-Daemon an, einen Container mit dem Namen hello-world zu suchen und zu starten. Ist Ihre Docker-Installation fehlerfrei konfiguriert, sollten Sie eine Ausgabe erhalten, die der auf dem nachstehenden Screeenshot entspricht.

Zu deuten ist diese Terminal-Ausgabe folgendermaßen: Um den Befehl docker run hello-world auszuführen, durchsucht der Docker-Daemon zunächst die lokalen Dateien Ihres System nach dem entsprechenden Container-Image. Da Sie den Container hello-world zum ersten Mal ausführen, bleibt die Suche des Daemons erfolglos. Sie erhalten die Mitteilung „Unable to find image“(„Das Image konnte nicht gefunden werden“).

$ sudo docker run hello-world
[sudo] password for osboxes:
Unable to find image 'hello-world:latest' locally

Kann Docker ein gewünschtes Image auf dem lokalen System nicht finden, leitet der Daemon einen Download-Prozess (Pulling) aus dem Docker Repository ein.

latest: Pulling from library/hello-world
78445dd45222: Pull complete
Digest: sha256:c5515758d4c5e1e838e9cd307f6c6a0d620b5e07e6f927b07d05f6d12a1ac8d7
Status: Downloaded newer image for hello-world:latest

Nach erfolgreichem Download erhalten Sie die Mitteilung: „Downloaded newer image for hello-world:latest“ („Neues Image für hello-world:latest heruntergeladen“). Anschließend wird der Container gestartet. Dieser beinhaltet ein einfaches hello-world-Script mit folgender Botschaft der Entwickler:

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
 3. The Docker daemon created a new container from that image which runs the executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://cloud.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/engine/userguide/

Für Sie bedeutet dieser Text: Ihre Docker-Installation funktioniert einwandfrei.

Docker deinstallieren

Genauso bequem, wie Sie die Docker-Engine über das Terminal installieren, lässt sich die Container-Plattform auf diesem Weg auch wieder deinstallieren. Möchten Sie das Docker-Paket von Ihrem System entfernen, geben Sie folgenden Befehl ins Ubuntu-Terminal ein und bestätigen Sie mit [ENTER]:

 $ sudo apt-get purge docker-engine

Nachdem die für die Deinstallation benötigten Informationen eingelesen wurden, werden Sie aufgefordert, den Befehl erneut zu bestätigen.

Um fortzufahren, geben Sie „Y“ (Yes) ein und bestätigen Sie mit [ENTER]. Wählen Sie „n“, um die Deinstallation abzubrechen.

Images und Container werden bei der Deinstallation der Docker-Engine nicht automatisch entfernt. Löschen Sie diese mithilfe dieses Befehls:

$ sudo rm -rf /var/lib/docker

Wurden zusätzliche Konfigurations-Dateien installiert, müssen diese manuell entfernt werden.

Arbeiten mit Docker

Sie haben sichergestellt, dass Ihre Docker-Engine vollständig installiert ist und fehlerfrei läuft? Dann wird es Zeit, sich mit den Anwendungsmöglichkeiten der Container-Plattform vertraut zu machen. Lernen sie im Folgenden, wie Sie die Docker-Engine über das Terminal steuern, welche Möglichkeiten Ihnen das Docker-Hub bietet und warum Docker-Container den Umgang mit Anwendungen revolutionieren könnten.

So steuern Sie die Docker-Engine

Ab Version 16.04 nutzt Ubuntu das Hintergrundprogramm systemd(kurz für „System-Daemon“), um Prozesse zu managen. Bei systemd handelt es sich um einen init-Prozess, der auch bei anderen Linux-Distributionen wie RHEL, CentOS oder Fedora zum Einsatz kommt. In der Regel erhält systemd die Prozess-ID 1. Als erster Prozess des Systems ist der Daemondafür verantwortlich, alle folgenden Prozesse zu starten, zu überwachen und zu beenden. Bei früheren Ubuntu-Versionen (14.10 und älter) übernimmt das Hintergrundprogramm upstart diese Funktion.

Auch der Docker-Daemon lässt sich via systemd steuern. In der Standardinstallation ist die Container-Plattform so konfiguriert, dass der Daemon automatisch mit dem System-Boot startet. Diese Voreinstellung lässt sich über das Kommandozeilenwerkzeug systemctl individuell anpassen.

Mit systemctl senden Sie Befehle an systemd, um einen Prozess zu steuern oder dessen Status abzufragen. Die Syntax eines solchen Befehls entspricht folgendem Schema:

systemctl [OPTION] [BEFEHL]

Einige Befehle beziehen sich auf bestimmte Ressourcen (beispielsweise Docker). In der Terminologie von systemd werden diese als Units (Einheiten) bezeichnet. In diesem Fall ergibt sich der Befehl aus der jeweiligen Anweisung und dem Namen der Unit, die angesprochen werden soll.

Möchten Sie den Autostart des Docker-Daemons aktivieren (enable) bzw. deaktivieren (disable), nutzen Sie das Kommandozeilenwerkzeug systemctl mit folgenden Befehlen:

$ sudo systemctl enable docker
$ sudo systemctl disable docker

Das Kommandozeilenwerkzeug systemctl erlaubt Ihnen zudem, den Status einer Unit abzufragen:

$ sudo systemctl status docker

Ist die Docker-Engine auf Ihrem Ubuntu-System aktiv, sollte die Ausgabe im Terminal der auf folgendem Screenshot entsprechen:

Ist Ihre Docker-Engine zum aktuellen Zeitpunkt deaktiviert, erhalten Sie die Statusangabe inactive (dead). Starten Sie den Docker-Daemon in diesem Fall manuell, um Container auszuführen.

Möchten Sie Ihre Docker-Engine manuell starten, stoppen oder neustarten, sprechen Sie systemd miteinem der folgenden Befehle an.

Um den deaktivierten Daemon zu starten, verwenden Sie systemctl in Kombination mit dem Befehl start:

$ sudo systemctl start docker

Soll der Docker-Daemon beendet werden, kommt stattdessen der Befehl stop zum Einsatz:

$ sudo systemctl stop docker

Einen Neustart der Engine veranlassen Sie mit dem Befehl restart:

$ sudo systemctl restart docker

So nutzen Sie das Docker-Hub

Wenn die Docker-Engine das Herzstück der Container-Plattform darstellt, dann ist das Docker-Hub die Seele des Open-Source-Projekts. Hier trifft sich die Community. Anwender finden in der cloudbasierten Registry alles, was sie benötigen, um ihrer Docker-Installation Leben einzuhauchen.

Der Onlinedienst bietet diverse offizielle Repositorys mit mehr als 100.000 kostenlosen Apps. Anwender haben die Möglichkeit, eigene Image-Archive zu erstellen und diese gemeinsam mit Arbeitsgruppen zu nutzen. Neben dem professionellen Support durch das Entwicklerteam finden Einsteiger hier Anschluss an die Nutzergemeinde. Ein Forum für den Community-Support steht über GitHub zur Verfügung.

Anmeldung im Docker-Hub

Die Anmeldung im Docker-Hub ist kostenlos. Nutzer benötigen lediglich eine E-Mail-Adresse sowie die selbst gewählte Docker-ID. Diese fungiert später als persönlicher Repository-Namespace und gewährt Nutzern Zugang zu allen Docker-Diensten. Derzeit umfasst das Angebot neben dem Docker-Hub die Docker-Cloud, den Docker-Store und ausgewählte Beta-Programme. Darüber hinaus ermöglicht die Docker-ID einen Log-in in das Docker-Support-Center sowie in das Docker-Success-Portal und die Docker-Foren.

Der Anmeldeprozess erfolgt in fünf Schritten:

1. Docker-ID wählen: Im Rahmen der Anmeldung wählen Sie einen Benutzernamen, der später als Ihre persönliche Docker-ID fungiert. Ihr Benutzername für das Docker-Hub und alle andere Docker-Dienste muss 4 bis 30 Zeichen umfassen und darf lediglich aus Ziffern und Kleinbuchstaben bestehen.

2. E-Mail-Adresse angeben: Geben Sie Ihre aktuelle E-Mail-Adresse an. Beachten Sie, dass Sie die Anmeldungen für das Docker-Hub via E-Mail bestätigen müssen.

3. Passwort wählen: Wahlen Sie ein geheimes Passwort mit 6 bis 128 Zeichen.

4. Anmeldung absenden: Klicken Sie auf „Sign up“, um Ihre Registrierung einzureichen. Wurden die Daten vollständig übermittelt, sendet Docker einen Link zur Verifizierung Ihrer E-Mail-Adresse an das von Ihnen angegebene Postfach.

5. E-Mail-Adresse bestätigen: Bestätigen Sie Ihre E-Mail-Adresse durch einen Klick auf den Verifizierungslink.

Die Onlinedienste des Docker-Projekts stehen Ihnen unmittelbar nach der Registrierung über den Browser zur Verfügung.Hier erstellen Sie Repositorys und Arbeitsgruppen oder durchsuchen das Docker-Hub via „Explore“ nach öffentlichen Ressourcen.

Alternativ können Sie sich via docker login direkt über das Terminal Ihres Betriebssystems anmelden. Eine detaillierte Beschreibung des Befehls finden Sie in der Docker-Dokumentation.

Prinzipiell steht das Docker-Hub Nutzern auch ohne Account und Docker-ID zur Verfügung. In diesem Fall lassen sich jedoch ausschließlich Images aus öffentlichen Repositorys laden. Ein Upload (push) eigener Images ist ohne Docker-ID nicht möglich.

Repositorys im Docker-Hub erstellen

Der kostenlose Docker-Hub-Account umfasst ein privates Repository und bietet Ihnen die Möglichkeit, beliebig viele öffentliche Repositorys zu erstellen. Sollten Sie weitere private Repositorys benötigen, können Sie diese mit einem kostenpflichtigen Upgrade freischalten.

Um ein Repository anzulegen, gehen Sie folgendermaßen vor:

1. Namespace wählen: Neu erstellte Repositorys werden automatisch dem Namespace Ihrer Docker-ID zugeordnet. Alternativ haben Sie die Möglichkeit, die ID einer Organisation anzugeben, der Sie angehören.

2. Repository benennen: Geben Sie einen Namen für das neu erstellte Repository an.

3. Beschreibung hinzufügen: Fügen Sie eine Kurzbeschreibung sowie eine ausführliche Gebrauchsanweisung hinzu.

4. Sichtbarkeit einstellen: Entscheiden Sie, ob das Repository öffentlich sichtbar (public) oder nur Ihnen oder Ihrer Organisation zugänglich (private) sein soll.

Bestätigen Sie Ihre Angaben mit einem Klick auf „Create“.

Teams & Organisationen erstellen

Mit dem Hub bietet Docker Ihnen eine cloudbasierte Plattform, auf der Sie selbsterstellte Images zentral verwalten und bequem mit Arbeitsgruppen teilen. In der Docker-Terminologie werden diese Organisationen genannt. Genau wie Nutzer-Accounts erhalten Organisationen individuelle IDs, über die sich Images bereitstellen und herunterladen lassen. Rechte und Rollen innerhalb einer Organisation lassen sich über Teams zuordnen. So haben beispielsweise nur Nutzer, die dem Team „Owners“ zugeordnet wurden, die Berechtigung, private oder öffentliche Repositorys anzulegen und Zugriffsrechte zu vergeben.

Auch Arbeitsgruppen erstellen und verwalten Sie direkt über das Dashboard. Weitere Informationen zum Umgang mit Organisationen und Teams finden Sie in der Docker-Dokumentation.

So arbeiten Sie mit Images und Containern

Als erste Anlaufstelle für offizielle Docker-Ressourcen stellt das Docker-Hub den Ausgangspunkt unserer Einführung in den Umgang mit Images und Containern dar. Das Entwicklungsteam stellt hier u. a. das Demo-Image whalesay zur Verfügung, das als Grundlage für das nachfolgende Docker-Tutorial dienen soll.

Docker-Images herunterladen

Das whalesay-Image finden Sie, indem Sie die Startseite des Docker-Hubs aufrufen und den Begriff whalesay in die Suchleiste rechts neben dem Docker-Logo eingeben.

Klicken Sie in den Suchergebnissen auf die Ressource mit der Bezeichnung docker/whalesay, um das öffentliche Repository für dieses Image aufzurufen.

Docker-Repositorys sind immer nach demselben Muster aufgebaut: Im Kopfbereich der Seite finden Nutzer die Bezeichnung des Images, die Kategorie des Repositorys sowie den Zeitpunkt des letzten Uploads (lastpushed).

Darüber hinaus bietet jedes Docker-Repository folgende Info-Boxen:

  • Short Description: Kurzbeschreibung der Ressource
  • Full Description: ausführliche Beschreibung, in der Regel inklusive Gebrauchsanweisung
  • Docker Pull Command: Kommandozeilenbefehl, um das Image aus dem Repository herunterzuladen (pull)
  • Owner: Information über den Ersteller des Repositorys
  • Comments: Kommentarbereich am Seitenende

Den Informationsboxen des Repositorys lässt sich entnehmen, dass es sich bei whalesay um eine Modifikation des quelloffenen Perl-Skripts cowsay handelt. Das von Tony Monroe im Jahr 1999 entwickelte Programm generiert in seiner Ursprungsform eine ASCII-Grafik in Form einer Kuh, die zusammen mit einer Nachricht im Terminal des Benutzers erscheint.

Um docker/whalesay herunterzuladen, benutzen Sie den Befehl docker pull nach folgendem Grundschema:

$ docker pull [OPTIONS] NAME [:TAG|@DIGEST]

Der Befehl docker pull weist den Daemon an, ein Image aus dem Repository zu laden. Um welches Image es sich handelt, bestimmen Sie durch die Angabe der Image-Bezeichnung (NAME). Darüber hinaus können Sie Docker anweisen, wie der gewünschte Befehl ausgeführt werden soll (OPTIONS). Ebenfalls optional ist die Angabe von Tags (:TAG) und eindeutigen Identifikationsnummern (@DIGEST), die es ermöglichen, eine bestimmte Version eines Images herunterzuladen.

Eine lokale Kopie des docker/whalesay-Images erhalten Sie somit durch folgenden Befehl:

$ docker pull docker/whalesay

In der Regel können Sie diesen Schritt jedoch überspringen. Möchten Sie einen Container starten, lädt der Docker-Daemon Images, die er auf dem lokalen System nicht finden kann, automatisch aus dem Repository herunter.

Docker-Images als Container starten

Um ein Docker-Image zu starten, nutzen Sie den Befehl docker run nach folgendem Grundschema:

$ docker run [OPTIONS] IMAGE [:TAG|@DIGEST] [CMD] [ARG...]

Einziger obligatorischer Bestandteil des Befehls docker run ist die Bezeichnung des gewünschten Docker-Images. Auch wenn Sie Container starten, haben Sie die Möglichkeit, fakultative Optionen, TAGs und DIGESTs zu definieren. Darüber hinaus lässt sich der Befehl docker run mit weiteren Befehlen kombinieren, die ausgeführt werden, sobald der Container startet. In diesem Fall wird der vom Image-Ersteller definierte CMD (COMMAND, ein Befehl, der beim Starten des Containers automatisch ausgeführt wird) überschrieben. Weitere optionale Konfigurationen lassen sich durch zusätzliche Argumente (ARG…) definieren. Diese ermöglichen es beispielweise, Benutzer hinzuzufügen oder Umgebungsvariablen (Environment-Variables) zu übergeben.

Nutzen Sie den Kommandozeilenbefehl

$ docker run docker/whalesay cowsay boo 

um das als Image vorliegende Perl-Skript herunterzuladen und in einem Container auszuführen. Sie werden sehen, dass sich whalesay in einem wesentlichen Punkt vom Ursprungsskript unterscheidet.

Wird das Image docker/whalesay ausgeführt, gibt das Skript eine ASCII-Grafik in Form eines Wals sowie die mit dem cowsay-Befehl übergebene Textnachricht „boo“ im Terminal aus.

Wie beim Testlauf sucht der Daemon das gewünschte Image zunächst im lokalen Dateiverzeichnis. Da sich hier kein gleichnamiges Paket findet, wird ein Pulling aus dem Docker-Repository eingeleitet. Anschließend startet der Daemon das modifizierte Cowsay-Programm. Ist dieses durchgelaufen, wird der Container automatisch beendet.

Wie cowsay bietet Ihnen auch Dockers whalesay die Möglichkeit, in den Programmablauf einzugreifen, um die Textausgabe im Terminal zu beeinflussen. Testen Sie diese Funktion, indem Sie das „boo“ im Ausgangsbefehl durch eine beliebige Zeichenfolge ersetzen – z. B. durch einen lahmen Wal-Witz.

$ sudo docker run docker/whalesay cowsay What did the shark say to the whale? What are you blubbering about?

Alle Docker-Images auf dem lokalen System anzeigen

Sind Sie sich nicht sicher, ob Sie ein bestimmtes Image bereits heruntergeladen haben, können Sie eine Übersicht aller Images auf Ihrem lokalen System aufrufen. Nutzen sie dazu folgenden Kommandozeilenbefehl:

$ sudo docker image 

Der Befehl docker image gibt Ihnen alle lokalen Images inklusive Dateigröße, Tag und Image-ID aus.

Starten Sie einen Container, wird das zugrundeliegende Image als Kopie aus dem Repository heruntergeladen und dauerhaft auf Ihrem Computer gespeichert. So sparen Sie Zeit, falls Sie zu einem späteren Zeitpunkt erneut auf das betreffende Image zugreifen möchten. Ein erneuter Download wird nur dann eingeleitet, wenn sich die Image-Quelle verändert – beispielsweise, wenn im Repository eine aktuellere Version zur Verfügung steht.

Alle Container auf dem lokalen System anzeigen

Möchten Sie sich eine Übersicht aller Container ausgeben lassen, die auf Ihrem System ausgeführt werden oder in der Vergangenheit ausgeführt wurden, nutzen Sie den Kommandozeilenbefehl docker psin Kombination mit der Option --all (kurz: -a):

$ sudo docker ps -a

Die Terminalausgabe umfasst Informationen wie die jeweilige Container-ID, das zugrundeliegende Image, den Befehl, der beim Starten des Containers ausgeführt wurde, den Zeitpunkt, an dem der jeweilige Container gestartet wurde, sowie den aktuellen Status.

Möchten Sie lediglich die Container anzeigen, die aktuell auf Ihrem System ausgeführt werden, nutzen Sie den Kommandozeilenbefehl docker ps ohne weitere Option:

$ sudo docker ps

Derzeit sollten sich auf Ihrem System jedoch keine laufenden Container befinden.

Docker-Images erstellen

Sie wissen nun, wie man Images im Docker-Hub findet, diese herunterlädt und auf jedem beliebigen System ausführt, auf dem die Docker-Engine installiert wurde. Mit Docker steht Ihnen jedoch nicht nur das umfangreiche App-Angebot der Registry zur Verfügung. Die Plattform bietet Ihnen darüber hinaus weitreichende Möglichkeiten, eigene Images zu erstellen und diese mit anderen Entwicklern zu teilen.

Bereits in den einleitenden Kapiteln dieses Tutorials haben Sie erfahren, dass jedes Docker-Image auf einem sogenannten Dockerfilebasiert. Dockerfiles können Sie sich als eine Art Bauanleitung für Images vorstellen. Es handelt sich um einfache Textdateien, die alle Anweisungen enthalten, die Docker benötigt, um ein Image zu erstellen. Lernen Sie in den folgenden Schritten, wie Sie ein solches Dockerfile schreiben und Docker anweisen, dieses als Grundlage für ein eigenes Image zu verwenden.

1. Neues Verzeichnis anlegen: Das Docker-Entwicklerteam empfiehlt, für jedes Dockerfile ein eigenes Verzeichnis anzulegen. Verzeichnisse erstellen Sie unter Linux bequem über das Terminal. Verwenden Sie folgenden Kommandozeilenbefehl, um ein Verzeichnis mit dem Namen mydockerbuild zu erstellen:

$ mkdir mydockerbuild

2. In das neue Verzeichnis navigieren: Nutzen Sie den Befehl cd, um in das neu erstellte Arbeitsverzeichnis zu navigieren.

$ cd mydockerbuild

3. Neue Textdatei erstellen: Auch Textdateien erstellen Sie unter Ubuntu bequem über das Terminal. Verwenden Sie dazu einen Editor wie Nano oder Vim. Erstellen Sie im Verzeichnis mydockerbuild eine Textdatei mit dem Namen Dockerfile.

$ nano Dockerfile

4. Dockerfile schreiben: Die neu erstellte Textdatei dient als Bauplan für Ihr selbst entwickeltes Image.Statt das Image von Grund auf neu zu programmieren, nutzen wir in diesem Docker-Tutorial das Demo-Image docker/whalesay als Vorlage. Dieses binden Sie über den Befehl FROM in Ihr Dockerfile ein. Verwenden Sie das Tag :latest,um auf die neueste Version des Images zu verweisen.

FROM docker/whalesay:latest

Bisher arbeitet docker/whalesay so, dass Sie dem Wal die Worte in den Mund legen müssen. Im Terminal erscheint genau der Text, den Sie zuvor in Kombination mit dem Befehl zum Starten des Containers eingegeben haben. Interessanter wäre es jedoch, wenn das Skript automatisch immer wieder neue Textausgaben generieren würde. Umsetzen lässt sich dies beispielsweise mithilfe des Programms fortunes, das auf jedem Linux-System zur Verfügung steht. Die Grundfunktion von Fortunes besteht darin, Glückskeks-Sprüche und humorvolle Aphorismen zu generieren. Nutzen Sie folgenden Befehl, um Ihren lokalen Paket-Index zu aktualisieren und fortunes zu installieren:

RUN apt-get -y update && apt-get install -y fortunes

Anschließend definieren Sie ein CMD-Statement. Dieses wird nach dem Befehl RUN ausgeführt, sofern es beim Aufruf (docker run image CMD) nicht überschrieben wurde. Verwenden Sie

CMD /usr/games/fortune -a | cowsay

um das Programm fortunes mit der Option -a („Wähle aus allen Datenbanken“) auszuführen und die Ausgabe über das Programm cowsay im Terminal anzeigen zu lassen.

Ihr Dockerfile sollte nun folgendermaßen aussehen:

FROM docker/whalesay:latest
RUN apt-get -y update && apt-get install -y fortunes
CMD /usr/games/fortune -a | cowsay

Beachten Sie: Befehle innerhalb eines Dockerfiles sind immer einzeilig und beginnen stets mit einem Schlüsselwort. Die zugrundeliegende Syntax ist case-insensitive – es ist also egal, ob Sie groß- oder kleinschreiben. Es hat sich jedoch eine konsequente Großschreibung von Schlüsselwörtern etabliert.

5. Textdatei speichern: Speichern Sie Ihre Eingabe. Sollten Sie den Editor Nano verwenden, nutzen Sie dazu die Tastenkombination [STRG] + [O] und bestätigen Sie mit [ENTER]. Nano gibt Ihnen die Meldung aus, dass drei Zeilen in die ausgewählte Datei geschrieben wurden. Beenden Sie den Texteditor mit der Tastenkombination [STRG] + [X].

6. Image aus Dockerfile erstellen: Um ein Image aus einem Dockerfile zu erstellen, navigieren Sie zunächst in das Verzeichnis, in dem Sie die Textdatei abgelegt haben. Die Image-Erstellung starten Sie mit dem Kommandozeilenbefehl docker build. Möchten Sie das Image individuell benennen oder mit einem Tag versehen, verwenden Sie die Option-t sowie nachfolgend die gewünschte Kombination aus Bezeichnung und Tag. Es gilt das Standardformat name:tag.

Im aktuellen Beispiel soll ein Image mit dem Namen docker-whale erzeugt werden:

$ docker build -t docker-whale .

Der abschließende Punkt gibt an, dass sich das zugrundeliegende Dockerfile im ausgewählten Verzeichnis befindet. Alternativ haben Sie die Möglichkeit, einen Dateipfad oder eine URL zu den Quelldateien anzugeben.

Der build-Prozess startet, sobald Sie den Befehl mit [ENTER] bestätigt haben. Zunächst überprüft der Docker-Daemon, ob ihm alle Dateien vorliegen, die für die Erstellung des Images benötigt werden. In der Docker-Terminologie werden diese unter dem Begriff „Context“ zusammengefasst. Im Terminal erscheint folgende Statusmeldung:

Sending build context to Docker daemon 2.048 kB 

Im Anschluss wird das Image docker/whalesay mit dem Tag :latest lokalisiert:

Step 1/3 : FROM docker/whalesay:latest
   ---> 6b362a9f73eb

Liegt der für die Image-Erstellung benötigte Context vollständig vor, startet der Docker-Daemon die via FROM eingebundene Image-Vorlage in einem temporären Container und geht zum nächsten Befehl im Dockerfile über. Im aktuellen Beispiel handelt es sich dabei um den RUN-Befehl, der die Installation des fortunes-Programms zur Folge hat.

Step 2 : RUN apt-get -y update && apt-get install -y fortunes
   ---> Running in 80b81eda1a11
…etc. 

Am Ende jedes Schritts im Rahmen der Image-Erstellung gibt Docker Ihnen eine ID für den entsprechenden Layer (Schicht) aus, der in diesem Schritt erstellt wurde. Dabei gilt: Jede Zeile im zugrundeliegenden Dockerfile entspricht einem Layer des darauf aufbauenden Images.

Wurde der RUN-Befehl beendet, stoppt der Docker-Daemon den dafür erstellten Container, entfernt diesen und startet einen neuen temporären Container für das Layer des CMS-Statements.

Step 3/3 : CMD /usr/games/fortune -a | cowsay
 ---> Running in c3ac46675e7a
 ---> 4419af61d32d
Removing intermediate container c3ac46675e7a

Am Ende des Erstellungsprozesses wird auch der in Schritt 3 erstellte temporäre Container beendet und entfernt. Docker gibt Ihnen die ID des neuen Images aus:

Successfully built 4419af61d32d

Ihr neu erstelltes Image finden Sie unter dem Namen docker-whale in der Übersicht ihrer lokal gespeicherten Images.

$ sudo docker images

Um einen Container aus Ihrem neu erstellten Image zu starten, verwenden Sie den Kommandozeilenbefehl sudo docker run in Kombination mit dem Namen des Images:

$ sudo docker run docker-whale 

Wurde das Image fehlerfrei aus dem Dockerfile erstellt, sollte Ihr Wal Sie nun mit mehr oder weniger weisen Sprüchen begeistern. Beachten Sie: Jedes Mal, wenn Sie den Container neu starten, wird ein anderer Spruch generiert.

Docker-Images taggen und ins Docker-Hub hochladen

Möchten Sie Ihr selbsterstelltes Image docker-whale ins Hub laden, um es dort der Community oder einer Arbeitsgruppe zur Verfügung zu stellen, müssen Sie es zunächst mit einem gleichnamigen Repository in Ihrem persönlichen Namespace verknüpfen. In der Docker-Terminologie wird dieser Schritt Tagging genannt.

Um ein Image über das Docker-Hub zu veröffentlichen, gehen Sie folgendermaßen vor:

1. Repository erstellen: Loggen Sie sich mit Ihrer Docker-ID und dem persönlichen Passwort im Docker-Hub ein und erstellen Sie ein öffentliches Repository mit dem Namen docker-whale.

2. Image-ID ermitteln: Ermitteln Sie die ID Ihres selbsterstellten Images docker-whale mithilfe des Kommandozeilenbefehls docker images.

$ sudo docker images
REPOSITORY      TAG     IMAGE ID       CREATED        SIZE
docker-whale    latest  4419af61d32d   22 hours ago   275 MB
hello-world     latest  48b5124b2768   6 weeks ago    1.84 kB
docker/whalesay latest  6b362a9f73eb   21 months ago  247 MB

In unserem Fall lautet die Image-ID 4419af61d32d. Diese benötigen wir für das Tagging im nächsten Schritt.

3. Image taggen: Taggen Sie das Image docker-whale mithilfe des Kommandozeilenbefehls docker tag nach folgendem Schema:

$ sudo docker tag [Image-ID][Docker-ID]/[Image-Name]:[TAG]

Auf das aktuelle Beispiel bezogen lautet der Kommandozeilenbefehl für das Tagging somit:

$ sudo docker tag 4419af61d32d myfreedockerid/docker-whale:latest

Ob Ihr Image korrekt getaggt wurde, überprüfen Sie in der Übersicht via docker images. Der Name des Repositorys sollte nun Ihre Docker-ID beinhalten.

4. Image hochladen: Um das Image hochzuladen, müssen Sie sich zunächst im Docker-Hub anmelden. Dies erfolgt über den Kommandozeilenbefehl docker login.  

$ sudo docker login

Das Terminal fordert Sie auf, Ihren Benutzernahmen (die Docker-ID) sowie ihr Passwort einzugeben.

War die Anmeldung erfolgreich, verwenden Sie den Kommandozeilenbefehl docker push, um Ihr Image in das neu erstellte Repository hochzuladen.

$ sudo docker push myfreedockerid/docker-whale

Der Upload-Prozess sollte lediglich einige Sekunden in Anspruch nehmen. Der aktuelle Status wird Ihnen über das Terminal ausgegeben.

Melden Sie sich über den Browser im Docker-Hub an, um sich das hochgeladene Image anzeigen zu lassen.

Möchten Sie mehr als ein Image pro Repository hochladen, verwenden Sie verschiedene Tags, um Ihre Images in unterschiedlichen Versionen anzubieten. Beispielsweise:

myfreedockerid/docker-whale:latest
myfreedockerid/docker-whale:version1
myfreedockerid/docker-whale:version

Eine Übersicht verschiedener Image-Versionen lässt sich in Docker-Hub-Repositorys über den Reiter „Tags“ abrufen.

Images verschiedener Projekte hingegen sollten in separaten Repositorys angeboten werden.

 War der Upload erfolgreich, steht Ihr selbsterstelltes Image nun jedem Docker-Nutzer weltweit über das öffentliche Repository zur Verfügung.

 5. Testlauf: Testen Sie den Erfolg des Uploads, indem Sie das soeben hochgeladene Image herunterladen.

 Beachten Sie, dass Sie die lokale Version des Images zunächst löschen müssen, um eine neue Kopie mit demselben Tag herunterzuladen. Andernfalls meldet Docker, dass das gewünschte Image bereits in der aktuellen Version vorliegt.

Um lokale Docker-Images zu löschen, nutzen Sie den Kommandozeilenbefehl docker rmi in Kombination mit der entsprechenden Image-ID. Diese ermitteln Sie wie gehabt via docker images. Meldet Docker Konflikte – z. B. weil eine Image-ID in mehreren Repositorys oder von einem Container verwendet wird –, bekräftigen Sie Ihren Befehl mit der Option --force (Kurz: -f), um den Löschvorgang zu erzwingen.

sudo docker rmi -f 4419af61d32d

Lassen Sie sich erneut eine Übersicht aller lokalen Images anzeigen:

$ sudo docker Images

Die gelöschten Elemente sollten in der Terminal-Ausgabe nicht mehr auftauchen. Nutzen Sie nun den im Repository angegebenen Pull-Befehl, um eine neue Kopie des Images aus dem Docker-Hub herunterzuladen:

$ sudo docker pull myfreedockerid/docker-whale

vServer (VPS) von IONOS

Günstige und starke VPS für Webserver, Mailserver und eigene Anwendungen mit persönlichem Berater und 24/7 Support. Bereits ab 5€/Monat! inkl.Performance-Upgrade 2019!

100 % SSD-Speicher
Bereit in 55 Sek.
SSL Zertifikat

Vom Einsteiger zum Docker-Profi

In unserem Docker-Tutorial haben wir gezeigt, dass sich die schlanke Container-Plattform in wesentlichen Punkten von der klassischen Hardware-Virtualisierung unterscheidet. Docker setzt auf Software-Container und umgeht so den Overhead eines virtuellen Gastbetriebssystems. Container teilen sich den Kernel eines gemeinsamen Hosts und erzeugen als isolierte Prozesse im User-Space alles, was für die Laufzeit von Anwendungen benötigt wird. Das Ergebnis ist ein Maximum an Portabilität. Mit Docker lässt sich ein und derselbe Software-Container plattformübergreifend auf diversen Systemen und Infrastrukturen ausführen. Voraussetzung ist lediglich eine lokale Installation der Docker-Engine sowie ein Zugang zum cloudbasierten Docker-Hub.

Wie schnell sich mit Docker eine voll funktionsfähige Container-Plattform realisieren lässt, haben wir am Beispiel der beliebten Linux-Distribution Ubuntu demonstriert. Sie haben gelernt, wie Sie Docker unter Ubuntu installieren und einrichten, wie Sie Anwendungen als Images aus dem Docker-Hub herunterladen und lokal in Containern ausführen. Sie haben ein Dockerfile selbst geschrieben, daraus Ihr eigenes Image erstellt und dieses über den Cloud-Service anderen Docker-Nutzern zur Verfügung gestellt. Kurzum: Sie sind nun mit den Grundlagen der Container-Plattform vertraut.

Doch das Docker-Universum ist groß. Im Laufe der Zeit hat sich um das prominente Open-Source-Projekt ein lebendiges Ökosystem entwickelt. Zudem drängen zahlreiche Konkurrenten mit alternativen Software-Produkten auf den Markt. Interessant wird Docker für Administratoren vor allem dann, wenn komplexe Anwendungen mit mehreren Containern parallel auf verschiedenen Systemen betrieben werden. Docker bietet dazu diverse Funktionen zur Orchestrierung eines solches Clusters. Näheres dazu finden Sie in unserm weiterführenden Artikel zu den Docker-Tools Swarm und Compose.


Auf dem Laufenden bleiben?

Jetzt für unseren Newsletter anmelden und gratis Online-Marketing Whitepaper für lokale Anbieter sichern!