# Lataa testaus ASP.NET Core -sovellukset k6:lla: Esittely

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

Sovelluksenne toimii täydellisesti kannettavalla tietokoneellanne. Yksikkötestit läpäisevät. Integraatiotestit läpäisevät tuotannon, ja yhtäkkiä kaikki pysähtyy. Viisisataa oikeaa käyttäjää osuu sivullesi yhtä aikaa, ja palvelimesi alkaa palauttaa 503 virhettä. Huolellisesti laadittu välimuististrategiasi ei siis toimi aivan niin kuin luulit. Se tietokanta, jonka luulit olevan nopea? Se luo pullonkaulan mittakaavassa.

Tätä painajaista jokainen kehittäjä pelkää, mutta suurin osa ei testaa. **Suorituskykytestit eivät ole valinnaisia - se on ero onnistuneen lanseerauksen ja 3 AM:n hätäsivun välillä.** Tämä kaksiosainen opas näyttää tarkalleen, miten tämä skenaario voidaan estää k6-koneella, joka on riittävän tehokas yrityssovelluksiin, mutta riittävän yksinkertainen toimimaan CI/CD-putkessa.

Tämä on **Osa 1** kaksiosaisesta sarjasta, joka koskee kuormitustestausta k6:lla:

- **Osa 1 (tämä artikla)**: Johdatus k6:een, asennus, testityypit ja miksi k6
- **[Osa 2: Käytännön toteutus](/blog/k6-testing-practical)**: Kirjoitustestit, CI/CD-integraatio, profilointi ja tosimaailman esimerkit

## Johdanto

Suorituskykytestit ovat kriittisiä kaikissa tuotannon ASP.NET Core -sovelluksissa. Rakennatpa yksinkertaista blogia, monimutkaista mikropalveluarkkitehtuuria tai yrityssovellusta, sinun täytyy tietää, miten sovelluksesi käyttäytyy kuormitettuna. Kestääkö se 100 samanaikaista käyttäjää? 1 000? Missä pullonkaulat ovat? Toimiiko välimuististrategiasi?

