Aller au contenu principal

Vue d'ensemble des files de messages

File de messages de niveau entreprise avec NATS, le système de messagerie cloud-native haute performance.

Qu'est-ce que NATS ?​

NATS est un système de messagerie simple, sécurisé et haute performance conçu pour les applications cloud-native, la messagerie IoT et les architectures microservices. SailOps fournit des clusters NATS entièrement gérés avec JetStream pour :

  • Messagerie Pub/Sub - Diffusion d'événements en temps réel
  • Request/Reply - Communication synchrone entre services
  • Queue groups - Distribution de messages avec équilibrage de charge
  • Streams persistants - Rejeu et durabilité des messages
  • Stores Key-Value - Configuration distribuée
  • Stores d'objets - Stockage de fichiers volumineux

Versions supportées​

VersionStatut
NATS 2.10✓ Supportée
NATS 2.11✓ Supportée
NATS 2.12✓ Supportée

Fonctionnalités clés​

Conception Cloud-Native​

NATS est conçu pour les architectures modernes :

  • Empreinte ultra-légère
  • Pas de dépendances externes
  • Clustering intégré
  • Support multi-tenant

Haute performance​

Optimisé pour la vitesse et l'échelle :

  • Millions de messages par seconde
  • Latence sub-milliseconde
  • Overhead mémoire minimal
  • Scaling horizontal

JetStream​

Couche de persistance intégrée :

  • Streams - Stockage persistant des messages
  • Consumers - Livraison flexible des messages
  • Key-Value - Stores key-value distribués
  • Object Store - Stockage de gros objets binaires

Service géré​

SailOps gère les opérations :

  • Provisionnement automatique
  • Monitoring et métriques
  • Clustering haute disponibilité
  • Mises à jour de sécurité

Cas d'utilisation​

Architecture événementielle​

Découpler les services avec la messagerie pub/sub :

// Publisher
await nc.publish('orders.created', JSON.stringify({
orderId: 'order-123',
customerId: 'cust-456',
total: 99.99
}));

// Subscriber
const sub = nc.subscribe('orders.created');
for await (const msg of sub) {
const order = JSON.parse(msg.data);
await processOrder(order);
}

Communication entre microservices​

Pattern Request/Reply pour les appels de services :

// Service
const sub = nc.subscribe('users.get');
for await (const msg of sub) {
const { userId } = JSON.parse(msg.data);
const user = await db.getUser(userId);
msg.respond(JSON.stringify(user));
}

// Client
const response = await nc.request('users.get', JSON.stringify({ userId: '123' }));
const user = JSON.parse(response.data);

Files de travail​

Distribuer le travail entre plusieurs workers :

// Plusieurs workers s'abonnent au même queue group
const sub = nc.subscribe('tasks.process', { queue: 'workers' });
for await (const msg of sub) {
const task = JSON.parse(msg.data);
await processTask(task);
}

Notifications en temps réel​

Envoyer des notifications aux clients connectés :

// Le serveur envoie des notifications
await nc.publish(`notifications.user.${userId}`, JSON.stringify({
type: 'new_message',
from: 'John',
preview: 'Hey, comment ça va ?'
}));

// Le client reçoit les notifications
const sub = nc.subscribe(`notifications.user.${userId}`);
for await (const msg of sub) {
displayNotification(JSON.parse(msg.data));
}

Architecture​

Composants JetStream​

Streams​

Stockage persistant des messages avec rétention configurable :

PolitiqueDescription
LimitsConserver les messages jusqu'aux limites atteintes
InterestConserver tant que des consumers sont abonnés
Work QueueChaque message livré une fois puis supprimé

Consumers​

Consommation flexible des messages :

  • Push - Messages livrés aux abonnés
  • Pull - Les clients récupèrent les messages à la demande
  • Durable - L'état persiste à travers les reconnexions
  • Ephemeral - Consumers temporaires

Stores Key-Value​

Stockage key-value distribué :

  • Historique et versionnage des clés
  • Support TTL
  • Surveillance des changements
  • Opérations atomiques

Stores d'objets​

