Partager via

Orchestrer les applications Python dans .NET Aspire

Dans cet article, vous allez apprendre à utiliser des applications Python dans un hôte d’application .NET Aspire. L’exemple d’application de cet article illustre le lancement d’une application Python. L’extension Python pour .NET Aspire nécessite l’utilisation d’environnements virtuels.

Conditions préalables

Pour utiliser .NET.NET Aspire, vous avez besoin de l’installation locale suivante :

Pour plus d'informations, consultez la configuration et les outils de .NET.NET Aspire, ainsi que le SDK de .NET.NET Aspire.

En outre, vous devez installer Python sur votre ordinateur. L’exemple d’application de cet article a été créé avec Python version 3.12.4 et pip version 24.1.2. Pour vérifier vos versions Python et pip, exécutez les commandes suivantes :

python --version

pip --version

Pour télécharger Python (y compris pip), consultez la page de téléchargement Python.

Créer un projet .NET.NET Aspire à l’aide du modèle

Pour commencer à lancer un projet Python dans .NET Aspire, utilisez le modèle de démarrage pour d'abord créer un hôte d'application .NET Aspire.

dotnet new aspire -o PythonSample

Dans la même session de terminal, modifiez les répertoires dans le projet nouvellement créé :

cd PythonSample

Une fois le modèle créé, lancez l’hôte d’application avec la commande suivante pour vous assurer que l’hôte de l’application et le .NET.NET Aspire tableau de bord s’exécutent correctement :

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

Si le .NET.NET Aspire tableau de bord ne s’ouvre pas, ouvrez-le avec le lien dans la sortie de la console. À ce stade, le tableau de bord n’affiche aucune ressource. Arrêtez l’hôte de l’application en appuyant sur Ctrl + C dans le terminal.

Préparer une application Python

À partir de votre session de terminal précédente où vous avez créé la solution .NET Aspire, créez un répertoire pour contenir le code source Python.

mkdir hello-python

Modifiez les répertoires dans le répertoire hello-python nouvellement créé :

cd hello-python

Initialiser l’environnement virtuel Python

Pour utiliser des applications Python, elles doivent se trouver dans un environnement virtuel. Pour créer un environnement virtuel, exécutez la commande suivante :

python -m venv .venv

Pour plus d’informations sur les environnements virtuels, consultez la Python: installer des packages dans un environnement virtuel à l’aide de pip et venv.

Pour activer l’environnement virtuel, activez l’installation et l’utilisation des packages, exécutez la commande suivante :

source .venv/bin/activate

Vérifiez que pip dans l’environnement virtuel est up-to-date en exécutant la commande suivante :

python -m pip install --upgrade pip

Installer des packages Python

Installez le paquet Flask en créant un fichier requirements.txt dans le répertoire hello-python et en ajoutant la ligne suivante :

Flask==3.0.3

Ensuite, installez le package Flask en exécutant la commande suivante :

python -m pip install -r requirements.txt

Une fois Flask installé, créez un fichier nommé main.py dans le répertoire hello-python et ajoutez le code suivant :

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)

Le code précédent crée une application Flask simple qui écoute sur le port 8111 et retourne le message "Hello, World!" lorsque le point de terminaison racine est accessible.

Mettre à jour le projet hôte d’application

Installez le package d’hébergement Python en exécutant la commande suivante :

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

Une fois le package installé, le code XML du projet doit avoir une nouvelle référence de package similaire à l’exemple suivant :

<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>

Remplacez le code de l'hôte d'application Program.cs par le code suivant. Ce code ajoute le Python projet en .NET Aspire appelant l’API AddPythonApp et en spécifiant le nom du projet, le chemin du projet et le fichier de point d’entrée :

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();

Important

Le code précédent supprime l’erreur ASPIREHOSTINGPYTHON001 de diagnostic. Cette erreur est générée, car l’API AddPythonApp est expérimentale et peut changer dans la version ultérieure. Pour plus d’informations, consultez Erreur du compilateur ASPIREHOSTINGPYTHON001.

Exécuter l’application

Maintenant que vous avez ajouté le package d’hébergement Python, mis à jour l’hôte de l’application Program.cs fichier et créé un projet Python, vous pouvez exécuter l’hôte de l’application :

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

Lancez le tableau de bord en cliquant sur le lien dans la sortie de la console. Le tableau de bord doit afficher le projet Python en tant que ressource.

tableau de bord .NET Aspire : Python exemple d’application.

Sélectionnez le lien Points de terminaison pour ouvrir le point de terminaison hello-python dans un nouvel onglet de navigateur. Le navigateur doit afficher le message « Hello, World ! » :

.NET Aspire tableau de bord : Python exemple de point de terminaison d’application.

Arrêtez l’hôte de l’application en appuyant sur Ctrl + C dans le terminal.

Ajouter la prise en charge des données de télémétrie

Pour ajouter un peu d’observabilité, ajoutez des données de télémétrie pour surveiller l’application Python dépendante. Dans le Python projet, ajoutez les packages suivants OpenTelemetry en tant que dépendance dans le fichier requirements.txt :

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

Ensuite, réinstallez les exigences de l’application Python dans l’environnement virtuel en exécutant la commande suivante :

python -m pip install -r requirements.txt

La commande précédente installe le OpenTelemetry package et l’exportateur OTLP , dans l’environnement virtuel. Mettez à jour l’application Python pour inclure le code OpenTelemetry, en remplaçant le code main.py existant par les éléments suivants :

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)

Mettez à jour le fichier launchSettings.json du projet hôte d’application pour inclure la ASPIRE_ALLOW_UNSECURED_TRANSPORT variable d’environnement sous le http profil :

{
  "$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 variable ASPIRE_ALLOW_UNSECURED_TRANSPORT est requise, car lorsque le client OpenTelemetry est exécuté localement dans Python, il rejette le certificat de développement local. Relancez l'hôte de l'application à nouveau.

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

Important

L’hôte .NET.NET Aspire de l’application doit être exécuté à l’aide de HTTP au lieu de HTTPS. La OpenTelemetry bibliothèque nécessite HTTP lors de l’exécution dans un environnement de développement local.

Une fois l’hôte de l’application en cours d’exécution, accédez au tableau de bord et sélectionnez l’onglet Journalisation structurée . Notez qu’il contient désormais des événements de journalisation.

Tableau de bord .NET Aspire : journalisation structurée de processus Python.

Résumé

Bien qu’il existe plusieurs considérations qui dépassent la portée de cet article, vous avez appris à créer .NET Aspire solution qui s’intègre à Python. Vous avez également appris à utiliser l’API AddPythonApp pour héberger des applications Python.

Voir aussi