Lire en anglais

Partager via

Nouveautés de .NET.NET Aspire 9.0

  • Article

📢 .NET Aspire 9.0 est la prochaine version majeure en disponibilité générale de .NET Aspire; il prend en charge les deux:

  • .NET 8.0 Support à long terme (LTS) ou
  • .NET Soutien à Terme Standard 9.0 (STS).

Notes

Vous pouvez utiliser .NET Aspire 9,0 avec .NET 8 ou .NET 9 !

Cette version traite de certaines des fonctionnalités les plus demandées et des points de douleur de la communauté. Les meilleures fonctionnalités sont pilotées par la communauté ! Pour rejoindre la communauté, visitez-nous sur Discord pour discuter avec les membres de l’équipe et collaborer avec nous sur GitHub.

Pour plus d’informations sur la version officielle .NET et la prise en charge des versions .NET Aspire, consultez :

Mise à niveau vers .NET.NET Aspire 9

Pour effectuer une mise à niveau à partir de versions antérieures de .NET Aspire vers .NET Aspire 9, suivez les instructions du guide officiel Mise à niveau vers .NET.NET Aspire 9. Le guide fournit des instructions détaillées sur la mise à niveau de vos solutions .NET Aspire existantes vers .NET Aspire 9. Que vous le fassiez manuellement ou à l'aide de l'Assistant Mise à niveau, le guide facilite grandement le processus.

Améliorations apportées aux outils

.NET Aspire 9 simplifie la configuration de votre environnement pour développer des applications .NET Aspire. Vous n’avez plus besoin d’une charge de travail .NET. Au lieu de cela, vous installez le nouveau sdk .NET.NET Aspire dans le projet hôte d’application de vos solutions .NET.NET Aspire. Pour plus d’informations, consultez .NET.NET Aspire configuration et les outils.

Les modèles ont été déplacés

.NET .NET Aspire 9 déplace vers des packages NuGet distincts le contenu qui était auparavant installé via la charge de travail. Cela inclut les modèles permettant de créer de nouveaux projets et solutions .NET.NET Aspire. Ces modèles sont installés à l’aide de la commande dotnet new install. Celles-ci peuvent être installées en exécutant la commande suivante :

CLI .NET 
dotnet new install Aspire.ProjectTemplates::9.0.0

Conseil

Si la charge de travail .NET.NET Aspire est déjà installée, vous devez passer l’indicateur de --force pour remplacer les modèles existants. N’hésitez pas à désinstaller la charge de travail .NET.NET Aspire.

Pour plus d’informations, consultez .NET.NET Aspire modèles.

Améliorations de l’expérience utilisateur du tableau de bord et nouvelles fonctionnalités d’interactivité

Le tableau de bord .NET.NET Aspire continue à s’améliorer avec chaque version.

Gérer le cycle de vie des ressources

La fonctionnalité la plus demandée pour le tableau de bord consiste à gérer les cycles de vie de vos ressources nommées orchestrées. Plus précisément, la possibilité d’arrêter, de démarrer et de redémarrer des ressources. Cette fonctionnalité fonctionne pour les projets, les conteneurs et les exécutables. Il permet de redémarrer des ressources individuelles sans avoir à redémarrer l’hôte d’application entier. Pour les ressources de projet, lorsque le débogueur est attaché, il est réattaché lors du redémarrage. Pour plus d’informations, consultez .NET.NET Aspire tableau de bord : Arrêter ou démarrer une ressource.

Support mobile et réactif

Le tableau de bord .NET Aspire est désormais adapté aux appareils mobiles, s'adapte de manière réactive à un large éventail de tailles d'écran et permet la gestion en déplacement des applications déployées .NET Aspire. D'autres améliorations de l'accessibilité ont été apportées, notamment l'affichage des paramètres et la gestion du contenu en débordement sur les appareils mobiles.

Propriétés sensibles, volumes et contrôles de santé dans les détails de la ressource