Stockage de gros objets binaires :

  • Stocker des fichiers jusqu'à 5GB
  • Uploads fragmentés
  • Support des métadonnées
  • Téléchargements en streaming

Classes de calcul​

Les clusters NATS utilisent des classes de calcul avec des ratios CPU:RAM fixes :

ClasseRatio CPU:RAMSmallMediumLargeXLarge
Eco1:20.5 / 1 Gi1 / 2 Gi2 / 4 Gi3 / 6 Gi
Standard1:41 / 4 Gi2 / 8 Gi4 / 16 Gi15 / 58 Gi
Production1:41 / 4 Gi2 / 8 Gi4 / 16 Gi6 / 28 Gi

Format: vCPU / Mémoire

Réplicas​

Configurez la taille du cluster pour la disponibilité :

RéplicasDescription
1Nœud unique, pas de réplication (développement)
3Haute disponibilité (recommandé pour la production)
5Tolérance aux pannes maximale
Choisir les réplicas
  • Utilisez 1 réplica pour le développement et les tests
  • Utilisez 3 réplicas pour les charges de production
  • Utilisez 5 réplicas pour les systèmes critiques nécessitant une disponibilité maximale

Sécurité​

Accès réseau​

Par défaut, les clusters NATS sont accessibles depuis :

  • Les containers du même projet
  • Le réseau interne du projet

Accès Public (Optionnel)​

Activez l'accès externe à votre cluster NATS :

  1. Allez dans les paramètres du cluster
  2. Activez Accès Public
  3. Configurez la Liste d'IP autorisées — ajoutez chaque CIDR autorisé et une note optionnelle (100 caractères max) pour identifier son usage

Une fois activé, seules les IPs de votre liste autorisée peuvent se connecter depuis l'extérieur de votre projet.

Authentification​

L'authentification par mot de passe protège votre cluster :

const nc = await connect({
servers: 'nats://my-cluster.my-project:4222',
user: 'admin',
pass: 'your-password'
});

Chiffrement du transport​

Les clusters NATS managés exposent actuellement des endpoints NATS non chiffrés (nats://), aussi bien sur le réseau interne que via l'accès public optionnel. La configuration TLS n'est pas encore disponible et l'API la refuse ; l'accès public n'ajoute donc aucun chiffrement du transport. Conservez les flux sensibles sur le réseau privé du projet et utilisez l'authentification par mot de passe jusqu'à la disponibilité du TLS managé.

Monitoring​

Métriques intégrées​

  • Nombre de connexions
  • Taux de messages (entrée/sortie)
  • Débit en octets
  • Utilisation du stockage des streams
  • Retard des consumers

Visualiser les métriques​

  1. Accédez à votre cluster NATS
  2. Cliquez sur l'onglet Observabilité
  3. Sélectionnez la plage temporelle
  4. Visualisez les graphiques de performance

Tarification​

Les clusters NATS sont facturés à l'heure en fonction de :

  • La classe de calcul et les ressources
  • Le nombre de réplicas
  • L'utilisation du stockage JetStream

Voir Facturation pour les informations détaillées de tarification.

Bonnes pratiques​

1. Utilisez des noms de sujets significatifs​

Organisez les sujets de manière hiérarchique :

orders.created
orders.updated
orders.{orderId}.status
payments.processed
payments.failed

2. Configurez une rétention appropriée​

Adaptez la rétention à votre cas d'utilisation :

  • Limits : Quand vous avez besoin de l'historique des messages
  • Interest : Quand les messages sont uniquement pour les consumers actifs
  • Work Queue : Quand chaque message doit être traité une seule fois

3. Utilisez les groupes de consumers pour le scaling​

Distribuez la charge entre les workers :

// Tous les workers dans le même queue group partagent la charge
const sub = nc.subscribe('tasks.*', { queue: 'task-workers' });

4. Surveillez le retard des consumers​

Configurez des alertes pour le retard des consumers afin de détecter les délais de traitement.

5. Utilisez des consumers durables pour la fiabilité​

Les consumers durables maintiennent leur état à travers les redémarrages :

const consumer = await js.consumers.get('ORDERS', 'order-processor');

Prochaines étapes​