Archives pour la catégorie Unix

[Supervision] Script pour superviser la mémoire des Linux

Bonjour à tous,

Aujourd’hui je vous propose un script en Perl que j’ai fait afin de superviser la mémoire utilisée réellement sur un serveur Linux (ce script peut aussi bien être utilisé pour superviser des serveurs Debian, Ubuntu, RedHat, CentOS, etc.).

Pourquoi j’ai fait mon propre script? Tout simplement parce que lorsqu’on lance par exemple la commande « top », nous avons la mémoire globale « utilisée » (résultat de la plupart des scripts que j’ai pu trouvé). Cela veut dire qu’il compte aussi bien la mémoire utilisée pour les programmes, pour les buffers mais aussi pour le cache. Ces deux dernières peuvent être libérées si jamais l’OS ou une application en a vraiment besoin.

Vous allez voir, il est tout simple et créé une sortie pour le grapher sur Nagios/Centreon.

#! /usr/bin/perl -w

############################## check_snmp_memory_linux ##############
# Version : 1.0
# Date : Dec 04 2011
#####################################################################
#
# Help : ./check_snmp_memory_linux.pl -h
#

use strict;
use Net::SNMP;
use Getopt::Long;
use POSIX;

# SNMP Datas

my $memory_Total        = ".1.3.6.1.4.1.2021.4.5.0";
my $memory_Free         = ".1.3.6.1.4.1.2021.4.6.0";
my $memory_Buffered     = ".1.3.6.1.4.1.2021.4.14.0";
my $memory_Cached       = ".1.3.6.1.4.1.2021.4.15.0";

# Globals

my $version='1.0';

my $o_host      = undef;        # hostname
my $o_community = undef;        # community
my $o_port      = 161;          # port
my $o_help      = undef;        # wan't some help ?
my $o_version   = undef;        # print version
my $o_version2  = undef;        # use snmp v2c

my %ERRORS=('OK'=>0,'WARNING'=>1,'CRITICAL'=>2,'UNKNOWN'=>3,'DEPENDENT'=>4);

# Variable pour les valeurs de Mem

my $memUsed     = undef;
my $memFree     = undef;
my $memBuffered = undef;
my $memCached   = undef;
my $memTotal    = undef;
my $percentMem  = undef;

my $memUsedOctets = undef;
my $memUsedGOctets = undef;
my $memFreeOctets = undef;
my $memCachedOctets = undef;
my $memBufferedOctets = undef;
my $memTotalOctets = undef;
my $memTotalGOctets = undef;

my $resultat    = undef;
my $c_output    = undef;
my $c_status    = undef;

my $warn_value  = 95;
my $crit_value  = 98;

# Functions

sub p_version {
        print "check_snmp_memory_linux version : $version\n";
}

sub print_usage {
        print "Usage: $0 -H <host> -C <snmp_community> [-2] [-p <port>]\n\n";
}

sub help {
   print "\nSNMP Memory Linux Monitor for Nagios version ",$version,"\n";
   print_usage();
   print <<EOT;
-h, --help
        print this help message
-H, --hostname=HOST
        name or IP address of host to check
-C, --community=COMMUNITY NAME
        community name for the host's SNMP agent (implies SNMP v1 or v2c with option)
-2, --v2c
        Use snmp v2c
-P, --port=PORT
        SNMP port (Default 161)
-V, --version
        prints version number
EOT

}

sub check_options {
        Getopt::Long::Configure ("bundling");

        GetOptions(
                'h'     => \$o_help,            'help'          => \$o_help,
                'H:s'   => \$o_host,            'hostname:s'    => \$o_host,
                'p:i'   => \$o_port,            'port:i'        => \$o_port,
                'C:s'   => \$o_community,       'community:s'   => \$o_community,
                'V'     => \$o_version,         'version'       => \$o_version,
                '2'     => \$o_version2,        'v2c'           => \$o_version2
        );
        if ( defined ($o_help) ) {
                help();
                exit $ERRORS{"UNKNOWN"};
        };

        if ( defined($o_version) ) {
                p_version();
                exit $ERRORS{"UNKNOWN"};
        };

        if ( ! defined($o_host) ) { # check host and filter
                print "No host defined!\n";
                print_usage();
                exit $ERRORS{"UNKNOWN"};
        };

        # Check Snmp Information
        if ( ! defined($o_community) ) {
                print "No community defined!\n";
                print_usage();
                exit $ERRORS{"UNKNOWN"};
        }
}

