Le script Shell implémente la surveillance des ressources du système et des processus Linux_Connaissances de base

Dans le processus d'exploitation et de maintenance du serveur, il est souvent nécessaire de surveiller diverses ressources du serveur, telles que : la surveillance de la charge du processeur, la surveillance de l'utilisation du disque, la surveillance du numéro de processus, etc., afin d'alarmer et de notifier rapidement quand une anomalie se produit dans le système Administrateur. Cet article présente plusieurs exigences de surveillance courantes et l'écriture de scripts shell sous les systèmes Linux.

Répertoire des articles :

1.Linux utilise Shell pour vérifier si le processus existe
2.Linux utilise Shell pour détecter l'utilisation du processeur du processus
3.Linux utilise Shell pour détecter l'utilisation de la mémoire des processus
4.Linux utilise Shell pour détecter l'utilisation du handle de processus
5.Linux utilise Shell pour vérifier si un port TCP ou UDP écoute
6.Linux utilise Shell pour vérifier le nombre de processus en cours d'exécution d'un certain nom de processus
7.Linux utilise Shell pour détecter la charge du processeur du système
8.Linux utilise Shell pour détecter l'espace disque du système
9. Résumé

Vérifiez si le processus existe

Lors de la surveillance d'un processus, nous avons généralement besoin d'obtenir l'ID du processus. L'ID du processus est l'identifiant unique du processus. Cependant, il peut parfois y avoir plusieurs processus avec le même nom de processus exécutés sous différents utilisateurs sur le serveur. . La fonction suivante GetPID Elle donne la fonction d'obtenir l'ID de processus du nom de processus spécifié sous l'utilisateur spécifié (actuellement, on considère uniquement le démarrage d'un processus avec ce nom de processus sous cet utilisateur. Elle a deux paramètres : le nom d'utilisateur et le nom de processus). Il utilise d'abord ps pour trouver les informations sur le processus, et en même temps utilise grep pour filtrer le processus requis, et enfin utilise sed et awk pour trouver la valeur ID du processus requis (cette fonction peut être modifiée en fonction de la situation réelle , par exemple si d'autres informations doivent être filtrées, etc.).

Liste 1. Surveiller le processus

Copier le code Le code est le suivant :

fonction GetPID #User #Name
{
PsUser=$1
PsName=2$
pid=`ps -u $PsUser|grep $PsName|grep -v grep|grep -v vi|grep -v dbxn
|grep -v tail|grep -v start|grep -v stop |sed -n 1p |awk '{print $1}'`
echo $pid
>

Exemple de démo :

1) Programme source (par exemple, recherchez l'ID du processus où l'utilisateur est root et le nom du processus est CFTestApp)

Copier le code Le code est le suivant :

PID=`GetPID racine CFTestApp`

écho $PID

2) Sortie du résultat

Copier le code Le code est le suivant :

11426
[coque dyu@xilinuxbldsrv]$

3) Analyse des résultats

Comme le montre la sortie ci-dessus : 11426 est l'ID de processus du programme CFTestApp sous l'utilisateur root.

4) Introduction aux commandes

1. ps : affichez les informations instantanées sur le processus dans le système. Paramètres : -u Répertorie l'état des programmes appartenant à cet utilisateur, qui peut également être spécifié à l'aide du nom d'utilisateur. -p spécifie l'identifiant du processus et répertorie l'état du processus. -o spécifie le format de sortie 2. grep : utilisé pour rechercher la ligne actuelle dans le fichier qui correspond à la chaîne. Paramètres : -v sélection inversée, c'est-à-dire afficher la ligne sans le contenu de la "chaîne de recherche". 3. sed : Un éditeur de texte non interactif qui édite les fichiers ou les fichiers exportés à partir de l'entrée standard et ne peut traiter qu'une seule ligne de contenu à la fois. Paramètres : -n Lit la ligne d'entrée suivante et utilise la commande suivante pour traiter la nouvelle ligne au lieu de la première commande. p flag imprime les lignes correspondantes 4. awk : un langage de programmation utilisé pour le traitement de texte et de données sous Linux/Unix. Les données peuvent provenir d'une entrée standard, d'un ou plusieurs fichiers ou de la sortie d'autres commandes. Il prend en charge des fonctions avancées telles que les fonctions définies par l'utilisateur et les expressions régulières dynamiques, et constitue un puissant outil de programmation sous Linux/Unix. Il est utilisé depuis la ligne de commande, mais le plus souvent sous forme de script. La façon dont awk traite le texte et les données : il analyse le fichier ligne par ligne, de la première ligne à la dernière ligne, à la recherche de lignes qui correspondent à un modèle spécifique et effectue l'opération souhaitée sur ces lignes. Si aucune action de traitement n'est spécifiée, les lignes correspondantes sont affichées sur la sortie standard (écran). Si aucun mode n'est spécifié, toutes les lignes spécifiées par l'opération sont traitées. Paramètres : -F fs ou –field-separator fs : Spécifiez le séparateur de repli du fichier d'entrée, fs est une chaîne ou une expression régulière, telle que -F :.
Parfois, il est possible que le processus ne démarre pas. La fonction suivante consiste à vérifier si l'ID du processus existe. Si le processus n'est pas en cours d'exécution, le résultat est :
.

