integrazione di .NET AspireDapr

Distributed Application Runtime (Dapr) offre API per sviluppatori che fungono da canale per interagire con altri servizi e dipendenze e astrarre l'applicazione dalle specifiche di tali servizi e dipendenze. Dapr e .NET Aspire possono collaborare per migliorare l'esperienza di sviluppo locale. Usando Dapr con .NET Aspire, è possibile concentrarsi sulla scrittura e sull'implementazione di applicazioni distribuite basate su .NETanziché sull'onboarding locale.

In questa guida imparerai come sfruttare l'astrazione di Dapre la configurazione prescrittiva delle tecnologie cloud di .NET Aspireper creare microservizi semplici, portabili, resilienti e sicuri su scala globale.

Confronto tra .NET Aspire e Dapr

A prima vista, Dapr e .NET Aspire possono sembrare avere funzionalità sovrapposte, e in effetti le hanno. Tuttavia, accettano approcci diversi. .NET .NET Aspire ha un'opinione precisa su come creare applicazioni distribuite su una piattaforma cloud e si concentra sul miglioramento dell'esperienza di sviluppo in locale. Dapr è un runtime che astrae le complessità comuni della piattaforma cloud sottostante sia durante lo sviluppo che nell'ambiente di produzione. Si basa su sidecar per fornire astrazioni per elementi come la configurazione, la gestione dei segreti e la messaggistica. La tecnologia sottostante può essere facilmente disattivata tramite i file di configurazione, mentre il codice non deve cambiare.

Aspetto	.NET Aspire	Dapr
Scopo	Progettato per semplificare lo sviluppo di soluzioni native del cloud nei computer di sviluppo locali.	Progettato per semplificare lo sviluppo e l'esecuzione di app distribuite con API comuni che possono essere facilmente scambiate.
API	Gli sviluppatori devono chiamare le API delle risorse usando gli SDK specifici	Gli sviluppatori chiamano le API nel sidecar Dapr, che inoltra la chiamata all'API corretta. È facile scambiare LE API delle risorse senza modificare il codice nei microservizi.
Lingue	I microservizi vengono scritti in linguaggi .NET, Go, Python, Javascript e altri.	È possibile chiamare funzioni sidecar Dapr in qualsiasi linguaggio che supporti le interfacce HTTP/gRPC.
Criteri di sicurezza	Non include criteri di sicurezza, ma può configurare in modo sicuro le connessioni tra le risorse dipendenti.	Include criteri di sicurezza personalizzabili che controllano quali microservizi hanno accesso ad altri servizi o risorse.
Distribuzione	Sono disponibili strumenti di distribuzione per Azure e Kubernetes.	Non include gli strumenti di distribuzione. Le app vengono in genere distribuite con sistemi di integrazione continua/sviluppo continuo (CI/CD).
Dashboard	Offre una visione completa delle risorse e della loro telemetria e supporta l'ascolto su qualsiasi risorsa supportata da OTEL.	Limitato solo alle risorse Dapr.

.NET Aspire semplifica la configurazione e il debug delle applicazioni Dapr fornendo un'API semplice per configurare Dapr sidecar e esponendo le sidecar come risorse nel dashboard.

Esplora i componenti di Dapr con .NET Aspire

Dapr fornisce molti componenti predefiniti e quando si usa Dapr con .NET Aspire è possibile esplorare e configurare facilmente questi componenti. Non confondere questi componenti con le integrazioni .NET.NET Aspire. Si consideri, ad esempio, quanto segue:

• Dapr- Archivi stati: chiamare AddDaprStateStore per aggiungere un archivio stati configurato al progetto di .NET.NET Aspire.
• Dapr— Pub Sub: Chiama AddDaprPubSub per aggiungere un pub sub configurato al tuo progetto di .NET.NET Aspire.
• Dapr- Componenti: Chiama AddDaprComponent per aggiungere al progetto .NET.NET Aspire un'integrazione già configurata.

Installare Dapr

Questa integrazione richiede Dapr versione 1.13 o successiva. Per installare Dapr, vedere Installare la CLI Dapr. Dopo aver installato l'interfaccia a riga di comando di Dapr, esegui il dapr initcome descritto in per inizializzare Dapr nel tuo ambiente locale.

Importante

Se si tenta di eseguire la soluzione .NET Aspire senza l'interfaccia della riga di comando di Dapr, verrà visualizzato l'errore seguente:

Unable to locate the Dapr CLI.

Integrazione dell'hosting

