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: VerbindungsfehlerZeitüberschreitung: Verbindungs- oder Lese-Zeitüberschreitunghttp_502: Backend hat 502 zurückgegebenhttp_503: Backend hat 503 zurückgegebenhttp_504: Backend hat 504 zurückgegebenhttp_500: Backend hat 500 zurückgegebenhttp_403: Backend hat 403 zurückgegebenhttp_404: Backend hat 404 zurückgegebennon_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 Sienginx -s reloadausführen. - Health Checks sind nur passiv. Die Parameter
max_failsundfail_timeoutreagieren 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:
- Backend läuft nicht
systemctl status your-app curl -v http://127.0.0.1:3000/ - Falscher Port oder Socket-Pfad
ss -tlnp | grep 3000 ls -la /run/gunicorn/app.sock - Firewall blockiert die Verbindung
firewall-cmd --list-all - Antwort-Header zu groß
Prüfen Sie das Fehlerprotokoll auf “upstream sent too big header”:
tail -f /var/log/nginx/error.logVergrößern Sie die Puffergröße:
proxy_buffer_size 8k; proxy_buffers 16 8k; - 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:
- Lese-Zeitüberschreitung erhöhen
proxy_read_timeout 300s; - Backend-Leistung prüfen
time curl http://127.0.0.1:3000/slow-endpoint - 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).