Copier le code Le code est le suivant :

Le processus n'existe pas
# Vérifiez si le processus existe
Si [ "-$PID" == "-" ]
Alors
{
echo "Le processus n'existe pas."
}
fi

Détecter l'utilisation du processeur du processus

Lors de la maintenance des services d'application, nous rencontrons souvent des situations où le processeur est trop élevé, provoquant une congestion et une interruption des activités. Un excès de CPU peut être dû à des situations anormales telles qu'une surcharge commerciale ou des boucles sans fin. Le CPU du processus métier est constamment surveillé via des scripts. Le personnel de maintenance peut être averti à temps lorsque l'utilisation du CPU est anormale, ce qui permet au personnel de maintenance d'analyser, de localiser et de détecter. éviter les affaires en temps opportun, les interruptions, etc. La fonction suivante obtient l'utilisation du processeur du processus pour un ID de processus spécifié. Il a un paramètre pour l'ID du processus. Il utilise d'abord ps pour trouver les informations sur le processus, tout en filtrant la ligne %CPU via grep -v, et utilise enfin awk pour trouver la partie entière du pourcentage d'utilisation du processeur (s'il y en a plusieurs). CPU dans le système, l'utilisation du CPU peut être supérieure à 100 %).

Liste 2. Surveillance en temps réel du CPU des processus métier

Copier le code Le code est le suivant :

