Sdílet prostřednictvím

Kurz: Použití řídicího panelu .NET Aspire s aplikacemi Python

  • Článek

Řídicí panel .NET.NET Aspire poskytuje skvělé uživatelské prostředí pro zobrazení telemetrie a je k dispozici jako samostatná image kontejneru, která se dá použít s libovolnou aplikací s podporou OpenTelemetry. V tomto článku se dozvíte, jak:

  • Spusťte řídicí panel .NET.NET Aspire v samostatném režimu.
  • Použijte řídicí panel .NET Aspire s aplikací Python.

Požadavky

K dokončení tohoto kurzu potřebujete následující:

  • Docker nebo Podman.
    • Můžete použít alternativní prostředí vykonávání kontejneru, ale příkazy v tomto článku platí pro Docker.
  • Python 3.9 nebo vyšší místně nainstalované.
  • Ukázková aplikace.

Ukázková aplikace

Tento kurz je možné dokončit pomocí Flask, Django nebo FastAPI. K dispozici je ukázková aplikace v jednotlivých architekturách, která vám pomůže postupovat spolu s tímto kurzem. Stáhněte nebo naklonujte ukázkovou aplikaci do místní pracovní stanice.

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

Místní spuštění aplikace:

  1. Přejděte do složky aplikace:

    cd msdocs-python-flask-webapp-quickstart

  2. Vytvořte pro aplikaci virtuální prostředí:

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

  3. Nainstalujte závislosti:

    pip install -r requirements.txt

  4. Spusťte aplikaci:

    flask run

  5. Ve webovém prohlížeči přejděte na ukázkovou aplikaci na http://localhost:5000.

    snímek obrazovky aplikace Flask spuštěné místně v prohlížeči

Přidání OpenTelemetry

Pokud chcete používat řídicí panel .NET Aspire s aplikací Python, musíte nainstalovat sadu OpenTelemetry SDK a exportér. Sada OpenTelemetry SDK poskytuje rozhraní API pro instrumentaci aplikace a exportér odesílá telemetrická data na řídicí panel .NET Aspire.

  1. Nainstalujte OpenTelemetry SDK a exportér:

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

  2. Do aplikace přidejte nový soubor s názvem otlp_tracing.py a přidejte následující kód:

    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. Aktualizujte aplikaci (app.py pro Flask, main.py pro FastAPI), aby zahrnovala importy a volala funkci 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. Nahraďte print voláními logger.info ve vaší aplikaci.

  5. Restartujte aplikaci.

Instrumentace specifická pro rámec

Tato instrumentace se zaměřuje pouze na přidání OpenTelemetry do našeho kódu. Pro podrobnější instrumentaci můžete použít balíčky OpenTelemetry Instrumentace pro konkrétní architektury, které používáte.

  1. Nainstalujte balíček instrumentace Flask:

    pip install opentelemetry-instrumentation-flask

  2. Do aplikace přidejte následující kód:

    from opentelemetry.instrumentation.flask import FlaskInstrumentor

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

Spusťte řídicí panel Aspire

Pokud chcete spustit řídicí panel Aspire v samostatném režimu, spusťte následující příkaz Docker:

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

V protokolech Docker se zobrazí koncový bod a klíč řídicího panelu. Zkopírujte klíč a přejděte do http://localhost:18888 ve webovém prohlížeči. Zadejte klíč pro přihlášení k řídicímu panelu.

Zobrazení strukturovaných protokolů

Procházejte aplikací Python a na řídicím panelu Aspire uvidíte strukturované protokoly. Na stránce strukturovaných protokolů se zobrazují protokoly z vaší aplikace a můžete protokoly filtrovat a prohledávat.

snímek obrazovky řídicího panelu Aspire zobrazující protokoly Python aplikací

Další kroky

Úspěšně jste použili řídicí panel .NET Aspire s aplikací Python. Pro podrobnější informace o řídicím panelu .NET.NET Aspire si přečtěte přehled řídicího panelu Aspire, a jak orchestrovat aplikaci Python pomocí hostitele aplikace .NET.NET Aspire.