Kornplacering

Orleans säkerställer att när ett kornigt anrop görs är en instans av det kornet tillgängligt i minnet på någon server i klustret för att hantera begäran. Om kornet för närvarande inte är aktivt i klustret Orleans väljs en server för att aktivera kornet. Den här processen kallas kornplacering. Placering är också ett sätt Orleans att balansera belastningen: att placera upptagna korn jämnt hjälper till att distribuera arbetsbelastningen över klustret.

Placeringsprocessen i Orleans är helt konfigurerbar. Välj bland färdiga placeringsprinciper, till exempel slumpmässig, föredrar lokal och belastningsbaserad, eller konfigurera anpassad logik. Detta ger fullständig flexibilitet när du bestämmer var korn skapas. Placera till exempel korn på en server nära de resurser som de behöver för att arbeta på eller nära andra korn som de kommunicerar med. Som standardinställning väljer Orleans en slumpmässigt kompatibel server.

Konfigurera placeringsstrategin Orleans använder globalt eller per kornklass.

Slumpmässig placering

Orleans slumpmässigt väljer en server från de kompatibla servrarna i klustret. För att konfigurera denna placeringsstrategi, lägg till RandomPlacementAttribute i grain-klassen.

Lokal placering

Om den lokala servern är kompatibel Orleans väljer du den lokala servern. Annars väljer den en slumpmässig server. Konfigurera den här placeringsstrategin genom att lägga till PreferLocalPlacementAttribute till gränsklassen.

Hash-baserad placering

Orleans hashar korn-ID till ett icke-negativt heltal och tillämpar en modulooperation med antalet kompatibla servrar. Den väljer sedan motsvarande server i listan över kompatibla servrar som sorteras efter serveradress. Observera att den här placeringen inte garanteras vara stabil när klustermedlemskapet ändras. Mer specifikt kan tillägg, borttagning eller omstart av servrar ändra den server som valts för ett angivet korn-ID. Eftersom korn som placeras med hjälp av denna strategi registreras i kornregistret, brukar inte denna förändring i placeringsbeslutet när medlemskapet ändras ha någon märkbar effekt.

Konfigurera den här placeringsstrategin genom att lägga till HashBasedPlacementAttribute till gränsklassen.

Aktiveringsbaserad placering

Den här placeringsstrategin försöker placera nya kornaktiveringar på den minst hårt belastade servern baserat på antalet nyligen upptagna korn. Den innehåller en mekanism där alla servrar regelbundet publicerar sitt totala aktiveringsantal till alla andra servrar. Placeringschefen väljer sedan en server som förväntas ha minst aktiveringar genom att undersöka det senast rapporterade aktiveringsantalet och förutsäga det aktuella antalet baserat på de senaste aktiveringarna som gjorts av placeringschefen på den aktuella servern. Chefen väljer flera servrar slumpmässigt när du gör den här förutsägelsen för att undvika att flera separata servrar överbelastar samma server. Som standard väljs två servrar slumpmässigt, men det här värdet kan konfigureras via ActivationCountBasedPlacementOptions.

Den här algoritmen baseras på avhandlingen The Power of Two Choices in Randomized Load Balancing av Michael David Mitzenmacher. Det används också i Nginx för distribuerad belastningsutjämning, enligt beskrivningen i artikeln NGINX och "Power of Two Choices" Load-Balancing Algorithm.

Konfigurera den här placeringsstrategin genom att lägga till ActivationCountBasedPlacementAttribute till gränsklassen.

Placering av tillståndslös arbetare

Tillståndslös arbetstagarplacering är en särskild placeringsstrategi som används av stateless worker grains. Den här placeringen fungerar nästan identiskt med PreferLocalPlacement, förutom att varje server kan ha flera aktiveringar av samma grain, och grainen är inte registrerad i grainkatalogen eftersom det inte finns något behov av det.

Konfigurera den här placeringsstrategin genom att lägga till StatelessWorkerAttribute till gränsklassen.

Silo-befattningsbaserad lokalisation

Detta är en deterministisk placeringsstrategi som placerar korn på silor med en specifik roll. Konfigurera den här placeringsstrategin genom att lägga till SiloRoleBasedPlacementAttribute till gränsklassen.

Resursoptimerad placering

Den resursoptimerade placeringsstrategin försöker optimera klusterresurser genom att balansera kornaktiveringar mellan silor baserat på tillgängligt minne och CPU-användning. Den tilldelar vikter till körningsstatistik för att prioritera olika resurser och beräknar en normaliserad poäng för varje silo. Silon med lägst poäng väljs för kommande aktivering. Normalisering säkerställer att varje egenskap bidrar proportionellt till den övergripande poängen. Justera vikter via ResourceOptimizedPlacementOptions baserat på specifika krav och prioriteringar för olika resurser.

