Ejercicio: uso de datos de OpenTelemetry en una aplicación nativa de nube

En este ejercicio, obtendrá una mejor visibilidad de todos los datos generados por OpenTelemetry en la aplicación. Has terminado de agregar la funcionalidad de diagnóstico al servicio de la tienda. Con eso en su lugar, agregará Prometheus y Grafana a los servicios de eShopLite y verá algunas de las métricas que se capturan. El siguiente paso es agregar Zipkin y ver las trazas distribuidas. Por último, agregue Application Insights a la aplicación y úselo para ver los datos.

Agregar Prometheus y Grafana

Prometheus y Grafana proporcionan imágenes de Docker que facilitan su incorporación a los proyectos. Los incluye en el archivo docker-compose.yml , en la raíz de la solución.

1. En el panel EXPLORADOR , seleccione el archivo docker-compose.yml .

2. Agregue este CÓDIGO YAML a la parte inferior del archivo:

     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
   

El archivo yaml de Docker anterior agrega dos nuevos servicios, Prometheus y Grafana. La sección Prometheus configura un contenedor para responder en el puerto 9090. Asigna la carpeta Prometheus que espera un archivo prometheus.yml. La sección Grafana configura un contenedor para responder en el puerto 3000. Asigna tres carpetas dentro de una carpeta Grafana.

Configuración de Prometheus

Prometheus debe configurarse para que sepa dónde recopilar las métricas. Agregue un archivo prometheus.yml a la carpeta prometheus .

1. En el panel EXPLORER , haga clic con el botón derecho en la carpeta dotnet-observability y, a continuación, seleccione Nueva carpeta.

2. En el campo nombre, escriba prometheus.

3. En el panel EXPLORADOR , haga clic con el botón derecho en la carpeta prometheus y seleccione Nuevo archivo.

4. En el campo nombre, escriba prometheus.yml.

5. En el editor de archivos, escriba este CÓDIGO YAML:

   global:
     scrape_interval: 1s
   
   scrape_configs:
     - job_name: 'products'
       static_configs:
         - targets: ['backend:8080']
     - job_name: 'store'
       static_configs:
         - targets: ['frontend:8080']
   

   El código YAML anterior configura Prometheus para obtener métricas de los servicios back-end y front-end. A medida que la aplicación se ejecuta en Docker, los nombres de host son los nombres de servicio.

6. Seleccione Ctrl+S para guardar el archivo.

Configuración de Grafana

Grafana debe configurarse para que sepa dónde recopilar las métricas.

1. En el panel EXPLORADOR , haga clic con el botón derecho en la carpeta dotnet-observability y seleccione Nueva carpeta.

2. En el campo nombre, escriba grafana.

3. Haga clic con el botón derecho en la carpeta grafana y seleccione Nueva carpeta.

4. En el campo nombre, escriba el origen de datos.

5. Haga clic con el botón derecho en la carpeta grafana y seleccione Nueva carpeta.

6. En el campo name, escriba dashboard.

7. Expanda la carpeta grafana , haga clic con el botón derecho en la carpeta del origen de datos y seleccione Nuevo archivo.

8. En el campo nombre, escriba datasource.yml.

9. En la pestaña editor, escriba este CÓDIGO YAML:

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

   El CÓDIGO YAML anterior configura Grafana para que use Prometheus como origen de datos.

10. Seleccione Ctrl+S para guardar el archivo.

Actualización de la aplicación ASP.NET Core para exponer métricas para Prometheus

Ahora, el proyecto de diagnóstico solo está configurado para exponer métricas a la consola. Tú actualizas el proyecto para exponer métricas a Prometheus en su lugar.

1. En el panel TERMINAL de la parte inferior, vaya a la carpeta Diagnósticos .

2. Ejecute este comando:

   cd .\eShopLite\Diagnostics\ 
   

3. Quite el OpenTelemetry.Exporter.Console paquete:

   dotnet remove package OpenTelemetry.Exporter.Console
   

4. Incorporación del paquete OpenTelemetry.Exporter.Prometheus.AspNetCore:

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

5. En el panel EXPLORADOR , expanda la carpeta Diagnósticos y, a continuación, seleccione DiagnosticServiceCollectionExtensions.cs.

6. Reemplace el exportador .AddConsoleExporter(); de consola por este código:

   .AddPrometheusExporter();
   

