# Ladda test ASP.NET kärnprogram med k6: Inledning

<!--category-- Testing, Performance, k6, ASP.NET -->
<datetime class="hidden">2025-12-02T14:00</datetime>

Din ansökan fungerar perfekt på din bärbara dator. Enhet tester passera. Integration tester passera. Du distribuerar till produktion, och plötsligt allt mals till ett stopp. Fem hundra riktiga användare träffar din hemsida samtidigt, och din server börjar returnera 503 fel. Din noggrant utformade caching strategi? Visar sig att det inte fungerar riktigt som du trodde. Databasen fråga du trodde var snabb? Det skapar en flaskhals i skala.

Detta är mardrömsscenariot varje utvecklare fruktar, men de flesta inte testa för. **Prestandatester är inte valfria - det är skillnaden mellan en lyckad lansering och en 3 AM nödsida.** Denna tvådelade guide kommer att visa dig exakt hur du kan förhindra detta scenario med hjälp av k6, den moderna belastningstestningsverktyg som är tillräckligt kraftfull för företagsprogram men tillräckligt enkel att köra i din CI / CD rörledning.

Det här är **Häfte 1** i en tvådelad serie om belastningsprovning med k6:

- **Del 1 (denna artikel)**: Introduktion till k6, installation, testtyper och varför k6
- **[Del 2: Praktiskt genomförande](/blog/k6-testing-practical)**: Skriva tester, CI/CD integration, profilering och verkliga exempel

## Inledning

Prestandatestning är avgörande för alla program för produktion ASP.NET Core. Oavsett om du bygger en enkel blogg, en komplex mikroservicearkitektur eller ett företagsprogram, behöver du veta hur din applikation beter sig under belastning. Kommer den att hantera 100 samtidiga användare? 1000? Var är flaskhalsarna? Fungerar din cachestrategi egentligen?

