Compartir a través de

integración de .NET AspireDapr

  • Artículo

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 pueden trabajar 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 incorporarlas localmente.

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

Comparación de .NET Aspire y Dapr

A primera vista, Dapr y .NET Aspire pueden parecer que tienen funcionalidad superpuesta, y efectivamente lo tienen. Sin embargo, toman diferentes enfoques. .NET .NET Aspire tiene una opinión formada sobre cómo crear aplicaciones distribuidas en una plataforma en la nube y se enfoca en mejorar la experiencia de desarrollo local. Dapr es un entorno de ejecución que abstrae las complejidades comunes de la plataforma en la nube subyacente tanto durante el desarrollo como en producción. 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.

Aspecto .NET Aspire Dapr
Propósito Diseñado para facilitar el desarrollo de soluciones nativas de la nube en equipos de desarrollo local. Diseñado para facilitar el desarrollo y ejecución de aplicaciones distribuidas con API comunes que se pueden intercambiar fácilmente.
APIs Los desarrolladores deben llamar a las API de recursos mediante sus SDK específicos Los desarrolladores utilizan las API en el sidecar Dapr, que reenvía la llamada a la API correcta. Es fácil intercambiar API de recursos sin cambiar el código en los microservicios.
Idiomas Escribes microservicios en lenguajes .NET, Go, Python, Javascript y otros. Puede llamar a las funciones de sidecar Dapr en cualquier lenguaje que admita interfaces HTTP/gRPC.
Directivas de seguridad No incluye directivas de seguridad, pero puede configurar de forma segura conexiones entre recursos dependientes entre sí. Incluye directivas de seguridad personalizables que controlan qué microservicios tienen acceso a otros servicios o recursos.
Despliegue Hay herramientas de implementación para Azure y Kubernetes. No incluye herramientas de implementación. Normalmente, las aplicaciones se implementan con sistemas de integración continua/desarrollo continuo (CI/CD).
Panel de control Proporciona una vista completa de los recursos y sus datos de telemetría y admite la escucha en cualquier recurso compatible con OTEL. Limitado solo a Dapr recursos.

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

Instalar Dapr

Esta integración requiere 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, como se describe en Initialize Dapr en el entorno local.

Importante

Si intenta ejecutar la solución .NET Aspire sin la CLI de Dapr, recibirá el siguiente error:

Unable to locate the Dapr CLI.

Integración de hospedaje

En la solución de .NET Aspire, para integrar Dapr y acceder a sus tipos y API, agregue el paquete NuGet 📦Aspire.Hosting.Dapr en el proyecto de host de la aplicación .

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 el sidecar Dapr a los recursos de .NET Aspire

Dapr usa el patrón sidecar de . El sidecar Dapr se ejecuta junto con la aplicación como un servidor HTTP ligero, portátil y sin estado que escucha las solicitudes HTTP entrantes de la aplicación.

Para agregar un sidecar a un recurso de .NET.NET Aspire, llame al método WithDaprSidecar en él. 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();

Configura los sidecars de Dapr

El método WithDaprSidecar ofrece sobrecargas para configurar las opciones de sidecar de Dapr, como AppId y varios 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()
{
    AppId = "FirstSidecar",
    DaprGrpcPort = 50001,
    DaprHttpPort = 3500,
    MetricsPort = 9090
};

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

Ejemplo completo de host de aplicación de Dapr

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

  • Un servicio de API de backend que declara un sidecar Dapr con los valores predeterminados.
  • Un proyecto de frontend web 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()
{
    AppId = "FirstSidecar",
    DaprGrpcPort = 50001,
    DaprHttpPort = 3500,
    MetricsPort = 9090
};

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

builder.Build().Run();

Al iniciar la solución .NET Aspire, el panel muestra el sidecar Dapr como un recurso, con su estado y registros.

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

Utilizar los sidecars de Dapr para consumir los proyectos de .NET Aspire

Para usar las API de Dapr desde recursos de .NET Aspire, puede usar el 📦Dapr. Paquete NuGet 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

Agregar cliente Dapr

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

builder.Services.AddDaprClient();

Invocar métodos Dapr

Ahora se puede insertar una instancia de DaprClient en los servicios para interactuar con el sidecar de Dapr a través del SDK 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 el método que envía una solicitud HTTP al sidecar de Dapr. Es un método genérico que toma:

  • Un verbo HTTP.
  • El ID de aplicación Dapr del servicio al que se va a llamar.
  • Nombre del método.
  • 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:

  • El cliente Dapr que se va a agregar al generador de servicios.
  • La clase WeatherApiClient que usa el cliente Dapr para llamar al servicio 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();

Por ejemplo, en un proyecto de Blazor, puede insertar la clase WeatherApiClient en una página Razor y usarla para llamar al servicio 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();
    }
}

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.

Pasos siguientes