Tutorial: Criar um aplicativo mínimo Orleans

Artigo
07/03/2024

Neste tutorial, você segue instruções passo a passo para criar peças móveis fundamentais comuns à maioria dos Orleans aplicativos. Foi concebido para ser autónomo e minimalista.

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

Pré-requisitos

Configuração do projeto

Para este tutorial, você vai criar quatro projetos como parte da mesma solução:

Biblioteca para conter as interfaces de grão.
Biblioteca para conter as classes de grãos.
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.

Comece criando um projeto de Aplicativo de Console em uma nova solução. Chame o silo de parte do projeto 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.
Adicione outro projeto de Aplicativo de Console e nomeie-o Client.
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 .NET usando o Visual Studio.
Adicione outra Biblioteca de Classes e nomeie-a Grains.

Excluir arquivos de origem padrão

Exclua Class1.cs de Grãos.
Exclua Class1.cs de GrainInterfaces.

Adicionar referências

Grãos referencia GrainInterfaces.
Silo referencia Grãos.
O cliente faz referência a GrainInterfaces.

Adicionar Orleans pacotes NuGet

Project	Pacote NuGet
Silo	`Microsoft.Orleans.Server` `Microsoft.Extensions.Logging.Console` `Microsoft.Extensions.Hosting`
Cliente	`Microsoft.Orleans.Client` `Microsoft.Extensions.Logging.Console` `Microsoft.Extensions.Hosting`
Interfaces de Grão	`Microsoft.Orleans.Sdk`
Grãos	`Microsoft.Orleans.Sdk` `Microsoft.Extensions.Logging.Abstractions`

Microsoft.Orleans.ServerMicrosoft.Orleans.Sdk e Microsoft.Orleans.Client 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 add package ou Install and manage packages in Visual Studio using the NuGet Package Manager.

Definir uma interface de grão

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

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

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. Você usa o provedor de clustering localhost, que permite executar tudo localmente, sem depender de sistemas de armazenamento externos. Para obter mais informações, consulte Configuração de desenvolvimento local. Neste exemplo, você executa um cluster com um único silo nele.

Adicione o seguinte código a 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 UseOrleans método.
Especifica que o provedor de clustering localhost deve ser usado com o UseLocalhostClustering(ISiloBuilder, Int32, Int32, IPEndPoint, String, String) método.
Executa o host e aguarda o término do processo, ouvindo Ctrl+C ou .SIGTERM

Criar o cliente

Finalmente, você precisa configurar um cliente para se comunicar com os grãos, conectá-lo ao cluster (com um único silo nele) e invocar o grão. A configuração de clustering deve corresponder à que você usou para o silo. Para obter mais informações, consulte 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 a aplicação

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 a partir da linha de comando, execute o seguinte comando no diretório que contém o arquivo de projeto do Silo:

dotnet run

Você verá inúmeras saídas como parte da inicialização do Silo. Depois de ver a seguinte mensagem, você está 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.

Partilhar via