Zum Inhalt springen
Deutsch

Allokationsstrategie

Der Sharding-Koordinator wählt für jeden Shard einen Node:

  • Beim ersten Kontakt — wenn eine Shard-ID erstmals auftaucht, führt der Koordinator allocate(shardId, candidates, currentShards) aus, um ihren Besitzer zu wählen.
  • Beim Rebalance — alle paar Sekunden führt der Koordinator rebalance(currentShards, candidates, inProgress) aus, um Shards zu finden, die wandern sollten.

Die zwei eingebauten Strategien tauschen Einfachheit gegen Balance:

StrategieAllokationRebalance
HashAllocationStrategy (Default)shardId mod sorted-candidatesNur wenn sich die Menge der Kandidaten, die up sind, ändert und diese Änderung zur Ruhe gekommen ist — dann aber die meisten Shards auf einmal.
LeastShardAllocationStrategyKandidat mit den wenigsten Shards.Drainiert den geschäftigsten Node in die übrigen.
import { HashAllocationStrategy, StartShardingOptions } from 'actor-ts/cluster';
const startShardingOptions = StartShardingOptions.create()
.withTypeName('cart')
.withEntityActor(CartActor)
.withExtractEntityId((message) => message.entityId)
.withAllocationStrategy(new HashAllocationStrategy());
sharding.start(
startShardingOptions, // Default
);

Die Formel:

const sorted = [...candidates].sort();
return sorted[shardId % sorted.length];

Macht gut:

  • Deterministisch — bei derselben Kandidatenmenge landen dieselben Shards immer auf denselben Nodes.
  • Minimales Rebalance — nur Shards, deren Hash-Ziel sich ändert, müssen wandern (wenn Nodes joinen oder gehen). „Minimal” bezieht sich darauf, ob überhaupt verschoben wird, nicht darauf, wie viel: der Modulus ändert sich für die meisten Shards, sobald sich die Kandidatenzahl ändert. Bei numShards = 64 verschiebt ein Beitritt 1 → 2 also 32 Shards, 2 → 3 42 bis 44 und 3 → 4 dann 46 bis 49. Die Spanne kommt aus der Adressreihenfolge: Die Kandidaten werden sortiert, also hängt die Zahl davon ab, wo der neue Node einsortiert wird — das untere Ende, wenn er zuletzt kommt, das obere, wenn er zuerst kommt. Die Strategie schlägt alle in einem Durchgang vor; dass das nicht als ein Schwall ankommt, verhindert die Obergrenze des Koordinators — siehe Die Obergrenze für Churn.
  • Kein State — die Strategie verfolgt nichts; sie ist eine reine Funktion.

Macht nicht:

  • Nach Last balancieren — ungleiche Entity-Aktivität bedeutet, dass manche Nodes beschäftigter werden als andere, selbst bei gleicher Shard-Anzahl.
  • Langsame Nodes kompensieren — ein kämpfendes Mitglied bekommt trotzdem seinen fairen Anteil an Shards.

Richtig für gleichmäßige Workloads, in denen Shards ungefähr gleich teuer sind, oder als sinnvoller Default, während du misst, ob du etwas Schlaueres brauchst.

import { LeastShardAllocationStrategy, StartShardingOptions } from 'actor-ts/cluster';
const shardingOptions = StartShardingOptions.create()
// ...
.withAllocationStrategy(new LeastShardAllocationStrategy(
/* rebalanceThreshold */ 1,
/* maxSimultaneousRebalance */ 3,
));
sharding.start(shardingOptions);

Die Formel:

  • Allokation: wähle den Kandidaten mit den wenigsten aktuell gehosteten Shards (Gleichstand wird per Adress-Ordnung gebrochen).
  • Rebalance: zuerst jeden Shard auf einem Node, der kein Kandidat ist — eine Region, die wegen ihrer Shard-Anzahl abgewiesen wurde, oder eine auf einem Mitglied ohne die Rolle des Typs —, gleich wie die Last unter den Kandidaten verteilt ist. Dann, wenn max(shardCount) - min(shardCount) >= rebalanceThreshold unter den Kandidaten, bewege Shards weg vom geschäftigsten Node zum am wenigsten beschäftigten. Höchstens maxSimultaneousRebalance Shards pro Durchgang, beide Arten zusammen.

