Redis Cluster எவ்வாறு scaling ஐ செயல்படுத்துகிறது?

Question

Accepted Answer

**Redis Cluster** **horizontal scaling** ஐ செயல்படுத்துகிறது பல Redis nodes களில் தரவுகளை sharding செய்வதன் மூலம் — dataset மற்றும் load ஐ விநியோகிப்பது இதனால் Redis ஒற்றை சேவையகத்தின் நினைவகத்திற்கு அப்பாலான தரவு மற்றும் throughput ஐ கையாள முடியும். இது தரவை **hash slots** வழியாக பிভாகிக்கிறது மற்றும் உள்ளமைக்கப்பட்ட உচ்च கிடைக்கூடிய தன்மை வழங்குகிறது.

## Hash slots மூலம் Sharding

```text
Redis Cluster divides the keyspace into 16384 HASH SLOTS.
  → each key maps to a slot: slot = CRC16(key) mod 16384
  → slots are distributed across the cluster's primary nodes
  → each node owns a subset of slots (and thus a subset of the data)
→ This spreads data and load across nodes → scales memory and throughput horizontally.
```

தரவு nodes முழுவதும் **hash slots** (மொத்தம் 16384) மூலம் பிভாகிக்கப்படுகிறது: ஒவ்வொரு key ஒரு slot க்கு hash ஆகிறது, மற்றும் slots primary nodes முழுவதும் பரவுகின்றன — எனவே ஒவ்வொரு node தரவின் ஒரு பகுதியை வைத்திருக்கிறது, ஒற்றை சேவையகத்திற்கு அப்பாலான capacity ஐ scaling செய்கிறது.

## உள்ளமைக்கப்பட்ட உচ்च கிடைக்கூடிய தன்மை

```text
Each primary node has REPLICAS:
  → if a primary fails, one of its replicas is promoted (automatic failover)
  → the cluster continues serving (HA without separate Sentinel)
→ Redis Cluster combines SHARDING (scale) + REPLICATION (HA).
```

## Clients மற்றும் redirection

```text
→ Clients connect to the cluster; a key's request goes to the node owning its slot.
→ If a client hits the wrong node, it gets a MOVED redirect to the right node
  (cluster-aware clients cache the slot map and route directly).
```

## மல்டி-key constraint (முக்கியமான)

```text
⚠️ Multi-key operations only work if all keys are in the SAME slot (same node):
  → operations spanning keys on different nodes are NOT supported directly
  → use HASH TAGS to force related keys into the same slot:
     {user:1000}:profile and {user:1000}:settings → same slot ({...} part is hashed)
→ Design keys so related data that's used together shares a slot.
```

## அது ஏன் முக்கியமான

Redis Cluster ஐ புரிந்துகொள்வது **Redis ஐ ஒற்றை சேவையகத்திற்கு அப்பாலாக horizontal scaling** செய்வதற்கு முக்கியமான, எனவே இது பெரிய அளவிலான Redis deployments களுக்கு மதிப்புமிக்க senior-level அறிவு.

மূল மதிப்பு **horizontal scaling**: தரவு அல்லது throughput ஒற்றை Redis சேவையகத்தின் நினைவகம் கையாள முடியுமான அளவை விட அதிகமாக இருக்கும்போது, Cluster **தரவை பல nodes முழுவதும் shards** (16384 **hash slots** மூலம், ஒவ்வொரு key ஒரு slot க்கு mapping செய்கிறது primary nodes முழுவதும் விநியோகிக்கப்படுகிறது), ஒற்றை machine ஐ அப்பாலாக data மற்றும் load ஐ பரவி scaling — பெரிய அளவிலான systems களுக்கு அপরிহார்யம்.

**hash slot mechanism** ஐ புரிந்துகொள்வது (எவ்வாறு keys slots க்கு map செய்யப்படுகிறது மற்றும் slots nodes க்கு) Cluster எவ்வாறு தரவை விநியோகிக்கிறது என்பதற்கு அடிப்படை.

Cluster **உள்ளமைக்கப்பட்ட உচ்च கிடைக்கூடிய தன்மை** வழங்குகிறது (ஒவ்வொரு primary க்கும் replicas உள்ளது automatic failover உடன், sharding மற்றும் replication ஐ இணைக்கிறது தனி Sentinel ஐ தேவை இல்லாமல்) என்பதை அறிந்திருப்பது scale வில் reliability களுக்கு முக்கியமான.

**client redirection** ஐ புரிந்துகொள்வது (MOVED redirects, cluster-aware clients slot map ஐ cache செய்கிறது) எவ்வாறு requests சரியான node க்கு reach செய்கிறது என்பதை விளக்குகிறது.

மிக முக்கியமாக, **multi-key constraint** ஐ புரிந்துகொள்வது — மல்டி-key operations க்கு அனைத்து keys ஒரே slot இல் இருக்க வேண்டும், **hash tags** (`{user:1000}:...` தொடர்புடைய keys க்கு ஒரே slot க்கு forcing செய்கிறது) உடன் தீர்க்கப்படுகிறது — அপরிहार्யம் ஏனெனில் இது ஒரு உண்மையான slimitation இது key design ஐ பாதிக்கிறது (உடன் பயன்படுத்தப்படும் தொடர்புடைய தரவு co-located ஆக இருக்க வேண்டும்), மற்றும் அதை புரிந்துகொள்வாதது cluster இல் mल्टी-key operations உடன் errors ஐ cause செய்கிறது.

ஒற்றை Redis சேவையகத்திற்கு அப்பாலாக scaling செய்வது high-volume systems க்கு ஒரு உண்மையான தேவை ஆக இருப்பதால், மற்றும் Redis Cluster (hash slots மூலம் sharding + உள்ளமைக்கப்பட்ட HA) இதற்கான mechanism ஆக இருப்பதால் — multi-key operations க்கு महत्वपूर्ण hash-tag/multi-key constraint உடன் design ஐ பாதிக்கிறது — Redis Cluster ஐ புரிந்துகொள்வது Redis ஐ scaling செய்வதற்கு முக்கியமான senior-level அறிவு, ஒரு topic horizontal scaling ஐ புரிந்துகொள்வதையும் மற்றும் practical constraints (key co-location) ஐ demonstrating Redis தரவை nodes முழுவதும் விநியோகிக்கும்போது வருகிறது.