Exercício – Usar dados OpenTelemetry em um aplicativo nativo de nuvem

  • 15 minutos

Neste exercício, você obterá melhor visibilidade de todos os dados gerados pelo OpenTelemetry em seu aplicativo. Você concluiu a adição da funcionalidade de diagnóstico ao serviço de loja. Com isso, você adiciona Prometheus e Grafana aos eShopLite serviços e analisa algumas das métricas capturadas. A próxima etapa é adicionar o Zipkin e visualizar os rastreamentos distribuídos. Por fim, adicione o Application Insights ao seu aplicativo e use-o para exibir os dados.

Adicionar Prometheus e Grafana

O Prometheus e o Grafana fornecem imagens do Docker que facilitam adicioná-las aos seus projetos. Você os inclui no arquivo docker-compose.yml , na raiz da solução.

  1. No painel EXPLORER , selecione o arquivo docker-compose.yml .

  2. Adicione este YAML à parte inferior do arquivo:

      prometheus:
    image: prom/prometheus
    container_name: prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
    ports:
      - 9090:9090
    restart: unless-stopped
    volumes:
      - ./prometheus:/etc/prometheus

  grafana:
    image: grafana/grafana
    container_name: grafana
    ports:
      - 3000:3000
    restart: unless-stopped
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=grafana
    volumes:
      - ./grafana/datasource:/etc/grafana/provisioning/datasources

O yaml do Docker anterior adiciona dois novos serviços, Prometheus e Grafana. A seção Prometheus configura um contêiner para responder na porta 9090. Ele mapeia a pasta prometheus esperando um arquivo prometheus.yml . A seção Grafana configura um contêiner para responder na porta 3000. Ele mapeia três pastas dentro de uma pasta grafana .

Configurar Prometheus

O Prometheus precisa ser configurado para saber onde coletar as métricas. Adicione um arquivo prometheus.yml à pasta prometheus .

  1. No painel EXPLORER , clique com o botão direito do mouse na pasta dotnet-observability e selecione Nova Pasta.

  2. No campo nome, insira prometheus.

  3. No painel EXPLORER , clique com o botão direito do mouse na pasta prometheus e selecione Novo Arquivo.

  4. No campo nome, insira prometheus.yml.

  5. No editor de arquivos, insira este YAML:

    global:
  scrape_interval: 1s

scrape_configs:
  - job_name: 'products'
    static_configs:
      - targets: ['backend:8080']
  - job_name: 'store'
    static_configs:
      - targets: ['frontend:8080']

    O YAML anterior configura o Prometheus para coletar as métricas dos serviços back-end e front-end. Como o aplicativo está em execução no Docker, os nomes de host são os nomes de serviço.

  6. Selecione Ctrl+S para salvar o arquivo.

Configurar Grafana

O Grafana precisa ser configurado para saber onde coletar as métricas.

  1. No painel EXPLORER , clique com o botão direito do mouse na pasta dotnet-observability e selecione Nova Pasta.

  2. No campo nome, insira grafana.

  3. Clique com o botão direito do mouse na pasta grafana e selecione Nova Pasta.

  4. No campo nome, insira a fonte de dados.

  5. Clique com o botão direito do mouse na pasta grafana e selecione Nova Pasta.

  6. No campo nome, insira o dashboard.

  7. Expanda a pasta grafana , clique com o botão direito do mouse na pasta de fonte de dados e selecione Novo Arquivo.

  8. No campo nome, insira datasource.yml.

  9. Na guia Editor, insira este YAML:

    apiVersion: 1

datasources:
- name: Prometheus
  type: prometheus
  url: http://prometheus:9090 
  isDefault: true
  access: proxy
  editable: true

    O YAML anterior configura o Grafana para usar o Prometheus como a fonte de dados.

  10. Selecione Ctrl+S para salvar o arquivo.

Atualizar seu aplicativo ASP.NET Core para expor as métricas do Prometheus

Agora, o projeto de diagnóstico só está configurado para expor métricas ao console. Em vez disso, você atualiza o projeto para expor métricas ao Prometheus.

  1. No painel TERMINAL na parte inferior da tela, vá para a pasta Diagnósticos.

  2. Execute este comando:

    cd .\eShopLite\Diagnostics\

  3. Remova o OpenTelemetry.Exporter.Console pacote:

    dotnet remove package OpenTelemetry.Exporter.Console

  4. Adicione o pacote OpenTelemetry.Exporter.Prometheus.AspNetCore:

    dotnet add package OpenTelemetry.Exporter.Prometheus.AspNetCore --prerelease

  5. No painel EXPLORER , expanda a pasta Diagnóstico e selecione DiagnosticServiceCollectionExtensions.cs.

  6. Substitua o exportador .AddConsoleExporter(); de console por este código:

    .AddPrometheusExporter();

  7. Na parte inferior do arquivo, antes do último }, adicione este código:

    public static void MapObservability(this IEndpointRouteBuilder routes)
{
  routes.MapPrometheusScrapingEndpoint();
}

    Este código adiciona um endpoint de Prometheus para coleta de dados a todos os serviços que o integram ao seu aplicativo. Isso permite que o Prometheus colete métricas de http://service/metrics.

  8. Selecione Ctrl+S para salvar o arquivo.