########## MAIN #######

check_options();

# Connection to host
my ($session,$error);
if ( defined ($o_version2) ) {
        # SNMPv2 Login
        ($session, $error) = Net::SNMP->session(
                -hostname  => $o_host,
                -version   => 2,
                -community => $o_community,
                -port      => $o_port
        );
} else {
        # SNMPV1 login
        ($session, $error) = Net::SNMP->session(
                -hostname  => $o_host,
                -community => $o_community,
                -port      => $o_port
        );
}
if ( !defined($session) ) {
        printf("ERROR opening session: %s.\n", $error);
        exit $ERRORS{"UNKNOWN"};
}


$resultat       = $session->get_request($memory_Total);
$memTotal       = $resultat->{$memory_Total};

$resultat       = $session->get_request($memory_Free);
$memFree        = $resultat->{$memory_Free};

$resultat       = $session->get_request($memory_Buffered);
$memBuffered    = $resultat->{$memory_Buffered};

$resultat       = $session->get_request($memory_Cached);
$memCached      = $resultat->{$memory_Cached};

$memUsed = $memTotal - ( $memFree + $memBuffered + $memCached );

$memUsedOctets = $memUsed * 1024;
$memUsedGOctets = $memUsed / 1048576;
$memUsedGOctets = sprintf("%.2f", $memUsedGOctets);
$memTotalOctets = $memTotal * 1024;
$memTotalGOctets = $memTotal / 1048576;
$memTotalGOctets = sprintf("%.2f", $memTotalGOctets);
$memCachedOctets = $memCached * 1024;
$memBufferedOctets = $memBuffered * 1024;
$memFreeOctets = $memFree * 1024;
$percentMem = floor(( $memUsed / $memTotal ) * 100);

if ( $percentMem < $warn_value ) {
        $c_output       = "OK - La memoire est utilisee a ".$percentMem."%. Il y a ".$memUsedGOctets." Go d'utilisee sur ".$memTotalGOctets." Go. | Mem_Totale=".$
memTotalOctets."o; Mem_Used=".$memUsedOctets."o; Mem_Buffered=".$memBufferedOctets."o; Mem_Cached=".$memCachedOctets."o; Mem_Free=".$memFreeOctets."o";        $c_status       = "OK";
}
elsif ( ($percentMem >= $warn_value) && ($percentMem < $crit_value) ) {
        $c_output       = "WARNING - La memoire est utilisee a ".$percentMem."%. Il y a ".$memUsedGOctets." Go d'utilisee sur ".$memTotalGOctets." Go. | Mem_Total
e="
.$memTotalOctets."o; Mem_Used=".$memUsedOctets."o; Mem_Buffered=".$memBufferedOctets."o; Mem_Cached=".$memCachedOctets."o; Mem_Free=".$memFreeOctets."o";        $c_status       = "WARNING";
}
elsif ( $percentMem >= $crit_value ) {
        $c_output       = "CRITICAL - La memoire est utilisee a ".$percentMem."%. Il y a ".$memUsedGOctets." Go d'utilisee sur ".$memTotalGOctets." Go. | Mem_Tota
le="
.$memTotalOctets."o; Mem_Used=".$memUsedOctets."o; Mem_Buffered=".$memBufferedOctets."o; Mem_Cached=".$memCachedOctets."o; Mem_Free=".$memFreeOctets."o";
        $c_status       = "CRITICAL";
}

$session->close;
print "$c_output \n";
exit $ERRORS{$c_status};

Ce script permet de récupérer les mêmes valeurs que la commande suivante :

$ free -m

1 Star2 Stars3 Stars4 Stars5 Stars (No Ratings Yet)
Loading...

Astuces en vrac (4)

Aujourd’hui, un nouveau petit mémo concernant 2 requêtes SQL pour récupérer des informations intéressantes sur votre supervision. Et un autre pour contrôler la synchronisation de votre serveur de temps.