Nella soluzione .NET Aspire, per integrare Dapr e accedere ai relativi tipi e API, aggiungere il pacchetto NuGet 📦Aspire.Hosting.Dapr nel progetto host dell'app .

.NET

dotnet add package Aspire.Hosting.Dapr

PackageReference

<PackageReference Include="Aspire.Hosting.Dapr"
                  Version="*" />

Per ulteriori informazioni, vedere dotnet add package o Gestire le dipendenze dei pacchetti nelle applicazioni .NET.

Aggiungere il sidecar Dapr alle risorse di .NET Aspire

Dapr usa il modello sidecar . Il sidecar Dapr viene eseguito insieme alla tua app come server HTTP leggero, portatile e senza stato, in ascolto delle richieste HTTP in arrivo alla tua app.

Per aggiungere un sidecar a una risorsa .NET.NET Aspire, chiamare il metodo WithDaprSidecar. Il parametro appId è l'identificatore univoco per l'applicazione Dapr, ma è facoltativo. Se non si specifica un appId, viene invece usato il nome della risorsa padre.

using Aspire.Hosting.Dapr;

var builder = DistributedApplication.CreateBuilder(args);

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

Configurare i sidecar Dapr

Il metodo WithDaprSidecar offre sovraccarichi per configurare le opzioni sidecar Dapr, come AppId e varie porte. Nell'esempio seguente la Dapr sidecar è configurata con porte specifiche per GRPC, HTTP, metriche e un ID app specifico.

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

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

Esempio completo di host dell'app Dapr

Mettere tutto insieme, considera il seguente esempio di un progetto host di app .NET.NET Aspire che include:

• Servizio API back-end che dichiara un Dapr sidecar con impostazioni predefinite.
• Progetto front-end web che dichiara un Dapr sidecar con opzioni specifiche, ad esempio porte esplicite.

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

Quando avvii la soluzione .NET Aspire, il dashboard mostra il sidecar Dapr come risorsa, con il suo stato e i log.

Usare i Dapr sidecar nei progetti .NET Aspire

Per usare le API di Dapr da risorse di .NET Aspire, è possibile usare il 📦Dapr. AspNetCore/ pacchetto NuGet. L'SDK di Dapr fornisce un set di API per interagire con i sidecar Dapr.

Nota

Usare la libreria Dapr.AspNetCore per l'integrazione Dapr con ASP.NET (integrazione di inserimento dipendenze, registrazione delle sottoscrizioni, e così via). Le app nonASP.NET (come le app console) possono utilizzare il 📦Dapr.Client per effettuare chiamate tramite il sidecar Dapr.

.NET

dotnet add package Dapr.AspNetCore

PackageReference

<PackageReference Include="Dapr.AspNetCore"
                  Version="*" />

Aggiungere Dapr client

Dopo l'installazione in un progetto ASP.NET Core, l'SDK può essere aggiunto al generatore di servizi.

builder.Services.AddDaprClient();

Richiamare metodi di Dapr

È ora possibile inserire un'istanza di DaprClient nei servizi per interagire con il sidecar Dapr tramite l'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 è il metodo che invia una richiesta HTTP al sidecar Dapr. Si tratta di un metodo generico che accetta:

• Un verbo HTTP.
• ID app Dapr del servizio da chiamare.
• Nome del metodo.
• Un token di annullamento.

A seconda del verbo HTTP, può anche accettare un corpo della richiesta e intestazioni. Il parametro di tipo generico è il tipo del corpo della risposta.

Il file completo Program.cs per il progetto front-end mostra:

• Il client Dapr da aggiungere al generatore di servizi.
• Classe WeatherApiClient che usa il client Dapr per chiamare il servizio back-end.

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

Ad esempio, in un progetto Blazor è possibile inserire la classe WeatherApiClient in una pagina razor e usarla per chiamare il servizio back-end:

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

Quando si utilizza l'SDK Dapr, il sidecar Dapr viene chiamato tramite HTTP. Il Dapr sidecar inoltra quindi la richiesta al servizio di destinazione. Mentre il servizio di destinazione viene eseguito in un processo separato dal sidecar, l'integrazione legata al servizio avviene nel sidecar Dapr ed è responsabile della scoperta del servizio e dell'instradamento della richiesta al servizio di destinazione.

Passaggi successivi

• Dapr
• Dapr documentazione
• Dapr GitHub repo
• .NET Aspire Dapr app di esempio
• .NET .NET Aspire integrazioni
• .NET Aspire GitHub deposito