Wie man ein benutzerdefiniertes NGINX-Docker-Image erstellt

NGINX in einem Docker-Container kann in vielen Umgebungen einen zuverlässigen Webservice bieten. Vielleicht arbeitest du an einer persönlichen Website, einem kleinen Webservice oder einem Heimlaborprojekt. Docker kann dir dabei helfen, die Konsistenz über verschiedene Maschinen und Konfigurationen hinweg zu erhalten. Dieser Ansatz bietet eine Möglichkeit, NGINX beim Wechsel zwischen Entwicklung und Produktion mit weniger Overhead zu betreiben. Es ist üblich, sich auf Docker zu verlassen, um den Webserver einfach zu verpacken, was es einfacher macht, deine Projekte ohne umständliche manuelle Schritte zu teilen.

In diesem Artikel erfährst du, wie du ein fertiges NGINX-Image verwendest, wie du Inhalte von deinem lokalen Rechner aus bereitstellst und wie du dein Image mit eigenen Funktionen erweiterst. Außerdem geht es um die Einrichtung eines Reverse-Proxys und die Verwendung von Docker Compose für die Bereitstellung mehrerer Dienste. Am Ende wirst du sehen, wie du Container mit ein paar einfachen Befehlen verwalten kannst und einen detaillierten Überblick darüber bekommst, wie du Docker und NGINX für praktische Aufgaben integrieren kannst.

Wenn du neu bei Docker bist, solltest du dir unseren Docker für Einsteiger um alles Wesentliche zu lernen.

Was ist Docker NGINX?

Docker NGINX bedeutet, dass der NGINX-Webserver in einem leichtgewichtigen Container läuft. Docker-Container sind so etwas wie kleine Pakete, die eine Anwendung und alle benötigten Abhängigkeiten enthalten. 

NGINX ist ein beliebter Webserver, der für seine hohe Leistung, die einfache Konfiguration und die flexible Handhabung des HTTP-Datenverkehrs bekannt ist. NGINX mit Docker zu koppeln ist attraktiv, weil es die Umgebung konsistent hält. Wenn du unter macOS, Windows oder Linux arbeitest, bleibt der Inhalt des Containers derselbe. Das bedeutet, dass sie sich unabhängig vom Host-Betriebssystem identisch verhält.

Ein typisches Docker-Image für NGINX enthält die Serversoftware, eine Standardkonfiguration und eine Verzeichnisstruktur für gehostete Dateien. Du kannst diesen Container sofort ausführen oder ihn anpassen, indem du bestimmte Ordner zuordnest, Konfigurationsdateien anpasst oder ein Image auf Basis deiner eigenen Dockerdatei erstellst. Auf diese Weise kannst du benutzerdefinierte Module oder Skripte hinzufügen, um NGINX an deine Anwendung anzupassen.

Wenn du mehr über die Containerisierung von Anwendungen erfahren möchtest, lies unseren Wie man eine Anwendung mit Docker containerisiert Tutorial. Er geht näher darauf ein, wie man Machine-Learning-Anwendungen mit Docker auf einsteigerfreundliche Weise containerisieren kann. 

Voraussetzungen

Bevor du mit der Ausführung von NGINX-Containern beginnst, musst du sicherstellen, dass Docker installiert ist. Docker hat offizielle Installationsprogramme für macOS, Windows und verschiedene Linux-Distributionen. In der Docker-Dokumentation findest du eine Schritt-für-Schritt-Anleitung für jedes Betriebssystem. 

Schau dir unsere Einführung in Docker für einen umfassenden Leitfaden für den Einstieg in Docker.

Teste deine Installation mit einem schnellen Befehl wie

docker version
derrickmwiti@Derricks-MacBook-Pro% docker version
Client:
 Version:           28.0.1
 API version:       1.48
 Go version:        go1.23.6
 Git commit:        068a01e
 Built:             Wed Feb 26 10:38:16 2025
 OS/Arch:           darwin/arm64
 Context:           desktop-linux
