Aspire Dapr integrering

Inkluderar: Värdintegrering ingår Endast värdintegrering – integrering ingår inte

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 Aspire kan samarbeta för att förbättra din lokala utvecklingsupplevelse. Genom att använda Dapr med 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 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 Aspire och Dapr

Vid första anblicken kan Dapr och Aspire se ut som om de har överlappande funktioner, och det gör de. De har dock olika tillvägagångssätt. Aspire har en bestämd uppfattning om hur du bygger distribuerade applikationer på en molnplattform och fokuserar på att förbättra den lokala utvecklingsmiljön. 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.

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 Aspire

Dapr innehåller många inbyggda komponenteroch när du använder Dapr med Aspire kan du enkelt utforska och konfigurera dessa komponenter. Blanda inte ihop dessa komponenter med 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 projektet Aspire .
• Dapr– Pub sub: Ring AddDaprPubSub för att lägga till en konfigurerad pub-sub i projektet Aspire .
• Dapr— Komponenter: Anropa AddDaprComponent för att lägga till en konfigurerad integrering i projektet Aspire .

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

Unable to locate the Dapr CLI.

Integrering av värdtjänster

Lägg till CommunityToolkit i din Aspire lösning för att integrera Dapr och komma åt dess typer och API:er.📦Aspire Gästfrihet.Dapr NuGet-paket i AppHost-projektet.

dotnet add package CommunityToolkit.Aspire.Hosting.Dapr

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

Mer information finns i dotnet lägg till paket eller Hantera paketberoenden i .NET applikationer.

Lägg till Dapr sidovagn i 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.

För att lägga till en sidovagn till en Aspire-resurs, anropa WithDaprSidecar-metoden 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 sidvagn

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 AppHost-exempel

Om du sätter ihop allt bör du överväga följande exempel på ett Aspire AppHost-projekt 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 Aspire-lösningen visar instrumentpanelen Dapr sidovagn som en resurs med dess status och loggar.

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

Om du vill använda Dapr API:er från 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.

dotnet add package Dapr.AspNetCore

<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
• Aspire Dapr exempelapp
• Aspire Integrationer
• Aspire GitHub Repo