Partager via

Utiliser Dapr avec .NET Aspire

  • 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 collaborent 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 passer du temps supplémentaire avec l’intégration locale.

Dans ce guide, vous allez apprendre à tirer parti de l'abstraction de Dapret de la configuration volontaire de .NET Aspirepour les technologies cloud afin de créer des microservices simples, portables, résilients et sécurisés, déployés à grande échelle sur Azure.

Conditions préalables

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

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

En plus des prérequis pour .NET.NET Aspire, vous aurez besoin des éléments suivants :

  • 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 décrit dans Initialiser Dapr dans votre environnement local.

Important

Si vous tentez d’exécuter l’application sans l’interface CLI Dapr, vous recevez l’erreur suivante :

Unable to locate the Dapr CLI.

Démarrer

Pour commencer, vous devez ajouter le package d’hébergement Dapr à votre projet hôte d'application en installant le package NuGet 📦Aspire.Hébergement.Dapr.

dotnet add package Aspire.Hosting.Dapr

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

Ajouter un Dapr side-car

Dapr utilise le modèle Sidecar pour s’exécuter en même temps que votre application. Le Dapr sidecar s’exécute en même temps que votre application en tant que HTTP server léger, portable et sans état qui attend les requêtes HTTP entrantes à partir de votre application.

Pour ajouter un side-car à une ressource .NET.NET Aspire, appelez la méthode WithDaprSidecar sur la ressource souhaitée. 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();

La méthode WithDaprSidecar offre des surcharges pour configurer les options de side-car de Dapr, comme l’ID d’application et les 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()
{
    DaprGrpcPort = 50001,
    DaprHttpPort = 3500,
    MetricsPort = 9090
};

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

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

  • API back-end qui déclare une sidecar Dapr avec des valeurs par défaut.
  • Frontend qui déclare un Dapr sidecar avec des options spécifiques, comme des ports explicites.
using Aspire.Hosting.Dapr;

var builder = DistributedApplication.CreateBuilder(args);

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

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

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

builder.Build().Run();

Le tableau de bord .NET Aspire affiche le sidecar Dapr en tant que ressource, avec son état et ses journaux de bord.

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

Ajout du Kit de développement logiciel (SDK) Dapr

Pour utiliser les API Dapr à partir de ressources .NET Aspire, vous pouvez utiliser le 📦Dapr.AspNetCore/. 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

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

Une instance de DaprClient peut maintenant être injectée dans vos services pour interagir avec le sidecar Dapr via le 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 une méthode qui envoie une requête HTTP au side-car Dapr. Il s’agit d’une méthode générique qui prend :

  • Un 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 :

  • L'ajout de Daprclient au générateur de services
  • Classe WeatherApiClient qui utilise le Daprclient 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, la classe WeatherApiClient peut être injectée dans une intégration et utilisée 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.

Dapr et .NET Aspire

À la première vue, Dapr et .NET Aspire peuvent ressembler à des fonctionnalités qui se chevauchent, et elles le font. Toutefois, ils prennent tous les deux une approche différente. .NET .NET Aspire est une approche avisée sur la façon de créer des applications distribuées sur une plateforme cloud. Dapr est un runtime qui extrait les complexités courantes de la plateforme cloud sous-jacente. 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.

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

Étapes suivantes

.NET Aspire Dapr exemple d’application