TOC

Comment installer et configurer NATS sur Ubuntu 16.04

introduction

NATS est un système de messagerie open source hautes performances, souvent décrit comme «un système nerveux central pour le cloud». Il est capable de router des millions de messages par seconde, ce qui le rend idéal pour la connexion de microservices et de périphériques IoT (Internet of Things).

NATS est un système de messagerie Pub Sub. Dans ce type de système, un ou plusieurs publishers envoient des messages à un certain sujet vers un message broker et le courtier de messages transmet ces messages à tous les clients, ou subscribers du sujet donné. Les éditeurs ne connaissent pas les abonnés et ne s’intéressent pas à eux, et inversement. Cette architecture facilite la mise à l’échelle du système et l’ajout de nouvelles fonctionnalités, car nous pouvons ajouter des éditeurs et des abonnés sans affecter le reste du système. Ce type de système est idéal pour surveiller les serveurs et les périphériques. les appareils peuvent envoyer des messages et nous pouvons nous abonner à ces messages pour envoyer des notifications par courrier électronique ou par un autre moyen.

Dans ce tutoriel, nous allons installer + gnatsd +, le serveur NATS officiel, en tant que service et le rendre accessible de manière sécurisée. Nous allons également créer un système d’alerte de surcharge du serveur de base qui envoie des courriels lorsque la charge du serveur devient trop importante, en utilisant + gnatsd + comme courtier de messages.

Conditions préalables

Pour compléter ce tutoriel, vous aurez besoin de:

Étape 1 - Téléchargement du serveur NATS

Commençons par télécharger le serveur + gnatsd + et en s’assurant qu’il fonctionne sur notre système sans aucun problème.

La dernière version stable + gnatsd + est la version 0.9.4 au moment de la rédaction de ce tutoriel. Vous pouvez consulter home page de téléchargement NATS pour obtenir une version ultérieure et adapter les commandes ci-dessous si nécessaire si vous souhaitez utiliser une version plus récente.

Commencez par vous connecter à votre serveur avec votre compte non root:

ssh @

Assurez-vous ensuite que vous vous trouvez dans le répertoire de base de votre utilisateur:

cd

Ensuite, utilisez + wget + pour télécharger + gnatsd + sur votre serveur:

wget https://github.com/nats-io/gnatsd/releases/download/v/gnatsd-v-linux-amd64.zip

L’archive que vous venez de télécharger est une archive compressée, vous devez donc installer + unzip + pour extraire les fichiers. Vous pouvez l’installer avec + apt +:

sudo apt-get install -y unzip

Puis utilisez + unzip + pour extraire + gnatsd +:

unzip -p gnatsd-v-linux-amd64.zip gnatsd-v-linux-amd64/gnatsd > gnatsd

Ensuite, rendez exécutable + gnatsd + afin de pouvoir l’exécuter:

chmod +x gnatsd

Testons que nous pouvons exécuter + gnatsd + en l’exécutant à partir du répertoire en cours. Utilisez la commande suivante pour démarrer + gnatsd +:

./gnatsd --addr 127.0.0.1 --port 4222

La sortie que vous voyez sera semblable à cet exemple:

Output[1851] 2016/09/23 05:20:02.247420 [INF] Starting nats-server version 0.9.4
[1851] 2016/09/23 05:20:02.248182 [INF] Listening for client connections on
[1851] 2016/09/23 05:20:02.248626 [INF] Server is ready

Par défaut, + gnatsd + écoute sur le port + 4222 + sur l’adresse + 0.0.0.0 + qui correspond à toutes les interfaces. En utilisant l’argument + - port +, vous pouvez changer le port, et avec + - addr + vous pouvez changer l’adresse qu’il écoute. Nous avons exécuté + gnatsd + avec + - addr 127.0.0.1 +, afin qu’il ne soit disponible que sur notre serveur et que les clients externes ne puissent y accéder. Plus tard dans le tutoriel, nous allons sécuriser + gnatsd + et l’ouvrir au monde entier.

Appuyez sur + CTRL + C + pour arrêter + gnatsd +.

Maintenant que vous savez que les choses fonctionnent, mettons les choses en place de manière plus formelle.

Étape 2 - Création de la structure de répertoire et du fichier de configuration

