# Lastprüfung von ASP-.-NET Core Applications mit der Einführung von k.6:

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

Ihre Anwendung funktioniert perfekt auf Ihrem Laptop .. . Unit Tests Pass ?. ? Integrationstests pass ? . ? Sie stellen zur Produktion und plötzlich alles schleift zu einem Stillstand bereit ? . ? Fünfhundert echte Benutzer treffen gleichzeitig Ihre Homepage ?, ? und Ihr Server beginnt die Rückgabe von Fehlern . ? Ihre sorgfältig gestaltete Caching-Strategie ?? ? stellt sich heraus, dass es nicht so funktioniert wie du dachtest , . ? Diese Datenbankanfrage, die du für schnell gehalten hast !? ?

Dies ist das Alptraum-Szenario, vor dem jeder Entwickler Angst hat. **Leistungstests sind optional erhältlich.' ist der Unterschied zwischen einem erfolgreichen Start und einer Notfallseite.** Dieser zweiseitige Guide zeigt Ihnen genau, wie Sie dieses Szenario mit dem modernen Lasttest-Tool von k.6, verhindern können, das für Unternehmensanwendungen leistungsstark genug ist, aber einfach genug, um in Ihrer CI-/-CD-Pipeline laufen zu lassen.

Das ist **Teil** von einer zwei- oder mehrteiligen Serie auf Lastprüfung mit k- oder

- **Teil dieses Artikels**Einführung in die Installation von k-6,, ,, Testtypen und warum k-6,
- **[Teil Praktische Umsetzung](/blog/k6-testing-practical)**Schreibteste zur Integration von CIP-/CDs, zum Profilieren von , und zu realen Beispielen für -

## Einleitung

Leistungsprüfungen sind für jede Produktion von entscheidender Bedeutung ASP-.-NET Kernanwendung – . – Egal ob Sie einen einfachen Blog aufbauen – , – eine komplexe Microservice-Architektur –, – oder eine Enterprise-Anwendung – , – Sie müssen wissen, wie sich Ihre Anwendung unter Last verhält – MKK6 – Wird es gleichzeitige Benutzer mit 100 – MSC9 – behandeln Wo sind die Engpässe?? – Funktioniert Ihre Caching-Strategie tatsächlich?