fonction GetCpu
{
CpuValue=`ps -p $1 -o pcpu |grep -v CPU | awk '{print $1}' | echo $CpuValue
>

La fonction suivante consiste à obtenir l'utilisation du processeur de ce processus via la fonction ci-dessus GetCpu, puis à utiliser des instructions conditionnelles pour déterminer si l'utilisation du processeur dépasse la limite si elle dépasse 80 % (peut être ajustée en fonction de la situation réelle). L'alarme sera émise, sinon des informations normales seront émises.
Liste 3. Déterminez si l'utilisation du processeur dépasse la limite

Copier le code Le code est le suivant :

fonction CheckCpu
{
PID=1$
cpu=`GetCpu $PID`
Si [ $cpu -gt 80 ]
Alors
{
echo "L'utilisation du processeur est supérieure à 80 %"
}
sinon
{
echo "L'utilisation du processeur est normale"
}
fi
>

Exemple de démonstration :

1) Programme source (en supposant que l'ID de processus de CFTestApp a été interrogé ci-dessus comme 11426)

Copier le code Le code est le suivant :

Vérifiez le processeur 11426

2) Sortie du résultat

Copier le code Le code est le suivant :

L'utilisation du processeur est de 75
L'utilisation du processeur est normale
[coque dyu@xilinuxbldsrv]$

3) Analyse des résultats
Comme le montre le résultat ci-dessus : l'utilisation actuelle du processeur du programme CFTestApp est de 75 %, ce qui est normal et ne dépasse pas la limite d'alarme de 80 %.

Détecter l'utilisation de la mémoire du processus

Lors de la maintenance des services d'application, nous rencontrons souvent des situations où le processus plante en raison d'une utilisation excessive de la mémoire, provoquant une interruption de l'activité (par exemple, l'espace mémoire adressable maximum d'un programme 32 bits est de 4G. S'il est dépassé, la mémoire l'application échouera et la mémoire physique est également limitée). Une utilisation excessive de la mémoire peut être due à des fuites de mémoire, à une accumulation de messages, etc. L'utilisation de la mémoire du processus métier est constamment surveillée via des scripts. Des alarmes peuvent être envoyées à temps (par exemple, par SMS) lorsque l'utilisation de la mémoire est anormale, de sorte que. le personnel de maintenance peut le gérer en temps opportun. La fonction suivante obtient l'utilisation de la mémoire du processus pour un ID de processus spécifié. Il a un paramètre pour l'ID du processus, il utilise d'abord ps pour trouver les informations sur le processus, tout en filtrant les lignes VSZ via grep -v, puis obtient l'utilisation de la mémoire en mégaoctets en divisant par 1 000.

Liste 4. Surveiller l'utilisation de la mémoire des processus métier

Copier le code Le code est le suivant :

Fonction GetMem
{
MEMUsage=`ps -o vsz -p $1|grep -v VSZ`
(( MEMUsage /= 1000))
echo $MEMUsage
>

La fonction suivante consiste à obtenir l'utilisation de la mémoire de ce processus via la fonction GetMem ci-dessus, puis à utiliser des instructions conditionnelles pour déterminer si l'utilisation de la mémoire dépasse la limite si elle dépasse 1,6 Go (peut être ajustée en fonction de la situation réelle). une alarme sera émise, sinon des informations normales seront émises.

Listing 5. Déterminer si l'utilisation de la mémoire dépasse la limite

Copier le code Le code est le suivant :

mem=`GetMem $PID`                                                                           si [ $mem -gt 1600 ]
alors
{
echo "L'utilisation de la mémoire est supérieure à 1,6G"
}
sinon
{
echo "L'utilisation de la mémoire est normale"
}
fi

Exemple de démo :

1) Programme source (en supposant que l'ID de processus de CFTestApp a été interrogé ci-dessus comme 11426)

Copier le code Le code est le suivant :

mem=`GetMem 11426`

echo "L'utilisation de la mémoire est $mem M"

Si [ $mem -gt 1600 ]
Alors
{
echo "L'utilisation de la mémoire est supérieure à 1,6 Go"
}
sinon
{
echo "L'utilisation de la mémoire est normale"
}
fi

2) Sortie du résultat

Copier le code Le code est le suivant :

L'utilisation de la mémoire est de 248 M
L'utilisation de la mémoire est normale
[coque dyu@xilinuxbldsrv]$

3) Analyse des résultats

Comme le montre la sortie ci-dessus : l'utilisation actuelle de la mémoire du programme CFTestApp est de 248 Mo, ce qui est normal et ne dépasse pas la limite d'alarme de 1,6 G.

Détecter l'utilisation du gestionnaire de processus

Lors de la maintenance des services applicatifs, nous rencontrons souvent des interruptions d'activité dues à une utilisation excessive des handles. L'utilisation de handles de processus sur chaque plateforme est limitée. Par exemple, sur la plateforme Linux, nous pouvons utiliser la commande ulimit – n (ouvrir les fichiers (-n) 1024) ou afficher le contenu de /etc/security/limits.conf pour obtenir la limite de gestion du processus. Une utilisation excessive du handle peut être due à une charge excessive, à une fuite du handle, etc. L'utilisation du handle du processus métier est constamment surveillée via des scripts. Des alertes peuvent être envoyées à temps lorsque des anomalies se produisent (par exemple, par SMS), afin que le personnel de maintenance puisse le faire. les traiter en temps opportun. La fonction suivante obtient l’utilisation du handle de processus pour un ID de processus spécifié. Il a un paramètre pour l'ID de processus. Il utilise d'abord ls pour afficher les informations de descripteur de processus, puis utilise wc -l pour compter le nombre de descripteurs de sortie.

Copier le code Le code est le suivant :

Fonction GetDes
{
DES=`ls /proc/$1/fd | wc -l`
écho $DES
>

La fonction suivante consiste à obtenir l'utilisation du handle de ce processus via la fonction GetDes ci-dessus, puis à utiliser des instructions conditionnelles pour déterminer si l'utilisation du handle dépasse la limite si elle dépasse 900 (peut être ajustée en fonction de la situation réelle). , une alarme sera émise, sinon la sortie sera une information normale.

Copier le code Le code est le suivant :

des=` GetDes $PID`
si [ $des -gt 900 ]
alors
{
echo "Le nombre de des est supérieur à 900"
}
sinon
{
echo "Le nombre de des est normal"
}
fi

Exemple de démo :

1) Programme source (en supposant que l'ID de processus de CFTestApp trouvé dans la requête ci-dessus est 11426)

Copier le code Le code est le suivant :

des=`GetDes 11426`

echo "Le nombre de des est $des"

Si [ $des -gt 900 ]
Alors
{
echo "Le nombre de des est supérieur à 900"
}
sinon
{
echo "Le nombre de des est normal"
}
fi

2) Sortie du résultat

Copier le code Le code est le suivant :

Le nombre de des est de 528
Le nombre de des est normal
[coque dyu@xilinuxbldsrv]$

3) Analyse des résultats

Comme le montre la sortie ci-dessus : l'utilisation actuelle du handle du programme CFTestApp est de 528, ce qui est normal et ne dépasse pas la limite d'alarme de 900.

4) Introduction aux commandes

wc : compte le nombre d'octets, de mots et de lignes dans le fichier spécifié, et affiche et affiche les résultats statistiques. Paramètres : -l compte le nombre de lignes. -c compte les octets. -w Compte le nombre de mots.

Vérifiez si un port TCP ou UDP est à l'écoute

La détection de port est souvent rencontrée dans la détection des ressources système, en particulier dans les situations de communication réseau, la détection de l'état du port est souvent très importante. Parfois, le processus, le processeur, la mémoire, etc. peuvent être dans un état normal, mais le port est dans un état anormal et l'entreprise ne fonctionne pas normalement. La fonction suivante peut déterminer si le port spécifié écoute. Il a un paramètre pour le port à détecter. Il utilise d'abord netstat pour afficher les informations d'occupation du port, puis filtre le nombre de ports TCP d'écoute via grep, awk et wc. La deuxième instruction affiche le nombre de ports UDP de surveillance. . Si l'écoute des ports TCP et UDP est entièrement 0, renvoyez 0, sinon renvoyez 1.

.

Liste 6. Détection de ports

Copier le code Le code est le suivant :

fonction Écoute
{
TCPListeningnum=`netstat -an | grep ":$1 " n
awk '$1 == "tcp" && $NF == "ECOUTE" {print $0}' | wc -l`
UDPListeningnum=`netstat -an|grep ":$1 " n
|awk '$1 == "udp" && $NF == "0.0.0.0:*" {print $0}' | (( Numéro d'écoute = TCPListeningnum UDPListeningnum ))
Si [ $Listeningnum == 0 ]
Alors
{
écho "0"
}
sinon
{
écho "1"
}
fi
>

Exemple de démo :
1) Programme source (par exemple, interrogez l'état du port 8080 pour voir s'il écoute)

Copier le code Le code est le suivant :

isListen=`Écoute 8080`
Si [ $isListen -eq 1 ]
Alors
{
echo "Le port écoute"
}
sinon
{
echo "Le port n'écoute pas"
}
fi

2) Sortie du résultat

Copier le code Le code est le suivant :

Le port est à l'écoute
[coque dyu@xilinuxbldsrv]$


3) Analyse des résultats

