Freigeben über

Verwenden Sie Dapr mit .NET Aspire

  • Artikel

Verteilte Anwendungslaufzeit (Dapr) bietet Entwickler-APIs, die als Konduit für die Interaktion mit anderen Diensten und Abhängigkeiten dienen und die Anwendung aus den Besonderheiten dieser Dienste und Abhängigkeiten abstrahieren. Dapr und .NET Aspire zusammenarbeiten, um Ihre lokale Entwicklungserfahrung zu verbessern. Mithilfe von Dapr und .NET Aspirekönnen Sie sich auf das Schreiben und Implementieren von auf .NETbasierten verteilten Anwendungen konzentrieren, statt zusätzliche Zeit für das lokale Onboarding aufzuwenden.

In diesem Leitfaden erfahren Sie, wie Sie die Abstraktion von Daprund die strukturierte Konfiguration von .NET Aspirebei Cloud-Technologien nutzen können, um einfache, portable, widerstandsfähige und sichere Microservices in großem Maßstab auf Azurezu erstellen.

Voraussetzungen

Um mit .NET.NET Aspirezu arbeiten, benötigen Sie folgendes lokal installiert:

Weitere Informationen finden Sie unter .NET.NET Aspire-Setup und -Toolsund .NET.NET Aspire-SDK.

Zusätzlich zu den Voraussetzungen für .NET.NET Aspirebenötigen Sie:

  • Dapr Version 1.13 oder höher

Um Daprzu installieren, finden Sie unter Installationsanleitung für die Dapr CLI-. Nach der Installation der Dapr CLI führen Sie die in Initialize dapr init beschriebenen Dapr in Ihrer lokalen Umgebungaus.

Wichtig

Wenn Sie versuchen, die App ohne die Dapr CLI auszuführen, wird die folgende Fehlermeldung angezeigt:

Unable to locate the Dapr CLI.

Loslegen

Um zu beginnen, müssen Sie das Dapr Hosting-Paket zu Ihrem App-Host-Projekt hinzufügen, indem Sie das 📦Aspire.Hosting.Dapr NuGet-Paket installieren.

dotnet add package Aspire.Hosting.Dapr

Weitere Informationen finden Sie unter dotnet add package oder Verwalten von Paketabhängigkeiten in .NET-Anwendungen.

Hinzufügen eines Dapr Beiwagens

Dapr verwendet das Sidecar-Muster, um zusammen mit Ihrer Anwendung zu laufen. Das Dapr-Sidecar wird zusammen mit Ihrer App als einfache, tragbare und zustandslose HTTP-server ausgeführt, die auf eingehende HTTP-Anforderungen Ihrer App wartet.

Rufen Sie zum Hinzufügen eines Sidecars zu einer .NET.NET Aspire Ressource die WithDaprSidecar Methode für die gewünschte Ressource auf. Der appId-Parameter ist der eindeutige Bezeichner für die Dapr Anwendung, ist aber optional. Wenn Sie keine appIdangeben, wird stattdessen der übergeordnete Ressourcenname verwendet.

using Aspire.Hosting.Dapr;

var builder = DistributedApplication.CreateBuilder(args);

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

Die WithDaprSidecar-Methode bietet Überladungen zum Konfigurieren Ihrer Dapr Sidecar-Optionen wie App-ID und Ports. Im folgenden Beispiel wird das Dapr Sidecar mit bestimmten Ports für GRPC, HTTP, Metriken und eine bestimmte App-ID konfiguriert.

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

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

Betrachten Sie das folgende Beispiel für ein .NET.NET Aspire App-Hostprojekt, das Folgendes umfasst:

  • Eine Back-End-API, die ein Dapr Sidecar mit Standardeinstellungen deklariert.
  • Ein Frontend, das ein Dapr Sidecar mit bestimmten Optionen deklariert, z. B. Explict-Ports.
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();

Im .NET Aspire-Dashboard wird das Dapr-Sidecar als Ressource zusammen mit seinem Status und Protokollen angezeigt.