L’affichage des détails de la ressource contient plusieurs améliorations :

  • Les propriétés peuvent être marquées comme sensibles, les masquant automatiquement dans l’interface utilisateur du tableau de bord. Cette fonctionnalité de sécurité permet d’éviter de divulguer accidentellement des clés ou des mots de passe lors du partage d’écran du tableau de bord avec d’autres personnes. Par exemple, les arguments de conteneur peuvent transmettre des informations sensibles et sont donc masqués par défaut.

  • Les volumes de conteneurs configurés sont répertoriés dans les détails de la ressource.

  • .NET .NET Aspire 9 ajoute la prise en charge des vérifications de santé. Des informations détaillées sur ces vérifications peuvent désormais être affichées dans le volet détails de la ressource, montrant pourquoi une ressource peut être marquée comme non saine ou détériorée. En savoir plus sur les vérifications d’intégrité ici.

Journal de console coloré

codes d’échappement ANSI mettre en forme le texte dans les terminaux en contrôlant les couleurs (premier plan et arrière-plan) et les styles tels que gras, soulignement et italique. Auparavant, la page de journaux de la console du tableau de bord ne pouvait afficher qu’un seul code d’échappement ANSI à la fois et échouait lorsque plusieurs codes étaient combinés. Par exemple, il peut afficher du texte rouge, mais pas du texte qui était rouge et gras.

Une contribution communautaire de @mangeg qui a amélioré la prise en charge des codes d'échappement ANSI et supprimé cette limitation.

journaux de console colorés

Une autre amélioration des journaux de la console masque les codes d’échappement non pris en charge. Les codes qui ne sont pas liés à l’affichage du texte, tels que le positionnement du curseur ou la communication avec le système d’exploitation, n’ont pas de sens dans cette interface utilisateur et sont masqués.

Ajouts centrés sur les utilisateurs de télémétrie

de télémétrie reste un aspect essentiel de .NET.NET Aspire. Dans .NET.NET Aspire 9, de nombreuses nouvelles fonctionnalités ont été introduites dans le service télémétrie.

Filtrage amélioré des données de télémétrie

Les traces peuvent être filtrées avec des valeurs d’attribut. Par exemple, si vous souhaitez uniquement afficher les traces d’un point de terminaison dans votre application, l’attribut http.route sur les requêtes HTTP peut être filtré sur une valeur spécifiée.

Le filtrage de télémétrie prend également en charge la complétion automatique des valeurs existantes. La boîte de dialogue Ajouter un filtre fournit une zone de liste déroulante permettant de sélectionner parmi les valeurs disponibles dans le tableau de bord. Cette fonctionnalité facilite beaucoup le filtrage des données réelles et permet d’éviter les fautes de frappe en entrant une valeur vous-même.

Pour plus d’informations, consultez le tableau de bord .NET.NET Aspire : Filtrer les traces.

Combiner des données de télémétrie à partir de plusieurs ressources

Lorsqu’une ressource a plusieurs réplicas, vous pouvez désormais filtrer les données de télémétrie pour afficher les données de toutes les instances à la fois. Sélectionnez la ressource parente, étiquetée (application). Pour plus d’informations, consultez .NET.NET Aspire tableau de bord : Combiner les données de télémétrie à partir de plusieurs ressources.

Prise en charge des données de télémétrie du navigateur

Le tableau de bord prend en charge le protocole OTLP (OpenTelemetry) sur HTTP et le partage de ressources entre origines (CORS). Ces fonctionnalités permettent d’envoyer des OpenTelemetry à partir d’applications de navigateur au tableau de bord .NET Aspire.

Par exemple, une application monopage basée sur navigateur peut configurer le kit de développement logiciel (SDK) JavaScript OpenTelemetry pour envoyer des journaux structurés, des traces et des métriques créés dans le navigateur au tableau de bord. Les données de télémétrie du navigateur s’affichent en même temps que les données de télémétrie du serveur.

page de détails de trace avec de télémétrie du navigateur

Pour plus d’informations sur la configuration des données de télémétrie du navigateur, consultez la documentation Enable browser telemetry.

Hôte d’application (orchestration)

Le hôte d’application est l’une des fonctionnalités les plus importantes de . Dans .NET.NET Aspire 9, plusieurs nouvelles fonctionnalités spécifiques ont été ajoutées à l’hôte de l’application.

Attente des dépendances

Si vous avez suivi .NET.NET Aspire, vous savez déjà que votre projet hôte d’application est l’emplacement où vous définissez votre modèle d’application. Vous créez un générateur d’applications distribuées, ajoutez et configurez des ressources et exprimez leurs dépendances. À présent, vous pouvez spécifier qu’une ressource doit attendre pour une autre ressource avant de commencer. Cela peut vous aider à éviter les erreurs de connexion au démarrage en démarrant uniquement les ressources lorsque leurs dépendances sont « prêtes ».