Denna omfattande guide visar dig hur du laddar test ASP.NET Core program med hjälp av [k6 Ordförande](https://k6.io/) - ett av de mest kraftfulla verktygen för belastningstest med öppen källkod. [Minimal blog@ info: whatsthis](/blog/minimalblog-introduction) som vårt exempel program (en enkel markdown-baserad blogg med minne och utdata caching), de tekniker och mönster som visas här gäller för **alla ASP.NET Core-program**.

I slutet av den här tvådelade serien vet du hur man:

- Installera och konfigurera k6 på alla plattformar (Windows, Mac, Linux)
- Skriv omfattande prestandatester för olika scenarier
- Integrera k6 i din CI/CD-rörledning med GitHub-åtgärder
- Använd profileringsverktyg (dotTrace, dotMemory) tillsammans med k6 för att hitta flaskhalsar
- Genomföra olika teststrategier: rök, belastning, stress, spik och blötläggningstester
- Ställ in prestanda regressionsdetektering för att förhindra långsam kod från att nå produktionen

**Varför MinimalBlog som exempel?** Det är en riktig ASP.NET Core 9.0-applikation med vanliga mönster: Razor Sidor, minne caching, utgång caching, fil I/O, och markdown bearbetning. Testing metoder du lär dig gäller lika för dina MVC-appar, Web APIs, Blazor program, eller minimala API:er.

[TOC]

## Vad är k6 och varför använda det?

[k6 Ordförande](https://k6.io/) är ett modernt verktyg för belastningstestning som är byggt för utvecklare. Till skillnad från äldre verktyg som JMeter eller LoadRunner, är k6:

- **Utvecklarevänlig**: Tester är skrivna i JavaScript (ES6+)
- **CLI-först**: Perfekt för CI/CD rörledningar
- **Lättviktig**: Single binär, inga beroenden
- **Exakt**: Skrivet i Gå för exakta mått
- **Skriptbar**: Full programmeringskapacitet för komplexa scenarier
- **Molnet är klart**: Kan integreras med k6 Cloud, Grafana, Prometheus

För MinimalBlog är k6 perfekt eftersom:

1. **Vi kan testa caching**: k6 kan verifiera cachehuvuden och beteende
2. **Vi kan simulera verklig trafik**: Testa flera samtidiga användare
3. **Vi kan validera prestationsanspråk**: Mät faktiska svarstider
4. **Vi kan integrera med CI/CD**: Automattestning i vår pipeline
5. **Vi kan testa specifika scenarier**: Kategorifiltrering, enskilda inlägg, hemsida

## Installerar k6

### Windows-installation

**Alternativ 1: Användning av choklad (rekommenderas)**

```powershell
choco install k6
```

**Alternativ 2: Användning av Winget**

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

**Alternativ 3: manuell installation**

1. Ladda ner den senaste Windows-utgåvan från [Utgåvor av GitHub](https://github.com/grafana/k6/releases)
2. Extrahera `k6.exe` akt
3. Lägg till katalogen i din PATH eller flytta `k6.exe` till en katalog redan i PATH

**Verifiera installation:**

```powershell
k6 version
```

### Mac- installation

**Alternativ 1: Användning av Homebrew (rekommenderas)**

```bash
brew install k6
```

**Alternativ 2: Användning av MacPorts**

```bash
sudo port install k6
```

**Alternativ 3: manuell installation**

```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 installation:**

```bash
k6 version
```

### Linuxinstallation

**Alternativ 1: Användning av pakethanterare**

För **Debian/Ubuntu Ordförande**:

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

**Alternativ 2: Använda Snap**

```bash
sudo snap install k6
```

**Alternativ 3: manuell installation**

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

**Alternativ 4: Användning av Docker**

```bash
docker pull grafana/k6:latest

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

**Verifiera installation:**

```bash
k6 version
```

## Förstå k6 Test Anatomy

Innan vi dyker in i test, låt oss förstå den grundläggande strukturen av en k6 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
}
```

Nyckelbegrepp:

- **Virtuella användare (VU)**: Simulerade samtidiga användare
- **Giltighetstid**: Hur länge testet pågår
- **Kontroller**: Assertioner som inte stoppar testet
- **Tröskelvärden**: Kriterier för godkännande/underkännande
- **Tröskelvärden**: Svarstid, genomströmning, felfrekvens

## Typer av prestandatester

Innan du testar din ansökan, låt oss förstå de fem huvudtyper av belastning tester och när du 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

**Syfte**: Verifiera systemet fungerar under minimal belastning

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

- Efter varje kodändring
- Innan du kör mer intensiva tester
- Som en sundhetskontroll i CI/CD

**Kännetecken**:

- 1-2 fordonsenheter (virtuella användare)
- Kort varaktighet (30s-1min)
- Tester grundläggande funktionalitet

### 2. Belastningsprovningar

**Syfte**: Bedöm prestanda vid förväntad normal belastning

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

- För att fastställa utgångsvärdets prestanda
- För att verifiera att SLA är uppfyllda
- Regelbunden regressionsprovning av prestanda

**Kännetecken**:

- Realistiskt antal användare
- Uppehållen last
- Typisk varaktighet: 5-15 minuter

### 3. Stresstester

**Syfte**: Hitta systembrytpunkt

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

- För att förstå kapacitetsgränser
- Att identifiera flaskhalsar
- Planering för skalning

**Kännetecken**:

- Gradvis ökande belastning
- Tryck över normal kapacitet
- Längd: 10-30 minuter

### 4. Spike tester

**Syfte**: Testa beteende under plötsliga trafik spikar

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

- Förberedelse för lansering av produkter
- Provning av automatisk skalning
- Validerar reservbeteende

**Kännetecken**:

- Plötslig stor ökning av belastningen
- Kort förlängningstid
- Total varaktighet: 5-10 minuter

### 5. Blötprov (avslutningsprovningar)

**Syfte**: Hitta minnesläckage och nedbrytning över tid

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

- Före större utgåvor
- Testning av långdistanstjänster
- Validerar resursstädning

**Kännetecken**:

- Normala belastningsnivåer
- Utökad varaktighet (timmar eller dagar)
- Övervaka 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 verktyg för belastningstestning tillgängliga, varför ska du välja k6? Låt oss jämföra k6 med populära alternativ:

### k6 vs Apache JMeter

**Apache JMeter Ordförande** är veteran för verktyg för belastningsprovning (sedan 1999).

på funktionen  på k6  på JMeter
|---------|----|---------|
| **Anläggning** till Single binära, inga beroenden  och kräver Java, tyngre installera
| **Provningsdefinition** med JavaScript-kod, XML eller grafiskt gränssnitt
| **Resursanvändning** Tung (Java) - lätt (Go) - lätt (Go) - tung (Java)
| **Integrering av KI/CD** på Excellent (CLI-först)  på Kräver plugins
| **Att lära sig kurva** på ett enkelt sätt för utvecklare  på Steeper, GUI-fokuserad
| **Protokollstöd** på HTTP, WebSockets, gRPC  på bredare (FTP, JDBC, SMTP, etc.)

**När JMeter ska användas i stället:**

- Behöver GUI för icke-tekniska testare
- Testprotokoll utanför HTTP (JDBC, LDAP, SOAP)
- Har redan JMeters kompetens i team
- Behöver omfattande plugin ekosystem

**Varför k6 är bättre för de flesta ASP.NET Core-appar:**

- Snabbare att skriva tester (JavaScript vs XML)
- Lättare resursavtryck
- Bättre integrering av KI/CD
- Mer modern utvecklarupplevelse

### k6 vs Locust

**Lokust Ordförande** är ett Python-baserat belastningstestverktyg, populärt i Python-butiker.

på funktionen "k6" och "Locust"
|---------|----|---------|
| **Språk** på JavaScript  på Python
| **Prestanda** Mycket snabb (Go runtime)  och långsammare (Python GIL)
| **Lätt att använda** Enkel JavaScript  på Pythonic, lätt
| **Distribuerad testning** & k6 Moln (betalt)  till Inbyggt (fritt)
| **Webbgränssnitt** på begränsad  på Excellent realtids-UI  på
| **Metrisk export** på många format  på CSV, web UI  på nätet

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

- Python-första laget
- Behöver gratis distribuerad testning
- Vill ha realtid web UI under tester
- Komplex Python logik i tester

**Varför k6 är bättre för de flesta ASP.NET Core-appar:**

- Bättre prestanda för korrekta mätvärden
- JavaScript mer bekant för webbutvecklare
- Renare tröskel/suspensionssyntax
- Bättre integrering av Prometheus/Grafana

### k6 vs Gatling

**Gettling Ordförande** är ett Scala-baserat verktyg med utmärkt rapportering.

på funktionen  på k6  på Gattling  på
|---------|----|---------|
| **Språk** Kopiering tillåten med angivande av källan.
| **Rapporter** på grund (+ förlängningar)  och vackra inbyggda HTML-rapporter
| **Att lära sig kurva** Enkelt och moderat (Scala DSL)
| **Prestanda** Utmärkt, bra, bra, bra, bra, bra, bra, bra, bra, bra, bra, bra, bra, bra, bra, bra, bra, bra, bra, bra, bra, bra, bra, bra, bra, bra, bra, bra, bra, bra, bra.
| **Öppna källkod** till Fullt öppen  och öppen med företagstillägg
| **Molntjänst** & k6 Cloud  på Gattling Enterprise

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

- JVM/Scala-expertis i team
- Behöver fantastiska inbyggda rapporter
- Test av komplexa HTTP-scenarier
- Krav på företagsstöd

**Varför k6 är bättre för de flesta ASP.NET Core-appar:**

- JavaScript är mer tillgängligt
- Enklare installation och genomförande
- Bättre för snabba CI/CD-kontroller
- Enkelare för enkel HTTP-testning

### k6 mot artilleri

**Stärkelse** är ett annat testverktyg för JavaScript-belastning.

på funktionen  på k6  på artilleri
|---------|----|---------|
| **Provningsdefinition** på JavaScript kod  på YAML + JS krokar
| **Prestanda** Snabbare (gå)  på längre sikt (Node.js)
| **Lätt att använda** på kodbaserad  på YAML-config-baserad
| **Byggt för** på belastningsprovning  på belastning + funktionstestning  och
| **Överlåtelser** Utmärkta tröskelvärden  och grundförväntningar
| **Omfattning** Utökningar  på insticksmoduler

**När du ska använda Artillery istället:**

- Föredrar YAML över kod
- Behöver Socket.io-testning
- Vill ha kombinerade belastningar + funktionstester
- Använder redan Node.js ekosystem

**Varför k6 är bättre för de flesta ASP.NET Core-appar:**

- Mer exakta mått (Go vs Node.js)
- Bättre tröskelsystem
- Renare JavaScript API
- Mer mogen och stabil

### k6 mot wrk/wrk2

**vegetabiliska fetter och oljor samt fraktioner av sådana fetter eller oljor, även raffinerade men inte kemiskt modifierade** är ett lätt HTTP-benchmarkingverktyg.

 Feature  k6  wrk  
|---------|----|---------|
| **Lätt att använda** Högnivåa API:er  på låg nivå C + Lua  på låg nivå
| **Scenarier** Stöd för ett rikt scenario  på grund av HTTP endast
| **Tröskelvärden** på ett övergripande och grundläggande sätt
| **Skriptering** Kopiering tillåten med angivande av källan.
| **Användningsfall** på full belastningsprovning  på snabbriktmärken  på

**När du ska använda wrch istället:**

- Behöver absolut minimala omkostnader
- Snabba engångsriktmärken
- Testa rå HTTP-prestanda
- Provning av protokoll på låg nivå

**Varför k6 är bättre för de flesta ASP.NET Core-appar:**

- Mycket lättare att skriva tester
- Bättre rapportering och mätvärden
- Scenariostöd (ramp-up, steg)
- CI/CD-vänlig

### k6 vs Playwright/Cypress (Browser-Based)

**Uppspelningsrätt** och **Cypress Ordförande** är verktyg för automatisering av webbläsare som ibland används för belastningstester.

på funktionen "k6" och "playwright"/"Cypress"
|---------|----|---------|
| **Tillvägagångssätt** Protocol-nivå HTTP  med verklig webbläsare  på
| **Prestanda** på tusentals VU:er  på tiotals webbläsare
| **Resursanvändning** Lättviktig, tung (browser)
| **JavaScript Körning** "Nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej, nej!
| **Fall av primäranvändning** Läckningsprovning  på E2E-funktionsprov

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

- Måste testa JavaScript-utförande
- Måste verifiera webbläsarens rendering
- Test av komplexa SPA:er
- Funktionell E2E-provning

**Varför k6 är bättre för de flesta ASP.NET Core-appar:**

- Protocol-nivåtestning tillräcklig för serverrenderade appar
- Behov av att simulera 100+ samtidiga användare
- Mycket effektivare resursanvändning

### Sammanfattning: k6: s söta fläck

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

- Snabb, noggrann belastningsprovning
- Utvecklarvänligt JavaScript API
- Utmärkt CI/CD-integration
- HTTP-testning på protokollnivå (ingen webbläsare behövs)
- Rikt scenariostöd (rök, belastning, stress, spik, blötläggning)
- Modernt verktyg med bra ekosystem
- Lätt resursanvändning

**k6 är perfekt för:**

- API:er och webbtjänster
- Server-side-utgivna appar
- Prestandagrindar för CI/CD
- Utvecklingsdriven prestandatestning
- Moln-inhemska program

**Överväg alternativ om du behöver:**

- Browser-baserad testning (använd [Uppspelningsrätt](https://playwright.dev/))
- Omfattande protokollstöd utanför HTTP (använd [JMeter Ordförande](https://jmeter.apache.org/))
- Gratis distribuerad testning (använd [Lokust Ordförande](https://locust.io/))
- Vackra inbyggda rapporter (använd [Gettling Ordförande](https://gatling.io/))
- Grafiskt gränssnitt för icke-tekniska testare (användning) [JMeter Ordförande](https://jmeter.apache.org/))

## Nästa steg

Nu när du förstår vad k6 är, hur man installerar det, vilka typer av prestandatester som finns tillgängliga, och varför k6 är ett utmärkt val för ASP.NET Core-program, är du redo att börja skriva faktiska tester.

**Fortsätt till [Del 2: Praktiskt genomförande](/blog/k6-testing-practical)** där vi ska täcka:

- Ställa in din testmiljö
- Skriva rök, last, stress, spik och indränkt test
- Testa cachebeteende
- Realistiska simuleringar av användarresor
- Integrering av CI/CD med GitHub-åtgärder
- Detektion av prestanda regression
- Profilering med dotTrace och dotMemory
- Bästa praxis och felsökning

## Resurser

### k6 Dokumentation

- [Officiella k6-dokument](https://k6.io/docs/) - Fullständig k6-dokumentation
- [k6 JavaScript- API](https://k6.io/docs/javascript-api/) - Alla tillgängliga k6 API:er
- [k6 exempel](https://github.com/grafana/k6-learn) - Exempel på testskript
- [k6 mätvärden](https://k6.io/docs/using-k6/metrics/) - Förstå mätvärden
- [k6-trösklar](https://k6.io/docs/using-k6/thresholds/) - Fastställande av godkända/underkända kriterier

### Alternativa verktyg för belastningsprovning

- [Apache JMeter Ordförande](https://jmeter.apache.org/) - Java-baserad belastningstestning
- [Lokust Ordförande](https://locust.io/) - Pythonbaserad belastningsprovning
- [Gettling Ordförande](https://gatling.io/) - Scala-baserad belastningsprovning
- [Stärkelse](https://www.artillery.io/) - Node.js belastningstestning
- [vegetabiliska fetter och oljor samt fraktioner av sådana fetter eller oljor, även raffinerade men inte kemiskt modifierade](https://github.com/wg/wrk) - HTTP benchmarkingverktyg
- [Uppspelningsrätt](https://playwright.dev/) - Automatisering och testning av webbläsare