[JAVA] Créez un tableau de bord pour les appareils réseau avec Django!

NetOpsCoding Advent Clender Ceci est l'article du 7ème jour. Dans cet article, nous utilisons Django pour obtenir des informations sur les périphériques réseau. En tant qu'application Web, nous partagerons comment créer un tableau de bord qui vous permet de vérifier le statut d'un seul coup. (La cible pour l'acquisition d'informations est principalement le routeur, pas le commutateur) スクリーンショット 2016-12-07 5.09.55.png

** Le tableau de bord créé cette fois a été téléchargé vers le git suivant. Qiita n'explique pas les détails, veuillez donc consulter l'article réel pour plus de détails ** https://github.com/Mabuchin/netboard

introduction

Différents outils ont été développés de l'Antiquité à nos jours comme outils d'acquisition du statut des périphériques réseau. Cacti, MRTG, Zabbix, Munin et ainsi de suite ... Bien sûr, ces outils sont des outils très utiles pour vérifier l'état du réseau s'ils sont bien utilisés. En fait, cela devrait être la norme dans divers sites d'exploitation. Cependant, lorsque je l'utilise dans le site d'exploitation réel, je veux une autre fonction, j'aimerais pouvoir voir cela aussi ... Je pense qu'il existe de nombreux phénomènes de ce type. Les sites d'exploitation du réseau ne sont pas tous en même temps et chaque site d'exploitation doit avoir des éléments différents que vous souhaitez vérifier en un coup d'œil. Surtout lors de la vérification de l'état par dépannage, ce que vous voyez en premier dépend de ce que vous surveillez.

Cette fois, en utilisant régulièrement ** les outils de surveillance ci-dessus **, j'ai réalisé un tableau de bord qui vous permet de ne voir que les informations que vous souhaitez en cas de problème et pendant le travail ** sur une page du Web **. regarder.

Informations d'acquisition et méthode d'acquisition