7. En la parte inferior del archivo, antes del último }, agregue este código:

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

   Este código agrega un punto de conexión de extracción de Prometheus a todos los servicios que lo incluyen con su aplicación. Esto permite a Prometheus extraer las métricas de http://service/metrics.

8. Seleccione Ctrl+S para guardar el archivo.

Exposición de métricas en el servicio Store

Actualmente, la aplicación solo está configurada para exponer métricas para el servicio Products . También actualizas la aplicación para exponer métricas para el servicio Store.

1. En el panel EXPLORADOR , en EXPLORADOR DE SOLUCIONES, haga clic con el botón derecho en el proyecto Store y seleccione Agregar referencia de proyecto.

2. Haga clic en Diagnósticos.

3. En el panel EXPLORADOR , expanda la carpeta Store y, a continuación, seleccione Program.cs.

4. En el comentario de código // Add observability code here, agregue una llamada al método Diagnóstico:

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

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

   app.MapObservability();
   

   Este método agrega el punto de conexión de extracción de Prometheus al servicio Store.

6. Seleccione Ctrl+S para guardar el archivo.

7. En el panel EXPLORADOR, expanda la carpeta Product y luego seleccione Program.cs.

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

   app.MapObservability();
   

   Este método agrega el punto de conexión de extracción de Prometheus al servicio Products.

9. Seleccione Ctrl+S para guardar el archivo.

Prueba de las nuevas características de observabilidad

Ahora probará las nuevas características de observabilidad que agregó a la aplicación.

1. En el panel TERMINAL de la parte inferior, vaya a la carpeta dotnet-observability/eShopLite .

   cd ..
   

2. Actualice los contenedores de aplicaciones.

   dotnet publish /p:PublishProfile=DefaultContainer 
   

3. Vaya a la carpeta dotnet-observability e inicie la aplicación con Docker:

   cd ..
   docker compose up
   

4. En la pestaña PUERTOS , seleccione Abrir en explorador para Prometheus (9090) . Si se ejecuta localmente en Visual Studio Code, abra un explorador y, en una nueva pestaña, vaya a la aplicación http://localhost:9090Prometheus .

5. En el menú superior, seleccione Estado y, a continuación, seleccione Destinos.

   

   Debería ver los productos y los servicios de Store enumerados como UP.

6. En la pestaña PUERTOS , seleccione Abrir en explorador para Grafana (3000). Si se ejecuta localmente en Visual Studio Code, abra un explorador y, en una nueva pestaña, vaya a la aplicación http://localhost:3000Grafana .

7. Ingrese el nombre de usuario admin.

8. Escriba la contraseña grafana.

9. Seleccione Crear el primer panel.

10. Seleccione Importar panel.

11. En una nueva pestaña, vaya a GitHub y abra el archivo json del panel de ASP.NET Core .

12. Copie el archivo raw .

13. Pegue el código JSON en el cuadro de texto Importar a través del modelo JSON del panel .

14. Seleccionar Cargar.

15. En la lista desplegable Origen de datos de Prometheus , seleccione Prometheus.

16. Seleccione Importar.

    

    Debería ver un panel en el que se muestran las métricas de los servicios Products y Store . Seleccione el trabajo para cambiar entre los dos servicios.

17. En el panel TERMINAL , seleccione Ctrl+C para detener la aplicación.

Agregar Zipkin

Ahora amplía las funcionalidades de seguimiento de la aplicación agregando Zipkin. Como hizo antes, agrega un contenedor Zipkin a la aplicación y lo configura para conectarse al recopilador de OpenTelemetry. A continuación, agrega el exportador de OpenTelemetry Zipkin a la aplicación.

1. En el panel EXPLORADOR , seleccione el archivo docker-compose.yml dentro de la carpeta dotnet-observability .

2. Agregue prometheus y zipkin en el depends_on para el frontend.

   depends_on: 
     - backend
     - prometheus
     - zipkin 
   

3. Agregue prometheus en depends_on para backend.

    depends_on: 
      - prometheus
   

4. Agregue variables de entorno para Zipkin a BOTHfrontend y backend:

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

   Los dos servicios deben tener este aspecto:

   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. Agregue este CÓDIGO YAML a la parte inferior del archivo:

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

   El código YAML anterior agrega un contenedor Zipkin a la aplicación. Configura el contenedor zipkin para responder en el puerto 9411.

