Tutorial: Erstellen einer minimalen Orleans-Anwendung

Artikel
07/03/2024

In diesem Tutorial folgen Sie einer Schritt-für-Schritt-Anleitung, um die grundlegenden beweglichen Teile zu erstellen, die in den meisten Orleans-Anwendungen vorkommen. Es ist in sich abgeschlossen und minimalistisch gehalten.

In diesem Tutorial fehlen eine angemessene Fehlerbehandlung und anderer wichtiger Code, der in einer Produktionsumgebung nützlich wäre. Es sollte Ihnen jedoch dabei helfen, ein praktisches Verständnis der allgemeinen App-Struktur für Orleans zu erlangen und es Ihnen ermöglichen, Ihr weiteres Lernen auf die für Sie wichtigsten Teile zu konzentrieren.

Voraussetzungen

Projekteinrichtung

In diesem Tutorial erstellen Sie vier Projekte als Teil derselben Projektmappe:

Bibliothek, die die Körnungsschnittstellen enthält
Bibliothek, die die Körnungsklassen enthält
Konsolen-App zum Hosten des Silos
Konsolen-App zum Hosten des Clients

Erstellen der Struktur in Visual Studio

Ersetzen Sie den Standardcode durch den Code, der für jedes Projekt angegeben ist.

Erstellen Sie zunächst ein Konsolen-App-Projekt in einer neuen Projektmappe. Rufen Sie das Projektteilsilo auf, und nennen Sie die Projektmappe OrleansHelloWorld. Weitere Informationen zum Erstellen einer Konsolen-App finden Sie unter Tutorial: Erstellen einer .NET-Konsolenanwendung mit Visual Studio.
Fügen Sie ein weiteres Konsolen-App-Projekt hinzu, und nennen Sie es Client.
Fügen Sie eine Klassenbibliothek hinzu, und nennen Sie sie GrainInterfaces. Informationen zum Erstellen einer Klassenbibliothek finden Sie unter Tutorial: Erstellen einer .NET-Klassenbibliothek mit Visual Studio.
Fügen Sie eine weitere Klassenbibliothek hinzu, und nennen Sie sie Grains.

Löschen von Standardquelldateien

Löschen Sie Class1.cs aus Grains.
Löschen Sie Class1.cs aus GrainInterfaces.

Hinzufügen von Verweisen

Grains verweist auf GrainInterfaces.
Silo verweist auf Grains.
Client verweist auf GrainInterfaces.

Hinzufügen von Orleans NuGet-Paketen

Projekt	NuGet-Paket
Silo	`Microsoft.Orleans.Server` `Microsoft.Extensions.Logging.Console` `Microsoft.Extensions.Hosting`
Client	`Microsoft.Orleans.Client` `Microsoft.Extensions.Logging.Console` `Microsoft.Extensions.Hosting`
Körnungsschnittstellen	`Microsoft.Orleans.Sdk`
Auflösung	`Microsoft.Orleans.Sdk` `Microsoft.Extensions.Logging.Abstractions`

Microsoft.Orleans.Server, Microsoft.Orleans.Client und Microsoft.Orleans.Sdk sind Metapakete, die Abhängigkeiten mit sich bringen, die Sie wahrscheinlich für Silo und Client benötigen. Weitere Informationen zum Hinzufügen von Paketverweisen finden Sie unter dotnet add package oder Installieren und Verwalten von Paketen in Visual Studio mit dem NuGet-Paket-Manager.

Definieren einer Körnungsschnittstelle

Fügen Sie im Projekt GrainInterfaces eine IHello.cs-Codedatei hinzu, und definieren Sie die folgende IHello-Schnittstelle darin:

namespace GrainInterfaces;

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

Definieren einer Körnungsklasse

Fügen Sie im Grains-Projekt eine HelloGrain.cs-Codedatei hinzu, und definieren Sie die folgende Klasse darin:

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

Erstellen des Silos

Zum Erstellen des Silo-Projekts fügen Sie Code hinzu, um einen Server zu initialisieren, der die Körnungen hostet und ausführt – ein Silo. Sie verwenden den Localhost-Clusteringanbieter, mit dem Sie alles lokal ausführen können, ohne dass eine Abhängigkeit von externen Speichersystemen vorhanden ist. Weitere Informationen finden Sie unter Konfiguration für lokale Entwicklung. In diesem Beispiel führen Sie einen Cluster mit einem einzelnen Silo darin aus.

Fügen Sie program.cs des Silo-Projekts den folgenden Code hinzu:

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

Der vorangehende Code:

Konfiguriert den IHost für die Verwendung von Orleans mit der UseOrleans-Methode.
Gibt an, dass der Localhost-Clusteringanbieter mit der UseLocalhostClustering(ISiloBuilder, Int32, Int32, IPEndPoint, String, String)-Methode verwendet werden soll.
Führt den host aus und wartet, bis der Prozess beendet wird, indem auf STRG+C oder SIGTERM gelauscht wird.

Erstellen des Clients

Schließlich müssen Sie einen Client für die Kommunikation mit den Körnungen konfigurieren, ihn mit dem Cluster (mit einem einzelnen Silo) verbinden und die Körnung aufrufen. Die Clusterkonfiguration muss mit der Konfiguration übereinstimmen, die Sie für das Silo verwendet haben. Weitere Informationen finden Sie unter Cluster und 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();

Ausführen der Anwendung

Erstellen Sie die Projektmappe, und führen Sie das Silo aus. Nachdem Sie die Bestätigungsmeldung erhalten haben, dass das Silo ausgeführt wird, führen Sie den Client aus.

Um das Silo über die Befehlszeile zu starten, führen Sie den folgenden Befehl über das Verzeichnis aus, das die Projektdatei des Silos enthält:

dotnet run

Im Rahmen des Startvorgangs des Silos werden zahlreiche Ausgaben angezeigt. Nachdem die folgende Meldung angezeigt wurde, können Sie den Client ausführen:

Application started. Press Ctrl+C to shut down.

Führen Sie im Clientprojektverzeichnis denselben .NET CLI-Befehl in einem separaten Terminalfenster aus, um den Client zu starten:

dotnet run

Weitere Informationen zum Ausführen von .NET-Apps finden Sie unter dotnet run. Wenn Sie Visual Studio verwenden, können Sie mehrere Startprojekte konfigurieren.

Freigeben über