Macht gut:

  • Konvergiert zur Balance, selbst wenn Nodes ungleichmäßig beigetreten/gegangen sind.
  • Gedrosseltes Rebalance — begrenzte Per-Pass-Bewegungen vermeiden Thrashing.
  • Address-Tiebreak — deterministische Ordnung ohne Überraschungen.

Macht nicht:

  • Per-Shard-Last kennen — sie zählt Shards, nicht Arbeit. Zwei Shards mit sehr unterschiedlicher Arbeitsmenge sehen gleich aus.
  • Sofort reagieren — maxSimultaneousRebalance kappt die Bewegung pro Durchgang; in einem 100-Shard-Cluster, der einen neuen Node gewinnt, dauert volles Rebalance ~33 Durchgänge (× rebalanceInterval — typisch eine Minute oder so).
new LeastShardAllocationStrategy(
/* rebalanceThreshold */ 2, // erst auslösen, wenn Ungleichgewicht ≥ 2
/* maxSimultaneousRebalance */ 5, // bis zu 5 Shards pro Durchgang bewegen
);
  • rebalanceThreshold — größerer Wert = weniger Churn, mehr Toleranz für Ungleichgewicht. 1 lässt jedes Ungleichgewicht ein Rebalance auslösen; 5 wartet auf echten Unterschied.
  • maxSimultaneousRebalance — größerer Wert = schnellere Konvergenz, mehr Handoff-Verkehr. 3 ist eine vernünftige Mitte.

Dieses Limit und die konfigurierte Rebalance-Obergrenze sind zwei verschiedene Ebenen, und beide greifen: maxSimultaneousRebalance begrenzt, was diese Strategie pro Durchgang vorschlägt, die Obergrenze begrenzt, was der Koordinator von einer beliebigen Strategie annimmt. Eine Strategie, die sich selbst deckelt, ersetzt die Obergrenze also nicht — die Default-Strategie deckelt gar nichts, und eine selbst geschriebene ebenso wenig.

Für 100-Shard-Cluster mit häufigem Mitgliedschafts-Churn beide erhöhen (Threshold ~3, Max ~10). Für 16-Shard-Cluster, bei denen jeder Shard-Move teuer ist (großer State), beide niedrig halten.

Implementiere die Schnittstelle:

interface AllocationStrategy {
allocate(
shardId: number,
candidates: ReadonlyArray<NodeAddress>,
currentShards: ReadonlyMap<string, ReadonlySet<number>>,
): NodeAddress;
rebalance(
currentShards: ReadonlyMap<string, ReadonlySet<number>>,
candidates: ReadonlyArray<NodeAddress>,
rebalanceInProgress: ReadonlySet<number>,
): Set<number>;
}

Der Koordinator weist nie einer Region einen Shard zu, deren Mitglied nicht up ist, und er verfolgt, wie lange die Menge der Regionen, deren Mitglied up ist — die zulässigen Regionen —, schon stillhält (siehe Mitglieder, die nicht up sind). Davon hängt ab, wie deine Strategie aufgerufen wird:

  • Solange die Menge noch nicht zur Ruhe gekommen ist, kann allocate für einen Shard zweimal gefragt werden: zuerst mit allen registrierten Regionen, die den Typ hosten könnten, und den Shards, die jede registrierte Region hält — wohin der Shard ginge, wenn alle im Blick sind —, und nur wenn es eine wählt, deren Mitglied nicht up ist, noch einmal mit den zulässigen Regionen allein und deren Shards. rebalance wird gar nicht aufgerufen.
  • Sobald die Menge für das Beruhigungsfenster stillgehalten hat, wird allocate einmal gefragt, mit den zulässigen Regionen und deren Shards, und rebalance wird mit den zulässigen Regionen als Kandidaten und den Shards jeder Region aufgerufen, deren Mitglied up ist. Diese Map ist absichtlich breiter als die Kandidaten: Sie enthält auch eine Region, die auf einem Mitglied registriert ist, das up ist, die aber kein Kandidat ist — wegen ihrer Shard-Anzahl abgewiesen oder ohne die Rolle des Typs —, damit ihre Shards für einen Umzug auf einen Kandidaten vorgeschlagen werden können. Beide eingebauten Strategien schlagen jeden davon vor — LeastShardAllocationStrategy noch vor ihrer Schwellenprüfung, innerhalb ihres Budgets pro Durchgang. Eine eigene Strategie, die nur die Kandidaten gewichtet, lässt sie, wo sie sind.

