Orleans grain-katalog

Korn har stabila logiska identiteter och kan aktiveras (instansieras) och inaktiveras många gånger under programmets livslängd, men högst en aktivering av korn finns när som helst. Varje gång ett korn aktiveras kan det placeras på en annan silo i klustret. När ett korn aktiveras i klustret registreras det i det globala registret, kornkatalogen. Detta säkerställer att efterföljande anrop av det kornet kommer att levereras till aktiveringen av kornet och att inga andra aktiveringar (instanser) av det kornet skapas. Kornkatalogen ansvarar för att hålla en mappning mellan en kornidentitet och var (vilken silo) den aktuella aktiveringen finns på.

Som standard Orleans använder en inbyggd distribuerad minnesintern katalog. Den här katalogen är så småningom konsekvent och partitionerad över alla silor i klustret i form av en distribuerad hash-tabell.

Från och med 3.2.0 stöder Orleans även pluggbara implementeringar av grain-katalogen.

Två sådana plugin-program ingår i 3.2.0-versionen:

• En Azure Table-implementering: Microsoft.Orleans. GrainDirectory.AzureStorage
• En Redis-butiksimplementering: Microsoft.Orleans. GrainDirectory.Redis

Du kan konfigurera vilken kornkatalogimplementering som ska användas per korntyp och du kan till och med mata in implementeringen.

Vilken kornkatalog ska du använda?

Vi rekommenderar att du alltid börjar med standardkatalogen (inbyggd distribuerad katalog i minnet). Även om det så småningom är konsekvent och tillåter tillfällig duplicerad aktivering när klustret är instabilt, är den inbyggda katalogen självförsörjande utan externa beroenden, kräver ingen konfiguration och har använts i produktion hela tiden.

När du har viss erfarenhet Orleans av och har ett användningsfall för en kornkatalog med starkare garanti för enkel aktivering och/eller vill minimera antalet korn som inaktiveras när en silo i klustret stängs av bör du överväga att använda en lagringsbaserad implementering av kornkatalogen, till exempel Redis-implementeringen. Prova att använda den för en eller några korntyper först, från och med de som är långlivade och har en betydande mängd tillstånd eller en dyr initieringsprocess.

Konfiguration

Som standard behöver du inte göra något. Den minnesinterna kornkatalogen används automatiskt och partitioneras i klustret. Om du vill använda en icke-standardkonfiguration av kornkatalogen måste du ange namnet på katalog-plugin-programmet som ska användas. Detta kan göras via ett attribut på kornklassen och med beroendeinmatning och katalog-plugin-programmet med det namnet under silokonfigurationen.

Kornkonfiguration

Ange kornkatalogens plugin-namn med GrainDirectoryAttribute:

[GrainDirectory(GrainDirectoryName = "my-grain-directory")]
public class MyGrain : Grain, IMyGrain
{
    // ...
}

Silokonfiguration

Här konfigurerar vi redis grain-katalogimplementeringen:

siloBuilder.AddRedisGrainDirectory(
    "my-grain-directory",
    options => options.ConfigurationOptions = redisConfiguration);

Azure Grain-katalogen är konfigurerad så här:

siloBuilder.AddAzureTableGrainDirectory(
    "my-grain-directory",
    options => options.ConnectionString = azureConnectionString);

Du kan konfigurera flera kataloger med olika namn att använda för olika kornklasser:

siloBuilder
    .AddRedisGrainDirectory(
        "redis-directory-1",
        options => options.ConfigurationOptions = redisConfiguration1)
    .AddRedisGrainDirectory(
        "redis-directory-2",
        options => options.ConfigurationOptions = redisConfiguration2)
    .AddAzureTableGrainDirectory(
        "azure-directory",
        options => options.ConnectionString = azureConnectionString);