Nginx in Docker installieren – So einfach funktioniert es

Grundlegendes zu Nginx und Docker

Nginx ist ein leistungsstarker Webserver und Reverse Proxyserver, der für seine hohe Performance und Skalierbarkeit bekannt ist. In diesem Artikel zeige ich dir, wie du Nginx in Docker installierst.

Docker ermöglicht es, Anwendungen und ihre Abhängigkeiten in einer konsistenten Umgebung zu verpacken und auszuführen. So kannst du damit z. B. sehr einfach eine WordPress Webseite bereitstellen.

Warum sollte man Nginx verwenden?

Nginx, ausgesprochen als „Engine X“, ist ein vielseitiger und leistungsstarker Webserver, der auch als Reverse Proxy, Load Balancer und HTTP-Cache fungieren kann.

Seine Popularität ist auf mehrere beeindruckende Merkmale zurückzuführen, die ihn zu einer bevorzugten Wahl in der Welt der Webserver machen. Alternativen wäre im übrigen Apache, Lighttpd oder IIS von Microsoft. Der am weitverbreitete ist aber Nginx.

Geschwindigkeit und Effizienz:

Nginx zeichnet sich durch seine bemerkenswerte Geschwindigkeit und Effizienz aus. Er ist in der Lage, eine große Anzahl gleichzeitiger Verbindungen zu verarbeiten, was es ideal für Hochlastszenarien macht. Die Architektur von Nginx ist darauf ausgelegt, ressourcenschonend zu sein und gleichzeitig eine optimale Leistung zu bieten.

Skalierbarkeit:

Die Fähigkeit von Nginx, Lasten auf mehrere Server zu verteilen, macht diesen zu einer hervorragenden Lösung für skalierbare Webanwendungen. Als Load Balancer kann es den Datenverkehr effizient auf mehrere Server verteilen, um eine gleichmäßige Auslastung zu gewährleisten und Ausfälle zu vermeiden.

Reverse Proxy:

Nginx agiert als Reverse Proxy, der Anfragen von Clients entgegennimmt und sie an die entsprechenden Server weiterleitet. Dies ermöglicht eine saubere Trennung zwischen öffentlichen Benutzern und den internen Servern, wodurch die Sicherheit und Flexibilität verbessert wird.

HTTP-Cache:

Die integrierte Fähigkeit von Nginx, statische Ressourcen zu cachen, verbessert die Ladezeiten von Webseiten erheblich. Dies ist besonders wichtig, um die Performance zu erhöhen, und die Serverlast zu reduzieren, insbesondere in Umgebungen mit hohem Traffic.

Vielseitigkeit:

Nginx ist äußerst vielseitig und eignet sich nicht nur als eigenständiger Webserver, sondern auch als Frontend für verschiedene Arten von Anwendungen. Er kann als Reverse Proxy für Anwendungen wie Node.js, Python Django und viele andere dienen.

Durch die Containerisierung mit Nginx Docker können diese Vorzüge einfach in unterschiedlichen Umgebungen genutzt werden, was die Kombination aus Nginx und Docker zu einer leistungsstarken Wahl für Entwickler und Systemadministratoren macht.

Die besten Docker Bücher

Auch interessanter Artikel:

Docker installieren

Bevor du in die faszinierende Welt von Nginx eintauchen kannst, ist es zunächst wichtig, Docker auf deinem System zu installieren. Docker ermöglicht es, Anwendungen und ihre Abhängigkeiten in leichtgewichtigen Containern zu isolieren und auszuführen. Du musst dabei die folgenden Schritte durchführen, um Docker zu installieren.

Betriebssystemvoraussetzungen überprüfen:

Zuerst solltest du sicherstellen, dass dein Betriebssystem die Voraussetzungen für die Docker-Installation erfüllt. Docker unterstützt eine Vielzahl von Betriebssystemen, darunter Windows, macOS und verschiedene Linux-Distributionen. Überprüfe die offizielle Docker-Dokumentation, um sicherzustellen, dass dein System kompatibel ist.

Docker herunterladen:

