{"canonical_url":"https://engineer.company/sv/glossary/load-balancer/","content_markdown":"# Lastbalanserare\n\n## Vad det är\n\nEn lastbalanserare är en server som tar emot begäranden från klienter och\nfördelar dem över en pool av andra servrar som alla gör samma jobb. Ingen\nenskild maskin bär hela lasten, och när en faller bort tar den inte med sig\ntjänsten. På engelska heter den load balancer, och många svenska utvecklare\nanvänder det engelska ordet också; i konfigurationsfiler och diagram förkortas\ndet ofta till LB. Själva arbetet kallas lastbalansering. Klienterna ser bara en\nadress, nämligen lastbalanserarens. Servrarna bakom den bildar en pool, som\nnginx kallar en upstream-grupp och HAProxy en backend.\n\nFör varje begäran fattar en lastbalanserare två beslut: vilka servrar som är\nfriska nog att ta emot den, och vilken av dem som får den. Det andra beslutet är\nbalanseringsmetoden. Round robin ger servrarna begäranden i tur och ordning och\när vad nginx gör när inget annat är inställt. Least connections skickar nästa\nbegäran till den server som har minst antal aktiva anslutningar och jämnar på så\nsätt ut lasten när vissa begäranden tar mycket längre tid än andra. HAProxys\nmanual rekommenderar metoden för långa sessioner som LDAP och SQL och kallar den\nilla lämpad för korta sessioner som HTTP. Hashning gör en nyckel, till exempel\nklientens IP-adress eller den begärda URL:en, till ett val av server, så att\nsamma nyckel fortsätter att hamna på samma maskin. nginx har också en\nslumpmässig metod som kan dra två servrar och skicka begäran till den av dem som\nhar minst att göra. Vikter drar valet mot de större maskinerna: i exemplet i\nnginx egen guide får en server med `weight=3` tre av fem begäranden, medan två\nservrar med standardvikten 1 får en var.\n\nLastbalanserare skiljer sig också åt i hur mycket av trafiken de läser. I\nHAProxys `mode tcp`, som är standard, kopplas klient och server ihop i en\nanslutning med full duplex, utan någon granskning alls på lager 7, och det\npassar för TLS som skickas igenom oöppnad, för SSH och för SMTP. I `mode http`\ntolkas varje begäran innan servern väljs: begäranden som bryter mot protokollet\navvisas, och trafiken kan styras efter sökväg eller header. En lastbalanserare\nsom arbetar på HTTP-nivå avslutar klientens anslutning och öppnar en egen mot\nservern, så applikationen ser lastbalanseraren som sin enda klient om inte den\nursprungliga adressen skickas vidare, oftast i headern `X-Forwarded-For`. Därför\när en lastbalanserare och en omvänd proxy så ofta samma process: nginx är båda,\noch dess egen guide beskriver lastbalansering som en del av dess implementation\nav omvänd proxy.\n\n## Varför det spelar roll\n\nEn server har ett tak. När en tjänst växer ur det är det lastbalanseraren som\nlåter ett team ställa upp en andra och en tredje kopia i stället för att köpa en\nstörre maskin, och varje ny kopia bakom den ger mer kapacitet utan att\nklienterna märker att poolen har ändrats. Samma upplägg gör underhåll till\nvardag: ta en server ur rotationen, uppdatera den, kontrollera den, sätt in den\nigen och upprepa med nästa, medan användarna betjänas av resten.\n\nDet gör också att en server som faller bort blir en mindre händelse än ett\navbrott. När en server slutar svara slutar lastbalanseraren att välja den, och\nde övriga servrarna tar över dess andel. Det fungerar bara om de har kapacitet\növer. Tre servrar som var och en kör på 80 % av sin kapacitet kan inte täcka upp\nför varandra: faller en bort får var och en av de två andra 120 % av en servers\narbete.\n\nEn lastbalanserare ändrar också hur applikationen måste skrivas. Med round robin\neller least connections kan två begäranden i följd från samma klient hamna på\ntvå olika servrar, vilket nginx guide påpekar. Allt en server håller i sitt eget\nminne eller på sin egen disk mellan två begäranden, till exempel en\ninloggningssession, en uppladdad fil som väntar på bearbetning eller en cache av\nanvändarens varukorg, är borta så fort nästa begäran landar på en annan server.\nAntingen lägger applikationen det tillståndet någonstans där alla servrar når\ndet, i en databas eller en delad cache, eller så binder lastbalanseraren varje\nklient till en server, så som nginx `ip_hash` gör, utom när den servern inte går\natt nå.\n\nTill sist blir lastbalanseraren själv den enda maskin som varje begäran måste\npassera. Tio applikationsservrar bakom en enda lastbalanserare har fortfarande\nen enskild felpunkt; den har bara flyttat. Ett seriöst upplägg kör\nlastbalanseraren som ett par med en adress som kan flytta mellan de två, eller\nanvänder en hanterad lastbalanserare där leverantören står för redundansen.\n\n## Så ser det ut i praktiken\n\nHär fördelar en nginx-server begäranden över tre applikationsservrar och håller\nen fjärde i reserv:\n\n```nginx\nupstream app {\n    least_conn;\n    server 10.0.0.11:8080 max_fails=3 fail_timeout=30s;\n    server 10.0.0.12:8080 max_fails=3 fail_timeout=30s;\n    server 10.0.0.13:8080 max_fails=3 fail_timeout=30s weight=2;\n    server 10.0.0.20:8080 backup;\n}\n\nserver {\n    listen 80;\n    location / {\n        proxy_pass http://app;\n        proxy_set_header Host $host;\n        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;\n        proxy_next_upstream error timeout http_502 http_503;\n        proxy_next_upstream_tries 2;\n        proxy_connect_timeout 2s;\n    }\n}\n```\n\n`least_conn` skickar varje ny begäran till den server som har minst antal aktiva\nanslutningar och avgör lika läge med viktad round robin. Den tredje servern är\nden största maskinen, så `weight=2` räknar den dubbelt.\n`max_fails=3 fail_timeout=30s` betyder att tre misslyckade försök inom 30\nsekunder tar en server ur poolen i 30 sekunder, varefter nginx provar den igen\nmed riktiga begäranden och tar tillbaka den om de lyckas. Utan de parametrarna\ngäller standardvärdena, och då räcker ett enda fel inom 10 sekunder.\n`backup`-servern får begäranden bara medan alla tre primära servrar är\notillgängliga.\n\nI `location`-blocket avgör `proxy_next_upstream` när en begäran lämnas vidare\ntill en annan server: vid ett fel i kommunikationen med servern, vid en timeout\noch vid ett 502- eller 503-svar. `proxy_next_upstream_tries 2` begränsar hur\nmånga gånger det kan hända för en begäran; standardvärdet 0 betyder ingen gräns.\nDe två `proxy_set_header`-raderna behåller det värdnamn som klienten bad om, som\nnginx annars skulle byta ut mot upstream-namnet `app`, och lägger till klientens\nadress i `X-Forwarded-For` så att applikationen kan logga de verkliga besökarna\ni stället för lastbalanseraren. `proxy_connect_timeout 2s` ger upp en server som\ninte har tagit emot anslutningen inom två sekunder, där standardvärdet skulle ha\nväntat i 60.\n\nDe här kontrollerna är passiva: nginx märker att en server är sjuk först när\nriktiga begäranden till den misslyckas. HAProxy kan dessutom själv undersöka\nvarje server enligt ett eget schema. `option httpchk GET /healthz` i en backend,\ntillsammans med `check` på varje `server`-rad, skickar den begäran varannan\nsekund som standard; tre fel i rad markerar servern som nere, och två lyckade\nsvar tar tillbaka den. Utan `check` kör HAProxy inga hälsokontroller och\nbetraktar servern som alltid tillgänglig.\n\nInnan nginx är en lastbalanserare är det en webbserver, och en helt vanlig\nsådan. Det är en av de två webbservrarna bakom\n[40 webbplatser administrerade på Apache och Nginx](/sv/portfolio/administered-40-websites-on-apache-and-nginx/)\nmellan 2003 och 2014, som kördes på hostingservrar med Ubuntu Linux och\nkonfigurerades, prestandaoptimerades och underhölls för att hålla sig\ntillförlitliga under verklig trafik. `backup`-raden har en släkting en nivå upp,\ndär servrarna är hela leverantörer.\n[E-post med failover mellan tre leverantörer](/sv/portfolio/built-email-with-failover-and-delivery-logging/)\nhar SendGrid som primär med SMTP2GO och Azure Communication Services bakom och\nväxlar automatiskt mellan dem, så att en dålig eftermiddag hos en leverantör\nledde till ett nedsatt driftläge i stället för ett avbrott.\n\n## Var det går fel\n\n**En server som svarar 500 på alla begäranden stannar kvar i poolen.** Som\nstandard räknar nginx bara fel i kommunikationen med servern, timeouter och\nogiltiga svarsheaders som misslyckade försök. En server vars applikation har\ntappat kontakten med databasen och returnerar 500 på allt svarar snabbt och\nartigt, så lastbalanseraren fortsätter att skicka den dess andel av trafiken.\nSvaren 500, 502, 503, 504 och 429 räknas mot en server bara när de står i\n`proxy_next_upstream`, och 403 och 404 räknas aldrig. Skriv upp de koder som\nbetyder ”servern är trasig”, och ge servrarna en aktiv kontroll mot en endpoint\nsom använder allt applikationen behöver för att leverera en sida.\n\n**En långsam begäran körs på varje server i tur och ordning.** `timeout` ingår i\nstandardvärdet för `proxy_next_upstream`, och `proxy_read_timeout` är 60\nsekunder som standard. En rapport som tar 70 sekunder att bygga får timeout på\nden första servern, lämnas vidare till den andra, får timeout igen och går\nvidare till den tredje, så klienten väntar i tre minuter medan varje server gör\nsamma arbete. En timeout räknas alltid som ett misslyckat försök, så med\nstandardvärdet 1 för `max_fails` markeras också varje server som begäran har\npasserat som otillgänglig i 10 sekunder. Begränsa vidarebefordringarna med\n`proxy_next_upstream_tries` och `proxy_next_upstream_timeout`, ge den långsamma\nendpointen en egen `location` med längre timeout, eller flytta arbetet bort från\nsjälva begäran och in i ett bakgrundsjobb.\n\n**En betalning går igenom två gånger.** nginx skickar som standard inte en\nPOST-, LOCK- eller PATCH-begäran vidare till en annan server när den väl har\nnått en, eftersom den första servern redan kan ha agerat på den. Lägger man till\n`non_idempotent` i `proxy_next_upstream` för att få timeouterna att försvinna\ntar man bort det skyddet: en betalning som den första servern genomförde men\nsvarade för långsamt på genomförs igen av den andra. Låt inställningen vara\navstängd om inte varje endpoint bakom den är\n[idempotent](/sv/glossary/#idempotent), till exempel för att den tar emot en\nidempotensnyckel och vägrar upprepa en begäran den redan har sett.\n\n**Alla besökare ser ut att komma från lastbalanseraren.** Utan headrarna från\nexemplet loggar applikationen lastbalanserarens adress för varje begäran, och\nvarje gräns som hålls per IP-adress drabbar nu alla användare på en gång.\n`X-Forwarded-For` har en egen fälla. `$proxy_add_x_forwarded_for` lägger till\nklientens adress efter den `X-Forwarded-For` som klienten själv skickade med, så\nde första posterna är vad klienten valde att skriva. Applikationen bör bara lita\npå den post som dess egen lastbalanserare har lagt till, och bara ta emot\nheadern från lastbalanserarens adress.\n\n**Ett helt kontor hamnar på en server.** nginx `ip_hash` hashar de tre första\noktetterna i en IPv4-adress, så alla klienter som delar dem hamnar på samma\nserver, och ett helt företag bakom en NAT-gateway kommer in som en enda klient.\nÄndringar i poolen ger den motsatta överraskningen. Med en vanlig `hash` kan det\natt lägga till eller ta bort en server flytta de flesta nycklar till en annan\nserver, och varje användare som var bunden på det sättet förlorar det som den\ngamla servern höll. nginx dokumentation råder till att markera en server med\n`down` i stället för att ta bort den ur en `ip_hash`-grupp, och erbjuder\n`hash ... consistent`, som bara flyttar några få nycklar när poolen ändras. Ännu\nbättre är att hålla sessionstillståndet borta från servrarna, för då spelar det\ningen roll var en klient hamnar.\n\n## Läs mer\n\n- [Using nginx as HTTP load balancer](https://nginx.org/en/docs/http/load_balancing.html)\n  — de tre grundläggande metoderna, vikter, sessionsbeständighet och de passiva\n  hälsokontrollerna, var och en med en kort konfiguration.\n- [Module ngx_http_upstream_module](https://nginx.org/en/docs/http/ngx_http_upstream_module.html)\n  — alla parametrar på en `server`-rad, bland dem `max_fails`, `backup` och\n  undantaget för grupper med en enda server, samt metoderna `hash`, `ip_hash`,\n  `least_conn` och `random`.\n- [Module ngx_http_proxy_module](https://nginx.org/en/docs/http/ngx_http_proxy_module.html)\n  — `proxy_next_upstream` och vad som räknas som ett misslyckat försök,\n  timeouterna och de headers som nginx sätter på vägen till servern.\n- [HAProxy 3.4 Configuration Manual](https://docs.haproxy.org/3.4/configuration.html)\n  — `balance` och dess algoritmer, TCP- och HTTP-läget och aktiva\n  hälsokontroller med `check`, `inter`, `rise` och `fall`.\n\n\u003chttps://engineer.company/sv/glossary/load-balancer/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hur en lastbalanserare väljer server för varje begäran, hur den märker att en server är sjuk och fem sätt som en balanserad pool ändå sviker på.","formats":{"gemtext":"https://engineer.company/sv/glossary/load-balancer/index.gmi","gopher":"https://engineer.company/sv/glossary/load-balancer/gophermap","html":"https://engineer.company/sv/glossary/load-balancer/","json":"https://engineer.company/sv/glossary/load-balancer/index.json","markdown":"https://engineer.company/sv/glossary/load-balancer/index.md","pdf":"https://engineer.company/sv/glossary/load-balancer/index.pdf"},"kind":"page","language":"sv","title":"Vad är en lastbalanserare?","url":"https://engineer.company/sv/glossary/load-balancer/","version":1}