Intégration Webhook de Monasca OpenStack

2016-03-25

Machine-translated from English. Read the English original

# L'histoire en deux secondes de Graham sur les Webhooks [non technique]

Eh bien, je suis sûr que vous savez tous ce que sont les webhooks, mais je ne l'ai découvert que le mois dernier en préparation d'une autre intégration Helion OpenStack.

Voici ma compréhension simplifiée : ce sont des « Notifications Push ».

Avec l'avènement des internets, nous sommes devenus très intelligents très vite et avons commencé à utiliser tous ces protocoles UDP et TCP fous pour la communication M2M. Comme la bande passante n'était jamais un problème (je plaisante), l'efficacité n'était jamais la première exigence.

De nombreuses solutions de surveillance se sont arrêtées à HTTP comme protocole de choix et ont simplement interrogé les ressources qui les intéresse et attendu une réponse. Monasca vous fournit une API RESTful si vous souhaitez utiliser cette approche.

Cependant, avec le cloud viennent les défis de l'échelle. Et lorsque vous essayez d'interroger des centaines de milliers de services en quelques secondes, l'efficacité est très importante. Les webhooks arrivent alors pour sauver la mise.

Contrairement au sondage « à l'ancienne » et inefficace qui nécessite un HTTP GET suivi d'un HTTP POST, même lorsqu'il n'y a rien à signaler, les webhooks nécessitent un seul HTTP POST et ne se déclenchent que lorsqu'il y a quelque chose de worth POSTing home about!!!

Donc, pour résumer : ce sont des HTTP GET/POST fréquents contre des HTTP POST peu fréquents. Il y a un mythe urbain qui circule sur le net selon lequel, lorsque Github a introduit les Webhooks, cela a réduit la charge sur leurs serveurs de 66X par les utilisateurs qui surveillaient les nouveaux changements de code. [ Je n'ai aucun fait]

Comment les configurer – simples, surtout si vous avez lu mon précédent blog sur l'intégration SMTP. Faisons d'abord la partie GUI – tout cela pourrait être fait depuis la CLI, mais cela me nécessiterait de lire davantage.

Note : L'interface graphique de la console d'exploitation est spécifique à la distribution Helion OpenStack. Si vous n'utilisez pas Helion, vous devrez utiliser la CLI Monasca.

Configuration Webhook dans HOS Monasca

Connectez-vous à la console d'exploitation Helion en tant qu'utilisateur administrateur de cloud
Sélectionnez l'option Méthodes de notification dans le menu « hamburger » en haut à gauche de l'écran.
Créez une nouvelle méthode de notification, sélectionnez Webhook et saisissez les détails de l'URL vers laquelle vous souhaitez HTTP POST les notifications.

Et c'est tout ce qu'il y a à faire avec les webhooks. Mais attendez, « comment testons-nous et vérifions cela », vous pensez... eh bien, lisez la suite.

Créer une alarme de test

Retour à notre menu « hamburger » et cette fois sélectionnez Création d'alarme et créez une nouvelle alarme comme suit – nous voulons de faux alertes ici – donc j'utiliserai cpu.idle comme métrique et définirai des valeurs absurdes –
TestAlarm
Créer une nouvelle définition d'alarme

Initialement, 2 alarmes Inconnues peuvent apparaître car c'est la première fois que cette alarme s'exécute et qu'elle n'a pas d'état précédent. Cependant, soyez patient, dans quelques minutes de plus, vous devriez voir le tableau de bord s'illuminer comme indiqué ci-dessous.
Alarm dashboard
Attendez quelques minutes (5)

Vous pouvez maintenant sélectionner les alarmes pour plus de détails.
Alarm List
Regarder les alarmes
Alarm detail
Afficher les détails de l'alarme

Et bien sûr, ce pour quoi nous avons tous attendu – les alertes webhook!!!

Doh! Comment testons-nous les alertes webhook…

De nombreuses solutions de surveillance de qualité entreprise ne prennent toujours pas en charge les webhooks aujourd'hui – ces derniers ne comprennent tout simplement pas l'agilité et s'étonnent que les petits poissons les dépassent.

Encore une fois, je ne recommande pas de faire quoi que ce soit de ce que vous êtes sur le point de voir sur des systèmes de production – c'est purement pour tester et vérifier les webhooks. Veuillez également noter que j'ai ouvert un port sur le pare-feu du plan de contrôle HOS pour me permettre d'utiliser mon nœud de déploiement en tant que serveur webhook fonctionnant sur le port 3001. [Voir l'article SMTP précédent si vous souhaitez tester cela DANS VOTRE LAB]

