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
| Version | Statut |
|---|---|
| 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 :
| Politique | Description |
|---|---|
| Limits | Conserver les messages jusqu'aux limites atteintes |
| Interest | Conserver tant que des consumers sont abonnés |
| Work Queue | Chaque 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 :
| Classe | Ratio CPU:RAM | Small | Medium | Large | XLarge |
|---|---|---|---|---|---|
| Eco | 1:2 | 0.5 / 1 Gi | 1 / 2 Gi | 2 / 4 Gi | 3 / 6 Gi |
| Standard | 1:4 | 1 / 4 Gi | 2 / 8 Gi | 4 / 16 Gi | 15 / 58 Gi |
| Production | 1:4 | 1 / 4 Gi | 2 / 8 Gi | 4 / 16 Gi | 6 / 28 Gi |
Format: vCPU / Mémoire
Réplicas
Configurez la taille du cluster pour la disponibilité :
| Réplicas | Description |
|---|---|
| 1 | Nœud unique, pas de réplication (développement) |
| 3 | Haute disponibilité (recommandé pour la production) |
| 5 | Tolérance aux pannes maximale |
- 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 :
- Allez dans les paramètres du cluster
- Activez Accès Public
- 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
- Accédez à votre cluster NATS
- Cliquez sur l'onglet Observabilité
- Sélectionnez la plage temporelle
- 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');