Partilhar via

Tutorial: Usar o painel .NET Aspire com aplicativos Python

  • Artigo

O painel .NET.NET Aspire oferece uma ótima experiência do usuário para visualização de telemetria e está disponível como uma imagem de contêiner independente que pode ser usada com qualquer aplicativo habilitado para OpenTelemetry. Neste artigo, você aprenderá a:

  • Inicie o painel de .NET.NET Aspire no modo autônomo.
  • Utilize o painel .NET Aspire com uma aplicação Python.

Pré-requisitos

Para concluir este tutorial, você precisa do seguinte:

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

Exemplo de aplicação

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. Descarregue ou clone a aplicação de exemplo para a 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é à aplicação de exemplo em http://localhost:5000 num navegador web.

    Captura de tela do aplicativo Flask executado localmente em um navegador

Adicionando OpenTelemetry

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

  1. Instale o SDK do OpenTelemetry e o exportador:

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

  2. Adicione um novo arquivo ao seu 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 o aplicativo.

Instrumentação específica do quadro

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

  1. Instale o pacote de instrumentação 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 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 registos de Docker, o endpoint e a chave do dashboard são exibidos. Copie a chave e navegue até http://localhost:18888 em um navegador da Web. Introduza a chave para iniciar sessão no dashboard.

Exibir logs estruturados

Navegue pelo aplicativo Python e você 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 do Aspire mostrando os logs do aplicativo Python

Próximos passos

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