Usar Dapr com .NET Aspire

Distributed Application Runtime (Dapr) oferece APIs de desenvolvedor que servem como um canal para interagir com outros serviços e dependências e abstrair o aplicativo das especificidades desses serviços e dependências. Dapr e .NET Aspire trabalham em conjunto para melhorar 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 integração local.

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

Pré-requisitos

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

• .NET 8.0 ou .NET 9.0
• Um runtime de contêiner compatível com OCI, como:
  • Docker desktop ou Podman. Para obter mais informações, consulte tempo de execução de contêiner.
• Um IDE (Ambiente de Desenvolvedor Integrado) ou um editor de código, como:
  • Visual Studio 2022 versão 17.9 ou superior (opcional)
  • Visual Studio Code (opcional)
    • C# Dev Kit: Extensão (opcional)
  • JetBrains Rider com .NET.NET Aspire plug-in (opcional)

Para obter mais informações, consulte .NET.NET Aspirede instalação e ferramentas e .NET.NET Aspiredo SDK.

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

• Dapr versão 1.13 ou posterior

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

Unable to locate the Dapr CLI.

Começar

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

dotnet add package Aspire.Hosting.Dapr

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

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

Adicionar um sidecar Dapr

Dapr usa o padrão de sidecar para ser executado junto com seu aplicativo. O sidecar Dapr é executado juntamente ao seu aplicativo, atuando como um HTTP server leve, portátil e sem estado, que escuta solicitações HTTP de entrada do seu aplicativo.

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

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 uma ID de aplicativo específica.

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 backend que declara um sidecar Dapr com configurações padrão.
• Uma interface que declara um sidecar Dapr com opções específicas, como as 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 seus status e logs.

Adicionando o SDK do Dapr

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

dotnet add package Dapr.AspNetCore

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

Depois de 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 em seus serviços para interagir com o sidecar Dapr utilizando o 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 usa:

• 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 usar um corpo da solicitação e cabeçalhos. O parâmetro de tipo genérico é o tipo do corpo da resposta.

O arquivo de Program.cs completo do projeto de front-end mostra:

• 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 de 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 SDK do Dapr é usado, o sidecar Dapr é chamado via HTTP. O sidecar Dapr encaminha a solicitação ao 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 pelo 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 de fato têm. No entanto, ambos tomam uma abordagem diferente. .NET .NET Aspire é uma abordagem opinativa sobre como criar aplicativos distribuídos em uma plataforma de nuvem. Dapr é um runtime que abstrai as complexidades comuns da plataforma de nuvem subjacente. Ele depende de sidecars para fornecer abstrações para aspectos como configuração, gestão de segredos e mensagens. A tecnologia subjacente pode ser facilmente alternada por meio de arquivos de configuração, enquanto seu código não precisa ser alterado.

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

Explorar componentes Dapr com .NET Aspire

Dapr fornece muitos componentes internos e quando você usa Dapr com .NET Aspire você pode explorar e configurar esses componentes facilmente. Não confunda esses componentes com integrações .NET.NET Aspire. Por exemplo, considere o seguinte:

• Dapr— Repositórios de estado: chame AddDaprStateStore para adicionar um repositório de estado configurado ao seu projeto de .NET.NET Aspire.
• Dapr— Pub Sub: ligue para AddDaprPubSub para adicionar um pub sub configurado a seu projeto .NET.NET Aspire.
• Dapr— Componentes: chame AddDaprComponent para adicionar uma integração configurada ao seu projeto de .NET.NET Aspire.

Próximas etapas