Partager via

intégration de .NET AspireDapr

  • Article

Distributed Application Runtime (Dapr) offre des API de développement qui servent d’intermédiaire pour interagir avec d’autres services et dépendances et extraire l’application des spécificités de ces services et dépendances. Dapr et .NET Aspire pouvez collaborer pour améliorer votre expérience de développement local. En utilisant Dapr avec .NET Aspire, vous pouvez vous concentrer sur l’écriture et l’implémentation d’applications distribuées basées sur .NETau lieu de l’intégration locale.

Dans ce guide, vous allez apprendre à tirer parti de l’abstraction de Dapret de la configuration .NET Aspireavisée des technologies cloud pour créer des microservices simples, portables, résilients et sécurisés à grande échelle.

Comparaison des .NET Aspire et des Dapr

À la première vue, Dapr et .NET Aspire peuvent ressembler à des fonctionnalités qui se chevauchent, et elles le font. Toutefois, ils prennent différentes approches. .NET .NET Aspire a des principes arrêtés sur la façon de créer des applications distribuées sur une plate-forme de cloud et met l'accent sur l'amélioration de l'expérience de développement local. Dapr est un runtime qui extrait les complexités communes de la plateforme cloud sous-jacente pendant le développement et en production. Il s’appuie sur des side-cars pour fournir des abstractions pour des éléments tels que la configuration, la gestion des secrets et la messagerie. La technologie sous-jacente peut être facilement remplacée via des fichiers de configuration, tandis que votre code n’a pas besoin de changer.

Aspect .NET Aspire Dapr
Objectif Conçu pour faciliter le développement de solutions natives cloud sur des ordinateurs de développement locaux. Conçu pour faciliter le développement et l’exécution d’applications distribuées avec des API courantes qui peuvent être facilement échangées.
APIs Les développeurs doivent appeler des API de ressources à l’aide de leurs kits sdk spécifiques Les développeurs appellent des API dans le side-car Dapr, qui transfère l’appel à l’API correcte. Il est facile d’échanger des API de ressources sans modifier le code dans vos microservices.
Langues Vous écrivez des microservices dans .NET langues, Go, Python, Javascript et d’autres. Vous pouvez appeler les fonctions sidecar Dapr dans n'importe quel langage prenant en charge les interfaces HTTP/gRPC.
Stratégies de sécurité N’inclut pas de stratégies de sécurité, mais peut configurer en toute sécurité les connexions entre les ressources dépendantes. Inclut des stratégies de sécurité personnalisables qui contrôlent les microservices qui ont accès à d’autres services ou ressources.
Déploiement Il existe des outils de déploiement pour Azure et Kubernetes. N’inclut pas les outils de déploiement. Les applications sont généralement déployées avec des systèmes d’intégration continue/développement continu (CI/CD).
Tableau de bord Fournit une vue complète des ressources et de leurs données de télémétrie et prend en charge l'écoute sur n'importe quelle ressource prise en charge par OTEL. Limité aux ressources Dapr uniquement.

.NET Aspire facilite la configuration et le débogage d’applications Dapr en fournissant une API simple pour configurer Dapr sidecars et en exposant les sidecars en tant que ressources dans le tableau de bord.

Explorer les composants Dapr avec .NET Aspire

Dapr fournit de nombreux composants intégrés , et lorsque vous utilisez Dapr avec .NET Aspire vous pouvez facilement explorer et configurer ces composants. Ne confondez pas ces composants avec les intégrations .NET.NET Aspire. Prenons l’exemple suivant :

Installer Dapr

Cette intégration nécessite Dapr version 1.13 ou ultérieure. Pour installer Dapr, consultez Installer le CLI Dapr. Après avoir installé l’interface CLI Dapr, exécutez le dapr init, comme décrit dans Initialiser Dapr dans votre environnement local.

Important

Si vous tentez d’exécuter la solution .NET Aspire sans l’interface CLI Dapr, vous recevez l’erreur suivante :

Unable to locate the Dapr CLI.

