Tutorial: Creación de una aplicación de Orleans mínima

Artículo
06/21/2023

En este tutorial, seguirá las instrucciones paso a paso para crear los elementos móviles fundamentales comunes a la mayoría de las aplicaciones de Orleans. Está diseñado para ser autónomo y minimalista.

Este tutorial carece de un control de errores adecuado y de otro código esencial que sería útil para un entorno de producción. Sin embargo, debería ayudarle a obtener una comprensión práctica de la estructura común de la aplicación para Orleans y permitirte centrar su aprendizaje continuado en las partes de mayor interés.

Requisitos previos

Configuración del proyecto

En este tutorial, va a crear cuatro proyectos como parte de la misma solución:

Biblioteca para contener las interfaces de grano.
Biblioteca que contiene las clases de granos.
Aplicación de consola para hospedar el silo.
Aplicación de consola para hospedar el cliente.

Creación de la estructura en Visual Studio

Reemplace el código predeterminado por el código especificado para cada proyecto.

Empiece por crear un proyecto de aplicación de consola en una nueva solución. Llame a la parte del proyecto "silo" y asigne a la solución el nombre OrleansHelloWorld. Para más información sobre cómo crear una aplicación de consola, consulte Tutorial: Creación de una aplicación de consola de .NET con Visual Studio.
Agregue otro proyecto de aplicación de consola y asígnele el nombre Client.
Agregue una biblioteca de clases y asígnele el nombre GrainInterfaces. Para información sobre cómo crear una biblioteca de clases, consulte Tutorial: Creación de una biblioteca de clases de .NET con Visual Studio.
Agregue otra biblioteca de clases y asígnele el nombre Grains.

Eliminación de los archivos de origen predeterminados

Elimine Class1.cs de Grains.
Elimine Class1.cs de GrainInterfaces.

Agregar referencias

Granos hace referencia a GrainInterfaces.
Silo hace referencia a Granos.
El cliente hace referencia a GrainInterfaces.

Adición de paquetes NuGet de Orleans

Project	Paquete de NuGet
Silo	`Microsoft.Orleans.Server` `Microsoft.Extensions.Logging.Console` `Microsoft.Extensions.Hosting`
Remoto	`Microsoft.Orleans.Client` `Microsoft.Extensions.Logging.Console` `Microsoft.Extensions.Hosting`
Interfaces de grano	`Microsoft.Orleans.Sdk`
Granos	`Microsoft.Orleans.Sdk` `Microsoft.Extensions.Logging.Abstractions`

Microsoft.Orleans.Server, Microsoft.Orleans.Client y Microsoft.Orleans.Sdk son metapaquetes que aportan dependencias que probablemente necesitará en el silo y el cliente. Para más información sobre cómo agregar referencias de paquete, consulte dotnet add package o Instalación y administración de paquetes en Visual Studio mediante el Administración de paquetes NuGet.

Definición de una interfaz de grano

En el proyecto GrainInterfaces, agregue un archivo de código IHello.cs y defina la siguiente interfaz IHello en él:

namespace GrainInterfaces;

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

Definición de una clase de grano

En el proyecto Grains, agregue un archivo de código HelloGrain.cs y defina la siguiente clase en él:

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!
            """);
    }
}

Creación del silo

Para crear el proyecto Silo, agregue código para inicializar un servidor que hospede y ejecute los granos: el silo. Use el proveedor de agrupación en clústeres localhost, que le permite ejecutar todo localmente, sin dependencia de los sistemas de almacenamiento externos. Para obtener más información, consulte Configuración de desarrollo local. En este ejemplo, ejecutará un clúster con un único silo en él.

Agregue el código siguiente a Program.cs del proyecto 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();

El código anterior:

Configura el objeto IHost para usar Orleans con el método UseOrleans.
Especifica que el proveedor de agrupación en clústeres localhost debe usarse con el método UseLocalhostClustering(ISiloBuilder, Int32, Int32, IPEndPoint, String, String).
Ejecuta host y espera a que finalice el proceso, para lo cual escucha Ctrl+C o SIGTERM.

Creación del cliente

Por último, es necesario configurar un cliente para comunicarse con nuestros granos, conectarlo al clúster (con un solo silo en él) e invocar el grano. La configuración de la agrupación en clústeres debe coincidir con la que se ha usado para el silo. Para más información, consulte Clústeres y 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();

Ejecución de la aplicación

Compile la solución y ejecute el Silo. Después de recibir el mensaje de confirmación de que el Silo se está ejecutando, ejecute el Cliente.

Para iniciar el Silo desde la línea de comandos, ejecute el siguiente comando desde el directorio que contiene el archivo de proyecto del Silo:

dotnet run

Como parte del inicio del Silo, verá numerosas salidas. Después de ver el mensaje siguiente, está listo para ejecutar el cliente:

Application started. Press Ctrl+C to shut down.

En el directorio de proyecto del cliente, ejecute el mismo comando de la CLI de .NET en una ventana de terminal independiente para iniciar el cliente:

dotnet run

Para más información sobre la ejecución de aplicaciones .NET, consulte dotnet run. Si usa Visual Studio, puede configurar varios proyectos de inicio.