Expor as métricas no serviço Store

No momento, o aplicativo está configurado apenas para expor métricas para o serviço Produtos . Você atualiza o aplicativo para expor também as métricas do serviço Loja.

  1. No painel EXPLORER , em GERENCIADOR de SOLUÇÕES, clique com o botão direito do mouse no projeto da Loja e, em seguida, selecione Adicionar Referência do Projeto.

  2. Selecione Diagnóstico.

  3. No painel EXPLORER , expanda a pasta Store e selecione Program.cs.

  4. Sob o comentário do código // Add observability code here, adicione uma chamada ao método Diagnóstico:

    builder.Services.AddObservability("Store", builder.Configuration);

  5. Antes do app.Run() método, adicione este código:

    app.MapObservability();

    Este método adiciona o ponto de extremidade de extração do Prometheus ao serviço Store.

  6. Selecione Ctrl+S para salvar o arquivo.

  7. No painel EXPLORER , expanda a pasta Produto e selecione Program.cs.

  8. Antes do app.Run() método, adicione este código:

    app.MapObservability();

    Este método adiciona o ponto de extremidade de extração do Prometheus ao serviço Products.

  9. Selecione Ctrl+S para salvar o arquivo.

Testar os novos recursos de observabilidade

Agora você testa os novos recursos de observabilidade adicionados ao aplicativo.

  1. No painel TERMINAL na parte inferior, acesse a pasta dotnet-observability/eShopLite.

    cd ..

  2. Atualize os contêineres de aplicativos.

    dotnet publish /p:PublishProfile=DefaultContainer

  3. Vá para a pasta dotnet-observability e inicie o aplicativo com o Docker:

    cd ..
docker compose up

  4. Na guia PORTAS , selecione Abrir no Navegador para Prometheus (9090). Se você estiver executando localmente no Visual Studio Code, abra um navegador e, em uma nova guia, vá para o aplicativo Prometheus http://localhost:9090.

  5. No menu superior, selecione Status e selecione Destinos.

    Captura de tela que mostra o aplicativo Prometheus configurado mostrando a integridade do aplicativo eShopLite.

    Você verá os serviços Products e Store listados como UP.

  6. Na guia PORTAS , selecione Abrir no Navegador para Grafana (3000). Se estiver executando localmente no Visual Studio Code, abra um navegador e, em uma nova guia, abra o aplicativo http://localhost:3000Grafana.

  7. Insira o nome de usuário admin.

  8. Insira a senha grafana.

  9. Selecione Criar seu primeiro painel.

  10. Selecione Importar painel.

  11. Na guia nova, acesse o GitHub e abra o arquivo JSON do painel do ASP.NET Core.

  12. Copie o arquivo Raw.

  13. Cole o JSON na caixa de texto Importar por meio do modelo JSON do painel.

  14. Selecione Carregar.

  15. No menu suspenso Fonte de dados do Prometheus, selecione Prometheus.

  16. Selecione Importar.

    Captura de tela que mostra um painel ASP.NET no Grafana.

    Você deve ver um painel mostrando métricas para os serviços de Produtos e Lojas . Selecione Trabalho para alternar entre os dois serviços.

  17. No painel TERMINAL , selecione Ctrl+C para interromper o aplicativo.

Adicionar Zipkin

Agora você estende os recursos de rastreamento do aplicativo adicionando o Zipkin. Como você fez antes, adicione um contêiner zipkin ao seu aplicativo e configure-o para se conectar ao coletor OpenTelemetry. Em seguida, adicione o exportador OpenTelemetry Zipkin ao seu aplicativo.

  1. No painel EXPLORER , selecione o arquivo docker-compose.yml dentro da pasta dotnet-observability .

  2. Adicione prometheus e zipkin no depends_on para o frontend.

    depends_on: 
  - backend
  - prometheus
  - zipkin

  3. Adicione prometheus em depends_on para o backend.

     depends_on: 
   - prometheus

  4. Adicione variáveis ambientais para Zipkin a BOTHfrontend e backend:

    environment: 
  - ZIPKIN_URL=http://zipkin:9411

    Os dois serviços devem ter esta aparência:

    frontend:
  image: storeimage
  build:
    context: .
    dockerfile: ./eShopLite/Store/Dockerfile
  environment: 
    - ProductEndpoint=http://backend:8080
    - ZIPKIN_URL=http://zipkin:9411
  ports:
    - "32000:8080"
  depends_on: 
    - backend
    - prometheus
    - zipkin