Note : À tous les codeurs là-bas, je m'excuse maintenant pour toutes les règles que je brise, le mauvais codage, etc. soyez gentil, j'ai bricolé ces exemples grâce à toutes vos publications 🙂

J'ai fourni deux scripts d'exemple ci-dessous, un pour NodeJS et un pour Python. Python parce que de nombreux utilisateurs d'OpenStack le connaîtront. NodeJS parce que je voulais une excuse pour jouer avec – c'est bien ! Je ne couvre pas comment configurer vos environnements python ou node ici, il y a des tonnes de blogs sur ces sujets. Virtual Environment (virtualenv) est votre ami si vous utilisez python – utilisez-le.

Exemple Python

Copiez le script python suivant dans un fichier et enregistrez-le sous webhook.py. Ce script attend les notifications webhook et, lorsqu'il les reçoit, les écrit dans un fichier journal. Cela pourrait être utilisé par les solutions de surveillance héritées pour analyser les alertes – ce n'est pas de qualité entreprise cependant – juste un exemple.

webhook.py

# Author: Graham Joseph Land
# Blog: allthingscloud.eu
# Twitter: @allthingsclowd
# Email: graham@ the above domain
# Date: 24/03/2016
# 
# Name: webhook.py
# Version: 0.1
# Purpose: This script listens for webhook notifications and then writes them to a logfile
#
from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
import json
import logging
import logging.handlers

# log file for this script
log_file = '/home/stack/monitoring/venv/webhook/webhook.log'

log_max_size = 25165824         # 24 MB
log_level = logging.INFO
#log_level = logging.DEBUG      # DEBUG is quite verbose

log = logging.getLogger('log')
log.setLevel(log_level)
log_handler = logging.handlers.RotatingFileHandler(log_file,
                                                   maxBytes=log_max_size,
                                                   backupCount=4)
f = logging.Formatter("%(asctime)s %(filename)s %(levelname)s %(message)s",
                      "%B %d %H:%M:%S")
log_handler.setFormatter(f)
log.addHandler(log_handler)

class webhookReceiver(BaseHTTPRequestHandler):

    def do_POST(self):
        """
            receives post, handles it
        """
        log.info('<<<<<<<<< Alert Start >>>>>>>>')
        message = 'OK'
        self.rfile._sock.settimeout(5)
        data_string = self.rfile.read(int(self.headers['Content-Length']))
        self.send_response(200)
        self.send_header("Content-type", "text")
        self.send_header("Content-length", str(len(message)))
        self.end_headers()
        self.wfile.write(message)

        # parse data
        text = json.loads(data_string)
        text = json.dumps(text, indent=2)
        log.info(text)
        log.info('<<<<<<<<< Alert End >>>>>>>>')

    def log_message(self, formate, *args):
        """
            disable printing to stdout/stderr for every post
        """
        return

def main():
    """
        the main event.
    """
    try:
        server = HTTPServer(('', 3001), webhookReceiver)
        log.info('started web server...')
        server.serve_forever()
    except KeyboardInterrupt:
        log.info('ctrl-c pressed, shutting down.')
        server.socket.close()

if __name__ == '__main__':

Exécutez le script et suivez le fichier journal – maintenant retournez en arrière et générez à nouveau les alertes et voyez ce qui se passe..
Webhook Alarm

Et voilà – les webhooks – « simples »!

Pour exclure les problèmes Monasca, vous pouvez également tester ce script à l'aide d'une déclaration curl comme suit :

