Nginx als Reverse Proxy mit SSL einrichten

Sie betreiben mehrere Anwendungen auf einem einzigen VPS? Nginx als Reverse Proxy ermöglicht es Ihnen, Traffic an verschiedene Dienste weiterzuleiten, SSL-Zertifikate automatisch zu verwalten und die Leistung zu verbessern — alles auf einem Server. Wenn Sie einen Docker-nativen Ansatz bevorzugen, schauen Sie sich stattdessen unseren Traefik-Leitfaden an.

Warum das wichtig ist

Ohne einen Reverse Proxy bräuchten Sie:

• Eine separate öffentliche IP für jede Anwendung
• Manuelle SSL-Zertifikatsverwaltung pro Dienst
• Jede App müsste ihre eigenen Sicherheits-Header verwalten
• Kein zentralisiertes Logging oder Rate Limiting

Ein Reverse Proxy löst all das. Ein Einstiegspunkt, mehrere Backends, automatisches HTTPS.

Echte Vorteile:

• 10+ Apps auf einem VPS mit einer IP betreiben
• Kostenloses automatisches SSL über Let’s Encrypt
• Zentrale Stelle für Sicherheits-Header
• Load Balancing bei Skalierung
• WebSocket-Unterstützung für Echtzeit-Apps

Voraussetzungen

• Ein VPS mit Ubuntu 22.04+ (wir empfehlen Hostinger VPS für ihre Leistung und einfache DNS-Verwaltung)
• Ein Domainname, der auf Ihren Server zeigt
• Root- oder Sudo-Zugang
• Anwendungen, die auf localhost-Ports laufen

Schritt 1: Nginx installieren

# Update packages
sudo apt update

# Install Nginx
sudo apt install nginx -y

# Start and enable
sudo systemctl start nginx
sudo systemctl enable nginx

# Verify it's running
sudo systemctl status nginx

Öffnen Sie die IP Ihres Servers in einem Browser — Sie sollten die Nginx-Willkommensseite sehen.

Schritt 2: Die Verzeichnisstruktur verstehen

/etc/nginx/
├── nginx.conf              # Main config (rarely edit)
├── sites-available/        # All site configs
├── sites-enabled/          # Symlinks to active configs
├── snippets/               # Reusable config snippets
└── conf.d/                 # Additional configs

Schritt 3: Ihren ersten Reverse Proxy konfigurieren

Angenommen, Sie haben eine Node.js-App, die auf Port 3000 läuft. Erstellen Sie eine Konfiguration:

sudo nano /etc/nginx/sites-available/myapp.example.com

Fügen Sie hinzu:

server {
    listen 80;
    listen [::]:80;
    server_name myapp.example.com;

    location / {
        proxy_pass http://127.0.0.1:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        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_cache_bypass $http_upgrade;
    }
}

Aktivieren Sie die Seite:

# Create symlink
sudo ln -s /etc/nginx/sites-available/myapp.example.com /etc/nginx/sites-enabled/

# Test configuration
sudo nginx -t

# Reload Nginx
sudo systemctl reload nginx

Schritt 4: Certbot für kostenloses SSL installieren

# Install Certbot and Nginx plugin
sudo apt install certbot python3-certbot-nginx -y

Schritt 5: Ihr SSL-Zertifikat erhalten

sudo certbot --nginx -d myapp.example.com

Certbot wird:

1. Überprüfen, dass Sie die Domain besitzen
2. Zertifikate generieren
3. Nginx automatisch für HTTPS konfigurieren
4. Die automatische Verlängerung einrichten

Ihre Konfiguration wird nun automatisch mit SSL-Einstellungen aktualisiert.

Schritt 6: Automatische Verlängerung überprüfen

# Test renewal process
sudo certbot renew --dry-run

# Check the timer
sudo systemctl status certbot.timer

Zertifikate werden vor Ablauf automatisch verlängert. Kein manuelles Eingreifen erforderlich.

Schritt 7: Mehrere Anwendungen hinzufügen

Für jede neue App erstellen Sie eine Konfigurationsdatei:

API-Backend (Port 4000):

sudo nano /etc/nginx/sites-available/api.example.com

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

    location / {
        proxy_pass http://127.0.0.1:4000;
        proxy_http_version 1.1;
        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;
    }
}

