Skip to main content

NGINX Reverse Proxy: Der vollständige Leitfaden

Dieser Artikel ist eine Übersetzung des englischen Originals.


Ein NGINX Reverse Proxy befindet sich zwischen Clients und Ihren Backend-Servern, leitet Client-Anfragen weiter und gibt Antworten zurück. Diese Architektur verbessert die Sicherheit, ermöglicht Load-Balancing und bietet SSL-Terminierung in einer einzigen, leistungsstarken Schicht.

Dieser Leitfaden deckt alles ab, was Sie benötigen, um NGINX als Reverse Proxy zu konfigurieren – von grundlegenden proxy_pass-Direktiven bis hin zu fortgeschrittenem Load-Balancing, WebSocket-Unterstützung und der Fehlerbehebung häufiger Fehler wie 502 Bad Gateway und 504 Gateway Timeout.

Was ist ein Reverse Proxy?

Ein Reverse Proxy empfängt Anfragen von Clients und leitet sie an einen oder mehrere Backend-Server weiter. Anders als ein Forward Proxy (den Clients nutzen, um auf externe Ressourcen zuzugreifen) verbirgt ein Reverse Proxy Ihre Backend-Infrastruktur vor der Außenwelt.

Die Vorteile der Nutzung von NGINX als Reverse Proxy:

  • Load-Balancing über mehrere Backend-Server
  • SSL/TLS-Terminierung zur Auslagerung der Verschlüsselung von den Backends
  • Caching zur Reduzierung der Backend-Last
  • Komprimierung zur Minimierung der Bandbreite
  • Sicherheit durch das Verbergen von Backend-Server-Details
  • Zentralisiertes Logging und Monitoring

NGINX ist aufgrund seiner ereignisgesteuerten Architektur, seines geringen Speicherbedarfs und seiner Fähigkeit, Tausende gleichzeitiger Verbindungen effizient zu verarbeiten, die beliebteste Wahl für Reverse-Proxy-Bereitstellungen.

NGINX installieren

Auf RHEL-basierten Distributionen (Rocky Linux, AlmaLinux, CentOS Stream):

dnf install nginx
systemctl enable --now nginx

Auf Debian/Ubuntu:

apt install nginx
systemctl enable --now nginx

Grundlegende proxy_pass-Konfiguration

Die Direktive proxy_pass ist die Grundlage der NGINX Reverse-Proxy-Konfiguration. Sie teilt NGINX mit, wohin eingehende Anfragen weitergeleitet werden sollen. Vollständige Syntaxdetails finden Sie in der offiziellen NGINX proxy_pass-Dokumentation.

Minimale Konfiguration

Erstellen Sie eine Konfigurationsdatei in /etc/nginx/conf.d/:

