Cad ba cheart duit a mheas agus tú ag tógáil microservices in Node?

Question

Accepted Answer

**Microservices** a roinnt ar fheidhmchlár ina seirbhísí beaga neamhspleácha atá inannrachadh go neamhspleách, agus iad ag cumarsáid thar an líonra. Tá Node oiriúnach dóibh — ach tugann an ailtireacht an chastacht córas dáilteach isteach agus ní mór duit a bheith réamhullmhaithe.

## Monalite i gcomparáid le microservices

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

Microservices a thairgint simplíochta in-phróisis do chalaochtaí oibriúcháin — níl ann ach ar fhiú nuair a bhíonn gá duit i ndáiríre do scálú/fhíorscaoileadh neamhspleách nó múintir dhóchur iomadúla.

## Cumarsáid idir seirbhísí

```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
```

Is fearr **teachtaireachta neamhsioncreonach** a bhaint amach maidir le díchumasc agus réamhdhúnmhaireacht áit ar féidir; tá glaonna sioncronach níos simplí ach cruthú ceangailte teann agus tuislí os cionn.

## Imní príomhúla ort a shainmhíniú

```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
```

## Samhail dhúnmhaireachta: 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
```

## An socrú macánta

```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.
```

## Cén fáth a bhíonn tábhacht ann

Is rogha ailtireachta mhór iad microservices le malartuithe suntasacha.

Oiriúnann Node dóibh (éadrom, tosú gasta), ach ní iad na codanna crua ná an cód — is iad na **imní córas dáilteach**: cumarsáid idir-seirbhíse (ag soilíonn teachtaireachta neamhsioncreonach le haghaidh díchumasc), úinéireacht sonraí neamhspleách, dúnmhaireacht (timeouts/atriail/circuit breakers a chosc tuislí os cionn), inbhraithnitheacht (rianú/logáil ar fud seirbhísí), agus comhsheasmhacht dheireanach.

Ar do thuiscint ar na seo — agus an réalachas macánta go gcuireann microservices casta ann go leor feidhmchlár nach bhfuil gá (is minic gur fearr monalite maith) — is é sin a scarann cinneadh ailtireachta soladach ó bhreith cargo ar phatrún foinsiúil.