NGINX und NGINX Plus mit Docker bereitstellen

NGINX | 09. November 2021

Rick NelsonRegional Vice President, Solution Engineering

Redaktion – Die NGINX Plus-Dockerfiles für Alpine Linux und Debian wurden im November 2021 aktualisiert, um die neuesten Softwareversionen zu berücksichtigen. Außerdem verwenden sie (zusammen mit den überarbeiteten Anweisungen) Docker-Secrets, um beim Erstellen eines NGINX Plus-Images Lizenzinformationen zu übermitteln.

Docker ist eine offene Plattform zum Erstellen, Bereitstellen und Ausführen verteilter Anwendungen in Form von Containern (leichtgewichtigen, eigenständigen, ausführbaren Softwarepaketen, die alles enthalten, was zum Ausführen einer Anwendung erforderlich ist). Container können wiederum mithilfe von Container-Orchestrierungsplattformen wie Kubernetes bereitgestellt und orchestriert werden. (Neben der in diesem Blog behandelten Docker-Container-Technologie bietet NGINX den F5 NGINX Ingress Controller in Versionen auf Basis von NGINX Open Source und NGINX Plus an; für Abonnenten von NGINX Plus ist der Support ohne zusätzliche Kosten enthalten.)

Als Softwareanwendungen eignen sich NGINX Open Source und F5 NGINX Plus hervorragend für den Einsatz mit Docker. Außerdem veröffentlichen wir ein NGINX Open Source-Image auf Docker Hub, dem Repository für Docker-Images. In diesem Beitrag wird Folgendes erläutert:

NGINX Open Source bereitstellen mit dem Image von Docker Hub
NGINX im Container verwalten (Verbindung herstellen, konfigurieren, protokollieren, neu laden und neu starten)
NGINX Plus bereitstellen mithilfe eines von Ihnen erstellten Docker-Images

Einführung

Die offene Docker-Plattform umfasst die Docker Engine – die Open-Source-Laufzeitumgebung zum Erstellen, Ausführen und Orchestrieren von Containern – sowie Docker Hub, einen gehosteten Dienst, über den Docker-Anwendungen von der gesamten Entwickler-Community oder innerhalb einer bestimmten Organisation verteilt, geteilt und gemeinsam weiterentwickelt werden.

Docker-Container ermöglichen es Entwicklern, sich auf die „Inhalte“ ihrer Anwendungen zu konzentrieren, indem sie Anwendungen von den Einschränkungen der Infrastruktur entkoppeln. Dockerisierte Anwendungen lassen sich sofort auf jede beliebige Infrastruktur portieren – ob Laptop, Bare-Metal-Server, VM oder Cloud. Dadurch werden sie zu modularen Komponenten, die sich problemlos zu vollwertigen verteilten Anwendungen zusammenstellen und neu kombinieren sowie in Echtzeit kontinuierlich weiterentwickeln lassen.

Weitere Informationen zu Docker finden Sie unter „Warum Docker?“ oder in der vollständigen Docker-Dokumentation.

Verwenden des NGINX Open Source-Docker-Images

Sie können eine NGINX-Instanz in einem Docker-Container mithilfe des NGINX Open Source-Images von Docker Hub erstellen.

Beginnen wir mit einem sehr einfachen Beispiel. Um eine NGINX-Instanz in einem Container mit der standardmäßigen NGINX-Konfiguration zu starten, führen Sie diesen Befehl aus:

# docker run --name mynginx1 -p 80:80 -d nginxfcd1fb01b14557c7c9d991238f2558ae2704d129cf9fb97bb4fadf673a58580d

Dieser Befehl erstellt einen Container namens „mynginx1“ auf Basis des NGINX-Images. Der Befehl gibt die Langform der Container-ID zurück, die im Namen der Protokolldateien verwendet wird; siehe „Protokollierung verwalten“.

Die Option -p weist Docker an, den Port, der durch das NGINX-Image im Container verfügbar gemacht wird – Port 80 –, dem angegebenen Port auf dem Docker-Host zuzuordnen. Der erste Parameter gibt den Port auf dem Docker-Host an, während der zweite Parameter dem im Container verfügbaren Port zugeordnet wird.

