Alla artiklar

Nginx reverse proxy: konfigurera en proxy till din backend

För robotar
15 november 2026
Nginx reverse proxy: konfigurera en proxy till din backend

En nginx reverse proxy tar emot trafik från besökare och skickar den vidare till en backendserver, till exempel en applikation som körs på en annan port eller på en annan server. I stället för att låta besökaren kontakta backendservern direkt tar nginx hand om förfrågan, vidarebefordrar den och returnerar svaret. Det ger dig ett enda ställe att hantera TLS, komprimering, cachning och säkerhetsheaders på, oavsett vilken teknik som körs bakom proxyn.

Vad en reverse proxy gör

En reverse proxy fungerar som mellanhand mellan klienten och din backend. Klienten skickar en förfrågan till nginx, och nginx skickar vidare den till backendservern enligt konfigurationen. Sedan skickar nginx tillbaka svaret till klienten. Besökaren ser bara nginx och känner sällan till att en annan server står bakom.

Det är användbart i flera situationer. Din applikation kan lyssna på en port som inte ska vara öppen mot internet, till exempel port 3000 för en Node.js-tjänst eller port 8080 för en Java-tjänst. Du kan också vilja köra flera tjänster under samma domän men på olika sökvägar, eller lägga TLS, gzip och cachning framför en backend som inte klarar det själv. En reverse proxy kan också dölja vilken teknik som körs bakom, vilket gör uppställningen enklare att förändra senare utan att besökaren märker det.

Konfigurera en grundläggande reverse proxy

Börja med att definiera vilken server som utgör din backend i ett upstream-block:

upstream backend {
    server 127.0.0.1:3000;
}

Sedan pekar du en location-block till den servern med direktiven proxy_pass:

server {
    listen 80;
    server_name exempel.se;

    location / {
        proxy_pass http://backend;
    }
}

proxy_pass är den centrala direktiven i en reverse proxy. Den avgör vart förfrågan ska skickas. Om backend-definitionen är ett upstream-namn använder nginx lastbalansering mellan servrarna i gruppen, om du har fler än en. Du kan också peka direkt mot en adress, till exempel proxy_pass http://127.0.0.1:3000;, men ett upstream-block gör det enklare att lägga till fler servrar senare.

Skicka vidare klientinformation till backenden

Som standard ser backendservern inte den ursprungliga klienten. Den ser bara nginx som avsändare, vilket kan ställa till det om backenden behöver känna till användarens IP-adress eller vilken domän som efterfrågades. För att lösa det skickar du vidare de vanligaste headers:

location / {
    proxy_pass http://backend;
    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;
}

Host ser till att backenden får rätt domännamn i förfrågan. X-Real-IP innehåller klientens IP-adress. X-Forwarded-For bygger på en lista av IP-adresser när flera proxys ligger i kedjan, så varje proxy kan lägga till sin egen adress. X-Forwarded-Proto berättar om den ursprungliga förfrågan kom över HTTP eller HTTPS. Det är viktigt om backenden genererar länkar eller omdirigeringar, eftersom den annars kan peka besökaren till HTTP även om sajten använder HTTPS.

Kryptera trafiken med TLS

Om din domän ska nås över HTTPS konfigurerar du nginx att lyssna på port 443 med ssl. Du behöver ett certifikat och en nyckel, till exempel från Let's Encrypt eller en annan certifikatutfärdare:

server {
    listen 443 ssl;
    server_name exempel.se;

    ssl_certificate /etc/letsencrypt/live/exempel.se/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/exempel.se/privkey.pem;

    location / {
        proxy_pass http://backend;
    }
}

Nyckelfilen får inte vara publikt tillgänglig och bör skyddas med rätt filrättigheter. När TLS avslutas hos nginx skickas trafiken mellan nginx och backendservern vanligtvis okrypterad internt, om inte du också konfigurerar TLS framför backenden. För en enkel uppställning räcker det att avsluta TLS hos nginx och köra HTTP mellan nginx och backendservern på samma värd eller i samma nätverk.

Komprimera svaret med gzip

