.NET Aspire Dapr-Integration

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 können zusammenarbeiten, um Ihre lokale Entwicklungserfahrung zu verbessern. Durch die Verwendung von Dapr zusammen mit .NET Aspirekönnen Sie sich auf das Schreiben und Implementieren von .NET-basierten verteilten Anwendungen konzentrieren, anstatt lokale Einarbeitung.

In diesem Leitfaden erfahren Sie, wie Sie die Abstraktion von Daprund die vordefinierte Konfiguration von Cloudtechnologien durch .NET Aspirenutzen, um einfache, tragbare, robuste und sichere Mikroservices im großen Maßstab zu erstellen.

Vergleich von .NET Aspire und Dapr

Auf den ersten Blick können Dapr und .NET Aspire so aussehen, als hätten sie überlappende Funktionen, und das tun sie auch. Sie nehmen jedoch unterschiedliche Ansätze. .NET .NET Aspire hat eine klare Meinung darüber, wie verteilte Anwendungen auf einer Cloud-Plattform erstellt werden, und konzentriert sich darauf, die Erfahrung bei der lokalen Entwicklung zu verbessern. Dapr ist eine Laufzeitumgebung, die die allgemeinen Komplexitäten der zugrunde liegenden Cloudplattform sowohl während der Entwicklung als auch im produktiven Einsatz 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.

Aspekt	.NET Aspire	Dapr
Zweck	Entwickelt, um die Entwicklung von cloud nativen Lösungen auf lokalen Entwicklungscomputern zu vereinfachen.	Entwickelt, um die Entwicklung und Ausführung verteilter Apps mit allgemeinen APIs zu erleichtern, die problemlos ausgetauscht werden können.
APIs	Entwickler müssen Ressourcen-APIs mit ihren spezifischen SDKs aufrufen	Entwickler rufen APIs im Dapr Sidecar auf, wodurch der Aufruf an die richtige API weitergeleitet wird. Es ist einfach, Ressourcen-APIs auszutauschen, ohne Code in Ihren Microservices zu ändern.
Sprachen	Sie schreiben Microservices in .NET Sprachen, Go, Python, Javascript und anderen.	Sie können Dapr Sidecar-Funktionen in jeder Sprache aufrufen, die HTTP/gRPC-Schnittstellen unterstützt.
Sicherheitsrichtlinien	Enthält keine Sicherheitsrichtlinien, kann jedoch verbindungen zwischen abhängigen Ressourcen sicher konfigurieren.	Enthält anpassbare Sicherheitsrichtlinien, die steuern, welche Microservices Zugriff auf andere Dienste oder Ressourcen haben.
Einsatz	Es gibt Bereitstellungstools für Azure und Kubernetes.	Enthält keine Bereitstellungstools. Apps werden in der Regel mit Ci/CD-Systemen (Continuous Integration/Continuous Development) bereitgestellt.
Instrumententafel	Bietet eine umfassende Übersicht über die Ressourcen und deren Telemetrie und unterstützt das Überwachen aller unterstützten OTEL-Ressourcen.	Beschränkt auf Dapr-Ressourcen.

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

• Dapr– Zustandsspeicher: Rufen Sie AddDaprStateStore auf, um Ihrem .NET.NET Aspire Projekt einen konfigurierten Zustandsspeicher hinzuzufügen.
• Dapr– Pub Sub: Rufen Sie AddDaprPubSub auf, um Ihrem .NET.NET Aspire Projekt ein konfiguriertes Pub Sub hinzuzufügen.
• Dapr– Komponenten: Rufen Sie AddDaprComponent auf, um eine konfigurierte Integration zu Ihrem Projekt .NET.NET Aspire hinzuzufügen.

Installieren von Dapr

Für diese Integration ist Dapr Version 1.13 oder höher erforderlich. Um Daprzu installieren, finden Sie unter Installationsanleitung für die Dapr CLI-. Führen Sie nach der Installation der Dapr CLI die dapr initaus, wie in Initialize Dapr in Ihrer lokalen Umgebungbeschrieben.

Wichtig

Wenn Sie versuchen, die .NET Aspire Lösung ohne die Dapr CLI auszuführen, wird die folgende Fehlermeldung angezeigt:

Unable to locate the Dapr CLI.

Integration von Hosting

Fügen Sie in Ihrer .NET Aspire-Lösung die 📦Aspirehinzu, um Dapr zu integrieren und auf die zugehörigen Typen und APIs zuzugreifen. Hosting.Dapr NuGet-Paket im App-Host Projekt.

.NET CLI

dotnet add package Aspire.Hosting.Dapr

PackageReference

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

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

Hinzufügen Dapr Sidecar zu .NET Aspire Ressourcen

Dapr verwendet das Sidecar-Pattern. Das Dapr Sidecar wird zusammen mit Ihrer App als einfacher, portierbarer und zustandsloser HTTP-Server ausgeführt, der auf eingehende HTTP-Anforderungen von Ihrer App lauscht.

Rufen Sie zum Hinzufügen eines Sidecars zu einer .NET.NET Aspire-Ressource die WithDaprSidecar-Methode darauf 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();

Konfigurieren Dapr Sidecars

Die WithDaprSidecar-Methode bietet Überladungen, um Dapr-Sidecar-Optionen wie AppId oder verschiedene Ports zu konfigurieren. Im folgenden Beispiel wird das Dapr Sidecar mit bestimmten Ports für GRPC, HTTP, Metriken und eine bestimmte App-ID konfiguriert.

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

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

Vollständiges Beispiel für Dapr-App-Host

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

• Ein Back-End-API-Dienst, der ein Dapr Sidecar standardmäßig deklariert.
• Ein Web-Frontend-Projekt, das ein "Dapr Sidecar" mit bestimmten Optionen, wie expliziten Ports, deklariert.

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

Wenn Sie die .NET Aspire Lösung starten, zeigt das Dashboard das Dapr Sidecar als Ressource mit dem Status und den Protokollen an.

Verwenden von Dapr Sidecars bei der Nutzung von .NET Aspire Projekten

Um -APIs aus -Ressourcen zu verwenden, können Sie das NuGet-Paket .AspNetCore/ verwenden. 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.

.NET CLI

dotnet add package Dapr.AspNetCore

PackageReference

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

Hinzufügen Dapr Client

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

builder.Services.AddDaprClient();

Aufrufen Dapr Methoden

Eine Instanz von DaprClient kann jetzt in Ihre Dienste integriert werden, um mit dem Dapr Sidecar über das Dapr SDK zu kommunizieren.

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 die 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 Dienstes, der aufgerufen werden soll.
• Der Methodenname.
• Ein Abbruchtoken.

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:

• Der Dapr Client, der dem Service Builder hinzugefügt wird.
• Die WeatherApiClient Klasse, die den Dapr Client verwendet, um den Back-End-Dienst aufzurufen.

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 können Sie beispielsweise die WeatherApiClient Klasse in eine Razor-Seite einfügen und sie verwenden, um den Backend-Dienst aufzurufen.

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

Nächste Schritte

• Dapr
• Dapr Dokumentation
• Dapr GitHub Repo-
• .NET Aspire Dapr Beispiel-App
• .NET .NET Aspire Integrationen
• .NET Aspire GitHub repo