C# 
var builder = DistributedApplication.CreateBuilder(args);

var rabbit = builder.AddRabbitMQ("rabbit");

builder.AddProject<Projects.WebApplication1>("api")
       .WithReference(rabbit)
       .WaitFor(rabbit); // Don't start "api" until "rabbit" is ready...

builder.Build().Run();

Lorsque l’hôte de l’application démarre, il attend que la ressource rabbit soit prête avant de démarrer la ressource api.

Deux méthodes sont présentées pour attendre une ressource :

  • WaitFor: attendez qu’une ressource soit prête avant de démarrer une autre ressource.
  • WaitForCompletion: attendez qu’une ressource se termine avant de démarrer une autre ressource.

Pour plus d’informations, consultez .NET.NET Aspire hôte d’application : attente des ressources.

Vérifications d’intégrité des ressources

L’API WaitFor utilise des contrôles d’intégrité standard .NET pour déterminer si une ressource est prête. Mais que signifie « une ressource prête » ? La meilleure partie est, c’est configurable par le consommateur au-delà de ses valeurs par défaut.

Lorsqu’une ressource n’expose aucun contrôle d’intégrité (aucun contrôle d’intégrité inscrit dans l’application), l’hôte de l’application attend que la ressource soit dans l’état Running avant de démarrer la ressource dépendante.

Pour les ressources qui exposent des points de terminaison HTTP, vous pouvez facilement ajouter une vérification d’intégrité qui interroge un chemin spécifique pour une réponse HTTP 200.

C# 
var builder = DistributedApplication.CreateBuilder(args);

var catalogApi = builder.AddContainer("catalog-api", "catalog-api")
                        .WithHttpEndpoint(targetPort: 8080)
                        .WithHttpHealthCheck("/health");

builder.AddProject<Projects.WebApplication1>("store")
       .WithReference(catalogApi.GetEndpoint("http"))
       .WaitFor(catalogApi);

builder.Build().Run();

L’exemple précédent ajoute un contrôle d’intégrité à la ressource catalog-api. L’hôte de l’application attend que le contrôle d’intégrité retourne un statut sain avant de démarrer la ressource store. Elle détermine que la ressource est prête lorsque le point de terminaison /health retourne un code d’état HTTP 200.

Bien que store attende que catalog-api devienne sain, les ressources du tableau de bord apparaissent comme suit :

En attente d’une ressource défectueuse avant de démarrer

Le mécanisme de contrôle d’intégrité de l’hôte d’application s’appuie sur l’implémentation IHealthChecksBuilder à partir de l’espace de noms Microsoft.Extensions.Diagnostics.HealthChecks.

Données du rapport de contrôle d’intégrité, qui sont affichées dans le tableau de bord :

Détails de la vérification d'intégrité dans la vue des détails des ressources du tableau de bord

La création d’une vérification de santé personnalisée est simple. Commencez par définir la vérification d’intégrité, puis associez son nom à toutes les ressources auxquelles elle s’applique.

C# 
var builder = DistributedApplication.CreateBuilder(args);

var healthyAfter = DateTime.Now.AddSeconds(20);

builder.Services.AddHealthChecks().AddCheck(
    "delay20secs",
    () => DateTime.Now > healthyAfter 
        ? HealthCheckResult.Healthy() 
        : HealthCheckResult.Unhealthy()
    );

var cache = builder.AddRedis("cache")
                   .WithHealthCheck("delay20secs");

builder.AddProject<Projects.MyApp>("myapp")
       .WithReference(cache)
       .WaitFor(cache);

L’exemple précédent ajoute un contrôle d’intégrité à la ressource cache, qui la signale en mauvaise santé pendant les 20 premières secondes après le démarrage de l'hôte d'application. Par conséquent, la ressource myapp attend 20 secondes avant de commencer, ce qui garantit que la ressource cache est saine.

Les méthodes AddCheck et WithHealthCheck fournissent un mécanisme simple pour créer des vérifications d'état et les associer à des ressources spécifiques.

Conteneurs persistants

