Exercício - Adicionar OpenTelemetry a um aplicativo nativo da nuvem

7 minutos

Neste exercício, você adiciona um novo projeto de diagnóstico à sua eShopLite solução. Você verá como incluir os pacotes OpenTelemetry NuGet 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 espaço de código GitHub que hospeda o exercício ou concluí-lo localmente no Visual Studio Code.

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

Esta etapa leva vários minutos enquanto o GitHub cria e configura o espaço de código. Depois que o processo for concluído, você verá os arquivos de código para o exercício. O código usado para o resto 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 para sua máquina local. Em seguida:

Instale quaisquer requisitos do sistema para executar o Dev Container no Visual Studio Code.
Verifique 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: reconstruir e reabrir no contêiner
Selecione eShopLite - dotnet-observability na lista suspensa. O Visual Studio Code cria seu contêiner de desenvolvimento localmente.

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

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

Na paleta de comandos Visual Studio Code, digite >.NET: Open Solution.
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 Selecione um modelo para criar um novo projeto .NET, selecione Biblioteca de Classes (Comum, Biblioteca).
No campo Nome, insira Diagnóstico.
No menu suspenso Projeto será criado, selecione Diretório padrão.

Adicionar pacotes 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 do projeto Diagnostics :
```
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 Diagnostics e selecione Diagnostics.csproj.
Altere a 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.
<PropertyGroup>No , 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, você agora introduz 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 com o 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 criar o projeto:
```
dotnet build
```
Você deve ver uma saída semelhante a este exemplo:
```
Build succeeded.
    0 Warning(s)
    0 Error(s)
```
O projeto Diagnostics está agora pronto para ser usado pelo serviço de Produtos.
No painel EXPLORER, em GERENCIADOR DE SOLUÇÕES, clique com o botão direito do mouse no projeto Produtos e selecione Adicionar Referência de Projeto.
Selecione Diagnóstico.
No painel EXPLORER, expanda a pasta Produtos e selecione Program.cs.
Sob o comentário // Add observability code herede código , adicione uma chamada ao método Diagnostics:
```
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ê deve ver uma saída semelhante a este exemplo:
```
Build succeeded.
    0 Warning(s)
    0 Error(s)
```

Atualize as configurações do Docker e execute 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 back-end (serviço de produtos ) e front-end (serviço de loja ) devem ser criados. Em seguida, o aplicativo é iniciado.
Se você estiver fazendo esse exercício em um espaço de código, selecione a guia PORTS na parte inferior da janela Código do Visual Studio. Selecione o link Abrir no navegador ao lado do serviço Front-End .
Se você estiver fazendo esse exercício localmente no Visual Studio Code, em uma nova guia do navegador, vá para 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 o separador 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 parar o aplicativo.

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