{"canonical_url":"https://engineer.company/da/glossary/scalability/","content_markdown":"# Skalerbarhed\n\n## Hvad det er\n\nSkalerbarhed er den måde, et systems kapacitet vokser på, når der tilføjes\nressourcer. Et system skalerer godt, når dobbelt så mange maskiner bærer omtrent\ndobbelt så meget belastning med de samme svartider, og dårligt, når den ekstra\nhardware mest venter på noget, den ikke kan hjælpe med. Ordet beskriver et\nforhold mellem belastning og omkostning, ikke en egenskab, et system enten har\neller mangler.\n\nDer er to retninger at vokse i. At skalere op, vertikal skalering, betyder en\nstørre maskine: flere kerner, mere hukommelse, hurtigere diske. Det kræver\ningen ændring af softwaren og stopper ved den største maskine, det kan betale\nsig at købe. At skalere ud, horisontal skalering, betyder flere maskiner, der\ndeler arbejdet. Her er der ikke samme loft, men kun arbejde, der kan deles op,\nfår gavn af det.\n\nHTTP er formet med udskalering for øje. RFC 9110 bemærker, at mange\nimplementeringer bygger på HTTP's tilstandsløse design for at genbruge\nforbindelser gennem proxyer eller fordele forespørgsler dynamisk på flere\nservere. Et weblag, der ikke gemmer noget mellem forespørgslerne, kan vokse ved\nat sætte flere kopier af sig selv bag en load balancer, og enhver kopi kan\nbesvare enhver forespørgsel.\n\nBelastning har mere end én dimension, og et system kan skalere i én og gå i stå\ni en anden: forespørgsler i sekundet, mængden af lagrede data, antallet af\nlejere og antallet af skrivere, der kæmper om den samme post. Den sidste er den\nsværeste, fordi en enkelt række kun kan ændres af én transaktion ad gangen,\nuanset hvor mange servere der står omkring den.\n\nRegnestykket bag det er Amdahls lov. Når en del af arbejdet skal køre i\nrækkefølge, gør parallel hardware kun resten hurtigere, så den sekventielle del\nsætter grænsen: er 5 % af arbejdet serielt, kan hele jobbet aldrig køre mere end\n20 gange hurtigere, heller ikke på tusind maskiner. I en database er den\nserielle del ofte en lås. I en applikation er den ofte én delt tæller, én kø\neller ét sessionslager.\n\n## Hvorfor det betyder noget\n\nSkalerbarheden afgør, hvad vækst koster. Når et system skalerer godt, er en\nfordobling af trafikken en linje på en faktura. Når det skalerer dårligt, vokser\nregningen hurtigere end belastningen, eller mere hardware holder helt op med at\nhjælpe, og løsningen bliver et redesign, der skal udføres, mens trafikken\nstrømmer ind.\n\nHardware kan afhjælpe flaskehalse i processorer, hukommelse eller diske, men\nineffektivt arbejde og krav om sekventiel udførelse kan bestå. En forespørgsel,\nder unødigt scanner en hel tabel, kan stadig udføre overflødigt arbejde på en\nstørre server. En større maskine fjerner ikke kravet om, at opdateringer af den\nsamme række skal udføres én ad gangen, og flere applikationsservere kan øge\nantallet af skrivende klienter i køen. De fleste systemer, der ser ud til at\nhave brug for flere maskiner, skal læses først.\n\nI PostgreSQL er stedet at begynde at læse `pg_stat_statements`, en udvidelse,\nder registrerer hver normaliseret sætning med antal kald og udførelsestid.\nSorteret efter samlet tid frem for gennemsnit viser den, hvor serveren faktisk\nbruger sig selv: en forespørgsel, der tager 2 ms og kører en million gange i\ntimen, koster 2.000 sekunder af den time, mens en rapport på to sekunder, der\nkører to gange, 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 skridt mod flere maskiner har sine egne driftsomkostninger, og derfor\nbetyder rækkefølgen noget. En strammere sætning eller et bedre indeks kan\nforbedre ydeevnen uden at tilføje endnu en server. En læsereplika er\nkonfiguration. Partitionering ændrer én tabel. Sharding, hvor data deles ud på\nseparate databaseservere, ændrer driften omkring dem: migreringer, backup,\ngendannelser og rapporter skal tage højde for separate shards; en joinoperation\npå tværs af shards kan flyttes til applikationskoden; og en forespørgsel, der\nikke kender sin shardnøgle, kan være nødt til at spørge dem alle.\n\n## Sådan ser det ud i praksis\n\nEn PostgreSQL-database bag en mellemstor applikation rummede brugerkonti,\nlejere, geografiske data og dagligt elforbrug. Den kørte under lav belastning,\nmen blev langsommere, efterhånden som datamængderne voksede. Opgaven var at\ngøre den\n[ti gange hurtigere uden at omlægge arkitekturen](/da/portfolio/accelerated-postgresql-performance-by-10x/),\nmed plads til fremtidig datavækst som en del af målet. Arbejdet var GiST-indeks\ntil de geografiske data, sammensatte indeks på lejer og datointerval,\neltabellen partitioneret efter tid, hash-partitionering af de geografiske data,\nomskrevne forespørgsler tjekket med `EXPLAIN ANALYZE` og connection pooling.\nSvartiderne blev ti gange bedre, databasens ressourceforbrug faldt med 40 %, og\nsystemet kunne tage imod voksende datamængder uden ydeevnetab og med mindre\nbehov for hardwareopgraderinger.\n\nI en mellemstor virksomhed med ti PostgreSQL- og SQL Server-databaseservere\nblev infrastrukturen\n[skaleret til 40 % mere brugertrafik uden servicetab](/da/portfolio/ran-10-postgresql-and-ms-sql-servers-on-ubuntu/).\nSamtidig blev svartiderne for forespørgsler 30 % bedre gennem\nkonfigurationstuning og indeksoptimering.\n\nRækkefølgen, arbejdet følger, er beskrevet i\n[en note om at optimere før sharding](/da/notes/optimise-before-you-shard/):\nkig, stram op, tag læsningerne væk fra den primære, partitionér tabellerne\nomkring det varme punkt, og shard først, når én maskine er fuld af godt\narbejde. Noten nævner tre tilfælde, hvor sharding er rimeligt: den primære er\nmættet af sætninger, der allerede er slanke, data er vokset fra deres\nvedligeholdelse, eller isolation er selve kravet.\n\n## Hvor det går galt\n\n**Flere webservere foran én database.** Hver applikationsserver åbner sine egne\nforbindelser, og når mange gange flere sessioner er aktive, end databasen har\nkerner, bruger serveren sin tid på at skifte mellem dem. En forbindelsespulje\nløser det, før nogen hardware gør, og endnu en webserver gør det værre.\n\n**Én varm række.** Når hver forespørgsel skriver til den samme post, for\neksempel en lagertæller eller en saldo, er gennemløbet begrænset til omtrent de\nskrivninger, én lås kan bære, divideret med den tid, låsen holdes, uanset\nantallet af maskiner. Alt langsomt inde i låsen sænker loftet. Hold\ntransaktionen kort, hold eksterne kald uden for den, og når én vare vokser fra\nsin maskine, så del dens lager op i mindre stykker, der hver har præcis én ejer.\n\n**Tilstand, der bor på én server.** Sessioner i én proces' hukommelse, uploads\nskrevet til dens lokale disk eller et planlagt job, der går ud fra, at det er\nden eneste kopi, forhindrer alle, at en anden instans kan være ligeværdig. Læg\nden tilstand i et fælles lager, så enhver instans kan besvare enhver\nforespørgsel.\n\n**Replikaer behandlet som kopier af den primære.** En streaming-replika ligger\nlidt bagefter, så en bruger, der lige har skrevet noget og derefter læser fra\nreplikaen, ser det måske ikke; læs nylige skrivninger fra den primære. En lang\nrapport på en standby kan også blive annulleret, når den holder de ændringer\ntilbage, der afspilles. PostgreSQL dokumenterer det som\nforespørgselskonflikter, sammen med de indstillinger, der afvejer\nreplikaforsinkelse mod dem.\n\n**Partitioner, forespørgslerne aldrig nævner.** Partitionering deler én tabel\nefter en nøgle, for eksempel en måned eller en lejer, så en forespørgsel, der\nnævner nøglen, kun læser de partitioner, den har brug for. En forespørgsel uden\nnøglen læser hver eneste partition og vinder intet ved opdelingen. Partitionér\nefter det, forespørgslerne allerede filtrerer på, og forvent kun en gevinst for\nstore tabeller: PostgreSQL-manualens tommelfingerregel er en tabel, der er\nstørre end databaseserverens fysiske hukommelse.\n\n## Læs mere\n\n- [RFC 9110: HTTP Semantics, section 3.3](https://www.rfc-editor.org/rfc/rfc9110#section-3.3)\n  — forbindelser, klienter og servere, og det tilstandsløse design, der lader\n  implementeringer fordele forespørgsler på flere servere.\n- [PostgreSQL: Table Partitioning](https://www.postgresql.org/docs/current/ddl-partitioning.html)\n  — hvad partitionering er, hvornår det betaler sig, og hvordan partition\n  pruning springer de partitioner over, en forespørgsel ikke kan få brug for.\n- [PostgreSQL: pg_stat_statements](https://www.postgresql.org/docs/current/pgstatstatements.html)\n  — udvidelsen, der holder styr på antal kald og tider for hver normaliseret\n  sætning.\n- [PostgreSQL: Hot Standby](https://www.postgresql.org/docs/current/hot-standby.html)\n  — læseforespørgsler på en standby og de konflikter, der kan\n  annullere dem.\n- [RFC 9111: HTTP Caching](https://www.rfc-editor.org/rfc/rfc9111)\n  — hvordan HTTP-caches gemmer og genbruger svar, så gentagne forespørgsler\n  ikke behøver at nå originserveren.\n\n\u003chttps://engineer.company/da/glossary/scalability/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hvad skalerbarhed betyder, at skalere op eller ud, hvorfor en delt række eller et serielt trin sætter loft, og hvad man måler før en ny databaseserver.","formats":{"gemtext":"https://engineer.company/da/glossary/scalability/index.gmi","gopher":"https://engineer.company/da/glossary/scalability/gophermap","html":"https://engineer.company/da/glossary/scalability/","json":"https://engineer.company/da/glossary/scalability/index.json","markdown":"https://engineer.company/da/glossary/scalability/index.md","pdf":"https://engineer.company/da/glossary/scalability/index.pdf"},"kind":"page","language":"da","title":"Hvad er skalerbarhed?","url":"https://engineer.company/da/glossary/scalability/","version":1}