curl -H "Content-Type: application/json" -X POST -d '{"alarm_id": "1234","alarm_definition_id": "freddef","alarm_name": "fire alarm","alarm_description": "alarmDescription","alarm_timestamp": "timestamp","state": "Critical","old_state": "oldState","message": "this is the message","tenant_id": "tenant1234","metrics": "1234"}' --trace-ascii debugdump.txt http://172.16.60.9:3000/openstack/alerts

Exemple NodeJS

Notez que j'utilise un point de terminaison webhook différent de celui utilisé dans l'exemple python.
nodejswebhook

Il faut une structure de fichiers légèrement plus complexe pour l'application d'exemple NodeJS.

Nous utilisons le principal app server.js qui appelle ensuite l'application de « route » webhook.js qui traitera le webhook à sa réception.

(venv)stack@helion-cp1-c0-m1-mgmt:~/monitoring/nodejs$ tree -I node_modules
.
|-- routers
|   `-- webhook.js
`-- server.js

Copiez les deux applications ci-dessous dans des fichiers correspondants nommés en utilisant la même structure de répertoire montrée ci-dessus.

server.js

var bodyParser  = require( 'body-parser' ),
    express     = require( 'express' ),
    app         = express();

var webhook        = require( './routers/webhook' );

app.use( bodyParser.json() );
app.use( bodyParser.urlencoded({
  extended: true
}) );

app.get( '/', function ( req, res, next ) {
    res.send( 'Hooks listener running' );
});
app.use( '/openstack/alerts', webhook );

app.listen( 3001 );

et dans le sous-répertoire routers

webhook.js

var express = require( 'express' ),
    bodyParser = require('body-parser'),
    router  = express.Router();

router.use(bodyParser.json());

router.post( '/', function ( req, res, next ) {
    console.log(req.body);

    res.status(200).json({message: 'Monasca Hook received!'})
});

module.exports  = router;

Lancez l'application et testez d'abord avec curl –

stack@helion-cp1-c0-m1-mgmt:~$ curl -H "Content-Type: application/json" -X POST -d '{"alarm_id": "1234","alarm_definition_id": "freddef","alarm_name": "fire alarm","alarm_description": "alarmDescription","alarm_timestamp": "timestamp","state": "Critical","old_state": "oldState","message": "this is the message","tenant_id": "tenant1234","metrics": "1234"}' --trace-ascii debugdump.txt http://172.16.60.9:3001/openstack/alerts
{"message":"Monasca Hook received!"}stack@helion-cp1-c0-m1-mgmt:~$

Le résultat devrait ressembler à ceci

(venv)stack@helion-cp1-c0-m1-mgmt:~/monitoring/nodejs$ nodejs server.js
{ alarm_id: '1234',
  alarm_definition_id: 'freddef',
  alarm_name: 'fire alarm',
  alarm_description: 'alarmDescription',
  alarm_timestamp: 'timestamp',
  state: 'Critical',
  old_state: 'oldState',
  message: 'this is the message',
  tenant_id: 'tenant1234',
  metrics: '1234' }

Et enfin, envoyez une alerte depuis Monasca comme détaillé plus tôt pour voir les notifications webhook arriver et être traitées par l'application.
NodeAlerts

[Notes : Dépannage de la livraison des notifications]

Si vous ne voyez toujours aucun trafic maintenant ET que votre fichier /var/log/monasca/notification/notification.log est vide, essayez de reconfigurer monasca

cd ~/scratch/ansible/next/hos/ansible
ansible-playbook -i hosts/verb_hosts monasca-reconfigure.yml

Lors de la reconfiguration des définitions d'alarme existantes, assurez-vous de sélectionner À LA FOIS la case de notification ET les méthodes de notification individuelles requises.
Utilisez TCPDUMP pour vérifier si le trafic webhook quitte les interfaces de l'un des trois nœuds de contrôleur [recherchez sur le numéro de port webhook].

Originally published on allthingscloud.eu (2016-03-25).