Comme le montre la sortie ci-dessus : le port 8080 de ce serveur Linux est en état d'écoute.

4) Introduction aux commandes

netstat : Utilisé pour afficher les données statistiques liées aux protocoles IP, TCP, UDP et ICMP. Il est généralement utilisé pour vérifier la connexion réseau de chaque port de la machine. Paramètres : -a affiche toutes les sockets de la connexion. -n Utiliser l'adresse IP directement sans passer par un serveur de noms de domaine.
La fonction suivante détecte également si un certain port TCP ou UDP est dans un état normal.

Copier le code Le code est le suivant :

tcp : netstat -an|egrep $1 |awk '$6 == "ÉCOUTER" && $1 == "tcp" {print $0}'
udp : netstat -an|egrep $1 |awk '$1 == "udp" && $5 == "0.0.0.0:*" {print $0}'

Présentation de la commande

egrep : recherche la chaîne spécifiée dans le fichier. L'effet d'exécution de egrep est similaire à grep -E. La syntaxe et les paramètres utilisés peuvent faire référence à la commande grep. La différence avec grep réside dans la méthode d'interprétation des chaînes. egrep utilise une syntaxe d'expression régulière étendue pour interpréter, tandis que grep utilise des expressions régulières de base. Syntaxe, les expressions régulières étendues ont des spécifications d'expression plus complètes que les expressions régulières de base.

Afficher le nombre de processus en cours d'exécution d'un certain nom de processus

Parfois, nous pouvons avoir besoin d'obtenir le nombre de processus démarrés sur le serveur. La fonction suivante consiste à détecter le nombre de processus en cours d'exécution. Par exemple, le nom du processus est CFTestApp.

Copier le code Le code est le suivant :

