WebAssembly et conteneurs : orchestration d’architectures distribuées avec .NET Aspire

L’exécution, la composition et le débogage d’applications distribuées sur la machine du développeur local peuvent s’avérer difficiles, sujets aux erreurs et chronophages. Ces tâches quotidiennes pourraient être considérablement simplifiées grâce à .NET Aspire.

Dans cet article, nous allons rapidement plonger dans .NET Aspire et illustrer comment vous pouvez orchestrer des applications distribuées de nouvelle génération (lire natives du cloud) composées de conteneurs, de charges de travail WebAssembly et de leurs dépendances.

Qu’est-ce que .NET Aspire

.NET Aspire est une pile d’applications qui vous permet d’orchestrer des applications distribuées composées de différents composants interconnectés et de leurs dépendances. Dans le domaine de .NET Aspire, l’orchestration fait référence à la gestion, à la connexion et à la configuration de tous les composants d’une application distribuée (cloud native) pour améliorer l’environnement de développement local et ses flux de travail (boucle interne).

Il est important de noter que l’orchestration de .NET Aspire n’est pas destinée à remplacer les systèmes robustes utilisés dans les environnements de production, tels que Kubernetes.Présentation de .NET Aspire)

Fondamentalement, .NET Aspire vous permet, en tant que développeur, d’exprimer l’architecture de votre application distribuée à l’aide de code C#. L’orchestration dans .NET Aspire permet de résoudre les problèmes courants suivants :

• Composition de l’application : Permettre de spécifier toutes les pièces qui composent votre application.
• Découverte de services et gestion des chaînes de connexion : injection des bonnes chaînes de connexion, des configurations réseau et des informations de découverte de services pour rationaliser l’expérience du développeur.

Pour simplifier l’intégration avec des services et des plateformes populaires tels que PostgreSQL, Redis et d’autres, vous pouvez utiliser des composants .NET Aspire, qui sont également distribués sous forme de packages NuGet. Les composants sont conçus pour fonctionner de manière transparente avec l’orchestration .NET Aspire et répondre aux problèmes courants du cloud natif, tels que l’ajout de contrôles d’intégrité et la contribution de données de télémétrie.

Enfin et surtout, .NET Aspire s’intègre parfaitement à différents environnements de développement, allant de Visual Studio complet à Visual Studio Code et au dotnet CLI.

La disponibilité générale de .NET Aspire a été annoncée par Microsoft lors de Microsoft Build 2024.

Premiers pas avec .NET Aspire

Dans le cadre de cet article, nous explorerons .NET Aspire à l’aide de dotnet CLI. Pour commencer, assurez-vous que vous disposez de la dernière version dotnet CLI (8.0) installé sur votre machine. Vous pouvez installer .NET Aspire en ajoutant la charge de travail correspondante à votre installation .NET. Vous ajoutez le aspire charge de travail à l’aide des commandes suivantes :

# Update workload manifests
dotnet workload update

# Install the .NET Aspire Workload
dotnet workload install aspire

# Verify .NET Aspire Workload installation
dotnet workload list

Intégration de l’environnement d’exécution du conteneur

Différents composants d’application et/ou dépendances peuvent être exécutés en tant que conteneurs sur votre machine locale. Actuellement, .NET Aspire prend en charge deux environnements d’exécution de conteneurs : Docker Desktop et PodmanBien que .NET Aspire utilise par défaut Docker Desktop comme environnement d’exécution du conteneur, vous pouvez passer à Podman en définissant le DOTNET_ASPIRE_CONTAINER_RUNTIME variable d’environnement à podman:

# Use podman as container runtime
export DOTNET_ASPIRE_CONTAINER_RUNTIME=podman

Découverte d’un AppHost .NET Aspire

