Compartilhar via

Tutorial: Usar o painel .NET Aspire com aplicativos Python

  • Artigo

O painel .NET.NET Aspire fornece uma excelente experiência do usuário para exibir a telemetria e está disponível como uma imagem de contêiner autônoma que pode ser usada com qualquer aplicativo com suporte a OpenTelemetry. Neste artigo, você aprenderá a:

  • Inicie o painel .NET.NET Aspire no modo autônomo.
  • Use o painel .NET Aspire com o aplicativo Python.

Pré-requisitos

Para concluir este tutorial, você precisa do seguinte:

  • Docker ou Podman.
    • Você pode usar um runtime de contêiner alternativo, mas os comandos neste artigo são para Docker.
  • Python 3.9 ou superior instalado localmente.
  • Um aplicativo de exemplo.

Aplicativo de exemplo

Este tutorial pode ser concluído usando Flask, Django ou FastAPI. Um aplicativo de exemplo em cada estrutura é fornecido para ajudá-lo a acompanhar este tutorial. Baixe ou clone o aplicativo de exemplo na estação de trabalho local.

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

Para executar o aplicativo localmente:

  1. Vá para a pasta do aplicativo:

    cd msdocs-python-flask-webapp-quickstart

  2. Crie um ambiente virtual para o aplicativo:

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

  3. Instale as dependências:

    pip install -r requirements.txt

  4. Execute o aplicativo:

    flask run

  5. Navegue até o aplicativo de exemplo em http://localhost:5000 em um navegador da Web.

    Captura de tela do aplicativo Flask em execução localmente em um navegador

Adicionando OpenTelemetry

Para usar o painel .NET Aspire com seu aplicativo Python, você precisa instalar o SDK e o exportador do OpenTelemetry. O SDK do OpenTelemetry fornece a API para instrumentar seu aplicativo e o exportador envia dados de telemetria para o painel de .NET Aspire.

  1. Instale o SDK OpenTelemetry e o exportador:

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

  2. Adicione um novo arquivo ao aplicativo chamado otlp_tracing.py e adicione o seguinte código:

    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. Atualize seu aplicativo (app.py para Flask, main.py para FastAPI) para incluir as importações e chamar a função 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. Substitua as chamadas print por chamadas logger.info em seu aplicativo.

  5. Reinicie seu aplicativo.

Instrumentação específica da estrutura

Essa instrumentação se concentrou apenas em adicionar OpenTelemetry ao nosso código. Para instrumentação mais detalhada, você pode usar os pacotes de instrumentação OpenTelemetry para as estruturas específicas que você está usando.

  • do Flask
  • FastAPI

  1. Instale o pacote de instrumentação do Flask:

    pip install opentelemetry-instrumentation-flask

  2. Adicione o seguinte código ao seu aplicativo:

    from opentelemetry.instrumentation.flask import FlaskInstrumentor

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

Iniciar o painel de Aspire

Para iniciar o painel Aspire no modo autônomo, execute o seguinte comando Docker:

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

Nos logs de Docker, o endpoint e a chave do painel são exibidos. Copie a chave e navegue até http://localhost:18888 em um navegador da Web. Insira a chave para fazer logon no painel.

Exibir logs estruturados

Navegue pelo aplicativo Python e verá logs estruturados no painel Aspire. A página de logs estruturados exibe logs do seu aplicativo, e você pode filtrar e pesquisar os logs.

Captura de tela do painel Aspire mostrando os logs de aplicativos Python

Próximas etapas

Você usou com êxito o painel .NET Aspire com um aplicativo Python. Para saber mais sobre o painel de .NET.NET Aspire, consulte a visão geral do painel Aspire e como orquestrar um aplicativo Python com o host do aplicativo .NET.NET Aspire.