WikiMiNET

La documentation technique et administrative

Outils pour utilisateurs

Outils du site


wiki:monitoring:userparameters

Personnalisation Du monitoring à MiNET

Apache

Nous allons accéder à la page de status du serveur apache. Pour celà :

  • Créez un Virtual Host monitoring :
<Location /server-status>
    SetHandler server-status
    Allow from 127.0.0.1
    Order deny,allow
    Deny from all
</Location>

Les données sont accessibles à cette URL : http://127.0.0.1/server-status

Les user parameter ne font que selectionner les données intéressantes :

UserParameter=apache_custom_stat[*],curl http://127.0.0.1/server-status 2>/dev/null | head -n $1 | tail -n 1 | awk '{print $ $2}'

NGinx

Les concept est à peu près le même sur NGinx. Créez un Virtual Host monitoring avec :

server {
    listen 10061;
    location /nginx_status {
        stub_status on;
        access_log off;
        allow 127.0.0.1;
        deny all;
    }
}

Puis le tout est accessible à cet URL : http://127.0.0.1:10061/nginx_status

Ici aussi le Userparameter ne sert qu'à sélectionner les info qui nous intéressent :

UserParameter=nginx[*],curl http://127.0.0.1:10061/nginx_status | head -n $1 | tail -n 1 | awk '{print $ $2}'

MySQL