Gehe auf die offizielle Docker-Website und wähle die passende Version für dein Betriebssystem aus. Für Windows und macOS gibt es Installationsprogramme, die einfach heruntergeladen und ausgeführt werden können. Für Linux-Systeme werden detaillierte Anleitungen für verschiedene Distributionen bereitgestellt.

Installationsprozess durchführen:

Nachdem der Download abgeschlossen ist, führe das Installationsprogramm aus. Während des Installationsprozesses benötigst du in der Regel auch Administratorberechtigungen.

Docker Desktop starten (für Windows und macOS):

Wenn du Docker auf Windows oder macOS installiert hast, starte Docker Desktop nach Abschluss der Installation. DU kannst abschließend mit folgendem Befehl leicht prüfen, ob der Docker-Daemon läuft.

docker info

Nginx Docker Container downloaden

Nachdem du erfolgreich Docker auf deinem System installiert hast, ist der nächste Schritt das Finden des Nginx Docker Abbilds im zentralen Docker Hub. Sinnvoll ist es auch, wenn du dort einen Account besitzt.

Starte deinen Browser und gehe zur Docker Hub-Website. Docker Hub ist die zentrale Anlaufstelle für die Suche und das Teilen von Docker-Images.
Nutze die Suchleiste auf der Docker Hub-Website und gebe „nginx“ ein.

Durchsuche die Ergebnisse, um das offizielle Nginx Docker Abbild zu finden. Das offizielle Image wird von der Nginx-Community gepflegt und ist in der Regel eine zuverlässige und aktuelle Quelle.

Ein Docker-Image kann verschiedene Tags haben, die verschiedene Versionen oder Konfigurationen repräsentieren. Wähle das gewünschte Tag basierend auf deinen Anforderungen aus. Zum Beispiel kann das Tag „latest“ die neueste stabile Version repräsentieren.

Nachdem du das passende Nginx-Image und Tag gefunden hast, kannst du das nginx docker image über die Kommandozeile herunterladen. Öffne dein Terminal oder die Kommandozeile und führe folgenden Befehl aus, um das Image herunterzuladen.

docker pull nginx:latest

Dieser Befehl fordert Docker auf, das Nginx-Image mit dem Tag „latest“ herunterzuladen. Docker wird automatisch alle erforderlichen Dateien und Abhängigkeiten herunterladen, um das Image auf deinem System verfügbar zu machen. Letztlich kannst du das Vorhandensein des Images prüfen.

docker images

Docker Container erstellen

Nun, da du das Nginx-Image erfolgreich heruntergeladen hast, ist es an der Zeit, einen Docker-Container zu erstellen und Nginx zum Laufen zu bringen. Um nginx Docker starten zu können, musst du noch einige Vorbereitungen treffen.

Als Erstes erstellst du einen neuen Ordner für das Nginx-Projekt. Dieser Ordner wird als Arbeitsverzeichnis für den Container dienen.

mkdir mein_nginx_projekt
cd mein_nginx_projekt

Um jetzt das nginx Docker Abbild starten zu können, benötigt man den Befehl run mit den folgenden Parametern.

docker run -d -p 80:80 --name mein_nginx_container nginx:latest
  • Der Parameter -d sorgt dafür, dass der Container im Hintergrund läuft.
  • Mit -p 80:80 wird der Port 80 des Hosts mit dem Port 80 des Containers verbunden, sodass du Nginx über http://localhost aufrufen kannst.
  • --name mein_nginx_container gibt dem Container den Namen „mein_nginx_container“. Du kannst hier jeden Namen verwenden, den du bevorzugst.
  • nginx:latest gibt das verwendete Image und das Tag an.

Den Status des Containers kannst du immer mit den Befehle „docker ps“ prüfen.

docker ps

Du solltest eine Liste der laufenden Container sehen, darunter auch deinen neu erstellten Nginx-Container.

Öffne deinen Webbrowser und besuche http://localhost. Du solltest die Standard-Nginx-Begrüßungsseite sehen, was darauf hinweist, dass Nginx erfolgreich in deinem Docker-Container läuft.

Grundlegende Nginx Konfiguration

Jetzt, da dein Nginx-Container erfolgreich läuft, wollen wir einen Blick auf die grundlegende Konfiguration werfen. Dies ermöglicht es dir, Nginx nach deinen Bedürfnissen anzupassen und einfache Anpassungen vorzunehmen.