Die Option „-d“ gibt an, dass der Container im getrennten Modus ausgeführt wird. Das bedeutet, dass er bis zum Beenden weiterläuft, aber nicht auf Befehle reagiert, die über die Befehlszeile ausgeführt werden. Im nächsten Abschnitt erklären wir, wie Sie mit dem Container interagieren.

Um zu überprüfen, ob der Container erstellt wurde und ausgeführt wird, und um die Portzuordnungen anzuzeigen, führen wir docker ps aus. (Zur besseren Lesbarkeit haben wir die Ausgabe hier auf mehrere Zeilen verteilt.)

# docker psCONTAINER ID  IMAGE         COMMAND               CREATED         STATUS        ...  
fcd1fb01b145  nginx:latest  "nginx -g 'daemon of  16 seconds ago  Up 15 seconds ... 

    ... PORTS              NAMES
    ... 0.0.0.0:80->80/tcp mynginx1

Das Feld PORTS in der Ausgabe gibt an, dass Port 80 auf dem Docker-Host Port 80 im Container zugeordnet ist. Eine weitere Möglichkeit, zu überprüfen, ob NGINX ausgeführt wird, besteht darin, eine HTTP-Anfrage an diesen Port zu senden. Daraufhin wird der Code der standardmäßigen NGINX-Willkommensseite angezeigt:

# curl http://localhost<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
 body {
 width: 35em;
 margin: 0 auto;
 font-family: Tahoma, Verdana, Arial, sans-serif;
 }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="https://www.nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>

Arbeiten mit dem NGINX-Docker-Container

Jetzt haben wir also einen funktionierenden NGINX-Docker-Container. Aber wie verwalten wir die Inhalte und die NGINX-Konfiguration? Und wie sieht es mit der Protokollierung aus?

Ein Hinweis zu SSH

Es ist üblich, den SSH-Zugriff auf NGINX-Instanzen zu aktivieren. Im NGINX-Image ist OpenSSH jedoch nicht installiert, da Docker-Container in der Regel für einen einzigen Zweck vorgesehen sind (in diesem Fall für die Ausführung von NGINX). Stattdessen verwenden wir andere von Docker unterstützte Methoden.

Alternativ zu den folgenden Befehlen können Sie mit dem folgenden Befehl eine interaktive Shell in einem laufenden NGINX-Container öffnen (anstatt eine SSH-Sitzung zu starten). Dies empfehlen wir jedoch nur fortgeschrittenen Benutzern.

Auf Alpine-Linux-Systemen:

# docker exec -it NGINX_container_ID sh

Auf Debian-Systemen:

# docker exec -it NGINX_container_ID bash

Inhalts- und Konfigurationsdateien verwalten

Es gibt verschiedene Möglichkeiten, sowohl die von NGINX bereitgestellten Inhalte als auch die NGINX-Konfigurationsdateien zu verwalten. Im Folgenden stellen wir einige davon vor.

Option 1 – Inhalte und Konfiguration auf dem Docker-Host verwalten

Beim Erstellen des Containers können wir Docker anweisen, ein lokales Verzeichnis auf dem Docker-Host in ein Verzeichnis im Container einzubinden. Das NGINX-Image verwendet die standardmäßige NGINX-Konfiguration, bei der /usr/share/nginx/html als Stammverzeichnis des Containers dient und Konfigurationsdateien unter /etc/nginx abgelegt werden. Führen Sie für einen Docker-Host mit Inhalten im lokalen Verzeichnis /var/www und Konfigurationsdateien unter /var/nginx/conf den folgenden Befehl aus (der hier lediglich zur besseren Lesbarkeit über mehrere Zeilen dargestellt ist):

# docker run --name mynginx2 --mount type=bind source=/var/www,target=/usr/share/nginx/html,readonly --mount type=bind,source=/var/nginx/conf,target=/etc/nginx/conf,readonly -p 80:80 -d nginx

Nun wird jede Änderung an den Dateien in den lokalen Verzeichnissen /var/www und /var/nginx/conf auf dem Docker-Host in den Verzeichnissen /usr/share/nginx/html und /etc/nginx im Container übernommen. Die Option readonly bedeutet, dass diese Verzeichnisse nur auf dem Docker-Host und nicht aus dem Container heraus geändert werden können.

