Megosztás a következőn keresztül:

.NET Aspire Orleans integráció

  • Cikk

A Orleans beépített támogatással rendelkezik a .NET.NET Aspireszámára. .NET .NET Aspirealkalmazásmodellje lehetővé teszi az alkalmazás szolgáltatásainak, adatbázisainak és egyéb erőforrásainak és infrastruktúrájának leírását, valamint azok egymáshoz való viszonyát. Orleans lehetővé teszi a rugalmasan méretezhető és hibatűrő elosztott alkalmazások létrehozását. A .NET Aspire segítségével konfigurálhatja és vezényelheti Orleans és annak függőségeit, például úgy, hogy Orleans-nek biztosít fürttagságot és tárhelyet.

Orleans erőforrásként jelenik meg a .NET Aspire. A többi integrációtól eltérően a Orleans integráció nem hoz létre tárolót, és nem igényel külön ügyfél-integrációs csomagot. Ehelyett az Orleans alkalmazásgazdaprojekt .NET Aspire konfigurációját kell elvégeznie.

Jegyzet

Ehhez az integrációhoz Orleans 8.1.0-s vagy újabb verzióra van szükség.

Üzemeltetési integráció

Az integrációs Orleans a Orleans szolgáltatást OrleansService típusként modellezi. Az ilyen típusú és API-k eléréséhez adja hozzá a 📦Aspire. Hosting.Orleans NuGet-csomagot az alkalmazáshoszt projektben.

dotnet add package Aspire.Hosting.Orleans

További információért tekintse meg a dotnet add package vagy Csomagfüggőségek kezelése a .NET alkalmazásokban.

Egy Orleans-erőforrás hozzáadása

Az alkalmazásgazdaprojektben hívja meg AddOrleans egy Orleans szolgáltatáserőforrás-szerkesztő hozzáadásához és visszaküldéséhez. A Orleans erőforrásnak megadott név diagnosztikai célokra szolgál. A legtöbb alkalmazás esetében elegendő "default" érték.

var orleans = builder.AddOrleans("default")

Azure-tároló használata táblák csoportosításához és szemcsés tároláshoz

Egy Orleans alkalmazásban az alapvető építőelem egy granulátum. A gabonák tartós állapotúak lehetnek. A gabona tartós állapotát valahol tárolnia kell. Egy .NET.NET Aspire alkalmazásban Azure Blob Storage egy lehetséges hely.

Orleans gazdagépek egy adatbázisban regisztrálják magukat, amelyet arra használnak, hogy megkeressék egymást és fürtöt alkossanak. Tárolják, hogy mely kiszolgálók tagjai az adatbázistáblákban lévő silóknak. Ezeket az információkat relációs vagy NoSQL-adatbázisok használatával is tárolhatja. Egy .NET.NET Aspire alkalmazásban népszerű választás a tábla tárolására Azure Table Storage.

Ha a Orleans konfigurálását fürtözéssel és tárolással szeretné végrehajtani a Azure-ben, telepítse a 📦Aspire.Hosting.Azure.Storage NuGet-csomagot az alkalmazásgazda projektbe.

dotnet add package Aspire.Hosting.Azure.Storage

Az alkalmazásgazdaprojektben a AddOrleanshívása után konfigurálja a Orleans erőforrást fürtözéssel és adatmag-tárolással, használva a WithClustering és WithGrainStorage módszereket.

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

Az előző kód azt jelzi Orleans, hogy az arra hivatkozó összes szolgáltatásnak hivatkoznia kell a clusteringTable erőforrásra is.

Adjunk hozzá egy Orleans kiszolgálóprojektet az alkalmazás gazdagéphez.

Most hozzáadhat egy új projektet, amely .NET Aspire szinkronizálásra van regisztrálva, a megoldáshoz Orleans kiszolgálóként. Részt vesz a Orleans fürtben, mint egy siló, amelynek összetevői szemcsék. Hivatkozzon a WithReference(orleans)használatával a kiszolgálóprojektből származó Orleans erőforrásra. Amikor a szolgáltatásból hivatkozik az Orleans erőforrásra, a rendszer a következő erőforrásokra is hivatkozik:

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

Orleans ügyfélprojekt hozzáadása az alkalmazásgazda szolgáltatásban

Orleans kliens kommunikál az Orleans szervereken működő komponensekkel. Egy .NET Aspire-alkalmazásban például előfordulhat, hogy egy előtérbeli webhely meghívja a szemcséket egy Orleans-fürtben. Hivatkozzon az Orleans erőforrásra az Orleans ügyfél használatával 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);

A Orleans kiszolgálóprojekt létrehozása

Az alkalmazásgazda projekt befejezése után implementálhatja a Orleans kiszolgálóprojektet. Kezdjük a szükséges NuGet-csomagok hozzáadásával:

A Orleans kiszolgálóprojekt mappájában futtassa az alábbi parancsokat:

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

Ezután adja hozzá a Azure Storage-blob és táblázatügyfeleket a Orleans kiszolgálóprojekt Program.cs fájljához, majd hívja meg a UseOrleans-at.

var builder = WebApplication.CreateBuilder(args);

builder.AddServiceDefaults();
builder.AddKeyedAzureTableClient("clustering");
builder.AddKeyedAzureBlobClient("grain-state");
builder.UseOrleans();

Az alábbi kód egy teljes példa egy Orleans kiszolgálóprojektre, beleértve a CounterGrainnevű szemcsét is:

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;
    }
}

Orleans ügyfélprojekt létrehozása

Az Orleans ügyfélprojektben adja hozzá ugyanazokat a NuGet-csomagokat:

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

Ezután a Orleans ügyfélprojekt Program.cs fájljában adja hozzá a Azure táblatároló-ügyfelet, majd hívja meg UseOrleansClient.

builder.AddKeyedAzureTableClient("clustering");
builder.UseOrleansClient();

Az alábbi kód egy teljes példa egy Orleans ügyfélprojektre. A fenti Orleans-kiszolgáló példájában definiált CounterGrain szemcsét hívja meg:

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

A OpenTelemetry engedélyezése

Konvenció szerint .NET.NET Aspire megoldások tartalmazzák a szolgáltatás alapértelmezett konfigurációjának és viselkedésének meghatározására szolgáló projektet. Ezt a projektet a szolgáltatás alapértelmezés szerint projektnek nevezik, és a sablonok ServiceDefaultsvégződésű névvel hozzák létre. A OrleansOpenTelemetry.NET Aspire konfigurálásához alkalmazza a szolgáltatás alapértelmezett projektjének konfigurációját a Orleans megfigyelhetőségi útmutatót követve.

Módosítsa a ConfigureOpenTelemetry metódust a Orleansmérőszámok és nyomkövetési eszközök hozzáadásához. Az alábbi kódrészlet bemutatja a szolgáltatás alapértelmezett projektjében található módosított Extensions.cs fájlt, amely tartalmazza a metrikákat és a nyomkövetéseket a(z) Orleans-ből.

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;
}

Támogatott szolgáltatók

A OrleansAspire integráció jelenleg Orleans szolgáltatók egy korlátozott részét támogatja:

  • Klaszterezés
    • Redis
    • Azure Tárolótáblák
  • Kitartás:
    • Redis
    • Azure Tárolótáblák
    • Azure Tároló blobok
  • Emlékeztetők:
    • Redis
    • Azure Tárolótáblák
  • Szemcsés könyvtár:
    • Redis
    • Azure Tárolótáblák

A streamszolgáltatók nem támogatottak Orleans 8.1.0-s verziójától.

Következő lépések

Microsoft Orleans dokumentációjaSzavazási mintaalkalmazás Orleans