L’orchestration .NET Aspire est destinée à un type de projet spécial appelé AppHost. Nous n’explorerons pas la création d’un projet AppHost étape par étape dans le cadre de cet article. Au lieu de cela, nous souhaitons mettre en évidence ici certaines des caractéristiques spécifiques à .NET Aspire. Si vous n’avez jamais utilisé ou entendu parler de .NET Aspire auparavant, nous vous recommandons d’explorer le site officiel Documentation de .NET AspireIl explique très bien les concepts de base de .NET Aspire et vous guide à travers les étapes d’orchestration, d’exécution et de débogage d’applications distribuées sur votre machine locale.

Jetons un œil à une orchestration assez simple composée d’une WebAPI .NET et d’un cache Redis (les capacités de cache Redis sont fournies par le Aspire.Hosting.Redis Paquet NuGet) :

var builder = DistributedApplication.CreateBuilder(args);

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

builder.AddProject("webapi", "../Fermyon.AspireShowcase.WebApi/Fermyon.AspireShowcase.WebApi.csproj")
    .WithOtlpExporter()
    .WithReference(redis);

builder.Build().Run();

En supposant que le projet WebAPI soit instrumenté à l’aide Télémétrie ouverte (ce qui pourrait également être réalisé en utilisant Valeurs par défaut du service .NET Aspire), vous pouvez suivre les appels à l’aide du tableau de bord .NET Aspire lors de l’exécution locale du projet AppHost.

Traces d’un projet .NET WebAPI dans le tableau de bord .NET Aspire

Présentation de Fermyon.Aspire.Spin

Chez Fermyon, nous croyons fermement que .NET Aspire est un booster de productivité pour de nombreux développeurs et organisations, et c’est pourquoi nous avons commencé à créer une extension pour .NET Aspire, vous permettant d’ajouter des applications WebAssembly sans serveur (Spin Apps) à vos architectures d’applications distribuées. Fermyon.Aspire.Spinvous pouvez ajouter des applications Spin écrites dans n’importe quel langage qui compile en WebAssembly (le wasm32-wasi plate-forme) – à votre application en utilisant le IDistributedApplicationBuilder interface.

Capacités fournies par Fermyon.Aspire.Spin

Pour des raisons de flexibilité, Fermyon.Aspire.Spin vous permet d’ajouter des Spin Apps soit en référençant le code source de vos Spin Apps, soit en pointant vers une référence OCI existante qui pourrait être extraite de n’importe quel registre de conteneurs compatible OCI (tel qu’Azure Container Registry).

En plus de cela, vous pouvez utiliser Fermyon.Aspire.Spin pour faire ce qui suit :

• Créez des configurations d’exécution à la volée en utilisant :

  • Dépendances définies dans .NET Aspire.
  • Bases de données SQLite, fournies par Spin.
  • Magasins de clés-valeurs SQLite, fournis par Spin.
  • Inférence LLM hybride, utilisant Fermyon Cloud.

• Spécifiez les variables d’environnement transmises à votre application Spin à l’aide du fournisseur de configuration de variables d’environnement (SPIN_VARIABLE_).
• Au démarrage de l’hôte .NET Aspire, vous pouvez :

  • vérifier que spin La CLI est installée à l’aide de CheckForSpin crochet de cycle de vie.
  • s’authentifier auprès des registres OCI privés/protégés à l’aide de SpinRegistryLogin crochet de cycle de vie.
  • installer le requis spin Plugins CLI utilisant le InstallSpinPlugin crochet de cycle de vie.

Installation de Fermyon.Aspire.Spin

Installation Fermyon.Aspire.Spin c’est aussi simple que d’ajouter le package NuGet correspondant à votre projet .NET Aspire AppHost :

# Adding Fermyon.Aspire.Spin
dotnet add package Fermyon.Aspire.Spin

Orchestration des conteneurs et WebAssembly

Une fois que vous avez installé Fermyon.Aspire.Spin vous pouvez utiliser les méthodes d’extension fournies par le package NuGet pour orchestrer votre application distribuée. Toutes les méthodes d’extension sont fournies au Aspire.Hosting espace de noms – ce qui signifie que vous n’avez pas besoin d’importer des espaces de noms supplémentaires pour accéder à ces méthodes d’extension. AddSpinApp est la méthode la plus connue. Elle vous permet d’ajouter des applications Spin à la DistributedApplicationBuilder.

