.NET Aspire Dapr integração

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 podem trabalhar juntos 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 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.

Comparando .NET Aspire e Dapr

À primeira vista, Dapr e .NET Aspire podem parecer ter funcionalidades sobrepostas, e têm. No entanto, adotam abordagens diferentes. .NET .NET Aspire é opinativo sobre como construir aplicativos distribuídos em uma plataforma de nuvem e se concentra em melhorar a experiência de desenvolvimento local. Dapr é um ambiente de execução que abstrai as complexidades comuns da plataforma de nuvem subjacente, não só durante o desenvolvimento mas também na produção. 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.

Aspeto	.NET Aspire	Dapr
Finalidade	Projetado para facilitar o desenvolvimento de soluções nativas da nuvem em computadores de desenvolvimento local.	Projetado para facilitar o desenvolvimento e a execução de aplicativos distribuídos com APIs comuns que podem ser facilmente trocadas.
APIs	Os desenvolvedores devem chamar APIs de recursos usando seus SDKs específicos	Os programadores chamam APIs no sidecar Dapr, que depois encaminha a chamada para a API correta. É fácil trocar APIs de recursos sem alterar o código em seus microsserviços.
Idiomas	Você escreve microserviços em .NET idiomas, Go, Python, Javascript e outros.	Você pode chamar funções sidecar do Dapr em qualquer linguagem de programação que suporte interfaces HTTP/gRPC.
Políticas de segurança	Não inclui políticas de segurança, mas pode configurar com segurança conexões entre recursos interdependentes.	Inclui políticas de segurança personalizáveis que controlam quais microsserviços têm acesso a outros serviços ou recursos.
Implantação	Existem ferramentas de implantação para Azure e Kubernetes.	Não inclui ferramentas de implantação. Os aplicativos geralmente são implantados com sistemas de Integração Contínua/Desenvolvimento Contínuo (CI/CD).
Painel de Controlo	Fornece uma visão abrangente dos recursos e da sua telemetria, e suporta a monitorização de qualquer recurso compatível com OTEL.	Limitado apenas a Dapr recursos.

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

• Dapr—Armazenamentos de estado: Chame AddDaprStateStore para adicionar um armazenamento de estado configurado ao seu projeto .NET.NET Aspire.
• Dapr—Pub Sub: Chame AddDaprPubSub para adicionar um sub pub configurado ao seu projeto .NET.NET Aspire.
• Dapr—Componentes: chame AddDaprComponent para adicionar uma integração configurada ao seu projeto .NET.NET Aspire.

Instalar Dapr

Esta integração requer 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, conforme descrito em Inicializar Dapr em seu ambiente local.

Importante

Se você tentar executar a solução de .NET Aspire sem a CLI Dapr, receberá o seguinte erro:

Unable to locate the Dapr CLI.

Integração de hospedagem

Na sua solução .NET Aspire, para integrar Dapr e aceder aos seus tipos e APIs, adicione o pacote NuGet 📦Aspire.Hosting.Dapr no projeto de host do aplicativo .

.NET CLI

dotnet add package Aspire.Hosting.Dapr

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

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

Adicionar o sidecar Dapr aos recursos .NET Aspire

Dapr utiliza o padrão sidecar . O sidecar Dapr é executado ao lado da sua aplicação como um servidor 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 nesse recurso. 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();

Configurar Dapr sidecars

O método WithDaprSidecar oferece sobrecargas de configuração para as opções de sidecar do seu Dapr, como AppId e várias 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()
{
    AppId = "FirstSidecar",
    DaprGrpcPort = 50001,
    DaprHttpPort = 3500,
    MetricsPort = 9090
};

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

Exemplo completo de host de aplicativo Dapr

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

• Um serviço de API de back-end que declara um sidecar (Dapr) com padrões predefinidos.
• Um projeto web 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()
{
    AppId = "FirstSidecar",
    DaprGrpcPort = 50001,
    DaprHttpPort = 3500,
    MetricsPort = 9090
};

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

builder.Build().Run();

Quando inicias a solução .NET Aspire, o painel de instrumentos exibe o sidecar Dapr como recurso, com o seu estado e registos.

Use Dapr sidecars no consumo de projetos .NET Aspire

Para utilizar as APIs Dapr a partir dos recursos .NET Aspire, pode-se usar o pacote NuGet 📦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.

.NET CLI

dotnet add package Dapr.AspNetCore

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

Adicionar Dapr cliente

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

builder.Services.AddDaprClient();

Invocar métodos Dapr

Uma instância de DaprClient pode agora 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 é o método que envia uma solicitação HTTP para o sidecar Dapr. É um método genérico que aceita:

• Um verbo HTTP.
• O Dapr ID do aplicativo 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 cliente Dapr está a ser adicionado ao construtor de serviços.
• A classe WeatherApiClient que utiliza o cliente Dapr 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, você pode injetar a classe WeatherApiClient em uma página de barbear e usá-la 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.

Próximos passos

• Dapr
• Dapr documentação
• Dapr GitHub repo
• .NET Aspire Dapr aplicativo de exemplo
• .NET .NET Aspire integrações
• .NET Aspire GitHub repo