Nginx als Proxy-Server

Nginx fungiert als Hochleistungs-Proxy-Server, indem es Client-Anfragen effizient an Backend-Server weiterleitet und deren Antworten zurückgibt, wodurch Funktionen wie Lastverteilung (Load Balancing), SSL-Terminierung und Inhalts-Caching ermöglicht werden.

Einführung

Nginx (Engine-X) ist ein Open-Source-Webserver, der auch als Reverse-Proxy, HTTP-Cache und Lastverteiler fungieren kann. Seine ereignisgesteuerte Architektur ermöglicht es ihm, eine große Anzahl gleichzeitiger Verbindungen effizient zu verarbeiten, wodurch er sich für Umgebungen mit hohem Datenverkehr eignet. Als Proxy sitzt Nginx zwischen Clients und Backend-Servern, vermittelt den Datenverkehr und fügt Funktionsebenen hinzu.

Warum Nginx als Proxy verwenden?

Der Einsatz von Nginx als Proxy-Server bietet mehrere betriebliche Vorteile:

• Lastverteilung (Load Balancing): Verteilt den eingehenden Netzwerkverkehr auf mehrere Backend-Server, um die Reaktionsfähigkeit und Zuverlässigkeit der Anwendung zu verbessern.
• SSL/TLS-Terminierung: Verwaltet verschlüsselte Verbindungen von Clients, entschlüsselt den Datenverkehr, bevor er an Backend-Server weitergeleitet wird, die dann mit unverschlüsseltem HTTP arbeiten können. Dies entlastet die Anwendungsserver von kryptografischen Prozessen.
• Caching: Speichert häufig aufgerufene Inhalte, reduziert die Last auf den Backend-Servern und verkürzt die Antwortzeiten für Clients.
• Sicherheit: Fungiert als Puffer, der Backend-Server vor direktem Client-Zugriff und potenziellen Angriffen schützt. Es kann Anfragen filtern und Zugriffsrichtlinien durchsetzen.
• Hohe Verfügbarkeit: In Verbindung mit der Lastverteilung kann Nginx den Datenverkehr von fehlerhaften Backend-Servern wegleiten und so einen kontinuierlichen Dienst gewährleisten.
• Datenverkehrsmanagement: Ermöglicht URL-Rewriting, Anfragenfilterung und Inhaltsmanipulation.

Nginx-Proxy-Typen

Nginx arbeitet hauptsächlich in zwei Proxy-Modi: Reverse-Proxy und Forward-Proxy.

Reverse-Proxy

Ein Reverse-Proxy ruft Ressourcen im Auftrag eines Clients von einem oder mehreren Servern ab. Diese Ressourcen werden dann an den Client zurückgegeben, wobei es so aussieht, als ob sie vom Proxy-Server selbst stammen würden. Clients sind sich der Backend-Architektur nicht bewusst.

Forward-Proxy

Ein Forward-Proxy ruft Ressourcen von einer Vielzahl von Servern im Auftrag eines Clients ab. Er fungiert als Vermittler für Clients, die Ressourcen von externen Servern anfordern. Clients sind explizit für die Nutzung des Forward-Proxys konfiguriert.

Grundlegende Reverse-Proxy-Konfiguration

Die Konfiguration von Nginx als Reverse-Proxy beinhaltet die Definition eines server-Blocks, der auf eingehende Anfragen lauscht und dann die proxy_pass-Direktive verwendet, um diese an einen Upstream-Server weiterzuleiten.

Voraussetzungen

• Eine installierte Nginx-Instanz.
• Zugriff auf Nginx-Konfigurationsdateien (typischerweise /etc/nginx/nginx.conf oder Dateien innerhalb von /etc/nginx/sites-available/).
• Ein Backend-Server (z.B. ein Anwendungsserver, ein anderer Webserver), der läuft und für den Nginx-Server zugänglich ist.

Kern-Konfigurationsdirektiven