gzip minskar storleken på textbaserade svar som HTML, CSS och JavaScript innan de skickas till besökaren. Det går snabbare att ladda sidan och minskar datatrafiken. Aktivera det i http-blocket:

gzip on;
gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript;
gzip_vary on;

Med gzip_vary on skickar nginx en Vary: Accept-Encoding-header. Det berättar för cachor att svaret finns i både en komprimerad och en okomprimerad variant, så att besökare med äldre webbläsare får rätt version.

Spara svar i cache med proxy_cache

En reverse proxy kan lagra svar från backenden så att inte varje besökare behöver vänta på backendservern. Definiera först en cachezon i http-blocket:

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

Sedan använder du zonen i location-blocket:

location / {
    proxy_cache static;
    proxy_pass http://backend;
}

Nginx cachar svar som backenden markerar som cachbara, vanligtvis genom Cache-Control-headern. Var försiktig med att cacha personliga eller inloggningsskyddade sidor — de ska inte hamna i en delad cache där andra besökare kan se dem. Du kan styra cachningen ytterligare med direktiv som proxy_cache_valid och proxy_no_cache.

Lägg på säkerhetsheaders

Säkerhetsheaders styr hur webbläsaren hanterar din sajt och skyddar mot flera vanliga attacker. Lägg till dem i server- eller location-blocket:

add_header X-Frame-Options "DENY" always;
add_header X-Content-Type-Options "nosniff" always;
add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;

X-Frame-Options med värdet DENY förbjuder att sidan visas i ett iframe, vilket skyddar mot klicka-jackning. X-Content-Type-Options förhindrar att webbläsaren gissar innehållstypen på ett svar. Strict-Transport-Security tvingar webbläsaren att bara använda HTTPS under den angivna tiden, så länge sajten har ett giltigt certifikat.

Begränsa antalet förfrågningar med rate limiting

Rate limiting skyddar backendservern mot att överbelastas av för många förfrågningar från samma adress. Definiera en gränszon:

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

Tillämpa gränsen på de sökvägar som behöver skydd:

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

Här tillåts tio förfrågningar per sekund per IP-adress, med plats för tjugo extra förfrågningar i en kö. nodelay innebär att förfrågningar inom kögränsen skickas direkt utan extra fördröjning. Det är ett enkelt sätt att skydda en publikt tillgänglig API-väg mot missbruk.

Testa och ladda om konfigurationen

Innan du tillämpar ändringarna bör du alltid kontrollera att konfigurationen är giltig:

sudo nginx -t

Om testet går igenom laddar du om nginx så att den nya konfigurationen börjar gälla:

sudo systemctl reload nginx

nginx -t kontrollerar syntaxen utan att starta om tjänsten. Ett reload tillämpar ändringarna utan avbrott för pågående anslutningar. Hoppa aldrig över testet — ett fel i konfigurationsfilen kan förhindra att nginx startar om.

Vanliga misstag att undvika

  • Glöm inte X-Forwarded-Proto om backenden skapar omdirigeringar. Annars kan den peka besökaren till HTTP även om sajten använder HTTPS.
  • Cacha inte sidor som innehåller personlig information eller inloggningsstatus. De ska inte hamna i en delad cache.
  • Testa alltid med nginx -t innan du laddar om, så ett fel i konfigurationsfilen inte tar ned sajten.
  • Kom ihåg att öppna portar 80 och 443 i brandväggen om din backend körs på en egen server.

Snabbchecklista

  • upstream eller proxy_pass pekar mot rätt backend och port
  • Host, X-Real-IP, X-Forwarded-For och X-Forwarded-Proto skickas vidare till backenden
  • TLS-certifikat och nyckel är på plats för port 443
  • gzip är aktiverat för textbaserade svar
  • Cachning är avslagen för personliga och inloggningsskyddade sidor
  • Säkerhetsheaders är på plats
  • Rate limiting är konfigurerat för känsliga sökvägar
  • Konfigurationen har testats med nginx -t

Den här guiden ger dig en fungerande nginx reverse proxy för statiska sajter, SPA:er och applikationsservrar. Om du i stället vill bygga en konfiguration för en ren statisk sajt finns den i vår guide om att konfigurera en statisk sajt med nginx.

Relaterade artiklar