Compartilhar via

Tutorial: Criar um aplicativo mínimo de Orleans

  • Artigo

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

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

Pré-requisitos

Configuração do projeto

Para este tutorial, você criará 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 dado para cada projeto.

  1. Comece criando um projeto de Aplicativo de Console em uma nova solução. Chame o silo da parte do projeto e dê o nome OrleansHelloWorld à solução. 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

Projeto 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 granularidade Microsoft.Orleans.Sdk
Grãos Microsoft.Orleans.Sdk
Microsoft.Extensions.Logging.Abstractions

Microsoft.Orleans.Server, Microsoft.Orleans.Client e Microsoft.Orleans.Sdk são metapacotes que trazem consigo dependências das quais 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 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 interface IHello 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 dependência de sistemas de armazenamento externos. Para obter mais informações, confira Configuração de desenvolvimento local. Neste exemplo, você executa 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:

Criar o cliente

Por fim, você precisa configurar um cliente para se comunicar com os grãos, conectá-lo ao cluster (com um único silo) e invocar o grão. A configuração de clustering deve corresponder à que você usou 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ê 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.

Consulte também