Server: Docker Desktop 4.39.0 (184744)
 Engine:
  Version:          28.0.1
  API version:      1.48 (minimum version 1.24)
  Go version:       go1.23.6
  Git commit:       bbd0a17
  Built:            Wed Feb 26 10:40:57 2025
  OS/Arch:          linux/arm64
  Experimental:     false
 containerd:
  Version:          1.7.25
  GitCommit:        bcc810d6b9066471b0b6fa75f557a15a1cbf31bb
 runc:
  Version:          1.2.4
  GitCommit:        v1.2.4-0-g6c52b3f
 docker-init:
  Version:          0.19.0
  GitCommit:        de40ad0

Wenn du Versionsdetails siehst, bedeutet das, dass Docker bereit ist. Neben Docker selbst brauchst du einen Internetzugang, um das NGINX-Image aus Docker Hub zu ziehen. Wenn du dein Image erstellen willst, brauchst du einen Texteditor, um ein Dockerfile zu schreiben. Jeder Texteditor ist gut geeignet, aber wähle einen, der für dich bequem ist.

Einrichten von NGINX in einem Docker Container

NGINX von einem vorgefertigten Image zu starten, ist normalerweise die schnellste Methode. Du kannst sie in wenigen Sekunden von Docker Hub abrufen und dann einen Container starten. Danach siehst du die Standardseite in deinem Browser. Dieser kurze Prozess ist oft der erste Schritt in vielen Docker-basierten Server-Setups.

Ziehen des NGINX Docker-Images

Das offizielle NGINX-Image ist öffentlich auf Docker Hub unter dem Namen nginx verfügbar.

Mach es so:

docker pull nginx
derrickmwiti@Derricks-MacBook-Pro % docker pull nginx
Using default tag: latest
latest: Pulling from library/nginx
4c7c1a5bd3af: Download complete 
bef2ee7fab45: Download complete 
d9b636547744: Downloading [======================>                            ]  12.58MB/28.04MB
0994e771ba34: Downloading [===>                                               ]  3.146MB/40.56MB
589701e352f8: Download complete 
13f89c653285: Download complete 
8e77214beb25: Download complete 

Das geht zur Registrierung und holt die neueste Version. Wenn alles fertig ist, kannst du überprüfen, ob sie auf deinem Rechner existiert:

docker images
derrickmwiti@Derricks-MacBook-Pro% docker images
REPOSITORY                                                                     TAG                                                                           IMAGE ID       CREATED         SIZE

nginx                                                                          latest                                                                        124b44bfc9cc   6 weeks ago     280MB
keras-custom-training-container                                                latest                                                                                                                                     <none>                                                                        7de0f04013e5   7                                                  

Dieser Befehl zeigt eine Liste der Bilder in deiner lokalen Bibliothek an. Du solltest das Bild nginx in der Tabelle sehen. Das bedeutet, dass du bereit bist, einen Container daraus zu erstellen. Entdecke eine Liste von Images, die du für deine Data-Science-Projekte brauchst, in unserer Top 12 Docker Container Images für maschinelles Lernen und KI Tutorial.

Ausführen des NGINX-Containers

Sobald sich das NGINX-Image auf deinem System befindet, kannst du den Container mit einem einzigen Befehl starten:

docker run --name mynginx -p 8080:80 -d nginx
derrickmwiti@Derricks-MacBook-Pro % docker run --name mynginx -p 8080:80 -d nginx
ec44d1a43016e9684b602437b967c0ed8e11c933a8a76b341b68c25168d2af70

Dieser Befehl bewirkt mehrere Dinge. Es läuft ein Container namens mynginx im Hintergrund (wegen der Option -d ). Er ordnet den Port 8080 auf deinem Host-Rechner dem Port 80 innerhalb des Containers zu. Diese Portzuordnung bedeutet, dass du die Seite http://localhost:8080 in deinem Browser aufrufen und die Standard-NGINX-Seite sehen. Der Container verwendet das nginx Image, das von Docker Hub bezogen wird.

Der neue Container sollte weiterlaufen, weil NGINX aktiv ist. Wenn du die Logs mit:

