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

<!--category-- Testing, Performance, k6, ASP.NET -->
<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<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

```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