[PYTHON] 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)
** 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)
- État de l'interface
- État du voisin BGP
- Informations sur le journal de l'appareil
- Flux de trafic en temps réel d'un port spécifique
- Transition en temps réel du processeur / mémoire --Confirmation avec commande arbitraire selon la situation
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.
- Python(2.7.9)
- Django(1.10.4)
- Exscript(2.1.503)
- tornado(4.4.2)
- Javascript
- jQuery
- highchart
- quicksearch
- Bootstrap3
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.
- Même lorsque vous utilisez un référentiel cloné, exécutez autre chose que «démarrer le projet» et «démarrer l'application».
% 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.
- nom d'hôte --Adresse IP
- SNMP Community --Nom d'utilisateur connexion
- Mot de passe
- Statut du routeur (accessible)
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!
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.
- HTML POST
- Détecté par urls.py et transmis l'opération aux vues cibles
- Appelez le script expect dans Views.py
- 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:
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