docker logs mynginx
derrickmwiti@Derricks-MacBook-Pro % docker logs mynginx
/docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration
/docker-entrypoint.sh: Looking for shell scripts in /docker-entrypoint.d/
/docker-entrypoint.sh: Launching /docker-entrypoint.d/10-listen-on-ipv6-by-default.sh
10-listen-on-ipv6-by-default.sh: info: Getting the checksum of /etc/nginx/conf.d/default.conf
10-listen-on-ipv6-by-default.sh: info: Enabled listen on IPv6 in /etc/nginx/conf.d/default.conf
/docker-entrypoint.sh: Sourcing /docker-entrypoint.d/15-local-resolvers.envsh
/docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh
/docker-entrypoint.sh: Launching /docker-entrypoint.d/30-tune-worker-processes.sh
/docker-entrypoint.sh: Configuration complete; ready for start up
2025/03/20 04:33:10 [notice] 1#1: using the "epoll" event method
2025/03/20 04:33:10 [notice] 1#1: nginx/1.27.4
2025/03/20 04:33:10 [notice] 1#1: built by gcc 12.2.0 (Debian 12.2.0-14) 
2025/03/20 04:33:10 [notice] 1#1: OS: Linux 6.10.14-linuxkit
2025/03/20 04:33:10 [notice] 1#1: getrlimit(RLIMIT_NOFILE): 1048576:1048576
2025/03/20 04:33:10 [notice] 1#1: start worker processes
2025/03/20 04:3

Du kannst alle Meldungen sehen, die NGINX geschrieben hat. 

Benutzerdefinierte Inhalte mit NGINX bereitstellen

Möglicherweise möchtest du eine HTML-Seite ausliefern und nicht die Standardseite, die im Container-Image enthalten ist. Du kannst eine einfache Datei auf deinem lokalen Rechner erstellen und sie dann in den Container mounten. So bleibt dein Inhalt vom Container getrennt. Jedes Mal, wenn du deine Seite veränderst, kannst du den Browser aktualisieren, um die Änderungen zu sehen.

Erstellen einer benutzerdefinierten HTML-Seite

Wähle einen geeigneten Ort auf deinem lokalen Rechner. Möglicherweise ein Ordner namens html_content in deinem Home-Verzeichnis. Erstelle dort eine index.html Datei. Das könnte so aussehen:

<html>
<head>
    <title>My NGINX Page</title>
</head>
<body>
    <h1>Hello from my Docker NGINX setup!</h1>
    <p>This is a custom page served from a local folder.</p>
</body>
</html>

Das ist eine einfache HTML-Seite. Du kannst jeden Text oder jedes Styling einfügen, das du möchtest. Füge Bilder, JavaScript oder etwas anderes hinzu, das deinen Bedürfnissen entspricht.

Einbinden der HTML-Seite in den NGINX-Container

Das offizielle NGINX-Image liefert standardmäßig Inhalte von /usr/share/nginx/html. Du kannst deinen lokalen Ordner diesem Ort innerhalb des Containers zuordnen. Das wird mit dem -v (volume) Flag in Docker gemacht. Stoppe alle vorhandenen Container mit dem Namen mynginx, um einen Port-Konflikt zu vermeiden:

docker stop mynginx
docker rm mynginx

Dann beginne einen neuen Container:

docker run --name mynginx -p 8080:80 -d \
    -v /Users/derrickmwiti/Documents/html_content:/usr/share/nginx/html \
    nginx
6f68085733eeac418c3302e5c580a4f7c5c0c36d3591d8e2a7f35f69f6308d18

Ersetze /path/to/html_content durch den tatsächlichen Pfad auf deinem Computer. Auf diese Weise kannst du jedes Mal, wenn du die Seite http://localhost:8080aufrufst, wird der Container die HTML-Datei bereitstellen, die du in html_content abgelegt hast. Wenn du sie index.html aufrufst, lädt NGINX diese Datei automatisch.