Option 2 – Dateien vom Docker-Host kopieren

Eine weitere Möglichkeit besteht darin, Docker die Inhalts- und Konfigurationsdateien während der Containererstellung aus einem lokalen Verzeichnis auf dem Docker-Host kopieren zu lassen. Nach der Erstellung eines Containers werden die Dateien verwaltet, indem bei Änderungen an den Dateien ein neuer Container erstellt wird oder indem die Dateien im Container geändert werden. Eine einfache Möglichkeit zum Kopieren der Dateien besteht darin, ein Dockerfile mit Befehlen zu erstellen, die beim Erzeugen eines neuen Docker-Images auf Basis des NGINX-Images von Docker Hub ausgeführt werden. Bei den Befehlen zum Kopieren von Dateien (COPY) im Dockerfile ist der lokale Verzeichnispfad relativ zum Build-Kontext, in dem sich das Dockerfile befindet.

In unserem Beispiel befinden sich die Inhalte im Verzeichnis content und die Konfigurationsdateien im Verzeichnis conf. Beide sind Unterverzeichnisse des Verzeichnisses, in dem sich das Dockerfile befindet. Das NGINX-Image enthält standardmäßige NGINX-Konfigurationsdateien unter /etc/nginx/nginx.conf und /etc/nginx/conf.d/default.conf. Da wir stattdessen die Konfigurationsdateien vom Host verwenden möchten, fügen wir einen RUN-Befehl hinzu, der die Standarddateien löscht:

FROM nginx
RUN rm /etc/nginx/nginx.conf /etc/nginx/conf.d/default.conf
COPY content /usr/share/nginx/html
COPY conf /etc/nginx

Wir erstellen unser eigenes NGINX-Image, indem wir den folgenden Befehl in dem Verzeichnis ausführen, in dem sich das Dockerfile befindet. Beachten Sie den Punkt („.“) am Ende des Befehls. Er legt das aktuelle Verzeichnis als Build-Kontext fest, der das Dockerfile und die zu kopierenden Verzeichnisse enthält.

# docker build -t mynginx_image1 .

Nun führen wir diesen Befehl aus, um einen Container namens „mynginx3“ auf Grundlage des Images „mynginx_image1“ zu erstellen:

# docker run --name mynginx3 -p 80:80 -d mynginx_image1

Wenn wir Änderungen an den Dateien im Container vornehmen möchten, verwenden wir einen Hilfscontainer, wie in Option 3 beschrieben.

Option 3 – Dateien im Container verwalten

Wie unter „Hinweis zu SSH“ erwähnt, können wir nicht per SSH auf den NGINX-Container zugreifen. Wenn wir also die Inhalts- oder Konfigurationsdateien direkt bearbeiten möchten, müssen wir einen Hilfscontainer mit Shell-Zugriff erstellen. Damit der Hilfscontainer auf die Dateien zugreifen kann, müssen wir ein neues Image erstellen, für das die entsprechenden Docker-Daten-Volumes definiert sind. Angenommen, wir möchten wie in Option 2 Dateien kopieren und gleichzeitig Volumes definieren, verwenden wir das folgende Dockerfile:

FROM nginxRUN rm /etc/nginx/nginx.conf /etc/nginx/conf.d/default.conf
COPY content /usr/share/nginx/html
COPY conf /etc/nginx
VOLUME /usr/share/nginx/html
VOLUME /etc/nginx

Anschließend erstellen wir das neue NGINX-Image, indem wir den folgenden Befehl ausführen (beachten Sie auch hier den Punkt am Ende):

# docker build -t mynginx_image2 .

Nun führen wir diesen Befehl aus, um einen NGINX-Container (mynginx4) auf Basis des Images mynginx_image2 zu erstellen:

# docker run --name mynginx4 -p 80:80 -d mynginx_image2

Anschließend führen wir den folgenden Befehl aus, um einen Hilfscontainer namens „mynginx4_files“ mit einer Shell zu starten. Dadurch können wir auf die Inhalts- und Konfigurationsverzeichnisse des soeben erstellten Containers „mynginx4“ zugreifen:

# docker run -i -t --volumes-from mynginx4 --name mynginx4_files debian /bin/bashroot@b1cbbad63dd1:/#

