# Laden Testing ASP.NET Core Toepassingen met k6: Inleiding

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

Uw applicatie werkt perfect op uw laptop. Unit tests passeren. Integratie tests passeren. U implementeert naar de productie, en plotseling alles maalt tot stilstand. Vijfhonderd echte gebruikers raken uw homepage tegelijkertijd, en uw server begint terug te keren 503 fouten. Uw zorgvuldig vervaardigde caching strategie? Blijkt dat het niet werkt helemaal zoals je dacht. Die database query dacht dat was snel? Het is het creëren van een bottleneck op schaal.

Dit is het nachtmerrie scenario elke ontwikkelaar vreest, maar de meeste niet testen voor. **Prestaties testen is niet optioneel - het is het verschil tussen een succesvolle lancering en een 3 AM noodpagina.** Deze twee-delige handleiding zal u precies laten zien hoe u dit scenario kunt voorkomen met behulp van k6, de moderne load testing tool die krachtig genoeg is voor enterprise toepassingen maar eenvoudig genoeg om te draaien in uw CI/CD pijplijn.

Dit is **Deel 1** van een tweedelige serie belastingstests met k6:

- **Deel 1 (dit artikel)**: Inleiding tot k6, installatie, testtypes, en waarom k6
- **[Deel 2: Praktische uitvoering](/blog/k6-testing-practical)**: Writing tests, CI/CD integratie, profiling, en real-world voorbeelden

## Inleiding

Performance testing is cruciaal voor elke productie ASP.NET Core applicatie. Of u nu een eenvoudige blog, een complexe microservice architectuur, of een enterprise applicatie bouwt, u moet weten hoe uw applicatie zich gedraagt onder belasting. Zal het omgaan met 100 gelijktijdige gebruikers? 1000? Waar zijn de knelpunten? Werkt uw caching strategie eigenlijk?