Sous Linux, les logiciels tiers liés aux services sont fréquemment conservés dans le répertoire + / srv +. Nous allons suivre cette convention et conserver les fichiers liés à NATS sous + / srv / nats +. Nous placerons le fichier exécutable + gnatsd + dans + / srv / nats / bin +.

Commencez par créer le dossier + / srv / nats / bin +:

sudo mkdir -p /srv/nats/bin

Déplacez ensuite + gnatsd + dans le dossier + / srv / nats / bin +:

sudo mv ~/gnatsd /srv/nats/bin

Le serveur peut charger sa configuration à partir d’un fichier, ce qui sera utile lorsque nous aurons besoin de modifier les paramètres du serveur plus tard dans le tutoriel. Créez le fichier + / srv / nats / gnatsd.config +:

sudo nano /srv/nats/gnatsd.config

Et ajoutez le contenu suivant au fichier:

/srv/nats/gnatsd.config

port: 4222
net: '127.0.0.1'

Ce fichier de configuration indique au serveur + gnatsd + d’écouter sur le port + 4222 + à l’adresse + 127.0.0.1 +, comme avant, mais cette fois nous n’aurons pas à spécifier ces options sur la ligne de commande.

Lançons le serveur à nouveau pour s’assurer que nous avons configuré les choses correctement. Exécutez la commande suivante pour lancer + gnatsd + en utilisant le nouveau fichier de configuration:

/srv/nats/bin/gnatsd -c /srv/nats/gnatsd.config

Le résultat est similaire à ce que vous avez vu auparavant:

Output[1869] 2016/06/18 05:30:55.988856 [INF] Starting nats-server version 0.9.4
[1869] 2016/06/18 05:30:55.989190 [INF] Listening for client connections on
[1869] 2016/06/18 05:30:55.989562 [INF] Server is ready

Encore une fois, appuyez sur + CTRL + C + pour fermer + gnatsd + et retourner à votre invite. Créons maintenant un utilisateur qui exécutera ce service.

Étape 3 - Création de l’utilisateur de service

Il est recommandé de faire fonctionner chaque service avec son propre compte utilisateur afin de limiter les dommages éventuels au cas où un service serait compromis. Créons un utilisateur et un groupe qui sera propriétaire du service NATS et des fichiers associés à NATS.

Commençons par créer un utilisateur système et un groupe appelé ++:

sudo adduser --system --group --no-create-home --shell /bin/false nats
OutputAdding system user `nats' (UID 106) ...
Adding new group `nats' (GID 114) ...
Adding new user `nats' (UID 106) with group `nats' ...
Not creating home directory `/home/nats'.

Nous avons assigné le shell + / bin / false + à l’utilisateur système + nats + afin de désactiver les connexions pour cet utilisateur et de supprimer la création du répertoire de base. Nous avons également créé un groupe + nats +.

Remplaçons le propriétaire du répertoire + / srv + par l’utilisateur et le groupe + nats +:

sudo chown -R nats:nats /srv

Maintenant que nous avons créé l’utilisateur et le groupe + nats +, poursuivons avec la création du service NATS.

Étape 4 - Exécuter gnatsd en tant que service

Nous aimerions que + gnatsd + démarre au démarrage du système et redémarre s’il se bloque. Nous allons utiliser systemd pour gérer cela.

systemd est un gestionnaire de services pour les systèmes Linux. Il est chargé de démarrer les services au démarrage, de les redémarrer si nécessaire et de les arrêter de manière contrôlée à l’arrêt du système.

Nous devons créer une configuration de service afin de définir comment et quand le service NATS doit être démarré. Les fichiers de service créés par l’utilisateur résident dans + / etc / systemd / system +, créez donc le fichier + / etc / systemd / system / nats.service +:

sudo nano /etc/systemd/system/nats.service

Et dans le fichier, placez ce script pour définir le mode de démarrage de + gnatsd +:

/etc/systemd/system/nats.service

[Unit]
Description=NATS messaging server

[Service]
ExecStart=/srv/nats/bin/gnatsd -c /srv/nats/gnatsd.config
User=nats
Restart=on-failure

[Install]
WantedBy=multi-user.target

  • La section + [Unit] + contient des informations génériques sur le service, telles que + Description + qui décrit le service.

  • La section + [Service] + contient la configuration liée au service. + ExecStart + est la commande permettant d’exécuter le serveur. Nous utilisons le chemin absolu de l’exécutable + gnatsd + ici. + Restart = on-failure signifie que le service doit être redémarré s’il se bloque ou se termine avec un échec. Il ne sera pas redémarré s’il a été arrêté par systemd.

  • La section + [Install] + contient des informations sur l’installation du service. + WantedBy = multi-user.target indique à systemd de démarrer le service lors du démarrage de` + multi-user.target`. Il s’agit d’une méthode générique de démarrage des services au démarrage du système.

Une fois que la description du service est en place, nous pouvons la démarrer avec la commande suivante:

sudo systemctl start

Confirmons que + gnatsd + est en cours d’exécution en envoyant un message + PING +:

printf "PING\r\n" | nc 127.0.0.1 4222

Nous venons d’utiliser + nc + pour communiquer avec + gnatsd +. + nc + est un utilitaire de ligne de commande permettant de communiquer avec des serveurs TCP ou UDP. La commande utilisée imprime une sortie similaire à celle-ci:

OutputINFO {"server_id":"Os7xI5uGlYFJfLlfo1vHox","version":"0.9.4","go":"go1.6.3","host":"127.0.0.1","port":4222,"auth_required":false,"ssl_required":false,"tls_required":false,"tls_verify":false,"max_payload":1048576}

La réponse + PONG + nous permet de savoir que le serveur écoute et fonctionne comme prévu. Nous devons exécuter une dernière commande pour que notre serveur NATS démarre au démarrage:

sudo systemctl enable

Vous verrez la sortie suivante qui confirme que le service a été installé:

OutputCreated symlink from /etc/systemd/system/multi-user.target.wants/nats.service to /etc/systemd/system/nats.service.

Nous avons correctement configuré + gnatsd + pour s’exécuter en tant que service. Maintenant, sécurisons-le et rendons-le accessible aux clients externes.

Étape 5 - Sécuriser les connexions au service NATS

Si tous les éditeurs et les abonnés que nous aimerions utiliser avec + gnatsd + étaient sur le même serveur, nous pourrions appeler cela fait et passer à autre chose, mais c’est rarement le cas de nos jours. Nous devrons laisser les clients externes se connecter et publier les messages vers + gnatsd + de manière sécurisée.

+ gnatsd + supporte le transport TLS, nous allons donc l’utiliser pour sécuriser la communication entre + gnatsd + et les clients NATS.

Tout d’abord, nous avons besoin d’un certificat. Vous pouvez acheter un certificat commercial, en récupérer un à partir de http://letsencrypt.org [Let Encrypt] ou générer un certificat auto-signé. Nous utiliserons cette dernière approche, car l’acquisition d’un certificat n’entre pas dans le cadre de cet article.

Créez un répertoire pour contenir le certificat temporairement:

mkdir ~/priv

Créez ensuite un certificat auto-signé avec la commande suivante:

openssl req -x509 -nodes -days 3650 -newkey rsa:2048 \
   -keyout priv/gnatsd.key -out priv/gnatsd.crt \
   -subj "/C=US/ST=/L=/O=/CN=www."

Cette commande crée un certificat RSA avec 2048 bits et une validité de 10 ans. Notez que nous avons utilisé un nom de domaine arbitraire car nous n’activons pas la vérification TLS pour le serveur + gnatsd + dans cet article.

Vous devriez maintenant avoir les fichiers + gnatsd.key + et + gnatsd.crt + dans le répertoire + ~ / priv +. Déplaçons ces fichiers dans notre structure de répertoires + / srv / nats / + afin que tout soit au même endroit. Exécutez la commande suivante:

sudo mv ~/priv /srv/nats

Maintenant, rendez + / srv / nats / priv + accessible uniquement pour l’utilisateur et le groupe + nats +:

sudo chmod 440 /srv/nats/priv/*
sudo chmod 550 /srv/nats/priv
sudo chown -R nats:nats /srv/nats/priv

Maintenant, nous mettons à jour + / srv / nats / gnatsd.config + pour contenir le certificat et la clé que nous venons de créer. Ouvrez à nouveau le fichier de configuration:

sudo nano /srv/nats/gnatsd.config

Et ajoutez la section suivante pour indiquer à + gnatsd + `d’utiliser votre certificat et votre clé:

/srv/nats/gnatsd.config

. . .

tls {
 cert_file: ""
 key_file: ""
 timeout: 1
}

Enregistrez le fichier et quittez l’éditeur. Ensuite, redémarrez le service pour qu’il puisse prendre en compte les modifications.

sudo systemctl restart

Voyons si nos certificats fonctionnent. Exécutez cette commande:

printf "PING\r\n" | nc localhost 4222

Cette fois, la commande affiche le message suivant:

OutputINFO {"server_id":"npkIPrCE5Kp8O3v1EfV8dz","version":"0.9.4","go":"go1.6.3","host":"127.0.0.1","port":4222,"auth_required":false,"ssl_required":true,"tls_required":true,"tls_verify":false,"max_payload":1048576}

Le serveur a renvoyé le message + -ERR 'Connexion sécurisée - TLS requis' + qui confirme que la nouvelle configuration a été prise en compte et qu’une connexion sécurisée est requise, ce que + nc + ne sait pas faire.

Afin de pouvoir communiquer avec notre service NATS sans installer un client NATS complet, nous allons utiliser un outil appelé catnats. Commençons par le télécharger:

wget https://github.com/yuce/catnats/raw/0.1.2/catnats.py

Et le rendre exécutable:

chmod +x catnats.py

Enfin, déplacez + catnats.py + vers le dossier + / srv / nats / bin + et renommez-le ainsi: + catnats +:

sudo mv catnats.py /srv/nats/bin/catnats

Vérifions que nous pouvons communiquer avec notre service NATS en utilisant + catnats +, en envoyant le même message + PING + que nous avons envoyé auparavant:

printf "PING\r\n" | /srv/nats/bin/catnats --addr 127.0.0.1:4222

Vous verrez cette sortie indiquant que votre connexion est sécurisée:

OutputINFO {"server_id":"npkIPrCE5Kp8O3v1EfV8dz","version":"0.9.4","go":"go1.6.3","host":"127.0.0.1","port":4222,"auth_required":false,"ssl_required":true,"tls_required":true,"tls_verify":false,"max_payload":1048576}

Maintenant que la communication est sécurisée, activons l’authentification afin qu’un nom d’utilisateur et un mot de passe soient nécessaires pour se connecter à NATS.

Étape 6 - Requérir une authentification

Notre service NATS ne nécessite pas d’authentification par défaut. C’est bien lorsque le service n’est accessible que sur un réseau privé, mais nous voulons que notre service NATS soit accessible sur Internet, nous devons donc activer l’authentification. + gnatsd + prend en charge l’authentification par nom d’utilisateur et mot de passe, et il est facile à activer.

Ouvrez le fichier + / srv / nats / gnatsd.config +:

sudo nano /srv/nats/gnatsd.config

Ajoutez une nouvelle section + autorisation + qui spécifie les informations d’identification. Nous allons utiliser ` comme nom d'utilisateur et ` comme mot de passe pour ce tutoriel. Vous devez utiliser un mot de passe plus long et plus complexe dans un environnement de production:

/srv/nats/gnatsd.config

. . .

authorization {
 user:
 password:
}

Enregistrez le fichier, puis changez le propriétaire de + / srv / nats / gnatsd.config + en + nats + et rendez-le lisible par cet utilisateur afin de protéger le nom d’utilisateur et le mot de passe d’autres utilisateurs du système:

sudo chown nats /srv/nats/gnatsd.config
sudo chmod 400 /srv/nats/gnatsd.config

Puis redémarrez le service pour que les modifications prennent effet:

sudo systemctl restart nats

Envoyons un message + PING + à + ​​gnatsd + pour vérifier si tout va bien. Encore une fois, utilisez + catnats + pour envoyer le message:

printf "PING\r\n" | /srv/nats/bin/catnats --addr 127.0.0.1:4222

Vous verrez le résultat suivant:

OutputNFO {"server_id":"sY0SSJBNbEw53HxzS9mH1t","version":"0.9.4","go":"go1.6.3","host":"127.0.0.1","port":4222,"auth_required":true,"ssl_required":true,"tls_required":true,"tls_verify":false,"max_payload":1048576}

