Passer au contenu
NestJS

NATS

NATS est un système de messagerie open source simple, sécurisé et performant pour les applications cloud natives, la messagerie IoT et les architectures de microservices. Le serveur NATS est écrit dans le langage de programmation Go, mais des bibliothèques clientes pour interagir avec le serveur sont disponibles pour des dizaines de langages de programmation majeurs. NATS prend en charge à la fois la livraison Au Maximum Une Fois et Au Moins Une Fois. Il peut fonctionner n’importe où, des grands serveurs et instances cloud, aux passerelles périphériques et même aux dispositifs Internet des Objets.

Installation

Pour commencer à créer des microservices basés sur NATS, installez d’abord le paquet requis :

Fenêtre de terminal
$ npm i --save nats

Aperçu

Pour utiliser le transporteur NATS, passez l’objet d’options suivant à la createMicroservice() méthode :

main.ts
const app = await NestFactory.createMicroservice<MicroserviceOptions>(AppModule, {
  transport: Transport.NATS,
  options: {
    servers: ['nats://localhost:4222'],
  },
});

Options

L’objet options est spécifique au transporteur choisi. Le transporteur NATS expose les propriétés décrites ici. De plus, il y a une propriété queue qui vous permet de spécifier le nom de la queue à laquelle votre serveur doit s’abonner (laissez undefined pour ignorer ce paramètre). Lisez-en plus sur les groupes de queues NATS ci-dessous.

Client

Comme d’autres transporteurs de microservices, vous avez plusieurs options pour créer une instance ClientProxy NATS.

Une méthode pour créer une instance est d’utiliser le ClientsModule. Pour créer une instance de client avec le ClientsModule, importez-le et utilisez la méthode register() pour passer un objet d’options ayant les mêmes propriétés que celles présentées ci-dessus dans la méthode createMicroservice(), ainsi qu’une propriété name à utiliser comme jeton d’injection. Lisez-en plus sur le ClientsModule ici.

main.ts
@Module({
  imports: [
    ClientsModule.register([
      {
        name: 'MATH_SERVICE',
        transport: Transport.NATS,
        options: {
          servers: ['nats://localhost:4222'],
        },
      },
    ]),
    ...
  ],
})

D’autres options pour créer un client (soit ClientProxyFactory soit @Client()) peuvent également être utilisées. Vous pouvez en lire davantage ici.

Request-response

Pour le style de message request-response (en savoir plus), le transporteur NATS n’utilise pas le mécanisme intégré de Request-Reply de NATS. Au lieu de cela, une “demande” est publiée sur un sujet donné en utilisant la méthode publish() avec un nom de sujet de réponse unique, et les répondants écoutent ce sujet et envoient des réponses au sujet de réponse. Les sujets de réponse sont dirigés vers le demandeur dynamiquement, indépendamment de l’emplacement de chaque partie.

Basé sur des événements

Pour le style de message basé sur des événements (en savoir plus), le transporteur NATS utilise le mécanisme intégré de Publish-Subscribe de NATS. Un éditeur envoie un message sur un sujet et tout abonné actif écoutant ce sujet reçoit le message. Les abonnés peuvent également enregistrer un intérêt pour des sujets génériques qui fonctionnent un peu comme une expression régulière. Ce modèle un-à-plusieurs est parfois appelé fan-out.

Groupes de queues

NATS propose une fonction d’équilibrage de charge intégrée appelée queues distribuées. Pour créer une souscription de queue, utilisez la propriété queue comme suit :

main.ts
const app = await NestFactory.createMicroservice<MicroserviceOptions>(AppModule, {
  transport: Transport.NATS,
  options: {
    servers: ['nats://localhost:4222'],
    queue: 'cats_queue',
  },
});

Contexte

Dans des scénarios plus sophistiqués, vous pourriez vouloir accéder à plus d’informations sur la requête entrante. Lors de l’utilisation du transporteur NATS, vous pouvez accéder à l’objet NatsContext.

main.ts
@MessagePattern('notifications')
getNotifications(@Payload() data: number[], @Ctx() context: NatsContext) {
  console.log(`Subject: ${context.getSubject()}`);
}

Jokers

Un abonnement peut être à un sujet explicite, ou il peut inclure des jokers.

main.ts
@MessagePattern('time.us.*')
getDate(@Payload() data: number[], @Ctx() context: NatsContext) {
  console.log(`Subject: ${context.getSubject()}`); // e.g. "time.us.east"
  return new Date().toLocaleTimeString(...);
}

Constructeurs d’enregistrements

Pour configurer les options de message, vous pouvez utiliser la classe NatsRecordBuilder (note : cela est faisable pour les flux basés sur des événements aussi). Par exemple, pour ajouter un en-tête x-version, utilisez la méthode setHeaders, comme suit :

main.ts
import * as nats from 'nats';


// quelque part dans votre code
const headers = nats.headers();
headers.set('x-version', '1.0.0');


const record = new NatsRecordBuilder(':cat:').setHeaders(headers).build();
this.client.send('replace-emoji', record).subscribe(...);

Et vous pouvez lire ces en-têtes côté serveur également, en accédant au NatsContext, comme suit :

main.ts
@MessagePattern('replace-emoji')
replaceEmoji(@Payload() data: string, @Ctx() context: NatsContext): string {
  const headers = context.getHeaders();
  return headers['x-version'] === '1.0.0' ? '🐱' : '🐈';
}

Dans certains cas, vous pourriez vouloir configurer des en-têtes pour plusieurs requêtes, vous pouvez les passer en tant qu’options au ClientProxyFactory :

main.ts
import { Module } from '@nestjs/common';
import { ClientProxyFactory, Transport } from '@nestjs/microservices';


@Module({
  providers: [
    {
      provide: 'API_v1',
      useFactory: () =>
        ClientProxyFactory.create({
          transport: Transport.NATS,
          options: {
            servers: ['nats://localhost:4222'],
            headers: { 'x-version': '1.0.0' },
          },
        }),
    },
  ],
})
export class ApiModule {}