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.

Le metriche personalizzate con le dimensioni

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.AspNetCore

Nella 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:5380

In 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-traffic

Sostituisce 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 run
export API_URI=http://127.0.0.1:5380/classify
dotnet run -- broken

In PowerShell la prima riga è $env:API_URI = "http://127.0.0.1:5380/classify". Nella prova, dopo 5 minuti:

setosa: 81
versicolor: 80
virginica: 80
502: 241

Il 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.

La mappa con l'API e il modello

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.

Una richiesta dall'inizio alla fine

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.

Le chiamate al modello fallite

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.

Le previsioni per specie

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.