Partilhar via

Use Dapr com .NET Aspire

  • Artigo

Distributed Application Runtime (Dapr) oferece APIs de desenvolvedor que servem como um canal para interagir com outros serviços e dependências e abstraem o aplicativo das especificidades desses serviços e dependências. Dapr e .NET Aspire trabalham juntos para melhorar a sua experiência de desenvolvimento local. Usando Dapr com .NET Aspire, você pode se concentrar em escrever e implementar aplicativos distribuídos baseados em .NETem vez de gastar tempo extra com a integração local.

Neste guia, você aprenderá como aproveitar a abstração do Dapre a configuração opinativa de tecnologias de nuvem do .NET Aspirepara criar microsserviços simples, portáteis, resilientes e seguros em escala em Azure.

Pré-requisitos

Para trabalhar com .NET.NET Aspire, você precisa do seguinte instalado localmente:

Para obter mais informações, consulte a configuração e ferramentas .NET.NET Aspire, e o SDK .NET.NET Aspire.

Além dos pré-requisitos para .NET.NET Aspire, você precisará:

  • Dapr versão 1.13 ou posterior

Para instalar o Dapr, consulte Instalar a Dapr CLI. Depois de instalar a CLI do Dapr, execute o dapr init descrito em Initialize Dapr em seu ambiente local.

Importante

Se você tentar executar o aplicativo sem a CLI Dapr, receberá o seguinte erro:

Unable to locate the Dapr CLI.

Começar

Para começar, você precisa adicionar o pacote de hospedagem Dapr ao seu projeto anfitrião do aplicativo instalando o pacote NuGet 📦Aspire.Hosting.Dapr.

dotnet add package Aspire.Hosting.Dapr

Para obter mais informações, consulte dotnet add package ou Gerir dependências de pacotes em .NET aplicações.

Adicionar um sidecar Dapr

Dapr usa o padrão sidecar para ser executado junto com seu aplicativo. O sidecar Dapr funciona junto com a sua aplicação como um server HTTP leve, portátil e sem estado que escuta as solicitações HTTP recebidas da sua aplicação.

Para adicionar um sidecar a um recurso .NET.NET Aspire, chame o método WithDaprSidecar no recurso desejado. O parâmetro appId é o identificador exclusivo para o aplicativo Dapr, mas é opcional. Se não fornecer um appId, será usado o nome do recurso pai.

using Aspire.Hosting.Dapr;

var builder = DistributedApplication.CreateBuilder(args);

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

O método WithDaprSidecar oferece sobrecargas para configurar suas opções de sidecar Dapr, como ID do aplicativo e portas. No exemplo a seguir, o sidecar Dapr é configurado com portas específicas para GRPC, HTTP, métricas e um ID de aplicativo específico.

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

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

Juntando tudo, considere o seguinte exemplo de um projeto de host de aplicativo .NET.NET Aspire que inclui:

  • Uma API de back-end que declara um sidecar Dapr com valores predefinidos.
  • Um frontend que declara um sidecar Dapr com opções específicas, como portas explícitas.
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();

O painel .NET Aspire mostra o sidecar Dapr como um recurso, com o respetivo status e logs.

.NET Aspire painel mostrando os recursos de sidecar Dapr

Adicionando o SDK do Dapr

Para usar APIs Dapr de recursos .NET Aspire, você pode usar o 📦Dapr. AspNetCore/. O SDK do Dapr fornece um conjunto de APIs para interagir com os sidecars do Dapr.

Observação

Utilize a biblioteca Dapr.AspNetCore para a integração Dapr com ASP.NET (integração DI, registo de subscrições, etc.). Aplicações que não pertencem à categoriaASP.NET (como aplicações de consola) podem simplesmente usar o 📦DaprcomClient para fazer chamadas através do sidecar Dapr.

dotnet add package Dapr.AspNetCore

Uma vez instalado em um projeto ASP.NET Core, o SDK pode ser adicionado ao construtor de serviços.

builder.Services.AddDaprClient();

Uma instância de DaprClient agora pode ser injetada nos seus serviços para interagir com o sidecar Dapr através do 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 é um método que envia uma solicitação HTTP para o sidecar Dapr. É um método genérico que aceita:

  • Um verbo HTTP
  • O ID do aplicativo Dapr do serviço a ser chamado
  • O nome do método
  • Um token de cancelamento

Dependendo do verbo HTTP, ele também pode ter um corpo de solicitação e cabeçalhos. O parâmetro de tipo genérico é o tipo do corpo da resposta.

O ficheiro completo de Program.cs para o projeto de front-end mostra o seguinte:

  • O Daprclient sendo adicionado ao construtor de serviços
  • A classe WeatherApiClient que usa o Daprclient para chamar o serviço de 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 exemplo, em um projeto Blazor, a classe WeatherApiClient pode ser injetada em uma integração e usada para chamar o serviço de 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();
    }
}

Quando o Dapr SDK é utilizado, o sidecar Dapr é chamado via HTTP. Em seguida, o sidecar Dapr encaminha a solicitação para o serviço de destino. Enquanto o serviço de destino é executado em um processo separado do sidecar, a integração relacionada ao serviço é executada no sidecar Dapr e é responsável pela descoberta do serviço e roteamento da solicitação para o serviço de destino.

Dapr e .NET Aspire

À primeira vista, Dapr e .NET Aspire podem parecer ter funcionalidades sobrepostas, e têm. No entanto, ambos adotam uma abordagem diferente. .NET .NET Aspire é uma abordagem opinativa sobre como criar aplicativos distribuídos em uma plataforma de nuvem. Dapr é um ambiente de execução que elimina as complexidades habituais da plataforma de nuvem subjacente. Baseia-se em sidecars para fornecer abstrações para coisas como configuração, gestão de segredos e mensageria. A tecnologia subjacente pode ser facilmente trocada através de arquivos de configuração, enquanto seu código não precisa ser alterado.

.NET Aspire facilita a configuração e a depuração de aplicativos Dapr, fornecendo uma API simples para configurar Dapr sidecars e expondo os sidecars como recursos no painel.

Explore os componentes Dapr, com .NET Aspire

Dapr fornece muitos componentes integradose, ao utilizar o Dapr com o .NET Aspire, pode facilmente explorar e configurar esses componentes. Não confunda esses componentes com integrações .NET.NET Aspire. Por exemplo, considere o seguinte:

Próximos passos

.NET Aspire Dapr aplicativo de exemplo