Procedura per vedere ogni chiamata a un modello pubblicato: quanto dura, quante falliscono e cosa prevede. Un'API ASP.NET Core chiama il modello e, con OpenTelemetry, manda ad Application Insights le richieste, le chiamate al modello e un contatore delle previsioni per specie. Una console .NET imita due client: uno corretto e uno che dimentica una delle quattro misure del fiore.
Occorre: l'area di lavoro mlw-guide-extranet-01 con il modello iris-model registrato nella versione 2, cioè i passi da 1 a 8 della guida Addestrare una rete neurale su Azure Machine Learning e chiamarla da .NET, e .NET 11 sul computer.
Durata: circa un'ora, metà di attesa per la pubblicazione del modello.
Costo: meno di un dollaro, se elimini le risorse alla fine. Il listino di Azure indica 0,115 dollari l'ora per la macchina dell'endpoint e, per i dati di Log Analytics, 0 dollari fino a 5 GB e 2,99 dollari al GB oltre; in tutta la prova i dati sono stati meno di 1 MB.
Il portale delle schermate è in inglese: i nomi dei comandi sono riportati come appaiono a schermo.
Il modello e Application Insights
1. Pubblica il modello
Nello studio apri Models > iris-model, versione 2, premi Use this model > Real-time endpoint e compila:
- Instance count:
1 - Virtual machine:
Standard_D2as_v4, quella proposta - Endpoint: New
- Endpoint name: un nome tuo, unico nella regione, qui
iris-otel-extranet-01 - Deployment name:
blue
Premi Deploy. In Endpoints > iris-otel-extranet-01, scheda Consume, copia REST endpoint e Primary key. La chiave dà accesso al modello: non scriverla nel codice e non pubblicarla.
2. Attiva le dimensioni delle metriche
Sul portale di Azure apri l'Application Insights creato con l'area di lavoro di Azure Machine Learning, nel gruppo rg-guide-ml-01: il nome inizia con mlwguideinsights. Nel menu premi Configure > Usage and estimated costs > Custom metrics (Preview), scegli With dimensions e premi OK.

Senza questo passo il contatore delle previsioni arriva in Metrics senza la specie e Apply splitting resta disattivato. Nella prova l'impostazione è valsa solo per i dati arrivati dopo.
3. Copia la stringa di connessione
Nel menu premi Overview e copia Connection string. L'API la usa per mandare i dati a questo Application Insights.
L'API
4. Crea l'API
dotnet new web -n iris-api
cd iris-api
dotnet add package Azure.Monitor.OpenTelemetry.AspNetCoreNella prova il pacchetto era alla versione 1.6.0. Sostituisce Program.cs:
using System.Diagnostics;
using System.Diagnostics.Metrics;
using System.Net.Http.Headers;
using Azure.Monitor.OpenTelemetry.AspNetCore;
using OpenTelemetry.Metrics;
using OpenTelemetry.Resources;
string scoringUri = Environment.GetEnvironmentVariable("SCORING_URI")!;
string key = Environment.GetEnvironmentVariable("ENDPOINT_KEY")!;
string[] species = ["setosa", "versicolor", "virginica"];
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddOpenTelemetry()
.ConfigureResource(resource => resource.AddService("iris-api"))
.UseAzureMonitor()
.WithMetrics(metrics => metrics.AddMeter("Iris"));
var app = builder.Build();
HttpClient model = new();
model.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", key);
Meter meter = new("Iris");
Counter<long> predictions = meter.CreateCounter<long>("iris.predictions");
app.MapPost("/classify", async (Dictionary<string, double> flower) =>
{
var body = new { input_data = new { columns = flower.Keys, index = new[] { 0 }, data = new[] { flower.Values } } };
using HttpResponseMessage response = await model.PostAsJsonAsync(scoringUri, body);
if (!response.IsSuccessStatusCode)
{
return Results.StatusCode(502);
}
var probabilities = await response.Content.ReadFromJsonAsync<Dictionary<string, double>[]>();
string name = species[int.Parse(probabilities![0].MaxBy(p => p.Value).Key)];
Activity.Current?.SetTag("iris.species", name);
predictions.Add(1, new KeyValuePair<string, object?>("species", name));
return Results.Ok(new { species = name });
});
app.Run();UseAzureMonitor manda ad Application Insights le richieste che arrivano all'API, le chiamate che l'API fa al modello e le metriche; AddService dà il nome iris-api che compare nella mappa. Per ogni previsione l'API scrive la specie nella richiesta, come iris.species, e aggiunge 1 al contatore iris.predictions, con la dimensione species. Se il modello risponde con un errore, l'API risponde 502.
5. Avvia l'API
Imposta le tre variabili con i valori copiati ai passi 1 e 3 e avvia:
export SCORING_URI=https://iris-otel-extranet-01.westeurope.inference.ml.azure.com/score
export ENDPOINT_KEY=<chiave>
export APPLICATIONINSIGHTS_CONNECTION_STRING="<stringa di connessione>"
dotnet run --urls http://127.0.0.1:5380In PowerShell le righe con export diventano $env:SCORING_URI = "...", $env:ENDPOINT_KEY = "..." e $env:APPLICATIONINSIGHTS_CONNECTION_STRING = "...". L'API resta in ascolto su http://127.0.0.1:5380.
Il traffico
6. Crea la console
In un altro terminale:
dotnet new console -n iris-traffic
cd iris-trafficSostituisce Program.cs. Per 5 minuti manda all'API una richiesta al secondo, alternando una setosa, una versicolor e una virginica, e alla fine conta le risposte. Con l'argomento broken imita un client con un difetto: toglie petal_width.
using System.Net.Http.Json;
string apiUri = Environment.GetEnvironmentVariable("API_URI")!;
bool broken = args.Length > 0 && args[0] == "broken";
// a setosa, a versicolor and a virginica
double[][] flowers = [[5.1, 3.5, 1.4, 0.2], [6.0, 2.9, 4.5, 1.5], [6.9, 3.1, 5.4, 2.1]];
using HttpClient http = new();
Dictionary<string, int> count = [];
DateTime end = DateTime.UtcNow.AddMinutes(5);
for (int i = 0; DateTime.UtcNow < end; i++)
{
double[] f = flowers[i % flowers.Length];
Dictionary<string, double> flower = new()
{
["sepal_length"] = f[0],
["sepal_width"] = f[1],
["petal_length"] = f[2],
["petal_width"] = f[3],
};
// a broken client forgets one of the four measures
if (broken)
{
flower.Remove("petal_width");
}
using HttpResponseMessage response = await http.PostAsJsonAsync(apiUri, flower);
string result = response.IsSuccessStatusCode
? (await response.Content.ReadFromJsonAsync<Dictionary<string, string>>())!["species"]
: ((int)response.StatusCode).ToString();
count[result] = count.GetValueOrDefault(result) + 1;
await Task.Delay(1000);
}
foreach (string result in count.Keys.Order())
{
Console.WriteLine($"{result}: {count[result]}");
}7. Manda richieste corrette e difettose
Avvia due console, in due terminali:
export API_URI=http://127.0.0.1:5380/classify
dotnet runexport API_URI=http://127.0.0.1:5380/classify
dotnet run -- brokenIn PowerShell la prima riga è $env:API_URI = "http://127.0.0.1:5380/classify". Nella prova, dopo 5 minuti:
setosa: 81
versicolor: 80
virginica: 80502: 241Il client corretto riceve sempre una specie; quello difettoso sempre 502.
Le chiamate in Application Insights
8. Guarda la mappa
In Application Insights premi Investigate > Application map. In alto premi Last hour, scegli Last 30 minutes e premi Apply; poi metti Exclude 4xx su Off.