Zugriff auf den Container-Bash:

Öffne dein Terminal und gib den folgenden Befehl ein, um Zugriff auf die Bash des Nginx-Containers zu erhalten:

docker exec -it mein_nginx_container /bin/bash

Dieser Befehl ermöglicht dir, interaktiv mit dem Container zu kommunizieren.

Navigiere zum Nginx-Konfigurationsverzeichnis:

Im Container navigiere zum Nginx-Konfigurationsverzeichnis mit dem Befehl. Grundsätzlich steckt im Nginx Docker ein Linux Betriebssystem. Sofern du noch nie mit Linux gearbeitet hast, solltest du dir die grundlegenden Terminal-Befehle näher ansehen. Für die Administration sind diese unerlässlich.

cd /etc/nginx

Hier findest du die Hauptkonfigurationsdatei nginx.conf sowie das Verzeichnis conf.d, in dem spezifischere Konfigurationen abgelegt werden können. Um jetzt die Konfigurationsdatei zu bearbeiten, musst du diese über einen Editor öffnen.

Standardmäßig ist dabei vi an Bord. Einfacher ist jedoch der nano Editor, welcher aber vorab noch im Container installiert werden muss. Daher empfehle ich dir auch diesen für das Arbeiten zu verwenden.

nano nginx.conf

Hier kannst du grundlegende Einstellungen wie Worker-Prozesse, Fehlerprotokolle und andere allgemeine Konfigurationsoptionen anpassen. Beachte jedoch, dass tiefgreifende Änderungen auch Fehlkonfigurationen zufolge haben können. Daher gehe mit bedacht vor.

Nginx ist so konzipiert, dass es Konfigurationsdateien aus dem Verzeichnis conf.d einliest. Diese Dateien sind einfacher zu verwalten und können spezifische Einstellungen für verschiedene Anwendungen enthalten. Bearbeite eine dieser Dateien, um benutzerdefinierte Einstellungen hinzuzufügen.

nano conf.d/meine_konfiguration.conf

Füge hier deine Anpassungen ein, wie die Konfiguration eines virtuellen Hosts. Anschließend ist ein Neustart des nginx Dienstes nötig.

service nginx restart

Alternativ kannst du den Container neu starten, um die Konfigurationsänderungen zu übernehmen:

docker restart mein_nginx_container

Einfache statische Inhalte bereitstellen

Jetzt, da dein Nginx-Container läuft und die grundlegende Konfiguration verstanden wurde, schauen wir uns an, wie du statische Inhalte, wie HTML-Seiten, CSS-Dateien und Bilder, in deinem Nginx-Container bereitstellen kannst.

Zuerst legst du einen Ordner in deinem Projektverzeichnis an, in dem du deine statischen Inhalte organisieren wirst.

mkdir statische_inhalte

Anschließend kopierst du dort deine statischen Dateien (HTML, CSS, Bilder) hinein. Hierfür reicht der einfache Copy-Befehl (cp) aus.