L’hôte de l'application prend désormais en charge des conteneurs persistants et. Les conteneurs persistants s’écartent du cycle de vie classique des conteneurs des applications .NET.NET Aspire orchestrées. Bien qu’ils soient créés et démarrés (lorsqu’ils ne sont pas déjà disponibles) par l’orchestrateur .NET Aspire, ils ne sont pas détruits par .NET Aspire.

Cela est utile lorsque vous souhaitez conserver le conteneur en cours d’exécution même après l’arrêt de l’hôte de l’application.

Important

Pour supprimer ces conteneurs, vous devez les arrêter manuellement à l’aide du runtime de conteneur.

Pour définir un IResourceBuilder<ContainerResource> avec une durée de vie persistante, appelez la méthode WithLifetime et transmettez ContainerLifetime.Persistent:

C# 
var builder = DistributedApplication.CreateBuilder(args);

var queue = builder.AddRabbitMQ("rabbit")
                   .WithLifetime(ContainerLifetime.Persistent);

builder.AddProject<Projects.WebApplication1>("api")
       .WithReference(queue)
       .WaitFor(queue);

builder.Build().Run();

Le tableau de bord affiche des conteneurs persistants avec une icône d’épingle :

conteneurs persistants

Une fois l’hôte de l’application arrêté, le conteneur continue à s’exécuter :

Docker bureau affichant RabbitMQ.

Le mécanisme de persistance du conteneur tente d’identifier quand vous souhaiterez peut-être recréer le conteneur. Par exemple, si l’environnement pour le conteneur change, le conteneur est redémarré afin que vous n’ayez pas besoin d’arrêter manuellement le conteneur si la configuration d’entrée de la ressource a changé.

Commandes de ressources

L’hôte de l’application prend en charge l’ajout de commandes personnalisées aux ressources. Cela est utile lorsque vous souhaitez ajouter des fonctionnalités personnalisées qui ne sont pas prises en charge en mode natif par l’hôte de l’application. Il existe probablement de nombreuses opportunités où l’exposition de méthodes d’extension personnalisées sur les ressources sera utile. Le .NET.NET Aspire Community Toolkit peut être un bon endroit pour partager ces extensions.

Lorsque vous définissez une commande personnalisée, elle est disponible dans le tableau de bord en tant que fonctionnalité d’expérience utilisateur.

Important

Ces .NET.NET Aspire commandes de tableau de bord sont disponibles uniquement lors de l’exécution du tableau de bord localement. Ils ne sont pas disponibles lors de l’exécution du tableau de bord dans Azure Container Apps.

Pour plus d’informations sur la création de commandes de ressources personnalisées, consultez Procédure : Créer des commandes de ressources personnalisées dans .NET.NET Aspire.

Mise en réseau de conteneurs

L’hôte d’application ajoute désormais tous les conteneurs à un réseau commun nommé default-aspire-network. Cela est utile lorsque vous souhaitez communiquer entre des conteneurs sans passer par le réseau hôte. Cela facilite également la migration de docker compose vers l’hôte d’application, car les conteneurs peuvent communiquer entre eux à l’aide du nom du conteneur.

Modèle d'événements

Le modèle d’événements permet aux développeurs de se connecter au cycle de vie de l’application et des ressources. Cela est utile pour exécuter du code personnalisé à des points spécifiques dans le cycle de vie de l’application. Il existe différentes façons de s’abonner à des événements, notamment des événements globaux et des événements par ressource.

Événements globaux :

  • BeforeStartEvent: événement déclenché avant le démarrage de l’application. Il s’agit du dernier endroit où les modifications apportées au modèle d’application sont observées. Cela s’exécute dans les modes « Exécuter » et « Publier ». Il s’agit d’un événement bloquant, ce qui signifie que l’application ne démarre pas tant que tous les gestionnaires n’ont pas terminé.
  • AfterResourcesCreatedEvent: événement déclenché après la création des ressources. Cela s’exécute uniquement en mode Exécution.
  • AfterEndpointsAllocatedEvent: Un événement déclenché après l’allocation des points de terminaison pour l'ensemble des ressources. Cela s’exécute uniquement en mode Exécution.

Les événements globaux sont analogues aux événements de cycle de vie de l’hôte d’application. Pour plus d'informations, consultez les cycles de vie de l'hôte d'application.

