Dela via

Självstudie: Använd instrumentpanelen .NET Aspire med apparna Python

Den .NET.NET Aspire-instrumentpanelen ger en utmärkt användarupplevelse för att visa telemetri och är tillgänglig som en fristående containerbild som kan användas med vilken OpenTelemetry-aktiverad app som helst. I den här artikeln får du lära dig att:

  • Starta instrumentpanelen .NET.NET Aspire i fristående läge.
  • Använd instrumentpanelen .NET Aspire med en Python app.

Förutsättningar

För att slutföra den här självstudien behöver du följande:

  • Docker eller Podman.
    • Du kan använda en alternativ container-runtime, men kommandona i den här artikeln gäller för Docker.
  • Python 3.9 eller senare lokalt installerad.
  • Ett exempelprogram.

Exempelprogram

Den här självstudien kan slutföras med antingen Flask, Django eller FastAPI. Ett exempelprogram i varje ramverk tillhandahålls som hjälper dig att följa med i den här självstudien. Ladda ned eller klona exempelprogrammet till din lokala arbetsstation.

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

Så här kör du programmet lokalt:

  1. Gå till applikationsmappen:

    cd msdocs-python-flask-webapp-quickstart

  2. Skapa en virtuell miljö för appen:

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

  3. Installera beroendena:

    pip install -r requirements.txt

  4. Kör appen:

    flask run

  5. Navigera till exempelprogrammet på http://localhost:5000 i en webbläsare.

    Skärmbild av Flask-appen som körs lokalt i en webbläsare

Lägga till OpenTelemetry

Om du vill använda .NET Aspire instrumentpanelen med din Python-app måste du installera OpenTelemetry SDK och exportör. OpenTelemetry SDK tillhandahåller API:et för instrumentering av ditt program och exportören skickar telemetridata till .NET Aspire instrumentpanel.

  1. Installera OpenTelemetry SDK och exportör:

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

  2. Lägg till en ny fil i programmet med namnet otlp_tracing.py och lägg till följande kod:

    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. Uppdatera ditt program (app.py för Flask, main.py för FastAPI) så att det inkluderar importen och anropar funktionen configure_oltp_grpc_tracing:

    import logging
from otlp_tracing import configure_otel_otlp

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

  4. Ersätt print-anropen med logger.info-anrop i ditt program.

  5. Starta om programmet.

Ramverksspecifik instrumentation

Denna instrumentering har endast fokuserat på att lägga till OpenTelemetry i vår kod. För mer detaljerad instrumentering kan du använda paketen OpenTelemetry Instrumentation för de specifika ramverk som du använder.

  1. Installera Flask-instrumentationspaketet:

    pip install opentelemetry-instrumentation-flask

  2. Lägg till följande kod i programmet:

    from opentelemetry.instrumentation.flask import FlaskInstrumentor

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

Starta instrumentpanel Aspire

Starta instrumentpanelen Aspire i fristående läge genom att köra följande Docker kommando:

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

I Docker loggar visas slutpunkten och nyckeln för instrumentpanelen. Kopiera nyckeln och gå till http://localhost:18888 i en webbläsare. Ange nyckeln för att logga in på instrumentpanelen.

Visa strukturerade loggar

Navigera runt i Python-programmet så visas strukturerade loggar i Aspire instrumentpanelen. Sidan strukturerade loggar visar loggar från ditt program och du kan filtrera och söka i loggarna.

Skärmbild av instrumentpanelen Aspire som visar Python programloggar

Nästa steg

Du har framgångsrikt använt .NET Aspire instrumentpanelen med en Python program. Mer information om .NET.NET Aspire-instrumentpanelen finns i översikten över Aspire-instrumentpanelen och hur man orkestrerar Python-program med hjälp av .NET.NET Aspire-appvärd.