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

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

Votre application fonctionne parfaitement sur votre ordinateur portable. Les tests d'unité réussissent . Les essais d'intégration réussint M SK2 Vous vous déployez à la production , et soudainement, tout se met en train de s'arrêter MSC4 Cinquante cent utilisateurs réels atteignent simultanément votre page d'accueil MST5 et votre serveur commence à retourner M ST6 erreurs M st7 Votre stratégie de caching soigneusement conçue M S ST8 Il est apparu qu'elle ne fonctionne pas M St 9 comme vous l'avez pensé M T 10 Cette demande de base de données que vous pensaviez être rapide M टी 11 C'est ce qui constitue un créneau d'étranglement à grande échelleM S ST 13

C’est le scénario du cauchemar que tous les développeurs craignent, mais la plupart ne testent pas. **Les essais de performance ne sont pas optionnels.** Ce guide de deux parties vous montrera exactement comment prévenir ce scénario en utilisant k6, l’outil moderne d’essai des charges qui est suffisamment puissant pour les applications d’entreprise mais assez simple à exploiter dans votre pipeline CD.

Il s'agit de **Partie 1** d'une série de deux pièces - sur l'essai de charge avec kM SK1

- **Partie 1**: Introduction à l’installation de kM SK1 Types d’essai de , , et pourquoi k6
- **[Partie 2: Mise en œuvre pratique](/blog/k6-testing-practical)**: Essais de rédactionM SK1 CI/ Intégration à la CD , profilageMNK4 et exemples réelsMRK5world

## Introduction

Les tests de performance sont essentiels pour toute production ASP.NET Application de base. Que vous construisiez un simple blogM SK3 une architecture complexe de microservices , ou une application d’entrepriseMSC5 vous devez savoir comment votre application se comporte sous la chargeMNK6 Est-ce qu’elle traite des utilisateurs concurrents MRK7 concurrentsMMK8 SNK9 Où se trouvent les embouteillages?? Votre stratégie de cache fonctionne-t-elle réellement?