Der neue Hilfscontainer mynginx4_files wird im Vordergrund mit einer dauerhaft geöffneten Standardeingabe (Option -i) und einem TTY (Option -t) ausgeführt. Alle in mynginx4 definierten Volumes werden als lokale Verzeichnisse in den Hilfscontainer eingebunden.

Das Argument debian bedeutet, dass der Hilfscontainer das Debian-Image von Docker Hub verwendet. Da auch das NGINX-Image Debian verwendet (und alle unsere bisherigen Beispiele das NGINX-Image nutzen), ist es am effizientesten, Debian für den Hilfscontainer zu verwenden, anstatt Docker ein weiteres Betriebssystem laden zu lassen. Das Argument /bin/bash bedeutet, dass die bash-Shell im Hilfscontainer ausgeführt wird und eine Eingabeaufforderung bereitstellt, über die Sie Dateien nach Bedarf ändern können.

Führen Sie die folgenden Befehle aus, um den Container zu starten und zu stoppen:

# docker start mynginx4_files# docker stop mynginx4_files

Um die Shell zu verlassen, den Container aber weiterlaufen zu lassen, drücken Sie Ctrl+p und anschließend Ctrl+q. Um wieder Shell-Zugriff auf einen laufenden Container zu erhalten, führen Sie diesen Befehl aus:

# docker attach mynginx4_files

Um die Shell zu verlassen und den Container zu beenden, führen Sie den Befehl exit aus.

Protokollierung verwalten

Sie können entweder die Standardprotokollierung oder eine benutzerdefinierte Protokollierung konfigurieren.

Standardprotokollierung verwenden

Das NGINX-Image ist standardmäßig so konfiguriert, dass die wichtigsten Zugriffs- und Fehlerprotokolle von NGINX an den Docker-Protokollsammler gesendet werden. Dazu werden sie jeweils mit stdout bzw. stderr verknüpft. Alle Meldungen aus beiden Protokollen werden dann auf dem Docker-Host in die Datei /var/lib/docker/containers/container-ID/container-ID-json.log geschrieben, wobei container‑ID die beim Erstellen eines Containers zurückgegebene vollständige ID ist. Für den ursprünglichen Container, den wir unter Verwenden des NGINX Open Source-Docker-Images erstellt haben, lautet sie beispielsweise fcd1fb01b14557c7c9d991238f2558ae2704d129cf9fb97bb4fadf673a58580d.

Um die Container-ID eines vorhandenen Containers abzurufen, führen Sie den folgenden Befehl aus. Dabei ist container‑name der Wert, der beim Erstellen des Containers mit dem Parameter --name festgelegt wurde (für die oben genannte Container-ID lautet er beispielsweise mynginx1):

# docker inspect --format '{{ .Id }}' container-name

Obwohl Sie die Protokolle anzeigen können, indem Sie die Datei container-ID-json.log direkt öffnen, ist es in der Regel einfacher, diesen Befehl auszuführen:

# docker logs container-name

Sie können auch die Docker Engine API verwenden, um die Protokollmeldungen abzurufen, indem Sie eine GET-Anfrage an den Docker-Unix-Socket senden. Dieser Befehl gibt sowohl das Zugriffsprotokoll (dargestellt durch stdout=1) als auch das Fehlerprotokoll (stderr=1) zurück. Sie können die Protokolle jedoch auch einzeln anfordern:

curl --unix-socket /var/run/docker-sock http://localhost/containers/container-name/logs?stdout=1&stderr=1

Weitere Informationen zu anderen Abfrageparametern finden Sie in der Docker Engine API-Dokumentation (suchen Sie auf dieser Seite nach „Get container logs“).

Benutzerdefinierte Protokollierung verwenden

Wenn Sie eine andere Methode zur Protokollerfassung implementieren oder die Protokollierung in bestimmten Konfigurationsblöcken (wie etwa server{} und location{}), anders konfigurieren möchten, definieren Sie ein Docker-Volume für das Verzeichnis bzw. die Verzeichnisse, in denen die Protokolldateien im Container gespeichert werden sollen, erstellen Sie einen Hilfscontainer für den Zugriff auf die Protokolldateien und verwenden Sie die gewünschten Protokollierungstools. Erstellen Sie dazu ein neues Image, das das Volume bzw. die Volumes für die Protokolldateien enthält.