événements par ressource :

  • BeforeResourceStartedEvent: événement déclenché avant le démarrage d’une ressource unique. Cela s’exécute uniquement en mode Exécution. Il s’agit d’un événement bloquant, ce qui signifie que la ressource ne démarre pas tant que tous les gestionnaires ne sont pas terminés.
  • ConnectionStringAvailableEvent: événement déclenché lorsqu’une chaîne de connexion est disponible pour une ressource. Cela s’exécute uniquement en mode Exécution.
  • ResourceReadyEvent: événement déclenché lorsqu’une ressource est prête à être utilisée. Cela s’exécute uniquement en mode Exécution.

Pour plus d’informations, consultez Eventing dans .NET.NET Aspire.

Intégrations

.NET .NET Aspire continue d’ajouter des intégrations qui facilitent la prise en main de vos services et outils favoris. Pour plus d’informations, consultez .NET.NET Aspire vue d’ensemble des intégrations.

Redis Insight

Le support pour Redis Insights est disponible sur une ressource Redis.

C# 
var builder = DistributedApplication.CreateBuilder(args);

builder.AddRedis("redis")
       .WithRedisInsight(); // Starts a Redis Insight container image
                            // that is pre-configured to work with the
                            // Redis instance.

La méthode d’extension WithRedisInsight peut être appliquée à plusieurs ressources Redis et chacune d’elles sera visible sur le tableau de bord Redis Insight.

tableau de bord Redis Insight montrant plusieurs instances Redis

Pour plus d’informations, consultez Ajouter une ressource Redis avec Redis Insights.

OpenAI (préversion)

À partir de .NET Aspire 9, une intégration supplémentaire OpenAI est disponible, ce qui permet d’utiliser directement la dernière bibliothèque dotnet OpenAI officielle. L'intégration du OpenAIClient l'inscrit comme un service singleton dans la collection de services. Le client peut être utilisé pour interagir avec l’API OpenAIREST.

De plus, l’intégration .NET AspireAzureOpenAI déjà disponible a été améliorée pour fournir un moyen flexible de configurer un OpenAIClient pour un service Azure AI OpenAI ou une API OpenAIREST dédiée avec la nouvelle méthode de générateur de AddOpenAIClientFromConfiguration(IHostApplicationBuilder, String). L’exemple suivant détecte si la chaîne de connexion concerne un service AzureAzure AI OpenAI et inscrit automatiquement l’instance OpenAIClient la plus appropriée.

C# 
builder.AddOpenAIClientFromConfiguration("openai");

Par exemple, si la connexion openai ressemble à Endpoint=https://{account}.azure.com;Key={key}; il peut deviner qu’elle peut inscrire un client AzureAzure AI OpenAI en raison du nom de domaine. Sinon, une OpenAIClient courante serait utilisée.

Consultez la résolution client agnostique pour plus de détails .

MongoDB

Ajout de la prise en charge de la définition du nom d’utilisateur et du mot de passe MongoDB lors de l’utilisation de la méthode d’extension AddMongoDB(IDistributedApplicationBuilder, String, Nullable<Int32>, IResourceBuilder<ParameterResource>, IResourceBuilder<ParameterResource>). S’il n’est pas spécifié, un nom d’utilisateur et un mot de passe aléatoires sont générés, mais peuvent être spécifiés manuellement à l’aide de ressources de paramètre.

C# 
var builder = DistributedApplication.CreateBuilder(args);

var username = builder.AddParameter("mongousername");
var password = builder.AddParameter("mongopassword", secret: true);

var db = builder.AddMongo("db", username, password);

Améliorations importantes Azure

Les sections suivantes décrivent Azure améliorations ajoutées dans .NET Aspire 9. Pour la liste complète des modifications majeures, consultez Modifications majeures dans .NET.NET Aspire 9.

Personnalisation des ressources Azure

Dans .NET Aspire 8, la personnalisation des ressources Azure ont été marquées expérimentales, car les bibliothèques de Azure.Provisioning sous-jacentes étaient nouvelles et collectaient des commentaires avant qu’elles ne soient marquées comme stables. Dans .NET.NET Aspire 9 ces API ont été mises à jour et suppriment l’attribut expérimental.

Azure Changement de nommage des ressources incompatible

