integracja .NET AspireDapr

Ś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 mogą współpracować, aby poprawić lokalne środowisko deweloperskie. Korzystając z Dapr oraz .NET Aspire, można skoncentrować się na pisaniu i implementowaniu aplikacji rozproszonych opartych na .NETzamiast lokalnej integracji.

W tym przewodniku dowiesz się, jak korzystać z abstrakcji Dapri domyślnej konfiguracji .NET Aspiretechnologii chmurowych, aby tworzyć proste, przenośne, odporne i zabezpieczone mikrousługi na dużą skalę.

Porównywanie .NET Aspire i Dapr

Na pierwszy rzut oka Dapr i .NET Aspire mogą wyglądać tak, jakby miały nakładające się funkcje i działają. Jednak przyjmują różne podejścia. .NET .NET Aspire ma zdecydowane poglądy na temat tworzenia rozproszonych aplikacji na platformie chmurowej i skupia się na poprawie doświadczenia w lokalnym środowisku programistycznym. Dapr to środowisko uruchomieniowe, które abstrahuje od typowych złożoności podstawowej platformy w chmurze zarówno podczas programowania, jak i w środowisku produkcyjnym. 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:

• Dapr— magazyny stanów: wywołaj AddDaprStateStore, aby dodać skonfigurowany magazyn stanów do projektu .NET.NET Aspire.
• Dapr— Pub Sub: wywołaj AddDaprPubSub, aby dodać skonfigurowany Pub Sub do projektu .NET.NET Aspire.
• Dapr— składniki: wywołaj AddDaprComponent, aby dodać skonfigurowaną integrację do projektu .NET.NET Aspire.

Zainstaluj Dapr

Ta integracja wymaga wersji 1.13 lub nowszej Dapr. Aby zainstalować Dapr, zobacz Install the Dapr CLI(Instalowanie interfejsu wiersza polecenia Dapr). Po zainstalowaniu interfejsu wiersza poleceń Dapr uruchom dapr init, jak opisano w części "Inicjowanie Dapr w środowisku lokalnym".

Unable to locate the Dapr CLI.

Integracja hostingu

W rozwiązaniu .NET Aspire, aby zintegrować Dapr i uzyskać dostęp do jego typów i interfejsów API, dodaj 📦Aspire.Hosting.Dapr pakiet NuGet w projekcie hosta aplikacji.

dotnet add package Aspire.Hosting.Dapr

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

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

Dodawanie przyczepki Dapr do zasobów .NET Aspire

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

Aby dodać przyczepkę do zasobu .NET.NET Aspire, wywołaj metodę WithDaprSidecar. 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();

Konfigurowanie Dapr wózków bocznych

Metoda WithDaprSidecar oferuje przeciążenia, aby skonfigurować opcje Dapr przyczepki, takie jak AppId i różne 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()
{
    AppId = "FirstSidecar",
    DaprGrpcPort = 50001,
    DaprHttpPort = 3500,
    MetricsPort = 9090
};

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

Kompletny przykład hosta aplikacji Dapr

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

• Usługa API zaplecza, która deklaruje podzespół "sidecar" Dapr z wartościami domyślnymi.
• Projekt frontendowy, który deklaruje Dapr sidecar 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()
{
    AppId = "FirstSidecar",
    DaprGrpcPort = 50001,
    DaprHttpPort = 3500,
    MetricsPort = 9090
};

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

builder.Build().Run();

Po uruchomieniu rozwiązania .NET Aspire pulpit nawigacyjny wyświetla Dapr przyczepkę jako zasób z jego stanem i dziennikami.

kokpit

Korzystanie z Dapr przyczepek w projektach .NET Aspire

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

dotnet add package Dapr.AspNetCore

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

Dodaj klienta Dapr

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

builder.Services.AddDaprClient();

Wywołaj metody Dapr

Instancję DaprClient można teraz wstrzyknąć do usług, aby nawiązać interakcję z komponentem pomocniczym Dapr za pomocą zestawu 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 sidecar. Jest to metoda ogólna, która przyjmuje:

• Czasownik HTTP.
• Identyfikator aplikacji Dapr dla usługi do wywołania.
• 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:

• Klient Dapr dodawany do kreatora usług.
• Klasa WeatherApiClient, która używa klienta Dapr do wywołania 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 można wdrożyć klasę WeatherApiClient do strony Razor i użyć jej do wywołania usługi zaplecza.

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

Następne kroki

• Dapr
• Dapr dokumentacja
• Dapr GitHub repozytorium
• przykładowa aplikacja .NET AspireDapr
• .NET .NET Aspire integracje
• .NET Aspire GitHub repozytorium