Um NGINX beispielsweise so zu konfigurieren, dass Protokolldateien unter /var/log/nginx/log gespeichert werden, können wir mit dem Dockerfile aus Option 3 beginnen und einfach eine VOLUME-Definition für dieses Verzeichnis hinzufügen:

FROM nginxRUN rm /etc/nginx/nginx.conf /etc/nginx/conf.d/default.conf
COPY content /usr/share/nginx/html
COPY conf /etc/nginx
VOLUME /var/log/nginx/log

Anschließend können wir wie oben beschrieben ein Image erstellen und damit einen NGINX-Container sowie einen Hilfscontainer anlegen, die Zugriff auf das Protokollverzeichnis haben. Im Hilfscontainer können beliebige gewünschte Protokollierungswerkzeuge installiert werden.

NGINX steuern

Da wir keinen direkten Zugriff auf die Befehlszeile des NGINX-Containers haben, können wir NGINX nicht mit dem Befehl „nginx“ steuern. Glücklicherweise können wir NGINX mithilfe von Signalen steuern, und Docker stellt den Befehl „kill“ bereit, um Signale an einen Container zu senden.

Führen Sie den folgenden Befehl aus, um die NGINX-Konfiguration neu zu laden:

# docker kill -s HUP container-name

Um NGINX neu zu starten, führen Sie diesen Befehl aus, um den Container neu zu starten:

# docker restart container-name

NGINX Plus mit Docker bereitstellen

Bisher haben wir Docker für NGINX Open Source behandelt, aber Sie können es auch mit dem kommerziellen Produkt NGINX Plus verwenden. Der Unterschied besteht darin, dass Sie zunächst ein NGINX Plus-Image erstellen müssen, da NGINX Plus als kommerzielles Angebot nicht auf Docker Hub verfügbar ist. Glücklicherweise ist dies recht einfach.

**Hinweis: Laden Sie Ihre NGINX Plus-Images niemals in ein öffentliches Repository wie Docker Hub hoch. Dies verstößt gegen Ihre Lizenzvereinbarung.**

Erstellen eines Docker-Images von NGINX Plus

Um ein NGINX Plus-Image zu erstellen, erstellen Sie zunächst ein Dockerfile. Die hier aufgeführten Beispiele verwenden Alpine Linux 3.14 und Debian 11 (Bullseye) als Basis-Docker-Images. Bevor Sie das NGINX Plus-Docker-Image erstellen können, müssen Sie Ihre Version der Dateien nginx-repo.crt und nginx-repo.key herunterladen. NGINX Plus-Kunden finden diese im Kundenportal. Wenn Sie eine kostenlose Testversion von NGINX Plus nutzen, wurden sie mit Ihrem Testpaket bereitgestellt. Kopieren Sie die Dateien in das Verzeichnis, in dem sich das Dockerfile befindet (der Docker-Build-Kontext).

Wie bei NGINX Open Source sind die Zugriffs- und Fehlerprotokolle von NGINX Plus standardmäßig mit dem Docker-Protokollsammler verknüpft. Es sind keine Volumes angegeben, Sie können diese jedoch bei Bedarf hinzufügen. Alternativ kann jedes Dockerfile verwendet werden, um Basis-Images zu erstellen, aus denen Sie wie zuvor beschrieben neue Images mit angegebenen Volumes erstellen können.

Wir geben in den Beispiel-Dockerfiles bewusst keine Version von NGINX Plus an, damit Sie die Datei beim Aktualisieren auf eine neue Version von NGINX Plus nicht bearbeiten müssen. Wir haben jedoch auskommentierte Varianten der entsprechenden Anweisungen eingefügt, die Sie wieder aktivieren können, wenn Sie die Datei versionsspezifisch gestalten möchten.

Ebenso haben wir (auskommentierte) Anweisungen für die Installation offizieller dynamischer Module für NGINX Plus eingefügt.

Standardmäßig werden beim Erstellen eines Containers keine Dateien vom Docker-Host kopiert. Sie können jeder COPY-Anweisungen hinzufügen Dockerfile, oder das von Ihnen erstellte Image kann wie oben beschrieben als Grundlage für ein weiteres Image verwendet werden.

