Udostępnij za pośrednictwem

Użyj Dapr z .NET Aspire

  • Artykuł

Środowisko Uruchomieniowe Aplikacji Rozproszonej (Dapr) oferuje interfejsy API dla deweloperów, które służą jako kanał umożliwiający interakcję z innymi usługami i zależnościami, a także abstrahują aplikację od specyfiki tych usług i zależności. Dapr i .NET Aspire współpracują, aby poprawić lokalne środowisko programistyczne. Używając Dapr z .NET Aspire, możesz skoncentrować się na pisaniu i implementowaniu aplikacji rozproszonych opartych na .NETzamiast poświęcać dodatkowy czas na lokalne wprowadzanie.

W tym przewodniku dowiesz się, jak wykorzystać abstrakcję Daproraz charakterystyczną konfigurację .NET Aspiretechnologii chmurowych do tworzenia mikrousług na dużą skalę, które są proste, przenośne, odporne i zabezpieczone na Azure.

Warunki wstępne

Aby pracować z .NET.NET Aspire, musisz mieć zainstalowane następujące rzeczy lokalnie:

Aby uzyskać więcej informacji, zobacz .NET.NET Aspire setup and toolingi .NET.NET Aspire SDK.

Oprócz wymagań wstępnych dotyczących .NET.NET Aspire, będziesz potrzebować następujących elementów:

  • Dapr w wersji 1.13 lub nowszej

Aby zainstalować Dapr, zobacz Install the Dapr CLI(Instalowanie interfejsu wiersza polecenia Dapr). Po zainstalowaniu interfejsu wiersza polecenia Dapr, uruchom opisane dapr init w sekcji "Inicjowanie Dapr" w swoim lokalnym środowisku.

Ważny

Jeśli spróbujesz uruchomić aplikację bez interfejsu wiersza polecenia Dapr, zostanie wyświetlony następujący błąd:

Unable to locate the Dapr CLI.

Zacznij

Aby rozpocząć, musisz dodać pakiet hostingowy Dapr do projektu hosta aplikacji, instalując pakiet NuGet 📦Aspire.Hosting.Dapr.

dotnet add package Aspire.Hosting.Dapr

Aby uzyskać więcej informacji, zobacz dotnet add package lub Zarządzaj zależnościami pakietów w .NET aplikacjach.

Dodaj wózek boczny Dapr

Dapr używa wzorca przyczepki do uruchamiania obok aplikacji. Dapr sidecar działa obok aplikacji jako lekki, przenośny i bezstanowy serwer HTTP server, który nasłuchuje przychodzących żądań HTTP do twojej aplikacji.

Aby dodać przyczepkę do zasobu .NET.NET Aspire, wywołaj metodę WithDaprSidecar dla żądanego zasobu. Parametr appId jest unikatowym identyfikatorem aplikacji Dapr, ale jest opcjonalny. Jeśli nie podasz appId, zamiast tego zostanie użyta nazwa zasobu nadrzędnego.

using Aspire.Hosting.Dapr;

var builder = DistributedApplication.CreateBuilder(args);

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

Metoda WithDaprSidecar oferuje przeciążenia, aby skonfigurować opcje Dapr przyczepki, takie jak identyfikator aplikacji i porty. W poniższym przykładzie moduł sidecar Dapr jest skonfigurowany do pracy z określonymi portami dla gRPC, HTTP, metryk oraz określonym identyfikatorem aplikacji.

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

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

Rozważmy następujący przykład projektu hosta aplikacji .NET.NET Aspire, który obejmuje:

  • Interfejs API backendu, który deklaruje kontener towarzyszący Dapr z ustawieniami domyślnymi.
  • Frontend, który deklaruje sidecar Dapr z określonymi opcjami, takimi jak jawne porty.
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();

Panel kontrolny .NET Aspire przedstawia Dapr sidecar jako zasób z jego statusem i dziennikami.

kokpit .NET Aspire przedstawiający zasoby pomocnicze Dapr

Dodawanie zestawu SDK Dapr

Aby użyć interfejsów API Dapr z zasobów .NET Aspire, możesz użyć 📦Dapr. AspNetCore/. Zestaw SDK Dapr udostępnia zestaw interfejsów API do interakcji z Dapr przyczepkami.

Notatka

Użyj biblioteki Dapr.AspNetCore na potrzeby integracji Dapr z ASP.NET (integracja DI, rejestracja subskrypcji itp.). Aplikacje inne niżASP.NET (takie jak aplikacje konsolowe) mogą po prostu używać 📦Dapr.Client, aby wykonywać wywołania za pośrednictwem modułu dodatkowego Dapr.

dotnet add package Dapr.AspNetCore

Po zainstalowaniu w projekcie ASP.NET Core zestaw SDK można dodać do generatora usług.

builder.Services.AddDaprClient();

Instancję DaprClient można teraz wstrzyknąć do usług, aby współdziałać z sidecarem Dapr za pośrednictwem 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 to metoda, która wysyła żądanie HTTP do Dapr sidekara. Jest to metoda ogólna, która przyjmuje:

  • Czasownik HTTP
  • Identyfikator aplikacji usługi Dapr, którą należy wywołać
  • Nazwa metody
  • Token anulowania

W zależności od czasownika HTTP może on również przyjmować treść żądania i nagłówki. Ogólny parametr typu jest typem treści odpowiedzi.

Pełny plik Program.cs dla projektu frontendowego pokazuje:

  • Dapr client dodawane do narzędzia do budowy usług
  • Klasa WeatherApiClient, która używa Daprclient do wywoływania usługi zaplecza
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();

Na przykład w projekcie Blazor klasę WeatherApiClient można wstrzyknąć do integracji i użyć do wywołania usługi backendowej.

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

Gdy jest używany zestaw SDK Dapr, Dapr przyczepka jest wywoływana za pośrednictwem protokołu HTTP. Przyczepka Dapr następnie przekazuje żądanie do usługi docelowej. Podczas gdy usługa docelowa działa w osobnym procesie niż sidecar, integracja związana z usługą działa w sidecarze Dapr i jest odpowiedzialna za odkrywanie usług oraz kierowanie żądań do usługi docelowej.

Dapr i .NET Aspire

Na pierwszy rzut oka Dapr i .NET Aspire mogą wyglądać tak, jakby miały nakładające się funkcje i działają. Jednak obaj przyjmują inne podejście. .NET .NET Aspire to subiektywne podejście do tworzenia aplikacji rozproszonych na chmurze. Dapr to środowisko uruchomieniowe, które abstrahuje od typowych złożoności podstawowej platformy w chmurze. Opiera się on na sidecarach, aby zapewnić abstrakcje dla takich elementów, jak konfiguracja, zarządzanie tajemnicami i obsługa komunikatów. Podstawowa technologia może być łatwo przełączana za pośrednictwem plików konfiguracji, podczas gdy kod nie musi się zmieniać.

.NET Aspire ułatwia konfigurowanie i debugowanie aplikacji Dapr, zapewniając prosty interfejs API do konfigurowania Dapr przyczepek oraz uwidaczniając przyczepki jako zasoby na pulpicie nawigacyjnym.

Eksplorowanie składników Dapr za pomocą .NET Aspire

Dapr udostępnia wiele wbudowanych składników , a w przypadku korzystania z Dapr z .NET Aspire można łatwo eksplorować i konfigurować te składniki. Nie należy mylić tych składników z integracją .NET.NET Aspire. Rozważmy na przykład następujące kwestie:

Następne kroki

przykładowa aplikacja .NET AspireDapr