{"canonical_url":"https://engineer.company/sv/glossary/load-test/","content_markdown":"# Lasttest\n\n## Vad det är\n\nEtt lasttest skickar en planerad mängd simulerad trafik mot ett system och mäter\nhur systemet beter sig medan det bär den: hur lång tid svaren tar, hur många\nbegäranden som misslyckas, hur stort genomflöde det klarar att hålla och vad\nservrarna lägger kraften på under tiden. Trafiken kommer från ett skript som\nspelar många användare på en gång; verktyget k6 kallar var och en av dem en\nvirtuell användare. Lasttestning är aktiviteten, och ett lasttest är en körning\nav den, med en form, en längd och kriterier för att bli godkänd. På engelska\nheter det load test.\n\nOrdet används både brett och snävt. Dokumentationen till k6, som Grafana Labs\nger ut, sorterar tester efter den last de lägger på. Ett smoke test kör en\nhandfull virtuella användare för att bevisa att skriptet fungerar. Ett\naverage-load test simulerar en vanlig dag i produktion. Ett stresstest går över\ngenomsnittet, ett soak test håller genomsnittlig last i timmar, ett spike test\nskickar en plötslig och mycket kraftig topp under några få minuter, och ett\nbreakpoint test höjer lasten tills något ger vika. Eftersom den engelska termen\nkan täcka varje test som simulerar trafik, kallar k6 den snäva sorten ett\naverage-load test och nämner att vissa team säger day-in-life test eller volume\ntest. Guiden är ärlig om ordförrådet: ”no consensus even exists about the names\nof these test types”. Kategorierna är också relativa. Ett stresstest för en\napplikation är ett average-load test för en annan.\n\nEtt lasttest är inte ett funktionellt test. Det frågar inte om kassan räknar\nihop varukorgen rätt; det frågar om kassan fortfarande svarar, och hur snabbt,\nmedan en realistisk mängd människor använder den. De två behöver varandra: ett\nskript som skickar trasiga begäranden i högt tempo mäter bara hur fort systemet\nsäger nej.\n\n## Varför det spelar roll\n\nVarje system har en trafiknivå där det inte längre hinner med, och frågan är\nbara vem som hittar den först. Locust, ett lasttestverktyg med öppen källkod där\ntesterna skrivs i vanlig Python, visar formen i sin quickstart. Allt eftersom\nverktyget lägger till användare kommer en punkt, runt 20 användare i exemplet,\ndär svarstiderna stiger så fort att antalet begäranden per sekund slutar öka,\ntrots att fler användare hela tiden tillkommer. Dokumentationen kallar målet\növerbelastat eller mättat. Den knäcken är systemets verkliga kapacitet som det\när byggt, oavsett vad arkitekturskissen lovar, och det är mycket billigare att\nhitta den vid en generalrepetition än framför kunderna.\n\nSjälva upprampningen mot knäcken säger också något. k6:s guide till average-load\ntests säger att det första resultatet syns medan lasten fortfarande ökar: om\nsvarstiden försämras när trafiken växer, och om systemet fallerar innan det ens\nnår full last. Platån visar sedan om prestanda och resursanvändning håller sig\nstabila, eftersom vissa system blir oberäkneliga just under den sträckan.\n\nLasttester gör dessutom prestanda till en kontroll i stället för en åsikt. k6\nlåter ett skript deklarera thresholds, tröskelvärden för godkänt eller underkänt\npå dess mätvärden, till exempel att färre än 1 % av begärandena misslyckas eller\natt 95 % av svaren kommer inom 200 ms. k6:s dokumentation påpekar att testare\nofta använder tröskelvärden för att skriva ned sina servicenivåmål. När alla\ntröskelvärden håller avslutar k6 med slutkod 0, och när något av dem fallerar\navslutar det med en kod som inte är 0, så att en pipeline kan stoppa en release\nsom gjorde tjänsten långsammare, utan att någon behöver läsa en graf.\n\n## Så ser det ut i praktiken\n\nTa en webbutik som förbereder en rea. Det mesta av trafiken under en rea kommer\nfrån folk som inte får varan, så svaret som måste hålla är ”slutsålt”, och det\när den vägen som ska övas först. Testet nedan är skrivet i k6. Det startar\nbegäranden i en fast takt i stället för med ett fast antal användare, rampar upp\ntill 2 000 begäranden per sekund under tre minuter, håller det i tjugo och\nrampar ned igen. Formen följer k6:s råd för average-load tests: upprampningen\ntar 5 till 15 % av testet, platån varar minst fem gånger så länge som\nupprampningen och nedrampningen ungefär lika länge som upprampningen. Ett spike\ntest, som k6 föreslår för biljettsläpp, produktlanseringar och säsongsreor,\nskulle komma efteråt med nästan ingen upprampning alls; det här bevisar först\natt svaret slutsålt håller i en jämn takt.\n\n```javascript\nimport http from 'k6/http';\n\nexport const options = {\n  scenarios: {\n    sold_out: {\n      executor: 'ramping-arrival-rate',\n      startRate: 0,\n      timeUnit: '1s',\n      preAllocatedVUs: 400,\n      stages: [\n        { target: 2000, duration: '3m' },\n        { target: 2000, duration: '20m' },\n        { target: 0, duration: '3m' },\n      ],\n    },\n  },\n  thresholds: {\n    http_req_failed: ['rate\u003c0.01'],\n    http_req_duration: ['p(95)\u003c200'],\n    dropped_iterations: ['count\u003c1'],\n  },\n};\n\nexport default function () {\n  http.get('https://shop.example/sale/items/4711');\n}\n```\n\nKör det med `k6 run sold-out.js`. Antalet virtuella användare är en uppskattning\nsom k6:s dokumentation ger en formel för: medianen av iterationstiden gånger\ntakten, plus en marginal. Vid 2 000 begäranden per sekund och ungefär en\ntiondels sekund för varje är 200 virtuella användare upptagna samtidigt, och 400\nger utrymme. Blir svaren långsammare varar varje iteration längre, poolen tar\nslut och k6 räknar de iterationer det inte kunde starta i `dropped_iterations`.\nDärför finns det tredje tröskelvärdet med: en tappad iteration betyder att\ntestet inte skickade den last det påstår, och k6 påpekar att tappade iterationer\nockså kan tyda på att systemets prestanda försämras. De andra två tröskelvärdena\nunderkänner körningen om minst 1 % av begärandena misslyckas eller om 95:e\npercentilen är 200 ms eller högre.\n\nScenariot kommer från anteckningen här på webbplatsen om att\n[sälja den sista biljetten exakt en gång](/sv/notes/selling-limited-stock-without-overselling/).\nMed en miljon köpare och tiotusen enheter måste 990 000 begäranden misslyckas,\npåpekar den, så avvisningen måste vara det billigaste svar systemet ger.\nAvsnittet om att bevisa designen tar upp lasttestning av avvisningarna: vägen\nför slutsålt måste förbli snabb när den är 99 % av trafiken, och edge-nätverket\nmåste ta upp den. Ett test som bara övar ett lyckat köp mäter den enda procent\nsom betyder minst för kapaciteten.\n\n## Var det går fel\n\n**Testet väntar på systemet det mäter.** I det k6 kallar den stängda modellen\nstartar varje virtuell användare sin nästa iteration först när den förra är\nklar. När servern blir långsammare blir användarna det också, ankomsttakten\nsjunker och systemet får ett mildare test än det planerade, en effekt som enligt\nk6 kallas coordinated omission i delar av litteraturen. Riktiga besökare väntar\ninte på varandra. När frågan är om ett system klarar en given takt av\nbegäranden, använd en executor från den öppna modellen, som\n`constant-arrival-rate` eller `ramping-arrival-rate`, som startar iterationer\nenligt schemat oavsett svarstid.\n\n**Lastgeneratorn är flaskhalsen.** Får maskinen som kör testet slut på virtuella\nanvändare, CPU eller minne beskriver resultaten generatorn och inte målet. k6\navråder från `maxVUs` i de flesta fall, eftersom det kostar CPU och minne att\nlägga till virtuella användare medan testet kör, och det kan överbelasta\ngeneratorn och snedvrida resultaten. Dimensionera `preAllocatedVUs` i förväg med\nnågra lokala provkörningar och håll ett öga på `dropped_iterations`. Locust\nfördelar lasten över flera maskiner med en master-process och många workers när\nen maskin inte räcker.\n\n**Den första körningen är den största.** k6:s dokumentation berättar att\ntusentals av dess användare har kört lasttester som snabbt fick deras\napplikationer eller staging-miljöer att gå ned. Börja med ett smoke test med\nnågra få virtuella användare för att bevisa skript och miljö, kör sedan ett\naverage-load test, och först därefter ett stresstest; k6 kallar den ordningen\navgörande. Problem som syns vid låg volym är mycket lättare att hitta innan\nlasten är hög.\n\n**Lasten går upp och ned som en berg-och-dalbana.** Ett mönster som stiger och\nsjunker flera gånger slösar resurser och gör det svårt att se vilken ändring som\ngav vilket symtom. k6 rekommenderar en riktning i taget: rampa upp, håll en\nplatå, rampa ned. Håll också scenario, data och miljö lika mellan körningarna,\nså att två resultat över huvud taget går att jämföra.\n\n**Ingen har bestämt vad godkänt betyder.** En körning som slutar med en sida\nfull av diagram och inga kriterier läses olika av alla som tittar på den, oftast\nvälvilligt. Skriv tröskelvärdena före körningen utifrån det mål tjänsten hålls\ntill, och låt slutkoden avgöra. Vid långa körningar kan k6 avbryta så fort ett\ntröskelvärde fallerar med `abortOnFail`, och `delayAbortEval` hindrar att det\nstoppar innan tillräckligt många mätvärden har kommit in för att betyda något.\n\n**En testtyp behandlas som hela svaret.** Ett average-load test säger lite om en\nrea som kommer på några sekunder, och ett spike test säger lite om ett fel som\nförst visar sig efter timmar av jämn användning. k6 är tydligt med att ingen\nenskild testtyp tar bort all risk, och att riskprofilen avgör blandningen: ett\nsystem som är utsatt vid långvarig användning behöver soak tests först, och ett\nsom är utsatt vid intensiv användning behöver stresstester. En topp kan också\nsätta i gång processer som aldrig körs en vanlig dag, så skriptet måste ta med\ndem.\n\n## Läs mer\n\n- [Load test types](https://grafana.com/docs/k6/latest/testing-guides/test-types/)\n  — k6:s översikt över smoke, average-load, stress, soak, spike och breakpoint\n  tests, med den last och längd som är typisk för var och en.\n- [Average-load testing](https://grafana.com/docs/k6/latest/testing-guides/test-types/load-testing/)\n  — hur upprampning, platå och nedrampning formas och vad du kan läsa ut av\n  varje del.\n- [Thresholds](https://grafana.com/docs/k6/latest/using-k6/thresholds/) — k6:s\n  kriterier för godkänt och underkänt, deras syntax och hur ett underkänt\n  tröskelvärde sätter slutkoden.\n- [Open and closed models](https://grafana.com/docs/k6/latest/using-k6/scenarios/concepts/open-vs-closed/)\n  — varför ett test där användarna väntar på svar får ett långsamt system att se\n  bättre ut.\n- [Arrival-rate VU allocation](https://grafana.com/docs/k6/latest/using-k6/scenarios/concepts/arrival-rate-vu-allocation/)\n  — hur många virtuella användare ett test med öppen modell behöver och vad\n  tappade iterationer betyder.\n- [What is Locust?](https://docs.locust.io/en/stable/what-is-locust.html)\n  — Locust-dokumentationens egen beskrivning av ett lasttestverktyg i Python och\n  dess distribuerade läge.\n\n\u003chttps://engineer.company/sv/glossary/load-test/\u003e\n","date_modified":"2026-11-08T11:12:58Z","description":"Vad ett lasttest mäter, hur det skiljer sig från stress-, soak- och spike-tester, hur du skriver ett med tröskelvärden och var resultaten vilseleder.","formats":{"gemtext":"https://engineer.company/sv/glossary/load-test/index.gmi","gopher":"https://engineer.company/sv/glossary/load-test/gophermap","html":"https://engineer.company/sv/glossary/load-test/","json":"https://engineer.company/sv/glossary/load-test/index.json","markdown":"https://engineer.company/sv/glossary/load-test/index.md","pdf":"https://engineer.company/sv/glossary/load-test/index.pdf"},"kind":"page","language":"sv","title":"Vad är ett lasttest?","url":"https://engineer.company/sv/glossary/load-test/","version":1}