Dieser Ansatz ist von Vorteil, wenn du den Inhalt regelmäßig anpassen willst. Du musst den Container nicht jedes Mal neu aufbauen. Der Server zieht die Inhalte aus deinem lokalen Ordner in Echtzeit. 

Wenn du eine Warnung bezüglich der Berechtigungen siehst, musst du sicherstellen, dass dein lokaler Benutzer und Docker diesen Ordner lesen können. 

Unter Linux kann das bedeuten, dass du den Eigentümer oder die Dateiberechtigungen anpasst. Unter Windows oder macOS kann es bedeuten, dass du Docker die Erlaubnis erteilst, auf dein Laufwerk zuzugreifen.

Erstellen eines benutzerdefinierten NGINX-Docker-Images

Das Einbinden eines lokalen Ordners ist eine schnelle Lösung für einfache Tests. Vielleicht möchtest du zusätzliche Module, eine spezielle Konfiguration oder eine andere Optimierung. Dabei kann es hilfreich sein, ein Image aufzubauen. 

Mit Docker ist es ganz einfach, eine kleine Rezeptdatei, ein sogenanntes Dockerfile, zu erstellen, die einen Container genau nach deinen Wünschen einrichtet. Dann hast du ein Bild, das du mit anderen teilen oder in eine Registry stellen kannst. Das kann bequemer sein, als den Leuten zu sagen, dass sie einen Haufen lokaler Dateien mounten sollen.

Eine Dockerdatei erstellen

Ein Dockerfile ist nur eine einfache Textdatei. Du kannst es Dockerfile nennen oder einen anderen Namen wählen, wenn du das möchtest. Lege sie in einem neuen Verzeichnis ab. Hier ist ein einfaches Beispiel:

FROM nginx:latest

COPY index.html /usr/share/nginx/html/index.html

Dabei wird das offizielle Bild von nginx:latest als Grundlage verwendet. Dann kopiert er eine lokale Datei namens index.html in den Standard-Webinhaltsordner im Container. Du kannst auch mehr Zeilen einfügen, wenn du sie brauchst. Du kannst zum Beispiel eine benutzerdefinierte nginx.conf kopieren oder Module hinzufügen, die du installieren möchtest. Das hängt von deinen Bedürfnissen ab. Wenn du nur eine statische Seite platzieren willst, reicht das obige Snippet aus.

Wenn du diese Dockerdatei erstellt hast, fügst du die benutzerdefinierte index.html in denselben Ordner ein. Dann kannst du bauen. Der typische Befehl lautet:

docker build -t mynginximage .
[+] Building 2.6s (7/7) FINISHED                                                                                                                                                       docker:desktop-linux
 => [internal] load build definition from Dockerfile                                                                                                                                                   0.0s
 => => transferring dockerfile: 245B                                                                                                                                                                   0.0s
 => [internal] load metadata for docker.io/library/nginx:latest                                                                                                                                        0.0s
 => [internal] load .dockerignore                                                                                                                                                                      0.0s
 => => transferring context: 2B                                                                                                                                                                        0.0s
 => [internal] load build context                                                                                                                                                                      0.0s
 => => transferring context: 365B                                                                                                                                                                      0.0s
 => [1/2] FROM docker.io/library/nginx:latest@sha256:124b44bfc9ccd1f3cedf4b592d4d1e8bddb78b51ec2ed5056c52d3692baebc19                                                                                  2.3s
 => => resolve docker.io/library/nginx:latest@sha256:124b44bfc9ccd1f3cedf4b592d4d1e8bddb78b51ec2ed5056c52d3692baebc19                                                                                  2.3s
 => [2/2] COPY index.html /usr/share/nginx/html/index.html                                                                                                                                             0.0s
 => exporting to image                                                                                                                                                                                 0.1s
 => => exporting layers                                                                                                                                                                                0.0s
 => => exporting manifest sha256:19dd719772fd7ac839fadb7d49862f84422f4571a442994ffaca152e9674553a                                                                                                      0.0s
 => => exporting config sha256:e974f3ab92a0278e419f0fe4c5a6fc43fafb4a75da27895d90c4f2d5d385daa1                                                                                                        0.0s
 => => exporting attestation manifest sha256:e391b0212e5a100bd9132fbbd6cb4052e288dbbcba093839b55f8b197131372b                                                                                          0.0s
 => => exporting manifest list sha256:d35c2bbe10ab0b7e46d1ef8fba6c6cb28628eb9c283db02607e32e95b62e14d5                                                                                                 0.0s
 => => naming to docker.io/library/mynginximage:latest                                                                                                                                                 0.0s
 => => unpacking to docker.io/library/mynginximage:latest                                                                                                                                              0.0s

