Condividi tramite

Orchestrare app Python in .NET Aspire

Questo articolo illustra come usare le app Python in un host app .NET Aspire. L'app di esempio in questo articolo illustra l'avvio di un'applicazione Python. L'estensione Python per .NET Aspire richiede l'uso di ambienti virtuali.

Prerequisiti

Per usare .NET.NET Aspire, è necessario che il codice seguente sia installato in locale:

Per altre informazioni, vedere .NET.NET Aspire configurazione e strumentie .NET.NET Aspire SDK.

Inoltre, è necessario installare Python nel computer. L'app di esempio in questo articolo è stata compilata con Python versione 3.12.4 e pip versione 24.1.2. Per verificare le versioni Python e pip, eseguire i comandi seguenti:

python --version

pip --version

Per scaricare Python (incluso pip), vedere la pagina di download Python.

Creare un progetto .NET.NET Aspire usando il modello

Per iniziare a avviare un Python progetto in .NET Aspire, usare il modello di avvio per creare prima un .NET Aspire host dell'applicazione:

dotnet new aspire -o PythonSample

Nella stessa sessione del terminale modificare le directory nel progetto appena creato:

cd PythonSample

Dopo aver creato il modello, avviare l'host dell'app con il comando seguente per assicurarsi che l'host dell'app e il .NET.NET Aspire dashboard vengano eseguiti correttamente:

dotnet run --project ./PythonSample.AppHost/PythonSample.AppHost.csproj

Se il .NET.NET Aspire Dashboard non si apre, aprilo con il collegamento presente nell'output della console. A questo punto il dashboard non mostrerà alcuna risorsa. Arrestare l'host dell'app premendo CTRL+C nel terminale.

Prepara un'app Python

Dalla sessione del terminale precedente in cui è stata creata la soluzione .NET Aspire creare una nuova directory per contenere il codice sorgente Python.

mkdir hello-python

Modificare le directory nella directory hello-python appena creata:

cd hello-python

Inizializza l'ambiente virtuale Python

Per lavorare con le app Python, devono trovarsi all'interno di un ambiente virtuale. Per creare un ambiente virtuale, eseguire il comando seguente:

python -m venv .venv

Per altre informazioni sugli ambienti virtuali, vedere il Python: Installare pacchetti in un ambiente virtuale usando pip e venv.

Per attivare l'ambiente virtuale, abilitare l'installazione e l'utilizzo dei pacchetti, eseguire il comando seguente:

source .venv/bin/activate

Assicurarsi che pip all'interno dell'ambiente virtuale sia aggiornato eseguendo il comando seguente:

python -m pip install --upgrade pip

Installare pacchetti Python

Installare il pacchetto Flask creando un file requirements.txt nella directory hello-python e aggiungendo la riga seguente:

Flask==3.0.3

Installare quindi il pacchetto Flask eseguendo il comando seguente:

python -m pip install -r requirements.txt

Dopo aver installato Flask, creare un nuovo file denominato main.py nella directory hello-python e aggiungere il codice seguente:

import os
import flask

app = flask.Flask(__name__)

@app.route('/', methods=['GET'])
def hello_world():
    return 'Hello, World!'

if __name__ == '__main__':
    port = int(os.environ.get('PORT', 8111))
    app.run(host='0.0.0.0', port=port)

Il codice precedente crea una semplice app Flask che ascolta sulla porta 8111 e restituisce il messaggio "Hello, World!" quando si accede all'endpoint root.

Aggiornare il progetto host dell'app

Installare il pacchetto di hosting Python eseguendo il comando seguente:

dotnet add ../PythonSample.AppHost/PythonSample.AppHost.csproj package Aspire.Hosting.Python --version 9.0.0

Dopo l'installazione del pacchetto, il codice XML del progetto deve avere un nuovo riferimento al pacchetto simile all'esempio seguente:

<Project Sdk="Microsoft.NET.Sdk">

  <Sdk Name="Aspire.AppHost.Sdk" Version="9.2.0" />

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net9.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <UserSecretsId>5fd92a87-fff8-4a09-9f6e-2c0d656e25ba</UserSecretsId>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Aspire.Hosting.AppHost" Version="9.3.1" />
    <PackageReference Include="Aspire.Hosting.Python" Version="9.3.1" />
  </ItemGroup>

</Project>

Sostituire il codice dell'host dell'applicazione Program.cs con il seguente frammento di codice. Questo codice aggiunge il Python progetto a .NET Aspire chiamando l'API AddPythonApp e specificando il nome del progetto, il percorso del progetto e il file del punto di ingresso:

using Microsoft.Extensions.Hosting;

var builder = DistributedApplication.CreateBuilder(args);

#pragma warning disable ASPIREHOSTINGPYTHON001
var pythonapp = builder.AddPythonApp("hello-python", "../hello-python", "main.py")
       .WithHttpEndpoint(env: "PORT")
       .WithExternalHttpEndpoints()
       .WithOtlpExporter();
#pragma warning restore ASPIREHOSTINGPYTHON001

if (builder.ExecutionContext.IsRunMode && builder.Environment.IsDevelopment())
{
    pythonapp.WithEnvironment("DEBUG", "True");
}