Dans le cadre de la mise à jour des bibliothèques Azure.Provisioning, le schéma d’affectation de noms par défaut pour Azure ressources a été mis à jour avec une meilleure prise en charge des différentes stratégies d’affectation de noms. Toutefois, cette mise à jour a entraîné une modification de la façon dont les ressources sont nommées. La nouvelle stratégie de nommage peut entraîner l’abandon des ressources Azure existantes et la création de nouvelles ressources Azure, après la mise à jour de votre application .NET Aspire de 8 à 9. Pour continuer à utiliser les mêmes politiques de dénomination 8, vous pouvez ajouter le code suivant à Program.csdans votre AppHost :

C# 
var builder = DistributedApplication.CreateBuilder(args);

builder.Services.Configure<AzureProvisioningOptions>(options =>
{
    options.ProvisioningBuildOptions.InfrastructureResolvers.Insert(0, new AspireV8ResourceNamePropertyResolver());
});

Azure SQL, PostgreSQLet mise à jour de Redis

Azure SQL, PostgreSQLet les ressources Redis sont différentes des autres ressources Azure, car il existe des ressources de conteneur locales pour ces technologies. Dans .NET Aspire 8, afin de créer ces ressources Azure, vous deviez commencer par une ressource de conteneur locale, puis l'« As » ou « PublishAs » en une ressource Azure. Cette conception a introduit des problèmes et ne s’est pas adaptée à d’autres API.

Par exemple, vous pouvez avoir ce code dans .NET.NET Aspire 8 :

C# 
var builder = DistributedApplication.CreateBuilder(args);

var sql = builder.AddSqlServer("sql")
                 .PublishAsAzureSqlDatabase();

var pgsql = builder.AddPostgres("pgsql")
                   .PublishAsAzurePostgresFlexibleServer();

var cache = builder.AddRedis("cache")
                   .PublishAsAzureSqlDatabase();

Dans .NET.NET Aspire 9 api suivantes ont été marquées comme obsolètes et un nouveau modèle d’API implémenté :

C# 
var builder = DistributedApplication.CreateBuilder(args);

var sql = builder.AddAzureSqlServer("sql")
                 .RunAsContainer();

var pgsql = builder.AddAzurePostgresFlexibleServer("pgsql")
                   .RunAsContainer();

var cache = builder.AddAzureRedis("cache")
                   .RunAsContainer();
Microsoft Entra ID par défaut

Pour rendre les applications .NET Aspire plus sécurisées, Azure Base de données pour PostgreSQL et les ressources Azure Cache for Redis ont été mises à jour pour utiliser l’ID Microsoft Entra par défaut. Cela nécessite des modifications apportées aux applications qui doivent se connecter à ces ressources. Consultez les rubriques suivantes pour mettre à jour les applications afin d’utiliser l’ID Microsoft Entra pour se connecter à ces ressources :

Les exemples suivants montrent comment configurer votre application pour se connecter aux ressources Azure à l’aide de l’ID Microsoft Entra :

Si vous devez utiliser l'authentification par mot de passe ou clé d’accès (non recommandé), vous pouvez activer cette option avec le code suivant :

C# 
var builder = DistributedApplication.CreateBuilder(args);

var pgsql = builder.AddAzurePostgresFlexibleServer("pgsql")
                   .WithPasswordAuthentication();

var cache = builder.AddAzureRedis("cache")
                   .WithAccessKeyAuthentication();

Prise en charge des Fonctions Azure (Version préliminaire)

La prise en charge des Azure Functions est l'une des fonctionnalités les plus demandées sur le suivi des problèmes .NET.NET Aspire, et nous sommes heureux d'introduire aujourd'hui le support en préversion dans cette version. Pour illustrer cette prise en charge, utilisons .NET.NET Aspire pour créer et déployer un webhook.

Pour commencer, créez un projet Azure Functions à l’aide de la boîte de dialogue Visual Studio Nouveau projet. Lorsque vous y êtes invité, cochez la case Enrôler dans Aspire orchestration lors de la création du projet.

Créer un projet de Fonctions .NET AspireAzure.

Dans le projet hôte de l'application, observez qu’il existe une PackageReference au nouveau 📦Aspire.Hosting.Azure.Fonctions package NuGet:

XML 
<ItemGroup>
    <PackageReference Include="Aspire.Hosting.AppHost" Version="9.0.0" />
    <PackageReference Include="Aspire.Hosting.Azure.Functions" Version="9.0.0" />
</ItemGroup>