Consultez l’exemple suivant, qui construit une application distribuée composée d’une application Spin, d’une API .NET et d’un cache Redis :

var builder = DistributedApplication.CreateBuilder(args);

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

builder.AddProject("webapi", "../Fermyon.AspireShowcase.WebApi/Fermyon.AspireShowcase.WebApi.csproj")
    .WithOtlpExporter()
    .WithReference(redis);

builder.AddSpinApp("spin-app", "../spin-app", 3000)
    .WithSpinEnvironment("LogLevel", "DEBUG");

builder.Build().Run();

Génération de configurations d’exécution avec .NET Aspire

Vous pouvez contrôler le comportement des différentes fonctionnalités d’hôte d’une application Spin en fournissant un fichier de configuration d’exécution. Fermyon.Aspire.Spin fournit un SpinRuntimeConfigurationBuilderque vous pouvez utiliser pour créer un fichier de configuration d’exécution personnalisé :

var rtc = SpinRuntimeConfigurationBuilder.Create("sample.toml")
    .WithRedisKeyValueStore("default", redis);

Vous souhaiterez peut-être partager des fichiers de configuration d’exécution entre plusieurs applications Spin. Il existe de nombreux scénarios dans lesquels cela est utile. Un bon exemple est une architecture distribuée dans laquelle plusieurs applications Spin doivent utiliser la même instance Redis comme magasin de clés-valeurs. Vous pouvez transmettre le SpinRuntimeConfigurationBuilder (rtc) à plusieurs applications Spin de vos architectures distribuées, comme indiqué ici :

builder.AddSpinApp("spin-app", "../spin-app", 3000)
    .WithSpinEnvironment("LogLevel", "DEBUG")
    .WithRuntimeConfig(rtc);

Exécution d’applications Spin avec .NET Aspire

Les applications Spin sont générées à l’aide de spin up commande, lors de l’exécution de votre projet hôte .NET Aspire. De plus, la --build le drapeau est automatiquement injecté par Fermyon.Aspire.Spin pour garantir que la dernière version de votre code source est compilée en WebAssembly.

Consommation d’applications Spin à partir des registres OCI

En plus d’orchestrer les Spin Apps en référençant le chemin d’accès au code source de l’application, vous pouvez également référencer les Spin Apps existantes en fournissant la référence OCI correspondante :

builder.AddSpinApp("existing-app",
    OciReference.From("thorstenhans/hello-world-spin-rust", "0.0.1"),
    3006); 

Dans l’extrait précédent, une application Spin est créée sur la base d’un artefact OCI public du Docker Hub.

Il est assez courant d’utiliser des registres privés qui nécessitent une authentification pour la distribution des artefacts OCI. Fermyon.Aspire.Spin prend en charge les registres privés en fournissant les SpinRegistryLogin crochet de cycle de vie. L’extrait ci-dessous illustre comment vous pouvez ajouter une application Spin en référençant un artefact OCI d’Azure Container Registry (ACR), qui nécessite une authentification :

var builder = DistributedApplication.CreateBuilder(args);
builder.Services.AddScoped(sp =>
{
    var credentials = new OciRegistryCredentials()
    {
        LoginServer = "aspirespin.azurecr.io",
        User = "aspire-host",
        Password = builder.Configuration.GetValue("ACR_PASSWORD")!
    };
    return new SpinRegistryLogin(credentials);
});

builder.AddSpinApp("existing-app",
    OciReference.From("aspirespin.azurecr.io/qr-generator", "0.0.1"),
    3007);
// ...

Vérifiez que Spin CLI est installé

Pour exécuter Spin Apps via .NET Aspire, la CLI Spin doit être installée sur les machines de développement et les systèmes d’intégration continue (CI). Fermyon.Aspire.Spin fournit un crochet de cycle de vie simple mais utile appelé CheckForSpinque vous pouvez utiliser pour vérifier que Spin CLI est installé sur la machine actuelle.