Diese umfassende Anleitung zeigt Ihnen, wie Sie ASP-.-NET Core-Anwendungen mit laden [K.M.S.K.](https://k6.io/) Eins der leistungsfähigsten offenen Werkzeuge für die Belastungsprüfung von -. [MinimalBlog](/blog/minimalblog-introduction) als unser Beispiel Anwendung -( , ein einfaches Markdown ,- , basierende Blog mit Speicher und Ausgabe Caching , ), , die Techniken und Muster hier angezeigt gelten für **Jede ASP-.-NET Core-Anwendung**.

Bis zum Ende dieser zwei---Teil-Serien, die dich kennen

- Installieren und Konfigurieren von k-6 auf jeder Plattform
- Schreiben Sie umfassende Leistungstests für verschiedene Szenarien
- Integrieren Sie mit GitHub Actions in Ihre CI®/-CD Pipeline
- Verwenden Sie Profiling-Tools zusammen mit k.6, um Engpässe zu finden
- Implementieren Sie verschiedene Teststrategien:-Rauch-,-Last,-Stress,-Spike,- und Einweichentests
- Leistungsregressionserkennung einrichten, um zu verhindern, dass der langsame Code die Produktion erreicht

**Warum MinimalBlog als Beispiel?** Es ist eine echte ASP-. NET Core Anwendung mit gängigen Mustern , : , Razor Seiten , , , Speicher caching ,, , Ausgabe Caching ., , Datei IM/ , und Markdown-Verarbeitung , . , Das Testen nähert sich Ihnen lernen Sie gleichermaßen auf Ihre MVC-Apps gelten , , Web-APIs , -, , Blazor Anwendungen , oder minimal APIs .

[TOC]

## Was ist und warum Sie es verwenden?

[K.M.S.K.](https://k6.io/) ist ein modernes Lastprüfwerkzeug, das für Entwickler gebaut wurde. Im Gegensatz zu älteren Werkzeugen wie JMeter oder LoadRunner.

- **Entwickler---freundlich**Tests sind in JavaScript geschrieben.
- **CLI---Erste**Perfekt für CI-/-CD Pipelines
- **Leichtgewicht**Keine Abhängigkeiten
- **Genau**In Go geschrieben für präzise Metriken
- **Scriptierbar**Volle Programmierfähigkeiten für komplexe Szenarien
- **Cloud®--bereit**: kann sich mit k-6 , Cloud, Grafana, Prometheus integrieren

Für minimales Blog-,-k.6- ist ideal, weil

1. **Wir können Caching testen.**.: . k . 6 . kann Cache-Header und Verhalten überprüfen
2. **Wir können echten Verkehr simulieren**Testen Sie mehrere gleichzeitige Benutzer
3. **Wir können Leistungsansprüche bestätigen**Messung der tatsächlichen Ansprechzeiten
4. **Wir können uns mit CI-/-CD integrieren.**Testen in unserer Pipeline automatisieren
5. **Wir können spezifische Szenarien testen**Kategorie Filtern – ," einzelne Beiträge – ," Homepage

## Installieren von k-6

### Installation von Windows

**Option Verwendung von Chocolatey -( Empfohlen**

```powershell
choco install k6
```

**Option Verwendung von Winget**

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

**Option "Handliche Installation"**

1. Laden Sie die neueste Windows-Version von [GitHub veröffentlicht](https://github.com/grafana/k6/releases)
2. Extrahieren `k6.exe` Datei
3. Fügen Sie das Verzeichnis zu Ihrem PATH hinzu oder verschieben `k6.exe` zu einem Verzeichnis bereits in PATH

**Verifizieren Sie die Installation.**

```powershell
k6 version
```

### Mac Installation

**Option zur Verwendung von Homebrew-Geräten**

```bash
brew install k6
```

**Option "MacPorts verwenden"**

```bash
sudo port install k6
```

**Option "Handliche 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
```

**Verifizieren Sie die Installation.**

```bash
k6 version
```

### Linux Installation

**Option Verwendung von Paketmanagern**

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 zur Verwendung von Snap**

```bash
sudo snap install k6
```

**Option "Handliche 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
```

**Option zur Verwendung von Docker**

```bash
docker pull grafana/k6:latest

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

**Verifizieren Sie die Installation.**

```bash
k6 version
```

## Das Verständnis der Testanatomie

Bevor wir ins Testen eintauchen, verstehen ''s die Grundstruktur eines k-Tests.

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

Schlüsselbegriffe

- **Virtuelle Benutzer**Simulierte gleichzeitige Benutzer
- **Dauer**Wie lange der Test läuft
- **Kontrollen**Beenden Sie den Test mit Assertionen, die nicht bereinigen
- **Schwellenwerte**Nichtzutreffendes streichen.
- **Metrik**Ansprechzeit ,-Durchsatz ,-Fehlerrate

## Leistungsprüfungen

Vor dem Testen Ihrer Anwendung, lassen Sie uns die fünf wichtigsten Arten von Lasttests verstehen und wann jedes verwenden

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

### Rauchtests

**Zweck**Prüfen Sie das System arbeitet unter minimaler Belastung

**Wann ist zu verwenden?**:

- Nach jeder Codeänderung
- Vor intensiveren Tests
- Als geistesgefährdete Prüfung in CI-/-CD

**Merkmale**:

- ,1-2 , VUs , ( , virtuelle Benutzer , ) ,
- Kurze Dauer
- Prüfung der grundlegenden Funktionalität

### Lastprüfungen

**Zweck**Bewertung der Leistung unter erwarteter Normallast

**Wann ist zu verwenden?**:

- Ermittlung der Ausgangsleistung
- Um SLAs zu überprüfen, sind sie erfüllt.
- Regelmäßige Leistungsregressionsprüfung

**Merkmale**:

- Realistische Anzahl der Nutzer
- Dauerlast
- Typische Dauer:

### Stresstests

**Zweck**Systembruchpunkt finden

**Wann ist zu verwenden?**:

- Kapazitätsgrenzen zu verstehen
- Ermittlung von Engpässen
- Planung für Skalierung

**Merkmale**:

- Nach und nach steigende Belastung
- Schub über die normale Kapazität hinaus
- Dauer:

### Würzige Prüfungen

**Zweck**Testverhalten unter plötzlichen Verkehrsspitzen

**Wann ist zu verwenden?**:

- Vorbereitung auf Produktstarts
- Testen von Auto---Skalierung
- Validierung des Fallback-Verhaltens

**Merkmale**:

- Plötzliche große Zunahme der Last
- Kurze Spießdauer
- Gesamtdauer: 1 Minuten

### 5.-Säulentests (-Dauerprüfungen

**Zweck**Suchen Sie Speicherlecks und Abbau im Laufe der Zeit

**Wann ist zu verwenden?**:

- Vor den wichtigsten Veröffentlichungen
- Prüfungsdienstleistungen für Langstrecken--
- Überprüfung der Ressourcenbereinigung

**Merkmale**:

- Normallast
- Längere Dauer Stunden oder Tage
- Überwachung auf Abbau

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

## Warum k-6 und nicht -...??

Mit so vielen Lastprüfwerkzeugen zur Verfügung, warum sollten Sie wählen k.M.S.K1. Let.'.s vergleichen k. M.K.3. mit beliebten Alternativen

### vs. Apache JMeter

**Apache JMeter** ist der Veteran von Lastprüfwerkzeugen

Funktion |, K6, |, JMeter, MSC4,
|---------|----|---------|
| **Installation** Eine einzelne binäre Version von , keine Abhängigkeiten benötigt Java eine schwerere Installation.
| **Prüfdefinition** JavaScript-Code XML oder GUI
| **Ressourcennutzung** Leichtgewichtige, leichtgewichtige und schwere (Java-)
| **Integration von CIP-/-CD** (CLI--P2P1P3P4P4p4P6P5P4K5P5p5P6D5P7P5EP4EP5F2P5K4P2EP1EP3EP6EP2AP4D4P5SK4EV5P2D5EV2P7EP7D5HP5D5DXEV1EV4DX
| **Curve lernen** Benutzerfreundlichkeit für Entwickler
| **Protokollunterstützung** Weitere Informationen finden Sie unter: http:europa.eu.int/comm/index_de.htm

**Wann JMeter stattdessen verwendet werden soll**

- Brauchen Sie GUI für nicht---technische Tester
- Protokolle über HTTP hinaus testen
- Bereits JMeter-Expertise im Team
- Brauchen Sie umfangreiche Plugin-Ökosystem

**Warum k-6 , ist besser für die meisten ASP-MSC1 ,NET Core Apps ,: .**

- Schneller zum Schreiben von Tests
- Leichtere Ressourcenbilanz
- Bessere Integration von CI-/-CD
- Mehr moderne Entwickler-Erfahrung

### k-6- vs Locust

**Heuschrecke** ist ein in Python-Shops beliebtes Lastprüfwerkzeug auf Basis von Pythons..

Funktion der |, k, 6, Locust
|---------|----|---------|
| **Sprache** |-JavaScript-Python-Python
| **Leistung** Sehr schnelles Gerät für die Laufzeit von ); langsameres Gerät für Python-GIL, |;
| **Benutzerfreundlichkeit** Einfaches JavaScript für Pythonic-Pythonisches Python-Phytonisches
| **Verteilte Tests** ]|-k-6-Wolke -- (-paid -- )--|--- gebaute - in freiem ) --
| **Web UI** Begrenzte Anzahl an Echtzeit-UI-Messungen
| **Metrics exportieren** Viele Formate CSV, ,, Web UI, MSC3,

**Wann wird Locust stattdessen verwendet?**

- Erstes Team von Python--
- Brauchen Sie kostenlose verteilte Tests
- Reale UI der --Zeit während der Tests wollen
- Komplexe Python-Logik in Tests

**Warum k-6 , ist besser für die meisten ASP-MSC1 ,NET Core Apps ,: .**

- Bessere Leistung für genaue Metriken
- JavaScript vertrauter für Web-Entwickler
- Cleaner-Schwellenwert-Syntax
- Bessere Integration von Prometheus/-Grafana

### k.6. vs. Gatling

**Gärung** ist ein Scala---basiertes Tool mit hervorragender Berichterstattung

Funktion |, K6, K|, Gatling
|---------|----|---------|
| **Sprache** |-Java JavaScript-Code:
| **Berichte** Grundlegende Erweiterungen von (+, ), |, schön gebaut in HTML-Berichten
| **Curve lernen** Leichtes, mittelschweres, mäßiges, mittleres und mittleres
| **Leistung** Sehr gut
| **Quelle öffnen** Vollständig geöffnet öffnen mit Enterprise-Additionen öffnen
| **Cloud-Dienst** ,| , k , 6 , Cloud , | , Gatling Enterprise

**Wann Sie stattdessen Gatling verwenden möchten**

- JVM./.Scala-Kompetenz im Team
- Beeindruckende eingebaute Berichte benötigen
- Prüfung komplexer HTTP-Szenarien
- Anforderungen an die Unternehmensunterstützung

**Warum k-6 , ist besser für die meisten ASP-MSC1 ,NET Core Apps ,: .**

- JavaScript ist zugänglicher
- Einfachere Einrichtung und Ausführung
- Besser für schnelle CIP-/-CD Kontrollen
- Einfacher für einfache HTTP-Tests

### Artillerie

**Artillerie** ist ein weiteres JavaScript Lasttest-Tool

Funktion |, K6, Artillerie |
|---------|----|---------|
| **Prüfdefinition** JavaScript-Code für die Haken von |YAML JS
| **Leistung** Schnellere und langsamere MSK-Knoten
| **Benutzerfreundlichkeit** Code: -, basierend auf |, YAML-Konfiguration, -, basierend
| **Gebaut für** Beladungsprüfung Beladung Belastbarkeit Beanspruchung Funktionsprüfung Beladung
| **Anordnungen** Hervorragende Schwellenwerte Grunderwartungen
| **Erweiterbarkeit** Erweiterungsbauteile für |, Plugins für MSV2

**Wann Sie statt dessen Artillerie verwenden**

- Bevorzugen Sie YAML vor Code
- Socket-..io Prüfung benötigen
- Funktionelle Tests wollen kombinierte Last
- Bereits Verwendung von Node-.-Js-Ökosystem

**Warum k-6 , ist besser für die meisten ASP-MSC1 ,NET Core Apps ,: .**

- Präzisere Metriken
- Besseres Schwellensystem
- Cleaner JavaScript API
- Reifer und stabiler

### K.M.SK. gegen Wrk.MSK.

**Wrk** ist ein leichtes HTTP-Benchmarking-Tool

]|-Feature
|---------|----|---------|
| **Benutzerfreundlichkeit** Hoch---Level-API Niedrige --Level-C Hoch-MSK1-level-API
| **Szenarien** Weitere Informationen finden Sie unter: http:www.cordis.lu
| **Metrik** Umfassende, umfassende und grundlegende Informationen
| **Scripting** |-JavaScript-Lua-Musik
| **Anwendungsfall** Vollständige Belastungsprüfung - Schnelle Benchmarks

**Wann Sie wrk stattdessen verwenden sollten**

- Absolut minimaler Overhead erforderlich
- Schnelle Benchmarks
- Rohe HTTP-Leistung testen
- Protokollprüfung auf niedriger Ebene

**Warum k-6 , ist besser für die meisten ASP-MSC1 ,NET Core Apps ,: .**

- Viel einfacher zu schreiben Tests
- Bessere Berichterstattung und Metriken
- Szenariounterstützung (-Rampe--Up,-Stadien)-Stadium
- WISSENSCHAFTLICHES UMFANG

### k ,6 , vs. Playwright , / , Zypressen , ( , Browser , - , basierend auf ) ,

**Wiedergaberecht** und **Zypressen** sind Browser-Automatisierungswerkzeuge, die manchmal für Lasttests verwendet werden

Beschreibung der Funktion „|" und ‚6‘
|---------|----|---------|
| **Ansatz** Protokoll-, HTTP-Ebene, Echtzeitbrowser
| **Leistung** Tausende von VUs | Zehn von Browsern
| **Ressourcennutzung** Leichtgewichtige, schwere und schwergewichtige MSK-Browser
| **Ausführung von JavaScript** Nicht zutreffend
| **Primärer Anwendungsfall** Prüfung der Last , | , E ,2 ,E-Funktionsprüfung

**Wann zu verwenden Playwright-/-Zypress statt ?:-**

- Notwendigkeit, die Ausführung von JavaScript zu testen
- Muss Browser-Rendering überprüfen
- Prüfung komplexer SPAs
- Funktionelles E-2-E-Testen

**Warum k-6 , ist besser für die meisten ASP-MSC1 ,NET Core Apps ,: .**

- Protokoll-Testen auf -, ausreichend für server-basierte Anwendungen
- Notwendigkeit, gleichzeitige Benutzer zu simulieren
- Viel effizientere Ressourcennutzung

### Zusammenfassung ,: , k , 6' , Sweet Spot

**Wählen Sie k.6, wenn Sie möchten.**

- Schnelle Prüfung der genauen Last
- Entwicklerfreundliche JavaScript-API
- Exzellente CIP-/-CD-Integration
- Protokoll---Level HTTP-Testing - kein Browser benötigt
- Reiche Szenariounterstützung (-Smoke,-Last,-Stress,-Spike,-save
- Moderne Werkzeuge mit gutem Ökosystem
- Leichte Ressourcennutzung

**k-6- ist perfekt für ,:-**

- APIs und Webdienste
- Server®- side gerenderte Apps
- CIP-/-CD-Leistungstore
- Entwickler---getriebene Leistungsprüfung
- Cloud®--native Anwendungen

**Betrachten Sie Alternativen, wenn Sie brauchen.**

- Browser®- based testing [Wiedergaberecht](https://playwright.dev/))
- Umfangreiche Protokollunterstützung über HTTP hinaus [JMeter](https://jmeter.apache.org/))
- Kostenloses verteiltes Testen [Heuschrecke](https://locust.io/))
- Schöne gebaute ,-'in Berichte , ('use [Gärung](https://gatling.io/))
- GUI für nicht messtechnische Tester [JMeter](https://jmeter.apache.org/))

## Nächste Schritte

Jetzt, da Sie verstehen, was k-6 ist , wie man es installiert , die Arten von Leistungstests zur Verfügung , und warum k-6 , ist eine große Wahl für ASP , . ,NET Core-Anwendungen , , , Sie sind bereit zu schreiben tatsächlichen Tests ,.

**Weiter zu [Teil Praktische Umsetzung](/blog/k6-testing-practical)** wobei wir uns auf : beziehen

- Einrichtung Ihrer Testumgebung
- Schreiben von Rauch-,-Last -,-Stress - ,-Spike - und Einweichentests
- Cache-Verhalten testen
- Realistische User Journey Simulationen
- CI-/-CD Integration mit GitHub Aktionen
- Leistungsregressionserkennung
- Profilierung mit dotTrace und dotMemory
- Best Practices und Fehlerbehebung

## Aufkommen

### Dokumentation

- [Amtliche Dokumente](https://k6.io/docs/) Gesamte Dokumentation
- [JavaScript API](https://k6.io/docs/javascript-api/) Alle verfügbaren APIs
- [Beispiele](https://github.com/grafana/k6-learn) Beispiel für Testskripte
- [K.M.SK0-Metriken](https://k6.io/docs/using-k6/metrics/) Metriken verstehen
- [Schwellenwerte](https://k6.io/docs/using-k6/thresholds/) Einstellen von Pass-Kriterien

### Alternative Lastprüfwerkzeuge

- [Apache JMeter](https://jmeter.apache.org/) Belastbarkeitsprüfung auf Java-Basis
- [Heuschrecke](https://locust.io/) Belastungsprüfung auf Basis von Python-
- [Gärung](https://gatling.io/) Belastungsprüfung auf der Grundlage von Scala-
- [Artillerie](https://www.artillery.io/) Prüfung der Belastung von MSK-Knoten
- [Wrk](https://github.com/wg/wrk) HTTP-Benchmarkingwerkzeug
- [Wiedergaberecht](https://playwright.dev/) Browser-Automatisierung Testen