builder.Build().Run();

Importante

Il codice precedente elimina l'errore ASPIREHOSTINGPYTHON001 di diagnostica. Questo errore viene generato perché l'API AddPythonApp è sperimentale e potrebbe cambiare in una versione futura. Per altre informazioni, vedere Errore del compilatore ASPIREHOSTINGPYTHON001.

Eseguire l'app

Dopo aver aggiunto il pacchetto di hosting Python, aggiornato l'host dell'app Program.cs file e creato un progetto di Python, è possibile eseguire l'host dell'app:

dotnet run --project ../PythonSample.AppHost/PythonSample.AppHost.csproj

Avviare il dashboard facendo clic sul collegamento nell'output della console. Il dashboard deve visualizzare il progetto Python come risorsa.

dashboard .NET Aspire: Python app di esempio.

Seleziona il link Endpoints per aprire l'endpoint hello-python in una nuova scheda del browser. Il browser dovrebbe visualizzare il messaggio "Hello, World!":

.NET Aspire dashboard: Python endpoint dell'app di esempio.

Arrestare l'host dell'app premendo CTRL + C nel terminale.

Aggiungere il supporto per i dati di telemetria

Per migliorare l'osservabilità, aggiungi dati di telemetria per monitorare l'app dipendente Python. Python Nel progetto aggiungere i pacchetti seguenti OpenTelemetry come dipendenza nel file requirements.txt:

Flask==3.0.3
opentelemetry-distro
opentelemetry-exporter-otlp-proto-grpc
opentelemetry-instrumentation-flask
gunicorn

Reinstallare quindi i requisiti dell'app Python nell'ambiente virtuale eseguendo il comando seguente:

python -m pip install -r requirements.txt

Il comando precedente installa il OpenTelemetry pacchetto e l'utilità di esportazione OTLP nell'ambiente virtuale. Aggiornare l'app Python per includere il codice OpenTelemetry, sostituendo il codice main.py esistente con il codice seguente:

import os
import logging
import flask
from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.instrumentation.flask import FlaskInstrumentor

app = flask.Flask(__name__)

trace.set_tracer_provider(TracerProvider())
otlpExporter = OTLPSpanExporter()
processor = BatchSpanProcessor(otlpExporter)
trace.get_tracer_provider().add_span_processor(processor)

FlaskInstrumentor().instrument_app(app)

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

@app.route('/', methods=['GET'])
def hello_world():
    logger.info("request received!")
    return 'Hello, World!'

if __name__ == '__main__':
    port = int(os.environ.get('PORT', 8111))
    debug = bool(os.environ.get('DEBUG', False))
    host = os.environ.get('HOST', '127.0.0.1')
    app.run(port=port, debug=debug, host=host)

Aggiornare il file dilaunchSettings.json del progetto host dell'app per includere la ASPIRE_ALLOW_UNSECURED_TRANSPORT variabile di ambiente nel http profilo:

{
  "$schema": "https://json.schemastore.org/launchsettings.json",
  "profiles": {
    "https": {
      "commandName": "Project",
      "dotnetRunMessages": true,
      "launchBrowser": true,
      "applicationUrl": "https://localhost:17171;http://localhost:15209",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development",
        "DOTNET_ENVIRONMENT": "Development",
        "ASPIRE_DASHBOARD_OTLP_ENDPOINT_URL": "https://localhost:21171",
        "ASPIRE_RESOURCE_SERVICE_ENDPOINT_URL": "https://localhost:22122"
      }
    },
    "http": {
      "commandName": "Project",
      "dotnetRunMessages": true,
      "launchBrowser": true,
      "applicationUrl": "http://localhost:15209",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development",
        "DOTNET_ENVIRONMENT": "Development",
        "ASPIRE_DASHBOARD_OTLP_ENDPOINT_URL": "http://localhost:19171",
        "ASPIRE_RESOURCE_SERVICE_ENDPOINT_URL": "http://localhost:20208",
        "ASPIRE_ALLOW_UNSECURED_TRANSPORT": "true"
      }
    }
  }
}

La variabile ASPIRE_ALLOW_UNSECURED_TRANSPORT è necessaria perché quando si esegue localmente il client OpenTelemetry in Python rifiuta il certificato di sviluppo locale. Avvia di nuovo l'host dell'app :

dotnet run --project ../PythonSample.AppHost/PythonSample.AppHost.csproj --launch-profile http

Importante

L'host .NET.NET Aspire dell'app deve essere eseguito usando HTTP anziché HTTPS. La OpenTelemetry libreria richiede HTTP durante l'esecuzione in un ambiente di sviluppo locale.

Quando l'host dell'app è in esecuzione, passare al dashboard e selezionare la scheda Registrazione strutturata . Si noti che ora contiene eventi di registrazione.

.NET Aspire dashboard: registrazione strutturata del processo di Python.

Sommario

Anche se esistono diverse considerazioni che esulano dall'ambito di questo articolo, hai imparato come sviluppare una soluzione .NET Aspire che si integra con Python. Si è anche appreso come usare l'API AddPythonApp per ospitare app Python.

Vedere anche