.NET Aspire Orleans integrering
Orleans har inbyggt stöd för .NET.NET Aspire. .NET .NET Aspireapplikationsmodell låter dig beskriva tjänster, databaser och andra resurser samt infrastruktur i din app och hur de förhåller sig till varandra. Orleans är ett enkelt sätt att skapa distribuerade program som är elastiskt skalbara och feltoleranta. Du kan använda .NET Aspire för att konfigurera och samordna Orleans och dess beroenden, till exempel genom att tillhandahålla Orleans med klustermedlemskap och lagring.
Orleans representeras som en resurs i .NET Aspire. Till skillnad från andra integreringar skapar Orleans inte en container och kräver inte ett separat klientintegreringspaket. I stället slutför du Orleans konfigurationen i .NET Aspire appvärdprojektet.
Not
Den här integreringen kräver Orleans version 8.1.0 eller senare.
Värdintegrering
Orleans värdintegration modellerar en Orleans tjänst som OrleansService typ. Om du vill komma åt den här typen och API:erna lägger du till 📦Aspire.Hosting.Orleans NuGet-paketet i programvärd projektet.
dotnet add package Aspire.Hosting.Orleans
Mer information finns i dotnet add package eller Hantera paketberoenden i .NET-applikationer.
Lägga till en Orleans resurs
I ditt appvärdprojekt anropar du AddOrleans för att lägga till och returnera en Orleans-tjänstresursbyggare. Namnet som ges till resursen Orleans är för diagnostiska ändamål. För de flesta program räcker det med ett värde på "default".
var orleans = builder.AddOrleans("default")
Använda Azure lagring för klustring av tabeller och kornlagring
I en Orleans-app är den grundläggande byggstenen en -korn. Korn kan ha varaktiga tillstånd. Du måste lagra det varaktiga tillståndet för ett korn någonstans. I ett .NET.NET Aspire program är Azure Blob Storage en möjlig plats.
Orleans värdar registrerar sig i en databas och använder den databasen för att hitta varandra och bilda ett kluster. De lagrar vilka servrar som är medlemmar i vilka silor i en databastabell. Du kan använda relationsdatabaser eller NoSQL-databaser för att lagra den här informationen. I ett .NET.NET Aspire program är ett populärt val att lagra den här tabellen Azure Table Storage.
Om du vill konfigurera Orleans med klustring och kornlagring i Azureinstallerar du 📦Aspire.Hosting.Azure.Storage NuGet-paketet i appvärdsprojektet:
dotnet add package Aspire.Hosting.Azure.Storage
När du har anropat AddOrleansi programvärdprojektet konfigurerar du Orleans resursen med klustring och kornlagring med hjälp av metoderna WithClustering respektive 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);
Föregående kod anger Orleans att alla tjänster som refererar till den också måste referera till clusteringTable resursen.
Lägga till ett Orleans-serverprojekt i appvärden
Nu kan du lägga till ett nytt projekt, registrerat i .NET Aspire orkestrering, i din lösning som en Orleans server. Det kommer att delta i det Orleans klustret som en silo med ingående korn. Referera till resursen Orleans från serverprojektet genom WithReference(orleans). När du refererar till den Orleans resursen från din tjänst refereras även dessa resurser till:
// 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);
Lägg till ett Orleans klientprojekt i appens värd
Orleans klienter kommunicerar med korn som finns på Orleans servrar. I en .NET Aspire-app kan du till exempel ha en frontend-webbplats som anropar grains i ett Orleans-kluster. Referera till Orleans-resursen från din Orleans-klient med hjälp av WithReference(orleans.AsClient()).
// 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);
Skapa Orleans-serverprojektet
Nu när värdprojektet för appen har slutförts kan du implementera Orleans-serverprojektet. Vi börjar med att lägga till nödvändiga NuGet-paket:
Kör följande kommandon i mappen för Orleans-serverprojektet:
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
Lägg sedan till Azure Storage-blob- och tabellklienter i Program.cs-filen för ditt Orleans-serverprojekt och anropa sedan UseOrleans.
var builder = WebApplication.CreateBuilder(args);
builder.AddServiceDefaults();
builder.AddKeyedAzureTableClient("clustering");
builder.AddKeyedAzureBlobClient("grain-state");
builder.UseOrleans();
Följande kod är ett fullständigt exempel på ett Orleans serverprojekt, inklusive ett korn med namnet 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;
}
}
Skapa ett Orleans klientprojekt
I Orleans-klientprojektet lägger du till samma NuGet-paket:
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
Lägg sedan till Azure-tabelllagringsklienten i Program.cs-filen för ditt Orleans-klientprojekt och anropa sedan UseOrleansClient.
builder.AddKeyedAzureTableClient("clustering");
builder.UseOrleansClient();
Följande kod är ett fullständigt exempel på ett Orleans klientprojekt. Den anropar det CounterGrain grain som definierats i Orleans serverexemplet ovan:
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();
Aktivera OpenTelemetry
Enligt konventionen innehåller .NET.NET Aspire lösningar ett projekt för att definiera standardkonfiguration och beteende för din tjänst. Det här projektet kallas ServiceDefaults-projektet och mallarna skapar det med ett namn som slutar på ServiceDefaults. Om du vill konfigurera Orleans för OpenTelemetry i .NET Aspireanvänder du konfigurationen för standardprojektet för tjänsten enligt Orleans observability guide.
Ändra metoden ConfigureOpenTelemetry för att lägga till mätare Orleansoch spårningsinstrument . Följande kodfragment visar den ändrade Extensions.cs filen från ett tjänststandardprojekt som innehåller mått och spårningar från Orleans.
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;
}
Leverantörer som stöds
Orleans Aspire-integreringen stöder en begränsad mängd av Orleans leverantörer idag.
- Klustring:
- Redis
- Azure lagringstabeller
- Ståndaktighet:
- Redis
- Azure lagringstabeller
- Azure lagringsblobar
- Påminnelser:
- Redis
- Azure lagringstabeller
- Grain-katalog:
- Redis
- Azure lagringstabeller
Streamingleverantörer stöds inte från och med Orleans version 8.1.0.
Nästa steg
.NET Aspire