நீங்கள் Node-ல் microservices-ஐ உருவாக்கும்போது என்ன கருத்தில் கொள்ள வேண்டும்?

Question

Accepted Answer

**Microservices** என்பது ஒரு பயன்பாட்டைச் சிறிய, சுயாதீனமாக-வரிசைப்படுத்தக்கூடிய சேவைகளாக பிரிக்கிறது, ஒவ்வொன்றும் ஒரு குறிப்பிட்ட டொமைனை소유 செய்கிறது மற்றும் நெட்வொர்க்கின் மூலம் தொடர்புகொள்கிறது. Node-ன் இலகுவான, வேகமாக-தொடங்கும் தன்மை அவற்றுக்கு நன்றாக பொருந்துகிறது — ஆனால் கட்டிடக்கலை விநியோகிக்கப்பட்ட-கணினி சிக்கலைக் கொண்டுவருகிறது, நீங்கள் அதற்கு திட்டமிட வேண்டும்.

## Monolith vs microservices

```text
Monolith:      one codebase/deployment — simple to build, harder to scale teams
Microservices: many small services — independent deploy/scale, but distributed complexity
```

Microservices உள்நிலை-செயல்முறை எளிமையை செயல் நমনীয়தার்கு பரிமாறிக்கொள்கிறது — நீங்கள் உண்மையில் சுயாதீன அளவை/வரிசையாக்கம் தேவைப்படும் போது அல்லது பல குழுக்கள் இருக்கும் போது மட்டுமே பயனுள்ளதாக இருக்கிறது.

## சேவைகளுக்கு இடையே தொடர்பு

```text
Synchronous:  REST / gRPC — direct request/response (simple, but tight coupling + cascading failures)
Asynchronous: message queues (RabbitMQ, Kafka) — events, decoupled, resilient
```

```js
// async/event-driven decouples services — a service publishes an event;
// others react without the publisher knowing/waiting for them
await queue.publish("order.created", { orderId: 123 });
// the email service, inventory service, etc. each consume it independently
```

**ஈতര-நேர செய்திப்பேச்சு** ஏற்றுக்கொள்ளவும் decoupling மற்றும் மீள்பயன்பாட்டுக்கு அங்கு சாத்தியம்; synchronous அழைப்புகள் எளிய ஆனால் கடைசியாக coupling மற்றும் குறைபாடு cascades உண்டாக்குகிறது.

## முக்கிய கவலைகள் நீங்கள் தீர்க்க வேண்டும்

```text
✓ Service discovery / API gateway — how services find each other & route external traffic
✓ Data ownership — each service owns its OWN database (no shared DB) → loose coupling
✓ Resilience — timeouts, retries, circuit breakers (a down service shouldn't cascade)
✓ Distributed tracing & centralized logging — debug a request across many services
✓ Eventual consistency — no cross-service transactions; use sagas / events
✓ Authentication — propagate identity (JWT) across service calls
✓ Idempotency — retried messages shouldn't double-process
```

## மீள்பயன்பாடு உதாரணம்: circuit breaker

```js
// stop hammering a failing dependency; fail fast and recover gracefully
const breaker = new CircuitBreaker(callPaymentService, { timeout: 3000, errorThreshold: 50 });
breaker.fallback(() => ({ status: "queued" })); // degrade gracefully when it's down
```

## வர்த்தக-ஆஃபு நேர்மை

```text
Microservices add real complexity: network failures, distributed debugging, data
consistency, deployment orchestration, more infrastructure. Many apps are better
as a well-structured monolith. Adopt microservices for specific needs, not by default.
```

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

Microservices என்பது ஒரு பெரிய கட்டிடக்கலை தேர்வு, குறிப்பிடத்தக்க வர்த்தக-ஆஃபு உடன்.

Node அவற்றுக்கு பொருந்துகிறது (இலகுவான, வேகமாக தொடக்கம்), ஆனால் கடினமான பாகங்கள் குறைந்த குறிப்பல்ல — அவை **விநியோகிக்கப்பட்ட-கணினி கவலைகள்**: சேவை-இடையே தொடர்பு (decoupling-க்கான ஈதர-நேர செய்திப்பேச்சுக்கு ஏற்றுக்கொள்ளவும்), சுயாதீன தகவல் உரிமை, மீள்பயன்பாடு (timeouts/retries/circuit breakers cascading குறைபாடுகளைத் தடுக்க), பார்க்கக்கூடியதை (tracing/logging சேவைகளுக்கு), மற்றும் இறுதிவாக் சீர்களாய் இருக்கும்.

இவற்றைப் புரிந்துகொள்ளுங்கள் — மற்றும் நெறி வாய்மை என்பது microservices என்பது சேர்க்கிறது நீங்கள் பல பயன்பாட்டுகளுக்கு தேவைப்படாத சிக்கலை (ஒரு நல்ல monolith என்பது பெரும்பாலான நேரம் சிறந்தது) — என்பது ஒரு நேர-ஆதாரமற்ற கட்டிடக்கலை தேர்வு மற்றும் cargo-culting ஒரு தாழ்ந்த உருவாக்கத்தை பிரிக்கிறது.