Esercizio - Aggiungere OpenTelemetry a un'applicazione nativa del cloud

7 minuti

In questo esercizio, si aggiunge un nuovo progetto di diagnostica alla soluzione eShopLite. Si vedrà come includere i pacchetti NuGet OpenTelemetry e poi come aggiungere l'osservabilità al servizio Prodotti.

Aprire l'ambiente di sviluppo e creare le risorse di Azure

Si può scegliere di fare l'esercizio in un codespace GitHub che lo ospita, oppure di completarlo in locale in Visual Studio Code.

Per usare un codespace, creare un codespace GitHub preconfigurato con questo modello Codespace.

Il passaggio di creazione e configurazione del codespace da parte di GitHub potrebbe durare qualche minuto. Al termine del processo, vengono visualizzati i file di codice per l'esercizio. Il codice usato per il resto di questo modulo si trova nella directory /dotnet-observability.

Per usare Visual Studio Code, clonare il repository https://github.com/MicrosoftDocs/mslearn-dotnet-cloudnative nel computer locale. Quindi:

Installare i requisiti di sistema per eseguire il contenitore di sviluppo in Visual Studio Code.
Verificare che Docker sia in esecuzione.
In una nuova finestra di Visual Studio Code aprire la cartella del repository clonato
Premere CTRL+MAIUSC+P per aprire il riquadro comandi.
Ricerca: >Contenitori di sviluppo: Rebuild and Reopen in Container(Ricompilare e riaprire nel contenitore)
Selezionare eShopLite - dotnet-observability dall'elenco a discesa. Visual Studio Code crea il contenitore di sviluppo in locale.

Aggiungere un progetto di diagnostica alla soluzione

Il primo passaggio per aggiungere l'osservabilità all'app eShopLite consiste nell'introdurre un nuovo progetto di diagnostica nella soluzione. Questo progetto contiene tutti i pacchetti e le configurazioni OpenTelemetry che verranno usati per aggiungere osservabilità all'app.

Nel riquadro comandi di Visual Studio Code, immettere >.NET: Aprire la soluzione.
Selezionare dotnet-observability/eShopLite/eShopLite.sln.
In Esplora soluzioni, nella parte inferiore del riquadro ESPLORA RISORSE, fare clic con il pulsante destro del mouse sulla soluzione eShopLite e quindi scegliere Nuovo progetto.
Nella finestra di dialogo Selezionare un modello per creare un nuovo progetto .NET selezionare Libreria di classi (comune, libreria).
Nel campo Nome, immettere Diagnostica.
Nell'elenco a discesa Il progetto verrà creato in selezionare Directory predefinita.

Aggiungere pacchetti OpenTelemetry

Aggiungere ora i pacchetti OpenTelemetry al nuovo progetto di diagnostica.

Usando il riquadro TERMINALE nella parte inferiore di Visual Studio Code, passare alla cartella del progetto Diagnostica:
```
cd dotnet-observability/eShopLite/Diagnostics
```

Eseguire i dotnet add comandi seguenti:

dotnet add package OpenTelemetry.Exporter.Console
dotnet add package OpenTelemetry.Extensions.Hosting
dotnet add package OpenTelemetry.Instrumentation.AspNetCore
dotnet add package OpenTelemetry.Instrumentation.EventCounters --prerelease
dotnet add package OpenTelemetry.Instrumentation.Runtime
dotnet add package OpenTelemetry.Instrumentation.SqlClient --prerelease
dotnet add package OpenTelemetry.Instrumentation.Http

Nel riquadro ESPLORA RISORSE, espandere la cartella Diagnostica e poi selezionare Diagnostics.csproj.
Modificare Project Sdk nella parte superiore in:
```
<Project Sdk="Microsoft.NET.Sdk.Web">
```
Il codice precedente consente di usare la classe IConfiguration nel codice.
In <PropertyGroup>, aggiungere il tipo di output:
```
<OutputType>Library</OutputType>
```
Il codice precedente garantisce che il progetto venga compilato come libreria. In caso contrario, il compilatore prevede un file Program.cs con un metodo main.

Aggiungere il codice per usare OpenTelemetry

Dopo aver aggiunto i pacchetti OpenTelemetry, è ora necessario introdurre il codice per usarli.

Nel riquadro ESPLORA RISORSE, fare clic con il pulsante destro del mouse sul file Class1.cs e quindi scegliere Rinomina.
Rinominare il file in DiagnosticServiceCollectionExtensions.cs.

Sostituire il codice nel file con il codice seguente:

using OpenTelemetry.Metrics;
using OpenTelemetry.Resources;
using OpenTelemetry.Trace;