Commencez par créer un utilisateur monitoring avec les droits qui vous semblent approprié (pas ceux d'administration).

Les valeurs sont obtenue par mysqladmin.

Voici le Userparameter :

UserParameter=mysql[*],cat /etc/zabbix/sql.stat| head -n $1 | tail -n 1 | awk '{print $ $2}'

Postgre SQL

On peu obtenir directement les informations depuis le client en ligne de commande : psql

Voici les Userparameters :

UserParameter=psql.version,psql --version|head -n1
UserParameter=psql.server_processes,psql -t -c "select sum(numbackends) from pg_stat_database"
UserParameter=psql.tx_commited,psql -t -c "select sum(xact_commit) from pg_stat_database"
UserParameter=psql.tx_rolledback,psql -t -c "select sum(xact_rollback) from pg_stat_database"
UserParameter=psql.db_size[*],psql -t -c "select pg_database_size('$1')"
UserParameter=psql.db_connections[*],psql -t -c "select numbackends from pg_stat_database where datname = '$1'"
UserParameter=psql.db_returned[*],psql -t -c "select tup_returned from pg_stat_database where datname = '$1'"
UserParameter=psql.db_fetched[*],psql -t -c "select tup_fetched from pg_stat_database where datname = '$1'"
UserParameter=psql.db_inserted[*],psql -t -c "select tup_inserted from pg_stat_database where datname = '$1'"
UserParameter=psql.db_updated[*],psql -t -c "select tup_updated from pg_stat_database where datname = '$1'"
UserParameter=psql.db_deleted[*],psql -t -c "select tup_deleted from pg_stat_database where datname = '$1'"

NMap

Le concept est, depuis une machine dédiée, de scanner une fois par jour le réseau MiNET, et de raller si des ports SSH sont ouvert depuis les machines de Prod vers un autre VLAN.

Pensez à ajouter les machines dans le 102 qui ont aussi une IP de développement.

Un cron éxécute donc nmap depuis l'utilisateur nmap

 su -c "crontab -l" nmap 

il serait bon de passer ce script en full awk :

#!/bin/bash
 
# Romain Cherré (varens) 2017
# varens@minet.net
# Inspired by the precedent from 
# Ignacio Tamayo (localhost) 2016 
# tamayo_j@minet.net
 
 
#Script pour sniffer les ports SSH et TELNET sur plusieurs vlans 
#Several files are written with the number or SSH/Telnet server found. Then the Zabbix agent monitores these files and raises alerts
#The files _detail.txt are used to identify which host has the ports opened
 
#Check the wiki.minet.net
 
SCRIPTPATH=$(cd -P $(dirname $0); pwd -P)
 
 
#### Usage ####:
##
### Add ranges, ... ###
# Add port : add port in ports variable and add it behind the list of addresses and range on which you want to test that port
# Add vlan : add vlan number VLAN array index and add to it ranges and addresses then ports you want to scan
# VLAN syntax : VLAN[<id_vlan>]="<address|range>{1,n} <ports>{1,n} <address|range>{0,n} <ports>{1,n} ..." 
#
#
# Ex VLAN[103]="192.168.103.0/24 23 192.168.103.15 192.168.103.21 192.168.103.18 192.168.103.80 22" will scan 192.168.103.0/24 on port 23 and 192.168.103.15 ... 192.168.103.82 on port 22
# and VLAN[2]="157.159.40.0/25 22 23" will scan in vlan 2 on range 157.159.40.0/25 the ports 22 and 23
 
### Reports ###
#
# The full nmap report for vlan VLAN_ID is found under VLAN_ID_full.txt
# The number of host with open port corresponding to protocol P in the vlan VLAN_ID is found in P_VLAN_ID.txt
# The addresses of host with an open port corresponding to protocol P in vlan VLAN_ID is found in P_VLAN_ID_detail.txt
 
 
 
ports=(22 23)
subnets=(2 3 14 102 103)
VLAN[2]="157.159.40.0/25 22 23"
VLAN[3]="157.159.40.128/26 23"
VLAN[14]="192.168.14.0/24 23"
VLAN[102]="192.168.102.0/24 23" 
VLAN[103]="192.168.103.0/24 23 192.168.103.15 192.168.103.21 192.168.103.18 192.168.103.80 22"
 
 
for i in ${subnets[@]}; do
	rm "$i""_full.txt"
	echo ${VLAN[$i]} | awk '{k=1;
				while($k!=""){
					addr=""
					portList=""
					while($k~/[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+/){
						addr=addr $k " ";
						k++;
					}
					while($k!="" && $k!~/[0-9]+\./){
						portList=portList $k ",";
						k++;
					}
					system("nmap -sT -PN -p" portList " --append-output -oG " '$SCRIPTPATH/$i'"_full.txt " addr);
			       	}
		      		}'
 	for j in ${ports[@]};do
		proto=$(awk '{j=5;while($j!=""){if($j~/'$j'\//){split($j, a ,/\//)}j++}}END{print a[5]}' "$SCRIPTPATH$i""_full.txt" )
		if [ -n "$proto" ]; then
			awk '{j=5;while($j!=""){if($j~/'$j'\/open/){print $2};j++}}' "$SCRIPTPATH$i""_full.txt" > "$SCRIPTPATH$proto""_$i""_detail.txt"
			cat "$SCRIPTPATH$proto""_$i""_detail.txt" | wc -l > "$SCRIPTPATH$proto""_$i"".txt"
		fi
	done
done

Avec zabbix, on ne fait que lire la valeur de ces fichiers. Editez

/etc/zabbix/zabbix_agentd.conf
UserParameter=nmap[*],cat $1

Et mettez sur les Triggers Zabbix du host *nmap* un check pour ces items ci

Firewall

Nous utilisons netstat -s pour obtenir les stats du firewall.

Par ailleurs nous lisons aussi les fichiers indiquant les stats sur la conntrack. Nous comptons aussi le nombre de sockets.

Voici les Userparameters :

UserParameter=netstat[*],netstat -s | head -n $1 | tail -n 1 | awk '{print $ $2}'
UserParameter=socket,netstat -an | grep "tcp\ \|udp\ \|udp6\|tcp6" | wc -l
UserParameter=conntrack,cat /proc/sys/net/ipv4/netfilter/ip_conntrack_count
UserParameter=conntrack_capacity,cat /proc/sys/net/ipv4/netfilter/ip_conntrack_max

ZFS

Le contenu de cette page a été utilisé.

Voici les user parameters correspondant :

UserParameter=zstat[*],/etc/zabbix/zstat.sh $1 $2
UserParameter=arc[*],/etc/zabbix/arcstat.pl -f arcsz | tail -n 1 | awk '{print $ $1}' | cut -d "G" -f 1
UserParameter=l2arc[*],/etc/zabbix/arcstat.pl -f l2size | tail -n 1 | awk '{print $ $1}'| cut -d "G" -f 1
UserParameter=memory_rep[*],echo ::memstat | sudo mdb -k | grep $1 | awk '{print $ $2}' | cut -d "%" -f 1
UserParameter=zpoolstatus[*],zpool status | grep $1 | wc -l
UserParameter=diskperf[*],iostat -xtc | grep $1 | awk '{print $ $2}'
UserParameter=raidZfreespac[*],sudo /etc/zabbix/free_space.sh
UserParameter=nfs.nfstat[*],nfsstat -s -v 3| head -n $1 | tail -n 1 |  awk '{print $ $2}'
UserParameter=nbsocket,netstat -an | wc -l
UserParameter=archit[*],/etc/zabbix/arcstat.pl -f read,hits,miss,hit%,l2read,l2hits,l2miss,l2hit%,arcsz,l2size 1 2 | tail -n 1 | awk '{print $ $1}'
UserParameter=last_snap_date[*],zfs list -t snapshot | grep '$1/$2@' | tail -n 1 | cut -d "@" -f 2 | cut -d " " -f 1 | cut -c7-12

Avec le fichier zstat.sh:

#!/bin/sh
 
case "$2" in
        operations_read)
                 zpool iostat $1 | tail -n 1 | awk '{print $4}'
                 ;;
        operations_write)
                 zpool iostat $1 | tail -n 1 | awk '{print $5}'
                 ;;
        bandwidth_read)
                 zpool iostat $1 | tail -n 1 | awk '{print $6}' | cut -d "K" -f 1
                 ;;
        bandwidth_write)
                 zpool iostat $1 | tail -n 1 | awk '{print $7}' | cut -d "K" -f 1
                 ;;
        latency_read)
