Compartir a través de

Tutorial: Uso del panel de .NET Aspire con aplicaciones de Python

  • Artículo

El panel de .NET.NET Aspire proporciona una excelente experiencia de usuario para ver la telemetría y está disponible como una imagen de contenedor independiente que se puede usar con cualquier aplicación habilitada para OpenTelemetry. En este artículo, aprenderá a:

  • Inicie el panel de .NET.NET Aspire en modo independiente.
  • Use el panel de .NET Aspire con una aplicación Python.

Prerrequisitos

Para completar este tutorial, necesita lo siguiente:

  • Docker o Podman.
    • Puede usar un entorno de ejecución de contenedor alternativo, pero los comandos de este artículo son para Docker.
  • Python 3.9 o superior instalado localmente.
  • Una aplicación de ejemplo.

Aplicación de ejemplo

Este tutorial se puede completar mediante Flask, Django o FastAPI. Se proporciona una aplicación de ejemplo en cada marco para ayudarle a seguir este tutorial. Descargue o clone la aplicación de ejemplo en la estación de trabajo local.

git clone https://github.com/Azure-Samples/msdocs-python-flask-webapp-quickstart

Para ejecutar la aplicación localmente:

  1. Vaya a la carpeta de la aplicación:

    cd msdocs-python-flask-webapp-quickstart

  2. Cree un entorno virtual para la aplicación:

    py -m venv .venv
.\.venv\Scripts\Activate.ps1

  3. Instale las dependencias:

    pip install -r requirements.txt

  4. Ejecute la aplicación:

    flask run

  5. Navegue a la aplicación de ejemplo en http://localhost:5000 en un navegador web.

    Captura de pantalla de la aplicación Flask que se ejecuta localmente en un explorador

Agregar OpenTelemetry

Para usar el panel de .NET Aspire con la aplicación de Python, debe instalar el SDK y el exportador de OpenTelemetry. El SDK de OpenTelemetry proporciona la API para instrumentar la aplicación y el exportador envía datos de telemetría al panel de .NET Aspire.

  1. Instale el SDK y el exportador de OpenTelemetry:

    pip install opentelemetry-api opentelemetry-sdk opentelemetry-exporter-otlp-proto-grpc

  2. Agregue un nuevo archivo a la aplicación denominado otlp_tracing.py y agregue el código siguiente:

    import logging
from opentelemetry import metrics, trace

from opentelemetry._logs import set_logger_provider
from opentelemetry.exporter.otlp.proto.grpc._log_exporter import (
    OTLPLogExporter,
)
from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor

def configure_oltp_grpc_tracing(
    endpoint: str = None
) -> trace.Tracer:
    # Configure Tracing
    traceProvider = TracerProvider()
    processor = BatchSpanProcessor(OTLPSpanExporter(endpoint=endpoint))
    traceProvider.add_span_processor(processor)
    trace.set_tracer_provider(traceProvider)

    # Configure Metrics
    reader = PeriodicExportingMetricReader(OTLPMetricExporter(endpoint=endpoint))
    meterProvider = MeterProvider(metric_readers=[reader])
    metrics.set_meter_provider(meterProvider)

    # Configure Logging
    logger_provider = LoggerProvider()
    set_logger_provider(logger_provider)

    exporter = OTLPLogExporter(endpoint=endpoint)
    logger_provider.add_log_record_processor(BatchLogRecordProcessor(exporter))
    handler = LoggingHandler(level=logging.NOTSET, logger_provider=logger_provider)
    handler.setFormatter(logging.Formatter("Python: %(message)s"))

    # Attach OTLP handler to root logger
    logging.getLogger().addHandler(handler)

    tracer = trace.get_tracer(__name__)
    return tracer

  3. Actualice la aplicación (app.py para Flask, main.py para FastAPI) para incluir las importaciones y llamar a la función configure_oltp_grpc_tracing:

    import logging
from otlp_tracing import configure_otel_otlp

logging.basicConfig(level=logging.INFO)
tracer = configure_otel_otlp()
logger = logging.getLogger(__name__)

  4. Reemplace las llamadas de print por llamadas logger.info en la aplicación.

  5. Reinicie la aplicación.

Instrumentación específica del marco

Esta instrumentación se ha centrado únicamente en agregar OpenTelemetry a nuestro código. Para obtener una instrumentación más detallada, puede utilizar los paquetes de instrumentación OpenTelemetry para los frameworks específicos que está utilizando.

  1. Instale el paquete de instrumentación de Flask:

    pip install opentelemetry-instrumentation-flask

  2. Agregue el código siguiente a la aplicación:

    from opentelemetry.instrumentation.flask import FlaskInstrumentor

# add this line after configure_otel_otlp() call
FlaskInstrumentor().instrument()

Inicio del panel de Aspire

Para iniciar el panel de Aspire en modo independiente, ejecute el siguiente comando Docker:

docker run --rm -it -p 18888:18888 -p 4317:18889 --name aspire-dashboard \
    mcr.microsoft.com/dotnet/aspire-dashboard:9.0

En los registros de Docker, se muestran el punto de conexión y la clave del panel. Copie la clave y vaya a http://localhost:18888 en un explorador web. Escriba la clave para iniciar sesión en el panel.

Visualización de registros estructurados

Navegue por la aplicación Python y verá registros estructurados en el panel de Aspire. La página de registros estructurados muestra los registros de la aplicación y puede filtrar y buscar en los registros.

Captura de pantalla del panel de Aspire en la que se muestran los registros de aplicación de Python

Pasos siguientes

Ha usado exitosamente el panel de .NET Aspire con una aplicación Python. Para obtener más información sobre el panel de .NET.NET Aspire, consulte la descripción general de Aspire y cómo gestionar una aplicación de Python con el host de aplicaciones de .NET.NET Aspire.