Kafka-ல் replication எவ்வாறு செயல்படுகிறது?

Question

Accepted Answer

Kafka **replicate** செய்கிறது partitions-ஐ multiple brokers-க்கு **durability மற்றும் availability** க்காக — ஒவ்வொரு partition-க்கும் leader மற்றும் follower replicas உள்ளது. ஒரு broker fail ஆனால், follower அதன் இடத்தை எடுக்கிறது. Replication எவ்வாறு செயல்படுகிறது என்பதைப் புரிந்துகொள்வது Kafka-வின் fault tolerance-க்குக் முக்கியமாகும்.

## Replication எவ்வாறு செயல்படுகிறது

```text
Each PARTITION is replicated across multiple brokers (REPLICATION FACTOR copies, e.g. 3):
  → LEADER replica → handles all reads and writes for the partition
  → FOLLOWER replicas → copy (replicate) the leader's data, staying in sync
  → producers/consumers interact with the LEADER; followers are backups
→ if the leader's broker FAILS → a follower is promoted to leader (failover) → no data loss,
  continued availability
```

## In-Sync Replicas (ISR)

```text
ISR (In-Sync Replicas) → the set of replicas CAUGHT UP with the leader:
  → only in-sync replicas are eligible to become leader (ensures the new leader has the data)
  → durability config: acks=all + min.insync.replicas → a write is acknowledged only when
    enough ISRs have it → survives failures without data loss
→ ISR is central to balancing durability and availability
```

## Durability vs availability trade-offs

```text
→ REPLICATION FACTOR (e.g. 3) → more copies = more fault tolerance (survive more failures)
→ acks setting (producer):
  acks=0 → no wait (fast, may lose data)  acks=1 → leader only (may lose on leader failure)
  acks=all → all ISRs confirm (safe, no loss, but slower)
→ min.insync.replicas → minimum ISRs required for a write (durability guarantee)
→ trade-off: stronger durability (acks=all, more replicas) vs throughput/availability
```

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

Kafka-ல் replication எவ்வாறு செயல்படுகிறது என்பதைப் புரிந்துகொள்வது மதிப்புள்ளது, ஏனெனில் இது **Kafka-வின் durability மற்றும் availability** (fault tolerance)-ற்குக் கோ**ல்** ஆகும், எனவே Kafka-வை நம்பகத்தன்மையுடன் புரிந்துகொள்ளவும் செயல்படுத்தவும் முக்கியமாகும்.

Replication என்பது Kafka இல் data தொலையாமலும் broker failures-ற்கும் இடையூறின்றி கிடைக்கும் நிலையில் இருக்கவும் உறுதி செய்கிற வழியாகும்.

**Replication எவ்வாறு செயல்படுகிறது** என்பதை புரிந்துகொள்வது — ஒவ்வொரு partition replicate செய்யப்படுகிறது brokers-க்கு (replication factor-க்கு ஏற்ப) **leader** reads/writes-ஐ கையாளுகிறது மற்றும் **followers** அதை replicate செய்கிறது, எனவே leader-வின் broker fail ஆனால் follower promote செய்யப்படுகிறது (failover, continued availability without data loss என்பதை வழங்குகிறது) — Kafka-வின் fault-tolerance mechanism-ஐ விளக்குகிறது.

**In-sync replicas (ISR)** -ஐப் புரிந்துகொள்வது — leader-வுடன் catch up செய்யப்பட்ட replicas-ந் set, இங்கு leader ஆக முடியக்கூடிய in-sync replicas மட்டுமே உள்ளன (new leader-க்கு data உள்ளதை உறுதி செய்கிறது), மற்றும் durability configuration (acks=all plus min.insync.replicas) writes-ஐ acknowledge செய்கிறது போது போதுமான ISRs-க்கு data இருந்தால் மட்டுமே (failures-ஐ survive செய்கிறது loss இல்லாமல்) — Kafka-வின் durability மற்றும் availability-ஐ எவ்வாறு சமநிலைப்படுத்துவது என்பதற்கு மைய உறுப்பு ஆகும், முக்கிய operational concept.

**Durability vs availability trade-offs** -ஐப் புரிந்துகொள்வது — replication factor (more copies = more fault tolerance), producer **acks** setting (acks=0 fast ஆனால் data தொலைக்கலாம், acks=1 leader-only, acks=all safe ஆனால் slower), மற்றும் min.insync.replicas — durability-ஐ throughput மற்றும் availability-க்கு எதிராக சமநிலைப்படுத்தும் முக்கிய configuration decisions-ஐ பிரதிபலிக்கிறது.

இந்த trade-offs என்பவை Kafka-வை operate செய்யும் போது நடைமுறை decisions ஆகும்: stronger durability (acks=all, more replicas, higher min ISRs) versus performance.

Replication-ஐப் புரிந்துகொள்வது Kafka-வை நம்பகத்தன்மையுடன் operate செய்வதற்கும் சரியான durability guarantees-ஐ configure செய்வதற்கும் இன்றியமையாதது.

Replication-ஆனது Kafka-வின் durability மற்றும் availability-க்குக் (leader/follower replication மற்றும் failover-ற்கான fault tolerance) கோல் ஆக இருப்பதாலும் அதை புரிந்துகொள்வது — mechanism, ISR, மற்றும் durability/availability trade-offs (replication factor, acks, min ISRs) — Kafka-வை நம்பகத்தன்மையுடன் operate செய்வதற்கும் suitable guarantees-ஐ configure செய்வதற்கும் முக்கியமாக இருப்பதாலும், Kafka-ல் replication எவ்வாறு செயல்படுகிறது என்பதை புரிந்துகொள்வது மதிப்புள்ள, நடைமுறை-relevant knowledge ஆகும் — Kafka-வின் fault tolerance மற்றும் durability-க்கு மைய உறுப்பு மற்றும் Kafka எவ்வாறு failures-ஐ survive செய்கிறது என்பதைப் புரிந்துகொள்வதற்கும் durability guarantees (acks, replication factor, ISR)-ஐ configure செய்வதற்கும் முக்கியமாகும், மற்றும் Kafka-வை நம்பகத்தன்மையுடன் operate செய்வதற்குக் கோ**ல்** ஆகும்.