.NET Aspire Dashboard mit Dapr Sidecar-Ressourcen

Hinzufügen des Dapr SDK

Um Dapr APIs aus .NET Aspire Ressourcen zu verwenden, können Sie die 📦Daprverwenden. AspNetCore/. Das Dapr SDK bietet eine Reihe von APIs für die Interaktion mit Dapr Sidecars.

Anmerkung

Verwenden Sie die Dapr.AspNetCore-Bibliothek für die Dapr-Integration mit ASP.NET (DI-Integration, Registrierung von Abonnements usw.). Nicht-ASP.NET-Apps (z. B. Konsolen-Apps) können einfach die 📦Daprverwenden.Client Anrufe über das Dapr Sidecar zu tätigen.

dotnet add package Dapr.AspNetCore

Nach der Installation in einem ASP.NET Core Projekt kann das SDK dem Service Builder hinzugefügt werden.

builder.Services.AddDaprClient();

Eine Instanz von DaprClient kann nun in Ihre Dienste eingefügt werden, um mit dem Dapr Sidecar über das Dapr SDK zu interagieren.

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 ist eine Methode, die eine HTTP-Anforderung an das Dapr Sidecar sendet. Es handelt sich um eine generische Methode, die Folgendes verwendet:

  • Ein HTTP-Verb
  • Die Dapr App-ID des Diensts, der aufgerufen werden soll
  • Der Methodenname
  • Ein Abbruchs-Token

Je nach HTTP-Verb kann es auch einen Anforderungstext und Header annehmen. Der generische Typparameter ist der Typ des Antwortkörpers.

Die vollständige Program.cs Datei für das Frontend-Projekt zeigt:

  • Das Hinzufügen von Daprclient zum Service Builder
  • Die WeatherApiClient Klasse, die die Daprclient zum Aufrufen des Backend-Dienstes verwendet
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 einem Blazor Projekt kann beispielsweise die WeatherApiClient Klasse in eine Integration eingefügt und zum Aufrufen des Back-End-Diensts verwendet werden.

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

Wenn das Dapr SDK verwendet wird, wird das Dapr Sidecar über HTTP aufgerufen. Der Dapr Sidecar leitet dann die Anforderung an den Zieldienst weiter. Während der Zieldienst in einem separaten Prozess als der Sidecar ausgeführt wird, läuft die dienstbezogene Integration im Dapr Sidecar und ist für die Dienstentdeckung und das Routing der Anfrage an den Zieldienst verantwortlich.

Dapr und .NET Aspire

Auf den ersten Blick können Dapr und .NET Aspire so aussehen, als hätten sie überlappende Funktionen, und das tun sie auch. Beide haben jedoch einen anderen Ansatz. .NET .NET Aspire ist ein subjektiver Ansatz zur Entwicklung verteilter Anwendungen auf einer Cloud-Plattform. Dapr ist eine Laufzeitumgebung, die die allgemeinen Komplexitäten der zugrunde liegenden Cloudplattform vereinfacht. Es basiert auf Sidecars, um Abstraktionen für Dinge wie Konfiguration, geheime Verwaltung und Messaging bereitzustellen. Die zugrunde liegende Technologie kann einfach über Konfigurationsdateien umgeschaltet werden, während der Code nicht geändert werden muss.

.NET Aspire erleichtert das Einrichten und Debuggen von Dapr Anwendungen, indem es eine einfache API zum Konfigurieren von Dapr Sidecars bereitstellt und die Sidecars im Dashboard als Ressourcen sichtbar macht.

Erkunden Sie Dapr-Komponenten mit .NET Aspire

Dapr bietet viele integrierte Komponenten, und wenn Sie Dapr mit .NET Aspire verwenden, können Sie diese Komponenten ganz einfach untersuchen und konfigurieren. Verwechseln Sie diese Komponenten nicht mit .NET.NET Aspire Integrationen. Betrachten Sie beispielsweise Folgendes:

Nächste Schritte

.NET Aspire Dapr Beispiel-App