integración de .NET AspireOrleans
Orleans tiene compatibilidad integrada con .NET.NET Aspire. .NET .NET Aspiremodelo de aplicación le permite describir los servicios, las bases de datos y otros recursos e infraestructura de la aplicación y cómo se relacionan entre sí. Orleans proporciona una manera sencilla de crear aplicaciones distribuidas que son escalables elásticamente y tolerantes a errores. Puede usar .NET Aspire para configurar y orquestar Orleans y sus dependencias, como proporcionar a Orleans la pertenencia y el almacenamiento del clúster.
Orleans se representa como un recurso en .NET Aspire. A diferencia de otras integraciones, la integración de Orleans no crea un contenedor y no requiere un paquete de integración de client independiente. En su lugar, complete la configuración de Orleans en el proyecto de host de la aplicación .NET Aspire.
Nota
Esta integración requiere Orleans versión 8.1.0 o posterior.
Integración de hospedaje
La integración de Orleans modela un servicio Orleans como el tipo OrleansService. "Para acceder a este tipo y las API, agregue el paquete de NuGet 📦Aspire.Hosting.Orleans en el proyecto del host de la aplicación ."
dotnet add package Aspire.Hosting.Orleans
Para obtener más información, consulte dotnet add package o Administrar las dependencias de paquetes en aplicaciones .NET.
Añade un recurso Orleans
En el proyecto host de tu aplicación, llama a AddOrleans para agregar y devolver un constructor de recursos del servicio Orleans. El nombre proporcionado al recurso Orleans es para fines de diagnóstico. Para la mayoría de las aplicaciones, basta un valor de "default".
var orleans = builder.AddOrleans("default")
Utilice el almacenamiento Azure para tablas de clústeres y almacenamiento de granos.
En una aplicación de
Orleans los hosts se registran en una base de datos y usan esa base de datos para buscarse entre sí y formar un clúster. Almacenan en una tabla de base de datos qué servidores son miembros de qué silos. Puede usar bases de datos relacionales o NoSQL para almacenar esta información. En una aplicación de .NET.NET Aspire, una opción popular para almacenar esta tabla es Azure Table Storage.
Para configurar Orleans con clustering y almacenamiento de granos en Azure, instale el paquete NuGet 📦Aspire.Hosting.Azure.Storage en el proyecto host de la aplicación.
dotnet add package Aspire.Hosting.Azure.Storage
En el proyecto host de la aplicación, después de llamar a AddOrleans, configure el recurso Orleans con agrupación en clústeres y almacenamiento específico mediante los métodos WithClustering y WithGrainStorage, respectivamente:
// 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);
El código anterior indica Orleans que cualquier servicio que haga referencia a él también debe hacer referencia al recurso clusteringTable.
Adición de un proyecto de Orleansserver en el host de la aplicación
Ahora puede agregar un nuevo proyecto, inscrito en la orquestación .NET Aspire, a su solución como un Orleansserver. Participará en el clúster de Orleans, sirviendo como silo con granos constituyentes. Haga referencia al recurso Orleans del proyecto server mediante WithReference(orleans). Al hacer referencia al recurso Orleans desde el servicio, también se hace referencia a esos recursos:
// 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);
Adición de un proyecto de Orleansclient en el host de la aplicación
Los clientes Orleans se comunican con granos hospedados en servidores Orleans. En una aplicación de .NET Aspire, por ejemplo, podría tener un sitio web frontal que llame a los granos en un clúster de Orleans. Haga referencia al recurso de Orleans desde el Orleansclient mediante 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);
Crea el proyecto Orleansserver
Ahora que se ha completado el proyecto host de la aplicación, puede implementar el proyecto de Orleansserver. Comencemos agregando los paquetes NuGet necesarios:
En la carpeta del proyecto de Orleansserver, ejecute estos comandos:
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
A continuación, en el archivo Program.cs del proyecto Orleansserver, agregue los clientes para blob y tablas del almacenamiento Azure y luego llame a UseOrleans.
var builder = WebApplication.CreateBuilder(args);
builder.AddServiceDefaults();
builder.AddKeyedAzureTableClient("clustering");
builder.AddKeyedAzureBlobClient("grain-state");
builder.UseOrleans();
El código siguiente es un ejemplo completo de un proyecto de Orleansserver, incluido un grano denominado 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;
}
}
Crea un proyecto Orleansclient
En el proyecto de Orleansclient, agregue los mismos paquetes NuGet:
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
A continuación, en el archivo Program.cs del proyecto de Orleansclient, agregue el almacenamiento de tablas Azureclient y llame a UseOrleansClient.
builder.AddKeyedAzureTableClient("clustering");
builder.UseOrleansClient();
El código siguiente es un ejemplo completo de un proyecto de Orleansclient. Llama al grano CounterGrain definido en el ejemplo anterior Orleansserver.
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();
Habilitación de OpenTelemetry
Por convención, las soluciones de .NET.NET Aspire incluyen un proyecto para definir la configuración y el comportamiento predeterminados para el servicio. Este proyecto se llama Proyecto de Valores Predeterminados y las plantillas lo crean con un nombre que termina en ServiceDefaults. Para configurar
Modifique el método ConfigureOpenTelemetry para agregar los medidores Orleans y los instrumentos de seguimiento . En el siguiente fragmento de código se muestra el archivo modificado Extensions.cs de un proyecto predeterminado de servicio que incluye métricas y seguimientos de 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;
}
Proveedores admitidos
La integración de OrleansAspire admite actualmente un subconjunto limitado de proveedores de Orleans:
- Agrupamiento:
- Redis
- Mesas de almacenamiento Azure
- Persistencia:
- Redis
- Mesas de almacenamiento Azure
- Blobs de Almacenamiento Azure
- Recordatorios:
- Redis
- Mesas de almacenamiento Azure
- Directorio de granos:
- Redis
- Mesas de almacenamiento Azure
A partir de la versión 8.1.0 de Orleans, no se admiten los proveedores de streaming.