Cela nous indique que les modifications ont été appliquées avec succès et que nous devons maintenant envoyer le nom d’utilisateur et le mot de passe corrects pour pouvoir vous connecter au service. Essayons encore, en fournissant le nom d’utilisateur ` et le mot de passe `:

printf "PING\r\n" | /srv/nats/bin/catnats --addr 127.0.0.1:4222 --user  --pass

Cette fois, cela a fonctionné, comme vous pouvez le constater avec la sortie suivante:

OutputINFO {"server_id":"sY0SSJBNbEw53HxzS9mH1t","version":"0.9.4","go":"go1.6.3","host":"127.0.0.1","port":4222,"auth_required":true,"ssl_required":true,"tls_required":true,"tls_verify":false,"max_payload":1048576}

Maintenant que nous avons limité ce service aux clients qui connaissent le nom d’utilisateur et le mot de passe, nous pouvons le reconfigurer pour que les clients externes puissent se connecter.

Étape 7 - Ouvrir le service au monde

Nous avons configuré notre serveur NATS pour l’écoute sur + 127.0.0.1 +, qui est l’interface locale. Si nous le faisons écouter sur + 0.0.0.0 +, il sera disponible pour le monde entier. Mettons à jour la dernière mise à jour + / srv / nats / gnatsd.config +:

sudo nano /srv/nats/gnatsd.config

Puis changez l’adresse IP associée au paramètre + net +:

/srv/nats/gnatsd.config

. . .
net: ''
. . .

Enregistrez le fichier et redémarrez le service:

sudo systemctl restart nats

Et maintenant, notre service NATS est prêt pour les connexions client externes. Pour apprendre à l’utiliser, créons un service de surveillance simple qui utilise notre serveur NATS en tant que courtier de messages.

Étape 8 - (Facultatif) Configuration des notifications en cas de surcharge du serveur

Dans cette section, vous allez créer un système simple de surveillance de la surcharge qui utilise votre service NATS. Le système recevra les moyennes de charge des serveurs et enverra un courrier électronique à un administrateur si l’un des serveurs est surchargé.

Le projet d’exemple comprendra les composants suivants:

  • Le service NATS que vous venez de configurer.

  • Un moniteur, qui publie le nom d’hôte, la moyenne de charge et le nombre de processeurs du serveur dans l’objet + stats.loadaverage + toutes les 60 secondes. Vous devez exécuter ce composant sur n’importe quel serveur sur lequel vous souhaitez surveiller la charge.

  • Un notificateur, qui s’abonne à l’objet + stats.loadaverage + et reçoit le nom d’hôte, la charge moyenne et le nombre de processeurs d’un serveur. Si la charge moyenne d’un hôte dépasse un certain seuil, le notifiant envoie un courrier électronique à une adresse prédéfinie via un serveur SMTP.

Nous allons exécuter tous ces composants sur le même serveur pour plus de simplicité, mais vous pouvez essayer d’exécuter chaque composant sur un serveur différent une fois ce didacticiel terminé.

Configuration du moniteur

Vous pouvez lire la charge moyenne sur un système Linux à partir de + / proc / loadavg +. Pour ce projet, nous nous intéressons uniquement à la charge moyenne de la dernière minute, qui est le premier champ de la sortie. Utilisez cette commande pour obtenir cette valeur:

cat /proc/loadavg | cut -f1 -d" "

Vous verrez le résultat suivant:

Output0.11

La charge moyenne obtenue en lisant + / proc / loadavg + dépend du nombre de processeurs. Vous devez donc la normaliser en divisant la moyenne de charge par le nombre de processeurs. Vous pouvez utiliser la commande suivante pour obtenir le nombre de processeurs de votre serveur:

getconf _NPROCESSORS_ONLN

Vous verrez le résultat affiché sur votre terminal:

Output1

Comme le shell par défaut de notre serveur ne peut pas traiter l’arithmétique en nombres flottants, nous enverrons la charge moyenne et le nombre de processeurs avec le nom d’hôte comme charge utile de notre message et effectuerons la division dans le notifiant ultérieurement. Voici la commande que nous allons utiliser pour construire la charge utile:

echo $(hostname) `cat /proc/loadavg | cut -f1 -d" "` `getconf _NPROCESSORS_ONLN`

La commande affiche le nom d’hôte, la charge moyenne et le nombre de processeurs, respectivement:

Output 0.28 1

Créons un script shell qui publie le nom d’hôte, la charge moyenne et le nombre de processeurs sur notre serveur NATS avec le sujet + stats.loadaverage +. Nous allons configurer notre système pour exécuter ce script périodiquement. Créez un nouveau fichier nommé + ~ / publish_load_average.sh +:

nano ~/publish_load_average.sh

Dans le fichier, ajoutez ce script:

~ / publish_load_average.sh

NATS_ADDR=
LOADAVG=
NPROC=
SUBJECT=
PAYLOAD=
MESSAGE=
printf "$MESSAGE" | /srv/nats/bin/catnats -q --raw --addr $NATS_ADDR --user  --pass

Ce script crée le message puis le redirige vers + catnats +, qui le publie sur le service NATS. Nous exécutons + catnats + avec le commutateur + -q + pour supprimer toute sortie, et nous utilisons le commutateur + - raw + afin que + catnats + n’essaie pas d’interpréter le contenu de l’entrée. Vous pouvez modifier la valeur de la variable + $ NATS_ADDR + si le service NATS se trouve sur des serveurs différents.

Vérifions que le script envoie des moyennes de charge à NATS.

La commande suivante lance + ~ / publish_load_average.sh + toutes les 5 secondes. Notez que nous utilisons le caractère + & + en fin de ligne pour exécuter la commande en arrière-plan:

while true; do sh ~/publish_load_average.sh; sleep 5; done &

La sortie indique que la commande est exécutée en arrière-plan avec un ID de processus:

Output[1]

Connectez-vous maintenant à NATS et abonnez-vous au sujet + stats.loadaverage + pour récupérer les moyennes de charge:

printf "SUB stats.loadaverage 0\r\n" | /srv/nats/bin/catnats --raw --no-exit --pong --user  --pass

Nous utilisons les indicateurs + - no-exit + pour désactiver l’exit automatique et + - pong + pour maintenir notre connexion à NATS active. Si tout est correct, vous devriez obtenir un résultat similaire au suivant, qui sera mis à jour toutes les 5 secondes:

OutputINFO {"server_id":"A8qJc7mdTy8AWBRhPWACzW","version":"0.8.1","go":"go1.6.2","host":"0.0.0.0","port":4222,"auth_required":true,"ssl_required":true,"tls_required":true,"tls_verify":false,"max_payload":1048576}
+OK
+OK
MSG stats.loadaverage 0 27