#                 zpool iostat $1 | tail -n 1 | awk '{print $8}'
                 iostat | tail -n 1 | awk '{print $5}'
                 ;;
        latency_write)
                 zpool iostat $1 | tail -n 1 | awk '{print $8}'
                 ;;
        *)
                exit 1
                ;;
 
esac
 
exit 0

De plus, voici les modifications à faire dans /etc/sudoers:

Cmnd_Alias ZABBIX_PROGRAMMS = /root/arcstat.pl, /usr/bin/mdb, /usr/bin/bc, /sbin/zfs, /usr/sbin/zfs, /usr/sbin/swap, /bin/cat, /etc/zabbix/free_space.sh
 
zabbix ALL=(ALL) NOPASSWD: ZABBIX_PROGRAMMS

Machines physiques

Cette page présente comment installer les outils dont nous allons nous servir.

Pour ce qui est du monitoring NFS, nous utilisons nfsstat -c.

Par ailleurs nous comptons le nombre de socket retournés par netstat -an

Voici les Userparameters :

UserParameter=sensors.temp.ambient,sudo ipmitool sdr type 'Temperature' |grep Ambient |grep 7.1 |sed -e 's/.*7.1 | \([0-9]\+\).*/\1/'
UserParameter=sensors.temp.ram[*],sensors | grep DIMM | tail -n 1 | cut -d '+' -f 2 | awk 'split($ \$1,x,\"°\") { print x[1] }'
UserParameter=nfsstat[*],nfsstat -c | head -n \$1 | tail -n 1 |  awk '{print $ \$2}'
UserParameter=ioping[*],sudo ioping -c 200 \$1 -i 0.001 | tail -n 1 | cut -d \"=\" -f 2 | cut -d \"/\" -f 3
UserParameter=nbsocket,netstat -an | wc -l

TV

Nous utilisons un script qui compte le nombre de processus de mumudvb, et qui relance les tunners qui sont éteint. Rien de bien plus compliqué.

Le script se trouve ici : /etc/zabbix/up_tunner.sh et appartient à root.

wiki/monitoring/userparameters.txt · Dernière modification: 2018/06/14 11:56 par simtrami