.NET Aspire Dapr integrering

Distributed Application Runtime (Dapr) erbjuder utvecklar-API:er som fungerar som en kanal för att interagera med andra tjänster och beroenden och abstrahera programmet från detaljerna i dessa tjänster och beroenden. Dapr och .NET Aspire kan samarbeta för att förbättra din lokala utvecklingsupplevelse. Genom att använda Dapr med .NET Aspirekan du fokusera på att skriva och implementera .NET-baserade distribuerade applikationer istället för lokal installation.

I den här guiden får du lära dig att dra nytta av Dapr:s abstraktion och .NET Aspire:s förhandskonfigurerade inställningar av molntekniker för att bygga enkla, bärbara, motståndskraftiga och säkra mikrotjänster i stor skala.

Jämföra .NET Aspire och Dapr

Vid första anblicken kan Dapr och .NET Aspire se ut som om de har överlappande funktioner, och det gör de. De har dock olika tillvägagångssätt. .NET .NET Aspire har en bestämd åsikt om hur man bygger distribuerade applikationer på en molnplattform och fokuserar på att förbättra den lokala utvecklingsupplevelsen. Dapr är en körtid som abstraherar bort de gemensamma komplexiteterna hos den underliggande molnplattformen både under utveckling och i produktion. Den förlitar sig på sidecars för att tillhandahålla abstraktioner för saker som konfiguration, hantering av hemligheter och meddelandehantering. Den underliggande tekniken kan enkelt växlas ut via konfigurationsfiler, medan koden inte behöver ändras.

Aspekt	.NET Aspire	Dapr
Avsikt	Utformad för att göra det enklare att utveckla molnbaserade lösningar på lokala utvecklingsdatorer.	Utformad för att göra det enklare att utveckla och köra distribuerade appar med vanliga API:er som enkelt kan växlas.
API:er	Utvecklare måste anropa resurs-API:er med hjälp av sina specifika SDK:er	Utvecklare anropar API i Dapr-sidecaren, som vidarebefordrar anropet till rätt API. Det är enkelt att växla resurs-API:er utan att ändra kod i dina mikrotjänster.
Språk	Du skriver mikrotjänster på .NET språk, Go, Python, Javascript och andra.	Du kan anropa Dapr sidovagnsfunktioner på valfritt språk som stöder HTTP/gRPC-gränssnitt.
Säkerhetsprinciper	Innehåller inte säkerhetsprinciper men kan konfigurera anslutningar mellan beroende resurser på ett säkert sätt.	Innehåller anpassningsbara säkerhetsprinciper som styr vilka mikrotjänster som har åtkomst till andra tjänster eller resurser.
Driftsättning	Det finns distributionsverktyg för Azure och Kubernetes.	Innehåller inte distributionsverktyg. Appar distribueras vanligtvis med CI/CD-system (Continuous Integration/Continuous Development).
Instrumentbräda	Ger en omfattande vy över resurserna och deras telemetri och har stöd för att lyssna på alla OTEL-resurser som stöds.	Begränsat till endast Dapr resurser.

.NET Aspire gör det enklare att konfigurera och felsöka Dapr program genom att tillhandahålla ett enkelt API för att konfigurera Dapr sidovagn och genom att exponera sidovagnen som resurser på instrumentpanelen.

Utforska Dapr komponenter med .NET Aspire

Dapr innehåller många inbyggda komponenteroch när du använder Dapr med .NET Aspire kan du enkelt utforska och konfigurera dessa komponenter. Blanda inte ihop dessa komponenter med .NET.NET Aspire integreringar. Tänk till exempel på följande:

• Dapr– Tillståndslager: Anropa AddDaprStateStore för att lägga till ett konfigurerat tillståndslager i ditt .NET.NET Aspire projekt.
• Dapr– Publicera-Prenumerera: Anropa AddDaprPubSub för att lägga till en konfigurerad publicera-prenumerera-funktion i ditt .NET.NET Aspire projekt.
• Dapr– Komponenter: Anropa AddDaprComponent för att lägga till en konfigurerad integrering i ditt .NET.NET Aspire projekt.

Installera Dapr

Den här integreringen kräver Dapr version 1.13 eller senare. Information om hur du installerar Daprfinns i Installera Dapr CLI-. När du har installerat Dapr CLI kör du dapr init, enligt beskrivningen i Initiera Dapr i din lokala miljö.

Viktig