Si le Lifecycle Hook ne parvient pas à localiser la CLI Spin sur une machine de développeur particulière, une exception correspondante sera levée lors du démarrage de l’application distribuée.

var builder = DistributedApplication.CreateBuilder(args);
builder.Services.AddScoped(); 

// ...

Installation des plugins Spin

L’interface de ligne de commande Spin est dotée d’une puissante infrastructure de plug-ins, permettant aux développeurs d’étendre l’interface de ligne de commande et d’ajouter encore plus de fonctionnalités. Pour garantir que vos applications Spin fonctionnent sur différentes machines de développement, vous pouvez utiliser l’ *InstallSpinPlugin* Accrochez et installez les plugins Spin CLI lors du démarrage du projet .NET Aspire Host.

Le kube Le plugin est un excellent exemple. Il permet de créer des manifestes de déploiement Kubernetes pour vos applications Spin lorsque vous souhaitez exécuter vos applications Spin sur SpinKube ou Fermyon Platform pour Kubernetes. L’extrait suivant utilise le InstallSpinPlugin Crochet de cycle de vie pour garantir la kube le plugin pour Spin CLI est installé :

var builder = DistributedApplication.CreateBuilder(args);

builder.Services.AddScoped(sp => new InstallSpinPlugin("kube"));
// ...

Observation des applications Spin avec .NET Aspire

Spin intègre la télémétrie et s’intègre parfaitement à OpenTelemetry. Dans le contexte de .NET Aspire, configurer OpenTelemetry pour vos applications Spin est aussi simple que d’appeler le WithOtlpExporter méthode sur votre application Spin :

builder.AddSpinApp("spin-app", "../spin-app", 3000)
    .WithSpinEnvironment("LogLevel", "DEBUG")
    .WithRuntimeConfig(rtc)
    .WithOtlpExporter();

L’exécution à nouveau de l’application distribuée et l’envoi de requêtes HTTP à l’application Spin entraînent la collecte et l’envoi de traces distribuées au point de terminaison OpenTelemetry fourni par .NET Aspire :

Traces distribuées d’une application Spin et du magasin de clés-valeurs Redis sous-jacent dans le tableau de bord .NET Aspire

Exploration des applications Spin à l’aide du tableau de bord .NET Aspire

Le tableau de bord .NET Aspire fournit des informations importantes sur tous les composants de vos applications distribuées, et les applications Spin ne font pas exception. Le tableau de bord .NET Aspire vous permet d’explorer :

• Journaux d’application structurés
• Journaux de la console (stdout)
• Métrique
• Variables d’environnement

En ce qui concerne les traces distribuées, les applications Spin contribuent à des mesures fondamentales via OpenTelemetry, qui seront automatiquement récupérées par .NET Aspire et visualisées dans la section Mesures du tableau de bord .NET Aspire.

Métriques d’une application Spin visualisées par le tableau de bord .NET Aspire

Conclusion et commentaires

L’orchestration d’applications distribuées composées d’applications Spin, de projets .NET et de conteneurs avec .NET Aspire réduit les frictions et simplifie considérablement l’expérience de développement local. Au lieu d’écrire des centaines de lignes de code déclaratif, vous pouvez simplement utiliser C# pour configurer et connecter les différentes parties d’une application distribuée.

Le tableau de bord .NET Aspire est l’endroit central pour comprendre le comportement d’une application distribuée au moment de l’exécution, explorer les données de configuration réelles des composants d’application individuels et approfondir les données de télémétrie générées par l’application.

Bénéficier d’un support de premier ordre pour l’utilisation de Spin Apps avec .NET Aspire est une étape supplémentaire dans le processus visant à rendre vos applications rapides, sécurisées et portables, en tirant parti des fonctionnalités fournies par Spin et WebAssembly en général.

Vous pouvez trouver le code source ici. Déposez un problème si vous manquez quelque chose, rencontrez des défauts ou rencontrez des difficultés pour intégrer vos applications Spin avec .NET Aspire.