cp deine_dateien/* statische_inhalte/

Der nginx Dienst muss jetzt auch Wissen, wo die statischen Inhalte abgelegt sind. Daher musst du im nginx Docker den Standortblock, der auf deine statischen Inhalte zeigt, angeben.

nano /etc/nginx/conf.d/statische_inhalte.conf

Füge folgenden Code ein und ersetze dein_ordner durch den Namen des Ordners, den du zuvor erstellt hast:

server {
    listen 80;
    server_name localhost;

    location / {
        root   /usr/share/nginx/html;
        index  index.html index.htm;
    }

    location /dein_ordner/ {
        alias /pfad/zum/dein_ordner/;
    }

    error_page 500 502 503 504 /50x.html;
    location = /50x.html {
        root /usr/share/nginx/html;
    }
}

Speichere die Änderungen und schließe den Texteditor. Abschließend muss die Konfigurationsdatei wieder neu eingelesen werden, weshalb der nginx Dienst neu gestartet werden muss.

service nginx restart

Zu guter Letzt muss noch der nginx Docker Container neu gestartet werden.

docker restart mein_nginx_container

Ob die Einstellungen alle richtig gemacht wurden und auch funktionieren, lässt sich leicht im Browser überprüfen. Öffne deinen Webbrowser und besuche http://localhost/dein_ordner/. Du solltest nun deine statischen Inhalte erfolgreich dargestellt sehen.

Konfiguration für dynamische Anwendungen

Jetzt, da du statische Inhalte erfolgreich in deinem Nginx-Container bereitgestellt hast, wollen wir uns der Konfiguration für dynamische Anwendungen zuwenden. Dies ist besonders wichtig, wenn deine Anwendung serverseitige Logik oder APIs verwendet.

Häufig kommt dabei nginx php docker oder auch das clientseitige Javascript zum Einsatz.

Auch hier ist die erste Anlaufstelle wieder eine Konfigurationsdatei mit der Endung conf. Der Einfachheit halber nenne ich diese Datei „dynamsiche_anwendung.conf“.

nano /etc/nginx/conf.d/dynamische_anwendung.conf

Nehmen wir an, deine dynamische Anwendung ist ein Node.js-Server, der auf http://localhost:3000 läuft. Dann musst du den folgenden Code in deine Konfigurationsdatei hinzufügen.

server {
    listen 80;
    server_name localhost;

    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }

    error_page 500 502 503 504 /50x.html;
    location = /50x.html {
        root /usr/share/nginx/html;
    }
}

Dieser Code konfiguriert Nginx als Reverse Proxy für deinen Node.js-Server. Er passt auch die Header an, um sicherzustellen, dass WebSocket-Verbindungen ordnungsgemäß funktionieren.

Wie bereits bekannt, benötigt nginx wieder einen Neustart. Auch der nginx Docker kann neu gestartet werden.

service nginx restart
docker restart mein_nginx_container

Die Überprüfung erfolgt dabei wieder über den Webbrowser, indem du die Adresse http://localhost. Aufrufst. Nginx leitet jetzt Anfragen an deinen Node.js-Server weiter. Du solltest die Ausgabe deiner dynamischen Anwendung sehen.

Docker Compose verwenden (optional)

Die Verwendung von Docker Compose erleichtert die Orchestrierung von Containern und die Konfiguration mehrerer Dienste in einer einzigen Datei. Wer sich mit Docker beschäftigt, der sollte sich auch, Docker Compose ansehen. Das ist nämlich besonders nützlich, wenn du mehrere Container miteinander verknüpfen möchtest. Im Grunde erstellt du damit eine einzige Datei, welche alle Komponenten für Nginx beinhaltet.

Als Erstes erstellst du die Datei mit dem Namen docker-compose.yml. Am besten erstellst du diese Datei wieder in deinem Hauptverzeichnis, deines Projekts.

nano docker-compose.yml

Als Beispiel soll eine Docker Compose Datei mit Nginx und einer Node.js-Anwendung erstellt werden.

version: '3'

services:
  nginx:
    image: nginx:latest
    ports:
      - "80:80"
    volumes:
      - ./nginx-conf:/etc/nginx/conf.d
      - ./statische_inhalte:/usr/share/nginx/html
    depends_on:
      - nodejs

  nodejs:
    image: node:latest
    working_dir: /app
    volumes:
      - ./deine_nodejs_anwendung:/app
    command: npm start

Dieses Beispiel definiert zwei Dienste: nginx und nodejs. Der Nginx-Dienst dient als Reverse Proxy und statischer Dateiserver, während der nodejs-Dienst einen Node.js-Server startet. Beachte, dass die Pfade (./nginx-conf, ./statische_inhalte, ./deine_nodejs_anwendung) auf deine Projektstruktur angepasst werden müssen.

Jetzt muss die Docker Compose Datei noch ausgeführt werden. Das erreichst du über folgenden Befehl. Der Parameter „-d“ dient dazu, dass der Dienst im Hintergrund läuft.

docker-compose up -d

Im Webbrowser solltest du jetzt die Ausgabe deiner Node.js-Anwendung sehen, die durch den Nginx-Reverse-Proxy bereitgestellt wird. Der Aufruf erfolgt dabei wieder über http://localhost:80.

SSL-Zertifikate hinzufügen (optional)

Die Hinzufügung von SSL-Zertifikaten zu deinem Nginx-Container ist entscheidend, um eine sichere Kommunikation über das HTTPS-Protokoll zu ermöglichen. In der Regel benötigst du ein öffentliches Zertifikat.

So kannst du u.a. docker letsencrypt-nginx verwenden, ein Zertifikat, welche du von einer vertrauenswürdigen Zertifizierungsstelle (CA) erwerben kannst, oder aber für Testzwecke ein selbstsigniertes Zertifikate erstellen.

Du benötigst zwei Schlüssel, einen privaten Schlüssel (privkey.pem) und ein Zertifikat (fullchain.pem).

Erstelle wieder im Hauptverzeichnis deines Projekts einen Ordner für die SSL-Zertifikate:

mkdir ssl_zertifikate

Im nächste Schritt Kopiere die erhaltenen Zertifikate (privkey.pem und fullchain.pem) in den gerade erstellten Ordner:

cp pfad/zu/deinen/zertifikaten/* ssl_zertifikate/

Jetzt muss noch das Zertifikat für Nginx angepasst werden. Bearbeite die Nginx-Konfiguration, um SSL zu aktivieren und die Zertifikate.

nano /etc/nginx/conf.d/ssl_konfiguration.conf

Füge den folgenden Code ein:

server {
    listen 80;
    server_name localhost;

    # HTTP-Weiterleitung zu HTTPS
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl;
    server_name localhost;

    ssl_certificate /pfad/zu/deinem/projekt/ssl_zertifikate/fullchain.pem;
    ssl_certificate_key /pfad/zu/deinem/projekt/ssl_zertifikate/privkey.pem;

    # SSL-Konfigurationseinstellungen hier hinzufügen

    location / {
        proxy_pass http://localhost:3000;  # Passe dies an deine Anwendung an
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }

    error_page 500 502 503 504 /50x.html;
    location = /50x.html {
        root /usr/share/nginx/html;
    }
}

Ersetze /pfad/zu/deinem/projekt durch den tatsächlichen Pfad zu deinem Projekt. Passe auch die proxy_pass-Zeile an, um deine Anwendung zu reflektieren.

Nachdem speichern der Änderungen an der Konfigurationsdatei starte Nginx im Container neu. Auch ein kompletter Neustart des Containers wäre ebenso möglich.

service nginx restart
docker restart mein_nginx_container

Öffne deinen Webbrowser und besuche https://localhost. Du solltest nun eine sichere Verbindung mit deinem Nginx-Server herstellen können. Erkennbar ist die sichere Verbindung am https Protokoll.

Fazit zu nginx unter Docker

Die Integration von Nginx und Docker ermöglicht eine effiziente Bereitstellung von Webanwendungen in verschiedenen Umgebungen. Durch die Nutzung von Containern kannst du sicherstellen, dass deine Anwendung konsistent und isoliert ausgeführt wird.

Experimentiere weiter mit den Konfigurationsoptionen von Nginx, um die volle Bandbreite seiner Funktionen zu entdecken. Viel Spaß beim Entwickeln und Bereitstellen! Docker sowie Nginx sind eine hervorragende Möglichkeit um local mit Anwendung zu arbeiten.

Dieser Artikel beinhaltet Partner-Links. Durch einen Klick darauf ge­lan­gt ihr direkt zum Anbieter. Solltet ihr euch dort für einen Kauf entscheiden, erhält IT-Learner eine kleine Provision. Der Preis ändert sich für euch nicht. Danke für eure Unterstützung! Letzte Aktualisierung am 14.02.2024

7dfa536eef774cf08d227ba39d27ef5d
Der Blogbetreiber und Autor: Markus Elsberger

Über den Autor

Mein Name ist Markus Elsberger und ich beschäftige mich mit der Administration von Windows und Linux Systemen sowie mit diversen Themen bzgl. Netzwerktechnik. In meiner Lehrtätigkeit erstelle ich verschiedene Szenarien und teste auch verschiedene Konfigurationen, welche ich in diesem Blog festhalten möchte.


Kostenlose Befehlsreferenzen und E-Books
(Netzwerkanalyse, Benutzerverwaltung, Festplattenkonfiguration, u. v. m.)


Nach oben scrollen
×