backend:
  image: productservice
  build: 
    context: .
    dockerfile: ./eShopLite/Products/Dockerfile
  environment: 
    - ZIPKIN_URL=http://zipkin:9411

  ports: 
    - "32001:8080"
  depends_on: 
    - prometheus

  5. Adicione este YAML à parte inferior do arquivo:

      zipkin:
    image: openzipkin/zipkin
    ports:
      - 9411:9411

    O YAML anterior adiciona um contêiner Zipkin ao aplicativo. Ele configura o contêiner zipkin para responder na porta 9411.

  6. Selecione Ctrl+S para salvar o arquivo.

  7. No painel TERMINAL , vá para a pasta Diagnóstico .

    cd ./eShopLite/Diagnostics/

  8. Adicione os pacotes de exportação Zipkin.

    dotnet add package OpenTelemetry.Exporter.Zipkin --prerelease

  9. No painel EXPLORER , expanda a pasta Diagnóstico e selecione DiagnosticServiceCollectionExtensions.cs.

  10. Na parte inferior dos provedores de rastreamento, adicione Zipkin:

    // add the tracing providers
.WithTracing(tracing =>
{
  tracing.SetResourceBuilder(resource)
              .AddAspNetCoreInstrumentation()
              .AddHttpClientInstrumentation()
              .AddSqlClientInstrumentation()
              .AddZipkinExporter(zipkin =>
              {
                var zipkinUrl = configuration["ZIPKIN_URL"] ?? "http://zipkin:9411";
                zipkin.Endpoint = new Uri($"{zipkinUrl}/api/v2/spans");
              });
});

  11. Selecione Ctrl+S para salvar o arquivo.

  12. No painel TERMINAL na parte inferior, acesse a pasta dotnet-observability/eShopLite.

    cd ..

  13. Atualize os contêineres de aplicativos.

    dotnet publish /p:PublishProfile=DefaultContainer

  14. Vá para a pasta dotnet-observability e inicie o aplicativo com o Docker:

    cd ..
docker compose up

  15. Na guia PORTAS , selecione Abrir no Navegador para Prometheus (9090). Se você estiver executando localmente no Visual Studio Code, abra uma nova guia do navegador e vá para o aplicativo Zipkin http://localhost:9411.

  16. No menu, selecione Dependências.

    Captura de tela que mostra o Zipkin apresentando as dependências Store do aplicativo eShopLite enviando solicitações para o serviço Products.

  17. No painel TERMINAL , selecione Ctrl+C para interromper o aplicativo.

Adicionar Application Insights

A última etapa é adicionar o Application Insights ao seu aplicativo.