Der Punkt am Ende gibt das aktuelle Verzeichnis als Baukontext an. Docker liest die Dockerdatei in diesem Verzeichnis. Am Ende hast du ein Image namens mynginximage auf deinem lokalen System. Prüfe es mit:

docker images
mynginximage                                                                   latest                                                                        d35c2bbe10ab   36 seconds ago   281MB

Du solltest den neuen Namen in der Liste sehen. Dieser Ansatz bedeutet, dass dein Dockerfile und HTML in einem einzigen Image kombiniert werden. Du musst zur Laufzeit nichts montieren.

Erstellen und Ausführen des benutzerdefinierten Images

Jetzt, wo du mynginximage erstellt hast, kannst du es ausführen:

docker run --name mycustomnginx -p 8080:80 -d mynginximage

Achte darauf, dass du den vorherigen Container stoppst, um Portkonflikte zu vermeiden. 

Dieser Container bedient automatisch die Seite, die du im Dockerfile platziert hast. Wenn du einen Browser unter http://localhost:8080 öffnest, solltest du diesen HTML-Text sehen. 

Du kannst dein Dockerfile mit anderen teilen oder das erstellte Image in eine Registry stellen. Dann können deine Teamkolleginnen und -kollegen es in Betrieb nehmen, ohne lokale Ordner zu kopieren.

Damit ist der Prozess der Erstellung eines minimalen benutzerdefinierten NGINX-Images abgeschlossen. Du bist von der offiziellen Basis ausgegangen, hast ein oder zwei Dateien kopiert und einen neuen Container erstellt, der deine eigene Website enthält. Du kannst das Dockerfile weiter ausbauen. Du könntest zum Beispiel die Konfiguration ändern, um PHP mit php-fpm in einem mehrstufigen Build zu behandeln, oder benutzerdefinierte Module hinzufügen, die NGINX nicht standardmäßig mitliefert.

Dieser Ansatz unterstreicht die Flexibilität von Docker: Jede Schicht im Dockerfile kann eine bestimmte Aufgabe übernehmen, und das fertige Image kann leicht verteilt werden. Du hast die Kontrolle über den Webinhalt und die Möglichkeit, die Einstellungen so zu verändern, dass der Container zu deinem Projekt passt. 

Erkunde diese 10 Docker-Projektideen, um Docker mit praktischen Projekten zu erlernen, die sich auf den Aufbau und die Optimierung von Data Science-Anwendungen konzentrieren.

NGINX als Reverse Proxy einrichten

NGINX kann eingehende Anfragen an andere Dienste auf demselben System oder sogar an Dienste weiterleiten, die auf anderen Rechnern laufen. Dies wird normalerweise als Reverse-Proxy-Einrichtung bezeichnet. Du könntest NGINX vor einer Gruppe von Anwendungen platzieren, damit die Anfragen über einen einzigen Einstiegspunkt laufen. 

Das kommt häufig vor, wenn du mehrere Docker-Container hast, die auf verschiedenen Ports lauschen, und du einen einzigen Domainnamen für alles haben willst. NGINX lauscht auf einem Standardport wie 80 oder 443 und leitet den Datenverkehr dann anhand des Pfads, des Hostnamens oder anderer Faktoren an den richtigen Dienst weiter.

Reverse Proxy verstehen

