{"canonical_url":"https://engineer.company/nb/glossary/scalability/","content_markdown":"# Skalerbarhet\n\n## Hva det er\n\nSkalerbarhet sier hvor mye mer et system klarer når du gir det flere ressurser.\nEt system skalerer godt når dobbelt så mange maskiner bærer omtrent dobbelt så\nmye last med de samme svartidene. Det skalerer dårlig når den nye maskinvaren\nfor det meste står og venter på noe den ikke kan hjelpe med. Ordet beskriver\naltså et forhold mellom last og kostnad, ikke en egenskap et system enten har\neller mangler.\n\nEt system kan vokse i to retninger. Å skalere opp, eller vertikal skalering,\nbetyr en større maskin: flere kjerner, mer minne, raskere disker. Programvaren\ntrenger ingen endring, men veksten stopper ved den største maskinen det lønner\nseg å kjøpe. Å skalere ut, eller horisontal skalering, betyr flere maskiner som\ndeler på arbeidet. Der finnes ikke det samme taket, men bare arbeid som lar seg\ndele opp, får noe igjen for det.\n\nHTTP ble formet med tanke på å skalere ut. RFC 9110 påpeker at mange\nimplementasjoner er avhengige av at HTTP er tilstandsløs, for å kunne gjenbruke\ntilkoblinger gjennom en proxy eller fordele forespørsler dynamisk over flere\nservere. Et webnivå som ikke husker noe mellom forespørslene, kan vokse ved å\nlegge til kopier av seg selv bak en lastbalanserer, og hvilken som helst kopi\nkan svare på hvilken som helst forespørsel.\n\nLast har mer enn én dimensjon, og et system kan skalere langs én og stå fast\nlangs en annen: forespørsler per sekund, mengden lagrede data, antall leietakere\nog antall skrivere som slåss om den samme posten. Den siste er den vanskeligste,\nfordi én rad bare kan endres av én transaksjon om gangen, uansett hvor mange\nservere som står rundt den.\n\nRegnestykket bak dette heter Amdahls lov. Når en del av arbeidet må kjøres i\nrekkefølge, gjør parallell maskinvare bare resten raskere, og den sekvensielle\ndelen setter grensen: er 5 % av arbeidet serielt, kan hele jobben aldri gå mer\nenn 20 ganger raskere, selv på tusen maskiner. I en database er den serielle\ndelen ofte en lås. I en applikasjon er den ofte én delt teller, én kø eller ett\nfelles lager for sesjoner.\n\n## Hvorfor det er viktig\n\nSkalerbarheten avgjør hva vekst koster. Skalerer systemet godt, blir en dobling\nav trafikken en ny linje på fakturaen. Skalerer det dårlig, vokser regningen\nraskere enn lasten, eller ny maskinvare slutter å hjelpe i det hele tatt, og\nløsningen blir en omlegging av arkitekturen som må gjøres mens trafikken\nstrømmer inn.\n\nMaskinvare kan avhjelpe flaskehalser i prosessorer, minne eller disker, men\nineffektivt arbeid og behov for sekvensiell utføring kan bestå. En spørring som\nunødvendig leser hele tabellen, kan fortsatt utføre overflødig arbeid på en\nstørre server. En større maskin fjerner ikke kravet om at oppdateringer av samme\nrad utføres én om gangen, og flere applikasjonsservere kan øke antallet\nskrivende klienter i køen. De fleste systemer som ser ut til å trenge flere\nmaskiner, trenger først å bli lest.\n\nI PostgreSQL begynner lesingen i `pg_stat_statements`, en utvidelse som\nregistrerer hver normaliserte setning med antall kall og kjøretid. Sortert etter\ntotal tid i stedet for gjennomsnitt viser den hvor serveren faktisk bruker\nkreftene sine: en spørring som tar 2 ms og kjøres en million ganger i timen,\nkoster 2 000 sekunder av den timen, mens en rapport på to sekunder som kjøres to\nganger, koster fire.\n\n```sql\nSELECT calls, round(total_exec_time) AS total_ms,\n       left(query, 60) AS query\n  FROM pg_stat_statements\n ORDER BY total_exec_time DESC\n LIMIT 10;\n```\n\nHvert steg mot flere maskiner har sine egne driftskostnader, og derfor betyr\nrekkefølgen noe. En strammere setning eller en bedre indeks kan forbedre ytelsen\nuten å legge til enda en server. En lesereplika er konfigurasjon. Partisjonering\nendrer én tabell. Sharding, å dele dataene mellom separate databaseservere,\nendrer driften rundt dem: migreringer, sikkerhetskopiering, gjenoppretting og\nrapporter må ta hensyn til separate shards; en join på tvers av shards kan\nflyttes til applikasjonskoden; og en spørring som ikke kjenner shardnøkkelen\nsin, kan måtte spørre alle.\n\n## Slik ser det ut i praksis\n\nEn PostgreSQL-database bak en mellomstor applikasjon holdt brukerkontoer,\nleietakere, geografiske data og daglige målinger av strømforbruk. Trafikken var\nlav, men databasen ble tregere etter hvert som datamengdene vokste. Oppdraget\nvar å gjøre den\n[10 ganger raskere uten å bygge om arkitekturen](/nb/portfolio/accelerated-postgresql-performance-by-10x/),\nog plass til framtidig datavekst var en del av målet. Arbeidet besto av\nGiST-indekser for de romlige dataene, sammensatte indekser på leietaker og\ndatointervall, tidsbasert partisjonering av strømtabellen, hash-partisjonering\nav de geografiske dataene, omskrevne spørringer sjekket med `EXPLAIN ANALYZE`,\nog tilkoblingspooling. Svartidene ble 10 ganger bedre, databasens ressursbruk\nfalt med 40 %, og systemet tok imot voksende datamengder uten å bli tregere,\nmed mindre behov for maskinvareoppgraderinger.\n\nHos et mellomstort teknologiselskap med ti databaseservere på PostgreSQL og\nSQL Server ble infrastrukturen\n[skalert for 40 % økning i brukertrafikken uten forringelse av tjenesten](/nb/portfolio/ran-10-postgresql-and-ms-sql-servers-on-ubuntu/).\nSamtidig ble svartidene for spørringer 30 % bedre, gjennom justering av\nkonfigurasjonen og optimalisering av indekser.\n\nRekkefølgen arbeidet følger, står i\n[et notat om å optimalisere før du sharder](/nb/notes/optimise-before-you-shard/):\nse, stram inn, ta lesingene bort fra primærnoden, partisjoner tabellene rundt\ndet hete punktet, og shard først når én maskin er full av godt arbeid. Notatet\nnevner tre tilfeller der sharding er rimelig: primærnoden er mettet av setninger\nsom allerede er slanke, dataene har vokst fra vedlikeholdet sitt, eller\nisolasjon er selve kravet.\n\n## Hvor det går galt\n\n**Flere webservere foran én database.** Hver applikasjonsserver åpner sine egne\ntilkoblinger, og når mange ganger flere økter er aktive enn databasen har\nkjerner, går serverens tid med til å bytte mellom dem. Tilkoblingspooling løser\ndet før ny maskinvare gjør det, og enda en webserver gjør det verre.\n\n**Én varm rad.** Når hver forespørsel skriver til den samme posten, f.eks. en\nlagerteller eller en saldo, begrenses gjennomstrømningen til omtrent antallet skrivinger én lås kan håndtere,\ndelt på hvor lenge låsen holdes, uansett antall maskiner. Alt som er tregt inne i låsen, senker det taket. Hold\ntransaksjonen kort, legg eksterne kall utenfor den, og når én vare vokser fra\nmaskinen sin, del lageret opp i mindre biter som hver har nøyaktig én eier.\n\n**Tilstand som bor på én server.** Sesjoner i minnet til én prosess,\nopplastinger skrevet til lokal disk eller en planlagt jobb som tar for gitt at\nden er den eneste kopien, hindrer alle sammen at en ny instans blir likeverdig\nmed den første. Legg den tilstanden i et delt lager, slik at hvilken som helst\ninstans kan svare på hvilken som helst forespørsel.\n\n**Replikaer behandlet som kopier av primærnoden.** En strømmende replika henger\nlitt etter, så den som nettopp har skrevet noe og så leser fra replikaen, kan\nfå se den gamle verdien. Les ferske skrivinger fra primærnoden. En lang rapport\npå en standby kan også bli avbrutt når den holder igjen endringene som spilles\nav. PostgreSQL dokumenterer dette som spørringskonflikter, sammen med\ninnstillingene som veier replikaforsinkelse opp mot dem.\n\n**Partisjoner som spørringene aldri nevner.** Partisjonering deler én tabell\netter en nøkkel, f.eks. måned eller leietaker, slik at en spørring som oppgir\nnøkkelen, bare leser partisjonene den trenger. En spørring som utelater\nnøkkelen, leser alle partisjonene og får ingenting igjen for oppdelingen.\nPartisjoner etter det spørringene allerede filtrerer på, og regn med at det\nlønner seg først for store tabeller: tommelfingerregelen i PostgreSQL-manualen\ner en tabell som er større enn databaseserverens fysiske minne.\n\n## Les mer\n\n- [RFC 9110: HTTP Semantics, section 3.3](https://www.rfc-editor.org/rfc/rfc9110#section-3.3)\n  — tilkoblinger, klienter og servere, og den tilstandsløse utformingen som lar\n  implementasjoner fordele forespørsler over flere servere.\n- [PostgreSQL: Table Partitioning](https://www.postgresql.org/docs/current/ddl-partitioning.html)\n  — hva partisjonering er, når den lønner seg, og hvordan partition pruning\n  hopper over partisjonene en spørring ikke kan trenge.\n- [PostgreSQL: pg_stat_statements](https://www.postgresql.org/docs/current/pgstatstatements.html)\n  — utvidelsen som tar vare på antall kall og kjøretid for hver normaliserte\n  setning.\n- [PostgreSQL: Hot Standby](https://www.postgresql.org/docs/current/hot-standby.html)\n  — lesespørringer på en standby, og konfliktene som kan avbryte\n  dem.\n- [RFC 9111: HTTP Caching](https://www.rfc-editor.org/rfc/rfc9111)\n  — hvordan HTTP-cacher lagrer og gjenbruker svar, slik at gjentatte\n  forespørsler slipper å gå helt til opprinnelsesserveren.\n\n\u003chttps://engineer.company/nb/glossary/scalability/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Større server, flere servere eller bedre spørringer? Slik vurderer du skalerbarhet før regningen vokser raskere enn lasten.","formats":{"gemtext":"https://engineer.company/nb/glossary/scalability/index.gmi","gopher":"https://engineer.company/nb/glossary/scalability/gophermap","html":"https://engineer.company/nb/glossary/scalability/","json":"https://engineer.company/nb/glossary/scalability/index.json","markdown":"https://engineer.company/nb/glossary/scalability/index.md","pdf":"https://engineer.company/nb/glossary/scalability/index.pdf"},"kind":"page","language":"nb","title":"Hva er skalerbarhet?","url":"https://engineer.company/nb/glossary/scalability/","version":1}