server {
    listen 80;
    server_name example.com;

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

Diese NGINX Reverse-Proxy-Konfiguration leitet alle Anfragen an ein Backend weiter, das auf Port 3000 läuft.

Das Verständnis der URI-Behandlung

Der abschließende Schrägstrich in proxy_pass ist von großer Bedeutung. Eine vollständige Erklärung aller Sonderfälle finden Sie in unserem speziellen GNINX proxy_pass-Leitfaden zum abschließenden Schrägstrich:

# Request: /api/users
# Backend receives: /api/users
location /api/ {
    proxy_pass http://backend;
}

# Request: /api/users  
# Backend receives: /users (path stripped)
location /api/ {
    proxy_pass http://backend/;
}

Wenn proxy_pass eine URI enthält (auch nur /), ersetzt NGINX den übereinstimmenden Location-Block durch die angegebene URI. Ohne URI wird der vollständige ursprüngliche Pfad unverändert weitergegeben.

Für fortgeschrittenere Szenarien, in denen das Proxy-Ziel selbst dynamisch ist (aus der Anfrage-URL extrahiert), lesen Sie unseren Leitfaden zum Proxying von Anfragen an jeden beliebigen Remote-Server mithilfe von Regex-Captures.

Wesentliche Proxy-Header

Backend-Anwendungen benötigen häufig Client-Informationen, die im Proxy-Prozess verloren gehen. Konfigurieren Sie diese Header, um kritische Daten durch Ihren NGINX Reverse Proxy weiterzugeben:

server {
    listen 80;
    server_name example.com;

    location / {
        proxy_pass http://127.0.0.1:3000;

        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-Host $host;
        proxy_set_header X-Forwarded-Port $server_port;
    }
}

Erläuterungen zu den Headern

Header Zweck
Host Ursprünglicher Host, der vom Client angefordert wurde
X-Real-IP Tatsächliche IP-Adresse des Clients
X-Forwarded-For Kette der Proxy-IPs einschließlich des Clients
X-Forwarded-Proto Ursprüngliches Protokoll (http oder https)
X-Forwarded-Host Ursprünglicher Host-Header
X-Forwarded-Port Ursprüngliche Portnummer

Die Variable $proxy_add_x_forwarded_for hängt die Client-IP an einen vorhandenen X-Forwarded-For-Header an und erhält so die vollständige Proxy-Kette.

Upstream-Blöcke für Load-Balancing

Definieren Sie für mehrere Backend-Server einen upstream-Block. Hier zeigt der NGINX Reverse Proxy seine wahre Stärke für Hochverfügbarkeitsarchitekturen:

upstream backend_servers {
    server 192.168.1.10:3000;
    server 192.168.1.11:3000;
    server 192.168.1.12:3000;
}

server {
    listen 80;
    server_name example.com;

    location / {
        proxy_pass http://backend_servers;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

Lastverteilungsmethoden

NGINX bietet mehrere Lastverteilungsalgorithmen:

Round Robin (Standard):

upstream backend {
    server 192.168.1.10:3000;
    server 192.168.1.11:3000;
}

Least Connections:

upstream backend {
    least_conn;
    server 192.168.1.10:3000;
    server 192.168.1.11:3000;
}

IP-Hash (Sitzungspersistenz):

upstream backend {
    ip_hash;
    server 192.168.1.10:3000;
    server 192.168.1.11:3000;
}

Gewichtete Verteilung:

upstream backend {
    server 192.168.1.10:3000 weight=5;
    server 192.168.1.11:3000 weight=3;
    server 192.168.1.12:3000 weight=1;
}

Serverseitige Parameter

Konfigurieren Sie das Serververhalten mit diesen Parametern:

upstream backend {
    server 192.168.1.10:3000 weight=5 max_fails=3 fail_timeout=30s;
    server 192.168.1.11:3000 weight=3;
    server 192.168.1.12:3000 backup;
    server 192.168.1.13:3000 down;
}
Parameter Beschreibung
weight=N Gewicht des Servers für die Lastverteilung (Standard: 1)
max_fails=N Fehlgeschlagene Versuche, bevor der Server als nicht verfügbar markiert wird (Standard: 1)
fail_timeout=Ns Zeit, die der Server nach max_fails nicht verfügbar bleibt (Standard: 10s)
backup Wird nur verwendet, wenn die primären Server nicht verfügbar sind
down Markiert den Server dauerhaft als nicht verfügbar

Keepalive für Verbindungen

Aktivieren Sie HTTP-Keepalive-Verbindungen zu Backends für eine bessere Leistung:

upstream backend {
    server 192.168.1.10:3000;
    server 192.168.1.11:3000;

    keepalive 32;
    keepalive_requests 1000;
    keepalive_timeout 60s;
}

server {
    listen 80;
    server_name example.com;

    location / {
        proxy_pass http://backend;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        proxy_set_header Host $host;
    }
}

Kritisch: Wenn Sie keepalive verwenden, müssen Sie proxy_http_version 1.1 setzen und den Header Connection leeren. HTTP/1.0 schließt Verbindungen standardmäßig, wodurch Keepalive zunichtegemacht wird.

Die Direktive keepalive 32 hält bis zu 32 Leerlaufverbindungen pro Worker-Prozess aufrecht. Dadurch entfällt der Aufwand für den Verbindungsaufbau bei nachfolgenden Anfragen.

Pufferungskonfiguration

NGINX puffert Antworten von Backends, bevor sie an Clients gesendet werden. Dadurch werden Backend-Server schnell wieder freigegeben, während Ihr NGINX-Reverse-Proxy langsame Client-Verbindungen verarbeitet.

location / {
    proxy_pass http://backend;

    proxy_buffering on;
    proxy_buffer_size 4k;
    proxy_buffers 8 4k;
    proxy_busy_buffers_size 8k;
    proxy_max_temp_file_size 1024m;
}

Referenz zu Puffer-Direktiven

Direktive Standard Zweck
proxy_buffering on Antwortpufferung aktivieren/deaktivieren
proxy_buffer_size 4k/8k Puffer für Antwort-Header
proxy_buffers 8 4k/8k Anzahl und Größe der Puffer für den Antwort-Body
proxy_busy_buffers_size 8k/16k Maximale Größe, die an den Client gesendet wird, während die Pufferung fortgesetzt wird
proxy_max_temp_file_size 1024m Maximale Größe der temporären Datei bei Pufferüberlauf

Wann die Pufferung deaktiviert werden sollte

Deaktivieren Sie die Pufferung für Streaming-Antworten oder Server-Sent Events:

location /stream/ {
    proxy_pass http://backend;
    proxy_buffering off;
    proxy_cache off;
}

Bei deaktivierter Pufferung leitet NGINX Daten sofort weiter, was die Time To First Byte (TTFB) für Streaming-Inhalte verbessert.

Timeout-Konfiguration

Konfigurieren Sie Timeouts, um langsame Backends zu behandeln und hängende Verbindungen zu verhindern:

location / {
    proxy_pass http://backend;

    proxy_connect_timeout 10s;
    proxy_send_timeout 60s;
    proxy_read_timeout 60s;
}

Aufschlüsselung der Timeouts

Direktive Standard Zweck
proxy_connect_timeout 60s Zeit zum Aufbau einer Verbindung mit dem Backend
proxy_send_timeout 60s Zeit zwischen aufeinanderfolgenden Schreibvorgängen an das Backend
proxy_read_timeout 60s Zeit zwischen aufeinanderfolgenden Lesevorgängen vom Backend

Wichtig: Diese Timeouts messen die Zeit zwischen Vorgängen, nicht die Gesamtanfragezeit. Eine Antwort, die in Teilen eintrifft, setzt den Lese-Timeout bei jedem Teil zurück.

Für langlaufende Anfragen (Datei-Uploads, Berichterstellung) erhöhen Sie proxy_read_timeout:

location /api/reports/ {
    proxy_pass http://backend;
    proxy_read_timeout 300s;
}

SSL/TLS-Terminierung

Behandeln Sie HTTPS auf der Proxy-Ebene, während Sie mit Backends über HTTP kommunizieren:

server {
    listen 443 ssl;
    server_name example.com;

ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256;
    ssl_prefer_server_ciphers off;

    location / {
        proxy_pass http://127.0.0.1:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

server {
    listen 80;
    server_name example.com;
    return 301 https://$host$request_uri;
}

Proxying zu HTTPS-Backends

Wenn Backends HTTPS erfordern:

location / {
    proxy_pass https://backend:443;
    proxy_ssl_verify on;
    proxy_ssl_trusted_certificate /etc/ssl/certs/ca-certificates.crt;
    proxy_ssl_server_name on;
}

Mehrere Dienste auf demselben Port

Für fortgeschrittene Szenarien, in denen Sie verschiedene Protokolle (SSH, MTProxy, HTTPS) über denselben Port routen müssen, kann das stream-Modul von NGINX mit SSL-Preread-Funktionen TLS-Handshakes prüfen, bevor geroutet wird. Weitere Informationen zur Verwendung von ALPN-Protokollen und SNI-basiertem Routing finden Sie in unserer Anleitung mehrere Dienste auf demselben Port.

WebSocket-Proxying

WebSocket-Verbindungen erfordern eine besondere Behandlung, da sie von HTTP aus ein Upgrade durchführen. Der NGINX-Reverse-Proxy muss die Upgrade-Header korrekt weitergeben:

map $http_upgrade $connection_upgrade {
    default upgrade;
    ""      close;
}

server {
    listen 80;
    server_name example.com;

    location /ws/ {
        proxy_pass http://127.0.0.1:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_read_timeout 86400s;
        proxy_send_timeout 86400s;
    }
}

Die Direktive map setzt Connection: upgrade, wenn der Client einen Upgrade-Header sendet, andernfalls Connection: close.

Erhöhen Sie die Timeouts für WebSockets deutlich, da Verbindungen unbegrenzt offen bleiben.

Praxisnahe Backend-Beispiele

Node.js-Anwendung

upstream nodejs_app {
    server 127.0.0.1:3000;
    keepalive 64;
}

server {
    listen 80;
    server_name app.example.com;

    location / {
        proxy_pass http://nodejs_app;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        proxy_read_timeout 60s;
        proxy_buffering on;
    }

    location /socket.io/ {
        proxy_pass http://nodejs_app;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_read_timeout 86400s;
    }
}

Python mit Gunicorn

upstream gunicorn_app {
    server unix:/run/gunicorn/app.sock;
    keepalive 32;
}

server {
    listen 80;
    server_name api.example.com;

    location / {
        proxy_pass http://gunicorn_app;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Script-Name "";

        proxy_redirect off;
    }

    location /static/ {
        alias /var/www/app/static/;
        expires 30d;
    }
}

Java-Anwendung (Tomcat/Spring Boot)

upstream java_app {
    server 127.0.0.1:8080;
    server 127.0.0.1:8081;
    keepalive 64;
}

server {
    listen 80;
    server_name java.example.com;

    client_max_body_size 50m;

    location / {
        proxy_pass http://java_app;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        proxy_connect_timeout 10s;
        proxy_read_timeout 120s;

        proxy_buffer_size 8k;
        proxy_buffers 16 8k;
    }
}

Failover und Hochverfügbarkeit

Konfigurieren Sie automatisches Failover auf fehlerfreie Backends:

upstream backend {
    server 192.168.1.10:3000 max_fails=3 fail_timeout=30s;
    server 192.168.1.11:3000 max_fails=3 fail_timeout=30s;
    server 192.168.1.12:3000 backup;
}

server {
    listen 80;
    server_name example.com;

    location / {
        proxy_pass http://backend;
        proxy_next_upstream error timeout http_502 http_503 http_504;
        proxy_next_upstream_tries 3;
        proxy_next_upstream_timeout 30s;

        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

Die Direktive proxy_next_upstream steuert, welche Fehler ein Failover auf den nächsten Server auslösen. Für Szenarien, in denen Sie Anfragen basierend auf Variablen oder Bedingungen an völlig andere server-Blöcke weiterleiten müssen, anstatt nur durch Upstreams zu rotieren, siehe das NGINX-Server-Redirect-Modul. Verfügbare Optionen:

  • Fehler: Verbindungsfehler
  • Zeitüberschreitung: Verbindungs- oder Lese-Zeitüberschreitung
  • http_502: Backend hat 502 zurückgegeben
  • http_503: Backend hat 503 zurückgegeben
  • http_504: Backend hat 504 zurückgegeben
  • http_500: Backend hat 500 zurückgegeben
  • http_403: Backend hat 403 zurückgegeben
  • http_404: Backend hat 404 zurückgegeben
  • non_idempotent: Nicht-idempotente Anfragen wiederholen (POST, PATCH)

Dynamische Backends und erweitertes Upstream-Management

Jeder bisher gezeigte upstream-Block geht davon aus, dass Ihre Backend-Adressen beim Start von NGINX feststehen und bekannt sind. In containerisierten, automatisch skalierten oder Cloud-Deployments bricht diese Annahme zusammen: Backends werden bei Bedarf erstellt und zerstört, und ihre DNS-Einträge ändern sich, während NGINX weiterläuft. Das Standard-NGINX hat hier drei seit Langem bestehende Einschränkungen, die historisch jeweils dem kommerziellen Produkt NGINX Plus vorbehalten waren:

  • Upstream-DNS wird einmalig beim Start aufgelöst. NGINX löst jeden server-Hostnamen auf, wenn es die Konfiguration lädt, und speichert das Ergebnis für die Lebensdauer dieser Konfiguration im Cache. Wenn sich der Eintrag ändert, fließt der Datenverkehr weiterhin zur alten IP-Adresse, bis Sie nginx -s reload ausführen.
  • Health Checks sind nur passiv. Die Parameter max_fails und fail_timeout reagieren erst, nachdem echte Benutzeranfragen bereits fehlgeschlagen sind. Das Standard-NGINX kann ein Backend nicht proaktiv prüfen und aus der Rotation nehmen, bevor ein Client betroffen ist.
  • Die Upstream-Liste ist statisch. Das Hinzufügen oder Entfernen eines Backends erfordert das Bearbeiten der Konfigurationsdatei und ein Reload. Es gibt keine Laufzeit-API, um den Pool zu ändern, während NGINX Datenverkehr bedient.

Das GetPageSpeed-Repository schließt alle drei Lücken bei Open-Source-NGINX, ohne ein NGINX-Plus-Abonnement.

Aktive Health Checks und eine Laufzeit-Upstream-API

Passive Health Checks sind von Natur aus reaktiv. Für proaktive Health Checks, bei denen NGINX jedes Backend nach einem Zeitplan abfragt und ein ungesundes entfernt, bevor ein Client es erreicht, sowie für eine Laufzeit-API, die Backends ohne Reload hinzufügt oder ausblendet, verwenden Sie NGINX-MOD. Es ist ein Drop-in-Ersatz für das Standard-Paket nginx, das Upstream-Management auf NGINX-Plus-Niveau in Open-Source-NGINX bringt. Siehe die speziellen Anleitungen für aktive Health Checks und die Dynamic-Upstream-API.

Erneutes Auflösen von Backend-DNS zur Laufzeit

Für Backends, deren IP-Adressen sich hinter einem stabilen Hostnamen ändern, muss NGINX DNS im laufenden Betrieb erneut auflösen. Auf NGINX 1.28 und neuer verwenden Sie den nativen Parameter resolve zusammen mit einer zone und einem resolver:

http {
    upstream backend {
        zone backend 64k;
        server api.example.com:8080 resolve;
    }

    resolver 8.8.8.8 valid=30s;
}

Siehe NGINX upstream resolve für die vollständige Anleitung.

Viele Produktionssysteme laufen noch mit älteren NGINX-Versionen, beispielsweise den mit RHEL 8 und RHEL 9 ausgelieferten Versionen, bei denen der native Parameter nicht verfügbar ist. Dort installieren Sie das Modul nginx-module-upstream-jdomain aus dem GetPageSpeed-Repository:

sudo dnf install https://extras.getpagespeed.com/release-latest.rpm
sudo dnf install nginx-module-upstream-jdomain

Laden Sie das Modul und verwenden Sie die Direktive jdomain anstelle von server innerhalb des upstream-Blocks:

load_module modules/ngx_http_upstream_jdomain_module.so;

http {
    resolver 8.8.8.8;

    upstream backend {
        jdomain api.example.com port=8080 interval=30;
    }

    server {
        listen 80;
        location / {
            proxy_pass http://backend;
            proxy_set_header Host api.example.com;
        }
    }
}

Das Modul löst die Domain im Hintergrund auf, während Anfragen eintreffen, ohne dass ein Reload erforderlich ist. Siehe NGINX upstream jdomain für alle Parameter.

Fehlerbehebung bei häufigen Fehlern

502 Bad Gateway

Ein 502-Fehler bedeutet, dass NGINX eine ungültige Antwort vom Backend erhalten hat oder die Verbindung fehlgeschlagen ist.

Häufige Ursachen:

  1. Backend läuft nicht
    systemctl status your-app
    curl -v http://127.0.0.1:3000/
    
  2. Falscher Port oder Socket-Pfad
    ss -tlnp | grep 3000
    ls -la /run/gunicorn/app.sock
    
  3. Firewall blockiert die Verbindung
    firewall-cmd --list-all
    
  4. Antwort-Header zu groß

    Prüfen Sie das Fehlerprotokoll auf “upstream sent too big header”:

    tail -f /var/log/nginx/error.log
    

    Vergrößern Sie die Puffergröße:

    proxy_buffer_size 8k;
    proxy_buffers 16 8k;
    
  5. SELinux blockiert die Netzwerkverbindung
    setsebool -P httpd_can_network_connect 1
    

504 Gateway Timeout

Ein 504-Fehler tritt auf, wenn das Backend zu lange für die Antwort benötigt.

Lösungen:

  1. Lese-Zeitüberschreitung erhöhen
    proxy_read_timeout 300s;
    
  2. Backend-Leistung prüfen
    time curl http://127.0.0.1:3000/slow-endpoint
    
  3. Lang laufende Vorgänge optimieren

    Erwägen Sie, sofort mit einer Job-ID zurückzukehren und einen Status-Endpunkt bereitzustellen.

Connection Refused

Prüfen Sie, ob das Backend an der erwarteten Adresse und dem erwarteten Port lauscht:

ss -tlnp | grep LISTEN
curl -v http://127.0.0.1:3000/

Wenn Sie Unix-Sockets verwenden, überprüfen Sie die Berechtigungen:

ls -la /run/gunicorn/app.sock
# Should be readable by nginx user
chmod 660 /run/gunicorn/app.sock
chown nginx:nginx /run/gunicorn/app.sock

Debugging Tips

Aktivieren Sie detaillierte Fehlerprotokollierung:

error_log /var/log/nginx/error.log debug;

Zeigen Sie den Upstream-Status mit stub_status an:

location /nginx_status {
    stub_status;
    allow 127.0.0.1;
    deny all;
}

Prüfen Sie die Konfigurationssyntax:

nginx -t
nginx -T | grep proxy

Security Best Practices

Hide Backend Server Information

proxy_hide_header X-Powered-By;
proxy_hide_header Server;
proxy_hide_header X-AspNet-Version;

proxy_pass_header Date;

Rate Limiting

limit_req_zone $binary_remote_addr zone=api:10m rate=10r/s;

server {
    location /api/ {
        limit_req zone=api burst=20 nodelay;
        proxy_pass http://backend;
    }
}

Request Size Limits

client_max_body_size 10m;
client_body_buffer_size 128k;

Restrict Access

location /admin/ {
    allow 10.0.0.0/8;
    allow 192.168.1.0/24;
    deny all;

    proxy_pass http://backend;
}

Performance Optimization

Compression

gzip on;
gzip_vary on;
gzip_proxied any;
gzip_comp_level 6;
gzip_types text/plain text/css application/json application/javascript text/xml application/xml;

Caching

proxy_cache_path /var/cache/nginx levels=1:2 keys_zone=cache:10m max_size=1g inactive=60m;

server {
    location / {
        proxy_cache cache;
        proxy_cache_valid 200 60m;
        proxy_cache_valid 404 1m;
        proxy_cache_use_stale error timeout updating http_502 http_503 http_504;
        proxy_cache_lock on;

        add_header X-Cache-Status $upstream_cache_status;

        proxy_pass http://backend;
    }
}

Connection Pooling

upstream backend {
    server 127.0.0.1:3000;
    keepalive 64;
    keepalive_requests 10000;
    keepalive_timeout 60s;
}

Complete Production Configuration

Hier ist eine vollständige, produktionsbereite NGINX-Reverse-Proxy-Konfiguration:

upstream app_backend {
    least_conn;
    server 192.168.1.10:3000 weight=5 max_fails=3 fail_timeout=30s;
    server 192.168.1.11:3000 weight=3 max_fails=3 fail_timeout=30s;
    server 192.168.1.12:3000 backup;

    keepalive 64;
    keepalive_requests 10000;
    keepalive_timeout 60s;
}

server {
    listen 80;
    server_name example.com www.example.com;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl http2;
    server_name example.com www.example.com;

    ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256;
    ssl_prefer_server_ciphers off;
    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 1d;

    client_max_body_size 50m;
    client_body_buffer_size 128k;

    gzip on;
    gzip_vary on;
    gzip_proxied any;
    gzip_comp_level 6;
    gzip_types text/plain text/css application/json application/javascript text/xml application/xml;

    location / {
        proxy_pass http://app_backend;
        proxy_http_version 1.1;
        proxy_set_header Connection "";

        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-Host $host;
        proxy_set_header X-Forwarded-Port $server_port;

        proxy_buffering on;
        proxy_buffer_size 8k;
        proxy_buffers 16 8k;
        proxy_busy_buffers_size 16k;

        proxy_connect_timeout 10s;
        proxy_send_timeout 60s;
        proxy_read_timeout 60s;

        proxy_next_upstream error timeout http_502 http_503 http_504;
        proxy_next_upstream_tries 3;
        proxy_next_upstream_timeout 30s;

        proxy_hide_header X-Powered-By;
    }

    location /health {
        access_log off;
        return 200 "healthyn";
        add_header Content-Type text/plain;
    }
}

Summary

Die Konfiguration von NGINX als Reverse Proxy umfasst das Verständnis mehrerer Schlüsselbereiche:

  • proxy_pass leitet Anfragen an Backend-Server weiter
  • upstream blocks ermöglichen Lastverteilung über mehrere Server
  • Headers übergeben Client-Informationen an Backends
  • Buffering verbessert die Leistung, indem Backends schnell freigegeben werden
  • Timeouts verhindern hängende Verbindungen und behandeln langsame Backends
  • Keepalive reduziert den Verbindungsaufwand für bessere Leistung
  • Failover gewährleistet Hochverfügbarkeit, wenn Backends ausfallen

Beginnen Sie mit einer Basiskonfiguration und fügen Sie bei Bedarf Komplexität hinzu. Testen Sie Konfigurationsänderungen immer mit nginx -t, bevor Sie neu laden, und überwachen Sie Ihre Fehlerprotokolle bei der Fehlersuche.

Für weiterführende Themen lesen Sie unsere Anleitungen zu tuning proxy_buffer_size und fixing 504 Gateway Timeout errors.

Routing today is security tomorrow. Ein falsch angeordneter location-Block oder ein Regex, der an der falschen Stelle greift, wird zum offenen Pfad. GetPageSpeed Amplify führt geplante gixy-Scans auf jedem Host aus und verknüpft die Ergebnisse mit Live-Laufzeitmetriken von NGINX. Drop-in-kompatibel mit dem veralteten nginx-amplify-agent (EOL Januar 2026).