Criar o recurso do Application Insights no Azure

  1. No painel TERMINAL, faça login no Azure.

    az login --use-device-code

  2. Exiba sua assinatura do Azure selecionada.

    az account show -o table

    Se a assinatura errada estiver selecionada, selecione a correta usando o comando az account set .

  3. Adicione a extensão para o Application Insights.

    az extension add -n application-insights

  4. Criar um recurso do Application Insights.

    az monitor app-insights component create --app eShopLiteInsights --location eastus --kind web -g eShopLite

    Você deverá ver este resultado:

    {
  "appId": "00001111-aaaa-2222-bbbb-3333cccc4444",
  "applicationId": "eShopLiteInsights",
  "applicationType": "web",
  "connectionString": "InstrumentationKey=00000000-0000-0000-0000-000000000000;IngestionEndpoint=https://eastus-2.in.applicationinsights.azure.com/;LiveEndpoint=https://eastus.livediagnostics.monitor.azure.com/",
  "creationDate": "2023-11-10T16:50:00.950726+00:00",
  "disableIpMasking": null,
  "etag": "\"3a02952a-0000-0100-0000-654e5f380000\"",
  "flowType": "Bluefield",
  "hockeyAppId": null,
  "hockeyAppToken": null,
  "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/eShopLite/providers/microsoft.insights/components/eShopLiteInsights",
  "immediatePurgeDataOn30Days": null,
  "ingestionMode": "ApplicationInsights",
  "instrumentationKey": "00000000-0000-0000-0000-000000000000",
  "kind": "web",
  "location": "eastus",
  "name": "eShopLiteInsights",
  "privateLinkScopedResources": null,
  "provisioningState": "Succeeded",
  "publicNetworkAccessForIngestion": "Enabled",
  "publicNetworkAccessForQuery": "Enabled",
  "requestSource": "rest",
  "resourceGroup": "eShopLite",
  "retentionInDays": 90,
  "samplingPercentage": null,
  "tags": {},
  "tenantId": "aaaabbbb-0000-cccc-1111-dddd2222eeee",
  "type": "microsoft.insights/components"
}

    Do JSON retornado anteriormente, copie o connectionString, excluindo o ". Por exemplo:

    InstrumentationKey=b851fa75-85a2-42f7-bb6f-413725d9d8ba;IngestionEndpoint=https://eastus-2.in.applicationinsights.azure.com/;LiveEndpoint=https://eastus.livediagnostics.monitor.azure.com/

  5. No painel EXPLORER , selecione o arquivo docker-compose.yml .

  6. Adicione uma variável de ambiente que o projeto de diagnóstico usa para se conectar ao Application Insights. Adicione este YAML ao serviço store :

    environment:
  - APPLICATIONINSIGHTS_CONNECTION_STRING=InstrumentationKey=b851fa75-85a2-42f7-bb6f-413725d9d8ba;IngestionEndpoint=https://eastus-2.in.applicationinsights.azure.com/;LiveEndpoint=https://eastus.livediagnostics.monitor.azure.com/

    Substitua a cadeia de conexão anterior pela que você copiou da CLI do Azure.

  7. Repita estas etapas para o serviço Produtos . O YAML final deve ter esta aparência:

      frontend:
    image: storeimage
    build:
      context: .
      dockerfile: ./eShopLite/Store/Dockerfile
    environment: 
      - ProductEndpoint=http://backend:8080
      - ZIPKIN_URL=http://zipkin:9411
      - APPLICATIONINSIGHTS_CONNECTION_STRING=InstrumentationKey=b851fa75-85a2-42f7-bb6f-413725d9d8ba;IngestionEndpoint=https://eastus-2.in.applicationinsights.azure.com/;LiveEndpoint=https://eastus.livediagnostics.monitor.azure.com/
    ports:
      - "32000:8080"
    depends_on: 
      - backend
      - prometheus
      - zipkin

  backend:
    image: productservice
    build: 
      context: .
      dockerfile: ./eShopLite/Products/Dockerfile
    environment: 
      - ZIPKIN_URL=http://zipkin:9411
      - APPLICATIONINSIGHTS_CONNECTION_STRING=InstrumentationKey=b851fa75-85a2-42f7-bb6f-413725d9d8ba;IngestionEndpoint=https://eastus-2.in.applicationinsights.azure.com/;LiveEndpoint=https://eastus.livediagnostics.monitor.azure.com/

  8. Selecione Ctrl+S para salvar o arquivo.

  9. No painel TERMINAL , vá para a pasta Diagnóstico .

    cd .\eShopLite\Diagnostics\

  10. Adicione o pacote exportador do Application Insights.

    dotnet add package Azure.Monitor.OpenTelemetry.AspNetCore --prerelease

  11. No painel EXPLORE , selecione a pasta Diagnóstico e selecione DiagnosticServiceCollectionExtensions.cs.

  12. Na parte superior do arquivo, adicione esta using instrução:

    using Azure.Monitor.OpenTelemetry.AspNetCore;

  13. Depois var otelBuilder = services.AddOpenTelemetry();, adicione este código:

    if (!string.IsNullOrEmpty(configuration["APPLICATIONINSIGHTS_CONNECTION_STRING"]))
{
  otelBuilder.UseAzureMonitor();
}

  14. Selecione Ctrl+S para salvar o arquivo.

  15. No painel TERMINAL na parte inferior, acesse a pasta dotnet-observability/eShopLite.

    cd ..

  16. Atualize os contêineres de aplicativos.

    dotnet publish /p:PublishProfile=DefaultContainer

  17. Vá para a pasta dotnet-observability e inicie o aplicativo com o Docker:

    cd ..
docker compose up

  18. Entre no portal do Azure com as mesmas credenciais usadas para entrar na CLI do Azure.

  19. No portal do Azure, selecione Grupos de recursos.

  20. Selecione o grupo de recursos eShopLite .

  21. Selecione o recurso eShopLiteInsights Application Insights.

  22. Selecione o Painel do Aplicativo.

    Captura de tela que mostra o Application Insights mostrando a integridade do aplicativo eShopLite.

  23. Para ver as alterações nas métricas, acesse o aplicativo eShopLite e altere o estoque. Em seguida, atualize o painel do Application Insights.

  24. No painel TERMINAL , pressione Ctrl+C para interromper o aplicativo.