In beiden Fällen wird eine Wahl, die nicht unter den übergebenen Kandidaten ist, nie zugewiesen — der Koordinator meldet sie auf WARN, mit der Wahl und den Kandidaten, einmal je Shard, bis dieser Shard zugewiesen ist —, und ein rebalance-Vorschlag für einen Shard, dessen aktueller Besitzer nicht up ist, wird verworfen. Ein allocate-Aufruf ist also eine Frage, keine Zuweisung: Eine Strategie mit Zustand — ein Round-Robin-Zeiger, ein „letzter Besitzer” — darf einen Aufruf nicht als gelandeten Shard zählen.

Nützlich für app-spezifische Regeln:

  • Bestimmte Shards an bestimmte Nodes pinnen — z. B. Shards mit IDs < 10 gehen immer auf coordinator-Rollen-Nodes.
  • Affinität / Anti-Affinität — bestimmte Shards zusammenhalten oder immer trennen.
  • Kapazitätsbewusst — jede Node-Metrik abfragen, nach verfügbarem Speicher gewichten.
class RoleAffinityAllocationStrategy implements AllocationStrategy {
constructor(private readonly coordinatorAddrs: Set<string>) {}
allocate(shardId, candidates, currentShards) {
if (shardId < 10) {
// Pinne Shards mit niedrigen IDs an Koordinator-Nodes
const coord = candidates.find(c => this.coordinatorAddrs.has(c.toString()));
if (coord) return coord;
}
return new HashAllocationStrategy().allocate(shardId, candidates, currentShards);
}
rebalance() { return new Set(); } // kein Rebalance für das Beispiel
}

Die Strategie läuft im Koordinator, der ein Singleton auf dem Cluster-Leader ist. Sie muss deterministisch genug sein, dass zwei Koordinatoren (während einer Leader-Wechsel-Übergabe) zur selben Entscheidung konvergieren würden — oder sich zumindest nicht gegenseitig die Arbeit zunichtemachen.

allocate läuft einmal pro neuer Shard-ID — höchstens zweimal, solange die Mitgliedschaft noch nicht zur Ruhe gekommen ist — begrenzt durch numShards (Default 64). Selbst eine teure Strategie ist hier in Ordnung.

rebalance läuft alle rebalanceIntervalMs (Default 2 s), sobald die Menge der Mitglieder, die up sind, zur Ruhe gekommen ist. Es sieht die zulässigen Regionen als Kandidaten und jeden Shard, den eine Region auf einem Mitglied hält, das up ist — nichts von einer Region auf einem Mitglied, das unreachable ist oder noch beitritt. Halte es unter ~100 ms, um die übrige Arbeit des Koordinators nicht zu blockieren.

Für die meisten Cluster:

  1. Default (HashAllocationStrategy) — fang hier an. Miss.
  2. LeastShardAllocationStrategy — wechsele, wenn der Default sichtbare Hotspots produziert (ein Node CPU-saturiert, andere idle).
  3. Eigene — nur wenn keine der eingebauten passt und du konkrete Hinweise hast, dass die Anpassung hilft.

Greife nicht präventiv zu einer eigenen Strategie. Die Eingebauten decken ~95 % der Fälle ab.