This is a viewer only at the moment see the article on how this works.
To update the preview hit Ctrl-Alt-R (or ⌘-Alt-R on Mac) or Enter to refresh. The Save icon lets you save the markdown file to disk
This is a preview from the server running through my markdig pipeline
Tuesday, 02 December 2025
La vostra applicazione funziona perfettamente sul vostro computer portatile. Test di unità passano. I test di integrazione passano. Implementate alla produzione, e improvvisamente tutto si arresta. Cinquecento utenti reali hanno colpito la vostra homepage contemporaneamente, e il vostro server inizia a restituire 503 errori. La vostra strategia di caching attentamente artigianale? Scopri che non funziona esattamente come pensavate. La query del database che pensavate fosse veloce? Sta creando un collo di bottiglia in scala.
Questo è lo scenario da incubo che ogni sviluppatore teme, ma la maggior parte non prova per. Il test delle prestazioni non è facoltativo - è la differenza tra un lancio di successo e una pagina di emergenza 3 AM. Questa guida in due parti vi mostrerà esattamente come evitare questo scenario utilizzando k6, il moderno strumento di prova del carico che è abbastanza potente per le applicazioni aziendali, ma abbastanza semplice da funzionare nella vostra pipeline CI / CD.
Questo e' Parte 1 di una serie in due parti su prove di carico con k6:
Il test delle prestazioni è fondamentale per qualsiasi applicazione ASP.NET Core di produzione. Sia che si stia costruendo un blog semplice, un'architettura complessa di microservizi o un'applicazione aziendale, è necessario sapere come la vostra applicazione si comporta sotto carico. Sarà gestire 100 utenti contemporanei? 1.000? Dove sono le strozzature? La vostra strategia di cacheing funziona davvero?
Questa guida completa mostra come caricare le applicazioni di test ASP.NET Core utilizzando k6 - uno dei più potenti strumenti di test del carico open-source disponibili. MinimalBlog come la nostra applicazione di esempio (un semplice blog basato su markdown con memoria e output caching), le tecniche e i modelli indicati qui si applicano a qualsiasi applicazione ASP.NET Core.
Entro la fine di questa serie in due parti, saprai come:
Perché MinimalBlog come esempio? Si tratta di una vera e propria applicazione ASP.NET Core 9.0 con modelli comuni: Razor Pages, memory caching, output caching, file I/O, e markdown processing. Gli approcci di test che imparerete si applicano allo stesso modo alle vostre applicazioni MVC, Web API, applicazioni Blazor, o API minime.
k6 è un moderno strumento di test del carico costruito per gli sviluppatori. A differenza di vecchi strumenti come JMeter o LoadRunner, k6 è:
Per MinimalBlog, k6 è ideale perché:
Opzione 1: utilizzo della cioccolata (raccomandata)
choco install k6
Opzione 2: Utilizzo di Winget
winget install k6 --source winget
Opzione 3: Installazione manuale
k6.exe filek6.exe a una directory già in PATHVerifica installazione:
k6 version
Opzione 1: utilizzo di homebrew (raccomandato)
brew install k6
Opzione 2: utilizzo di MacPorts
sudo port install k6
Opzione 3: Installazione manuale
# 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
Verifica installazione:
k6 version
Opzione 1: Uso dei gestori dei pacchetti
Per Debian/Ubuntu:
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
Per Fedora/CentOS/RHEL:
sudo dnf install https://dl.k6.io/rpm/repo.rpm
sudo dnf install k6
Opzione 2: Uso di Snap
sudo snap install k6
Opzione 3: Installazione manuale
# 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
Opzione 4: Uso di Docker
docker pull grafana/k6:latest
# Run a test
docker run --rm -i grafana/k6:latest run - <script.js
Verifica installazione:
k6 version
Prima di immergerci nel test, capiamo la struttura di base di un test k6:
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
}
Concetti chiave:
Prima di testare l'applicazione, cerchiamo di capire i cinque principali tipi di test di carico e quando utilizzare ciascuno:
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
Oggetto: Verificare che il sistema funzioni sotto carico minimo
Quando usare:
Caratteristiche:
Oggetto: Valutare le prestazioni sotto il carico normale previsto
Quando usare:
Caratteristiche:
Oggetto: Trova il punto di rottura del sistema
Quando usare:
Caratteristiche:
Oggetto: Comportamento di prova sotto picchi di traffico improvvisi
Quando usare:
Caratteristiche:
Oggetto: Trova perdite di memoria e degrado nel tempo
Quando usare:
Caratteristiche:
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
Con così tanti strumenti di test del carico disponibili, perché si dovrebbe scegliere k6? Confrontiamo k6 con le alternative popolari:
Apache JMeter è il veterano degli strumenti di prova del carico (dal 1999).
| Caratteristiche | k6 | JMeter |
|---|---|---|
| Installazione | Singola binaria, senza dipendenze | Richiede Java, installazione più pesante |
| Definizione della prova | codice JavaScript | XML o GUI |
| Uso delle risorse | Peso leggero (Go) | Pesante (Java) |
| Integrazione CI/CD | Eccellente (CLI-first) | Richiede plugin |
| Curve di apprendimento | Easy for developers | Steeper, GUI-focused |
| Supporto protocollo | HTTP, WebSockets, GRPC | Broader (FTP, JDBC, SMTP, ecc.) |
Quando usare JMeter invece:
Perché k6 è meglio per la maggior parte delle applicazioni ASP.NET Core:
LocustCity name (optional, probably does not need a translation) è uno strumento di prova del carico basato su Python, popolare nei negozi di Python.
| Caratteristica | k6 | Locusta |
|---|---|---|
| Lingua | JavaScript | Pitone |
| Prestazioni | Very fast (Go runtime) | Slow (Python GIL) |
| Facilità d'uso | JavaScript semplice | Pitonico, facile |
| Test distribuiti | K6 Cloud (paid) | Built-in (free) |
| UI web | Limited | Excellent real-time UI |
| Esportazione metrica | Molti formati | CSV, web UI |
Quando usare Locust invece:
Perché k6 è meglio per la maggior parte delle applicazioni ASP.NET Core:
GatlingCity name (optional, probably does not need a translation) è uno strumento basato sulla Scala con un eccellente reporting.
| Caratteristiche | k6 | Gatling |
|---|---|---|
| Lingua | JavaScript | Scala/Java |
| Relazioni | Basic (+ extensions) | Beautiful built-in HTML reports |
| Curve di apprendimento | Facile | Moderate (Scala DSL) |
| Prestazioni | Eccellente | Eccellente |
| Open Source | Completamente aperto | Aperto con add-on aziendali |
| Servizio cloud | K6 Cloud | Gatling Enterprise |
Quando usare Gatling invece:
Perché k6 è meglio per la maggior parte delle applicazioni ASP.NET Core:
Artiglieria è un altro strumento di test del carico JavaScript.
| Caratteristica | k6 | Artiglieria |
|---|---|---|
| Definizione della prova | codice JavaScript | YaML + ganci JS |
| Prestazioni | Più veloce (Go) | Più lento (Node.js) |
| Facilità d'uso | Code-based | YAML config-based |
| Costruito per | Prova di carico | Carico + prova funzionale |
| Asserzioni | Soglie eccellenti | Aspettative di base |
| Estendibilità | Estensioni | Plugin |
Quando usare invece l'artiglieria:
Perché k6 è meglio per la maggior parte delle applicazioni ASP.NET Core:
wrkCity name (optional, probably does not need a translation) è uno strumento di benchmarking HTTP leggero.
| Caratteristiche | k6 | Wrk |
|---|---|---|
| Facilità d'uso | API di alto livello | Basso livello C + Lua |
| Scenari | Supporto scenario ricco | Solo base HTTP |
| MetricsCity name (optional, probably does not need a translation) | Comprensive | Basic |
| Scripting | JavaScript | Lua |
| Usa caso | Prova a pieno carico | Parametri di riferimento rapidi |
Quando usare wrk invece:
Perché k6 è meglio per la maggior parte delle applicazioni ASP.NET Core:
PlaywrightCity name (optional, probably does not need a translation) e CypressCity name (optional, probably does not need a translation) sono strumenti di automazione del browser a volte utilizzati per i test di carico.
| Caratteristica | k6 | Playwright/Cypress |
|---|---|---|
| Approccio | HTTP a livello di protocollo | Browser reale |
| Prestazioni | Migliaia di VU | Decine di browser |
| Uso delle risorse | Peso leggero | Pesante (browser) |
| Esecuzione JavaScript | No | Sì |
| Caso di utilizzo primario | Prova di carico | Prova funzionale E2E |
Quando usare Playwright/Cypress invece:
Perché k6 è meglio per la maggior parte delle applicazioni ASP.NET Core:
Scegli k6 quando vuoi:
k6 è perfetto per:
Prendere in considerazione alternative se avete bisogno:
Ora che hai capito cos'è k6, come installarlo, i tipi di test di performance disponibili, e perché k6 è un'ottima scelta per le applicazioni ASP.NET Core, sei pronto per iniziare a scrivere test reali.
Continua a Parte 2: Attuazione pratica dove ci occuperemo di:
© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.