NGINX Plus-Dockerfile (Debian 11)

Codebeispiel wird geladen…

NGINX Plus-Dockerfile (Alpine Linux 3.14)

Codebeispiel wird geladen…

Erstellen des NGINX Plus-Images

Wenn sich das Dockerfile, nginx-repo.crt und nginx-repo.key im selben Verzeichnis befinden, führen Sie dort den folgenden Befehl aus, um ein Docker-Image namens nginxplus zu erstellen (beachten Sie wie zuvor den Punkt am Ende):

# DOCKER_BUILDKIT=1 docker build --no-cache -t nginxplus --secret id=nginx-crt,src=your_cert_file --secret id=nginx-key,src=your_key_file .

Das Flag „DOCKER_BUILDKIT=1“ gibt an, dass wir Docker BuildKit zum Erstellen des Images verwenden. Dies ist erforderlich, wenn die nachfolgend erläuterte Option --secret angegeben wird.

Die Option --no-cache weist Docker an, das Image von Grund auf neu zu erstellen, und stellt sicher, dass die neueste Version von NGINX Plus installiert wird. Wenn das Dockerfile bereits zuvor zum Erstellen eines Images verwendet wurde und Sie die Option --no-cache nicht angeben, verwendet das neue Image die Version von NGINX Plus aus dem Docker-Cache. (Wie bereits erwähnt, geben wir im Dockerfile bewusst keine NGINX Plus-Version an, damit die Datei nicht bei jeder neuen Version von NGINX Plus geändert werden muss.) Lassen Sie die Option --no-cache weg, wenn die Verwendung der NGINX Plus-Version aus dem zuvor erstellten Image akzeptabel ist.

Die Option „--secret“ übergibt das Zertifikat und den Schlüssel für Ihre NGINX Plus-Lizenz an den Docker-Build-Kontext, ohne dass die Gefahr besteht, dass die Daten offengelegt werden oder zwischen den Docker-Build-Layern erhalten bleiben. Die Werte der Argumente „id“ können nicht geändert werden, ohne das zugrunde liegende Dockerfile anzupassen. Sie müssen jedoch die Argumente „src“ auf den Pfad zu Ihren NGINX Plus-Zertifikats- und -Schlüsseldateien festlegen (dasselbe Verzeichnis, in dem Sie das Docker-Image erstellen, sofern Sie die vorherigen Anweisungen befolgt haben).

Eine Ausgabe wie die folgende des Befehls docker images nginxplus zeigt an, dass das Image erfolgreich erstellt wurde:

# docker images nginxplus
REPOSITORY  TAG     IMAGE ID      CREATED        VIRTUAL SIZE
nginxplus   latest  ef2bf65931cf  6 seconds ago  91.2 MB

Um einen Container namens „mynginxplus“ auf Basis dieses Images zu erstellen, führen Sie den folgenden Befehl aus:

# docker run --name mynginxplus -p 80:80 -d nginxplus

Sie können NGINX Plus-Container auf die gleiche Weise wie NGINX Open Source-Container steuern und verwalten.

Zusammenfassung

NGINX, NGINX Plus und Docker arbeiten hervorragend zusammen. Unabhängig davon, ob Sie das NGINX Open Source-Image von Docker Hub verwenden oder Ihr eigenes NGINX Plus-Image erstellen, können Sie problemlos neue Instanzen von NGINX und NGINX Plus in Docker-Containern starten und in Ihrer Kubernetes-Umgebung bereitstellen. Außerdem können Sie ganz einfach neue Docker-Images aus den Basis-Images erstellen, wodurch sich Ihre Container noch leichter steuern und verwalten lassen. Stellen Sie sicher, dass alle in Ihren Docker-Containern ausgeführten NGINX Plus-Instanzen durch Ihr Abonnement abgedeckt sind. Weitere Informationen erhalten Sie beim NGINX-Vertriebsteam.

Docker bietet noch viel mehr, als wir in diesem Artikel behandeln konnten. Weitere Informationen finden Sie in unserem kostenlosen O’Reilly-E-Book – Container-Netzwerke: Von Docker zu Kubernetes – oder auf www.docker.com.