Ce package fournit une API AddAzureFunctionsProject<TProject>(IDistributedApplicationBuilder, String) qui peut être appelée dans l'hôte de l'application pour configurer les projets Functions Azure au sein d'un hôte .NET Aspire.

C# 
var builder = DistributedApplication.CreateBuilder(args);

builder.AddAzureFunctionsProject<Projects.PigLatinApp>("piglatinapp");

builder.Build().Run();

Dans cet exemple, le webhook est chargé de traduire une chaîne d’entrée en Pig Latin. Mettez à jour le contenu de notre déclencheur avec le code suivant :

C# 
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;
using System.Text;
using FromBodyAttribute = Microsoft.Azure.Functions.Worker.Http.FromBodyAttribute;

namespace PigLatinApp;

public class Function1(ILogger<Function1> logger)
{
    public record InputText(string Value);
    public record PigLatinText(string Value);

    [Function("Function1")]
    public IActionResult Run(
        [HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequest req,
        [FromBody] InputText inputText)
    {
        logger.LogInformation("C# HTTP trigger function processed a request.");

        var result = TranslateToPigLatin(inputText.Value);

        return new OkObjectResult(new PigLatinText(result));
    }

    private static string TranslateToPigLatin(string input)
    {
        if (string.IsNullOrEmpty(input))
        {
            return input;
        }

        var words = input.Split(' ');
        StringBuilder pigLatin = new();

        foreach (string word in words)
        {
            if (IsVowel(word[0]))
            {
                pigLatin.Append(word + "yay ");
            }
            else
            {
                int vowelIndex = FindFirstVowelIndex(word);
                if (vowelIndex is -1)
                {
                    pigLatin.Append(word + "ay ");
                }
                else
                {
                    pigLatin.Append(
                        word.Substring(vowelIndex) + word.Substring(0, vowelIndex) + "ay ");
                }
            }
        }

        return pigLatin.ToString().Trim();
    }

    private static int FindFirstVowelIndex(string word)
    {
        for (var i = 0; i < word.Length; i++)
        {
            if (IsVowel(word[i]))
            {
                return i;
            }
        }
        return -1;
    }

    private static bool IsVowel(char c) =>
        char.ToLower(c) is 'a' or 'e' or 'i' or 'o' or 'u';
}

Définissez un point d’arrêt sur la première ligne logger.LogInformation de la méthode Run, puis appuyez sur F5 pour démarrer l’hôte Functions. Une fois le tableau de bord .NET.NET Aspire lancé, vous observez les éléments suivants :

Capture d’écran de la .NET Aspire en cours d’exécution avec une application de fonction Azure.

.NET .NET Aspire a :

  • Configuré une ressource de stockage émulée Azure à utiliser pour la comptabilité par l’hôte.
  • Lancement de l’hôte de Functions localement avec la cible en tant que le projet Functions enregistré.
  • Câble le port défini dans launchSettings.json du projet de fonctions pour l’écoute.

Utilisez votre client HTTP favori pour envoyer une requête au déclencheur et observez les entrées liées extraites du corps de la requête dans le débogueur.

Bash 
curl --request POST \
  --url http://localhost:7282/api/Function1 \
  --header 'Content-Type: application/json' \
  --data '{
  "value": "Welcome to Azure Functions"
}'

capture d’écran du tableau de bord .NET Aspire : débogage d’une application de fonction Azure.

Vous êtes maintenant prêt à déployer notre application sur Azure Container Apps (ACA). Le déploiement dépend actuellement des builds en préversion des packages Azure Functions Worker et du kit de développement logiciel (SDK) Worker. Si nécessaire, mettez à niveau les versions référencées dans le projet Functions :

XML 
<ItemGroup>
    <PackageReference Include="Microsoft.Azure.Functions.Worker" Version="2.0.0-preview2" />
    <PackageReference Include="Microsoft.Azure.Functions.Worker.Sdk" Version="2.0.0-preview2" />
</ItemGroup>

Vous devez également exposer un point de terminaison public pour notre projet Fonctions Azure afin que les requêtes puissent être envoyées à notre déclencheur HTTP :

C# 
builder.AddAzureFunctionsProject<Projects.PigLatinApp>("piglatinapp")
       .WithExternalHttpEndpoints();

Pour déployer l’application avec la azd CLI, vous devez d’abord obtenir la dernière version. Pour installer la dernière version, un avertissement s’affiche si votre version est obsolète. Suivez les instructions pour effectuer la mise à jour vers la dernière version.

