integração .NET AspireDapr

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 podem trabalhar juntos para melhorar sua experiência de desenvolvimento local. Usando Dapr com .NET Aspire, você pode se concentrar na escrita e implementação de aplicativos distribuídos baseados em .NETem vez de na integração local.

Neste guia, você aprenderá a tirar proveito da abstração do Dapre da configuração prescritiva do .NET Aspirepara tecnologias de nuvem, a fim de 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 de fato têm. No entanto, eles tomam abordagens diferentes. .NET .NET Aspire é opinativo sobre como criar aplicativos distribuídos em uma plataforma de nuvem e se concentra em melhorar a experiência de desenvolvimento local. Dapr é um runtime que abstrai as complexidades comuns da plataforma de nuvem subjacente durante o desenvolvimento e em produção. 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.

Aspecto	.NET Aspire	Dapr
Propósito	Projetado para facilitar o desenvolvimento de soluções nativas de nuvem em computadores de desenvolvimento locais.	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 recurso usando seus SDKs específicos	Os desenvolvedores fazem chamadas para as APIs no sidecar Dapr, que encaminha a chamada para a API correta. É fácil trocar APIs de recurso sem alterar o código em seus microsserviços.
Idiomas	Você escreve microsserviços em .NET idiomas, Go, Python, Javascript e outros.	Você pode chamar as funções sidecar Dapr em qualquer linguagem que dê suporte a 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 inter dependentes.	Inclui políticas de segurança personalizáveis que controlam quais microsserviços têm acesso a outros serviços ou recursos.
Implantação	Há ferramentas de implantação para Azure e Kubernetes.	Não inclui ferramentas de implantação. Os aplicativos geralmente são implantados com sistemas de CI/CD (Integração Contínua/Desenvolvimento Contínuo).
Painel	Fornece uma visão abrangente dos recursos e de sua telemetria e suporta o monitoramento de qualquer recurso compatível com OTEL.	Limitado somente a recursos Dapr.

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

Instalar Dapr

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

Importante

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

Unable to locate the Dapr CLI.

Integração de hospedagem

Em sua solução , para integrar e acessar seus tipos e APIs, adicione o . Hospedagem. pacote NuGet no do host do aplicativo projeto.

.NET CLI

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

Dapr usa o padrão de sidecar . O sidecar Dapr opera junto ao seu aplicativo como um servidor HTTP leve, portátil e sem estado que recebe solicitações HTTP provenientes do seu aplicativo.

Para adicionar um sidecar a um recurso de .NET.NET Aspire, chame o método WithDaprSidecar nele. 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();

Configurar sidecars Dapr

O método WithDaprSidecar oferece sobrecargas para configurar suas opções de sidecar 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 uma ID de aplicativo específica.

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

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

Exemplo completo do host do 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 configurações padrão.
• Um projeto de front-end da web 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 você inicia a solução .NET Aspire, o painel mostra o sidecar Dapr como um recurso, com seu status e logs.

Usar sidecars Dapr em projetos de consumo .NET Aspire

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

Nota

Use a biblioteca de Dapr.AspNetCore para a integração Dapr com ASP.NET (integração de DI, registro de assinaturas etc.). Aplicativos nãoASP.NET (como aplicativos de console) podem apenas usar o 📦Dapr.Client fazer chamadas por meio do sidecar Dapr.

.NET CLI

dotnet add package Dapr.AspNetCore

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

Adicionar Dapr cliente

Depois de 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 agora pode ser injetada em seus serviços para interagir com o sidecar Dapr por meio do SDK do 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 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 cliente Dapr está sendo adicionado ao construtor de serviços.
• A classe WeatherApiClient que usa o cliente Dapr para chamar o serviço de back-end.

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, você pode injetar a classe WeatherApiClient em uma página Razor e usá-la para chamar o serviço de 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();
    }
}

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.

Próximas etapas

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