Exercício - Use dados OpenTelemetry em um aplicativo nativo da nuvem

  • 15 minutos

Neste exercício, você obtém melhor visibilidade de todos os dados gerados pelo OpenTelemetry em seu aplicativo. Você termina de adicionar a capacidade de diagnóstico ao serviço da loja. Tendo isso configurado, adicionas o Prometheus e o Grafana aos serviços de eShopLite e consultas algumas das métricas capturadas. O próximo passo é adicionar o Zipkin e visualizar os rastreamentos distribuídos. Por fim, você adiciona o Application Insights ao seu aplicativo e o usa para exibir os dados.

Adicionar Prometheus e Grafana

Prometheus e 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 ficheiro:

      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 anterior Docker yaml 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 ficheiro 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 o Prometheus

O Prometheus precisa ser configurado para que ele saiba onde coletar as métricas. Você adiciona um arquivo prometheus.yml à pasta prometheus.

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

  2. No campo nome, digite prometheus.

  3. No painel EXPLORER , clique com o botão direito do rato na pasta prometheus e, em seguida, selecione Novo Ficheiro.

  4. No campo nome, digite prometheus.yml.

  5. No editor de ficheiros, introduza 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 recolher métricas dos serviços de back-end e de front-end . Como o aplicativo está sendo executado no Docker, os nomes de host são os nomes de serviço.

  6. Selecione Ctrl+S para salvar o arquivo.

Configurar o Grafana

O Grafana precisa ser configurado para que ele saiba onde coletar as métricas.

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

  2. No campo nome, digite grafana.

  3. Clique com o botão direito do rato na pasta grafana e, em seguida, selecione Nova Pasta.

  4. No campo nome, insira fonte de dados.

  5. Clique com o botão direito do rato na pasta grafana e, em seguida, selecione Nova Pasta.

  6. No campo de nome, insira painel.

  7. Expanda a pasta grafana, clique com o botão direito do mouse na pasta datasource e, em seguida, selecione Novo Arquivo.

  8. No campo nome, digite datasource.yml.

  9. Na guia do editor, introduza este conteúdo 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 Prometheus como fonte de dados.

  10. Selecione Ctrl+S para salvar o arquivo.

Atualize seu aplicativo ASP.NET Core para expor métricas para o Prometheus

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

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

  2. Execute este comando:

    cd .\eShopLite\Diagnostics\

  3. Remova o pacote OpenTelemetry.Exporter.Console.

    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 .AddConsoleExporter(); do exportador do console por este código:

    .AddPrometheusExporter();

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

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

    Este código adiciona um endpoint de scraping Prometheus a cada serviço que o inclui na sua aplicação. Isso permite que o Prometheus colete métricas de http://service/metrics.

  8. Selecione Ctrl+S para salvar o arquivo.

Expor métricas no serviço da Loja

Atualmente, a aplicação está configurada apenas para expor métricas do serviço Produtos. Você também atualiza o aplicativo para expor métricas para o serviço de da Store.

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

  2. Selecione Diagnósticos.

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

  4. No comentário do código // Add observability code here, adicione uma chamada ao método Diagnostics:

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

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

    app.MapObservability();

    Esse método adiciona o ponto de extremidade de raspagem Prometheus ao serviço do Store.

  6. Selecione Ctrl+S para salvar o arquivo.

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

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

    app.MapObservability();

    Esse método adiciona o ponto de extremidade de raspagem Prometheus ao serviço Produtos.

  9. Selecione Ctrl+S para salvar o arquivo.

Testar os novos recursos de observabilidade

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

  1. No painel TERMINAL na parte inferior, vá para 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, em seguida, selecione Targets.

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

    Você deve ver os Produtos e os serviços da Loja listados como UP.

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

  7. Introduza o nome de utilizador administrador.

  8. Digite a senha grafana.

  9. Selecione Criar seu primeiro painel.

  10. Selecione Importar painel.

  11. Em uma nova guia, vá para do GitHub e abra o arquivo json do painel do ASP.NET Core.

  12. Copie o ficheiro Raw.

  13. Cole o JSON na caixa de texto do modelo de Importação no painel.

  14. Selecione Carregar.

  15. Na lista suspensa da fonte de dados Prometheus , selecione Prometheus.

  16. Selecione Importar.

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

    Você verá um painel mostrando métricas para os produtos e os serviços de loja . Selecione o trabalho para alternar entre os dois serviços.

  17. No painel TERMINAL, selecione Ctrl+C para parar a aplicação.

Adicionar Zipkin

Agora você amplia os recursos de rastreamento do aplicativo adicionando Zipkin. Como fez antes, você adiciona um contêiner Zipkin ao seu aplicativo e o configura para se conectar ao coletor OpenTelemetria. Em seguida, você adiciona 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 no depends_on para o backend.

     depends_on: 
   - prometheus

  4. Adicione variáveis de ambiente para Zipkin para frontend 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 ficheiro:

      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 Diagnostics.

    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, vá para 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 mostrando as dependências da loja de aplicativos eShopLite enviando solicitações para o serviço de Produtos.

  17. No painel TERMINAL, selecione Ctrl+C para parar a aplicação.

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, inicie sessão 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, utilize o comando az account set para selecionar a correta.

  3. Adicione a extensão para Application Insights.

    az extension add -n application-insights

  4. Crie um recurso do Application Insights.

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

    Você deve ver esta saída:

    {
  "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 recebido 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. Você adiciona uma variável de ambiente que o projeto de diagnóstico usa para se conectar ao Application Insights. Adicione este YAML ao serviço de da 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 estes passos para o serviço de 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 Diagnostics.

    cd .\eShopLite\Diagnostics\

  10. Adicione o pacote de exportador do Application Insights.

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

  11. No painel EXPLORAR, selecione a pasta Diagnósticos e, em seguida, selecione DiagnosticServiceCollectionExtensions.cs.

  12. Na parte superior do ficheiro, adicione esta declaração using:

    using Azure.Monitor.OpenTelemetry.AspNetCore;

  13. Depois de 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, vá para 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 que você usou para entrar na CLI do Azure.

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

  20. Selecione o eShopLite grupo de recursos.

  21. Selecione o recurso eShopLiteInsights Application Insights.

  22. Selecione o Dashboard da Aplicação.

    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 parar o aplicativo.