Appuyez sur + CTRL + C + pour quitter ` + catnats + `. Arrêtons également la boucle appelée `+ publish_load_average.sh + car nous aurons une meilleure façon d’exécuter + publish_load_average.sh +:

kill

L’approche que nous venons de faire fonctionne bien pour les tests, mais nous ne souhaitons pas l’utiliser de manière permanente. Nous aimerions que le système exécute + publish_load_average.sh + toutes les minutes. Pour ce faire, nous pouvons ajouter une entrée crontab. Les systèmes Linux utilisent + cron +, un système capable d’exécuter des commandes ou des «travaux» selon un calendrier que nous spécifions. La commande + crontab + nous permet de gérer ces travaux. Vous pouvez tout apprendre sur Cron dans le tutoriel Comment utiliser Cron pour automatiser des tâches Sur un VPS.

Pour créer une nouvelle entrée, exécutez la commande:

crontab -e

Si vous n’avez jamais exécuté la commande ci-dessus, l’invite suivante peut vous demander de choisir un éditeur de texte pour gérer les entrées:

Outputno crontab for demo - using an empty one

Select an editor.  To change later, run 'select-editor'.
 1. /bin/ed
 2. /bin/nano        <---- easiest
 3. /usr/bin/vim.basic
 4. /usr/bin/vim.tiny

Choose 1-4 [2]:

Tapez le numéro correspondant à l’éditeur avec lequel vous êtes le plus à l’aise et appuyez sur + ENTER. Un fichier sera affiché dans l’éditeur que vous avez choisi.

A la fin du fichier ouvert, ajoutez la ligne suivante, mais remplacez votre nom d’utilisateur si vous avez utilisé autre chose que ++:

*/1 * * * * bash /home//publish_load_average.sh

L’entrée ci-dessus indique à + ​​cron + d’exécuter notre script + publish_load_average.sh + toutes les minutes. Enregistrez le fichier et fermez l’éditeur.

Voyons maintenant que la publication périodique de la charge moyenne fonctionne:

printf "SUB stats.loadaverage 0\r\n" | /srv/nats/bin/catnats --raw --no-exit --pong --user  --pass

Attendez quelques minutes et le résultat affiché sera similaire à celui-ci:

OutputINFO {"server_id":"A8qJc7mdTy8AWBRhPWACzW","version":"0.8.1","go":"go1.6.2","host":"0.0.0.0","port":4222,"auth_required":true,"ssl_required":true,"tls_required":true,"tls_verify":false,"max_payload":1048576}
+OK
+OK
MSG stats.loadaverage 0 27

MSG stats.loadaverage 0 27

Appuyez sur + CTRL + C + pour quitter + catnats +.

Nous avons correctement configuré le moniteur, qui envoie des messages à notre serveur NATS. Nous allons ensuite configurer le notificateur qui utilise ces données.

Création du notifiant

Créons la notification qui se connecte à notre service NATS et écoute les messages + stats.loadaverage +. Chaque fois que notre programme reçoit un message, il calcule la charge moyenne par processeur. S’il est supérieur à 0,6 ou 60% d’utilisation du processeur par processeur, il définit un indicateur d’avertissement pour l’hôte qui a publié le message et envoie un courrier électronique à une adresse prédéfinie. Si la charge moyenne par processeur est inférieure à 0,4, l’indicateur d’avertissement de l’hôte est effacé. Pour éviter d’inonder la boîte de réception, nous envoyons un seul courrier électronique lorsque l’indicateur d’avertissement est défini.

Nous allons utiliser Node.JS pour créer le notifiant, car il existe un excellent client NATS pour Node.js. Donc, installez d’abord Node.js:

sudo apt-get install -y npm

Créez ensuite le répertoire du notifiant et accédez-y:

mkdir ~/overload_notifier && cd ~/overload_notifier

Les projets Node.js utilisent un fichier nommé + package.json + qui contient des informations sur le projet et ses dépendances. Exécutez la commande suivante pour créer ce fichier:

npm init -y

Ensuite, installez le client NATS pour Node.js, ainsi que le module + nodemailer + que nous utiliserons dans ce projet pour envoyer des courriels d’avertissement:

npm install [email protected] [email protected] --save-exact

Nous pouvons maintenant créer le notifiant. Créez le fichier + notifier.js +:

nano notifier.js

Ajoutez ensuite le code suivant au fichier:

notifier.js

var NATS_URL = 'nats://127.0.0.1:4222';
var NATS_USER = '';
var NATS_PASS = '';
var EMAIL_TO = '';

Veillez à modifier ces options pour qu’elles correspondent à votre nom d’utilisateur et à votre mot de passe pour le service NATS, ainsi qu’à votre adresse électronique.

Ensuite, ajoutez ce code pour importer le client NATS Node.js et vous connecter au service + gnatsd +:

notifier.js

var tlsOptions = {
 rejectUnauthorized: false,
};
var nats = require('nats').connect({url: NATS_URL,
                                   tls: tlsOptions,
                                   user: NATS_USER,
                                   pass: NATS_PASS});

Ajoutez ensuite ce code pour configurer le courrier et connectez-vous au serveur SMTP qui enverra les courriels. Nous allons installer ce serveur sous peu:

notifier.js

var nodemailer = require('nodemailer');
var transport = nodemailer.createTransport('smtp://localhost:2525');

Ajoutez ensuite le reste du code pour calculer la charge moyenne et déterminer si nous devons ou non envoyer un courrier électronique de notification:

notifier.js

// keep the state of warnings for each host
var warnings = {};

function sendEmail(subject, text) {
   transport.sendMail({
       to: EMAIL_TO,
       subject: subject,
       text: text
   });
}

function processMessage(message) {
   // message fields: host load processor_count
   var fields = message.split(" ");
   var host = fields[0];
   var loadAverage = parseFloat(fields[1]) / parseInt(fields[2]);
   if (loadAverage > 0.6) {
       if (!warnings[host]) {
           // send warning email if one wasn't already sent
           var res = sendEmail('Warning! Server is Overloaded: ' + host,
                               'Load average: ' + loadAverage);
           // set warning for the host
           warnings[host] = true;
       }
   }
   else if (loadAverage < 0.4) {
       if (warnings[host]) {
           // clear the warning
           warnings[host] = false;
       }
   }
}

nats.subscribe('stats.loadaverage', processMessage);

Nous nous abonnons au message et chaque fois que nous recevons un message, nous exécutons la fonction + processMessage +, qui analyse la charge utile que nous avons envoyée et détermine la charge moyenne. S’il est trop élevé, nous envoyons le message et nous vérifions si nous en avons déjà envoyé un en définissant un indicateur basé sur le nom d’hôte. De cette façon, nous pouvons suivre les notifications par hôte. Si la charge moyenne est inférieure à notre seuil, nous désactivons cet indicateur.

Avec le moniteur et le notificateur en place, il est temps de tester notre exemple de projet.

Tester le projet

Prenons ceci pour un essai routier. Nous allons générer une charge artificielle et vérifier si le notifiant envoie le message d’avertissement lorsque la charge devient trop élevée.

Installons l’outil + stress + pour générer de la charge CPU sur notre serveur:

sudo apt-get install -y stress

Ensuite, nous devons configurer un serveur SMTP pour envoyer les messages de notre notificateur. L’installation et la configuration d’un serveur SMTP complet s’avéreraient excessives pour ce test. Nous allons donc utiliser un serveur SMTP simple qui affiche uniquement les courriers électroniques qui lui sont remis au lieu de les envoyer. Le langage de programmation Python a un module + DebuggingServer + que nous pouvons charger et qui supprime les courriels qu’il reçoit, mais les affiche à l’écran afin que nous puissions nous assurer que tout fonctionne. Python est déjà installé sur notre serveur Ubuntu, c’est donc une solution parfaite.

Commençons par le serveur de débogage SMTP en arrière-plan. Nous le ferons écouter sur + localhost + port + 2525 +, qui correspond à l’adresse SMTP que nous avons configurée dans notre code + notifier.js +. Exécutez cette commande pour démarrer le serveur SMTP:

python -m smtpd -n -c DebuggingServer localhost:2525 &

Ensuite, démarrez le notificateur en arrière-plan avec cette commande:

nodejs ~/overload_notifier/notifier.js &

Enfin, générons une charge sur tous les processeurs de notre serveur. Exécutez la commande + stress + avec les options suivantes:

stress --cpu $(getconf _NPROCESSORS_ONLN)

Au bout de quelques minutes, vous verrez une sortie semblable à celle-ci, lorsque le serveur SMTP commencera à afficher les messages envoyés par le notifiant:

Output---------- MESSAGE FOLLOWS ----------
Content-Type: text/plain
To:
Subject: Warning! Server is Overloaded:
Message-Id: <1466354822129-04c5d944-0d19670b-780eee12@localhost>
X-Mailer: nodemailer (2.4.2; +http://nodemailer.com/;
SMTP/2.5.0[client:2.5.0])
Content-Transfer-Encoding: 7bit
Date: Sun, 19 Jun 2016 16:47:02 +0000
MIME-Version: 1.0
X-Peer: 127.0.0.1


------------ END MESSAGE ------------

Cela vous permet de savoir que vous avez envoyé des courriels lorsque la charge est trop importante sur le serveur.

Appuyez sur + CTRL + C + pour arrêter de générer de la charge. Vous avez terminé l’exemple de projet et vous devriez maintenant avoir une bonne idée de la façon dont vous pourrez le faire fonctionner dans votre propre environnement.

Conclusion

Dans cet article, vous avez découvert le système de messagerie NATS PubSub, que vous l’avez installé de manière sécurisée en tant que service et que vous l’avez testé dans un exemple de projet. L’exemple de projet a utilisé le client Node.JS, mais NATS a des clients pour plusieurs langages et infrastructures que vous pouvez trouver répertoriés sur la page de téléchargement NATS. Vous pouvez en apprendre plus sur NATS dans son documentation officielle.

Related