Yaya NestJS ke goyan tabarau a kan microservices?

Question

Accepted Answer

NestJS yana da **goyan tabarau na microservices na jiya** — yana iya gudana a matsayin microservice da ke sadarwa ta hanyoyi daban-daban **transports** (TCP, Redis, NATS, RabbitMQ, Kafka, gRPC) maimakon HTTP, ta amfani da tsarin jiya, tsarin sadarwa na saƙo. Tsarin NestJS iri daya (modules, services, DI) yana aiki; kawai transport da patterns na saƙo suka canza.

## Yin microservice

```ts
// a microservice listens on a transport instead of HTTP
const app = await NestFactory.createMicroservice(AppModule, {
  transport: Transport.TCP,             // or REDIS, NATS, RMQ, KAFKA, GRPC
  options: { host: "0.0.0.0", port: 3001 },
});
await app.listen();
```

## Message patterns da event patterns

```ts
@Controller()
export class MathController {
  // REQUEST-RESPONSE: respond to a message and RETURN a result (RPC-style)
  @MessagePattern({ cmd: "sum" })
  sum(data: number[]): number {
    return data.reduce((a, b) => a + b, 0);   // the caller awaits this result
  }

// EVENT-BASED: react to an event, NO response expected (fire-and-forget)
  @EventPattern("order_created")
  handleOrderCreated(data: OrderDto) {
    this.processOrder(data);                   // just react; nothing returned
  }
}
```

Dan sauki na sadarwa biyu: **`@MessagePattern`** don ibeya-amsa (mai kira yana jira sakamakon, kamar RPC) da **`@EventPattern`** don abubuwan (jajaye-jajaye, zalunta — mai buga ba ya jira).

## Kiran wani microservice (client)

```ts
@Injectable()
export class AppService {
  constructor(@Inject("MATH_SERVICE") private client: ClientProxy) {}

async getSum() {
    // send() → request-response (returns an Observable of the result)
    return this.client.send({ cmd: "sum" }, [1, 2, 3]);
    // emit() → fire an event (no response)
    this.client.emit("order_created", orderData);
  }
}
```

`ClientProxy` (da aka tsara ta hanyar `ClientsModule`) yana aika saƙo/abubuwan zuwa sauran ayyuka — `send()` don ibeya-amsa, `emit()` don abubuwa.

## Aikace-aikacen lalata

```ts
// an app can serve HTTP AND connect microservice transports simultaneously
const app = await NestFactory.create(AppModule);
app.connectMicroservice({ transport: Transport.RMQ, options: {...} });
await app.startAllMicroservices();
await app.listen(3000);   // HTTP too
```

## Transport zaɓi yana da maɗauki

```text
TCP   → simple direct service-to-service
Redis/NATS → lightweight pub/sub messaging
RabbitMQ/Kafka → robust message queues/streams (durability, retries, decoupling)
gRPC  → high-performance, strongly-typed RPC (protobuf)
→ Async message brokers (RMQ/Kafka) give decoupling & resilience; gRPC gives speed+typing.
```

## Yaya ya shafi

Goyan tabarau na jiya na NestJS akan microservices yana da mahimmanci domin yana ba ka dama na gina tsarin da aka rarraba ta amfani da *sauran* tsarin NestJS da aka sani (modules, providers, DI, decorators) yayin jujjuya HTTP zuwa transports na saƙo - babbar amfani kuma karɗar fahimta.
">Fahimta shi yana mahimmanci don tsarawa na tsarin da ke iya ɗaukarwa: **message-pattern (ibeya-amsa) da event-pattern (jajaye-jajaye) bambance-bambance** yana tsara kai tsaye zuwa finafinai na sadarwa na microservices - kira ta jiya ta sauron sadarwa da karɗar ɓata (na ƙarshe, ta hanyar brokers na saƙo, yana ba da jiya kuma zalunta da ke sa microservices dogara).

Sanin yadda ake yin microservices, bayyana message/event handlers, kira sauran ayyuka ta hanyar `ClientProxy`, gina aikacen lalata na HTTP+microservice, da zaɓi transports (lightweight pub/sub da karɗa durable kamar Kafka/RabbitMQ da high-performance gRPC) yana da daraja na jiya kuma ilimi don tsarawa da rarraba back-ends.

Dagda microservices yana ƙara hadda haɗi gida (kuma ba kullum dama kallon monolith ba), NestJS yana saita aiwatarwa a tsari kuma jiya, yana sa jajjayen batu mahimmanci ga gina tsarin tsara, rarraba NestJS na girma.