namespace Microsoft.Extensions.DependencyInjection;

public static class DiagnosticServiceCollectionExtensions
{
  public static IServiceCollection AddObservability(this IServiceCollection services,
      string serviceName,
      IConfiguration configuration)
  {
    // create the resource that references the service name passed in
    var resource = ResourceBuilder.CreateDefault().AddService(serviceName: serviceName, serviceVersion: "1.0");

    // add the OpenTelemetry services
    var otelBuilder = services.AddOpenTelemetry();

    otelBuilder
        // add the metrics providers
        .WithMetrics(metrics =>
        {
          metrics
            .SetResourceBuilder(resource)
            .AddRuntimeInstrumentation()
            .AddAspNetCoreInstrumentation()
            .AddHttpClientInstrumentation()
            .AddEventCountersInstrumentation(c =>
            {
              c.AddEventSources(
                      "Microsoft.AspNetCore.Hosting",
                      "Microsoft-AspNetCore-Server-Kestrel",
                      "System.Net.Http",
                      "System.Net.Sockets");
            })
            .AddMeter("Microsoft.AspNetCore.Hosting", "Microsoft.AspNetCore.Server.Kestrel")
            .AddConsoleExporter();

        })
        // add the tracing providers
        .WithTracing(tracing =>
        {
          tracing.SetResourceBuilder(resource)
                      .AddAspNetCoreInstrumentation()
                      .AddHttpClientInstrumentation()
                      .AddSqlClientInstrumentation();
        });

    return services;
  }
}

Nel riquadro TERMINALE, eseguire questo comando per compilare il progetto:
```
dotnet build
```
L'output visualizzato sarà simile all'esempio seguente:
```
Build succeeded.
    0 Warning(s)
    0 Error(s)
```
Il progetto Diagnostica è ora pronto per essere usato dal servizio Prodotti.
Nel riquadro ESPLORA RISORSE, in ESPLORA SOLUZIONI, fare clic con il pulsante destro del mouse sul progetto Prodotti e quindi selezionare Aggiungi riferimento al progetto.
Selezionare Diagnostica.
Nel riquadro ESPLORA RISORSE, espandere la cartella Prodotti e quindi selezionare Program.cs.
Nel commento del codice // Add observability code here, aggiungere una chiamata al metodo di Diagnostica:
```
builder.Services.AddObservability("Products", builder.Configuration);
```
Nel riquadro TERMINALE, passare alla cartella Prodotti:
```
cd ../Products
```
Eseguire questo comando per compilare il progetto:
```
dotnet build
```
L'output visualizzato sarà simile all'esempio seguente:
```
Build succeeded.
    0 Warning(s)
    0 Error(s)
```

Aggiornare le impostazioni di Docker ed eseguire l'app

Nel riquadro TERMINALE, passare alla radice della cartella dotnet-observability:
```
cd ..
dotnet publish /p:PublishProfile=DefaultContainer
```
Eseguire questi comandi Docker:
```
cd /workspaces/mslearn-dotnet-cloudnative/dotnet-observability/
docker compose up 
```
I contenitori back-end (servizio Prodotti ) e front-end (servizio Store) devono essere compilati. Poi, viene avviata l'app.
Se si esegue questo esercizio in un codespace, selezionare la scheda PORTE, nella parte inferiore della finestra di Visual Studio Code. Selezionare il collegamento Apri nel browser accanto al servizio Front End.
Se si esegue questo esercizio in locale in Visual Studio Code, in una nuova scheda del browser, passare all'app in http://localhost:32000.
Nell'app, selezionare Prodotti nella barra di spostamento.
Selezionare Aggiorna magazzino per diversi prodotti. Poi, nella finestra di dialogo, modificare il valore di magazzino e selezionare Aggiorna.

Selezionare lascheda TERMINALE e scorrere i messaggi. Si noti che sono presenti messaggi da OpenTelemetry, ad esempio:

backend-1   | Export ec.Microsoft-AspNetCore-Server-Kestrel.connection-queue-length, Meter: OpenTelemetry.Instrumentation.EventCounters/1.5.1.1
backend-1   | (2023-11-09T19:55:14.8933518Z, 2023-11-09T20:04:44.8596671Z] http.request.method: PUT http.response.status_code: 200 http.route: /api/Stock/{id} network.protocol.name: http network.protocol.version: 1.1 url.scheme: http Histogram      
backend-1   | Value: Sum: 0.05144170000000001 Count: 4 Min: 0.0039736 Max: 0.0359739

Premi Ctrl+C per arrestare l'app.