Om du försöker köra .NET Aspire lösning utan Dapr CLI får du följande fel:

Unable to locate the Dapr CLI.

Värdintegrering

Lägg till 📦Aspire.Hosting.Dapr NuGet-paket i apphost projekt för att integrera Dapr och komma åt dess typer och API:er i din .NET Aspire-lösning.

.NET CLI

dotnet add package Aspire.Hosting.Dapr

PackageReference

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

Mer information finns på dotnet add package eller hantera paketberoenden i .NET-applikationer.

Lägg till Dapr sidovagn i .NET Aspire resurser

Dapr använder sidovagnsmönster. Den Dapr sidecar kör bredvid din app som en lättviktig, bärbar och tillståndslös HTTP-server som lyssnar efter inkommande HTTP-begäranden till din app.

Om du vill lägga till en sidovagn i en .NET.NET Aspire resurs anropar du metoden WithDaprSidecar på den. Parametern appId är den unika identifieraren för Dapr-programmet, men den är valfri. Om du inte anger ett appIdanvänds det överordnade resursnamnet i stället.

using Aspire.Hosting.Dapr;

var builder = DistributedApplication.CreateBuilder(args);

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

Konfigurera Dapr sidovagn

Metoden WithDaprSidecar erbjuder överbelastningar för att konfigurera sidovagnsalternativ för Dapr, såsom AppId och olika portar. I följande exempel konfigureras Dapr-sidvagn med specifika portar för GRPC, HTTP, mätvärden och ett specifikt app-ID.

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

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

Slutför Dapr appvärdexempel

När vi lägger samman allt, tänk på följande exempel på ett .NET.NET Aspire appvärdprojekt som innehåller:

• En backend-API-tjänst som deklarerar en Dapr sidecar med standardvärden.
• Ett webbfrontend-projekt som deklarerar en Dapr sidecar med specifika alternativ, till exempel explicita portar.

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

När du startar .NET Aspire-lösningen visar instrumentpanelen Dapr sidovagn som en resurs med dess status och loggar.

Använd Dapr sidovagnar i förbrukande av .NET Aspire projekt

Om du vill använda Dapr API:er från .NET Aspire resurser kan du använda 📦Dapr. AspNetCore/ NuGet-paket. Dapr SDK innehåller en uppsättning API:er för att interagera med Dapr sidovagnar.

Anteckning

Använd Dapr.AspNetCore-biblioteket för Dapr integrering med ASP.NET (DI-integrering, registrering av prenumerationer osv.). Appar som inteASP.NET (till exempel konsolappar) kan bara använda 📦Dapr.Client för att ringa samtal via Dapr sidovagn.

.NET CLI

dotnet add package Dapr.AspNetCore

PackageReference

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

Lägg till Dapr klient

När SDK:et har installerats i ett ASP.NET Core projekt kan det läggas till i tjänstverktyget.

builder.Services.AddDaprClient();

Anropa Dapr-metoderna

En instans av DaprClient kan nu matas in i dina tjänster för att interagera med Dapr sidovagn via Dapr SDK:

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 är den metod som skickar en HTTP-begäran till Dapr sidovagn. Det är en allmän metod som tar:

• Ett HTTP-verb.
• Det Dapr app-ID för tjänsten som ska anropas.
• Metodnamnet.
• En annulleringstoken.

Beroende på HTTP-verbet kan det också ta en begärandetext och rubriker. Den generiska typparametern är typen av svarstext.

Den fullständiga Program.cs filen för klientdelsprojektet visar:

• Den Dapr-klienten som läggs till i tjänstbyggaren.
• Den WeatherApiClient-klass som använder Dapr-klienten för att anropa serverdelstjänsten.

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

I ett Blazor-projekt kan du till exempel injicera WeatherApiClient-klassen i en Razor-sida och använda den för att kalla bakgrundstjänsten.

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

När Dapr SDK används anropas Dapr sidovagnen via HTTP. Sidovagn Dapr vidarebefordrar sedan begäran till målservice. Då måltjänsten körs i en separat process från sidecar, körs den integrering som är relaterad till tjänsten i Dapr sidecar och ansvarar för tjänstupptäckt och dirigering av förfrågan till måltjänsten.

Nästa steg

• Dapr
• Dapr dokumentation
• Dapr GitHub repo
• .NET Aspire Dapr exempelapp
• .NET .NET Aspire integreringar
• .NET Aspire GitHub repo