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

7 minutos

Neste exercício, você adiciona um novo projeto de diagnóstico à sua solução eShopLite. 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 de 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: >Dev Containers: Reconstruir e Reabrir no Contentor.
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 aplicativo eShopLite é 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 Codespace, 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 em, verifique se o diretório do caminho do ficheiro é /workspaces/mslearn-dotnet-cloudnative/dotnet-observability/eShopLite/.

Adicionar pacotes OpenTelemetry

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

Usando o painel TERMINAL na parte inferior do Codespace, 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 o Project Sdk na parte superior para:
```
<Project Sdk="Microsoft.NET.Sdk.Web">
```
O código anterior permite que você use a classe IConfiguration 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 arquivo Program.cs com um método main.

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.
No comentário de código // Add observability code here, adicione uma chamada à função 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 contentores de back-end (serviço Produtos) e de front-end (serviço Loja) devem ser construídos. 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 estiver a fazer este exercício localmente no Visual Studio Code, num novo separador do navegador, vá para a aplicação 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.

Feedback

Esta página foi útil?