integrasi .NET AspireDapr

Distributed Application Runtime (Dapr) menawarkan API pengembang yang berfungsi sebagai saluran untuk berinteraksi dengan layanan dan dependensi lain dan mengabstraksi aplikasi dari spesifik layanan dan dependensi tersebut. Dapr dan .NET Aspire dapat bekerja sama untuk meningkatkan pengalaman pengembangan lokal Anda. Dengan menggunakan Dapr dengan .NET Aspire, Anda dapat fokus pada penulisan dan penerapan aplikasi terdistribusi berbasis .NETalih-alih on-boarding lokal.

Dalam panduan ini, Anda akan mempelajari cara memanfaatkan abstraksi Daprdan konfigurasi berbasis opini .NET Aspiredari teknologi cloud untuk membangun mikrolayanan yang sederhana, portabel, tangguh, dan aman.

Membandingkan .NET Aspire dan Dapr

Pada pandangan pertama Dapr dan .NET Aspire mungkin terlihat seperti mereka memiliki fungsionalitas yang tumpang tindih, dan mereka melakukannya. Namun, mereka mengambil pendekatan yang berbeda. .NET .NET Aspire berpendapat tentang cara membangun aplikasi terdistribusi pada platform cloud dan berfokus pada peningkatan pengalaman pengembangan lokal. Dapr adalah runtime yang mengabstraksi kompleksitas umum platform cloud yang mendasarinya baik selama pengembangan maupun dalam produksi. Ini bergantung pada sidecar untuk memberikan abstraksi untuk hal-hal seperti konfigurasi, manajemen rahasia, dan pengiriman pesan. Teknologi yang mendasar dapat dengan mudah dialihkan melalui file konfigurasi, sementara kode Anda tidak perlu berubah.

.NET Aspire mempermudah penyiapan dan penelusuran kesalahan aplikasi Dapr dengan menyediakan API yang mudah digunakan untuk mengonfigurasi sidecar Dapr, dan dengan mengekspos sidecar tersebut sebagai sumber daya di dasbor.

Menjelajahi komponen Dapr dengan .NET Aspire

Dapr menyediakan banyak komponen bawaan , dan ketika Anda menggunakan Dapr dengan .NET Aspire Anda dapat dengan mudah menjelajahi dan mengonfigurasi komponen-komponen ini. Jangan bingung komponen-komponen ini dengan integrasi .NET.NET Aspire. Misalnya, pertimbangkan hal berikut:

• Dapr—Penyimpanan status: Panggil AddDaprStateStore untuk menambahkan penyimpanan status yang dikonfigurasi ke proyek .NET.NET Aspire Anda.
• Dapr—Pub Sub: Panggil AddDaprPubSub untuk menambahkan sub pub yang dikonfigurasi ke proyek .NET.NET Aspire Anda.
• Dapr—Komponen: Panggil AddDaprComponent untuk menambahkan integrasi yang dikonfigurasi ke proyek .NET.NET Aspire Anda.

Menginstal Dapr

Integrasi ini memerlukan Dapr versi 1.13 atau yang lebih baru. Untuk menginstal Dapr, lihat Menginstal CLI Dapr. Setelah menginstal CLI Dapr, jalankan dapr init, seperti yang dijelaskan dalam Inisialisasi Dapr di lingkungan lokal Anda.

Unable to locate the Dapr CLI.

Integrasi hosting

Dalam solusi .NET Aspire Anda, untuk mengintegrasikan Dapr dan mengakses tipe dan APInya, tambahkan paket NuGet 📦Aspire.Hosting.Dapr ke proyek host aplikasi .

dotnet add package Aspire.Hosting.Dapr

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

Untuk informasi selengkapnya, lihat dotnet menambahkan paket atau Mengelola dependensi paket di aplikasi .NET.

Tambahkan sidecar Dapr ke sumber daya .NET Aspire

Dapr menggunakan pola sidecar . Sidecar Dapr berjalan bersama aplikasi Anda sebagai server HTTP ringan, portabel, dan tanpa status yang mendengarkan permintaan HTTP masuk dari aplikasi Anda.

Untuk menambahkan sidecar ke sumber daya .NET.NET Aspire, panggil metode WithDaprSidecar di atasnya. Parameter appId adalah pengidentifikasi unik untuk aplikasi Dapr, tetapi bersifat opsional. Jika Anda tidak memberikan appId, nama sumber daya induk digunakan sebagai gantinya.

using Aspire.Hosting.Dapr;

var builder = DistributedApplication.CreateBuilder(args);

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

Mengonfigurasi sidecar Dapr

Metode WithDaprSidecar menawarkan kelebihan beban untuk mengonfigurasi opsi sidecar Dapr Anda seperti AppId dan berbagai port. Dalam contoh berikut, sidecar Dapr dikonfigurasi dengan port tertentu untuk GRPC, HTTP, metrik, dan ID aplikasi tertentu.

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

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

Contoh host aplikasi Dapr lengkap

Menyatukan semuanya, pertimbangkan contoh proyek host aplikasi .NET.NET Aspire berikut yang mencakup:

• Layanan API backend yang mendeklarasikan sidecar Dapr dengan nilai default.
• Proyek frontend web yang mendeklarasikan sidecar Dapr dengan opsi-opsi tertentu, seperti port yang eksplisit.

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

Saat Anda memulai solusi .NET Aspire, dasbor menampilkan sidecar Dapr sebagai sumber daya, dengan status dan lognya.

Dashboard

Gunakan sidecar Dapr dalam mengkonsumsi proyek .NET Aspire

Untuk menggunakan API dari sumber daya , Anda dapat menggunakan paket NuGet AspNetCore/ . SDK Dapr menyediakan sekumpulan API untuk berinteraksi dengan sidecar Dapr.

dotnet add package Dapr.AspNetCore

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

Menambahkan klien Dapr

Setelah diinstal ke dalam proyek ASP.NET Core, SDK dapat ditambahkan ke pembuat layanan.

builder.Services.AddDaprClient();

Memanggil metode Dapr

Instans DaprClient sekarang dapat disuntikkan ke layanan Anda untuk berinteraksi dengan sidecar Dapr melalui 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 adalah metode yang mengirim permintaan HTTP ke sidecar Dapr. Ini adalah metode generik yang mengambil:

• Kata kerja HTTP.
• ID aplikasi Dapr dari layanan yang akan dipanggil.
• Nama metode.
• Token pembatalan.

Tergantung pada kata kerja HTTP, ia juga dapat mengambil isi permintaan dan header. Parameter tipe generik adalah tipe dari tubuh respons.

File Program.cs lengkap untuk proyek frontend menunjukkan:

• Klien Dapr ditambahkan ke pembangun layanan.
• Kelas WeatherApiClient yang menggunakan klien Dapr untuk memanggil layanan backend.

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

Misalnya, dalam proyek Blazor, Anda dapat menyuntikkan kelas WeatherApiClient ke halaman Razor dan menggunakannya untuk mengakses layanan backend.

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

Ketika SDK Dapr digunakan, sidecar Dapr dipanggil melalui HTTP. Sidecar Dapr kemudian meneruskan permintaan ke layanan target. Meskipun layanan target berjalan dalam proses terpisah dari sidecar, integrasi yang terkait dengan layanan tersebut berjalan di sidecar Dapr dan menangani penemuan layanan serta perutean permintaan ke layanan target.

Langkah berikutnya

• Dapr
• Dapr dokumentasi
• Dapr GitHub repositori
• .NET Aspire Dapr aplikasi contoh
• .NET .NET Aspire integrasi
• .NET Aspire GitHub repositori