Wenn NGINX auf diese Weise konfiguriert ist, weiß der Client nichts von der Hintergrundkommunikation. NGINX fungiert als öffentliches Gesicht, das Anfragen empfängt und weiterleitet und die Antworten an den Kunden zurückschickt. 

Dieses Design vereinfacht deine Netzwerkstruktur. Es bietet auch die Möglichkeit, das Caching anzupassen, TLS-Zertifikate hinzuzufügen, die Lastverteilung zu steuern oder andere erweiterte Aufgaben zu erledigen. Oft ist es einfacher, diese Aufgaben an einem Ort zu erledigen, als sie auf mehrere Dienste zu verteilen.

Ein typisches Szenario könnte ein Container sein, auf dem NGINX auf Port 80 läuft und der Anfragen an einen Anwendungscontainer auf Port 3000 sendet. Während der Kunde http://yourdomain.com besucht, wird der Datenverkehr hinter den Kulissen an einen separaten Container weitergeleitet. 

So kann dein Anwendungscontainer seinen Standardport beibehalten, mit minimalem Overhead für den Nutzer. Ein weiterer Grund, dies zu tun, ist, dass du vielleicht die internen Details deiner Dienste verbergen oder eine einheitliche URL-Struktur präsentieren möchtest.

NGINX für Reverse Proxy konfigurieren

Um dies zu erreichen, brauchst du eine Konfigurationsdatei für ein benutzerdefiniertes NGINX, das Proxy-Direktiven verwendet. Du kannst dies tun, indem du eine neue Konfigurationsdatei einbindest, wenn du den Container startest, oder indem du ein benutzerdefiniertes Image erstellst, das diese Datei enthält. Hier ist ein einfaches Beispiel, um die allgemeine Idee zu veranschaulichen:

server {
    listen 80;

    location / {
        proxy_pass http://myapp:3000/;
    }
}

Im obigen Snippet wird jede Anfrage, die an deinem NGINX-Container auf Port 80 ankommt, an myapp:3000 gesendet. Der Name myapp deutet darauf hin, dass es einen weiteren Container gibt, der unter diesem Namen erreichbar ist, was bei der Verwendung von Docker-Netzwerken üblich ist .

Wenn du eigenständige Container verwendest, kannst du die IP-Adresse des Containers zuordnen oder die IP-Adresse des Hosts verwenden. Du kannst auch erweiterte Einstellungen wie proxy_set_header Host $host hinzufügen oder die Timeout-Werte an deine Anwendung anpassen.

Wenn du dich dafür entscheidest, diese Datei zur Laufzeit einzubinden, kannst du wie folgt vorgehen:

docker run --name nginxproxy -p 8080:80 -d \
    -v /path/to/nginx.conf:/etc/nginx/conf.d/default.conf \
    --network mynetwork \
    nginx

Mit diesem Befehl wird der NGINX-Container gestartet und deine lokale nginx.conf als Standardkonfiguration eingebunden. Er verbindet den Container auch mit einem Docker-Netzwerk namens mynetwork, in dem sich dein anderer Container (myapp) befindet. Das ist oft der einfachste Ansatz, wenn du deine Konfiguration außerhalb des Containers behalten willst. 

Es ist auch möglich, diese Datei in ein Dockerfile zu packen, wenn du eine statische Anordnung willst. Beide Ansätze können funktionieren, solange die Referenzen mit den Namen deiner Container und Netzwerke übereinstimmen.

Mit diesem Design hast du die Möglichkeit, eine einzige Domain oder IP für alle deine Webdienste und einen gemeinsamen Port zu verwenden. Wenn du mit mehreren Backend-Containern arbeitest, kannst du in deiner Konfiguration mehrere Standorte definieren, die jeweils auf einen anderen Container-Port verweisen. NGINX kann dann anhand des URL-Pfads zu jedem Dienst routen. Das ist ein beliebter Ansatz für Microservices, weil er die Einstiegspunkte auf eine ordentliche Art und Weise konsolidiert.

Docker Compose für die NGINX-Bereitstellung verwenden

