Udostępnij za pośrednictwem

Samouczek: używanie pulpitu nawigacyjnego .NET Aspire z aplikacjami Python

  • Artykuł

Panel .NET.NET Aspire zapewnia doskonałe doświadczenie użytkownika przy wyświetlaniu danych telemetrycznych i jest dostępny jako obraz kontenera, który może być używany z każdą aplikacją obsługującą OpenTelemetry. Z tego artykułu dowiesz się, jak wykonywać następujące działania:

  • Uruchom pulpit nawigacyjny .NET.NET Aspire w trybie autonomicznym.
  • Użyj pulpitu nawigacyjnego .NET Aspire z aplikacją Python.

Warunki wstępne

Do ukończenia tego samouczka potrzebne są następujące elementy:

  • Docker lub Podman.
    • Możesz użyć alternatywnego środowiska uruchomieniowego kontenera, ale polecenia w tym artykule dotyczą Docker.
  • Python 3.9 lub nowszy zainstalowany lokalnie.
  • Przykładowa aplikacja.

Przykładowa aplikacja

Ten samouczek można ukończyć przy użyciu platformy Flask, Django lub FastAPI. Udostępniono przykładową aplikację dla każdego środowiska, która pomoże Ci śledzić ten samouczek. Pobierz lub sklonuj przykładową aplikację na lokalną stację roboczą.

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

Aby uruchomić aplikację lokalnie:

  1. Przejdź do folderu aplikacji:

    cd msdocs-python-flask-webapp-quickstart

  2. Utwórz środowisko wirtualne dla aplikacji:

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

  3. Zainstaluj zależności:

    pip install -r requirements.txt

  4. Uruchom aplikację:

    flask run

  5. Przejdź do przykładowej aplikacji pod adresem http://localhost:5000 w przeglądarce internetowej.

    zrzut ekranu przedstawiający aplikację Platformy Flask działającą lokalnie w przeglądarce

Dodawanie OpenTelemetry

Aby użyć pulpitu nawigacyjnego .NET Aspire z aplikacją Python, musisz zainstalować zestaw OpenTelemetry SDK i eksportera. Zestaw SDK OpenTelemetry udostępnia interfejs API do instrumentowania aplikacji, a eksporter wysyła dane telemetryczne do pulpitu nawigacyjnego .NET Aspire.

  1. Zainstaluj zestaw OpenTelemetry SDK i eksportera:

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

  2. Dodaj nowy plik do aplikacji o nazwie otlp_tracing.py i dodaj następujący 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. Zaktualizuj aplikację (app.py dla platformy Flask, main.py dla interfejsu FastAPI), aby uwzględnić importy i wywołać funkcję 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. Zastąp wywołania print wywołaniami logger.info w aplikacji.

  5. Uruchom ponownie aplikację.

Instrumentacja specyficzna dla platformy

Ta instrumentacja koncentruje się tylko na dodawaniu OpenTelemetry do naszego kodu. Aby uzyskać bardziej szczegółową instrumentację, możesz użyć pakietów instrumentacji OpenTelemetry dla określonych platform, których używasz.

  1. Zainstaluj pakiet instrumentacji platformy Flask:

    pip install opentelemetry-instrumentation-flask

  2. Dodaj następujący kod do aplikacji:

    from opentelemetry.instrumentation.flask import FlaskInstrumentor

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

Uruchamianie pulpitu nawigacyjnego Aspire

Aby uruchomić pulpit nawigacyjny Aspire w trybie autonomicznym, uruchom następujące polecenie Docker:

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

W dziennikach Docker zostanie wyświetlony punkt końcowy i klucz pulpitu nawigacyjnego. Skopiuj klucz i przejdź do http://localhost:18888 w przeglądarce internetowej. Wprowadź klucz, aby zalogować się do pulpitu nawigacyjnego.

Wyświetlanie dzienników strukturalnych

Nawiguj po aplikacji Python i zobaczysz dzienniki ustrukturyzowane na pulpicie nawigacyjnym Aspire. Na stronie z ustrukturyzowanymi dziennikami są wyświetlane dzienniki z aplikacji, a użytkownik może je filtrować i przeszukiwać.

Zrzut ekranu kokpitu Aspire pokazujący dzienniki aplikacji Python

Następne kroki

Pomyślnie użyto pulpitu nawigacyjnego .NET Aspire z aplikacją Python. Aby dowiedzieć się więcej na temat pulpitu nawigacyjnego .NET.NET Aspire, zapoznaj się z omówieniem pulpitu nawigacyjnego Aspire oraz sposobem organizowania aplikacji Python z użyciem hosta aplikacji .NET.NET Aspire.