La première requête permet de récupérer l’adresse IP/Nom DNS et le nom de tous les serveurs supervisés par un poller. Pour cela, il suffit juste d’exécuter la requête suivante sur la base Centreon :

SELECT host_name AS Name, host_address AS Adresse
FROM `host`, `ns_host_relation`, `nagios_server`
WHERE ns_host_relation.host_host_id=host.host_id
AND ns_host_relation.nagios_server_id=nagios_server.id
AND nagios_server.name='mypoller'
ORDER BY host_name;

Continuer la lecture de Astuces en vrac (4) 

Interdire l’accès à Phpmyadmin depuis l’extérieur

Aujourd’hui, un petit mémo rapide pour configurer Phpmyadmin en interdisant son accès depuis l’extérieur ou depuis tout autre réseau que celui de votre LAN

Pour cela, il suffit juste de modifier le fichier /etc/apache2/conf.d/phpmyadmin.conf par les lignes 4, 5 et 6 :

<Directory /usr/share/phpmyadmin>
        Options FollowSymLinks
        DirectoryIndex index.php
        Order Deny,Allow
        Allow from 192.168.1.0/24
        Deny from All

        <IfModule mod_php5.c>
                AddType application/x-httpd-php .php

                php_flag magic_quotes_gpc Off
                php_flag track_vars On
                php_flag register_globals Off
                php_admin_flag allow_url_fopen Off
                php_value include_path .
                php_admin_value upload_tmp_dir /var/lib/phpmyadmin/tmp
                php_admin_value open_basedir /usr/share/phpmyadmin/:/etc/phpmyadmin/:/var/lib/phpmyadmin/
        </IfModule>

</Directory>

Cela signifie qu’on interdit tout autre personne que ceux du réseau local 192.168.1.0/24 à accéder à la page Phpmyadmin.

1 Star2 Stars3 Stars4 Stars5 Stars (3 votes, average: 3,67 out of 5)
Loading...

[HowTo] Installation d’un serveur DLNA sous Ubuntu Server avec Ushare

Bonjour à tous,

Aujourd’hui, je vais présenter l’installation d’un serveur DLNA sous Ubuntu Server (également disponible sous Debian bien sûr). Un serveur DLNA permet de partager du contenu numérique (intéressant pour le décodeur TV de votre Box Internet par exemple)

Installation du serveur :

$ apt-get install ushare

Continuer la lecture de [HowTo] Installation d’un serveur DLNA sous Ubuntu Server avec Ushare 

[HowTo] Surveillance de ses disques avec S.M.A.R.T.

Bonjour à tous,

Aujourd’hui, nous allons nous intéresser à la surveillance de nos précieux disques durs. Ils sont de plus en plus importants car ils contiennent un tas d’informations « vitales » : photos, videos, musiques, papiers, etc. Ca pourrait être sympa si nous pouvions connaitre l’état de santé de nos disques et être prévenu quand ils commencent à ne plus tourner rond 🙂

Pour surveiller cela, nous allons utiliser le démon S.M.A.R.T. Il faut installer :

$ apt-get install smartmontools

Continuer la lecture de [HowTo] Surveillance de ses disques avec S.M.A.R.T. 

[HowTo] Installation d’un serveur NFS

Aujourd’hui, nous allons nous intéresser à la mise en place d’un partage NFS sur un serveur sous Ubuntu Server.

Dans un premier temps, il faut installer les paquets nécessaires sur le serveur :

$ apt-get install nfs-kernel-server nfs-common

Les partages se configurent ensuite dans le fichier /etc/exports :

/data/Multimedia 192.168.1.0/24(rw,sync,insecure,no_subtree_check,all_squash,no_root_squash,anonuid=1000,anongid=1000)
/data/Soft 192.168.1.0/24(rw,sync,insecure,no_subtree_check,all_squash,no_root_squash,anonuid=1000,anongid=1000)
/data/Images 192.168.1.0/24(rw,sync,insecure,no_subtree_check,all_squash,no_root_squash,anonuid=1000,anongid=1000)
/data/Papiers 192.168.1.0/24(rw,sync,insecure,no_subtree_check,all_squash,no_root_squash,anonuid=1000,anongid=1000)
/data/Wii 192.168.1.0/24(rw,sync,insecure,no_subtree_check,all_squash,no_root_squash,anonuid=1000,anongid=1000)
/data/Files 192.168.1.0/24(rw,sync,insecure,no_subtree_check,all_squash,no_root_squash,anonuid=1000,anongid=1000)