Ein Reverse Proxy ist oft sinnvoller, wenn du mehrere Container hast, die zusammenarbeiten. Docker Compose ist ein Werkzeug, mit dem du viele Dienste in einer einzigen Datei definieren kannst. Dann kannst du sie mit einem einzigen Befehl nach oben oder unten bringen. Es verringert die Wahrscheinlichkeit von Fehlern bei der Erstellung von Containern oder der Zuordnung von Ports, da alle Details in einer Standarddatei enthalten sind.

Einführung in Docker Compose

Mit Docker Compose kannst du Gruppen von Containern verwalten. Du beschreibst jeden Dienst, gibst das zu verwendende Image, die zu veröffentlichenden Ports, die zu mountenden Volumes und die zu verbindenden Netzwerke an. Dann wird ein einfacher Befehl (docker compose up -d ) alles auf einmal starten .

Dieser Ansatz ist praktisch für die lokale Entwicklung oder für Staging-Umgebungen, in denen du mehrere Docker-Container koordinieren musst. Das übliche Dateiformat ist YAML.

Obwohl Docker Compose auf verschiedenen Betriebssystemen funktionieren kann, musst du sicherstellen, dass es installiert und erkannt wird. Moderne Docker-Desktop-Installationen enthalten sie oft standardmäßig. Überprüfe deine Version mit:

docker compose version
Docker Compose version v2.33.1-desktop.1

Wenn du die Versionsangaben siehst, kannst du fortfahren. Wenn du das nicht tust, kannst du in der Docker-Dokumentation nachlesen, wie du Docker Compose aktivierst oder installierst.

Erstellen einer docker-compose.yml Datei

Die Datei enthält in der Regel einen Abschnitt über Dienstleistungen. Im Folgenden findest du ein einfaches Beispiel für eine docker-compose.yml Datei, die einen einzelnen NGINX-Container für die Bereitstellung statischer Inhalte einrichtet: 

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/html

Hier ist, wie du die Datei interpretierst:

• Dienstleistungen: Definiert die Dienste (Container), aus denen deine Anwendung besteht.

• web: Dieser Dienst verwendet das neueste NGINX-Image.
• Häfen: Ordnet Port 80 innerhalb des Containers dem Port 8080 auf deinem Host-Rechner zu. Damit kannst du über http://localhost:8080 auf den Webserver zugreifen.
• Bände: Mounten Sie das lokale Verzeichnis html in das Standard-Inhaltsverzeichnis von NGINX innerhalb des Containers (/usr/share/nginx/html). Mit dieser Einstellung kann NGINX deine eigenen statischen Inhalte bereitstellen.

Dienste mit Docker Compose bereitstellen

Erstelle im gleichen Verzeichnis wie deine Datei docker-compose.yml ein Unterverzeichnis mit dem Namen html.

Platziere deine statischen HTML-Dateien (z.B. index.html) in diesem html Verzeichnis. In diesem Fall habe ich zur Demonstration eine einfache Seite im Bootstrap-Stil erstellt. 

Öffne ein Terminal und navigiere zu deinem Projektverzeichnis, in dem sich die Datei docker-compose.yml befindet.

Führe den folgenden Befehl aus, um den Dienst zu starten:

docker compose up -d
[+] Running 1/1
 ✔ Container html_content-web-1  Started 

Mit dem -d Flag wird der Container in einem losgelösten Modus ausgeführt, so dass er im Hintergrund laufen kann.

Docker Compose sieht sich die Datei docker-compose.yml im aktuellen Verzeichnis an. Er holt alle Bilder, die noch nicht vorhanden sind, und startet dann jeden Container. 

Öffne deinen Webbrowser und navigiere zu http://localhost:8080.

Du solltest sehen, dass dein statischer Inhalt von NGINX bereitgestellt wird.

Du kannst den Status deiner laufenden Dienste überprüfen, indem du nachschaust:

docker compose ps

Wenn du alles abreißen musst, kannst du die Container mit einem einzigen Befehl entfernen:

docker compose down

