Tutoriel : Créer une application Orleans minimale

Article
07/03/2024

Dans ce tutoriel, vous suivez des instructions pas à pas pour créer des parties mobiles de base communes à la plupart des applications Orleans. Il est conçu pour être autonome et minimaliste.

Il manque à ce tutoriel une gestion des erreurs appropriée et d’autres éléments de code principal qui seraient utiles pour un environnement de production. Toutefois, il devrait vous aider à obtenir une compréhension pratique de la structure d’application commune pour Orleans et vous permettre de concentrer votre apprentissage continu sur les parties les plus pertinentes pour vous.

Prérequis

Configuration du projet

Pour ce tutoriel, vous allez créer quatre projets dans le cadre de la même solution :

Bibliothèque pour contenir les interfaces de grain.
Bibliothèque pour contenir les classes de grain.
Application console pour héberger le Silo.
Application console pour héberger le Client.

Créer la structure dans Visual Studio

Remplacez le code par défaut par le code donné pour chaque projet.

Commencez par créer un projet d’application console dans une nouvelle solution. Appelez le composant de projet silo et nommez la solution OrleansHelloWorld. Pour plus d’informations sur la création d’une application console, consultez Tutoriel : Créer une application console .NET à l’aide de Visual Studio.
Ajoutez un autre projet d’application console et nommez-le Client.
Ajoutez une bibliothèque de classes et nommez-la GrainInterfaces. Pour plus d’informations sur la création d’une bibliothèque de classes, consultez Tutoriel : Créer une bibliothèque de classes .NET à l’aide de Visual Studio.
Ajoutez une autre bibliothèque de classes et nommez-la Grains.

Supprimer les fichiers sources par défaut

Supprimez Class1.cs de Grains.
Supprimez Class1.cs de GrainInterfaces.

Ajouter des références

Grains fait référence à GrainInterfaces.
Silo fait référence à Grains.
Client fait référence à GrainInterfaces.

Ajouter des paquets NuGet Orleans

Project	Package NuGet
Silo	`Microsoft.Orleans.Server` `Microsoft.Extensions.Logging.Console` `Microsoft.Extensions.Hosting`
Client	`Microsoft.Orleans.Client` `Microsoft.Extensions.Logging.Console` `Microsoft.Extensions.Hosting`
Interfaces de grain	`Microsoft.Orleans.Sdk`
Grains	`Microsoft.Orleans.Sdk` `Microsoft.Extensions.Logging.Abstractions`

Microsoft.Orleans.Server, Microsoft.Orleans.Client et Microsoft.Orleans.Sdk sont des métapaquets qui apportent des dépendances dont vous aurez probablement besoin sur le silo et le client. Pour plus d’informations sur l’ajout de références de package, consultez dotnet add package ou Installer et gérer des packages dans Visual Studio à l’aide du Gestionnaire de package NuGet.

Définir une interface de grain

Dans le projet GrainInterfaces, ajoutez un fichier de code IHello.cs et définissez-y l’interface IHello suivante :

namespace GrainInterfaces;

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

Définir une classe de grain

Dans le projet Grains, ajoutez un fichier de code HelloGrain.cs et définissez-y la classe suivante :

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

Créer le silo

Pour créer le projet Silo, ajoutez du code pour initialiser un serveur qui héberge et exécute les grains : un silo. Vous utilisez le fournisseur de clustering localhost, qui vous permet de tout exécuter localement, sans dépendre de systèmes de stockage externes. Pour plus d’informations, consultez Configuration du développement local. Dans cet exemple, vous exécutez un cluster comprenant un silo unique.

Ajoutez le code suivant dans le fichier Program.cs du projet 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();

Le code précédent :

Configure le IHost à utiliser Orleans avec la méthode UseOrleans.
Spécifie que le fournisseur de clustering localhost doit être utilisé avec la méthode UseLocalhostClustering(ISiloBuilder, Int32, Int32, IPEndPoint, String, String).
Exécute le host et attend que le processus se termine, en écoutant Ctrl+C ou SIGTERM.

Création du client

Enfin, vous devez configurer un client pour communiquer avec les grains, le connecter au cluster (comprenant un seul silo) et appeler le grain. La configuration de clustering doit correspondre à celle que vous avez utilisée pour le silo. Pour plus d’informations, consultez Clusters et clients.

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

Exécution de l'application

Générez la solution et exécutez le Silo. Une fois que vous avez obtenu le message confirmant que le Silo est en cours d’exécution, exécutez le Client.

Pour démarrer le Silo à partir de la ligne de commande, exécutez la commande suivante à partir du répertoire contenant le fichier projet du Silo :

dotnet run

Vous verrez de nombreuses sorties dans le cadre du démarrage du Silo. Après avoir vu le message suivant, vous êtes prêt à exécuter le client :

Application started. Press Ctrl+C to shut down.

Dans le répertoire du projet client, exécutez la même commande CLI .NET dans une fenêtre de terminal distincte pour démarrer le client :

dotnet run

Pour plus d’informations sur l’exécution des applications .NET, consultez dotnet run. Si vous utilisez Visual Studio, vous pouvez configurer plusieurs projets de démarrage.

Partager via