Une collection de commandes que vous devez connaître en isolant la cause du dépannage (édition serveur)

Commandes système

Afficher la disponibilité Linux (disponibilité)

Afficher la disponibilité de Linux. Lorsque la communication ping est temporairement NG, etc., le serveur peut être suspecté d'avoir redémarré et confirmé.

$ uptime
 12:16:05 up 48 days, 17:53,  2 users,  load average: 0.00, 0.02, 0.00

Il est souhaitable que la charge moyenne soit inférieure au nombre de cœurs de processeur.

Vérifier l'état du processus (commande supérieure, commande ps)

Répertorier les états des processus en cours (comme un instantané)

Utilisez la commande ps pour répertorier les états du processus en cours d'exécution (dans un instantané). Il est utilisé pour une confirmation telle que "Quel processus est la charge lourde?"

$ ps aux

Il peut être utilisé en combinaison avec la commande grep pour vérifier l'état du processus d'un service spécifique. Voici un exemple de vérification de l'état du processus de Nginx.

$ ps aux | grep -e nginx -e %CPU

Liste des processus en cours (en temps réel)

Utilisez la commande top pour répertorier les états (en temps réel) des processus en cours d'exécution. Il est recommandé d'ajouter "-c" à l'option car le chemin complet de la commande peut être affiché. Comme la commande PS, elle est utilisée pour vérifier "Quel processus représente la charge lourde?"

$ top -c

En vérifiant l'ID de processus avec la commande ps et en spécifiant l'option "-p" comme indiqué ci-dessous, vous ne pouvez vérifier que l'état du processus spécifique. Voici un exemple de vérification de l'état du processus de Nginx.

$ ps aux | grep -e nginx -e %CPU
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root      2142  0.0  0.0  53788    68 ?        Ss   Jun06   0:00 nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf
nginx     2143  0.0  0.1  85396  3048 ?        S    Jun06   0:03 nginx: worker process
root     13439  0.0  0.0  12108  1088 pts/0    S+   16:53   0:00 grep --color=auto -e nginx -e %CPU

//Exécuter en spécifiant l'ID de processus de nginx
$ top -cp 2142
top - 16:54:05 up 36 days, 22:31,  1 user,  load average: 0.06, 0.23, 0.16
Tasks:   1 total,   0 running,   1 sleeping,   0 stopped,   0 zombie
%Cpu(s):  0.0 us,  0.0 sy,  0.0 ni,100.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
MiB Mem :   1829.2 total,     80.2 free,   1558.7 used,    190.4 buff/cache
MiB Swap:   2048.0 total,    854.2 free,   1193.8 used.    120.1 avail Mem

  PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
 2142 root      20   0   53788     68     68 S   0.0   0.0   0:00.01 nginx

Comment lire le résultat de sortie

1ère ligne: les informations de disponibilité et de charge globale sont sorties.

top - 16:45:36 up 36 days, 22:23,  1 user,  load average: 0.01, 0.02, 0.00

2ème à 3ème lignes: l'état lié à la CPU et aux tâches est affiché.

Tasks: 116 total,   1 running, 115 sleeping,   0 stopped,   0 zombie
%Cpu(s): 12.5 us,  0.0 sy,  0.0 ni, 87.5 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st

Lignes 4-5: l'état lié à la mémoire et au swap est émis.

MiB Mem :   1829.2 total,     74.0 free,   1558.9 used,    196.3 buff/cache
MiB Swap:   2048.0 total,    854.2 free,   1193.8 used.    119.9 avail Mem

Vérifier les statistiques d'E / S du processeur, de la mémoire et du disque (vmstat)

Afficher les statistiques de la mémoire virtuelle, du processeur et des E / S disque. En spécifiant m avec l'option "--unit", l'affichage MB sera affiché et il sera plus facile à voir.

$ vmstat --unit m
procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
 2  0    153    228    115    962    0    0   234    16    3    3  1  0 99  0  0

En spécifiant "1" comme argument, il peut être affiché à des intervalles d'une seconde.

$ vmstat --unit m 1
procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
 0  0    153    228    115    962    0    0   234    16    3    3  1  0 99  0  0
 0  0    153    227    115    962    0    0     0     0  150  168  0  0 100  0  0
 0  0    153    227    115    962    0    0     0     0  151  188  0  0 100  0  0

