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

7 minutos

Neste exercício, você adicionará um novo projeto de diagnóstico à sua solução eShopLite. 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 concluí-lo localmente no Visual Studio Code.

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

Esta etapa levará alguns minutos enquanto o GitHub cria e configura o codespace. Após o processo ser 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 repositório https://github.com/MicrosoftDocs/mslearn-dotnet-cloudnative em seu computador local. Em seguida:

Instale todos os requisitos do sistema necessários 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 que foi 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 observabilidade ao aplicativo eShopLite é introduzir um novo projeto de diagnóstico na solução. Esse projeto contém todos os pacotes e configurações do OpenTelemetry 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.snl.
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 projeto .NET, selecione Biblioteca de Classes (Comum, Biblioteca).
No campo Nome, digite Diagnóstico.
No menu suspenso O projeto será criado em, selecione o Diretório padrão.

Adicionar pacotes do OpenTelemetry

Agora você adicionará os pacotes do OpenTelemetry ao novo projeto de diagnóstico.

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

Execute estes comandos dotnet add:

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 acima permite que você use a classe IConfiguration em seu código.
Em <PropertyGroup>, adicione o tipo de saída:
```
<OutputType>Library</OutputType>
```
O código acima garante que o projeto seja compilado como uma biblioteca. Caso contrário, o compilador esperará um arquivo Program.cs com um método main.

Adicione o código para usar o OpenTelemetry

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

No painel EXPLORER, clique com o botão direito do mouse no arquivo Class1.cs e selecione Renomear.
Renomeie o arquivo para DiagnósticoerviceCollectionExtensions.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 criar 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 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, acesse a pasta Produtos:
```
cd ../Products
```
Execute esse 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 execute o aplicativo

No painel TERMINAL, acesse 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. Depois, o aplicativo é iniciado.
Se estiver fazendo este exercício em um espaço de código, 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 estiver fazendo esse exercício localmente no Visual Studio Code, em uma nova guia 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 do estoque 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.