.NET Aspire Orleans-Integration
Orleans verfügt über integrierte Unterstützung für .NET.NET Aspire. mit .NET.NET AspireAnwendungsmodell können Sie die Dienste, Datenbanken und andere Ressourcen und Infrastruktur in Ihrer App und ihre Beziehung zueinander beschreiben. Orleans bietet eine einfache Möglichkeit, verteilte Anwendungen zu erstellen, die elastisch skalierbar und fehlertolerant sind. Sie können .NET Aspire verwenden, um Orleans und deren Abhängigkeiten zu konfigurieren und zu koordinieren, z. B. indem Sie Orleans mit Clustermitgliedschaft und Speicher bereitstellen.
Orleans wird als Ressource in .NET Aspiredargestellt. Im Gegensatz zu anderen Integrationen erstellt die Orleans-Integration keinen Container und erfordert kein separates Clientintegrationspaket. Stattdessen führen Sie die Orleans Konfiguration im .NET Aspire App-Hostprojekt aus.
Anmerkung
Für diese Integration ist Orleans Version 8.1.0 oder höher erforderlich.
Hosting Integration
Das Orleans-Host-Integrationsmodell bildet einen Orleans-Dienst als OrleansService-Typ ab. Um auf diesen Typ und diese APIs zuzugreifen, fügen Sie das 📦Aspire.Hosting.Orleans als NuGet-Paket zum -App-Host--Projekt hinzu.
dotnet add package Aspire.Hosting.Orleans
Weitere Informationen finden Sie unter dotnet add package oder Paketabhängigkeiten in .NET-Anwendungen verwalten.
Eine Orleans-Ressource hinzufügen
Rufen Sie in Ihrem App-Hostprojekt AddOrleans auf, um einen Orleans Dienstressourcen-Generator hinzuzufügen und zurückzugeben. Der Name, der der Orleans Ressource vergeben wird, dient zu Diagnosezwecken. Für die meisten Anwendungen genügt ein Wert von "default".
var orleans = builder.AddOrleans("default")
Verwenden von Azure Speicher für Clustertabellen und Kornspeicher
In einer Orleans-App ist der grundlegende Baustein ein Korn. Körner können dauerhafte Eigenschaften haben. Sie müssen den dauerhaften Zustand für ein Grain irgendwo speichern. In einer .NET.NET Aspire Anwendung ist Azure Blob Storage ein möglicher Ort.
Orleans Hosts registrieren sich selbst in einer Datenbank und verwenden diese Datenbank, um sich gegenseitig zu finden und einen Cluster zu bilden. Sie speichern, welche Server Mitglieder von Silos in einer Datenbanktabelle sind. Sie können relationale oder NoSQL-Datenbanken verwenden, um diese Informationen zu speichern. In einer .NET.NET Aspire Applikation ist Azure Table Storageeine beliebte Wahl zum Speichern dieser Tabelle.
Um Orleans mit Clustering und Datenbankspeicher in Azurezu konfigurieren, installieren Sie das 📦Aspire.Hosting.Azure.Storage NuGet-Paket im App-Host-Projekt.
dotnet add package Aspire.Hosting.Azure.Storage
Konfigurieren Sie in Ihrem App-Hostprojekt, nachdem Sie AddOrleansaufgerufen haben, die Ressource Orleans zusammen mit Clustering und Grain-Speicher mithilfe der Methoden WithClustering und WithGrainStorage.
// Add the resources which you will use for Orleans clustering and
// grain state storage.
var storage = builder.AddAzureStorage("storage").RunAsEmulator();
var clusteringTable = storage.AddTables("clustering");
var grainStorage = storage.AddBlobs("grain-state");
// Add the Orleans resource to the Aspire DistributedApplication
// builder, then configure it with Azure Table Storage for clustering
// and Azure Blob Storage for grain storage.
var orleans = builder.AddOrleans("default")
.WithClustering(clusteringTable)
.WithGrainStorage("Default", grainStorage);
Der vorangehende Code weist Orleans an, dass jeder Dienst, der auf ihn verweist, auch auf die clusteringTable-Ressource verweisen muss.
Fügen Sie ein Orleans Serverprojekt im App-Host hinzu
Jetzt können Sie Ihrer Lösung ein neues Projekt hinzufügen, das bei der .NET Aspire Orchestrierung angemeldet ist, als Orleans Server. Es wird an der Orleans Cluster als Silo mit Bestandteilkörnern teilnehmen. Verweisen Sie mithilfe von WithReference(orleans)auf die Orleans Ressource aus Ihrem Serverprojekt. Wenn Sie auf die Orleans-Ressource von Ihrem Dienst verweisen, werden diese Ressourcen ebenfalls referenziert.
// Add your server project and reference your 'orleans' resource from it.
// It can join the Orleans cluster as a silo.
// This implicitly adds references to the required resources.
// In this case, that is the 'clusteringTable' resource declared earlier.
builder.AddProject<Projects.OrleansServer>("silo")
.WithReference(orleans)
.WithReplicas(3);
Hinzufügen eines Orleans Clientprojekts im App-Host
Orleans Clients kommunizieren mit Grains, die auf Orleans Servern gehostet werden. In einer .NET Aspire-App haben Sie z. B. eine Front-End-Website, die Getreide in einem Orleans Cluster aufruft. Verweisen Sie mithilfe von WithReference(orleans.AsClient())auf die Ressource Orleans Ihres Orleans-Clients.
// Reference the Orleans resource as a client from the 'frontend'
// project so that it can connect to the Orleans cluster.
builder.AddProject<Projects.OrleansClient>("frontend")
.WithReference(orleans.AsClient())
.WithExternalHttpEndpoints()
.WithReplicas(3);
Erstellen Sie das Orleans-Server-Projekt
Nachdem das App-Hostprojekt abgeschlossen ist, können Sie das Orleans Serverprojekt implementieren. Beginnen wir mit dem Hinzufügen der erforderlichen NuGet-Pakete:
Führen Sie im Ordner für das Orleans Serverprojekt die folgenden Befehle aus:
dotnet add package Aspire.Azure.Data.Tables
dotnet add package Aspire.Azure.Storage.Blobs
dotnet add package Microsoft.Orleans.Server
dotnet add package Microsoft.Orleans.Persistence.AzureStorage
dotnet add package Microsoft.Orleans.Clustering.AzureStorage
Fügen Sie als Nächstes in der Datei Program.cs Ihres Orleans-Serverprojekts die Blob- und Tabellenclients von Azure Storage hinzu, und rufen Sie dann UseOrleansauf.
var builder = WebApplication.CreateBuilder(args);
builder.AddServiceDefaults();
builder.AddKeyedAzureTableClient("clustering");
builder.AddKeyedAzureBlobClient("grain-state");
builder.UseOrleans();
Der folgende Code ist ein vollständiges Beispiel für ein Orleans Serverprojekt, einschließlich eines Korns mit dem Namen CounterGrain:
using Orleans.Runtime;
using OrleansContracts;
var builder = WebApplication.CreateBuilder(args);
builder.AddServiceDefaults();
builder.AddKeyedAzureTableClient("clustering");
builder.AddKeyedAzureBlobClient("grain-state");
builder.UseOrleans();
var app = builder.Build();
app.MapGet("/", () => "OK");
await app.RunAsync();
public sealed class CounterGrain(
[PersistentState("count")] IPersistentState<int> count) : ICounterGrain
{
public ValueTask<int> Get()
{
return ValueTask.FromResult(count.State);
}
public async ValueTask<int> Increment()
{
var result = ++count.State;
await count.WriteStateAsync();
return result;
}
}
Erstellen eines Orleans Client-Projekts
Fügen Sie im Orleans-Clientprojekt dieselben NuGet-Pakete hinzu:
dotnet add package Aspire.Azure.Data.Tables
dotnet add package Aspire.Azure.Storage.Blobs
dotnet add package Microsoft.Orleans.Client
dotnet add package Microsoft.Orleans.Persistence.AzureStorage
dotnet add package Microsoft.Orleans.Clustering.AzureStorage
Fügen Sie als Nächstes in der Program.cs-Datei Ihres Orleans-Clientprojekts den Azure-Tabellenspeicher-Client hinzu, und rufen Sie dann UseOrleansClientauf.
builder.AddKeyedAzureTableClient("clustering");
builder.UseOrleansClient();
Der folgende Code ist ein vollständiges Beispiel für ein Orleans Clientprojekt. Es ruft die im Orleans-Serverbeispiel oben definierte CounterGrain-Einheit auf:
using OrleansContracts;
var builder = WebApplication.CreateBuilder(args);
builder.AddServiceDefaults();
builder.AddKeyedAzureTableClient("clustering");
builder.UseOrleansClient();
var app = builder.Build();
app.MapGet("/counter/{grainId}", async (IClusterClient client, string grainId) =>
{
var grain = client.GetGrain<ICounterGrain>(grainId);
return await grain.Get();
});
app.MapPost("/counter/{grainId}", async (IClusterClient client, string grainId) =>
{
var grain = client.GetGrain<ICounterGrain>(grainId);
return await grain.Increment();
});
app.UseFileServer();
await app.RunAsync();
Aktivieren von OpenTelemetry
Standardmäßig enthalten .NET.NET Aspire Lösungen ein Projekt zum Definieren der Standardkonfiguration und des Standardverhaltens für Ihren Dienst. Dieses Projekt heißt Projekt Dienststandards, und Vorlagen erstellen es mit einem Namen, der auf ServiceDefaultsendet. Um Orleans für OpenTelemetry in .NET Aspirezu konfigurieren, wenden Sie die Konfiguration auf Ihr Dienststandardprojekt an, das auf die Orleans Observability Handbuch folgt.
Ändern Sie die Methode ConfigureOpenTelemetry, um die Instrumente für OrleansMeter und Verfolgung hinzuzufügen. Der folgende Codeausschnitt zeigt die geänderte Extensions.cs Datei aus einem Dienststandardprojekt, das Metriken und Ablaufverfolgungen aus Orleansenthält.
public static IHostApplicationBuilder ConfigureOpenTelemetry(this IHostApplicationBuilder builder)
{
builder.Logging.AddOpenTelemetry(logging =>
{
logging.IncludeFormattedMessage = true;
logging.IncludeScopes = true;
});
builder.Services.AddOpenTelemetry()
.WithMetrics(metrics =>
{
metrics.AddAspNetCoreInstrumentation()
.AddHttpClientInstrumentation()
.AddRuntimeInstrumentation()
.AddMeter("Microsoft.Orleans");
})
.WithTracing(tracing =>
{
tracing.AddSource("Microsoft.Orleans.Runtime");
tracing.AddSource("Microsoft.Orleans.Application");
tracing.AddAspNetCoreInstrumentation()
.AddHttpClientInstrumentation();
});
builder.AddOpenTelemetryExporters();
return builder;
}
Unterstützte Anbieter
Die OrleansAspire-Integration unterstützt heute eine begrenzte Teilmenge von Orleans-Anbietern.
- Clusterbildung:
- Redis
- Azure Speichertabellen
- Ausdauer:
- Redis
- Azure Speichertabellen
- Azure Speicherblobs
- Erinnerungen:
- Redis
- Azure Speichertabellen
- Getreideverzeichnis:
- Redis
- Azure Speichertabellen
Streaminganbieter werden ab Orleans Version 8.1.0 nicht unterstützt.