Statische Website (anderes Verzeichnis):

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

    root /var/www/static.example.com;
    index index.html;

    location / {
        try_files $uri $uri/ =404;
    }
}

Aktivieren und SSL erhalten:

sudo ln -s /etc/nginx/sites-available/api.example.com /etc/nginx/sites-enabled/
sudo nginx -t && sudo systemctl reload nginx
sudo certbot --nginx -d api.example.com

Schritt 8: Sicherheits-Header hinzufügen

Erstellen Sie ein wiederverwendbares Snippet:

sudo nano /etc/nginx/snippets/security-headers.conf

add_header X-Frame-Options "SAMEORIGIN" always;
add_header X-Content-Type-Options "nosniff" always;
add_header X-XSS-Protection "1; mode=block" always;
add_header Referrer-Policy "strict-origin-when-cross-origin" always;
add_header Content-Security-Policy "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline';" always;
add_header Permissions-Policy "geolocation=(), microphone=(), camera=()" always;

Binden Sie es in Ihre Server-Blöcke ein:

server {
    # ... other config ...

    include snippets/security-headers.conf;

    location / {
        # ... proxy settings ...
    }
}

Schritt 9: WebSocket-Unterstützung konfigurieren

Für Apps, die WebSockets verwenden (Chat, Echtzeit-Funktionen):

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 "upgrade";
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_read_timeout 86400;  # 24 hours for long connections
}

Schritt 10: Rate Limiting einrichten

Schützen Sie sich vor Missbrauch in Ihrer nginx.conf:

sudo nano /etc/nginx/nginx.conf

Fügen Sie im http-Block hinzu:

http {
    # Define rate limit zones
    limit_req_zone $binary_remote_addr zone=general:10m rate=10r/s;
    limit_req_zone $binary_remote_addr zone=api:10m rate=30r/s;

    # ... rest of config ...
}

In Server-Blöcken anwenden:

location / {
    limit_req zone=general burst=20 nodelay;
    proxy_pass http://127.0.0.1:3000;
    # ...
}

location /api/ {
    limit_req zone=api burst=50 nodelay;
    proxy_pass http://127.0.0.1:4000;
    # ...
}

Schritt 11: Gzip-Komprimierung aktivieren

sudo nano /etc/nginx/conf.d/gzip.conf

gzip on;
gzip_vary on;
gzip_min_length 1024;
gzip_proxied any;
gzip_comp_level 6;
gzip_types
    text/plain
    text/css
    text/xml
    text/javascript
    application/json
    application/javascript
    application/xml
    application/xml+rss
    application/x-javascript
    image/svg+xml;

Schritt 12: Einfaches Load Balancing einrichten

Für mehrere Backend-Server:

upstream myapp_backends {
    least_conn;  # Send to least busy server
    server 127.0.0.1:3000 weight=3;
    server 127.0.0.1:3001 weight=2;
    server 127.0.0.1:3002 backup;  # Only if others fail
}

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

    location / {
        proxy_pass http://myapp_backends;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        # ... other headers ...
    }
}

Vollständiges Produktions-Konfigurationsbeispiel

Hier ist eine vollständige produktionsreife Konfiguration:

upstream app_backend {
    server 127.0.0.1:3000;
    keepalive 32;
}

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

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name myapp.example.com;

    # SSL (managed by Certbot, but you can customize)
    ssl_certificate /etc/letsencrypt/live/myapp.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/myapp.example.com/privkey.pem;
    ssl_session_timeout 1d;
    ssl_session_cache shared:SSL:50m;
    ssl_session_tickets off;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256;
    ssl_prefer_server_ciphers off;

    # HSTS
    add_header Strict-Transport-Security "max-age=63072000" always;

    # Security headers
    include snippets/security-headers.conf;

    # Logging
    access_log /var/log/nginx/myapp.access.log;
    error_log /var/log/nginx/myapp.error.log;

    # Rate limiting
    limit_req zone=general burst=20 nodelay;

    # Proxy settings
    location / {
        proxy_pass http://app_backend;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        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_cache_bypass $http_upgrade;
        proxy_connect_timeout 60s;
        proxy_send_timeout 60s;
        proxy_read_timeout 60s;
    }

    # Static files (if served by Nginx)
    location /static/ {
        alias /var/www/myapp/static/;
        expires 30d;
        add_header Cache-Control "public, immutable";
    }

    # Health check endpoint
    location /health {
        access_log off;
        return 200 "healthy\n";
        add_header Content-Type text/plain;
    }
}

