Tutorial: Criar um aplicativo mínimo de Orleans

Neste tutorial, siga as instruções passo a passo para criar as partes móveis fundamentais comuns à maioria dos Orleans aplicativos. Ele foi projetado para ser autossuficiente e minimalista.

Este tutorial não tem tratamento de erros apropriado e outros códigos essenciais úteis para um ambiente de produção. No entanto, ele deve ajudá-lo a obter uma compreensão prática da estrutura comum Orleans do aplicativo e permitir que você concentre seu aprendizado contínuo nas partes mais relevantes para você.

Pré-requisitos

• Visual Studio 2022 ou posterior
• SDK do .NET 8.0 ou posterior

Configuração do projeto

Para este tutorial, crie quatro projetos como parte da mesma solução:

• Uma biblioteca para conter as interfaces de granularidade.
• Uma biblioteca para conter as classes de granularidade.
• Um aplicativo de console para hospedar o Silo.
• Aplicativo de console para hospedar o Cliente.

Criar a estrutura no Visual Studio

Substitua o código padrão pelo código fornecido para cada projeto.

1. Comece criando um projeto de Aplicativo de Console em uma nova solução. Chame o projeto Silo e nomeie a solução OrleansHelloWorld. Para obter mais informações sobre como criar um aplicativo de console, consulte Tutorial: Criar um aplicativo de console .NET usando o Visual Studio.
2. Adicione outro projeto do Aplicativo de Console e nomeie-o Client.
3. Adicione uma Biblioteca de Classes e nomeie-a GrainInterfaces. Para obter informações sobre como criar uma biblioteca de classes, consulte Tutorial: Criar uma biblioteca de classes do .NET usando o Visual Studio.
4. Adicione outra Biblioteca de Classes e nomeie-a Grains.

Excluir arquivos de origem padrão

1. Exclua Class1.cs de Granularidades.
2. Excluir Class1.cs de GrainInterfaces.

Adicionar referências

1. Granularidades faz referência a GrainInterfaces.
2. Silo faz referência a Granularidades.
3. Cliente faz referência a GrainInterfaces.

Adicionar pacotes Orleans NuGet

Microsoft.Orleans.Server, Microsoft.Orleans.Cliente Microsoft.Orleans.Sdk são metapacotes que trazem dependências que você provavelmente precisará no Silo e no cliente. Para obter mais informações sobre como adicionar referências de pacote, consulte dotnet package add ou Instalar e Gerenciar Pacotes no Visual Studio usando o Gerenciador de Pacotes NuGet.

Definir uma interface de granularidade

No projeto GrainInterfaces , adicione um arquivo de código IHello.cs e defina a seguinte IHello interface:

namespace GrainInterfaces;

public interface IHello : IGrainWithIntegerKey
{
    ValueTask<string> SayHello(string greeting);
}

Definir uma classe de grãos

No projeto Grains , adicione um arquivo de código HelloGrain.cs e defina a seguinte classe:

using GrainInterfaces;
using Microsoft.Extensions.Logging;

namespace Grains;

public class HelloGrain : Grain, IHello
{
    private readonly ILogger _logger;

    public HelloGrain(ILogger<HelloGrain> logger) => _logger = logger;

    ValueTask<string> IHello.SayHello(string greeting)
    {
        _logger.LogInformation("""
            SayHello message received: greeting = "{Greeting}"
            """,
            greeting);
        
        return ValueTask.FromResult($"""

            Client said: "{greeting}", so HelloGrain says: Hello!
            """);
    }
}

Criar o silo

Para criar o projeto Silo, adicione código para inicializar um servidor que hospeda e executa os grãos— um silo. Use o provedor de clustering localhost, que permite executar tudo localmente sem depender de sistemas de armazenamento externos. Para obter mais informações, confira Configuração de desenvolvimento local. Neste exemplo, execute um cluster com um único silo.

Adicione o seguinte código ao Program.cs do projeto Silo:

using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

IHostBuilder builder = Host.CreateDefaultBuilder(args)
    .UseOrleans(silo =>
    {
        silo.UseLocalhostClustering()
            .ConfigureLogging(logging => logging.AddConsole());
    })
    .UseConsoleLifetime();

using IHost host = builder.Build();

await host.RunAsync();

O código anterior:

• Configura o IHost para usar Orleans com o método UseOrleans.
• Especifica o uso do provedor de clustering localhost com o método UseLocalhostClustering(ISiloBuilder, Int32, Int32, IPEndPoint, String, String).
• Executa o host e aguarda pelo término do processo, escutando por Ctrl+C ou SIGTERM.

Criar o cliente

Por fim, configure um cliente para se comunicar com os grãos, conecte-o ao cluster (com um único silo) e invoque o grão. A configuração de clustering deve corresponder à usada para o silo. Para obter mais informações, confira Clusters e Clientes.

using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.DependencyInjection;
using GrainInterfaces;

IHostBuilder builder = Host.CreateDefaultBuilder(args)
    .UseOrleansClient(client =>
    {
        client.UseLocalhostClustering();
    })
    .ConfigureLogging(logging => logging.AddConsole())
    .UseConsoleLifetime();

using IHost host = builder.Build();
await host.StartAsync();

IClusterClient client = host.Services.GetRequiredService<IClusterClient>();

IHello friend = client.GetGrain<IHello>(0);
string response = await friend.SayHello("Hi friend!");

Console.WriteLine($"""
    {response}

    Press any key to exit...
    """);

Console.ReadKey();

await host.StopAsync();

Executar o aplicativo

Crie a solução e execute o Silo. Depois de receber a mensagem de confirmação de que o Silo está em execução, execute o Cliente.

Para iniciar o Silo na linha de comando, execute o seguinte comando no diretório que contém o arquivo de projeto do Silo:

dotnet run

Você verá várias saídas como parte da inicialização do Silo. Depois de ver a seguinte mensagem, você estará pronto para executar o cliente:

Application started. Press Ctrl+C to shut down.

No diretório do projeto do cliente, execute o mesmo comando da CLI do .NET em uma janela de terminal separada para iniciar o cliente:

dotnet run

Para obter mais informações sobre como executar aplicativos .NET, consulte dotnet run. Se você estiver usando o Visual Studio, poderá configurar vários projetos de inicialização.

Consulte também

• Lista de pacotes do Orleans
• guia de configuração Orleans
• práticas recomendadas Orleans