Une fois l’installation terminée, accédez au dossier contenant le projet hôte d’application et exécutez azd init:

Azure Developer CLI 
$ azd init

Initializing an app to run on Azure (azd init)

? How do you want to initialize your app? Use code in the current directory

  (✓) Done: Scanning app code in current directory

Detected services:

  .NET (Aspire)
  Detected in: ./PigLatinApp/PigLatinApp.AppHost/PigLatinApp.AppHost.csproj

azd will generate the files necessary to host your app on Azure using Azure Container Apps.

? Select an option Confirm and continue initializing my app
? Enter a new environment name: azfunc-piglatin

Generating files to run your app on Azure:

  (✓) Done: Generating ./azure.yaml
  (✓) Done: Generating ./next-steps.md

SUCCESS: Your app is ready for the cloud!

Ensuite, déployez l’application en exécutant azd up:

Azure Developer CLI 
$ azd up 
? Select an Azure Subscription to use: 130. [redacted]
? Select an Azure location to use: 50. (US) West US 2 (westus2)

Packaging services (azd package)


Provisioning Azure resources (azd provision)
Provisioning Azure resources can take some time.

Subscription: [redacted]
Location: West US 2

  You can view detailed progress in the Azure Portal:
  [redacted]

  (✓) Done: Resource group: rg-azfunc-piglatin (967ms)
  (✓) Done: Container Registry: [redacted] (13.316s)
  (✓) Done: Log Analytics workspace: [redacted] (16.467s)
  (✓) Done: Container Apps Environment: [redacted] (1m35.531s)
  (✓) Done: Storage account: [redacted] (21.37s)

Deploying services (azd deploy)

  (✓) Done: Deploying service piglatinapp
  - Endpoint: {{endpoint-url}}

  Aspire Dashboard: {{dashboard-url}}

Enfin, testez votre application Functions déployée à l’aide de votre client HTTP favori :

Bash 
curl --request POST \
  --url {{endpoint-url}}/api/Function1 \
  --header 'Content-Type: application/json' \
  --data '{
  "value": "Welcome to Azure Functions"
}'

La prise en charge de Azure Functions dans .NET Aspire est toujours en préversion avec prise en charge d’un ensemble limité de déclencheurs, notamment :

Pour plus d’informations, consultez l’intégration officielle .NET AspireAzure "Fonctions" (Version préliminaire).

Personnalisation de Azure Container Apps

L'une des fonctionnalités les plus demandées est la possibilité de personnaliser le Azure Container Apps que l'hôte de l'application crée sans toucher à Bicep. Cela est possible à l’aide des API PublishAsAzureContainerApp<T>(IResourceBuilder<T>, Action<AzureResourceInfrastructure,ContainerApp>) et PublishAsAzureContainerApp<T>(IResourceBuilder<T>, Action<AzureResourceInfrastructure,ContainerApp>) dans l’espace de noms Aspire.Hosting.Azure.AppContainers. Ces méthodes personnalisent la définition d’application conteneur Azure que l’hôte de l’application crée.

Ajoutez la référence de package à votre fichier projet :

XML 
<ItemGroup>
  <PackageReference Include="Aspire.Hosting.Azure.AppContainers"
                    Version="9.0.0" />
</ItemGroup>

L’exemple suivant montre comment réduire à l'échelle une application conteneur Azure jusqu'à zéro (0) réplica :

C# 
var builder = DistributedApplication.CreateBuilder(args);

var db = builder.AddAzurePostgresFlexibleServer("pg")
                .RunAsContainer()
                .AddDatabase("db");

// Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed.
#pragma warning disable AZPROVISION001

builder.AddProject<Projects.WebApplication1>("api")
       .WithReference(db)
       .PublishAsAzureContainerApp((module, containerApp) =>
       {
           // Scale to 0
           containerApp.Template.Value!.Scale.Value!.MinReplicas = 0;
       });

#pragma warning restore AZPROVISION001

builder.Build().Run();

L’exemple de code précédent reporte la génération de la définition d’application conteneur Azure à l’hôte de l’application. Cela vous permet de personnaliser la définition de l'application conteneur Azure sans avoir à exécuter azd infra synth et à modifier de manière non sécurisée les fichiers bicep générés.

Voir aussi