Exercício – Adicionar OpenTelemetry a um aplicativo nativo de nuvem

7 minutos

Neste exercício, você adicionará um novo projeto de diagnóstico à sua eShopLite solução. Você verá como incluir os pacotes NuGet do OpenTelemetry e, em seguida, adicionar observabilidade ao serviço Produtos .

Abra o ambiente de desenvolvimento e crie os recursos do Azure

Você pode optar por usar um codespace do GitHub que hospeda o exercício ou concluir o exercício localmente no Visual Studio Code.

Para usar um codespace, crie um codespace do GitHub pré-configurado com esse modelo de criação de codespace.

Essa etapa leva vários minutos enquanto o GitHub cria e configura o codespace. Depois que o processo for concluído, você verá os arquivos de código do exercício. O código usado para o restante deste módulo está no diretório /dotnet-observability .

Para usar o Visual Studio Code, clone o https://github.com/MicrosoftDocs/mslearn-dotnet-cloudnative repositório em seu computador local. Em seguida:

Instale todos os requisitos do sistema para executar o Contêiner de Desenvolvimento no Visual Studio Code.
Confira se o Docker está em execução.
Em uma nova janela do Visual Studio Code, abra a pasta do repositório clonado
Pressione Ctrl+Shift+P para abrir a paleta de comandos.
Pesquisa: >Contêineres de Desenvolvimento: Recompilar e Reabrir no Contêiner
Escolha eShopLite - dotnet-observability na lista de seleção. O Visual Studio Code cria seu contêiner de desenvolvimento localmente.

Adicionar um projeto de diagnóstico à solução

A primeira etapa para adicionar a observabilidade ao eShopLite aplicativo é introduzir um novo projeto de diagnóstico à solução. Este projeto contém todos os pacotes OpenTelemetry e configurações que você usará para adicionar observabilidade ao aplicativo.

Na paleta de comandos do Visual Studio Code, insira >.NET: Abrir solução.
Selecione dotnet-observability/eShopLite/eShopLite.sln.
No Gerenciador de Soluções, na parte inferior do painel EXPLORER , clique com o botão direito do mouse na solução eShopLite e selecione Novo Projeto.
Na caixa de diálogo Selecionar um modelo para criar um novo projeto do .NET , selecione Biblioteca de Classes (Comum, Biblioteca).
No campo Nome , insira Diagnóstico.
No menu suspenso O projeto será criado em, selecione o Diretório padrão.

Adicionar pacotes do OpenTelemetry

Agora, adicione os pacotes OpenTelemetry ao novo projeto de diagnóstico.

Usando o painel TERMINAL na parte inferior do Visual Studio Code, vá para a pasta de projeto diagnóstico :
```
cd dotnet-observability/eShopLite/Diagnostics
```

Execute estes dotnet add comandos:

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

No painel EXPLORER , expanda a pasta Diagnóstico e selecione Diagnostics.csproj.
Altere o Project Sdk na parte superior para:
```
<Project Sdk="Microsoft.NET.Sdk.Web">
```
O código anterior permite que você use a IConfiguration classe em seu código.
No <PropertyGroup>, adicione o tipo de saída:
```
<OutputType>Library</OutputType>
```
O código anterior garante que o projeto seja compilado como uma biblioteca. Caso contrário, o compilador espera um Program.cs arquivo com um main método.

Adicionar o código para usar OpenTelemetry

Com os pacotes OpenTelemetry adicionados, agora você apresenta o código para usá-los.

No painel EXPLORER , clique com o botão direito do mouse no arquivo Class1.cs e selecione Renomear.
Renomeie o arquivo para DiagnosticServiceCollectionExtensions.cs.

Substitua o código no arquivo pelo seguinte código:

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

No painel TERMINAL , execute este comando para compilar o projeto:
```
dotnet build
```
Você deverá ver uma saída semelhante a este exemplo:
```
Build succeeded.
    0 Warning(s)
    0 Error(s)
```
O projeto diagnóstico agora está pronto para ser usado pelo serviço Produtos .
No painel EXPLORER , em GERENCIADOR de SOLUÇÕES, clique com o botão direito do mouse no projeto Produtos e, em seguida, selecione Adicionar Referência do Projeto.
Selecione Diagnóstico.
No painel EXPLORER , expanda a pasta Produtos e selecione Program.cs.
Sob o comentário do código // Add observability code here, adicione uma chamada ao método Diagnóstico:
```
builder.Services.AddObservability("Products", builder.Configuration);
```
No painel TERMINAL , vá para a pasta Produtos :
```
cd ../Products
```
Execute este comando para criar o projeto:
```
dotnet build
```
Você deverá ver uma saída semelhante a este exemplo:
```
Build succeeded.
    0 Warning(s)
    0 Error(s)
```

Atualizar as configurações do Docker e executar o aplicativo

No painel TERMINAL, vá para a raiz da pasta dotnet-observability:
```
cd ..
dotnet publish /p:PublishProfile=DefaultContainer
```
Execute estes comandos do Docker:
```
cd /workspaces/mslearn-dotnet-cloudnative/dotnet-observability/
docker compose up 
```
Os contêineres de back-end (serviço Produtos) e front-end (serviço Loja) devem ser criados e, em seguida, o aplicativo será compilado. Em seguida, o aplicativo é iniciado.
Se você estiver fazendo este exercício em um codespace, selecione a guia PORTAS na parte inferior da janela do Visual Studio Code. Selecione o link Abrir no navegador ao lado do serviço Front-End .
Se você estiver fazendo este exercício localmente no Visual Studio Code, em uma nova aba do navegador, acesse o aplicativo em http://localhost:32000.
No aplicativo, selecione Produtos na barra de navegação.
Selecione Atualizar Estoque para vários dos produtos. Em seguida, na caixa de diálogo, altere o valor da ação e selecione Atualizar.

Selecione a guia TERMINAL e percorra as mensagens. Observe que há mensagens do OpenTelemetry como:

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

Pressione Ctrl+C para interromper o aplicativo.

Você adicionou o OpenTelemetry com êxito ao serviço Produtos . Na próxima unidade, você verá como fazer melhor uso dos dados de telemetria exibindo-os em ferramentas como Prometheus e Grafana.