• proxy_pass: Die grundlegende Direktive zum Weiterleiten von Anfragen. Gibt das Protokoll, die Adresse und den optionalen Port des proxiierten Servers an.
• proxy_set_header: Modifiziert Anfrage-Header, die Nginx an den proxiierten Server sendet. Wesentlich für die Weitergabe von Client-IP, Host- und Protokollinformationen.
• proxy_buffering: Steuert, ob Nginx Antworten vom proxiierten Server puffert. Pufferung kann die Leistung verbessern, indem Nginx die gesamte Antwort empfangen kann, bevor sie an den Client gesendet wird.
• proxy_cache: Aktiviert das Caching von Antworten von proxiierten Servern.

# /etc/nginx/sites-available/my_reverse_proxy.conf

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

    location / {
        # Der Ziel-Backend-Server
        proxy_pass http://backend_app_server:8080;

        # Ursprünglichen Host und IP an das Backend weitergeben
        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-Pufferung für Streaming deaktivieren, für traditionelles Web aktivieren
        # proxy_buffering on; 
    }

    # Optional: Statische Dateien direkt von Nginx ausliefern
    location /static/ {
        root /var/www/my_app;
        expires 30d;
    }
}

Nachdem Sie diese Datei erstellt haben, aktivieren Sie sie, indem Sie einen symbolischen Link zu sites-enabled erstellen:
sudo ln -s /etc/nginx/sites-available/my_reverse_proxy.conf /etc/nginx/sites-enabled/
Testen Sie dann die Nginx-Konfiguration und laden Sie sie neu:
sudo nginx -t
sudo systemctl reload nginx

Erweiterte Reverse-Proxy-Konfiguration

Lastverteilung (Load Balancing)

Nginx kann Anfragen mithilfe verschiedener Lastverteilungsalgorithmen auf mehrere Backend-Server verteilen. Der upstream-Block definiert eine Gruppe von Servern.

# In nginx.conf oder einer separaten Datei, die vom http-Block eingebunden wird

upstream backend_servers {
    # Round-Robin (Standard)
    server backend_server1.example.com:8080;
    server backend_server2.example.com:8080;
    server 192.168.1.100:8080; # Kann IP-Adressen verwenden

    # Gewichtiges Round-Robin
    # server backend_server1.example.com:8080 weight=3;
    # server backend_server2.example.com:8080 weight=1;

    # Wenigste Verbindungen
    # least_conn;

    # IP Hash (Sticky Sessions basierend auf Client-IP)
    # ip_hash;

    # Health Checks (erfordert Nginx Plus oder spezifische Module)
    # server backend_server1.example.com:8080 max_fails=3 fail_timeout=30s;
}

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

    location / {
        proxy_pass http://backend_servers; # Referenziert den upstream-Block
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

SSL/TLS-Terminierung

Nginx kann SSL/TLS-Verbindungen terminieren und so den Verschlüsselungs-/Entschlüsselungsprozess von den Backend-Servern entlasten. Dies erfordert SSL-Zertifikate und -Schlüssel.

server {
    listen 443 ssl;
    server_name secure.example.com;

    ssl_certificate /etc/nginx/ssl/secure.example.com.crt;
    ssl_certificate_key /etc/nginx/ssl/secure.example.com.key;

    # Empfohlene SSL-Einstellungen für Sicherheit und Leistung
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers 'TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384';
    ssl_prefer_server_ciphers on;
    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 1h;
    ssl_stapling on;
    ssl_stapling_verify on;
    resolver 8.8.8.8 8.8.4.4 valid=300s;
    resolver_timeout 5s;

    location / {
        proxy_pass http://backend_app_server:8080; # Backend kann HTTP sein
        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 https; # Backend über ursprüngliches Protokoll informieren
    }
}

# Optional: HTTP auf HTTPS umleiten
server {
    listen 80;
    server_name secure.example.com;
    return 301 https://$host$request_uri;
}

Caching

Nginx kann Antworten von proxiierten Servern cachen, wodurch die Latenz und die Backend-Last für statische oder sich selten ändernde Inhalte erheblich reduziert werden.

# Im http-Block (außerhalb jedes server-Blocks)
proxy_cache_path /var/cache/nginx levels=1:2 keys_zone=my_cache:10m inactive=60m max_size=1g;
proxy_cache_key "$scheme$request_method$host$request_uri";

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

    location / {
        proxy_pass http://backend_app_server:8080;
        proxy_set_header Host $host;

        proxy_cache my_cache; # Caching für diesen Location aktivieren
        proxy_cache_valid 200 302 10m; # 200/302-Antworten für 10 Minuten cachen
        proxy_cache_valid 404 1m;    # 404-Antworten für 1 Minute cachen
        proxy_cache_bypass $http_pragma $http_authorization; # Nicht cachen, wenn diese Header vorhanden sind
        proxy_no_cache $http_pragma $http_authorization; # Cache nicht verwenden, wenn diese Header vorhanden sind

        add_header X-Proxy-Cache $upstream_cache_status; # Header hinzufügen, um den Cache-Status zu sehen
    }
}

