Esercitazione: Creare un'applicazione minima di Orleans

Articolo
01/29/2025

In questa esercitazione, seguirai istruzioni passo-passo per creare parti mobili fondamentali comuni alla maggior parte delle applicazioni Orleans. È progettato per essere indipendente e minimalista.

Questa esercitazione non dispone di una gestione degli errori appropriata e di altro codice essenziale che sarebbe utile per un ambiente di produzione. Tuttavia, dovrebbe aiutare a comprendere in modo pratico la struttura comune delle app per Orleans e consentire di concentrare l'apprendimento continuo sulle parti più rilevanti per te.

Prerequisiti

Configurazione del progetto

Per questa esercitazione si creeranno quattro progetti come parte della stessa soluzione:

Libreria che contiene le interfacce granulari.
Libreria per contenere le classi di cereali.
Applicazione console per ospitare il Silo.
App console per ospitare il client.

Creare la struttura in Visual Studio

Sostituire il codice predefinito con il codice specificato per ogni progetto.

Per iniziare, creare un progetto app console in una nuova soluzione. Denominare la parte del progetto 'silo' e la soluzione OrleansHelloWorld. Per altre informazioni sulla creazione di un'app console, vedere Esercitazione: Creare un'applicazione console .NET con Visual Studio.
Aggiungere un altro progetto App Console e denominarlo Client.
Aggiungere una libreria di classi e denominarla GrainInterfaces. Per informazioni sulla creazione di una libreria di classi, vedere Esercitazione: Creare una libreria di classi .NET con Visual Studio.
Aggiungere un'altra libreria di classi e denominarla Grains.

Eliminare i file di origine predefiniti

Eliminare Class1.cs da Grains.
Eliminare Class1.cs da GrainInterfaces.

Aggiungere riferimenti

grani riferimenti GrainInterfaces.
riferimenti silo grani.
Client riferimentiGrainInterfaces.

Aggiungere pacchetti NuGet Orleans

Progetto	Pacchetto NuGet
Silo	`Microsoft.Orleans.Server` `Microsoft.Extensions.Logging.Console` `Microsoft.Extensions.Hosting`
Cliente	`Microsoft.Orleans.Client` `Microsoft.Extensions.Logging.Console` `Microsoft.Extensions.Hosting`
Interfacce granulari	`Microsoft.Orleans.Sdk`
Grani	`Microsoft.Orleans.Sdk` `Microsoft.Extensions.Logging.Abstractions`

Microsoft.Orleans.Server, Microsoft.Orleans.Client e Microsoft.Orleans.Sdk sono metapacchetti che portano le dipendenze che probabilmente ti serviranno sul silo e sul client. Per altre informazioni sull'aggiunta di riferimenti ai pacchetti, vedere dotnet add package o Installare e gestire i pacchetti in Visual Studio usando Gestione pacchetti NuGet.

Definire un'interfaccia granulare

Nel progetto GrainInterfaces, aggiungere un file di codice IHello.cs e definire la seguente interfaccia IHello:

namespace GrainInterfaces;

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

Definire una classe granulare

Nel progetto Grani, aggiungi un file di codice HelloGrain.cs e definisci la seguente 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!
            """);
    }
}

Creare il silo

Per creare il progetto Silo, aggiungere il codice per inizializzare un server che ospita ed esegue i grani, ovvero un silo. Si usa il provider di clustering localhost, che consente di eseguire tutto in locale, senza una dipendenza da sistemi di archiviazione esterni. Per altre informazioni, vedere Configurazione di sviluppo locale. In questo esempio viene eseguito un cluster con un singolo silo.

Aggiungere il codice seguente a Program.cs del progetto 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();

Il codice precedente:

Configura il IHost per l'uso di Orleans con il metodo UseOrleans.
Specifica che il provider di clustering localhost deve essere usato con il metodo UseLocalhostClustering(ISiloBuilder, Int32, Int32, IPEndPoint, String, String).
Esegue il host e attende che il processo venga terminato, ascoltando CTRL+C o SIGTERM.

Creare il client

Infine, è necessario configurare un client per comunicare con i grani, connetterlo al cluster (con un singolo silo in esso) e richiamare la granularità. La configurazione del clustering deve corrispondere a quella usata per il silo. Per ulteriori informazioni, vedere Clusters e client.

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();

Eseguire l'applicazione

Compilare la soluzione ed eseguire il Silo. Dopo aver visualizzato il messaggio di conferma che il Silo è in esecuzione, eseguire il Client .

Per avviare silo dalla riga di comando, eseguire il comando seguente dalla directory contenente il file di progetto di Silo:

dotnet run

Verranno visualizzati numerosi output come parte dell'avvio del Silo. Dopo aver visualizzato il messaggio seguente, si è pronti per eseguire il client:

Application started. Press Ctrl+C to shut down.

Dalla directory del progetto client, esegui lo stesso comando .NET CLI in una finestra del terminale separata per avviare il client.

dotnet run

Per altre informazioni sull'esecuzione di app .NET, vedere dotnet run. Se si usa Visual Studio, è possibile configurare più progetti di avvio.

Condividi tramite