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

Artículo
01/31/2025

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

Este tutorial carece de control de errores adecuado y otro código esencial que sería útil para un entorno de producción. Sin embargo, debe ayudarle a comprender de forma práctica la estructura de aplicaciones común para Orleans y permitirle centrar su aprendizaje continuo en las partes más relevantes para usted.

Prerrequisitos

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 obtener 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 mediante 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 obtener información sobre cómo crear una biblioteca de clases, consulte Tutorial: Creación de una biblioteca de clases de .NET mediante Visual Studio.
Agregue otra biblioteca de clases y asígnele el nombre Grains.

Eliminación de archivos de origen predeterminados

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

Agregar referencias

Intervalos de agregación hace referencia a GrainInterfaces.
Silo hace referencia a Intervalos de agregación.
Cliente hace referencia a GrainInterfaces.

Adición de paquetes NuGet de Orleans

Proyecto	Paquete 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 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 obtener más información sobre cómo agregar referencias de paquete, consulte dotnet add package o Instalar y gestionar paquetes en Visual Studio usando el Administrador 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, un silo. Puede usar el proveedor de agrupación en clústeres localhost, que le permite ejecutar todo localmente, sin dependencia de sistemas de almacenamiento externos. Para obtener más información, vea Configuración de Desarrollo Local. En este ejemplo, ejecutas un clúster con un solo silo.

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 clústeres localhost debe usarse con el método UseLocalhostClustering(ISiloBuilder, Int32, Int32, IPEndPoint, String, String).
Ejecuta el host y espera a que finalice el proceso, escuchando Ctrl+C o SIGTERM.

Creación del cliente

Por último, debe configurar un cliente para comunicarse con los granos, conectarlo al clúster (con un solo silo en él) e invocar el grano. La configuración de agrupación en clústeres debe coincidir con la que usó para el silo. Para obtener 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 de Silo:

dotnet run

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

Application started. Press Ctrl+C to shut down.

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

dotnet run

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

Compartir a través de