Vérifier les statistiques d'E / S du processeur et du disque (iostat)

Affiche l'utilisation du processeur et l'utilisation du périphérique d'E / S.

$ iostat -h
Linux 4.18.0-147.8.1.el8_1.x86_64 (XXX-XX-XX-XXX)       07/01/2020      _x86_64_        (3 CPU)

avg-cpu:  %user   %nice %system %iowait  %steal   %idle
           0.6%    0.0%    0.4%    0.0%    0.0%   98.9%

      tps    kB_read/s    kB_wrtn/s    kB_read    kB_wrtn Device
    11.96       700.4k        48.5k       2.7T     194.7G vda
     0.00         0.0k         0.0k     416.0k       0.0k scd0

Vérifier l'état d'utilisation de la mémoire (commande gratuite)

Affichez l'état d'utilisation de la mémoire.

//Se référer à en kilo-octets
$ free

//Référence en unités mégaoctets
$ free -m

//Se référer à en unités de gigaoctet
$ free -g

Vérifier l'état d'utilisation du disque (commande df)

Affichez l'état d'utilisation du disque. En spécifiant l'option "-h", il sera affiché avec une unité appropriée, c'est donc recommandé.

$ df -h

Vérifier l'utilisation du disque (dans un répertoire spécifique) (commande du)

Affichez l'état d'utilisation du disque (sous un répertoire spécifique). En spécifiant l'option "-h", il sera affiché avec une unité appropriée, c'est donc recommandé.

$ du -h | sort -hr

Vous pouvez également spécifier la profondeur à vérifier en spécifiant l'option "--max-depth". Voici un exemple de vérification de l'état d'utilisation du disque dans le répertoire actuel.

$ du --max-depth=1 -h | sort -hr
772M    .
743M    ./.vscode-server
13M     ./.local
11M     ./.cache
44K     ./.vscode-remote
8.0K    ./.vscode
8.0K    ./.ssh
8.0K    ./.pylint.d
8.0K    ./.config

Vérifiez l'état de montage du volume (commande de montage)

Vérifiez l'état de montage du volume. Il est utilisé pour vérifier si le disque est correctement monté, par exemple lorsque "les données ne peuvent pas être lues". Notez que si vous exécutez sans l'option "-l", vous pouvez monter des disques qui ne doivent pas être montés, soyez donc prudent lors de l'exécution. Si vous voulez juste vérifier la situation, assurez-vous d'ajouter l'option "-l".

$ mount -l

De plus, il y a "/ etc / fstab" dans le fichier qui est étroitement lié à la commande de montage. Cela décrit les paramètres de montage du volume à refléter lorsque le serveur est démarré ou que le gestionnaire système est rechargé. Si vous ne pouvez pas confirmer l'état du montage avec la commande "mount -l" ci-dessus, même si les paramètres de montage sont décrits dans fstab, il y a place à la suspicion d'une anomalie.

$ cat /etc/fstab

Vérifiez la sortie du message par le noyau Linux (dmesg)