Ce guide complet vous montre comment charger les applications de base ASP.NET en utilisant [k6](https://k6.io/) - l’un des outils d’essai de chargement source les plus puissants disponibles, - . Alors que nous utilisons [MinimalBlog](/blog/minimalblog-introduction) comme notre exemple d’application (a simple markdown-blog basé sur la mémoire et le caching des sorties ), les techniques et les modèles présentés ici s’appliquent à **toute application ASP.NET Core**.

À la fin de cette série de deux pièces, vous saurez comment procéder.

- Installer et configurer k6 sur n'importe quelle plate-forme (Windows, MacM SK3 LinuxMSC4
- Rédiger des tests de performance exhaustifs pour différents scénarios
- Intégrer k6 dans votre pipeline CI/CD avec les actions de GitHub
- Utiliser les outils de profilage (dotTraceM SK1 dotMemory) à côté de kMSC3 pour repérer des lacunes
- Mettre en oeuvre différentes stratégies d'essai: fumée , charge, stressM SK3 spikeMSC4 et essais de suction
- Détecter la régression de performance afin d'empêcher que le code lent ne parvienne à la production

**Pourquoi MinimalBlog comme exemple?** Il'est une application ASP réelle .NET Core 9.0 avec des patrons communsMSC3 Pages RazorM SK4 caching de la mémoire,, cachage de l’ output,, fichier IMST7OMSST8 et traitement du marquage,MST9 Les méthodes d’essai que vous apprenez à appliquer aux applications MVC sont les mêmes pour vos applications Web MST11 API Web,M ST12 Application Blazor,M st13 ou API minimales,Mst14

[TOC]

## Qu'est-ce que k6 et pourquoi l'utiliser?

[k6](https://k6.io/) est un outil moderne d'essai de chargement conçu pour les développeurs. Contrairement à des outils plus anciens comme JMeter ou LoadRunner

- **Developer-friendly**: Les essais sont écrits en langage JavaScript
- **CLI-première**: Perfect pour les pipelines CIM SK1CD
- **Peu de poids**: Binaire unique, aucune dépendance
- **Précision**: Written in Go for precise metrics
- **Écribles**: Capacité de programmation complète pour des scénarios complexes
- **Nuages-à l'avance**: Peut s'intégrer à kM SK1 Cloud , Grafana, Prometheus

Pour MinimalBlog, kM SK1 est idéal parce:

1. **Nous pouvons tester le caching**: k6 peut vérifier les titres de cache et le comportement
2. **Nous pouvons simuler le trafic réel.**: Tester plusieurs utilisateurs concurrents
3. **Nous pouvons valider les revendications de rendement**: Mesure des temps de réponse réels
4. **Nous pouvons nous intégrer à CI/CD**: Essais automatisés dans notre pipeline
5. **Nous pouvons tester des scénarios spécifiques**: Filtration des catégoriesM SK1 Postes individuels , page d'accueil

## Installer k6

### Installation de Windows

**Option 1: Utilisation de chocolat (RecommandéM SK2**

```powershell
choco install k6
```

**Option 2: Utilisation de Winget**

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

**Option 3: Installation manuelle**

1. Téléchargez la version la plus récente de Windows [Publications de GitHub](https://github.com/grafana/k6/releases)
2. Extraire le `k6.exe` Le fichier
3. Ajouter le répertoire à votre PATH ou déménager `k6.exe` vers un répertoire déjà dans la PATH

**Vérifier l’installation:**

```powershell
k6 version
```

### Installation de Mac

**Option 1: Utilisation de l'alcool à base de bois d'oeuvre (RecommandéM SK2**

```bash
brew install k6
```

**Option 2: Utilisation de MacPorts**

```bash
sudo port install k6
```

**Option 3: Installation manuelle**

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

**Vérifier l’installation:**

```bash
k6 version
```

### Installation de Linux

**Option 1: Utilisation de gestionnaires de paquet**

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

Pour **Fedora/CentOS/RHEL**:

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

**Option 2: Utilisation de Snap**

```bash
sudo snap install k6
```

**Option 3: Installation manuelle**

```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: Utilisation de Docker**

```bash
docker pull grafana/k6:latest

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

**Vérifier l’installation:**

```bash
k6 version
```

## Comprendre k6 Anatomie d'essai

Avant de nous plonger dans l’essai, laissez-nous comprendre la structure fondamentale d’un test k6

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

Principaux concepts:

- **Utilisateurs virtuels (VUs)**: Utilisateurs concurrents simulés
- **Durée**: Combien de temps dure l'essai
- **Contrôles**: Affirmations qui n’arrêtent pas le test
- **Seuils**: PasserM SK1 Critères de défaillance
- **Metriques**: Temps de réponseM SK1 Proportion d'entrée , Taux d'erreur

## Types d'essais de performance

Avant d’essayer votre application, laissez 's comprendre les cinq principaux types de tests de charge et quand utiliser chacune:

```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. Essais de fumée

**Objectif**: Vérifier si le système fonctionne sous une charge minimale

**Quand utiliser**:

- Après chaque changement de code
- Avant d'effectuer des tests plus intensifs
- À titre de vérification sanitaire dans CI/CD

**Caractéristiques**:

- 1-2 VUs (Usagers virtuels)
- Durée courte (30s-1minM SK2
- Essais de fonctionnalités de base

### 2. Essais de chargement

**Objectif**: Évaluer le rendement en fonction de la charge normale prévue

**Quand utiliser**:

- Établir le rendement de base
- Veiller à ce que les SLA soient respectés
- Essais réguliers de régression du rendement

**Caractéristiques**:

- Nombre réel d'utilisateurs
- Charge soutenue
- Durée typique: M SK1 minutes

### 3. Essais de stress

**Objectif**: Trouver le point de rupture du système

**Quand utiliser**:

- Pour comprendre les limites de capacité
- Détermination des lacunes
- Planification de l'agrandissement

**Caractéristiques**:

- Augmentation graduelle de la charge
- Supprimer au-delà de la capacité normale
- Durée: M SK1 minutes

### 4. Essais d'étalonnage

**Objectif**: Comportement d'essai en cas de ralentissement soudain du trafic

**Quand utiliser**:

- Préparation des lancements de produits
- Évaluation automatique-scaling
- Validation du comportement de régression

**Caractéristiques**:

- Augmentation soudaine de la charge
- Durée de l'éruption courte
- Durée totale: M SK1 minutes

### 5. Essais d'écoulement  Essai de durabilité

**Objectif**: Trouver les fuites de mémoire et la dégradation au fil du temps

**Quand utiliser**:

- Avant les grandes sorties
- Essai des services de fonctionnement longs-
- Validation du nettoyage des ressources

**Caractéristiques**:

- Niveaux de charge normal
- Durée prolongée (heures ou joursM SK1
- Surveillance de la dégradation

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

## Pourquoi k6 et nonM SK1

Avec tant d’outils de test de charge disponibles, pourquoi choisir k6? LaissezM SK2s comparer k 6 avec les solutions de rechange populairesMSC4

### k6 vs Apache JMeter

**Apache JMeter** est l’ancienneté des outils d’essai de charge ( depuis 1999).

| Caractéristiques | kM SK2 | JMeter SSK4
|---------|----|---------|
| **Installation** | Binaire uniqueM SK1 aucune dépendance | requiert Java, installation plus lourde
| **Définition d'essai** | Code JavaScript | XML ou GUI |
| **Utilisation des ressources** | Poids léger (Go) | Peu lourd
| **CI/Intégration du CD** | Excellent (CLI-firstM SK3
| **Curve d'apprentissage** | Facile pour les développeurs | Plus facile à utiliser
| **Soutien du protocole** | HTTPM SK1 Sockets Web, gRPC | Broader

**Quand utiliser JMeter plutôt:**

- Besoin de GUI pour les essais techniques non -
- Examen des protocoles au-delà de HTTP (JDBC, LDAP , SOAPM SK3
- JMeter possède déjà une expertise en équipe
- Besoin d'un écosystème de plugin étendu

**Pourquoi k6 est meilleur pour la plupart des applications ASP.NET Core**

- Plus rapide à écrire les tests (JavaScript vs XML)
- Écart des ressources plus léger
- Amélioration de l’intégration CI/CD
- Plus d'expérience de développeur moderne

### k6 vs Locust

**Les locus** est un outil de test de charge basé sur Python - , populaire dans les magasins de Python

| Caractéristique | kM SK2 | Locust SSK4
|---------|----|---------|
| **Langue** | JavaScript | Python |
| **Rendement** | Très rapide (Durée d'exécution de l'essai
| **Facilité d'utilisation** | JavaScript simple | Pythonic, facile |
| **Essais distribués** | kM SK1 Nuage (payé) | ConstruitMSC5dans MSC6sans frais
| **L'interface Web** | Limitée | Excellent réel-interface de travail temps |
| **Exportation de métriques** | Bon nombre de formats | CSV, UI Web MSC3

**Quand utiliser Locust plutôt:**

- Python-première équipe
- Besoin de tests distribués gratuits
- Besoin d'interface Web réelle-au cours des essais
- Logique complexe de Python dans les tests

**Pourquoi k6 est meilleur pour la plupart des applications ASP.NET Core**

- Meilleure performance pour des mesures précises
- JavaScript plus familier pour les développeurs Web
- seuil plus propre/syntaxe d'affirmation
- Une meilleure intégration Prometheus/Grafana

### k6 vs Gatling

**Gatling (Québec)** est un outil basé sur Scala- avec une excellente présentation de rapports

| Caractéristique | kM SK2 MSC3 Gatling SMC4
|---------|----|---------|
| **Langue** | JavaScript | Scala/Java |
| **Rapports** | Extensions de base (+ extensions d'extensions
| **Curve d'apprentissage** | Facile | Moyenne Scala DSLM SK3 S|
| **Rendement** | Excellent | Excellent |
| **Source ouverte** | Ouvrir complètement | Ouvertre avec l'entreprise ajouter-ons |
| **Service en nuage** | kM SK1 Cloud | Gatling Enterprise |

**Quand utiliser Gatling en remplacement:**

- JVM/Scala expertise en équipe
- Besoin d’une construction stunning- dans les rapports
- Évaluation de scénarios HTTP complexes
- Exigences relatives au soutien aux entreprises

**Pourquoi k6 est meilleur pour la plupart des applications ASP.NET Core**

- JavaScript est plus accessible
- Établissement et exécution plus simples
- Améliorer les contrôles CI/CD rapides
- Plus simple pour les tests HTTP simples

### k6 vs Artillerie

**Artillerie** est un autre outil d’essai de chargement JavaScript.

| Caractéristiques de l'artillerie | kM SK2 |
|---------|----|---------|
| **Définition d'essai** | Code JavaScript | YAML + crochets de JS M|
| **Rendement** | Plus rapide (Go) | Moteur plus faible SSK4NodeM SK5js
| **Facilité d'utilisation** | Code
| **Élaboré pour** | Essais de charge | Essai de charge
| **Affirmations** | Seuils extrêmement élevés | Expectations de base
| **Extensibilité** | Extensions Plugins |

**Quand utiliser l'artillerie plutôt:**

- Préférer YAML au-dessus du code
- Besoin de tester le socket.io
- Besoin de tests fonctionnels de charge combinée +
- Utiliser déjà Node.js écosystème

**Pourquoi k6 est meilleur pour la plupart des applications ASP.NET Core**

- Mesures plus précises (Go vs NodeM SK1js)
- Un meilleur système de seuil
- API de JavaScript plus propre
- Plus mûre et plus stable

### k6 vs wrk/wrkM SK2

**États-Unis d'Amérique** est un outil de référence HTTP léger.

| Caractéristiques | kM SK2 | wrk SSK4
|---------|----|---------|
| **Facilité d'utilisation** | API de niveau élevé - d'un niveau élevé
| **Scénarios** | Soutien de scénarios riches | HTTP de base seulement |
| **Metriques** | Comprehensive | Basic |
| **Écrire** | JavaScript | Lua |
| **Utiliser le cas** | Essais de pleine charge | Critères rapides MSC2

**Quand utiliser wrk plutôt:**

- Besoin de frais généraux minimes absolus
- Évaluation rapide des points de repère
- Évaluation de la performance brute HTTP
- Essais de protocole à faible niveau

**Pourquoi k6 est meilleur pour la plupart des applications ASP.NET Core**

- Il est beaucoup plus facile de rédiger des tests
- Amélioration des rapports et de la mesure
- Soutien du scénario (ramp-upM SK2 étapesMSC3
- CI/CD amiable

### k6 vs PlaywrightM SK1Cypress (Browser-BasedMSC4

**Playwright** et **Cypresse** sont des outils d’automatisation du navigateur parfois utilisés pour les essais de chargement.

| Caractéristiques | k6 MSC3 PlaywrightM SK4Cypress SMC5
|---------|----|---------|
| **Approche** | Protocole-niveau HTTP | navigateur réel |
| **Rendement** | milliers de VUs | dizaines de navigateurs |
| **Utilisation des ressources** | Moins lourds | Peu lourds
| **Exécution de JavaScript** | Non | Oui |
| **Cas d'utilisation primaire** | Essais de chargement | E2E essais fonctionnels |

**Quand utiliser Playwright/Cypress plutôt:**

- Besoin de tester l'exécution JavaScript
- Besoin de vérifier la traduction du navigateur
- Essai de SPA complexes
- Essais fonctionnels E2E

**Pourquoi k6 est meilleur pour la plupart des applications ASP.NET Core**

- Protocole-essais de niveau suffisants pour le serveur-applications remises
- Il faut simuler des utilisateurs concurrents 100+
- Utilisation beaucoup plus efficace des ressources

### Résumé: kM SK1s Sweet Spot

**Choisissez k6 lorsque vous le souhaitez:**

- Essais de charge rapides,
- Developer-friendly JavaScript API
- Excellente intégration CI/CD
- Protocole-test HTTP de niveau (aucun navigateur n'est requis )
- Soutien à des scénarios riches (smoke,loadMSC2stressM SK3 spike , soakMST5
- Outils modernes avec un bon écosystème
- Utilisation de ressources légères

**k6 est parfait pour**

- APIs et services Web
- Applications rendues par le serveur-
- Ports de performance CI/CD
- Tests de performance dirigés par le développeur-
- Cloud-applications natives

**Pensez aux solutions de rechange si vous avez besoin:**

- Examen basé sur le navigateur-User ( [Playwright](https://playwright.dev/))
- Soutien du protocole étendu au-delà de HTTP (use [JMeter](https://jmeter.apache.org/))
- Essais distribués gratuits (utiliser [Les locus](https://locust.io/))
- Pièce construite-dans les rapports (usage [Gatling (Québec)](https://gatling.io/))
- GUI pour les essais techniques non -User [JMeter](https://jmeter.apache.org/))

## Prochaines étapes

Maintenant que vous comprenez ce qu’est k6, , comment l’installer, , les types d’essais de performance disponibles, , et pourquoi k 6 est une excellente solution pour ASP,. applications centrales NET,,, vous,M SK7 êtes prêts à commencer à rédiger des essais réels.

**Continuer à [Partie 2: Mise en œuvre pratique](/blog/k6-testing-practical)** où nous devons couvrir

- Établissement de votre environnement d'essai
- Évaluation de la fumée , charge , stress
- Essai du comportement de cache
- Simulations réalistes des voyages de l'utilisateur
- CI/CD intégration avec les actions de GitHub
- Détection de la régression du rendement
- Profilage avec dotTrace et dotMemory
- Pratiques exemplaires et résolution des problèmes

## Ressources

### k6 Documentation

- [Documents officiels k6](https://k6.io/docs/) - Documentation complète k6
- [k6 API JavaScript](https://k6.io/docs/javascript-api/) - Tous les APIs disponibles k6
- [k6 exemples](https://github.com/grafana/k6-learn) - Exemple de scripts d'essai
- [k6 métriques](https://k6.io/docs/using-k6/metrics/) - Comprendre les mesures
- [k6 seuils](https://k6.io/docs/using-k6/thresholds/) - Pass de configurationM SK1 Critères d'échec

### Autres outils d'essai de chargement

- [Apache JMeter](https://jmeter.apache.org/) Essais de charge basés sur - Java-
- [Les locus](https://locust.io/) Test de charge basé sur - Python-
- [Gatling (Québec)](https://gatling.io/) Essais de charge fondés sur - Scala-
- [Artillerie](https://www.artillery.io/) - Node.js essais de charge
- [États-Unis d'Amérique](https://github.com/wg/wrk) - Outil de référence HTTP
- [Playwright](https://playwright.dev/) - Automatisation du navigateur & essais