Intégration de l’hébergement

Dans votre solution .NET Aspire, pour intégrer Dapr et accéder à ses types et API, ajoutez le package NuGet 📦Aspire.Hosting.Dapr dans le projet hôte de l’application .

dotnet add package Aspire.Hosting.Dapr

Pour plus d’informations, consultez dotnet add package ou Manage package dependencies in .NET applications.

Ajouter le sidecar Dapr aux ressources .NET Aspire

Dapr utilise le modèle sidecar . Le Dapr side-car s’exécute en même temps que votre application en tant que serveur HTTP léger, portable et sans état qui écoute les requêtes HTTP entrantes à partir de votre application.

Pour ajouter un side-car à une ressource .NET.NET Aspire, appelez la méthode WithDaprSidecar dessus. Le paramètre appId est l’identificateur unique de l’application Dapr, mais il est facultatif. Si vous ne fournissez pas de appId, le nom de la ressource parent est utilisé à la place.

using Aspire.Hosting.Dapr;

var builder = DistributedApplication.CreateBuilder(args);

var apiService = builder
    .AddProject<Projects.Dapr_ApiService>("apiservice")
    .WithDaprSidecar();

Configurer Dapr side-cars

La méthode WithDaprSidecar offre des surcharges pour configurer vos options de "sidecar" Dapr telles que AppId et différents types de ports. Dans l’exemple suivant, le Dapr side-car est configuré avec des ports spécifiques pour GRPC, HTTP, métriques et un ID d’application spécifique.

DaprSidecarOptions sidecarOptions = new()
{
    AppId = "FirstSidecar",
    DaprGrpcPort = 50001,
    DaprHttpPort = 3500,
    MetricsPort = 9090
};

builder.AddProject<Projects.Dapr_Web>("webfrontend")
    .WithExternalHttpEndpoints()
    .WithReference(apiService)
    .WithDaprSidecar(sidecarOptions);

Exemple complet d’hôte d’application Dapr

Pour résumer, considérez l’exemple suivant d’un projet hôte d’application .NET.NET Aspire qui inclut :

  • Service d’API backend qui déclare un sidecar Dapr avec des valeurs par défaut.
  • Projet front-end web qui déclare un sidecar Dapr avec des options spécifiques, telles que des ports explicites.
using Aspire.Hosting.Dapr;

var builder = DistributedApplication.CreateBuilder(args);

var apiService = builder
    .AddProject<Projects.Dapr_ApiService>("apiservice")
    .WithDaprSidecar();

DaprSidecarOptions sidecarOptions = new()
{
    AppId = "FirstSidecar",
    DaprGrpcPort = 50001,
    DaprHttpPort = 3500,
    MetricsPort = 9090
};

builder.AddProject<Projects.Dapr_Web>("webfrontend")
    .WithExternalHttpEndpoints()
    .WithReference(apiService)
    .WithDaprSidecar(sidecarOptions);

builder.Build().Run();

Lorsque vous démarrez la solution .NET Aspire, le tableau de bord affiche le sidecar Dapr comme ressource, avec son état et ses journaux.

tableau de bord .NET Aspire avec affichage des ressources sidecar Dapr

Utiliser des Dapr side-car pour consommer des projets .NET Aspire

Pour utiliser les API Dapr à partir de ressources .NET Aspire, vous pouvez utiliser le package 📦Dapr.AspNetCore/ NuGet. Le SDK Dapr fournit un ensemble d'API pour interagir avec les sidecars Dapr.

Note

Utilisez la bibliothèque Dapr.AspNetCore pour l’intégration de Dapr à ASP.NET (intégration di, inscription d’abonnements, etc.). Les applications nonASP.NET (telles que les applications console) peuvent simplement utiliser le 📦DaprClient pour effectuer des appels par le biais du sidecar Dapr.

dotnet add package Dapr.AspNetCore

Ajouter Dapr client

Une fois installé dans un projet ASP.NET Core, le Kit de développement logiciel (SDK) peut être ajouté au générateur de services.

