Aller au contenu principal

Guide de configuration

Personnalisez la configuration de votre cluster NATS pour des performances et une fiabilité optimales.

Configuration du cluster​

Gestion des versions​

Mettez à jour votre version NATS :

  1. Accédez à votre cluster
  2. Cliquez sur Mettre à jour
  3. Sélectionnez la nouvelle version
  4. Appliquez les changements
attention

Les mises à jour de version déclenchent un redémarrage progressif. Planifiez les mises à jour pendant les périodes de faible trafic.

Mise à l'échelle des ressources​

Classe de calcul​

ClasseDescriptionCas d'utilisation
EcoRessources partagées, économiqueDéveloppement, tests
StandardPerformance équilibréeProduction
ProductionRessources dédiéesCharges critiques

Options de flavor​

Les flavors varient selon la classe de calcul. Voir Créer un cluster pour les spécifications détaillées.

Classe de calculSmallMediumLargeXLarge
Eco (1:2)0.5 vCPU, 1 Gi1 vCPU, 2 Gi2 vCPU, 4 Gi3 vCPU, 6 Gi
Standard (1:4)1 vCPU, 4 Gi2 vCPU, 8 Gi4 vCPU, 16 Gi15 vCPU, 58 Gi
Production (1:4)1 vCPU, 4 Gi2 vCPU, 8 Gi4 vCPU, 16 Gi6 vCPU, 28 Gi

Processus de mise à l'échelle​

  1. Accédez aux paramètres du cluster
  2. Sélectionnez une nouvelle classe de calcul ou flavor
  3. Appliquez les changements
  4. La mise à jour progressive se fait automatiquement

Configuration des réplicas​

RéplicasTolérance aux pannesPerformance
1AucuneMaximale
31 défaillance de nœudÉquilibrée
52 défaillances de nœudsRedondante
Production

Utilisez 3 réplicas en production. Cela fournit une tolérance aux pannes tout en maintenant de bonnes performances.

Configuration JetStream​

Activer/Désactiver JetStream​

  1. Accédez aux paramètres du cluster
  2. Basculez JetStream on/off
  3. Appliquez les changements
attention

Désactiver JetStream supprimera tous les streams, consumers, stores KV et stores d'objets.

Configuration des streams​

Types de stockage​

TypePersistancePerformanceCas d'utilisation
FilePersistantBonneProduction
MemoryNon-persistantExcellenteCache, données temporaires

Paramètres de rétention​

// Rétention basée sur les limites
{
retention: 'limits',
max_msgs: 1000000,
max_bytes: 1073741824, // 1GB
max_age: 604800000000000 // 7 jours (nanosecondes)
}

// Rétention basée sur l'intérêt
{
retention: 'interest'
// Messages supprimés quand pas de consumers
}

// Rétention work queue
{
retention: 'workqueue'
// Messages supprimés après accusé de réception
}

Réplication​

ParamètreDescription
1Pas de réplication (développement)
3HA standard
5Durabilité maximale

Configuration des consumers​

Politiques de livraison​

PolitiqueCommencer depuis
allDébut du stream
newNouveaux messages uniquement
lastDernier message
by_start_sequenceNuméro de séquence spécifique
by_start_timeTimestamp spécifique

Politiques d'accusé de réception​

PolitiqueDescription
nonePas d'accusé de réception requis
allAccuser réception de tous les messages jusqu'à la séquence
explicitChaque message accusé individuellement

Paramètres de re-livraison​

{
max_deliver: 5, // Tentatives de livraison maximales
ack_wait: 30000000000, // 30 secondes (nanosecondes)
max_ack_pending: 1000 // Messages non-accusés maximum
}

Configuration des stores Key-Value​

ParamètreDescriptionDéfaut
HistoryRévisions par clé1
TTLExpiration des entréesAucun
Max Value SizeTaille max des valeurs en octets-1 (illimité)
Max BytesStockage total-1 (illimité)
ReplicasNombre de copies1

Configuration des stores d'objets​

ParamètreDescriptionDéfaut
Max BytesStockage total-1 (illimité)
StorageFile ou MemoryFile
ReplicasNombre de copies1

Configuration de connexion​

Format de la chaîne de connexion​

nats://{cluster-name}.{namespace}:{port}

Exemple :

nats://my-nats.my-project-abc123:4222

Options client​

JavaScript/TypeScript​

import { connect } from 'nats';