Deze uitgebreide gids laat u zien hoe u test ASP.NET Core toepassingen met behulp van [k6](https://k6.io/) - een van de meest krachtige open source load testtools die beschikbaar zijn. [MinimaleBlog](/blog/minimalblog-introduction) als onze voorbeeld applicatie (een eenvoudige markdown-based blog met geheugen en output caching), de technieken en patronen die hier worden getoond zijn van toepassing op **elke ASP.NET kerntoepassing**.

Aan het einde van deze twee-delige serie, weet je hoe je:

- K6 installeren en configureren op elk platform (Windows, Mac, Linux)
- Schrijf uitgebreide prestatietests voor verschillende scenario's
- Integreer k6 in uw CI/CD-pijpleiding met GitHub-acties
- Profileringsinstrumenten (dotTrace, dotMemory) naast k6 gebruiken om knelpunten te vinden
- Implementeer verschillende teststrategieën: rook-, belasting-, stress-, piek- en wekentest
- Instellen van prestatie regressie detectie om te voorkomen dat trage code van het bereiken van de productie

**Waarom MinimalBlog als voorbeeld?** Het is een echte ASP.NET Core 9.0 applicatie met gemeenschappelijke patronen: Scheermes, geheugen caching, output caching, bestand I/O, en markdown processing. De testbenaderingen die je leert zijn gelijk van toepassing op uw MVC apps, Web API's, Blazor applicaties, of minimale API's.

[TOC]

## Wat is k6 en waarom gebruiken?

[k6](https://k6.io/) is een moderne load test tool gebouwd voor ontwikkelaars. In tegenstelling tot oudere tools zoals JMeter of LoadRunner, k6 is:

- **Ontwikkelaarvriendelijk**: Tests zijn geschreven in JavaScript (ES6+)
- **CLI-eerste**: Perfect voor CI/CD pijpleidingen
- **Lichtgewicht**: Enkel binair, geen afhankelijkheden
- **Nauwkeurig**: Geschreven in Ga voor nauwkeurige metriek
- **Scriptbaar**: Volledige programmeringsmogelijkheden voor complexe scenario's
- **Cloud-ready**: Kan integreren met k6 Cloud, Grafana, Prometheus

Voor MinimalBlog is k6 ideaal omdat:

1. **We kunnen caching testen.**: k6 kan cache headers en gedrag verifiëren
2. **We kunnen echt verkeer simuleren.**: Test meerdere gelijktijdige gebruikers
3. **We kunnen prestatieclaims valideren**: Meet de werkelijke responstijden
4. **We kunnen integreren met CI/CD**: Automatiseer testen in onze pijplijn
5. **We kunnen specifieke scenario's testen**: Categorie filtering, individuele berichten, homepage

## Installeren van k6

### Windows-installatie

**Optie 1: Gebruik van chocolade (aanbevolen)**

```powershell
choco install k6
```

**Optie 2: Winget gebruiken**

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

**Optie 3: Handmatige installatie**

1. Download de nieuwste Windows release van [GitHub releases](https://github.com/grafana/k6/releases)
2. Uitpakken van de `k6.exe` bestand
3. De map toevoegen aan je PATH of verplaatsen `k6.exe` naar een map die al in PATH staat

**Installatie verifiëren:**

```powershell
k6 version
```

### Mac-installatie

**Optie 1: Homebrew gebruiken (aanbevolen)**

```bash
brew install k6
```

**Optie 2: MacPorts gebruiken**

```bash
sudo port install k6
```

**Optie 3: Handmatige installatie**

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

**Installatie verifiëren:**

```bash
k6 version
```

### Linux installatie

**Optie 1: Pakketbeheerders gebruiken**

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

Voor **Fedora/CentOS/RHEL**:

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

**Optie 2: Snap gebruiken**

```bash
sudo snap install k6
```

**Optie 3: Handmatige installatie**

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

**Optie 4: Gebruik van Docker**

```bash
docker pull grafana/k6:latest

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

**Installatie verifiëren:**

```bash
k6 version
```

## Begrijpen k6 Test Anatomy

Voordat we in testen duiken, laten we de basisstructuur van een k6-test begrijpen:

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

Kernbegrippen:

- **Virtuele gebruikers (VU's)**: Gesimuleerde gelijktijdige gebruikers
- **Duur**: Hoe lang de test loopt
- **Controles**: Asserties die de test niet stoppen
- **Drempels**: Pass/fail criteria
- **Metrics**: Response time, throughput, foutenpercentage

## Soorten prestatietests

Voordat het testen van uw toepassing, laten we begrijpen de vijf belangrijkste soorten belastingstests en wanneer te gebruiken elk:

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

**Betreft**: Controleer of het systeem werkt onder minimale belasting

**Wanneer moet u dit middel gebruiken?**:

- Na elke codewijziging
- Alvorens intensievere tests uit te voeren
- Als een gezonde controle in CI/CD

**Kenmerken**:

- 1-2 VU's (virtuele gebruikers)
- Korte duur (30s-1min)
- Testen van de basisfunctionaliteit

### 2. Tests van de belasting

**Betreft**: Beoordeel de prestaties onder verwachte normale belasting

**Wanneer moet u dit middel gebruiken?**:

- Vaststelling van de basisprestaties
- Om te controleren of SLA's zijn voldaan
- Reguliere prestatieregressietest

**Kenmerken**:

- Realistisch aantal gebruikers
- Aanhoudende belasting
- Typische duur: 5-15 minuten

### 3. Stresstesten

**Betreft**: Zoek systeembreekpunt

**Wanneer moet u dit middel gebruiken?**:

- Om capaciteitsgrenzen te begrijpen
- Knelpunten identificeren
- Planning voor schaalvergroting

**Kenmerken**:

- Geleidelijk toenemende belasting
- Duw over de normale capaciteit
- Duur: 10-30 minuten

### 4. Spike Tests

**Betreft**: Test gedrag onder plotselinge verkeerspieken

**Wanneer moet u dit middel gebruiken?**:

- Voorbereiden voor productlanceringen
- Autoschaling testen
- Valideren van terugvalgedrag

**Kenmerken**:

- Plotselinge grote toename van de belasting
- Korte piekduur
- Totale duur: 5-10 minuten

### 5. Soak Tests (Endurance Tests)

**Betreft**: Zoek geheugenlekken en degradatie na verloop van tijd

**Wanneer moet u dit middel gebruiken?**:

- Vóór grote releases
- Long-running-diensten testen
- Valideren van resource cleanup

**Kenmerken**:

- Normale belastingsniveaus
- Verlengde duur (uren of dagen)
- Monitor voor afbraak

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

## Waarom k6 en niet...?

Met zoveel load test tools beschikbaar, waarom zou je kiezen voor k6? Laten we k6 vergelijken met populaire alternatieven:

### k6 vs Apache JMeter

**Apache JMeter** is de veteraan van gereedschap voor het testen van de belasting (sinds 1999).

Kenmerk K6 JMeter
|---------|----|---------|
| **Installatie** Single binaire, geen afhankelijkheden vereist Java, zwaardere installatie
| **Testdefinitie** JavaScript-code XML of GUI
| **Gebruik van hulpbronnen** Lichtgewicht (Go) Zwaar (Java)
| **CI/CD-integratie** Uitstekend (Cli-first) Vereist plugins
| **Leercurve** Gemakkelijk voor ontwikkelaars Steeper, GUI-gefocust
| **Protocolondersteuning** • HTTP, WebSockets, gRPC • Broder (FTP, JDBC, SMTP, enz.) •

**Wanneer JMeter te gebruiken in plaats daarvan:**

- Need GUI voor niet-technische testers
- Testprotocollen voorbij HTTP (JDBC, LDAP, SOAP)
- Al JMeter expertise in team
- Noodzaak van uitgebreide plugin ecosysteem

**Waarom k6 beter is voor de meeste ASP.NET Core apps:**

- Sneller om tests te schrijven (JavaScript vs XML)
- Lighter resource voetafdruk
- Betere CI/CD-integratie
- Meer moderne ervaring met ontwikkelaars

### k6 vs Locust

**Locust** is een Python-gebaseerde load test tool, populair in Python winkels.

Kenmerk K6 Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust Locust
|---------|----|---------|
| **Taal** JavaScript, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python, Python
| **Prestaties** Zeer snel (Go runtime) Langzamer (Python )
| **Gebruiksgemak** Eenvoudig JavaScript, Pythonisch, eenvoudig
| **Gedistribueerde test** K6 Cloud (betaald) Ingebouwd (gratis)
| **Web-UI** Uitstekende real-time UI
| **Metrics-export** Veel formaten CSV, web UI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

**Wanneer Locust te gebruiken in plaats daarvan:**

- Python-eerste team
- Noodzaak van gratis gedistribueerde testen
- Wil real-time web UI tijdens tests
- Complexe Python logica in tests

**Waarom k6 beter is voor de meeste ASP.NET Core apps:**

- Betere prestaties voor accurate metrics
- JavaScript bekender voor webontwikkelaars
- Schonere drempel/assertion syntax
- Betere integratie van Prometheus/Grafana

### k6 vs Gatling

**Gatling** is een Scala-gebaseerde tool met uitstekende rapportage.

Kenmerken K6 Gatling
|---------|----|---------|
| **Taal** JavaScript Scala/Java
| **Verslagen** Basis (+ extensies) Mooie ingebouwde HTML-rapporten
| **Leercurve** Gemakkelijk uit te stellen (Scala DSL)
| **Prestaties** Uitstekend. Uitstekend.
| **Bron openen** Openen met enterprise add-ons
| **Cloud Service** K6 Cloud Gatling Enterprise

**Wanneer moet Gatling in plaats daarvan worden gebruikt:**

- JVM/Scala-expertise in team
- Behoefte aan verbluffende ingebouwde rapporten
- Testen van complexe HTTP-scenario's
- Vereisten ter ondersteuning van het bedrijfsleven

**Waarom k6 beter is voor de meeste ASP.NET Core apps:**

- JavaScript is toegankelijker
- Eenvoudigere opstelling en uitvoering
- Beter voor snelle CI/CD controles
- Meer eenvoudig voor eenvoudige HTTP testen

### k6 vs Artillerie

**Artillerie** is een andere JavaScript load test tool.

Feature K6 Artillerie
|---------|----|---------|
| **Testdefinitie** JavaScript-code YAML + JS hooks
| **Prestaties** Sneller (Go) Langzamer (Node.js)
| **Gebruiksgemak** Op code gebaseerde YAML config-based
| **Gebouwd voor** Beproeving van de belasting Beproeving van de belasting + functionele tests
| **Asserties** Uitstekende drempels Basisverwachtingen
| **Extensibiliteit** Extensions . . Plugins . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

**Wanneer Artillerie te gebruiken in plaats daarvan:**

- Geef YAML de voorkeur boven code
- Socket.io testen nodig
- Wilt gecombineerde belasting + functionele tests
- Gebruikt al Node.js-ecosysteem

**Waarom k6 beter is voor de meeste ASP.NET Core apps:**

- Meer precieze metrieken (Go vs Node.js)
- Betere drempelregeling
- Cleaner JavaScript API
- Meer volwassen en stabiel

### k6 vs wrk/wrk2

**wrik** is een lichtgewicht HTTP benchmarking tool.

Feature K6 Wrk
|---------|----|---------|
| **Gebruiksgemak** API op hoog niveau Low-level C + Lua
| **Scenario's** Rijk scenario ondersteuning Basic HTTP alleen
| **Metrics** Uitgebreid Basic
| **Scripting** JavaScript Lua
| **Geval gebruiken** Snelle ijkpunten voor de volledige belasting

**Wanneer wrk gebruikt moet worden:**

- Noodzaak absolute minimale overhead
- Snelle eenmalige benchmarks
- Rauwe HTTP-prestaties testen
- Low-level protocol testen

**Waarom k6 beter is voor de meeste ASP.NET Core apps:**

- Veel makkelijker om tests te schrijven
- Betere rapportage en statistieken
- Scenariosteun (opruiming, fasen)
- CI/CD-vriendelijk

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

**Playwright** en **Cypress** zijn browser automatisering tools die soms worden gebruikt voor het testen van de belasting.

Playwright/Cypress
|---------|----|---------|
| **Aanpak** Echte browser op protocolniveau HTTP
| **Prestaties** Duizenden VU's Tientallen browsers
| **Gebruik van hulpbronnen** Lichtgewicht zwaar (browsers)
| **JavaScript-uitvoering** - Nee. Ja.
| **Primaire gebruikscase** Beproeving van de belasting E2E functionele tests

**Wanneer Playwright/Cypress te gebruiken in plaats daarvan:**

- Behoefte om JavaScript-uitvoering te testen
- Moet de weergave van de browser verifiëren
- Testen van complexe SPA's
- Functionele E2E-test

**Waarom k6 beter is voor de meeste ASP.NET Core apps:**

- Protocol-niveau testen voldoende voor server-gerenderde apps
- Noodzaak om 100+ gelijktijdige gebruikers te simuleren
- Veel efficiënter gebruik van hulpbronnen

### Samenvatting: k6's Sweet Spot

**Kies k6 wanneer u wilt:**

- Snelle, nauwkeurige belastingstest
- Ontwikkel-vriendelijke JavaScript API
- Uitstekende CI/CD integratie
- Protocol-level HTTP testen (geen browser nodig)
- Rijke scenario ondersteuning (roken, laden, stress, pieken, weken)
- Moderne tooling met goed ecosysteem
- Lichtgewicht hulpbronnengebruik

**k6 is perfect voor:**

- API's en webdiensten
- Server-side weergegeven apps
- BI/CD-prestatiepoorten
- Developer-driven performance testing
- Cloud-native-toepassingen

**Overweeg alternatieven indien nodig:**

- Op browser gebaseerde testen (gebruik [Playwright](https://playwright.dev/))
- Uitgebreide protocol ondersteuning voorbij HTTP (gebruik [JMeter](https://jmeter.apache.org/))
- Gratis gedistribueerde tests (gebruik [Locust](https://locust.io/))
- Mooie ingebouwde rapporten (gebruik [Gatling](https://gatling.io/))
- GUI voor niet-technische testers (gebruik [JMeter](https://jmeter.apache.org/))

## Volgende stappen

Nu je begrijpt wat k6 is, hoe je het moet installeren, de soorten prestatietests die beschikbaar zijn, en waarom k6 een geweldige keuze is voor ASP.NET Core toepassingen, ben je klaar om te beginnen met het schrijven van echte tests.

**Doorgaan naar [Deel 2: Praktische uitvoering](/blog/k6-testing-practical)** waar we het over hebben:

- Het opzetten van uw testomgeving
- Het schrijven van rook-, belasting-, stress-, piek- en wekentest
- Cachegedrag testen
- Realistische gebruikersreissimulaties
- CI/CD-integratie met GitHub-acties
- Prestatieregressiedetectie
- Profileren met dotTrace en dotMemory
- Beste praktijken en probleemoplossing

## Middelen

### k6 Documentatie

- [Officiële k6 documenten](https://k6.io/docs/) - Volledige k6 documentatie
- [k6 JavaScript API](https://k6.io/docs/javascript-api/) - Alle beschikbare k6 API's
- [k6 voorbeelden](https://github.com/grafana/k6-learn) - Voorbeeld testscripts
- [k6 metrics](https://k6.io/docs/using-k6/metrics/) - Begrijpen metrieken
- [k6-drempels](https://k6.io/docs/using-k6/thresholds/) - Het instellen van pass/fail criteria

### Alternatieve belastingstesttools

- [Apache JMeter](https://jmeter.apache.org/) - Java-based load testing
- [Locust](https://locust.io/) - Python-based load testing
- [Gatling](https://gatling.io/) - Op Scala gebaseerde belastingstesten
- [Artillerie](https://www.artillery.io/) - Node.js load testing
- [wrik](https://github.com/wg/wrk) - HTTP benchmarking tool
- [Playwright](https://playwright.dev/) - Browser automatisering & testen