Cette fois, ** BGP et [opération AS](https://www.nic.ad.jp/ En supposant qu'un opérateur de réseau effectue ja / basics / terms / as.html) **, déterminez les informations à acquérir. Si vous voulez le faire vous-même, vous pouvez le faire selon les exigences de chaque organisation, mais cette fois je vais réfléchir ci-dessus, ce qui est le plus facile à imaginer. Les éléments à confirmer cette fois sont les suivants.

--Vie et mort de chaque routeur lui-même (surveillance Ping)

Cette fois, créons un tableau de bord qui montre ce qui précède.

Installation

Les principales bibliothèques externes utilisées cette fois sont les suivantes. Python est obtenu à partir de pip, et divers modules d'affichage avant tels que JavaScrip sont obtenus à partir du Web.

Puisque le module Python a require.txt sur Github, vous pouvez également le télécharger en une seule fois comme suit.

cd ./netboard
pip install -r requirements.txt

Si vous souhaitez utiliser à partir de 1, vous avez besoin de la configuration du projet Django, donc Jetez les sorts de création d'un projet Django et de création d'une application de manière fluide, comme indiqué ci-dessous.

% django-admin.py startproject netopboard
% cd netopboard
% python manage.py createsuperuser
(Snip)
% python manage.py migrate
Operations to perform:
  Apply all migrations: admin, auth, contenttypes, sessions
Running migrations:
  Applying contenttypes.0001_initial... OK
  Applying auth.0001_initial... OK
  Applying admin.0001_initial... OK
%python manage.py startapp device_mon

Lorsque vous avez terminé, vérifiez si Django fonctionne

% python manage.py runserver
Performing system checks...

System check identified no issues (0 silenced).
December 05, 2016 - 08:16:56
Django version 1.10.4, using settings 'netopboard.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

Créer un modèle qui gère les informations du routeur

Lorsque vous obtenez des informations d'un appareil, vous avez besoin d'informations d'identification pour accéder au routeur, Dans la plupart des cas, vous aurez besoin de l'adresse IP cible, de la communauté SNMP, du mot de passe de connexion, etc. Cette fois, je définirai les informations dans le modèle de Django afin de pouvoir créer facilement une base de données. La définition du modèle DB de Django n'est pas pour chaque projet, mais pour l'application interne, elle est donc définie sous l'application créée device_mon. Cette fois, étant donné que le comportement doit être modifié en fonction du système d'exploitation de l'appareil, les informations du système d'exploitation de l'appareil sont également incluses.

Si ceux-ci sont définis comme le modèle de Django, ce sera comme suit.

device_mon/models.py


class Device(models.Model):
    hostname = models.CharField('Hostname',max_length=255,unique = True,)
    management_ip = models.GenericIPAddressField('Management IP address',null = True,blank = True,)
    snmp_community = models.CharField('SNMP community',max_length = 255,null = True,blank = True,)
    os = models.CharField('OS',max_length = 255,validators = [AsciiValidator],)
    user = models.CharField('User Name',max_length = 255,null = True,blank = True,)
    password = models.CharField('User Password',max_length = 255,null = True,blank = True,)
    enable_password =  models.CharField('Enable Password',max_length = 255,null = True,blank = True,)
    status = models.PositiveIntegerField('Status',default = 0)

    class Meta:
        verbose_name = 'Device'
        verbose_name_plural = 'Devices'

    def __unicode__(self):
        return self.hostname

Normalement, il est préférable de décider de la règle d'entrée avec Validator, etc., mais cette fois j'omettrai ce point. Après avoir défini le modèle, il est nécessaire de créer réellement un DB, alors construisons un DB comme suit.

% python manage.py makemigrations device_mon
Migrations for 'device_mon':
  device_mon/migrations/0001_initial.py:
    - Create model Device

À ce stade, la fondation est terminée: v:

** Toutes les explications qui suivent ne sont pas expliquées. Certaines pièces sont omises car seuls les points principaux sont grattés. Voir le code Github pour plus de détails **

Créer un écran d'accueil

Commençons par créer un écran d'accueil. Si vous créez une page qui sera la maison de votre tableau de bord, vous aurez une page comme celle-ci! スクリーンショット 2016-12-06 5.15.37.png

Vues et modèle

Tout d'abord, affichez la liste des périphériques réseau et créez une page d'accueil pour vérifier l'état actif et passer à la page détaillée. Puisque je veux afficher les informations du routeur sous forme de liste ici, j'ai créé le HTML à partir de Views.py comme suit. html est une description utilisant le moteur de template de Django.

views.py


from django.shortcuts import render
from device_mon.models import Device

def device_list(request):
    return render(request, 'device_mon/index.html', dict(devices=Device.objects.all().order_by('hostname')))

Dans les vues, tous les objets Device sont acquis et transmis au modèle. Dans le modèle, il le reçoit et dessine du html en fonction de ces informations. Dans le modèle, il est possible de créer une branche en utilisant un autre if pour afficher les informations reçues. C'est un modèle simple qui reçoit les objets Device et dessine autant de colonnes de tableau qu'il y a tout en reflétant le contenu. Si la partie de surveillance active est NG, le bouton est changé par «si» afin de ne pas passer à l'écran d'informations détaillées.

template/index.html


    <table class="table table-bordered table-condensed sortable table-hover" data-sort-key="0" id="bgp_statuses">
      <thead>
      <tr>
        <th>Hostname</th>
        <th>Address</th>
        <th>Access</th>
        <th>Detail</th>
      </tr>
      <tbody>
            {% for device in devices %} 
            <tr>
                <div class="form-group">
                    <td><strong>{{ device.hostname }}</strong></td>
                    <td class="target-data">{{ device.management_ip }}</td>
                    {% if device.status == 1 %}
                    <td><button type="submit" class="btn btn-success btn-xs btn-block " disabled="disabled">OK</button></td>
                    <form class= "form-inline" action="{% url 'device_mon:result' %}" method="post" role="form">
                        <input type="hidden" name="routerinfo_id" value="{{ device.id }}">
                        {% csrf_token %}
                        <td><button type="submit" class="btn btn-primary btn-xs btn-block">Check</button></td>
                    </form>
                    {% else %}
                    <td><button type="submit" class="btn btn-danger btn-xs btn-block" disabled="disabled">NG</button></td>
                    <td><button type="submit" class="btn btn-default btn-xs btn-block" disabled="disabled">Check</button></td>
                    {% endif %}
                </div>
            </tr>
            {% endfor %}
      </tbody>
      </table>

astuces: accès facile à la base de données à l'aide des commandes de gestion

En haut de la page, en plus de la liste des routeurs, la surveillance active de chaque routeur est effectuée. Il s'agit simplement de cingler régulièrement dans les coulisses et de stocker le résultat, mais à ce moment-là, dans la procédure de ping avec un programme complètement externe et de le stocker dans la base de données, la base de données est directement stockée. Vous aurez besoin de faire quelque chose comme l'édition. Cependant, comme vous pouvez le voir à partir de Views.py etc., vous pouvez facilement faire fonctionner l'objet en appelant models depuis l'application Django.

Les [commandes de gestion personnalisées] de Django (https://docs.djangoproject.com/ja/1.10/howto/custom-management-commands/) si vous avez besoin de modifier ou de référencer des objets de l'extérieur plutôt que du Web. Vous pouvez exécuter le programme en tant que commande supplémentaire dans manage.py de l'application Django. Dans ce cas, en exécutant un programme comme devices_alive.py sous / device_mon / management / commands / ʻet puis en exécutant python manage.py devices_alive`, le résultat de la surveillance active peut être exploité comme un modèle de Django. Peut être reflété dans la base de données par

devices_alive.py


#! /usr/bin/env python
# -*- coding: utf-8 -*-
from django.core.management.base import BaseCommand
from device_mon.models import Device
import pyping


class Command(BaseCommand):
    def handle(self, *args, **options):

        devices = Device.objects.all()

        for device in devices:
            response = pyping.ping(device.management_ip, count=1, timeout=1000)
            if response.ret_code == 0:
                device.status = 1
            else:
                device.status = 0

            device.save()

Analyse de l'état BGP / Interface

Pour les informations que vous souhaitez obtenir directement en vous connectant au routeur au lieu de SNMP, utilisez l'attente que vous connaissez. Bien sûr, cette partie peut être remplacée par netconf ou API de divers périphériques réseau. Cependant, comme je veux l'utiliser pour des appareils que netconf etc. ne supporte pas ou ne peut pas être utilisé pour diverses raisons, je vais effectuer une tristesse attendue cette fois. Je ne vais pas le chercher régulièrement, je n'ai qu'à aller le chercher lorsque la confirmation est nécessaire, donc j'essaierai d'en faire une structure que j'irai chercher quand j'appuie sur le bouton Vérifier en haut de Django. Le flux d'appels est le suivant.

  1. HTML POST
  2. Détecté par urls.py et transmis l'opération aux vues cibles
  3. Appelez le script expect dans Views.py
  4. Renvoyez le résultat de Views en HTML et reflétez-le sur le Web

L'exscript, qui est une variante de pexpect, est utilisé pour l'acquisition. L'article suivant a été très utile Essayez de passer du logiciel au routeur avec SSH (Exscript)

Exécutez n'importe quelle commande sur l'écran Web

Comme il existe une limite aux informations qui ne peuvent être saisies que par le portail, il est pratique lorsque vous souhaitez émettre une commande de confirmation sur le routeur pour obtenir des informations plus détaillées. Comme ceci: arrow_down: cmd_response.gif

La commande que vous souhaitez exécuter est envoyée à l'exscript au dos en utilisant urls.py, et le contenu de la réponse est reflété dans la partie modale.

Re-représentation de seulement quelques écrans par Ajax

Étant donné que l'argument pour exécuter des changements en fonction de la commande, cette fois je mets la commande que je veux obtenir dans l'URL.

urls.py


    url(r'^cmd_response/(?P<device_id>\d+)/(?P<cmd>.+)$', views.get_cmd_response, name='cmd_response')

Lorsque device_id est l'identifiant de base de données pour l'identification de périphérique et device_id est la partie de commande que vous voulez réellement saisir et que la valeur est renvoyée, Seule la partie modale est redessinée en Ajax, et le modal est affiché une fois terminé.

python


  var AjaxReload = function(url,target_id) {
          $.ajax({
                 url: url,
                 dataType: 'html',
                 beforeSend: function(){
                    dispLoading("Now Loading...");
                  },
                 success: function(data) {
                     $(target_id).html(data);
                 },
                 error:function() {
                     alert('Reload Error!');
                     removeLoading();
                 },
                 complete : function() { ///Attendez le retour du résultat de l'exécution de la commande avant d'afficher modal
                     removeLoading();
                     if(target_id=="#cmd_exec_result"){
                        $('#commandModal').modal('show')
                     }
                 }
          });
  }

device_mon/views.py



#plain cmd exec
def get_cmd_response(request,device_id,cmd):
    if cmd == 'None':
        cmd_result = 'None'
    else:
        cmd = cmd.replace('_',' ') # replace : show_bgp_su -> show bgp su
        device = Device.objects.get( pk = device_id )
        cmd_result = get_cmd(device,cmd)
    context = {
            'cmd_response'   : cmd_result,
            }
    return render(request,'device_mon/cmd_modal.html',context)

Acquisition en temps réel du trafic, du processeur, de la mémoire

Cela prend la forme d'acquérir SNMP en coulisses et de renvoyer le résultat à l'aide de WebSocket. Pour ici, veuillez vous référer à ce qui suit de NetOps Coding Advent Calender que j'ai écrit l'année dernière.

J'ai essayé de rendre le trafic en temps réel avec WebSocket http://qiita.com/Mabuchin/items/135a9edff34a3db00744

S'il te plait regarde. Le programme côté serveur de Websocket n'a pas été transformé en démon, mais ce n'est pas grave si vous le lancez comme ceci.

cd websock_server
nohup python if_traffic_wss.py &
nohup python process_wss.py &

En complément, il existe de nombreux cas où vous devez utiliser la MIB de chaque fournisseur pour le processeur et la mémoire. L'OID SNMP de IOS-XR et JUNOS utilise les éléments suivants.

python


JUNOS_CPU_USE = '.1.3.6.1.4.1.2636.3.1.13.1.8.9.1.0.0'
JUNOS_MEM_USE = '.1.3.6.1.4.1.2636.3.1.13.1.11.9.1.0.0'
IOSXR_CPU_USE = '.1.3.6.1.4.1.9.9.109.1.1.1.1.7.2'
IOSXR_MEM_USE = '.1.3.6.1.4.1.9.9.221.1.1.1.1.18'
IOSXR_MEM_FREE = '.1.3.6.1.4.1.9.9.221.1.1.1.1.20'

IOS-XR ne peut pas obtenir le taux d'utilisation de la mémoire en une seule fois. Mémoire en cours d'utilisation / (mémoire libre + mémoire en cours d'utilisation) Après l'avoir demandé sous la forme de, je le pousse vers le client de WebSocket.

mem_use = int((float(mem_use) / float(mem_use+mem_free) ) * 100)

finalement

Cela fait longtemps, mais j'ai présenté comment créer votre propre tableau de bord. Récemment, le nombre d'outils de suivi utiles a augmenté, mais il est difficile d'en trouver un qui corresponde parfaitement à votre propre politique opérationnelle. Pour un suivi régulier, je pense que vous devriez les examiner ensemble. Cependant, si vous avez besoin d'un outil qui vous permet de voir toutes les informations dont vous avez besoin pour vérifier immédiatement, comme lors d'une maintenance ou d'une panne, je pense que ce serait une bonne idée de créer un portail qui correspond à la politique d'exploitation comme celle-ci. Je vais.

Résumé du lien de référence

Netboard (tableau de bord créé cette fois) Introduction à Django (1) J'ai essayé de rendre le trafic en temps réel avec WebSocket Essayez de passer du logiciel au routeur avec SSH (Exscript)

Recommended Posts

Créez un tableau de bord pour les appareils réseau avec Django!
Créer une page d'accueil avec django
Créer un téléchargeur de fichiers avec Django
Créez une API d'intégration sociale pour les applications smartphone avec Django
[Python] Créer un écran pour le code d'état HTTP 403/404/500 avec Django
Créez un modèle pour votre planning Django
Créer un planning Django
Créer un LINE BOT avec Minette pour Python
Créez une application Hello World avec un seul fichier avec django
Créer une application Todo avec Django REST Framework + Angular
Essayez de créer une application Todo avec le framework Django REST
environnement en ligne de serveur de code (2) Créer un réseau virtuel avec Boto3
Créer une application Todo avec Django ③ Créer une page de liste de tâches
Créer une couche pour AWS Lambda Python dans Docker
Créer une application Todo avec Django ⑤ Créer une fonction d'édition de tâches
Créer un environnement django avec docker-compose (MariaDB + Nginx + uWSGI)
Construire un environnement Django pour Win10 (avec espace virtuel)
Créer une API avec Django
Créer un écran de connexion Django
Créer un répertoire avec python
[Memo] Construire un environnement de développement pour Django + Nuxt.js avec Docker
Recommandation de django, wagtail ~ Pourquoi développer un site web avec python ~
Créer un compte enfant de connect with Stripe en Python
[Django] Créez un modèle adapté au numéro de téléphone / code postal
Créez un Twitter BOT avec le SDK GoogleAppEngine pour Python
Créez une API Web capable de fournir des images avec Django
Créer une application Todo avec Django ① Créer un environnement avec Docker
(Pour les débutants) Essayez de créer une API Web simple avec Django
Étapes pour créer un projet Django
Déployer l'application Django avec Docker
Créez un environnement virtuel avec Python!
Ecrire un réseau résiduel avec TFLearn
Créer une application Web avec Django
Créer un filtre avec un modèle django
Commandes lors de la création de SNS avec Django
Créez un stepper de poisson avec numpy.random
Créer un bot LINE avec Django
Créer un environnement d'exécution Windows Python avec VScode + Remote WSL
Créez un fichier temporaire avec django sous forme de zip et renvoyez-le
Créez une illusion rayée avec correction gamma pour Python3 et openCV3
Pratique de développement d'applications Web: Créez une page de création d'équipe avec Django! (Page de création de décalage)
Créez un sélecteur de couleurs pour la roue chromatique avec Python + Qt (PySide)
Créer un environnement pour Django x Apache x mod_wsgi avec Vagrant (Ubuntu 16.04)
J'ai créé un environnement de développement pour Django 3.0 avec Docker, Docker-compose, Poetry
Créer une API REST pour faire fonctionner dynamodb avec le Framework Django REST
Créer un Ubuntu de démarrage USB avec un environnement Python pour l'analyse des données
Créer et renvoyer un fichier CSV CP932 pour Excel avec Chalice
[DynamoDB] [Docker] Créer un environnement de développement pour DynamoDB et Django avec docker-compose
Programmation pour les humains avec un __repr__ bien défini
Composez avec un réseau neuronal! Run Magenta
Créer un décorateur de fonction Python avec Class
Créer une API RESTful avec Django Rest Framework
Lecteur RSS simple réalisé avec Django
Créez une image factice avec Python + PIL.
Créons un environnement virtuel pour Python
[Python] Créez un environnement virtuel avec Anaconda
Créons un groupe gratuit avec Python