const nc = await connect({
servers: 'nats://my-nats.my-project-abc123:4222',

// Options de connexion
reconnect: true,
maxReconnectAttempts: -1, // Illimité
reconnectTimeWait: 1000, // 1 seconde

// Timeouts
timeout: 10000, // 10 secondes
pingInterval: 30000, // 30 secondes

// Paramètres de buffer
maxPingOut: 2,
noEcho: true
});

Go​

nc, err := nats.Connect(
"nats://my-nats.my-project-abc123:4222",
nats.MaxReconnects(-1),
nats.ReconnectWait(time.Second),
nats.Timeout(10*time.Second),
nats.PingInterval(30*time.Second),
nats.MaxPingsOutstanding(2),
)

Python​

nc = await nats.connect(
"nats://my-nats.my-project-abc123:4222",
reconnect_time_wait=1,
max_reconnect_attempts=-1,
connect_timeout=10,
ping_interval=30
)

Bonnes pratiques de connexion​

  1. Activer la reconnexion automatique : Toujours configurer la reconnexion automatique
  2. Définir des timeouts appropriés : Équilibrer réactivité et fiabilité
  3. Gérer les déconnexions : Implémenter une gestion d'erreurs appropriée
nc.status().subscribe((status) => {
switch (status.type) {
case 'disconnect':
console.log('Déconnecté de NATS');
break;
case 'reconnect':
console.log('Reconnecté à NATS');
break;
case 'error':
console.error('Erreur NATS :', status.data);
break;
}
});

Variables d'environnement​

Configurez votre application avec ces variables d'environnement :

# Connexion
NATS_URL=nats://my-nats.my-project-abc123:4222

# Authentification optionnelle
NATS_USER=admin
NATS_PASSWORD=your-password

# Le TLS managé n'est pas encore disponible ; les endpoints SailOps utilisent actuellement nats://.

Optimisation des performances​

Débit de messages​

Pour un haut débit :

ParamètreRecommandation
Publication par lotsPublier par lots de 100-1000
Publication asynchroneUtiliser fire-and-forget quand la durabilité n'est pas nécessaire
Parallélisme des consumersMultiples consumers avec queue groups
// Publication par lots
const js = nc.jetstream();
const promises = messages.map(msg =>
js.publish('events.batch', JSON.stringify(msg))
);
await Promise.all(promises);

Optimisation mémoire​

ParamètreRecommandation
Taille des messagesGarder les messages petits (moins de 1MB)
Rétention des streamsDéfinir des limites appropriées
Prefetch des consumersLimiter max_ack_pending

Optimisation de la latence​

ParamètreRecommandation
RéplicasUtiliser 3 pour équilibrer latence/durabilité
StockageUtiliser Memory pour la latence minimale
Accusé de réceptionUtiliser la politique none si la durabilité n'est pas critique

Configuration du monitoring​

Métriques à surveiller​

MétriqueSeuil d'alerte
Utilisation CPU>80%
Utilisation mémoire>85%
Nombre de connexionsProche du max
Taux de messagesBaisses inattendues
Retard des consumers>10000 en attente

Configuration des alertes​

  1. Allez dans Monitoring → Alertes
  2. Créez une règle d'alerte pour les métriques NATS
  3. Configurez les canaux de notification
  4. Définissez des seuils appropriés

Sauvegarde et récupération​

Sauvegarde des streams​

Exportez les données du stream pour la sauvegarde :

const stream = await js.streams.get('ORDERS');

// Exporter les messages
const consumer = await stream.getConsumer('backup-consumer');
const messages = [];

for await (const msg of consumer.consume()) {
messages.push({
subject: msg.subject,
data: msg.data,
headers: msg.headers
});
msg.ack();
}

// Sauvegarder dans un fichier
fs.writeFileSync('backup.json', JSON.stringify(messages));

Récupération des streams​

Importez les données sauvegardées :

const backup = JSON.parse(fs.readFileSync('backup.json'));
const js = nc.jetstream();

for (const msg of backup) {
await js.publish(msg.subject, msg.data, {
headers: msg.headers
});
}

Dépannage​

Utilisation mémoire élevée​

  1. Vérifiez les limites de stockage des streams
  2. Revoyez les paramètres de rétention des messages
  3. Purgez les anciens messages si nécessaire
  4. Envisagez de passer de Memory à File

Consumers lents​

  1. Augmentez les instances de consumers
  2. Utilisez des queue groups pour la distribution de charge
  3. Optimisez le traitement des messages
  4. Augmentez max_ack_pending

Problèmes de connexion​

  1. Vérifiez la chaîne de connexion
  2. Vérifiez la connectivité réseau
  3. Revoyez les règles de firewall
  4. Assurez-vous que le cluster est en cours d'exécution

Prochaines étapes​