builder.Services.AddDaprClient();

Appeler des méthodes Dapr

Une instance de DaprClient peut désormais être injectée dans vos services pour interagir avec le Dapr side-car via le kit sdk Dapr :

using Dapr.Client;

namespace Dapr.Web;

public class WeatherApiClient(DaprClient client)
{
    public async Task<WeatherForecast[]> GetWeatherAsync(
        int maxItems = 10, CancellationToken cancellationToken = default)
    {
        List<WeatherForecast>? forecasts =
            await client.InvokeMethodAsync<List<WeatherForecast>>(
                HttpMethod.Get,
                "apiservice",
                "weatherforecast",
                cancellationToken);

        return forecasts?.Take(maxItems)?.ToArray() ?? [];
    }
}

public record WeatherForecast(DateOnly Date, int TemperatureC, string? Summary)
{
    public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
}

InvokeMethodAsync est la méthode qui envoie une requête HTTP au side-car Dapr. Il s’agit d’une méthode générique qui prend :

  • Verbe HTTP.
  • ID d’application Dapr du service à appeler.
  • Nom de la méthode.
  • Jeton d’annulation.

Selon le verbe HTTP, un corps de requête et des en-têtes peuvent également être inclus. Le paramètre de type générique est le type du corps de la réponse.

Le fichier complet Program.cs du projet frontend affiche :

  • Le client Dapr est en cours d'ajout au générateur de services.
  • Classe WeatherApiClient qui utilise le client Dapr pour appeler le service principal.
using Dapr.Web;
using Dapr.Web.Components;

var builder = WebApplication.CreateBuilder(args);

// Add service defaults & Aspire components.
builder.AddServiceDefaults();

// Add services to the container.
builder.Services.AddRazorComponents()
    .AddInteractiveServerComponents();

builder.Services.AddOutputCache();

builder.Services.AddDaprClient();

builder.Services.AddTransient<WeatherApiClient>();

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error", createScopeForErrors: true);
    app.UseHsts();
}

app.UseHttpsRedirection();

app.UseStaticFiles();
app.UseAntiforgery();

app.UseOutputCache();

app.MapRazorComponents<App>()
    .AddInteractiveServerRenderMode();

app.MapDefaultEndpoints();

app.Run();

Par exemple, dans un projet Blazor, vous pouvez injecter la classe WeatherApiClient dans une page razor et l’utiliser pour appeler le service principal :

@page "/weather"
@attribute [StreamRendering(true)]
@attribute [OutputCache(Duration = 5)]

@inject WeatherApiClient WeatherApi

<PageTitle>Weather</PageTitle>

<h1>Weather</h1>

<p>This component demonstrates showing data loaded from a backend API service.</p>

@if (forecasts == null)
{
    <p><em>Loading...</em></p>
}
else
{
    <table class="table">
        <thead>
            <tr>
                <th>Date</th>
                <th>Temp. (C)</th>
                <th>Temp. (F)</th>
                <th>Summary</th>
            </tr>
        </thead>
        <tbody>
            @foreach (var forecast in forecasts)
            {
                <tr>
                    <td>@forecast.Date.ToShortDateString()</td>
                    <td>@forecast.TemperatureC</td>
                    <td>@forecast.TemperatureF</td>
                    <td>@forecast.Summary</td>
                </tr>
            }
        </tbody>
    </table>
}

@code {
    private WeatherForecast[]? forecasts;

    protected override async Task OnInitializedAsync()
    {
        forecasts = await WeatherApi.GetWeatherAsync();
    }
}

Lorsque le KIT de développement logiciel (SDK) Dapr est utilisé, le Dapr side-car est appelé via HTTP. Le Dapr sidecar achemine ensuite la requête au service cible. Pendant que le service cible s’exécute dans un processus distinct du side-car, l’intégration liée au service s’exécute dans le Dapr side-car et est responsable de la découverte du service et du routage de la requête vers le service cible.

Étapes suivantes