Nella prova la mappa mostrava iris-api con 482 chiamate, metà fallite, e la sua chiamata all'endpoint del modello: 482 chiamate, 235,1 millisecondi in media, metà fallite. Con Exclude 4xx su On, il valore proposto, le risposte 424 del modello non contano come errori e la freccia resta grigia.
9. Segui una richiesta
Premi Investigate > Performance. In alto premi Local Time: Last 24 hours, scegli Last 30 minutes e premi Apply. In basso a destra premi Drill into > 482 Samples e, nell'elenco che si apre, scegli una richiesta con Response code: 200.

Il riquadro mostra la richiesta all'API e, sotto, la chiamata al modello fatta durante la richiesta. Nella prova la richiesta è durata 218,1 millisecondi; in Custom Properties compare iris.species con la specie prevista, versicolor.
10. Trova gli errori
Premi Investigate > Failures, scegli Last 30 minutes come al passo 9 e apri la scheda Dependencies.

Nella prova 241 chiamate al modello su 482 erano fallite, tutte con codice 424: sono le richieste del client difettoso. Nella scheda Operations le stesse 241 richieste all'API compaiono con codice 502.
11. Conta le previsioni per specie
Premi Monitoring > Metrics e compila:
- Metric Namespace:
azure.applicationinsights, sotto CUSTOM - Metric:
iris.predictions - Aggregation: Sum
Premi Apply splitting e in Values spunta species. In alto premi Local Time: Last 24 hours (Automatic), scegli Last 30 minutes e premi Apply; poi, al posto di Line chart, scegli Bar chart.

Nella prova: 81 setosa, 80 versicolor e 80 virginica, come le risposte del client corretto al passo 7.
Eliminare le risorse
12. Elimina il gruppo
Ferma l'API con Ctrl+C. Elimina il gruppo rg-guide-ml-01 come al passo 13 della guida di partenza. Con il gruppo sparisce anche Application Insights.
13. Elimina in modo definitivo l'area di lavoro
Sul portale cerca Azure Machine Learning, premi Recently deleted, scegli la sottoscrizione e, in Location, West Europe. Spunta mlw-guide-extranet-01 e premi Permanently delete, come al passo 14 della guida di partenza. Senza questo passo, per 14 giorni non puoi creare un'area di lavoro con lo stesso nome.
Nomi dei comandi, schermate e risposte rilevati il 18 novembre 2026, regione West Europe, con .NET 11.