Runnum=`ps -ef | grep -v vi | grep -v grep "[ /]CFTestApp" |

Détecter la charge du processeur du système

Lors de la maintenance du serveur, nous rencontrons parfois des interruptions d'activité en raison d'une charge (utilisation) excessive du processeur système. Plusieurs processus peuvent être en cours d'exécution sur le serveur. Il est normal de visualiser le processeur d'un seul processus, mais la charge du processeur de l'ensemble du système peut être anormale. La charge du processeur du système est constamment surveillée via des scripts et des alarmes peuvent être envoyées à temps lorsque des anomalies se produisent, permettant au personnel de maintenance de les traiter en temps opportun et d'éviter les accidents. La fonction suivante peut détecter l'utilisation du processeur du système. Utilisez vmstat pour obtenir la valeur d'inactivité du processeur du système 5 fois, prendre la moyenne, puis obtenir la valeur réelle d'utilisation du processeur en prenant la différence de 100.

Copier le code Le code est le suivant :

fonction GetSysCPU
{
CpuIdle=`vmstat 1 5 |sed -n '3,$p' n
|awk '{x = x $15} FIN {print x/5}' |awk -F '{print $1}'
. CpuNum=`echo "100-$CpuIdle" bc`
echo $CpuNum
>

Exemple de démo :

1) Programme source

Copier le code Le code est le suivant :

cpu=`GetSysCPU`

echo "Le processeur système est $cpu"

si [ $cpu -gt 90 ]
alors
{
echo "L'utilisation du processeur système est supérieure à 90 %"
}
sinon
{
echo "L'utilisation du processeur système est normale"
}
fi

2) Sortie du résultat

Copier le code Le code est le suivant :

Le processeur du système est de 87
L'utilisation du processeur système est normale
[coque dyu@xilinuxbldsrv]$

3）結果分析

從上面的輸出可見：目前 Linux 伺服器系統 CPU 使用率為 87%，是正常的，沒有超過 90% 的警告限制。

4）指令介紹

vmstat：Virtual Meomory Statistics（虛擬記憶體統計）的縮寫，可對作業系統的虛擬記憶體、進程、CPU 活動進行監控。
參數： -n 表示在週期性循環輸出時，輸出的頭部資訊僅顯示一次。

偵測系統磁碟空間

系統磁碟空間偵測是系統資源偵測的重要部分，在系統維護維護中，我們經常需要查看伺服器磁碟空間使用量。因為有些業務要時時寫話單，日誌，或者臨時文件等，如果磁碟空間用盡，也可能會導致業務中斷，下面的函數可以檢測當前系統磁碟空間中某個目錄的磁碟空間使用情況. 輸入參數為需要偵測的目錄名，使用df 輸出系統磁碟空間使用訊息，然後透過grep 和awk 過濾得到某個目錄的磁碟空間使用百分比。

複製程式碼 程式碼如下:

 function GetDiskSpc
 {
    if [ $# -ne 1 ]
    then
        return 1
    fi
 
    Folder="$1$"
    DiskSpace=`df -k |grep $Folder |awk '{print $5}' |awk -F% '{print $1}'
    echo $DiskSpace
 }

範例示範：

1）原始程式（偵測目錄為 /boot）

複製程式碼 程式碼如下:

 Folder="/boot"
 
 DiskSpace=`GetDiskSpc $Folder`
 
 echo "The system $Folder disk space is $DiskSpace%"
 
 if [ $DiskSpace -gt 90 ]
 then
 {
    echo "The usage of system disk($Folder) is larger than 90%"
 }
 else
 {
    echo "The usage of system disk($Folder)  is normal"
 }
 fi

2）結果輸出

複製程式碼 程式碼如下:

 The system /boot disk space is 14%
 The usage of system disk(/boot)  is normal
 [dyu@xilinuxbldsrv shell]$

3）結果分析

從上面的輸出可見：目前此 Linux 伺服器系統上 /boot 目錄的磁碟空間已經使用了 14%，是正常的，沒有超過使用 90% 的警告限制。

4）指令介紹

df：檢查檔案系統的磁碟空間佔用情況。可以利用此指令來取得硬碟被佔用了多少空間，目前還剩下多少空間等資訊。 參數：-k 以 k 位元組為單位顯示。

總結

在 Linux 平台下，shell 腳本監控是一個非常簡單，方便，有效的對伺服器，進程進行監控的方法，對系統開發以及進程維護人員非常有幫助。它不僅可以對上面的訊息進行監控，發送告警，同時也可以監控進程的日誌等等的訊息，希望本文對大家有幫助。