Delen via

Zelfstudie: Het .NET Aspire-dashboard gebruiken met Python-apps

  • Artikel

Het .NET.NET Aspire dashboard biedt een geweldige gebruikerservaring voor het weergeven van telemetrie en is beschikbaar als een zelfstandige containerafbeelding die kan worden gebruikt met elke OpenTelemetry-app. In dit artikel leert u het volgende:

  • Start het .NET.NET Aspire dashboard in de zelfstandige modus.
  • Gebruik het .NET Aspire-dashboard met een Python-app.

Voorwaarden

U hebt het volgende nodig om deze zelfstudie te voltooien:

  • Docker of Podman.
    • U kunt een alternatieve containerruntime gebruiken, maar de opdrachten in dit artikel zijn bedoeld voor Docker.
  • Python 3,9 of hoger lokaal geïnstalleerd.
  • Een voorbeeldtoepassing.

Voorbeeldtoepassing

Deze zelfstudie kan worden voltooid met Flask, Django of FastAPI. Er wordt een voorbeeldtoepassing in elk framework geboden om u te helpen bij het volgen van deze zelfstudie. Download of kloon de voorbeeldtoepassing naar uw lokale werkstation.

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

De toepassing lokaal uitvoeren:

  1. Ga naar de toepassingsmap:

    cd msdocs-python-flask-webapp-quickstart

  2. Maak een virtuele omgeving voor de app:

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

  3. Installeer de afhankelijkheden:

    pip install -r requirements.txt

  4. Voer de app uit:

    flask run

  5. Blader in een webbrowser naar de voorbeeldtoepassing op http://localhost:5000.

    Schermopname van de Flask-app die lokaal wordt uitgevoerd in een browser

OpenTelemetry toevoegen

Als u het .NET Aspire-dashboard wilt gebruiken met uw Python-app, moet u de OpenTelemetry SDK en exporteur installeren. De OpenTelemetry SDK biedt de API voor het instrumenteren van uw toepassing en de exporteur verzendt telemetriegegevens naar het .NET Aspire dashboard.

  1. Installeer de OpenTelemetry SDK en exporttool:

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

  2. Voeg een nieuw bestand toe aan uw toepassing met de naam otlp_tracing.py en voeg de volgende code toe:

    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. Werk uw toepassing (app.py voor Flask, main.py voor FastAPI) bij om de importbewerkingen op te nemen en de configure_oltp_grpc_tracing-functie aan te roepen:

    import logging
from otlp_tracing import configure_otel_otlp

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

  4. Vervang de print-aanroepen door logger.info aanroepen in uw toepassing.

  5. Start de toepassing opnieuw op.

Frameworkspecifieke instrumentatie

Deze instrumentatie is alleen gericht op het toevoegen van OpenTelemetry aan onze code. Voor gedetailleerdere instrumentatie kunt u de OpenTelemetry Instrumentatiepakketten gebruiken voor de specifieke frameworks die u gebruikt.

  1. Installeer het Flask-instrumentatiepakket:

    pip install opentelemetry-instrumentation-flask

  2. Voeg de volgende code toe aan uw toepassing:

    from opentelemetry.instrumentation.flask import FlaskInstrumentor

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

Het Aspire-dashboard starten

Voer de volgende Aspire opdracht uit om het Docker dashboard in de zelfstandige modus te starten:

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

In de Docker logboeken worden het eindpunt en de sleutel voor het dashboard weergegeven. Kopieer de sleutel en navigeer naar http://localhost:18888 in een webbrowser. Voer de sleutel in om u aan te melden bij het dashboard.

Gestructureerde logboeken weergeven

Navigeer door de Python toepassing en u ziet gestructureerde logboeken in het Aspire dashboard. Op de pagina gestructureerde logboeken worden logboeken uit uw toepassing weergegeven en kunt u de logboeken filteren en doorzoeken.

Schermopname van het Aspire dashboard met de Python toepassingslogboeken

Volgende stappen

U hebt het .NET Aspire-dashboard gebruikt met een Python toepassing. Zie het overzicht van het .NET Aspire en het organiseren van een Aspire toepassing met de .NETvoor meer informatie over het .NET Aspire dashboard.