6. Seleccione Ctrl+S para guardar el archivo.

7. En el panel TERMINAL , vaya a la carpeta Diagnósticos .

   cd ./eShopLite/Diagnostics/
   

8. Agregue los paquetes de exportación de Zipkin.

   dotnet add package OpenTelemetry.Exporter.Zipkin --prerelease
   

9. En el panel EXPLORADOR , expanda la carpeta Diagnósticos y, a continuación, seleccione DiagnosticServiceCollectionExtensions.cs.

10. En la parte inferior de los proveedores de seguimiento, agregue 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. Seleccione Ctrl+S para guardar el archivo.

12. En el panel TERMINAL de la parte inferior, vaya a la carpeta dotnet-observability/eShopLite .

    cd ..
    

13. Actualice los contenedores de aplicaciones.

    dotnet publish /p:PublishProfile=DefaultContainer 
    

14. Vaya a la carpeta dotnet-observability e inicie la aplicación con Docker:

    cd ..
    docker compose up
    

15. En la pestaña PUERTOS , seleccione Abrir en explorador para Prometheus (9090) . Si se ejecuta localmente en Visual Studio Code, abra una nueva pestaña del explorador y vaya a la aplicación http://localhost:9411Zipkin .

16. En el menú, seleccione Dependencias.

    

17. En el panel TERMINAL , seleccione Ctrl+C para detener la aplicación.

Agrega Application Insights

El último paso es agregar Application Insights a la aplicación.

Creación del recurso de Application Insights en Azure

1. En el panel TERMINAL , inicie sesión en Azure.

   az login --use-device-code
   

2. Vea la suscripción de Azure seleccionada.

   az account show -o table
   

   Si se selecciona la suscripción incorrecta, seleccione la correcta mediante el comando az account set .

3. Agregue la extensión para Application Insights.

   az extension add -n application-insights
   

4. Cree un recurso de Application Insights.

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

   Debería ver esta salida:

   {
     "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"
   }
   

   Del código JSON anteriormente devuelto, copie el connectionString, excluyendo las ". Por ejemplo:

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

5. En el panel EXPLORADOR , seleccione el archivo docker-compose.yml .

6. Agregue una variable de entorno que el proyecto de diagnóstico usa para conectarse a Application Insights. Agregue este CÓDIGO YAML al servicio 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/
   

   Reemplace la cadena de conexión anterior por la que copió de la CLI de Azure.

7. Repita estos pasos para el servicio Products . El código YAML final debe tener este aspecto:

     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. Seleccione Ctrl+S para guardar el archivo.

9. En el panel TERMINAL , vaya a la carpeta Diagnósticos .

   cd .\eShopLite\Diagnostics\ 
   

10. Agregue el paquete exportador de Application Insights.

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

11. En el panel EXPLORAR , seleccione la carpeta Diagnósticos y, a continuación, seleccione DiagnosticServiceCollectionExtensions.cs.

12. En la parte superior del archivo, agregue esta using instrucción:

    using Azure.Monitor.OpenTelemetry.AspNetCore;
    

13. Después de var otelBuilder = services.AddOpenTelemetry();, agregue este código:

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

14. Seleccione Ctrl+S para guardar el archivo.

15. En el panel TERMINAL de la parte inferior, vaya a la carpeta dotnet-observability/eShopLite .

    cd ..
    

16. Actualice los contenedores de aplicaciones.

    dotnet publish /p:PublishProfile=DefaultContainer 
    

17. Vaya a la carpeta dotnet-observability e inicie la aplicación con Docker:

    cd ..
    docker compose up
    

18. Inicie sesión en Azure Portal con las mismas credenciales que usó para iniciar sesión en la CLI de Azure.

19. En Azure Portal, seleccione Grupos de recursos.

20. Seleccione el grupo de recursos eShopLite .

21. Seleccione el recurso de Application Insights eShopLiteInsights.

22. Seleccione el panel de la aplicación.

    

23. Para ver los cambios en las métricas, diríjase a la aplicación eShopLite y cambie el stock. A continuación, actualice el panel de Application Insights.

24. En el panel TERMINAL , presione Ctrl+C para detener la aplicación.