Tämä kattava opas näyttää, kuinka ASP.NET Core -sovellukset ladataan [k6](https://k6.io/) - yksi tehokkaimmista avoimen lähdekoodin testauksen työkaluista. [MinimalBlog](/blog/minimalblog-introduction) Esimerkkisovelluksenamme (yksinkertainen markdown-pohjainen blogi, jossa on muistia ja välimuistia) tässä esitetyt tekniikat ja kuviot koskevat **mikä tahansa ASP.NET-ydinsovellus**.

Tämän kaksiosaisen sarjan loppuun mennessä osaat:

- Asenna ja määritä k6 millä tahansa alustalla (Windows, Mac, Linux)
- Kirjoita kattavat suorituskykytestit eri skenaarioille
- Integroi k6 CI/CD-putkeen GitHub-toiminnoilla
- Käytä profilointityökaluja (pistejäljitys, pistemuisti) k6:n rinnalla pullonkaulojen löytämiseksi
- Toteuta erilaisia testausstrategioita: savu-, kuormitus-, stressi-, piikki- ja liotustestit
- Aseta suoritustason regressiohavaitseminen, jotta hidas koodi ei pääse tuotantoon

**Miksi esimerkkinä on minimalBlog?** Se on todellinen ASP.NET Core 9.0 -sovellus, jossa on yhteiset kuviot: Razor-sivut, muistivälimuistit, välimuistit, tiedostojen I/O ja maaliviivakäsittely. Testit koskevat yhtä lailla MVC-sovelluksia, verkkorajapintoja, Blazor-sovelluksia tai minimaalisia rajapintoja.

[TOC]

## Mikä on k6 ja miksi käyttää sitä?

[k6](https://k6.io/) Toisin kuin vanhemmat työkalut, kuten JMeter tai LoadRunner, k6 on:

- **Kehittäjäystävällinen**: Testit on kirjoitettu JavaScriptiin (ES6+)
- **CLI-ensimmäinen**: Täydellinen CI/CD-putkistoille
- **Kevyt**: Yksi binääri, ei riippuvuuksia
- **Täsmällinen**: Kirjoittanut Siirry tarkkoihin mittoihin
- **Käsikirjoitettava**: Kompleksisten skenaarioiden täydet ohjelmointivalmiudet
- **Pilvivalmiit**: Kykenee integroitumaan k6 Cloud, Graphana, Prometheus

MinimalBlogille k6 on ihanteellinen, koska:

1. **Voimme testata välilyöntejä**K6 voi varmistaa välimuistin otsikot ja käyttäytymisen
2. **Voimme simuloida todellista liikennettä**: Testaa useita samanaikaisia käyttäjiä
3. **Voimme vahvistaa suoritusväitteet**: Mittaa todelliset vasteajat
4. **Voimme integroitua CI/CD:n kanssa**: Automatisoi testaus putkeen
5. **Voimme testata tiettyjä skenaarioita**: Luokan suodatus, yksittäiset viestit, kotisivut

## Asentaminen k6

### Ikkunan asennus

**Vaihtoehto 1: Suklaan käyttö (suositeltu)**

```powershell
choco install k6
```

**Vaihtoehto 2: Wingetin käyttö**

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

**Vaihtoehto 3: Manuaalinen asennus**

1. Lataa viimeisin Windows-julkaisu osoitteesta [GitHubledget](https://github.com/grafana/k6/releases)
2. Poista `k6.exe` tiedosto
3. Lisää hakemisto PDH:hen tai siirrä `k6.exe` jo PDH:ssa olevaan hakemistoon

**Varmista asennus:**

```powershell
k6 version
```

### Mac-asennus

**Vaihtoehto 1: Homebrew'n käyttö (suositeltu)**

```bash
brew install k6
```

**Vaihtoehto 2: MacPortsin käyttö**

```bash
sudo port install k6
```

**Vaihtoehto 3: Manuaalinen asennus**

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

**Varmista asennus:**

```bash
k6 version
```

### Linux-asennus

**Vaihtoehto 1: Pakettipäälliköiden käyttö**

FINREP:n puolesta **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
```

FINREP:n puolesta **Fedora/CentOS/RHEL**:

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

**Vaihtoehto 2: Snap-toiminnon käyttö**

```bash
sudo snap install k6
```

**Vaihtoehto 3: Manuaalinen asennus**

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

**Vaihtoehto 4: Dockerin käyttö**

```bash
docker pull grafana/k6:latest

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

**Varmista asennus:**

```bash
k6 version
```

## K6-testin anatomian ymmärtäminen

Ennen kuin sukellamme testaukseen, ymmärretään k6-testin perusrakenne:

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

Avainkäsitteet:

- **Virtuaalikäyttäjät**: Simuloituvat rinnakkaiskäyttäjät
- **Kesto**: Kuinka kauan testi kestää
- **Tarkastukset**: Asenteet, jotka eivät pysäytä testiä
- **Kynnysarvot**: Läpäisy-/hylkäysperusteet
- **Metriikka**: Vasteaika, tulos, virhetaso

## Suorituskykytestien tyypit

Ennen sovelluksen testaamista selvitetään viisi pääasiallista kuormitustestiä ja niiden käyttöajankohta:

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

**Aihe**: Varmista, että järjestelmä toimii minimilatauksessa

**Milloin valmistetta käytetään**:

- Jokaisen koodinmuutoksen jälkeen
- Ennen intensiivisempien testien tekemistä
- Mielenterveydellisyyden tarkistamisena CI/CD

**Ominaispiirteet**:

- 1-2 VU:ta (Virtuaalikäyttäjät)
- Lyhyt kesto (30s-1min)
- Testaa perustoimintoja

### 2. Kuormitustestit

**Aihe**: Arvioi suorituskykyä odotetulla normaalikuormalla

**Milloin valmistetta käytetään**:

- Lähtötason suorituskyvyn määrittäminen
- Varmistaa, että SLA-sopimukset täyttyvät
- Säännöllinen regressiotesti

**Ominaispiirteet**:

- Käyttäjien realistinen määrä
- Kestävä kuormitus
- Tyypillinen kesto: 5-15 minuuttia

### 3. Stressitestit

**Aihe**: Etsi järjestelmän rikkoutumispiste

**Milloin valmistetta käytetään**:

- Kapasiteettirajojen ymmärtäminen
- Pullonkaulojen tunnistaminen
- Kaavoituksen suunnittelu

**Ominaispiirteet**:

- Vähitellen kasvava kuormitus
- Työntövoima yli normaalin kapasiteetin
- Kesto: 10-30 minuuttia

### 4. Spike-testit

**Aihe**: Testikäyttäytyminen äkillisten liikennepiikkien alla

**Milloin valmistetta käytetään**:

- Valmistellaan tuotteiden lanseerauksia
- Automaattiskaalauksen testaus
- Validoidaan varakäyttäytymistä

**Ominaispiirteet**:

- Äkillinen kuorman kasvu
- Lyhyt piikin kesto
- Kokonaiskesto: 5-10 minuuttia

### 5. Soak Tests (Endurance Tests)

**Aihe**: Etsi muistivuotoja ja muistin heikkenemistä ajan myötä

**Milloin valmistetta käytetään**:

- Ennen suuria julkistuksia
- Pitkäaikaispalvelujen testaus
- Varmennetaan resurssien puhdistusta

**Ominaispiirteet**:

- Normaalit kuormitustasot
- Pidennetty kesto (tunteja tai päiviä)
- Hajoamisen seuranta

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

## Miksi K6 ja ei...

Kun käytössä on niin paljon kuormaustestaustyökaluja, miksi valitsisit k6:n? Verrataan k6:ta suosittuihin vaihtoehtoihin:

### k6 vs Apache JMeter

**Apache JMeter** on kuormituksen testaustyökalujen veteraani (vuodesta 1999).

Aihe: JMeter
|---------|----|---------|
| **Asennus** Yksittäinen binääri, ei riippuvuuksia Vaatii Javaa, raskaampi asentaa
| **Testin määritelmä** JavaScript-koodi XML tai GUI
| **Resurssien käyttö** Kevytsarjalainen (Go) Raskas (Java)
| **CI/CD-integraatio** Erinomainen (CLI-ensimmäinen) Vaatii liitännäisiä
| **Opettele kurveja** Easy kehittäjille Steeper, GUI-focused
| **Protokollan tuki** HTTP, WebSockets, GRPC Broader (FTP, JDBC, SMTP jne.)

**Milloin JMeteriä käytetään sen sijaan:**

- Tarveopas ei-teknisille testaajille
- Testausprotokollat HTTP:n ulkopuolella (JDBC, LDAP, SOAP)
- JMeterillä on jo osaamista joukkueessa
- Tarvitaan laaja liitännäisekosysteemi

**Miksi k6 on parempi useimmille ASP.NET Core -sovelluksille:**

- Nopeammin kirjoittamaan testejä (JavaScript vs. XML)
- Kevyempi resurssijalanjälki
- Parempaa CI/CD-integraatiota
- Nykyaikaisempi kehittäjäkokemus

### k6 vs heinäsirkka

**Heinäsirkka** on Python-pohjainen kuormitustestaustyökalu, joka on suosittu Python-liikkeissä.

Aihe: heinäsirkka
|---------|----|---------|
| **Kieli** JULKAISUEHDOTUS Python
| **Suorituskyky** Erittäin nopea (juokseminen) Hitaampi (Python GIL)
| **Helppokäyttöisyys** Yksinkertainen Javascript Pythonic, helppo
| **Jaettu testaus** K6 Pilvi (maksullinen) Sisäänrakennettu (ilmainen)
| **Web UI** Erinomaisen reaaliaikaisen käyttöliittymän luominen
| **Metriikan vienti** Monia formaatteja CSV, web UI

**Milloin sen sijaan käytetään heinäsirkkaa:**

- Pythonin ensimmäinen joukkue
- Need free divide -testauksen tarve
- Haluaa reaaliaikaisen web-käyttöliittymän testien aikana
- Monimutkaista Python-logiikkaa testeissä

**Miksi k6 on parempi useimmille ASP.NET Core -sovelluksille:**

- Tarkkojen mittareiden parempi suorituskyky
- JavaScript lisää tuttuja web-kehittäjille
- Puhtaampi raja-arvo/vahvistussyntaksi
- Parempaa Prometheus/Grafanan integraatiota

### k6 vs Gatling

**Gatling** on Scala-pohjainen työkalu, jossa on erinomainen raportointi.

Aihe: Gatling
|---------|----|---------|
| **Kieli** JavaScript Scala/Java
| **Kertomukset** Perustiedot (+ laajennukset) Kaunis sisäänrakennettu HTML-raportti
| **Opettele kurveja** Kohtuullinen (Scala DSL) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
| **Suorituskyky** Erinomaisesti! Erinomaisesti!
| **Avaa lähdekoodi** Avoinna yritysten lisäjäsenillä
| **Pilvipalvelu** K6 Pilvi Gatling Enterprise

**Milloin Gatlingia käytetään sen sijaan:**

- JVM/Scala-osaaminen tiimissä
- Tarvitaan upeita, sisäänrakennettuja raportteja
- Testauskompleksiset HTTP-skenaariot
- Yritystukivaatimukset

**Miksi k6 on parempi useimmille ASP.NET Core -sovelluksille:**

- JavaScript on helpommin saatavilla
- Yksinkertaisempi asennus ja toteutus
- Parempi nopeille CI/CD-tarkastuksille
- Yksinkertaisempi yksinkertaiseen HTTP-testaukseen

### k6 vs. tykistö

**Tykistö** on toinen JavaScript-kuorman testaustyökalu.

Aihe: Tykistö
|---------|----|---------|
| **Testin määritelmä** JavaScript-koodi YAML + JS-koukut
| **Suorituskyky** Nopeampi (Go) Hitaampi (Node.js)
| **Helppokäyttöisyys** Koodipohjainen YAML-konfiguraatiopohjainen
| **Rakennettu** Kuormitustestaus Kuormitus + Toiminnallinen testaus
| **Aserminaatiot** Erinomaiset raja-arvot Perusodotukset
| **Laajamittaisuus** Laajennukset Liitännäiset

**Milloin tykistöä käytetään sen sijaan:**

- Mieluummin YAML kuin koodi
- Need Socket.io -testi
- Halutaan yhdistettyä kuormitusta + toiminnallisia testejä
- Käytä jo Node.js-ekosysteemiä

**Miksi k6 on parempi useimmille ASP.NET Core -sovelluksille:**

- Tarkemmat mittarit (Go vs. Node.js)
- Parempaa kynnysjärjestelmää
- Cleaner JavaScript API
- Kypsempi ja vakaampi

### k6 vs. wrk/wrk2

**Wrk** on kevyt HTTP-benchmarking-työkalu.

Ominaisuus k6 t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t ä t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t t
|---------|----|---------|
| **Helppokäyttöisyys** Korkeatasoinen API Matalatasoinen C + Lua
| **Skenaariot** Rikas skenaario tukee vain perus-HTTP:tä
| **Metriikka** Kokonaisvaltainen perusasia
| **Käsikirjoitus** JavaScript Lua
| **Käytä tapausta** Täyden kuormituksen testaus Nopeat viitearvot

**Milloin sen sijaan käytetään wrk:tä:**

- Tarvitaan ehdoton minimaalinen ylikulku
- Nopeat kertaluonteiset vertailuarvot
- Testataan raakaa HTTP-suorituskykyä
- Matalan tason protokollatestaus

**Miksi k6 on parempi useimmille ASP.NET Core -sovelluksille:**

- Paljon helpompi kirjoittaa testejä
- Paremmat raportit ja mittarit
- Skenaariotuki (laajennukset, vaiheet)
- CI/CD-ystävällinen

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

**Näytelmäkirjailija** sekä **Sypressi** ovat selaimen automaatiotyökaluja, joita joskus käytetään kuorman testaukseen.

Näytelmäkirjailija/Cypress-kirjailija
|---------|----|---------|
| **Lähestyminen** Protokollan taso HTTP Oikea selain
| **Suorituskyky** Tuhansia matkailijoita, kymmeniä selaimia
| **Resurssien käyttö** Kevytsarjalaiset Heavy (selaajat)
| **Javascript- suoritus** "Kyllä"
| **Ensisijainen käyttötapa** Kuormitustestaus E2E Toiminnallinen testaus

**Milloin Playwrightia/Cypressiä käytetään sen sijaan:**

- Javascript-testauksen tarve
- Selainten renderointi on todennettava
- Testauskompleksiset erityissuojelualueet
- Toiminnallinen E2E-testaus

**Miksi k6 on parempi useimmille ASP.NET Core -sovelluksille:**

- Protokollan tason testaus riittää palvelimen renderöityihin sovelluksiin
- Tarve simuloida 100+:n samanaikaista käyttäjää
- Paljon tehokkaampi resurssien käyttö

### Yhteenveto: K6's Sweet Spot

**Valitse k6, kun haluat:**

- Nopea, tarkka kuorman testaus
- Kehittäjäystävällinen JavaScript API
- Erinomainen CI/CD-integraatio
- Protokollan tason HTTP-testaus (ei tarvita selainta)
- Rikas skenaarion tuki (savu, kuormitus, stressi, piikki, liotus)
- Modernit työkalut hyvällä ekosysteemillä
- Kevyiden resurssien käyttö

**k6 sopii täydellisesti:**

- API- ja web-palvelut
- Palvelimen sivulle renderöidyt sovellukset
- CI/CD-tulosportit
- Kehittäjälähtöinen suorituskykytestaus
- Pilvisovellukset

**Harkitse vaihtoehtoja, jos tarvitset:**

- Selainpohjainen testaus (käytä [Näytelmäkirjailija](https://playwright.dev/))
- Laaja protokollatuki HTTP:n ulkopuolella (käyttö [JMeter](https://jmeter.apache.org/))
- Vapaasti jaettava testaus (käytä [Heinäsirkka](https://locust.io/))
- Kauniit sisäänrakennetut raportit (käytä [Gatling](https://gatling.io/))
- Ei-teknisten testaajien opas (käytä [JMeter](https://jmeter.apache.org/))

## Seuraavat vaiheet

Nyt kun ymmärrät, mikä k6 on, miten se asennetaan, millaisia suoritustestejä on saatavilla ja miksi k6 on hyvä valinta ASP.NET Core -sovelluksiin, olet valmis aloittamaan todellisten testien kirjoittamisen.

**Jatka [Osa 2: Käytännön toteutus](/blog/k6-testing-practical)** jossa käsittelemme:

- Testiympäristön pystyttäminen
- Savu-, kuormitus-, stressi-, piikki- ja liotustestien kirjoittaminen
- Testataan välimuistin käyttäytymistä
- Realistiset käyttäjämatkasimulaatiot
- CI/CD-integrointi GitHub-toimintoihin
- Suorituskyvyn regression toteaminen
- Profilointi pisteenjäljellä ja pistemuistilla
- Parhaita käytäntöjä ja vianetsintää

## Resurssit

### k6 Dokumentaatio

- [Viralliset k6-dokumentit](https://k6.io/docs/) - Täydelliset k6-dokumentit
- [k6 JavaScript API](https://k6.io/docs/javascript-api/) - Kaikki saatavilla olevat k6-rajapinnat
- [k6-esimerkkejä](https://github.com/grafana/k6-learn) - Esimerkkitestien käsikirjoitukset
- [k6-metriset](https://k6.io/docs/using-k6/metrics/) - Ymmärrysmittarit
- [k6-kynnykset](https://k6.io/docs/using-k6/thresholds/) - Läpäisy-/hylkäyskriteerien asettaminen

### Vaihtoehtoiset kuormitustestityökalut

- [Apache JMeter](https://jmeter.apache.org/) - Java-pohjainen kuormitustestaus
- [Heinäsirkka](https://locust.io/) - Python-pohjainen kuormitustestaus
- [Gatling](https://gatling.io/) - Scala-pohjainen kuormitustestaus
- [Tykistö](https://www.artillery.io/) - Node.js-kuormatestaus
- [Wrk](https://github.com/wg/wrk) - HTTP:n vertailutyökalu
- [Näytelmäkirjailija](https://playwright.dev/) - Selainautomaatio ja testaus