Nginx instellen als reverse proxy met SSL

Draai je meerdere applicaties op één VPS? Nginx als reverse proxy laat je verkeer naar verschillende services routeren, SSL-certificaten automatisch afhandelen en de prestaties verbeteren — allemaal op één server. Als je de voorkeur geeft aan een Docker-native aanpak, bekijk dan onze Traefik-gids.

Waarom dit belangrijk is

Zonder een reverse proxy heb je het volgende nodig:

• Een apart publiek IP-adres voor elke applicatie
• Handmatig SSL-certificaatbeheer per service
• Elke app moet zijn eigen beveiligingsheaders afhandelen
• Geen gecentraliseerde logging of snelheidsbeperking

Een reverse proxy lost dit allemaal op. Eén toegangspunt, meerdere backends, automatische HTTPS.

Echte voordelen:

• Draai 10+ apps op één VPS met één IP
• Gratis automatische SSL via Let’s Encrypt
• Centrale plek voor beveiligingsheaders
• Load balancing wanneer je opschaalt
• WebSocket-ondersteuning voor real-time apps

Vereisten

• Een VPS met Ubuntu 22.04+ (we raden Hostinger VPS aan vanwege hun prestaties en eenvoudig DNS-beheer)
• Een domeinnaam die naar je server verwijst
• Root- of sudo-toegang
• Applicaties die draaien op localhost-poorten

Stap 1: Nginx installeren

# 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

Open het IP-adres van je server in een browser — je zou de Nginx-welkomstpagina moeten zien.

Stap 2: De mappenstructuur begrijpen

/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

Stap 3: Je eerste reverse proxy configureren

Stel dat je een Node.js-app draait op poort 3000. Maak een configuratie aan:

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

Voeg toe:

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;
    }
}

Activeer de site:

# 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

Stap 4: Certbot installeren voor gratis SSL

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

Stap 5: Je SSL-certificaat ophalen

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

Certbot zal:

1. Verifiëren dat je eigenaar bent van het domein
2. Certificaten genereren
3. Nginx automatisch configureren voor HTTPS
4. Automatische verlenging instellen

Je configuratie is nu automatisch bijgewerkt met SSL-instellingen.

Stap 6: Automatische verlenging verifiëren

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

# Check the timer
sudo systemctl status certbot.timer

Certificaten worden automatisch verlengd voordat ze verlopen. Geen handmatige tussenkomst nodig.

Stap 7: Meerdere applicaties toevoegen

Maak voor elke nieuwe app een configuratiebestand aan:

API Backend (poort 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 (andere map):

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

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

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

Activeren en SSL ophalen:

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

Stap 8: Beveiligingsheaders toevoegen

Maak een herbruikbaar 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;

Voeg toe in je server blocks:

server {
    # ... other config ...

    include snippets/security-headers.conf;

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

Stap 9: WebSocket-ondersteuning configureren

Voor apps die WebSockets gebruiken (chat, real-time functies):

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
}

Stap 10: Snelheidsbeperking instellen

Bescherm tegen misbruik in je hoofd nginx.conf:

sudo nano /etc/nginx/nginx.conf

Voeg toe in het http-blok:

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 ...
}

Toepassen in server blocks:

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;
    # ...
}

Stap 11: Gzip-compressie inschakelen

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;

Stap 12: Basis load balancing instellen

Voor meerdere backend-servers:

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 ...
    }
}

Compleet productie-configuratievoorbeeld

Hier is een volledige productieklare configuratie:

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;
    }
}

Best practices

1. Eén configuratiebestand per domein - Makkelijker te beheren en te debuggen (ook belangrijk voor VPS-beveiliging)
2. Altijd testen voor herladen - nginx -t vangt syntaxfouten op
3. Gebruik includes voor gemeenschappelijke instellingen - Het DRY-principe geldt ook voor configuraties
4. Stel geschikte timeouts in - Laat trage clients geen verbindingen bezet houden
5. Schakel HTTP/2 in - Gratis prestatieverbetering voor HTTPS
6. Log apart per app - Makkelijker debuggen en analyseren
7. Gebruik upstream blocks - Zelfs voor enkele servers, maakt opschalen eenvoudiger
8. Houd SSL-configuratie up-to-date - Best practices voor beveiliging evolueren

Veelgemaakte fouten om te vermijden

❌ Vergeten de configuratie te testen - Eén typefout breekt alle sites

❌ Sites niet activeren - Een configuratie aanmaken zonder symlink doet niets

❌ Verkeerde trailing slash bij proxy_pass - /api vs /api/ gedraagt zich anders

❌ Ontbrekende WebSocket-headers - Real-time functies falen zonder melding

❌ Upstream keepalive negeren - Creëert onnodige verbindingen

❌ SSL-certificaat mismatch - Het certificaat moet exact overeenkomen met server_name

❌ Geen snelheidsbeperking - Je server wordt een DoS-doelwit

❌ Statische bestanden via de app serveren - Laat Nginx statische content direct afhandelen

Debugging-tips

# 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

Veelgestelde vragen

Hoeveel sites kan één Nginx-server aan?

Nginx is ongelooflijk efficiënt. Een bescheiden Hostinger VPS kan gemakkelijk 50+ sites met weinig verkeer aan, of meerdere sites met veel verkeer. Geheugen is meestal de beperkende factor.

Moet ik Apache of Nginx gebruiken?

Nginx voor reverse proxy, bijna altijd. Het gaat beter om met gelijktijdige verbindingen en gebruikt minder geheugen. Apache is prima voor traditionele PHP-hosting met mod_php. Voor een nog eenvoudigere opzet, overweeg een self-hosted PaaS zoals Coolify of Dokploy.

Wat is het verschil tussen sites-available en sites-enabled?

sites-available slaat alle configuraties op. sites-enabled bevat symlinks naar actieve configuraties. Hierdoor kun je een site uitschakelen zonder de configuratie te verwijderen.

Hoe ga ik om met www vs niet-www?

Voeg beide toe aan server_name en stuur de ene door naar de andere:

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

Waarom werkt mijn SSL-certificaat niet?

Veelvoorkomende oorzaken: DNS verwijst niet naar de server, poort 80/443 geblokkeerd door firewall, verkeerde server_name, of Certbot kon het eigendom niet verifiëren. Controleer sudo certbot certificates voor de status.

Kan ik Nginx gebruiken met Docker?

Absoluut! Je kunt Nginx in een container draaien of op de host die doorstuurt naar Docker-containers. Bekijk onze Docker Compose-gids voor details.

---

Volgende stappen: Stel monitoring in om je Nginx-prestaties te volgen en problemen op te sporen voordat ze problemen worden.