Dessutom exponerar den här placeringsstrategin ett alternativ för att skapa en starkare preferens för att den lokala silon (den som tar emot begäran om att göra en ny placering) ska väljas som mål för aktiveringen. Kontrollera detta via egenskapen LocalSiloPreferenceMargin , en del av alternativen.

Dessutom ger en adaptiv algoritm online en utjämningseffekt som undviker snabba signalfall genom att omvandla signalen till en polynomliknande förfallsprocess. Detta är särskilt viktigt för CPU-användning och bidrar totalt sett till att undvika resursmättnad på silor, särskilt nyligen anslutna.

Den här algoritmen baseras på resursbaserad placering med kooperativ Kalman-filtrering med dubbla lägen.

Konfigurera den här placeringsstrategin genom att lägga till ResourceOptimizedPlacementAttribute till gränsklassen.

Välj en placeringsstrategi

Att välja lämplig strategi för kornplacering, utöver standardvärdena Orleans , kräver övervakning och utvärdering. Valet bör baseras på appens storlek och komplexitet, arbetsbelastningsegenskaper och distributionsmiljö.

Slumpmässig placering förlitar sig på lagen om stora tal, så det är vanligtvis en bra standard för oförutsägbara belastningar spridda över många korn (10 000 eller mer).

Aktiveringsbaserad placering har också ett slumpmässigt element som förlitar sig på principen med två valmöjligheter. Detta är en vanlig algoritm för distribuerad belastningsutjämning och används i populära lastbalanserare. Silos publicerar ofta körningsstatistik om andra silor i klustret, inklusive:

• Tillgängligt minne, totalt fysiskt minne och minnesanvändning.
• CPU-användning.
• Totalt antal aktiveringar och senaste aktiva aktiveringsantal.
  • Ett glidande fönster med aktiveringar som är aktiva under de senaste sekunderna, ibland kallat arbetsuppsättning för aktivering.

Från den här statistiken används endast aktiveringsantal för att fastställa belastningen på en viss silo.

I slutändan kan du experimentera med olika strategier och övervaka prestandamått för att fastställa den bästa passformen. Om du väljer rätt strategi för kornplacering optimeras prestanda, skalbarhet och kostnadseffektivitet för Orleans appar.

Konfigurera standardplaceringsstrategin

Orleans använder slumpmässig placering om inte standardvärdet åsidosätts. Åsidosätt standardplaceringsstrategin genom att registrera en implementering av PlacementStrategy under konfigurationen:

siloBuilder.ConfigureServices(services =>
    services.AddSingleton<PlacementStrategy, MyPlacementStrategy>());

Konfigurera placeringsstrategin för ett korn

Konfigurera placeringsstrategin för en korntyp genom att lägga till lämpligt attribut i kornklassen. Relevanta attribut anges i avsnitten om placeringsstrategier ovan.

Exempel på anpassad placeringsstrategi

Definiera först en klass som implementerar IPlacementDirector gränssnittet, vilket kräver en enda metod. I det här exemplet förutsätter du att en funktion GetSiloNumber har definierats som returnerar ett silonummer med tanke på det Guid korn som ska skapas.

public class SamplePlacementStrategyFixedSiloDirector : IPlacementDirector
{
    public Task<SiloAddress> OnAddActivation(
        PlacementStrategy strategy,
        PlacementTarget target,
        IPlacementContext context)
    {
        var silos = context.GetCompatibleSilos(target).OrderBy(s => s).ToArray();
        int silo = GetSiloNumber(target.GrainIdentity.PrimaryKey, silos.Length);

        return Task.FromResult(silos[silo]);
    }
}

Definiera sedan två klasser för att tillåta tilldelning av kornklasser till strategin:

[Serializable]
public sealed class SamplePlacementStrategy : PlacementStrategy
{
}

[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
public sealed class SamplePlacementStrategyAttribute : PlacementAttribute
{
    public SamplePlacementStrategyAttribute() :
        base(new SamplePlacementStrategy())
    {
    }
}

Tagga sedan eventuella kornklasser som är avsedda att använda den här strategin med attributet:

[SamplePlacementStrategy]
public class MyGrain : Grain, IMyGrain
{
    // ...
}

Registrera strategin slutligen när du skapar ISiloHost:

private static async Task<ISiloHost> StartSilo()
{
    var builder = new HostBuilder(c =>
    {
        // normal configuration methods omitted for brevity
        c.ConfigureServices(ConfigureServices);
    });

    var host = builder.Build();
    await host.StartAsync();

    return host;
}

private static void ConfigureServices(IServiceCollection services)
{
    services.AddPlacementDirector<SamplePlacementStrategy, SamplePlacementStrategyFixedSiloDirector>();
}

För ett andra enkelt exempel som visar ytterligare användning av placeringskontexten, se PreferLocalPlacementDirector i Orleans källkodsförvaret.