Back to "Load Testing ASP.NET Core Applications with k6: Introduction"

This is a viewer only at the moment see the article on how this works.

To update the preview hit Ctrl-Alt-R (or ⌘-Alt-R on Mac) or Enter to refresh. The Save icon lets you save the markdown file to disk

# Load Testing ASP.NET Core Applications with k6: Introduction

<datetime class="hidden">2025-12-02T14:00</datetime>

Din applikation fungerar perfekt på din bärbara dator. Enhetens tester klarar sig . Integreringstesten klarar mig M SK2 Du laddar dig in i produktionen , och plötsligt hamnar allting i axeln Mska4 Femhundra verkliga användare träffar din hemsida samtidigt M Ska5 och din server börjar återvända | Mska6 fel Mske7 Din noggrant skapade kackerstrategi Mka8 visar sig att den inte fungerar som du trodde, Mska9 den datansökningen du trodde var snabb, M Ska11 Det är det som skapar en flaskhalva på skala, Mka13

Det här är ett mardrömscenario som alla utvecklare fruktar, men de flesta testar inte för **Trädskapstest är optionellt. Det är skillnaden mellan en lyckad start och en AM akutsida.** Denna guide med två delar visar er exakt hur man förhindrar detta scenario genom att använda k6, det moderna lasttestverktyget som är tillräckligt kraftfullt för företagsapplikationer men enkelt att köra i din CI

Det här är **Del 1** av en tvåpartserie på lasttestning med k6:

- **Del 1 (den här artikelnM SK2**: Introduction till kM SK1 installering , testtyper, och varför kSSK4
- **[Del 2: Praktisk implementation](/blog/k6-testing-practical)**: skrivande tester , CI

## Inleiding

Performancetestning är avgörande för alla produktions ASP.NET Core-applikationen . Oavsett om du är på väg att bygga en enkel blogg, ,, en komplex mikrotjänsternaad architecture, ,, eller en företags-application,,, så måste du veta hur din applikation beter sig under last.

Den här kompletta guidan visar hur man laddar testversioner av ASP.NET Core-applikationer [k6](https://k6.io/) - en av de mest kraftfulla öppna ♫ - ♫ källkodslasttestverktyg som finns ♫ [MinimalBlog](/blog/minimalblog-introduction) som vår exempelapplikation ( en enkel markering -baserad blogg med minne och utgångscaching), teknikerna och mönsterna som visas här gäller **vilken ASP.NET Core-applikation som helst**.

Till slutet av dessa två delar ser man

- Installera och konfigurera k6 på vilken plattform som helst.
- skriva omfattande test för olika scenarior
- Integrera k6 i din CI/CD pipeline med GitHub Actions
- Använd profileringsverktyg (dotTrace , dotMemory) tillsammans med kM SK3 för att hitta bottlenecks
- Implementera olika teststrategier
- Konfigurera utvecklingsdetektorn för att förhindra att långsam kod når produktionen

**Varför MinimalBlog som exempel?** Det är en riktig ASP-Applikation.

[TOC]

## Vad är k6 och varför använder man det

[k6](https://k6.io/) är ett modernt dragtestverktyg byggt för utvecklare.

- **Developer-vänlig**: Test är skrivna i JavaScript (ES6+)
- **CLI-first**: Perfekt för CI
- **Litevikt**: Enkel binär , inga beroende
- **Precision**: skrivet i Go för exakta mätningar
- **Skriptbar**: Hela programmerningsförmågan för komplexa scenarior
- **moln - redo**: Kan integreras med k6 Cloud, GrafanaM SK3 Prometheus

För MinimalBlog, k6 är idealt eftersom

1. **Vi kan testa kassering**: k6 kan bedöma kaskedjuster och beteende
2. **Vi kan simulera riktig trafik**: Testa flera samtida användare
3. **Vi kan bedöma prestationer**: mäta faktiska responsstid
4. **Vi kan integrera med CI/CD**: Automatiserade tester i vår pipeline
5. **Vi kan testa specifika scenarior**: Kategorisfilterning , individuella poster M SK2 hemsida

## Installerar k6

### Windows installering

**Option 1: Med chokladkaka | ( | Rekomenderad |)**

```powershell
choco install k6
```

**Option 2: med hjälp av Winget**

```powershell
winget install k6 --source winget
```

**Option 3: Handinstallation**

1. ladda ner den senaste versionen av Windows från [GitHub-utsläpp](https://github.com/grafana/k6/releases)
2. Extrahera `k6.exe` file
3. Lägg till katalogen i din PATH eller flytta `k6.exe` till en katalog som redan finns i PATH

**Verifiera installering:**

```powershell
k6 version
```

### Macinstallation

**Option 1: Med hemmabröd (Empfohlend)**

```bash
brew install k6
```

**Option 2: med MacPorts**

```bash
sudo port install k6
```

**Option 3: Handinstallation**

```bash
# Download and install the latest release
curl -O -L https://github.com/grafana/k6/releases/latest/download/k6-macos-amd64.zip
unzip k6-macos-amd64.zip
sudo cp k6-macos-amd64/k6 /usr/local/bin/
sudo chmod +x /usr/local/bin/k6
```

**Verifiera installering:**

```bash
k6 version
```

### Linuxinstallation

**Option 1: Genom att använda paketadministratörer**

För **Debian/Ubuntu**:

```bash
sudo gpg -k
sudo gpg --no-default-keyring --keyring /usr/share/keyrings/k6-archive-keyring.gpg --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys C5AD17C747E3415A3642D57D77C6C491D6AC1D69
echo "deb [signed-by=/usr/share/keyrings/k6-archive-keyring.gpg] https://dl.k6.io/deb stable main" | sudo tee /etc/apt/sources.list.d/k6.list
sudo apt-get update
sudo apt-get install k6
```

För **Fedora/CentOS/RHEL**:

```bash
sudo dnf install https://dl.k6.io/rpm/repo.rpm
sudo dnf install k6
```

**Option 2: med Snap**

```bash
sudo snap install k6
```

**Option 3: Handinstallation**

```bash
# Download the latest release
curl -O -L https://github.com/grafana/k6/releases/latest/download/k6-linux-amd64.tar.gz
tar -xzf k6-linux-amd64.tar.gz
sudo cp k6-linux-amd64/k6 /usr/local/bin/
sudo chmod +x /usr/local/bin/k6
```

**Option 4: med hjälp av Docker**

```bash
docker pull grafana/k6:latest

# Run a test
docker run --rm -i grafana/k6:latest run - <script.js
```

**Verifiera installering:**

```bash
k6 version
```

## Understanding k6 Testanatomi

Innan vi dyker in i tester, låt oss förstå den grundläggande strukturen av en k-test.

```javascript
import http from 'k6/http';
import { check, sleep } from 'k6';

// Test configuration
export const options = {
  vus: 10,              // Virtual users
  duration: '30s',      // Test duration
};

// Setup function (runs once before test)
export function setup() {
  // Prepare test data
  return { baseUrl: 'http://localhost:5000' };
}

// Main test function (runs for each VU)
export default function(data) {
  const response = http.get(data.baseUrl);

// Assertions
 check(response, {
 'status is 200': (r) => r.status === 200,
 'response time < 200ms': (r) => r.timings.duration < 200,
 });

sleep(1); // Wait between iterations
}

// Teardown function (runs once after test)
export function teardown(data) {
  // Clean up
}
```

Key concepts:

- **Virtuella användare (VUs)**: simulerade samtida användare
- **Tyd**: Hur länge testern körs
- **Kontroller**: Behauptelser som inte stoppar testet
- **tröskeln**: Pass
- **Metrik**: Reaktionstid , genomspetsning

## Typer av Leistungstest

Innan du testar din applikation, låt dig förstå de fem stora typerna av lasttest och när man ska använda varje.

```mermaid
graph TD
    A[Performance Testing Types] --> B[Smoke Test]
    A --> C[Load Test]
    A --> D[Stress Test]
    A --> E[Spike Test]
    A --> F[Soak Test]

B --> B1[1-2 VUs 30s-1min Basic Functionality]
 C --> C1[Normal Load 5-15 minutes Verify SLAs]
 D --> D1[Gradual Increase 10-30 minutes Find Breaking Point]
 E --> E1[Sudden Spike 5-10 minutes Test Recovery]
 F --> F1[Normal Load Hours/Days Memory Leaks]

style B stroke:#90EE90
    style C stroke:#87CEEB
    style D stroke:#FFD700
    style E stroke:#FF6347
    style F stroke:#DDA0DD
```

### 1. röktester

**Föremål**: Verifiera att systemet fungerar under minimal last

**När man ska använda**:

- Efter varje kodförändring
- Innan man kör mer intensiva tester
- Som en sanitetskontroll i CI/CD

**Besonderheiter**:

- 1-2 VUs
- Kortliv (30s-1minM SK2
- Testar grundläggande funktionalitet

### 2. Ladetester

**Föremål**: Bedömer prestation under förväntad normallast

**När man ska använda**:

- För att få upp en basnivå för prestationer
- För att verifiera att SLAs är uppfyllda
- Regellig prestansregressionstest

**Besonderheiter**:

- Ett realistiskt antal användare
- Hållbar belastning
- Den typiska tiden : 5-15 minuter

### 3. Stresstest

**Föremål**: Hitta systembrottspunkt

**När man ska använda**:

- För att förstå kapacitetgränser
- För att identifiera bottlenecks
- Planering för skalering

**Besonderheiter**:

- Gradvis ökande belastning
- Springa bortom normal kapacitet
- Tydlighet: 10-30 minuter

### 4. Spiketest

**Föremål**: Testbeteende under plötsliga trafikstockningar

**När man ska använda**:

- Att förbereda för lansering av produkter
- Testar automatiskt-scaling
- Att validera fallbackbeteendet

**Besonderheiter**:

- Plötsligt stora ökning av last
- Kort spikedauer
- Hela tiden : 5-10 minuter

### 5. Soak-tester

**Föremål**: Hitta minneslekar och nedbrytning över tid

**När man ska använda**:

- Innan större releases
- Att testa långa services
- Validatering av resurser

**Besonderheiter**:

- Normala belastningsnivåer
- Duration prolongerad ( timmar eller dagar )
- Monitor för nedbrytning

```mermaid
graph LR
    A[Start] --> B{Smoke Test Pass?}
    B -->|No| C[Fix Issues]
    C --> A
    B -->|Yes| D{Load Test Pass?}
    D -->|No| E[Optimize]
    E --> D
    D -->|Yes| F{Stress Test}
    F --> G{Found Limit?}
    G -->|Yes| H[Document Capacity]
    G -->|No| I[Increase Load]
    I --> F
    H --> J{Spike Test Pass?}
    J -->|No| K[Improve Resilience]
    K --> J
    J -->|Yes| L{Soak Test}
    L --> M{Memory Stable?}
    M -->|No| N[Fix Memory Leaks]
    N --> L
    M -->|Yes| O[Production Ready]

style O stroke:#90EE90
```

## Varför k6 och inte

Med så många lasttestverktyg tillgängliga

### k6 mot Apache JMeter

**Apache JMeter** är veteranen av lasttestverktyg ( sedan 1999).

| Funktionen | kM SK2 | | JMeter | | |
|---------|----|---------|
| **Installation** | Enkel binär
| **Testdefinitionen** | JavaScript-kod | XML eller GUI
| **Ressourcenanvändning** | Lågvikt (Go) ♫ ♫ | ♫ Smärt ♫
| **CI/CD integrering** | Utmärkt CLI-firstM SK3 | kräver plugins M|
| **Lärningskurvan** | Enkel för utvecklare | Steeper, GUIM SK3 fokuserad |
| **Protokollstöd** | HTTPM SK1 WebSockets, gRPC | Broader ( FTPMska5 JDBCM Ska6 SMTPMka7 etc

**När ska man använda JMeter istället:**

- Benötig GUI för icke- tekniska tester
- Testprotokoll bortom HTTP (JDBC, LDAP , SOAPM SK3
- Ännu har JMeter expertis i ett lag
- Man behöver ett omfattande plugin ekosystem

**Varför är k6 bättre för de flesta ASP-apps**

- snabbare att skriva tester (JavaScript vs XML)
- Litere resursavtryck
- Bättre CI/CD integrering
- Mer moderna utvecklare-upplevelser

### k6 mot Locust

**Stackdjur** är en Python-baserad belastningstestningsprogram som är populär i Python-butiker

| Funktionen | k6 | | 3 | Stack | 4 |
|---------|----|---------|
| **Språk** | JavaScript | Python |
| **Förmågor** | Väldigt snabbt (Ljumpningstid
| **Ärligt att använda** | Enkel JavaScript | Pythonic, enkel |
| **Distribuerade tester** | kM SK1 moln (betaledd) | byggt
| **Webbens gränssnitt** | Begränsat | Utmärkt verklig | - | tidig gränssnitt
| **Metrik Export** | Många format | CSV, webbgränssnitt

**När använda Locust istället:**

- Python-first team
- Bra att göra gratis distribuerade tester
- Vill ha en real- ---tids-web-UI under tester
- Kompleks Pythonlogi i tester

**Varför är k6 bättre för de flesta ASP-apps**

- Bättre resultat för korrekta mätningar
- JavaScript är mer välbekant för webbutvecklare
- renare tröskel
- Bättre Prometheus/Grafana integration

### k6 mot Gatling

**Gatling** är ett Scala-baserat verktyg med utmärkt rapporterande

| Funktion | kM SK2 | Gatling M|
|---------|----|---------|
| **Språk** | JavaScript | Scala
| **rapporter** | Grundversionen | (+ | Extensioner |) | ♫ | | Lika uppbyggda | МSK4 | i HTML-rapporter
| **Lärningskurvan** | Enkel | Mäktig ♫ ♫ ( ♫ Skala DSL ♫
| **Förmågor** | Utmärkt | Utvärdigt |
| **Open Source** | Till fullo öppet | Att öppna med företagstillsättning
| **Cloud Service** | kM SK1 moln | Gatling Enterprise |

**När ska man använda Gatling istället:**

- JVM/Scala expertis i ett team
- Man behöver fantastiska konstruerade reports
- Att testa komplexa HTTP-scenarier
- Erforderingar för företagsstöd

**Varför är k6 bättre för de flesta ASP-apps**

- JavaScript är mer tillgängligt
- Enklare Konfiguration och utföring
- Bättre för snabba CI/CD-kontroller
- Mer enkelt för enkla HTTP-testningar

### k6 mot Artillerie

**Artillerie** är ett annat testverktyg för JavaScripts laddande.

| Funktion | kM SK2 | Artillerie M|
|---------|----|---------|
| **Testdefinitionen** | JavaScript-kod | YAML + JS-häckar m|
| **Förmågor** | snabbare | ( | Go | ) | МSK3 | långsammare
| **Ärligt att använda** | Kod-baserade | YAML configM SK3baserad på |
| **byggt för** | Ladetestning | | | Lade |+ | funktionelltestning
| **Ägningar** | Utmärkta tröskeln | Grundgärningar
| **Extensibilitet** | Erweiterunger | Plugins |

**När man ska använda artillerie istället:**

- föredrar YAML än kod
- Bra att testa Socket
- Vill ha kombinerade last + funktionella tester
- Nu använder man Node.js ekosystem

**Varför är k6 bättre för de flesta ASP-apps**

- Mer exakta mätningar (Go vs Node.jsM SK2
- Ett bättre tröskelsystem
- En renare JavaScript API
- Mer mogna och stabila

### k6 mot wrk/wrkM SK2

**skämt** är en lätt HTTP- Benchmarking tool.

| Funktionen | k6 | wrk M|
|---------|----|---------|
| **Ärligt att använda** | HögaM SK1nivå API | lågt-nivå C + Lua |
| **Scenarier** | Den rika scenariotillgången | Bara basnivån HTTP
| **Metrik** | Den komplexa | Den grundläggande |
| **Skriptering** | JavaScript | Lua |
| **Använd fall** | Helalasttestning | | | Vinniga utgångspunkter ||

**När man ska använda wrk istället:**

- Det behövs absolut minimala överhead
- Vinniga ett---värder
- Att testa rå HTTP-presterande
- Protokolltestning på låg nivå

**Varför är k6 bättre för de flesta ASP-apps**

- Mycket enklare att skriva tester
- Bättre rapportering och mätningar
- Scenarisk stöd (rampM SK1up , steg
- CI/CD vänlig

### k6 mot Playwright

**Dramatiker** och **Cypress** är webbläsarens automatiserade verktyg som ibland används för laddande tester.

| Funktion | kM SK2 | Dramatiker/Cypress M|
|---------|----|---------|
| **Approach** | Protokoll
| **Förmågor** | Tusentals VUs | Tiotals webblader |
| **Ressourcenanvändning** | Lågvikt | Svårt ♫ ♫ ( ♫ webblader ♫
| **JavaScript- utdrag** | Nej | Ja |
| **Primära användarfall** | Ladetestning | E2E funktionell testning

**När ska man använda Playwright/Cypress istället:**

- Det behövs att testa JavaScripts Ausführung
- Det måste bedöma webbläraarens rendering
- Att testa komplexa SPA
- Funktionella E2E-tester

**Varför är k6 bättre för de flesta ASP-apps**

- Protokollet-tillräcklig testning för servern
- Man behöver simulera 100+ samtida användare
- Väldigt mer effektivt användande av resurser

### Summary: k6's Sweet Spot

**Välj k6 när du vill**

- Fast, korrekt lasttest
- Developer-vänlig JavaScript API
- Utmärkt CI/CD integrering
- Protokoll-nivån av HTTP-testning | ( | ingen webblader behövs
- Rika scenariotillstånd ( rökning , belastning , stress M SK3 spike
- Moderna verktyg med ett bra ekosystem
- Mindre vikt med hjälp av resurser

**k6 är perfekt för**

- API och webbtjänster
- Server-seitigt utformat applikationer
- CI/CD performance gates
- Developer-driven performance testing
- Cloud-nativa tillämpningar

**Tänk på alternativ om du behöver:**

- Browser-baserade tester (använda [Dramatiker](https://playwright.dev/))
- omfattande protokollstöd bortom HTTP (använda [JMeter](https://jmeter.apache.org/))
- fri distribuerad tester (använda [Stackdjur](https://locust.io/))
- vackert byggt- i rapporter (använda [Gatling](https://gatling.io/))
- GUI för icke-technicella tester (användbar [JMeter](https://jmeter.apache.org/))

## Nästa steg

Nu när du förstår vad k6 är,

**Fortsätt till [Del 2: Praktisk implementation](/blog/k6-testing-practical)** var vi kommer täcka

- Att sätta upp din testmiljö
- Rötningstest: smoke, ,, belastning, ,, stress, M SK2, spike och socktest
- Att testa kasbeteende
- Realistiska simulationer av användarnas resa
- CI/CD integration med GitHub actions
- Förvaltningsregressionsdetektion
- Profilering med dotTrace och dotMemory
- Vad man gör bäst och hur man löser problem

## resurser

### k6 Dokumentation

- [De officiella k6 dokumenten](https://k6.io/docs/) - Komplett k6 dokumentation
- [k6 JavaScript API](https://k6.io/docs/javascript-api/) - Alla tillgängliga k6 APIs
- [k6 exempel](https://github.com/grafana/k6-learn) - Example testscripts
- [k6 mätningar](https://k6.io/docs/using-k6/metrics/) - Understanding metrics
- [k6 trösklar](https://k6.io/docs/using-k6/thresholds/) - Inställningspass

### Alternativa Ladetestverktyg

- [Apache JMeter](https://jmeter.apache.org/) - Java-baserad lapptester
- [Stackdjur](https://locust.io/) - Python-baserad lapptester
- [Gatling](https://gatling.io/) - Scala -baserad lasttester
- [Artillerie](https://www.artillery.io/) - Noder .js belastningstest
- [skämt](https://github.com/wg/wrk) - HTTP benchmarking tool
- [Dramatiker](https://playwright.dev/) - Browserautomation & tester

This is a preview from the server running through my markdig pipeline

ASP.NET k6 Performance Testing

Load Testing ASP.NET Core Applications with k6: Introduction

Tuesday, 02 December 2025

Det här är ett mardrömscenario som alla utvecklare fruktar, men de flesta testar inte för Trädskapstest är optionellt. Det är skillnaden mellan en lyckad start och en AM akutsida. Denna guide med två delar visar er exakt hur man förhindrar detta scenario genom att använda k6, det moderna lasttestverktyget som är tillräckligt kraftfullt för företagsapplikationer men enkelt att köra i din CI

Det här är Del 1 av en tvåpartserie på lasttestning med k6:

Del 1 (den här artikelnM SK2: Introduction till kM SK1 installering , testtyper, och varför kSSK4
Del 2: Praktisk implementation: skrivande tester , CI

Inleiding

Den här kompletta guidan visar hur man laddar testversioner av ASP.NET Core-applikationer k6 - en av de mest kraftfulla öppna ♫ - ♫ källkodslasttestverktyg som finns ♫ MinimalBlog som vår exempelapplikation ( en enkel markering -baserad blogg med minne och utgångscaching), teknikerna och mönsterna som visas här gäller vilken ASP.NET Core-applikation som helst.

Till slutet av dessa två delar ser man

Installera och konfigurera k6 på vilken plattform som helst.
skriva omfattande test för olika scenarior
Integrera k6 i din CI/CD pipeline med GitHub Actions
Använd profileringsverktyg (dotTrace , dotMemory) tillsammans med kM SK3 för att hitta bottlenecks
Implementera olika teststrategier
Konfigurera utvecklingsdetektorn för att förhindra att långsam kod når produktionen

Varför MinimalBlog som exempel? Det är en riktig ASP-Applikation.

Vad är k6 och varför använder man det

k6 är ett modernt dragtestverktyg byggt för utvecklare.

Developer-vänlig: Test är skrivna i JavaScript (ES6+)
CLI-first: Perfekt för CI
Litevikt: Enkel binär , inga beroende
Precision: skrivet i Go för exakta mätningar
Skriptbar: Hela programmerningsförmågan för komplexa scenarior
moln - redo: Kan integreras med k6 Cloud, GrafanaM SK3 Prometheus

För MinimalBlog, k6 är idealt eftersom

Vi kan testa kassering: k6 kan bedöma kaskedjuster och beteende
Vi kan simulera riktig trafik: Testa flera samtida användare
Vi kan bedöma prestationer: mäta faktiska responsstid
Vi kan integrera med CI/CD: Automatiserade tester i vår pipeline
Vi kan testa specifika scenarior: Kategorisfilterning , individuella poster M SK2 hemsida

Installerar k6

Windows installering

Option 1: Med chokladkaka | ( | Rekomenderad |)

choco install k6

Option 2: med hjälp av Winget

winget install k6 --source winget

Option 3: Handinstallation

ladda ner den senaste versionen av Windows från GitHub-utsläpp
Extrahera k6.exe file
Lägg till katalogen i din PATH eller flytta k6.exe till en katalog som redan finns i PATH

Verifiera installering:

k6 version

Macinstallation

Option 1: Med hemmabröd (Empfohlend)

brew install k6

Option 2: med MacPorts

sudo port install k6

Option 3: Handinstallation

# Download and install the latest release
curl -O -L https://github.com/grafana/k6/releases/latest/download/k6-macos-amd64.zip
unzip k6-macos-amd64.zip
sudo cp k6-macos-amd64/k6 /usr/local/bin/
sudo chmod +x /usr/local/bin/k6

Verifiera installering:

k6 version

Linuxinstallation

Option 1: Genom att använda paketadministratörer

För Debian/Ubuntu:

sudo gpg -k
sudo gpg --no-default-keyring --keyring /usr/share/keyrings/k6-archive-keyring.gpg --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys C5AD17C747E3415A3642D57D77C6C491D6AC1D69
echo "deb [signed-by=/usr/share/keyrings/k6-archive-keyring.gpg] https://dl.k6.io/deb stable main" | sudo tee /etc/apt/sources.list.d/k6.list
sudo apt-get update
sudo apt-get install k6

För Fedora/CentOS/RHEL:

sudo dnf install https://dl.k6.io/rpm/repo.rpm
sudo dnf install k6

Option 2: med Snap

sudo snap install k6

Option 3: Handinstallation

# Download the latest release
curl -O -L https://github.com/grafana/k6/releases/latest/download/k6-linux-amd64.tar.gz
tar -xzf k6-linux-amd64.tar.gz
sudo cp k6-linux-amd64/k6 /usr/local/bin/
sudo chmod +x /usr/local/bin/k6

Option 4: med hjälp av Docker

docker pull grafana/k6:latest

# Run a test
docker run --rm -i grafana/k6:latest run - <script.js

Verifiera installering:

k6 version

Understanding k6 Testanatomi

Innan vi dyker in i tester, låt oss förstå den grundläggande strukturen av en k-test.

import http from 'k6/http';
import { check, sleep } from 'k6';

// Test configuration
export const options = {
  vus: 10,              // Virtual users
  duration: '30s',      // Test duration
};

// Setup function (runs once before test)
export function setup() {
  // Prepare test data
  return { baseUrl: 'http://localhost:5000' };
}

// Main test function (runs for each VU)
export default function(data) {
  const response = http.get(data.baseUrl);

  // Assertions
  check(response, {
    'status is 200': (r) => r.status === 200,
    'response time < 200ms': (r) => r.timings.duration < 200,
  });

  sleep(1); // Wait between iterations
}

// Teardown function (runs once after test)
export function teardown(data) {
  // Clean up
}

Key concepts:

Virtuella användare (VUs): simulerade samtida användare
Tyd: Hur länge testern körs
Kontroller: Behauptelser som inte stoppar testet
tröskeln: Pass
Metrik: Reaktionstid , genomspetsning

Typer av Leistungstest

Innan du testar din applikation, låt dig förstå de fem stora typerna av lasttest och när man ska använda varje.

graph TD
    A[Performance Testing Types] --> B[Smoke Test]
    A --> C[Load Test]
    A --> D[Stress Test]
    A --> E[Spike Test]
    A --> F[Soak Test]

    B --> B1[1-2 VUs<br/>30s-1min<br/>Basic Functionality]
    C --> C1[Normal Load<br/>5-15 minutes<br/>Verify SLAs]
    D --> D1[Gradual Increase<br/>10-30 minutes<br/>Find Breaking Point]
    E --> E1[Sudden Spike<br/>5-10 minutes<br/>Test Recovery]
    F --> F1[Normal Load<br/>Hours/Days<br/>Memory Leaks]

    style B stroke:#90EE90
    style C stroke:#87CEEB
    style D stroke:#FFD700
    style E stroke:#FF6347
    style F stroke:#DDA0DD

1. röktester

Föremål: Verifiera att systemet fungerar under minimal last

När man ska använda:

Efter varje kodförändring
Innan man kör mer intensiva tester
Som en sanitetskontroll i CI/CD

Besonderheiter:

1-2 VUs
Kortliv (30s-1minM SK2
Testar grundläggande funktionalitet

2. Ladetester

Föremål: Bedömer prestation under förväntad normallast

När man ska använda:

För att få upp en basnivå för prestationer
För att verifiera att SLAs är uppfyllda
Regellig prestansregressionstest

Besonderheiter:

Ett realistiskt antal användare
Hållbar belastning
Den typiska tiden : 5-15 minuter

3. Stresstest

Föremål: Hitta systembrottspunkt

När man ska använda:

För att förstå kapacitetgränser
För att identifiera bottlenecks
Planering för skalering

Besonderheiter:

Gradvis ökande belastning
Springa bortom normal kapacitet
Tydlighet: 10-30 minuter

4. Spiketest

Föremål: Testbeteende under plötsliga trafikstockningar

När man ska använda:

Att förbereda för lansering av produkter
Testar automatiskt-scaling
Att validera fallbackbeteendet

Besonderheiter:

Plötsligt stora ökning av last
Kort spikedauer
Hela tiden : 5-10 minuter

5. Soak-tester

Föremål: Hitta minneslekar och nedbrytning över tid

När man ska använda:

Innan större releases
Att testa långa services
Validatering av resurser

Besonderheiter:

Normala belastningsnivåer
Duration prolongerad ( timmar eller dagar )
Monitor för nedbrytning

graph LR
    A[Start] --> B{Smoke Test Pass?}
    B -->|No| C[Fix Issues]
    C --> A
    B -->|Yes| D{Load Test Pass?}
    D -->|No| E[Optimize]
    E --> D
    D -->|Yes| F{Stress Test}
    F --> G{Found Limit?}
    G -->|Yes| H[Document Capacity]
    G -->|No| I[Increase Load]
    I --> F
    H --> J{Spike Test Pass?}
    J -->|No| K[Improve Resilience]
    K --> J
    J -->|Yes| L{Soak Test}
    L --> M{Memory Stable?}
    M -->|No| N[Fix Memory Leaks]
    N --> L
    M -->|Yes| O[Production Ready]

    style O stroke:#90EE90

Varför k6 och inte

Med så många lasttestverktyg tillgängliga

k6 mot Apache JMeter

Apache JMeter är veteranen av lasttestverktyg ( sedan 1999).

Funktionen	kM SK2
Installation	Enkel binär
Testdefinitionen	JavaScript-kod	XML eller GUI
Ressourcenanvändning	Lågvikt (Go) ♫ ♫	♫ Smärt ♫
CI/CD integrering	Utmärkt CLI-firstM SK3	kräver plugins M
Lärningskurvan	Enkel för utvecklare	Steeper, GUIM SK3 fokuserad
Protokollstöd	HTTPM SK1 WebSockets, gRPC	Broader ( FTPMska5 JDBCM Ska6 SMTPMka7 etc

När ska man använda JMeter istället:

Benötig GUI för icke- tekniska tester
Testprotokoll bortom HTTP (JDBC, LDAP , SOAPM SK3
Ännu har JMeter expertis i ett lag
Man behöver ett omfattande plugin ekosystem

Varför är k6 bättre för de flesta ASP-apps

snabbare att skriva tester (JavaScript vs XML)
Litere resursavtryck
Bättre CI/CD integrering
Mer moderna utvecklare-upplevelser

k6 mot Locust

Stackdjur är en Python-baserad belastningstestningsprogram som är populär i Python-butiker

Funktionen	k6		3	Stack
Språk	JavaScript	Python
Förmågor	Väldigt snabbt (Ljumpningstid
Ärligt att använda	Enkel JavaScript	Pythonic, enkel
Distribuerade tester	kM SK1 moln (betaledd)	byggt
Webbens gränssnitt	Begränsat	Utmärkt verklig	-	tidig gränssnitt
Metrik Export	Många format	CSV, webbgränssnitt

När använda Locust istället:

Python-first team
Bra att göra gratis distribuerade tester
Vill ha en real- ---tids-web-UI under tester
Kompleks Pythonlogi i tester

Varför är k6 bättre för de flesta ASP-apps

Bättre resultat för korrekta mätningar
JavaScript är mer välbekant för webbutvecklare
renare tröskel
Bättre Prometheus/Grafana integration

k6 mot Gatling

Gatling är ett Scala-baserat verktyg med utmärkt rapporterande

Funktion	kM SK2	Gatling M
Språk	JavaScript	Scala
rapporter	Grundversionen	(+	Extensioner	)	♫	Lika uppbyggda	МSK4	i HTML-rapporter
Lärningskurvan	Enkel	Mäktig ♫ ♫ ( ♫ Skala DSL ♫
Förmågor	Utmärkt	Utvärdigt
Open Source	Till fullo öppet	Att öppna med företagstillsättning
Cloud Service	kM SK1 moln	Gatling Enterprise

När ska man använda Gatling istället:

JVM/Scala expertis i ett team
Man behöver fantastiska konstruerade reports
Att testa komplexa HTTP-scenarier
Erforderingar för företagsstöd

Varför är k6 bättre för de flesta ASP-apps

JavaScript är mer tillgängligt
Enklare Konfiguration och utföring
Bättre för snabba CI/CD-kontroller
Mer enkelt för enkla HTTP-testningar

k6 mot Artillerie

Artillerie är ett annat testverktyg för JavaScripts laddande.

Funktion	kM SK2	Artillerie M
Testdefinitionen	JavaScript-kod	YAML + JS-häckar m
Förmågor	snabbare	(	Go	)	МSK3	långsammare
Ärligt att använda	Kod-baserade	YAML configM SK3baserad på
byggt för	Ladetestning			Lade	+	funktionelltestning
Ägningar	Utmärkta tröskeln	Grundgärningar
Extensibilitet	Erweiterunger	Plugins

När man ska använda artillerie istället:

föredrar YAML än kod
Bra att testa Socket
Vill ha kombinerade last + funktionella tester
Nu använder man Node.js ekosystem

Varför är k6 bättre för de flesta ASP-apps

Mer exakta mätningar (Go vs Node.jsM SK2
Ett bättre tröskelsystem
En renare JavaScript API
Mer mogna och stabila

k6 mot wrk/wrkM SK2

skämt är en lätt HTTP- Benchmarking tool.

Funktionen	k6	wrk M
Ärligt att använda	HögaM SK1nivå API	lågt-nivå C + Lua
Scenarier	Den rika scenariotillgången	Bara basnivån HTTP
Metrik	Den komplexa	Den grundläggande
Skriptering	JavaScript	Lua
Använd fall	Helalasttestning		Vinniga utgångspunkter

När man ska använda wrk istället:

Det behövs absolut minimala överhead
Vinniga ett---värder
Att testa rå HTTP-presterande
Protokolltestning på låg nivå

Varför är k6 bättre för de flesta ASP-apps

Mycket enklare att skriva tester
Bättre rapportering och mätningar
Scenarisk stöd (rampM SK1up , steg
CI/CD vänlig

k6 mot Playwright

Dramatiker och Cypress är webbläsarens automatiserade verktyg som ibland används för laddande tester.

Funktion	kM SK2	Dramatiker/Cypress M
Approach	Protokoll
Förmågor	Tusentals VUs	Tiotals webblader
Ressourcenanvändning	Lågvikt	Svårt ♫ ♫ ( ♫ webblader ♫
JavaScript- utdrag	Nej	Ja
Primära användarfall	Ladetestning	E2E funktionell testning

När ska man använda Playwright/Cypress istället:

Det behövs att testa JavaScripts Ausführung
Det måste bedöma webbläraarens rendering
Att testa komplexa SPA
Funktionella E2E-tester

Varför är k6 bättre för de flesta ASP-apps

Protokollet-tillräcklig testning för servern
Man behöver simulera 100+ samtida användare
Väldigt mer effektivt användande av resurser

Summary: k6's Sweet Spot

Välj k6 när du vill

Fast, korrekt lasttest
Developer-vänlig JavaScript API
Utmärkt CI/CD integrering
Protokoll-nivån av HTTP-testning | ( | ingen webblader behövs
Rika scenariotillstånd ( rökning , belastning , stress M SK3 spike
Moderna verktyg med ett bra ekosystem
Mindre vikt med hjälp av resurser

k6 är perfekt för

API och webbtjänster
Server-seitigt utformat applikationer
CI/CD performance gates
Developer-driven performance testing
Cloud-nativa tillämpningar

Tänk på alternativ om du behöver:

Browser-baserade tester (använda Dramatiker)
omfattande protokollstöd bortom HTTP (använda JMeter)
fri distribuerad tester (använda Stackdjur)
vackert byggt- i rapporter (använda Gatling)
GUI för icke-technicella tester (användbar JMeter)

Nästa steg

Nu när du förstår vad k6 är,

Fortsätt till Del 2: Praktisk implementation var vi kommer täcka

Att sätta upp din testmiljö
Rötningstest: smoke, ,, belastning, ,, stress, M SK2, spike och socktest
Att testa kasbeteende
Realistiska simulationer av användarnas resa
CI/CD integration med GitHub actions
Förvaltningsregressionsdetektion
Profilering med dotTrace och dotMemory
Vad man gör bäst och hur man löser problem

resurser

k6 Dokumentation

De officiella k6 dokumenten - Komplett k6 dokumentation
k6 JavaScript API - Alla tillgängliga k6 APIs
k6 exempel - Example testscripts
k6 mätningar - Understanding metrics
k6 trösklar - Inställningspass

Alternativa Ladetestverktyg

Apache JMeter - Java-baserad lapptester
Stackdjur - Python-baserad lapptester
Gatling - Scala -baserad lasttester
Artillerie - Noder .js belastningstest
skämt - HTTP benchmarking tool
Dramatiker - Browserautomation & tester