Das stoppt und entfernt sie alle auf einmal. Wenn du die gesamte Umgebung replizieren willst, kopierst du einfach die Docker Compose-Datei und den entsprechenden Code auf einen neuen Rechner und führst dann die gleichen Befehle aus. Dadurch wird sichergestellt, dass du mit einem Minimum an manuellen Schritten konsistente Ergebnisse erhältst.

Verwaltung von NGINX-Containern

Während der Docker Compose Ansatz für Multi-Service-Workflows beliebt ist, musst du manchmal nur einen einzelnen Container oder einen kleinen Cluster verwalten. Docker bietet ein paar grundlegende Befehle, mit denen du sehen kannst, was läuft, Container anhalten oder stoppen und sie bei Bedarf entfernen kannst. 

Sie sind wichtig für die Verwaltung, vor allem wenn du mit mehreren NGINX-Containern oder wiederholten Builds experimentierst.

Laufende Container anzeigen

Wann immer du sehen willst, welche Container laufen, kannst du sie benutzen:

docker ps
CONTAINER ID   IMAGE          COMMAND                  CREATED         STATUS         PORTS                  NAMES
2d386c085129   mynginximage   "/docker-entrypoint.…"   4 minutes ago   Up 4 minutes   0.0.0.0:8080->80/tcp   mycustomnginx

Dieser Befehl gibt eine Tabelle mit den aktiven Containern aus, jeder mit einer ID, einem Bild, einem Namen und mehr. Wenn du alle Container sehen willst, auch die, die angehalten haben, verwende:

docker ps -a

Hier wird jeder Container angezeigt, der auf deinem System existiert, auch die, die beendet wurden. Oft ist es hilfreich zu sehen, welche Container aus älteren Läufen noch vorhanden sind. Wenn du mit mehreren Bildern experimentierst, hast du vielleicht Container mit den Namen mynginx, mycustomnginx oder etwas anderem.

Anhalten und Entfernen von Containern

Wenn du mit einem Container fertig bist, kannst du ihn per Namen stoppen:

docker stop mynginx
CONTAINER ID   IMAGE          COMMAND                  CREATED         STATUS         PORTS                  NAMES
2d386c085129   mynginximage   "/docker-entrypoint.…"   4 minutes ago   Up 4 minutes   0.0.0.0:8080->80/tcp   mycustomnginx

Dadurch wird Docker angewiesen, ein Stoppsignal an den Container zu senden, was dazu führen sollte, dass NGINX sauber heruntergefahren wird. Wenn du den Behälter gleich danach entfernen willst, kannst du das tun:

docker rm mynginx

Wenn du einen einzigen Befehl bevorzugst, der in einem Zug stoppt und entfernt, probiere es aus:

docker rm -f mynginx

Das erzwingt die Entfernung und stoppt den Container, wenn er noch läuft. Sei vorsichtig, wenn du diesen Ansatz in einer Produktionsumgebung verwendest, da er den Container beendet, ohne ihm ein sanftes Herunterfahren zu ermöglichen. Ein weiterer Haushaltsbefehl ist docker rmi, mit dem du Bilder aus deinem System entfernen kannst .

Das ist hilfreich, wenn du bestimmte Bilder nicht mehr brauchst und Speicherplatz freigeben willst. Docker löscht jedoch nur Images, die nicht von einem laufenden Container verwendet werden.

Fazit

NGINX in Docker ist eine praktische Methode, um Webseiten zu bedienen oder den Datenverkehr an andere Dienste weiterzuleiten. Du kannst das offizielle Image ausführen oder dein eigenes mit einem einfachen Dockerfile erstellen. Docker Compose kann mehrere Container koordinieren, wodurch komplexe Setups einfacher zu handhaben sind. 

Mit diesen Methoden kannst du Inhalte bereitstellen, Weiterleitungen verwalten und eine zuverlässige Umgebung für Webprojekte aufrechterhalten. 

Wenn du einen praktischeren Ansatz zum Erlernen von Docker brauchst, schau dir unseren Kurs Einführung in Docker um zu erfahren, welche Bedeutung Docker im Werkzeugkasten eines Datenexperten hat.