Delen via

Dapr gebruiken met .NET Aspire

  • Artikel

Distributed Application Runtime (Dapr) biedt ontwikkelaars-API's die fungeren als een kanaal voor interactie met andere services en afhankelijke modules en haalt de toepassing los van de specifieke kenmerken van deze services en modules. Dapr en .NET Aspire samenwerken om uw lokale ontwikkelervaring te verbeteren. Door Dapr te gebruiken met .NET Aspire, kunt u zich richten op het schrijven en implementeren van gedistribueerde .NETtoepassingen in plaats van extra tijd te besteden aan lokale onboarding.

In deze handleiding leert u hoe u kunt profiteren van de abstractie van Dapren .NET Aspire's mening over de configuratie van cloudtechnologieën om eenvoudige, draagbare, tolerante en beveiligde microservices op schaal te bouwen op Azure.

Voorwaarden

Als u met .NET.NET Aspirewilt werken, hebt u het volgende lokaal geïnstalleerd:

Zie .NET.NET Aspire setup en hulpprogramma'sen .NET.NET Aspire SDK-voor meer informatie.

Naast de vereisten voor .NET.NET Aspirehebt u het volgende nodig:

  • Dapr versie 1.13 of hoger

Om Daprte installeren, zie voor de installatie van Dapr CLI. Nadat u de Dapr CLI hebt geïnstalleerd, voert u de dapr init uit die wordt beschreven in Initialiseer Dapr in uw lokale omgeving.

Belangrijk

Als u de app probeert uit te voeren zonder de Dapr CLI, wordt de volgende fout weergegeven:

Unable to locate the Dapr CLI.

Aan de slag

Om aan de slag te gaan, moet u het Dapr-hostingpakket toevoegen aan uw app-hostproject door het 📦Aspire.HostingDapr NuGet-pakket te installeren.

dotnet add package Aspire.Hosting.Dapr

Zie dotnet pakket toevoegen of Pakketafhankelijkheden beheren in .NET toepassingenvoor meer informatie.

Een Dapr sidecar toevoegen

Dapr gebruikt het sidecar-patroon om naast uw toepassing te draaien. De Dapr-sidecar draait naast je app als een lichtgewicht, draagbare en stateless HTTP-server die inkomende HTTP-verzoeken van je app ontvangt.

Als u een sidecar wilt toevoegen aan een .NET.NET Aspire-resource, roept u de WithDaprSidecar methode aan voor de gewenste resource. De parameter appId is de unieke id voor de Dapr toepassing, maar dit is optioneel. Als u geen appIdopgeeft, wordt in plaats daarvan de naam van de ouderresource gebruikt.

using Aspire.Hosting.Dapr;

var builder = DistributedApplication.CreateBuilder(args);

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

De methode WithDaprSidecar biedt overbelastingen voor het configureren van uw Dapr sidecar-opties, zoals app-id en poorten. In het volgende voorbeeld is de Dapr sidecar geconfigureerd met specifieke poorten voor GRPC, HTTP, metrische gegevens en een specifieke app-id.

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

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

Denk aan het volgende voorbeeld van een .NET.NET Aspire app-hostproject dat alles samenbrengt:

  • Een back-end-API die een Dapr sidecar met standaardinstellingen declareert.
  • Een front-end die een Dapr sidecar declareert met specifieke opties, zoals expliciete poorten.
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();

Het .NET Aspire dashboard toont de Dapr sidecar als resource, met de status en logboeken.

.NET Aspire dashboard met Dapr sidecarbronnen

De Dapr SDK toevoegen

Als u Dapr API's van .NET Aspire resources wilt gebruiken, kunt u de 📦Dapr.AspNetCore/gebruiken. De Dapr SDK biedt een set API's voor interactie met Dapr sidecars.

Notitie

Gebruik de Dapr.AspNetCore-bibliotheek voor de Dapr-integratie met ASP.NET (DI-integratie, registratie van abonnementen, enzovoort). Niet-ASP.NET apps (zoals console-apps) kunnen alleen de 📦Daprgebruiken.Client bellen via de Dapr sidecar.

dotnet add package Dapr.AspNetCore

Nadat de SDK is geïnstalleerd in een ASP.NET Core-project, kan de SDK worden toegevoegd aan de servicebouwer.

builder.Services.AddDaprClient();

Een exemplaar van DaprClient kan nu worden geïnjecteerd in uw services om te communiceren met de Dapr sidecar via de 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 is een methode waarmee een HTTP-aanvraag naar de Dapr sidecar wordt verzonden. Het is een generieke methode die:

  • Een HTTP-woord
  • De Dapr app-id van de service die moet worden aangeroepen
  • De naam van de methode
  • Een annuleringstoken

Afhankelijk van het HTTP-werkwoord kan het ook een verzoekbody en headers bevatten. De generieke typeparameter is het type van het antwoordlichaam.

In het volledige Program.cs bestand voor het front-endproject ziet u:

  • De Daprclient toegevoegd aan de servicebouwer
  • De WeatherApiClient-klasse die gebruikmaakt van de Daprclient om de back-endservice aan te roepen
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();

In een Blazor project kan de WeatherApiClient klasse bijvoorbeeld worden geïnjecteerd in een integratie en worden gebruikt om de back-endservice aan te roepen.

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

Wanneer de Dapr SDK wordt gebruikt, wordt de Dapr sidecar aangeroepen via HTTP. De Dapr sidecar stuurt de aanvraag vervolgens door naar de doelservice. Terwijl de doeldienst wordt uitgevoerd in een afzonderlijk proces dan de sidecar, wordt de integratie die verband houdt met de dienst uitgevoerd in de Dapr sidecar en is verantwoordelijk voor dienstontdekking en het routeren van het verzoek naar de doeldienst.

Dapr en .NET Aspire

Op het eerste gezicht zien Dapr en .NET Aspire er mogelijk uit alsof ze overlappende functionaliteit hebben en dat wel. Beide hebben echter een andere aanpak. .NET .NET Aspire is een aanbevolen benadering voor het bouwen van gedistribueerde toepassingen op een cloudplatform. Dapr is een runtime waarmee de algemene complexiteit van het onderliggende cloudplatform wordt weggenomen. Het is afhankelijk van sidecars om abstracties te bieden voor zaken als configuratie, geheimbeheer en berichten. De onderliggende technologie kan eenvoudig worden overgeschakeld via configuratiebestanden, terwijl uw code niet hoeft te veranderen.

.NET Aspire maakt het instellen en opsporen van fouten in Dapr toepassingen eenvoudiger door een eenvoudige API te bieden voor het configureren van Dapr sidecars en door de sidecars weer te geven als resources in het dashboard.

Dapr onderdelen verkennen met .NET Aspire

Dapr biedt veel ingebouwde onderdelenen wanneer u Dapr gebruikt met .NET Aspire kunt u deze onderdelen eenvoudig verkennen en configureren. Verwar deze onderdelen niet met .NET.NET Aspire integraties. Denk bijvoorbeeld aan het volgende:

Volgende stappen

.NET Aspire Dapr voorbeeld-app