L’explication des options :
Continuer la lecture de [HowTo] Installation d’un serveur NFS 

[Apache2] : Astuces pour la sécurisation de votre serveur web

Bonjour,

Un petit billet pour vous donner en vrac quelques astuces afin de sécuriser un minimum votre serveur web.

Dans un premier temps, nous allons cacher quelques informations de version, d’OS, etc. afin que l’on ne puisse pas savoir du premier coup d’oeil, quelle version d’Apache tourne sur notre serveur. Pour cela, éditer le fichier /etc/apache2/conf.d/security sous Ubuntu ou /etc/apache2/apache2.conf sous Debian afin d’y ajouter les 2 directives suivantes :

ServerTokens Prod
ServerSignature Off

Le premier permet de ne pas renvoyer d’informations dans l’entête HTTP, tandis que l’autre évite de renvoyer des infos lors d’une erreur (403, 404, etc.).

Si vous avez installer le module PHP, il peut être intéressant de désactiver ses informations en éditant le fichier /etc/php5/apache2/php.ini et y ajouter/éditer les informations suivantes :

expose_php = Off
display_errors = Off

Une fois ces manipulations effectuées, redémarrer le service :

$ /etc/init.d/apache2 restart

D’autres pistes permettant de sécuriser votre installation pourrait être de limiter le parcours du répertoire, d’autoriser certains dossiers à certaines personnes, d’interdire l’exécution de scripts CGI, etc. Tout ceci est à effectuer dans le fichier de configuration de votre site web, généralement : /etc/apache2/sites-available/monsite.

Ce fut une présentation brève mais permettant de cacher certaines informations importantes (surtout la version d’Apache2)…

1 Star2 Stars3 Stars4 Stars5 Stars (1 votes, average: 5,00 out of 5)
Loading...

Script pour téléchargement sur Megaupload

Bonjour à tous,

Aujourd’hui je vais vous présenter un script assez sympathique qui permet de télécharger sans soucis et sans limite sur le site Megaupload.

J’ai trouvé cette astuce sur le site [Ubuntudz.com] et ensuite je l’ai amélioré pour l’adapter à ma sauce. Voici le code

#!/bin/bash

# Variables
dirDest="/data/Multimedia/torrents/complete"
fileDl="/root/.list"
destMail="contact@domain.tld"

# Main
while read line  
do
        # On recupere les 4 premiers caracteres de chaque ligne pour savoir si c'est une audresse http ou non
        beginningText=`expr substr "$line" 1 4`

        echo $line
        # Test pour obtenir le nom du fichier en cours de recuperation s'il a ete mentionne
        if [[ "$beginningText" == "http" ]] ; then
                url=`wget -qO- $line | grep -P "id=\"downloadlink\"" | grep -oP "(((http)\://){1}\S+)" | grep "megaupload.com\/files" | tr -d "\""`
                sleep 46
                wget -c $url -P $dirDest
                sed -i '1 d' $fileDl
        else
                titleDl="$line"
                sed -i '1 d' $fileDl
        fi
done < $fileDl

echo "Le téléchargement de $titleDl est terminé" | mail -s "[SUCCESS] : $titleDl" $destMail

Il faut ensuite creer le fichier qui contiendra les liens vers le site de megaupload « /root/.list » :

$ touch /root/.list

Puis, y copiez les informations suivantes :

Gladiator (--> représentant ici le nom de votre film)
http://www.megaupload.com/AABBCCDD
http://www.megaupload.com/EEFFGGHH

Vous n’avez plus qu’à lancer le script que nous avons appelé « megaupload.sh » et c’est parti pour le téléchargement. Pas mal non ?

Une fois le téléchargement terminé, un mail sera envoyé à votre adresse mail (si votre messagerie est configurée bien sûr).

1 Star2 Stars3 Stars4 Stars5 Stars (No Ratings Yet)
Loading...