Bewährte Vorgehensweisen

1. Eine Konfigurationsdatei pro Domain - Einfacher zu verwalten und zu debuggen (auch wichtig für die VPS-Sicherheit)
2. Immer vor dem Neuladen testen - nginx -t erkennt Syntaxfehler
3. Includes für gemeinsame Einstellungen verwenden - Das DRY-Prinzip gilt auch für Konfigurationen
4. Angemessene Timeouts setzen - Lassen Sie nicht zu, dass langsame Clients Verbindungen blockieren
5. HTTP/2 aktivieren - Kostenloser Leistungsschub für HTTPS
6. Pro App separat loggen - Einfacheres Debugging und Analyse
7. Upstream-Blöcke verwenden - Auch für einzelne Server, erleichtert die Skalierung
8. SSL-Konfiguration aktuell halten - Best Practices für Sicherheit entwickeln sich weiter

Häufige Fehler, die Sie vermeiden sollten

• Konfiguration nicht testen - Ein Tippfehler bricht alle Seiten

• Seiten nicht aktivieren - Eine Konfiguration ohne Symlink zu erstellen bewirkt nichts

• Falscher Schrägstrich bei proxy_pass - /api vs /api/ verhält sich unterschiedlich

• Fehlende WebSocket-Header - Echtzeit-Funktionen schlagen stillschweigend fehl

• Upstream-Keepalive ignorieren - Erzeugt unnötige Verbindungen

• SSL-Zertifikats-Diskrepanz - Das Zertifikat muss exakt mit dem server_name übereinstimmen

• Kein Rate Limiting - Ihr Server wird zum DoS-Ziel

• Statische Dateien über die App ausliefern - Lassen Sie Nginx statische Inhalte direkt verarbeiten

Debugging-Tipps

# Check Nginx error log
sudo tail -f /var/log/nginx/error.log

# Check specific site log
sudo tail -f /var/log/nginx/myapp.error.log

# Test configuration
sudo nginx -t

# Check if port is listening
sudo ss -tlnp | grep nginx

# View active connections
sudo nginx -T | grep server_name

FAQ

Wie viele Seiten kann ein Nginx-Server verarbeiten?

Nginx ist unglaublich effizient. Ein bescheidener Hostinger VPS kann problemlos 50+ Seiten mit geringem Traffic oder mehrere Seiten mit hohem Traffic verarbeiten. Der Arbeitsspeicher ist normalerweise der limitierende Faktor.

Sollte ich Apache oder Nginx verwenden?

Nginx als Reverse Proxy, fast immer. Es verarbeitet gleichzeitige Verbindungen besser und verwendet weniger Arbeitsspeicher. Apache ist in Ordnung für traditionelles PHP-Hosting mit mod_php. Für ein noch einfacheres Setup sollten Sie eine selbst gehostete PaaS wie Coolify oder Dokploy in Betracht ziehen.

Was ist der Unterschied zwischen sites-available und sites-enabled?

sites-available speichert alle Konfigurationen. sites-enabled enthält Symlinks zu den aktiven. So können Sie eine Seite deaktivieren, ohne ihre Konfiguration zu löschen.

Wie gehe ich mit www vs. ohne www um?

Fügen Sie beide zu server_name hinzu und leiten Sie eine zur anderen weiter:

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

Warum funktioniert mein SSL-Zertifikat nicht?

Häufige Ursachen: DNS zeigt nicht auf den Server, Port 80/443 ist durch die Firewall blockiert, falscher server_name, oder Certbot konnte den Besitz nicht verifizieren. Überprüfen Sie den Status mit sudo certbot certificates.

Kann ich Nginx mit Docker verwenden?

Auf jeden Fall! Sie können Nginx entweder in einem Container oder auf dem Host betreiben und auf Docker-Container weiterleiten. Weitere Details finden Sie in unserem Docker Compose-Leitfaden.

---

Nächste Schritte: Richten Sie Monitoring ein, um die Leistung Ihres Nginx zu überwachen und Probleme zu erkennen, bevor sie kritisch werden.