{"canonical_url":"https://engineer.company/sv/glossary/scalability/","content_markdown":"# Skalbarhet\n\n## Vad det är\n\nSkalbarhet beskriver hur ett systems kapacitet växer när det får fler resurser.\nEtt system skalar bra när dubbelt så många maskiner bär ungefär dubbelt så\nmycket last med samma svarstider, och dåligt när den extra hårdvaran mest står\noch väntar på något den inte kan hjälpa till med. Ordet beskriver alltså ett\nförhållande mellan last och kostnad, inte en egenskap som ett system antingen\nhar eller saknar.\n\nDet finns två riktningar att växa i. Att skala upp, vertikal skalning, betyder\nen större maskin: fler kärnor, mer minne, snabbare diskar. Programvaran behöver\ninte ändras, och vägen tar slut vid den största maskin som är värd att köpa. Att\nskala ut, horisontell skalning, betyder fler maskiner som delar på arbetet. Där\nfinns inget sådant tak, men bara arbete som går att dela upp har nytta av det.\n\nHTTP formades med utskalning i tankarna. RFC 9110 påpekar att många\nimplementationer förlitar sig på att HTTP är tillståndslöst för att återanvända\nanslutningar via proxyer eller för att fördela begäranden dynamiskt över flera\nservrar. Ett webbskikt som inte sparar något mellan begärandena kan växa genom\natt ställa fler kopior av sig själv bakom en lastbalanserare, och vilken kopia\nsom helst kan då besvara vilken begäran som helst.\n\nLast har fler än en dimension, och ett system kan skala längs en av dem och köra\nfast längs en annan: begäranden per sekund, mängden lagrad data, antalet tenants\noch antalet processer som vill skriva till samma post samtidigt. Den sista är\nsvårast, eftersom en enskild rad bara kan ändras av en transaktion i taget, hur\nmånga servrar som än står runt den.\n\nRäknestycket bakom det heter Amdahls lag. När en del av arbetet måste köras i\nsekvens snabbar parallell hårdvara bara upp resten, och den sekventiella delen\nsätter gränsen: är 5 % av arbetet seriellt kan hela jobbet aldrig gå mer än 20\ngånger snabbare, inte ens på tusen maskiner. I en databas är den seriella delen\nofta ett lås. I en applikation är den ofta en enda delad räknare, en kö eller\nett sessionslager.\n\n## Varför det spelar roll\n\nSkalbarheten avgör vad tillväxt kostar. Skalar systemet bra blir en fördubbling\nav trafiken en rad på en faktura. Skalar det dåligt växer notan snabbare än\nlasten, eller så slutar mer hårdvara att hjälpa över huvud taget, och lösningen\nblir en omdesign som måste göras medan trafiken redan strömmar in.\n\nHårdvara kan avhjälpa flaskhalsar i processorer, minne eller diskar, men\nineffektivt arbete och krav på sekventiell körning kan finnas kvar. En\ndatabasfråga som i onödan skannar en hel tabell kan fortfarande utföra\növerflödigt arbete på en större server. En större maskin tar inte bort kravet på\natt uppdateringar av samma rad utförs en i taget, och fler applikationsservrar\nkan öka antalet skrivande klienter i kön. De flesta system som ser ut att behöva\nfler maskiner behöver först läsas.\n\nI PostgreSQL börjar läsningen i `pg_stat_statements`, ett tillägg som\nregistrerar varje normaliserad sats med antal anrop och körtid. Sorterad på\ntotal tid i stället för på medelvärde visar den var servern faktiskt lägger sin\ntid: en SQL-fråga som tar 2 ms och körs en miljon gånger i timmen kostar 2 000\nsekunder av den timmen, medan en rapport på två sekunder som körs två gånger\nkostar fyra.\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\nVarje steg mot fler maskiner för med sig egna driftkostnader, och därför spelar\nordningen roll. En stramare sats eller ett bättre index kan förbättra prestandan\nutan att lägga till ännu en server. En läsreplik är konfiguration.\nPartitionering ändrar en tabell. Sharding, där datan delas upp på separata\ndatabasservrar, ändrar driften runt omkring: migreringar, säkerhetskopiering,\nåterställning och rapporter måste ta hänsyn till separata shards; en join över\nshards kan flyttas till applikationskoden; och en SQL-fråga som inte\nkänner till sin shardnyckel kan behöva fråga alla.\n\n## Så ser det ut i praktiken\n\nEn PostgreSQL-databas bakom en medelstor applikation höll användarkonton,\ntenants, geografiska data och daglig elförbrukning. Trafiken var låg, men\ndatabasen blev trögare i takt med att datavolymerna växte. Uppdraget var att\ngöra den\n[10 gånger snabbare utan att göra om arkitekturen](/sv/portfolio/accelerated-postgresql-performance-by-10x/),\noch utrymme för framtida datatillväxt var en uttalad del av målet. Arbetet\nbestod av GiST-index för de geografiska data, sammansatta index på tenant och\ndatumintervall, eltabellen partitionerad efter tid, hashpartitionering av\ngeodatan, omskrivna databasfrågor kontrollerade med `EXPLAIN ANALYZE` samt\nanslutningspoolning. Svarstiderna blev tio gånger bättre, databasens\nresursanvändning minskade med 40 %, och systemet tog emot växande datavolymer\nutan att bli långsammare, med mindre behov av hårdvaruuppgraderingar.\n\nPå ett medelstort företag med tio databasservrar för PostgreSQL och SQL Server\n[skalades infrastrukturen så att den klarade 40 % mer användartrafik utan försämrad tjänstekvalitet](/sv/portfolio/ran-10-postgresql-and-ms-sql-servers-on-ubuntu/).\nSamtidigt blev svarstiderna för databasfrågor 30 % bättre genom\nkonfigurationsjustering och indexoptimering.\n\nOrdningen som arbetet följer beskrivs i\n[en anteckning om att optimera innan man shardar](/sv/notes/optimise-before-you-shard/):\ntitta, skärp, flytta läsningarna från primärnoden, partitionera tabellerna runt\nden heta punkten och sharda först när en maskin är full av bra arbete.\nAnteckningen nämner tre fall där sharding är rimligt: primärnoden är mättad av\nsatser som redan är slimmade, datan har vuxit ifrån sitt underhåll, eller\nisoleringen är själva kravet.\n\n## Var det går fel\n\n**Fler webbservrar framför en databas.** Varje applikationsserver öppnar sina\negna anslutningar, och när många gånger fler sessioner är aktiva än databasen\nhar kärnor går serverns tid åt till att växla mellan dem. En anslutningspool\nlöser det innan någon hårdvara gör det, och ännu en webbserver gör saken värre.\n\n**En het rad.** När varje begäran skriver till samma post, t.ex. en lagerräknare\neller ett kontosaldo, stannar genomströmningen vid ungefär de skrivningar som\nett lås kan bära, delat med hur länge låset hålls, oavsett antal maskiner. Allt\nsom går långsamt inuti låset sänker taket. Håll transaktionen kort, lägg externa\nanrop utanför den, och när en vara växer ur sin maskin: dela upp dess lagersaldo\ni mindre poster som var och en har exakt en ägare.\n\n**Tillstånd som bor på en server.** Sessioner i minnet hos en enda process,\nuppladdade filer på dess lokala disk eller ett schemalagt jobb som utgår från\natt det är den enda kopian hindrar alla en andra instans från att bli likvärdig.\nLägg det tillståndet i en delad lagring, så att vilken instans som helst kan\nbesvara vilken begäran som helst.\n\n**Repliker som behandlas som kopior av primärnoden.** En strömmande replik\nligger lite efter, så en användare som just har skrivit något och sedan läser\nfrån repliken ser det kanske inte; läs nyss skrivna data från primärnoden. En\nlång rapport på en standby kan också avbrytas när den håller upp ändringarna som\nspelas upp. PostgreSQL dokumenterar det som frågekonflikter, tillsammans med de\ninställningar som väger replikens eftersläpning mot dem.\n\n**Partitioner som SQL-frågorna aldrig nämner.** Partitionering delar en tabell\nefter en nyckel, t.ex. en månad eller en tenant, så att en SQL-fråga som anger\nnyckeln bara läser de partitioner den behöver. En SQL-fråga utan nyckeln läser\nvarenda partition och vinner ingenting på uppdelningen. Partitionera på det som\nSQL-frågorna redan filtrerar på, och räkna med vinst bara för stora tabeller:\ntumregeln i PostgreSQL-manualen är en tabell som är större än databasserverns\nfysiska minne.\n\n## Läs mer\n\n- [RFC 9110: HTTP Semantics, section 3.3](https://www.rfc-editor.org/rfc/rfc9110#section-3.3)\n  — anslutningar, klienter och servrar, och den tillståndslösa design som låter\n  implementationer fördela begäranden över flera servrar.\n- [PostgreSQL: Table Partitioning](https://www.postgresql.org/docs/current/ddl-partitioning.html)\n  — vad partitionering är, när den lönar sig och hur partition pruning hoppar\n  över de partitioner som en SQL-fråga inte kan behöva.\n- [PostgreSQL: pg_stat_statements](https://www.postgresql.org/docs/current/pgstatstatements.html)\n  — tillägget som håller räkningen på anrop och tider för varje normaliserad\n  sats.\n- [PostgreSQL: Hot Standby](https://www.postgresql.org/docs/current/hot-standby.html)\n  — SQL-frågor som bara läser på en standby och de konflikter som kan avbryta\n  dem.\n- [RFC 9111: HTTP Caching](https://www.rfc-editor.org/rfc/rfc9111)\n  — hur HTTP-cachar sparar och återanvänder svar, så att upprepade begäranden\n  inte behöver nå ursprungsservern.\n\n\u003chttps://engineer.company/sv/glossary/scalability/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"För dig som planerar för tillväxt: att skala upp eller ut, varför en delad rad sätter taket och vad du mäter innan nästa databasserver köps in.","formats":{"gemtext":"https://engineer.company/sv/glossary/scalability/index.gmi","gopher":"https://engineer.company/sv/glossary/scalability/gophermap","html":"https://engineer.company/sv/glossary/scalability/","json":"https://engineer.company/sv/glossary/scalability/index.json","markdown":"https://engineer.company/sv/glossary/scalability/index.md","pdf":"https://engineer.company/sv/glossary/scalability/index.pdf"},"kind":"page","language":"sv","title":"Vad är skalbarhet?","url":"https://engineer.company/sv/glossary/scalability/","version":1}