Compartir a través de


Uso de Dapr con .NET Aspire

Distributed Application Runtime (Dapr) ofrece API de desarrollador que sirven como un conducto para interactuar con otros servicios y dependencias y abstraer la aplicación de los detalles de esos servicios y dependencias. Dapr y .NET Aspire trabajan juntos para mejorar la experiencia de desarrollo local. Al usar Dapr con .NET Aspire, puede centrarse en escribir e implementar aplicaciones distribuidas basadas en .NETen lugar de dedicar más tiempo a la incorporación local.

En esta guía, aprenderá a aprovechar la abstracción de Dapry la configuración opinada de .NET Aspirerespecto a las tecnologías en nube para crear microservicios sencillos, portátiles, resistentes y seguros a escala en Azure.

Prerrequisitos

Para trabajar con .NET.NET Aspire, necesita lo siguiente instalado localmente:

Para obtener más información, consulte configuración y herramientas de .NET.NET Aspirey sdk de .NET.NET Aspire.

Además de los requisitos previos para .NET.NET Aspire, necesitará:

  • Dapr versión 1.13 o posterior

Para instalar Dapr, consulte e instale la CLI de Dapr. Después de instalar la CLI de Dapr, ejecute el dapr init descrito en , inicialice Dapr en su entorno local.

Importante

Si intenta ejecutar la aplicación sin la CLI de Dapr, recibirá el siguiente error:

Unable to locate the Dapr CLI.

Comenzar

Para empezar, debe agregar el paquete de hosting Dapr al proyecto host de la aplicación instalando el paquete NuGet de 📦Aspire.Hosting.Dapr.

dotnet add package Aspire.Hosting.Dapr

Para obtener más información, consulte dotnet add package o Administrar las dependencias de paquetes en aplicaciones .NET.

Agregar un sidecar Dapr

Dapr usa el patrón sidecar para ejecutarse junto a tu aplicación. El componente sidecar de Dapr se ejecuta junto a tu aplicación como un server HTTP ligero, portátil y sin estado que escucha las solicitudes HTTP entrantes de tu aplicación.

Para agregar un sidecar a un recurso de .NET.NET Aspire, llame al método WithDaprSidecar en el recurso deseado. El parámetro appId es el identificador único de la aplicación Dapr, pero es opcional. Si no proporciona un appId, se usa en su lugar el nombre del recurso primario.

using Aspire.Hosting.Dapr;

var builder = DistributedApplication.CreateBuilder(args);

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

El método WithDaprSidecar ofrece sobrecargas para configurar las opciones de sidecar Dapr, como el identificador de aplicación y los puertos. En el ejemplo siguiente, el sidecar de Dapr se configura con puertos específicos para GRPC, HTTP, métricas y un identificador de aplicación específico.

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

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

Uniendo todo, considere el siguiente ejemplo de un proyecto de host de aplicación de .NET.NET Aspire que incluye:

  • Una API backend que declara un sidecar Dapr con valores predeterminados.
  • Un frontend que declara un sidecar de Dapr con opciones específicas, como puertos explícitos.
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();

El panel de .NET Aspire muestra el sidecar Dapr como un recurso, con su estado y registros.

panel de control de .NET Aspire que muestra recursos de sidecar Dapr

Adición del SDK de Dapr

Para usar las API de Dapr desde recursos de .NET Aspire, puede usar el 📦Dapr.AspNetCore/. El SDK de Dapr proporciona un conjunto de API para interactuar con Dapr sidecars.

Nota

Use la biblioteca de Dapr.AspNetCore para la integración de Dapr con ASP.NET (integración de DI, registro de suscripciones, etc.). Las aplicaciones que no pertenecen aASP.NET (como las aplicaciones de consola) pueden usar el 📦DapryClient para realizar llamadas a través del sidecar de Dapr.

dotnet add package Dapr.AspNetCore

Una vez instalado en un proyecto de ASP.NET Core, el SDK se puede agregar al generador de servicios.

builder.Services.AddDaprClient();

Puedes ahora insertar una instancia de DaprClient en tus servicios para interactuar mediante el SDK de Dapr con el sidecar de 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 es un método que envía una solicitud HTTP al sidecar de Dapr. Es un método genérico que toma:

  • Un verbo HTTP
  • El identificador de aplicación Dapr del servicio al que se va a llamar
  • Nombre del método
  • Un token de cancelación

Dependiendo del verbo HTTP, también puede aceptar un cuerpo de solicitud y encabezados. El parámetro de tipo genérico es el tipo del cuerpo de la respuesta.

El archivo de Program.cs completo del proyecto de front-end muestra:

  • Se va a agregar el Daprclient al generador de servicios.
  • La clase WeatherApiClient que utiliza el Daprclient para llamar al servicio de fondo
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();

Por ejemplo, en un proyecto de Blazor, la clase WeatherApiClient se puede insertar en una integración y usarse para llamar al servicio back-end.

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

Cuando se usa el SDK de Dapr, se llama al "sidecar" de Dapr mediante HTTP. A continuación, el sidecar Dapr reenvía la solicitud al servicio de destino. Mientras que el servicio de destino se ejecuta en un proceso separado del sidecar, la integración relacionada con el servicio se lleva a cabo en el sidecar Dapr y es responsable del descubrimiento de servicios y el enrutamiento de la solicitud al servicio de destino.

Dapr y .NET Aspire

A primera vista, Dapr y .NET Aspire pueden parecer que tienen funcionalidad superpuesta, y efectivamente lo tienen. Sin embargo, ambos toman un enfoque diferente. .NET .NET Aspire es un enfoque fundamentado sobre cómo crear aplicaciones distribuidas en una plataforma en la nube. Dapr es un entorno de ejecución que abstrae las complejidades comunes de la plataforma en la nube subyacente. Se basa en sidecars para proporcionar abstracciones de elementos como la configuración, la gestión de secretos y la mensajería. La tecnología subyacente se puede cambiar fácilmente a través de archivos de configuración, mientras que el código no necesita cambiar.

.NET Aspire facilita la configuración y depuración de aplicaciones Dapr proporcionando una API sencilla para configurar Dapr sidecars y exponiendo los sidecars como recursos en el panel.

Exploración de componentes de Dapr con .NET Aspire

Dapr proporciona muchos componentes integrados , y cuando se usa Dapr con .NET Aspire puede explorar y configurar fácilmente estos componentes. No confunda estos componentes con integraciones de .NET.NET Aspire. Por ejemplo, tenga en cuenta lo siguiente:

Pasos siguientes

aplicación de ejemplo .NET AspireDapr