Vérifiez les informations fournies par le noyau Linux (logiciel qui joue un rôle central dans le système d'exploitation, comme la gestion des processus, la gestion de la mémoire et la gestion des horaires). En spécifiant l'option "-T", les informations de temps deviennent plus faciles à voir. De plus, en spécifiant l'option "-x", le niveau d'information du message est affiché. Lorsque le serveur est redémarré mais que l'application ne peut pas lire les données normalement, vous pouvez constater que le disque est endommagé en vérifiant la sortie de dmesg.

$ dmesg -Tx

Vérifier les tendances d'utilisation des ressources passées (SAR)

Vérifiez la tendance d'utilisation des ressources passées (CPU, mémoire, etc.). Veuillez noter qu'il peut ne pas être installé selon le serveur.

//Vérifiez les tendances d'utilisation du processeur passées
$ sar -u

//Vérifiez les tendances d'utilisation de la mémoire passées
$ sar -r

Commandes réseau

Vérifier la communication réseau (ping)

Vérifiez la communication réseau. À propos, l'adresse IP "8.8.8.8" indique le DNS public de Google. Si la vérification de la communication ping est NG, c'est une bonne idée d'utiliser la commande "trace route" présentée ci-dessous pour vérifier où la communication était NG.

//Vérifier la communication par adresse IP
$ ping 8.8.8.8

//Vérifiez la communication par nom d'hôte * Il résout également le nom
$ ping google.com

//Continuez à vérifier la communication toutes les 1 seconde
$ ping -i 1 8.8.8.8

//Vérifier la communication avec IPv4
$ ping -4 google.com

//Vérifier la communication avec IPv6
$ ping -6 google.com

Tracer l'itinéraire du réseau

Vérifiez l'itinéraire réseau. Veuillez noter qu'il peut ne pas être installé selon le serveur. Il est souvent utilisé pour confirmer où la communication était NG.

$ traceroute 8.8.8.8

Confirmer la résolution du nom (nslookup, creuser)

Vérifiez la résolution du nom. La différence entre les commandes nslookup et dig est que la première traite le résultat de la réponse du serveur de noms de sorte qu'il soit facile à voir, tandis que la seconde affiche le résultat de la réponse du serveur de noms tel quel. Si vous vous méfiez du DNS, c'est une bonne idée d'utiliser d'abord cette commande pour vérifier l'état de la résolution de noms.

//Vérifiez la traction avant
$ nslookup google.com

//Vérifiez la traction inversée
$ nslookup 8.8.8.8
//Vérifiez la traction avant
$ dig google.com

//Vérifiez la traction inversée
$ dig -x 8.8.8.8

Vérifiez l'état de la connexion du socket TCP (ss, netstat)

Vérifiez l'état de la connexion du socket TCP. Notez que netstat est obsolète dans RHEL7 et versions ultérieures, et ss est recommandé comme commande alternative. Voici une commande permettant de vérifier l'état de la connexion du socket TCP IPv4. Il est utilisé pour vérifier quel type de serveur fonctionne à partir de l'état d'utilisation du port. Bien qu'il soit obsolète, netstat est plus facile à lire, il est donc préférable d'utiliser la commande netstat que la commande ss jusqu'à ce qu'elle soit complètement indisponible.

//Recommandation
$ ss -at4

//non recommandé
$ netstat -at4

Vérifier l'état du réseau (ip, ifconfig)

Vérifiez l'état du réseau. De plus, ifconfig est obsolète dans RHEL7 ou version ultérieure, et ip est recommandé comme commande alternative. Ce qui suit est une commande pour afficher les paramètres réseau de chaque interface existante. Il est utilisé pour vérifier l'état de connexion de l'interface réseau.

//Recommandation
$ ip a

//non recommandé
$ ifconfig -a

Vérification de la table de routage (ip, route, netstat)

Vérifiez la table de routage. Notez que route est obsolète dans RHEL7 et versions ultérieures, et ip est recommandé comme commande alternative. Voici une commande pour vérifier la table de routage. Bien que déconseillée, la sortie de la commande route est plus facile à lire, il est donc préférable d'utiliser la commande route plutôt que la commande ip jusqu'à ce qu'elle soit complètement indisponible.

//Recommandation
$ ip r

//non recommandé
$ route

//non recommandé
$ netstat -nr

Vérifier la table de cache ARP

Vérifiez la table de cache ARP. De plus, arp est obsolète dans RHEL7 ou version ultérieure, et ip est recommandé comme commande alternative. Ce qui suit est une commande pour vérifier la table de cache ARP. Par exemple, lorsque le routeur est remplacé, l'adresse MAC du périphérique précédent peut être laissée dans le cache APR, provoquant une panne de communication, etc., et elle est utilisée comme isolement dans ce cas.

//Recommandation
$ ip n

//non recommandé
$ arp -a

Autre

Vérifiez les journaux en temps réel

Vérifiez le journal de sortie en temps réel. Il est efficace de vérifier quel type de journal est généré lorsque des problèmes se produisent actuellement dans le formulaire en cours.

$ tail -f  access.log

Si un énorme journal est généré en peu de temps, il est souvent utilisé en combinaison avec la commande grep. Voici un exemple de combinaison de la commande tail et de la commande grep et de la sortie de l'erreur 404 uniquement en standard.

$ tail -f access.log | grep 404
125.197.158.68 - - [01/Jul/2020:13:45:11 +0900] "GET /404 HTTP/1.1" 301 162 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.97 Safari/537.36" "-"
125.197.158.68 - - [01/Jul/2020:13:45:11 +0900] "GET /404 HTTP/2.0" 404 548 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.97 Safari/537.36" "-"
125.197.158.68 - - [01/Jul/2020:13:45:11 +0900] "GET /favicon.ico HTTP/2.0" 404 548 "https://example.com/404" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.97 Safari/537.36" "-"

Rechercher des fichiers qui correspondent à (diverses) conditions

Recherchez des fichiers qui correspondent à (diverses) conditions. Souvent, vous ne connaissez pas la structure des fichiers de répertoire et vous ne savez pas où se trouve le fichier que vous recherchez. Dans un tel cas, cette commande est souvent utilisée pour la recherche.

//Recherchez le fichier spécifié sous le chemin de recherche
$trouver le chemin de recherche-nom Nom du fichier

//Exemple d'exécution
$ find /var/log/ -name "access.log"
/var/log/nginx/access.log

//Exemple utilisant des caractères génériques
$ find /var/log/ -name "*.log"
/var/log/letsencrypt/letsencrypt.log
/var/log/dnf.rpm.log
/var/log/dnf.librepo.log
/var/log/boot.log
/var/log/nginx/error.log
/var/log/nginx/access.log
/var/log/audit/audit.log
/var/log/cloud-init-output.log
/var/log/cloud-init.log
/var/log/dnf.log
/var/log/sssd/sssd_nss.log
/var/log/sssd/sssd_implicit_files.log
/var/log/sssd/sssd.log
/var/log/hawkey.log
/var/log/tuned/tuned.log

//Exemple de spécification du type de fichier (fichier uniquement)
$ find /opt/docker/ -name "*.conf" -type f
/opt/docker/nginx/conf/default.conf
/opt/docker/nginx/conf/nginx.conf

//Exemple de spécification du type de fichier (répertoire uniquement)
$ find /opt/docker/ -name "nginx" -type d
/opt/docker/nginx

Extraire des lignes contenant des caractères spécifiques du fichier

Extrayez les lignes contenant des caractères spécifiques du fichier. Cette commande est utilisée très souvent, mais elle est souvent utilisée pour vérifier si une erreur est sortie du journal de dépannage. Ici, je voudrais présenter un exemple pour un usage personnel.

//Extraire des lignes contenant des caractères spécifiques du fichier spécifié
$ grep access.log nginx.conf
    access_log  /var/log/nginx/access.log  main;

//Utilisez des caractères génériques pour extraire des lignes contenant des caractères spécifiques à partir de fichiers
$ grep http *.conf
default.conf:    return       301 https://$host$request_uri;
default.conf:    listen       443 ssl http2;
default.conf:    listen       [::]:443 ssl http2;
default.conf:        proxy_pass                             http://localhost:5601;
nginx.conf:http {
nginx.conf:                      '$status $body_bytes_sent "$http_referer" '
nginx.conf:                      '"$http_user_agent" "$http_x_forwarded_for"';

// -v Facultatif pour exclure des chaînes spécifiques de l'extraction
$ echo -e "test\ntast\ntest" > test.txt
$ cat test.txt
test
tast
test
$ grep test test.txt
test
test
$ grep -v test test.txt
tast

// -Extraire une chaîne de caractères spécifique par OU rechercher avec l'option e
$ grep -e test -e tast test.txt
test
tast
test

// -Extraire insensible à la casse avec l'option i
$ grep Access.log nginx.conf
$ grep -i Access.log nginx.conf
    access_log  /var/log/nginx/access.log  main;

//Effectue une recherche incluant les sous-répertoires et cible également la destination des liens symboliques
$ grep -R http
nginx/conf/default.conf:    return       301 https://$host$request_uri;
nginx/conf/default.conf:    listen       443 ssl http2;
nginx/conf/default.conf:    listen       [::]:443 ssl http2;
nginx/conf/default.conf:        proxy_pass                             http://localhost:5601;
nginx/conf/nginx.conf:http {
nginx/conf/nginx.conf:                      '$status $body_bytes_sent "$http_referer" '
nginx/conf/nginx.conf:                      '"$http_user_agent" "$http_x_forwarded_for"';
nginx/html/index.html:<a href="http://nginx.org/">nginx.org</a>.<br/>
nginx/html/index.html:<a href="http://nginx.com/">nginx.com</a>.</p>

Lister les fichiers

Liste des fichiers. Ici, je voudrais présenter un exemple pour un usage personnel.

//Répertoriez simplement les fichiers
$ ls
conf  docker-compose.yml  html

//Afficher également les informations sur le fichier
$ ls -l
total 12
drwxr-xr-x 2 root root 4096 May 22 20:52 conf
-rw-r--r-- 1 root root  655 May 22 20:37 docker-compose.yml
drwxr-xr-x 2 root root 4096 May 20 16:02 html

//Le fichier de points est également affiché
$ ls -la
total 20
drwxr-xr-x 4 root root 4096 May 22 20:37 .
drwxr-xr-x 5 root root 4096 May 19 13:47 ..
drwxr-xr-x 2 root root 4096 May 22 20:52 conf
-rw-r--r-- 1 root root  655 May 22 20:37 docker-compose.yml
drwxr-xr-x 2 root root 4096 May 20 16:02 html

//Lister les fichiers dans l'ordre chronologique et les afficher dans l'ordre inverse
$ ls -latr
total 20
drwxr-xr-x 5 root root 4096 May 19 13:47 ..
drwxr-xr-x 2 root root 4096 May 20 16:02 html
-rw-r--r-- 1 root root  655 May 22 20:37 docker-compose.yml
drwxr-xr-x 4 root root 4096 May 22 20:37 .
drwxr-xr-x 2 root root 4096 May 22 20:52 conf

//Afficher la taille du fichier dans un format lisible par l'homme
$ ls -latrh
total 20K
drwxr-xr-x 5 root root 4.0K May 19 13:47 ..
drwxr-xr-x 2 root root 4.0K May 20 16:02 html
-rw-r--r-- 1 root root  655 May 22 20:37 docker-compose.yml
drwxr-xr-x 4 root root 4.0K May 22 20:37 .
drwxr-xr-x 2 root root 4.0K May 22 20:52 conf

//Afficher récursivement
# ls -latrhR
.:
total 20K
drwxr-xr-x 5 root root 4.0K May 19 13:47 ..
drwxr-xr-x 2 root root 4.0K May 20 16:02 html
-rw-r--r-- 1 root root  655 May 22 20:37 docker-compose.yml
drwxr-xr-x 4 root root 4.0K May 22 20:37 .
drwxr-xr-x 2 root root 4.0K May 22 20:52 conf

./html:
total 16K
-rw-r--r-- 1 root root  612 Apr 14 23:19 index.html
-rw-r--r-- 1 root root  494 Apr 14 23:19 50x.html
drwxr-xr-x 2 root root 4.0K May 20 16:02 .
drwxr-xr-x 4 root root 4.0K May 22 20:37 ..

./conf:
total 16K
-rw-r--r-- 1 root root  670 May 20 19:32 nginx.conf
drwxr-xr-x 4 root root 4.0K May 22 20:37 ..
-rw-r--r-- 1 root root 1.3K May 22 20:52 default.conf
drwxr-xr-x 2 root root 4.0K May 22 20:52 .

Faire défiler le texte

Afficher le texte. Il est utilisé lors de la vérification de la partie erreur du journal.

$ more access.log
$ less access.log
$ view access.log

Différences entre les commandes «plus», «moins» et «afficher»

Le tableau ci-dessous résume les différences que vous devez connaître, bien qu'il y ait des différences mineures.

commander Vitesse d'affichage Comment sortir
more vite Se termine automatiquement lorsque vous atteignez la fin de la ligne/ q / Ctrl+C
less vite q
view lent :q

Recommended Posts

Une collection de commandes que vous devez connaître en isolant la cause du dépannage (édition serveur)
Vous ne devez pas utiliser l'option --color = always de la commande grep
Expliquer le mécanisme de Linux que vous ne connaissez pas de manière inattendue
Connaissance de l'algèbre linéaire que vous devez savoir lorsque vous faites de l'IA
Surveillez régulièrement la réponse HTTP du serveur Web
[Introduction à Python] Utilisation basique de la bibliothèque scipy que vous devez absolument connaître