WebSockets-Proxying

Das Proxying von WebSockets erfordert eine spezifische Header-Manipulation, um die Upgrade- und Connection-Header für den Protokollwechsel zu handhaben.

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

    location /ws/ {
        proxy_pass http://backend_websocket_server:8081;

        # WebSocket-spezifische Header
        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; # Bei Bedarf für langlebige Verbindungen anpassen
    }
}

Grundlegende Forward-Proxy-Konfiguration

Die Konfiguration von Nginx als Forward-Proxy ermöglicht es Clients, ihre ausgehenden Anfragen über Nginx zu routen. Dies wird typischerweise in Unternehmensnetzwerken zur Zugriffssteuerung oder Protokollierung verwendet.

Konfigurationsdirektiven

• resolver: Gibt DNS-Server an, die Nginx zur Auflösung von Hostnamen verwenden soll.
• proxy_pass: Wird innerhalb eines location-Blocks verwendet, jedoch mit einer Variablen für die Ziel-URL.

# Im http-Block (außerhalb jedes server-Blocks)
resolver 8.8.8.8 8.8.4.4 valid=300s; # Google Public DNS, bei Bedarf anpassen

server {
    listen 3128; # Üblicher Port für Proxy-Server
    listen [::]:3128;

    # Zugriff auf autorisierte Clients beschränken (z.B. internes Netzwerk)
    allow 192.168.1.0/24;
    deny all;

    location / {
        proxy_pass $scheme://$host$request_uri;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

        # Caching für einen allgemeinen Forward-Proxy deaktivieren
        proxy_no_cache 1;
        proxy_cache_bypass 1;
    }
}

Clients würden dann ihre Browser oder Anwendungen so konfigurieren, dass sie nginx_ip_address:3128 als Proxy verwenden.

Überwachung und Fehlerbehebung

Ein effektiver Betrieb von Nginx als Proxy erfordert Überwachungs- und Fehlerbehebungsfunktionen.

• Konfigurationstests: Überprüfen Sie immer die Konfigurationsdateien, bevor Sie Nginx neu laden.
  sudo nginx -t
• Dienststatus: Überprüfen Sie den Nginx-Dienststatus.
  sudo systemctl status nginx
• Zugriffsprotokolle (Access Logs): Nginx protokolliert jede verarbeitete Anfrage im Zugriffsprotokoll, das sich typischerweise unter /var/log/nginx/access.log befindet. Diese Protokolle enthalten Details wie Client-IP, Anfragemethode, URL, Statuscode und Antwortgröße.
• Fehlerprotokolle (Error Logs): Kritische Fehler, Warnungen und Debugging-Informationen werden in das Fehlerprotokoll geschrieben, normalerweise unter /var/log/nginx/error.log. Überwachen Sie diese Datei auf Probleme mit der Konfiguration, der Backend-Konnektivität oder Ressourcenbeschränkungen.
• Backend-Zustand: Stellen Sie sicher, dass die Backend-Server betriebsbereit und vom Nginx-Server aus zugänglich sind. Verwenden Sie Tools wie curl oder ping von der Nginx-Maschine aus, um die Konnektivität zu testen.
• Netzwerkkonnektivität: Überprüfen Sie die Netzwerkpfade zwischen Clients, Nginx und Backend-Servern.
• Ressourcennutzung: Überwachen Sie CPU, Arbeitsspeicher und Festplatten-E/A auf dem Nginx-Server, um Engpässe zu identifizieren.