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:
| Strategie | Allokation | Rebalance |
|---|---|---|
HashAllocationStrategy (Default) | shardId mod sorted-candidates | Nur wenn sich die Menge der Kandidaten, die up sind, ändert und diese Änderung zur Ruhe gekommen ist — dann aber die meisten Shards auf einmal. |
LeastShardAllocationStrategy | Kandidat mit den wenigsten Shards. | Drainiert den geschäftigsten Node in die übrigen. |
HashAllocationStrategy
Abschnitt betitelt „HashAllocationStrategy“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 = 64verschiebt 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.
LeastShardAllocationStrategy
Abschnitt betitelt „LeastShardAllocationStrategy“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) >= rebalanceThresholdunter den Kandidaten, bewege Shards weg vom geschäftigsten Node zum am wenigsten beschäftigten. HöchstensmaxSimultaneousRebalanceShards 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 —
maxSimultaneousRebalancekappt 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).
Die Knöpfe tunen
Abschnitt betitelt „Die Knöpfe tunen“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.1lässt jedes Ungleichgewicht ein Rebalance auslösen;5wartet 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.
Eigene Strategien
Abschnitt betitelt „Eigene Strategien“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>;}Das Aufrufprotokoll
Abschnitt betitelt „Das Aufrufprotokoll“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
allocatefü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 nichtupist, noch einmal mit den zulässigen Regionen allein und deren Shards.rebalancewird gar nicht aufgerufen. - Sobald die Menge für das Beruhigungsfenster stillgehalten hat,
wird
allocateeinmal gefragt, mit den zulässigen Regionen und deren Shards, undrebalancewird mit den zulässigen Regionen als Kandidaten und den Shards jeder Region aufgerufen, deren Mitgliedupist. Diese Map ist absichtlich breiter als die Kandidaten: Sie enthält auch eine Region, die auf einem Mitglied registriert ist, dasupist, 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 —LeastShardAllocationStrategynoch 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.
Performance
Abschnitt betitelt „Performance“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.
Auswahl
Abschnitt betitelt „Auswahl“Für die meisten Cluster:
- Default (
HashAllocationStrategy) — fang hier an. Miss. LeastShardAllocationStrategy— wechsele, wenn der Default sichtbare Hotspots produziert (ein Node CPU-saturiert, andere idle).- 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.
Wohin als Nächstes
Abschnitt betitelt „Wohin als Nächstes“- Sharding-Überblick — das große Bild: wie Allokation mit Rebalance + Handoff zusammenspielt.
- Rebalance — das Handoff-Protokoll, das die Strategie auslöst.
- Remember Entities — was mit Platzierung einer Entity nach einem Respawn passiert.
- Sharded Daemon Process —
nutzt standardmäßig
LeastShardAllocationStrategy.
