Tutorial: .NET Aspire Dashboard mit Python Apps verwenden

Artikel
12/15/2024

Das -.NET-.NET Aspire-Dashboard bietet eine großartige Benutzererfahrung für die Anzeige von Telemetriedaten und ist als eigenständiges Container-Image verfügbar, das mit jeder OpenTelemetry-fähigen App verwendet werden kann. In diesem Artikel erfahren Sie, wie Sie:

Starten Sie das .NET.NET Aspire-Dashboard im eigenständigen Modus.
Verwenden Sie das .NET Aspire-Dashboard mit einer Python-App.

Voraussetzungen

Um dieses Lernprogramm abzuschließen, benötigen Sie Folgendes:

Docker oder Podman.
- Sie können eine alternative Containerlaufzeit verwenden, aber die Befehle in diesem Artikel gelten für Docker.
Python 3.9 oder höher lokal installiert.
Eine Beispielanwendung.

Beispielanwendung

Dieses Lernprogramm kann entweder mit Flask, Django oder FastAPI abgeschlossen werden. Eine Beispielanwendung in jedem Framework wird bereitgestellt, um Ihnen zu helfen, diesem Tutorial zu folgen. Laden Sie die Beispielanwendung auf Ihre lokale Arbeitsstation herunter, oder klonen Sie sie.

Flask
FastAPI

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

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

So führen Sie die Anwendung lokal aus:

Flask
FastAPI

Wechseln Sie zum Anwendungsordner:

cd msdocs-python-flask-webapp-quickstart

Erstellen Sie eine virtuelle Umgebung für die App:

Windows
macOS/Linux

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

python3 -m venv .venv
source .venv/bin/activate

Installieren Sie die Abhängigkeiten:
```
pip install -r requirements.txt
```
Führen Sie die App aus:
```
flask run
```
Navigieren Sie zur Beispielanwendung unter http://localhost:5000 in einem Webbrowser.

Wechseln Sie zum Anwendungsordner:

cd msdocs-python-fastapi-webapp-quickstart

Erstellen Sie eine virtuelle Umgebung für die App:

Windows
macOS/Linux

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

python3 -m venv .venv
source .venv/bin/activate

Installieren Sie die Abhängigkeiten:
```
pip install -r requirements.txt
```
Führen Sie die App aus:
```
uvicorn main:app --reload
```
Navigieren Sie zur Beispielanwendung unter http://localhost:8000 in einem Webbrowser.

Hinzufügen von OpenTelemetry

Um das .NET Aspire-Dashboard mit Ihrer Python-App zu verwenden, müssen Sie das OpenTelemetry SDK und den Exporter installieren. Das OpenTelemetry SDK stellt die API zum Instrumentieren Ihrer Anwendung bereit, und der Exporter sendet Telemetriedaten an das .NET Aspire-Dashboard.

Installieren Sie das OpenTelemetry SDK und den Exporter:

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

Fügen Sie ihrer Anwendung eine neue Datei namens otlp_tracing.py hinzu, und fügen Sie den folgenden Code hinzu:

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

Aktualisieren Sie Ihre Anwendung (app.py für Flask, main.py für FastAPI), um die Importe einzuschließen und die configure_oltp_grpc_tracing-Funktion aufzurufen:

import logging
from otlp_tracing import configure_otel_otlp

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

Ersetzen Sie die print-Aufrufe durch logger.info-Aufrufe in Ihrer Anwendung.
Starten Sie Die Anwendung neu.

Frameworkspezifische Instrumentierung

Diese Instrumentierung konzentriert sich nur auf das Hinzufügen von OpenTelemetry zu unserem Code. Für eine detailliertere Instrumentierung können Sie die OpenTelemetry Instrumentationspakete für die spezifischen Frameworks verwenden, die Sie nutzen.

Flask
FastAPI

Installieren Sie das Flask-Instrumentierungspaket:
```
pip install opentelemetry-instrumentation-flask
```

Fügen Sie Ihrer Anwendung den folgenden Code hinzu:

from opentelemetry.instrumentation.flask import FlaskInstrumentor

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

Installieren Sie das FastAPI-Instrumentierungspaket:
```
pip install opentelemetry-instrumentation-fastapi
```

Fügen Sie Ihrer Anwendung den folgenden Code hinzu:

from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor

# add this line after configure_otel_otlp() call
FastAPIInstrumentor.instrument_app(app)

Starten des Aspire Dashboards

Führen Sie den folgenden Aspire Befehl aus, um das Docker-Dashboard im eigenständigen Modus zu starten:

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

In den Docker Protokollen werden der Endpunkt und der Schlüssel für das Dashboard angezeigt. Kopieren Sie den Schlüssel, und navigieren Sie zu http://localhost:18888 in einem Webbrowser. Geben Sie den Schlüssel ein, um sich beim Dashboard anzumelden.

Strukturierte Protokolle anzeigen

Navigieren Sie in der Python-Anwendung, und Sie sehen strukturierte Protokolle im Aspire-Dashboard. Auf der Seite "Strukturierte Protokolle" werden Protokolle aus Ihrer Anwendung angezeigt, und Sie können die Protokolle filtern und durchsuchen.

Screenshot des Aspire Dashboards mit den Python Anwendungs-Logs

Nächste Schritte

Sie haben das .NET Aspire-Dashboard erfolgreich mit einer Python-Applikation verwendet. Weitere Informationen zum .NET.NET Aspire-Dashboard finden Sie in der Übersicht des Aspire-Dashboards und dazu, wie Sie eine Python-Anwendung mit dem .NET.NET Aspire-App-Hostorchestrieren.

Freigeben über