8 comandi Linux per una gestione efficace dei processi

In genere, il ciclo di vita di un processo applicativo ha tre stati principali:avvio, esecuzione e arresto. Ogni Stato può e deve essere gestito con attenzione se vogliamo essere amministratori competenti. Questi otto comandi possono essere utilizzati per gestire i processi durante il loro ciclo di vita.

Avvio di un processo

Il modo più semplice per avviare un processo è digitarne il nome nella riga di comando e premere Invio. Se vuoi avviare un server web Nginx, digita nginx . Forse vuoi solo controllare la versione.

alan@workstation:~$ nginx

alan@workstation:~$ nginx -v
nginx versione:nginx/1.14.0

Visualizzazione del percorso eseguibile

La precedente dimostrazione dell'avvio di un processo presuppone che il file eseguibile si trovi nel percorso eseguibile. Comprendere questo percorso è la chiave per avviare e gestire in modo affidabile un processo. Gli amministratori spesso personalizzano questo percorso per lo scopo desiderato. Puoi visualizzare il tuo percorso eseguibile utilizzando echo $PATH .

alan@workstation:~$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin

CHE

Usa il comando which per visualizzare il percorso completo di un file eseguibile.

alan@workstation:~$ which nginx                                                    
/opt/nginx/bin/nginx

Userò il popolare software per server web Nginx per i miei esempi. Supponiamo che Nginx sia installato. Se il comando che nginx non restituisce nulla, quindi Nginx non è stato trovato perché cerca solo il percorso eseguibile definito. Esistono tre modi per porre rimedio a una situazione in cui un processo non può essere avviato semplicemente per nome. Il primo è digitare il percorso completo. Anche se preferirei non dover digitare tutto questo, vero?

alan@workstation:~$ /home/alan/web/prod/nginx/sbin/nginx -v
nginx versione:nginx/1.14.0

Il terminale Linux

• I 7 migliori emulatori di terminale per Linux
• 10 strumenti da riga di comando per l'analisi dei dati in Linux
• Scarica ora:cheat sheet SSH
• Cheat sheet sui comandi avanzati di Linux
• Esercitazioni sulla riga di comando di Linux

La seconda soluzione sarebbe installare l'applicazione in una directory nel percorso dell'eseguibile. Tuttavia, ciò potrebbe non essere possibile, in particolare se non disponi dei privilegi di root.

La terza soluzione è aggiornare la variabile di ambiente del percorso eseguibile per includere la directory in cui è installata l'applicazione specifica che si desidera utilizzare. Questa soluzione dipende dalla shell. Ad esempio, gli utenti Bash dovrebbero modificare la riga PATH=nel loro file .bashrc.

PATH="$HOME/web/prod/nginx/sbin:$PATH" 

Ora, ripeti l'eco e quali comandi o prova a controllare la versione. Molto più facile!

alan@workstation:~$ echo $PATH
/home/alan/web/prod/nginx/sbin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr /bin

alan@workstation:~$ quale nginx
/home/alan/web/prod/nginx/sbin/nginx

alan@workstation:~$ nginx -v                                                 
versione nginx:nginx/1.14.0

Mantenere in esecuzione un processo

NOHUP

Un processo potrebbe non continuare a essere eseguito quando ci si disconnette o si chiude il terminale. Questo caso speciale può essere evitato precedendo il comando che desideri eseguire con il comando nohup. Inoltre, l'aggiunta di una e commerciale (&) manderà il processo in background e consentirà di continuare a utilizzare il terminale. Ad esempio, supponiamo di voler eseguire myprogram.sh.

nohup myprogram.sh & 

Una cosa carina che fa nohup è restituire il PID del processo in esecuzione. Parlerò di più del PID in seguito.

Gestisci un processo in esecuzione

Il terminale Linux

• I 7 migliori emulatori di terminale per Linux
• 10 strumenti da riga di comando per l'analisi dei dati in Linux
• Scarica ora:cheat sheet SSH
• Cheat sheet sui comandi avanzati di Linux
• Esercitazioni sulla riga di comando di Linux

Ad ogni processo viene assegnato un numero di identificazione del processo (PID) univoco. Questo numero è ciò che utilizziamo per gestire ogni processo. Possiamo anche usare il nome del processo, come dimostrerò di seguito. Esistono diversi comandi che possono controllare lo stato di un processo in esecuzione. Diamo una rapida occhiata a questi.

PS

Il più comune è ps. L'output predefinito di ps è un semplice elenco dei processi in esecuzione nel terminale corrente. Come puoi vedere di seguito, la prima colonna contiene il PID.

alan@workstation:~$ ps
PID TTY          TIME CMD
23989 pts/0    00:00:00 bash
24148 pts/0    00:00:00 ps

Vorrei visualizzare il processo Nginx che ho iniziato in precedenza. Per fare ciò, dico a ps di mostrarmi ogni processo in esecuzione (-e ) e un elenco completo (-f ).

alan@workstation:~$ ps -ef
UID        PID  PPID  C STIME TTY          TIME CMD 
root         1     0  0 Aug18 ? 00:00:10 /sbin/init splash
root         2     0  0 ago18 ? 00:00:00 [kthreadd]
root         4     2  0 ago18 ? 00:00:00 [kworker/0:0H]
root         6     2  0 ago18 ? 00:00:00 [mm_percpu_wq]
root         7     2  0 ago18 ? 00:00:00 [ksoftirqd/0]
root         8     2  0 ago18 ? 00:00:20 [rcu_sched]
root         9     2  0 ago18 ? 00:00:00 [rcu_bh]
root        10     2  0 ago18 ? 00:00:00 [migrazione/0]
root        11     2  0 ago18 ? 00:00:00 [watchdog/0]
root        12     2  0 ago18 ? 00:00:00 [cpuhp/0]
root        13     2  0 ago18 ? 00:00:00 [cpuhp/1]
root        14     2  0 ago18 ? 00:00:00 [watchdog/1]
root        15     2  0 ago18 ? 00:00:00 [migrazione/1]
root        16     2  0 ago18 ? 00:00:00 [ksoftirqd/1]
alan     20506 20496  0 10:39 pts/0    00:00:00 bash
alan     20520  1454  0 10:39 ? 00:00:00 nginx:processo master nginx
alan     20521 20520  0 10:39 ? 00:00:00 nginx:worker process
alan     20526 20506  0 10:39 pts/0    00:00:00 man ps
alan     20536 20526  0 10:39 pts/0    00:00:00 pager 
alan     20564 20496  0 10:40 pts/1    00:00:00 bash

Puoi vedere i processi Nginx nell'output del comando ps sopra. Il comando mostrava quasi 300 righe, ma l'ho abbreviato per questa illustrazione. Come puoi immaginare, provare a gestire 300 righe di informazioni di processo è un po' complicato. Possiamo reindirizzare questo output a grep per filtrare nginx.

alan@workstation:~$ ps -ef |grep nginx
alan     20520  1454  0 10:39 ? 00:00:00 nginx:processo master nginx
alan     20521 20520  0 10:39 ? 00:00:00 nginx:processo di lavoro

Va meglio. Possiamo vedere rapidamente che Nginx ha PID di 20520 e 20521.

PGREP

Il comando pgrep è stato creato per semplificare ulteriormente le cose eliminando la necessità di chiamare grep separatamente.

alan@workstation:~$ pgrep nginx
20520
20521

Supponiamo di essere in un ambiente di hosting in cui più utenti eseguono diverse istanze di Nginx. Puoi escludere altri dall'output con -u opzione.

alan@workstation:~$ pgrep -u alan nginx
20520
20521

PIDOF

Un altro elegante è pidof. Questo comando verificherà il PID di un binario specifico anche se è in esecuzione un altro processo con lo stesso nome. Per impostare un esempio, ho copiato il mio Nginx in una seconda directory e l'ho avviato con il prefisso impostato di conseguenza. Nella vita reale, questa istanza potrebbe trovarsi in una posizione diversa, ad esempio una directory di proprietà di un utente diverso. Se eseguo entrambe le istanze Nginx, ps -ef l'output mostra tutti i loro processi.

alan@workstation:~$ ps -ef |grep nginx
alan     20881  1454  0 11:18 ? 00:00:00 nginx:processo principale ./nginx -p /home/alan/web/prod/nginxsec
alan     20882 20881  0 11:18 ? 00:00:00 nginx:processo lavoratore
alan     20895  1454  0 11:19 ? 00:00:00 nginx:processo master nginx
alan     20896 20895  0 11:19 ? 00:00:00 nginx:processo di lavoro

L'uso di grep o pgrep mostrerà i numeri PID, ma potremmo non essere in grado di discernere quale istanza è quale.

alan@workstation:~$ pgrep nginx
20881
20882
20895
20896

Il comando pidof può essere utilizzato per determinare il PID di ogni specifica istanza Nginx.

alan@workstation:~$ pidof /home/alan/web/prod/nginxsec/sbin/nginx
20882 20881

alan@workstation:~$ pidof /home/alan/ web/prod/nginx/sbin/nginx
20896 20895

TOP

Il comando in alto è in circolazione da molto tempo ed è molto utile per visualizzare i dettagli dei processi in esecuzione e identificare rapidamente problemi come i problemi di memoria. La sua visualizzazione predefinita è mostrata di seguito.

top - 11:56:28 fino a 1 giorno, 13:37,  1 utente,  media di caricamento:0,09, 0,04, 0,03
Attività:292 in totale, 3 in esecuzione, 225 a riposo, 0 fermi, 0 zombi
%Cpu(s): 0.1 us,  0.2 sy,  0.0 ni, 99.7 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
KiB Mem :16387132 total, 10854648 free,  1859036 used,  3673448 buff /cache
KiB Swap:       0 totale,        0 gratuito,        0 utilizzato. 14176540 Dispositivi MEM 
 
 Utente PID PR NI Virt Res Shr SC S% CPU% Mem Time + Command 
 17270 Alan 20 0 3930764 247288 98992 R 0.7 1.5 5:58.22 Gnome-shell 
 20496 Alan 20 0 816144 45416 29844 S 0.5 0.3 0:22.16 GNOME-Terminale- 
 21110 Alan 20 0 41940 3988 3188 R 0.1 0.0 0:00.17 Top 
 1 Root 20 0 225564 9416 6768 S 0.0 0.1 0:10.72 Systemd 
 2 Root 20 0 0 0 0 0 0,0 0.0 0:00.01 Kthreadd 
 4 Root 0 -20 0 0 0 0 0,0 0.0 0:00.00 KWorker / 0:0H 
 6 Root 0 -20       0      0      0 I   0.0  0.0   0:00.00 mm_percpu_wq
    7 radice      20   0       0     0      0 S   0.0  0.0   0:00.08 k 

 L'intervallo di aggiornamento può essere modificato digitando la lettera s seguito dal numero di secondi che preferisci per gli aggiornamenti. Per semplificare il monitoraggio dei nostri processi Nginx di esempio, possiamo chiamare top e passare i PID utilizzando -p opzione. Questo output è molto più pulito.
 
alan@workstation:~$ top -p20881 -p20882 -p20895 -p20896

Compiti:  4 in totale,   0 in esecuzione,   4 inattivo,   0 fermo,   0 zombi
%Cpu(s ): 2.8 us,  1.3 sy,  0.0 ni, 95.9 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
KiB Mem :16387132 total, 10856008 free,  1857648 used,  3673476 buff/cache
Ki Scambio:       0 totale,        0 gratuito,        0 utilizzato. 14177928 Dispositivi MEM 
 
 Utente PID PR NI Virt Res Shr SC S% CPU% MEM TIME + Comando 
 20881 Alan 20 0 12016 348 0 s 0.0 0.0 0:00.00 Nginx 
 20882 Alan 20 0 12460 1644 932 S 0.0 0.0 0:00.00 Nginx 
 20895 Alan 20 0 12016 352 0 s 0.0 0.0 0:00.00 Nginx 
 20896 Alan 20 0 12460 1628 912 s 0.0 0.0 0:00.00 nginx 
 

 È importante determinare correttamente il PID durante la gestione dei processi, in particolare interrompendone uno. Inoltre, se si utilizza top in questo modo, ogni volta che uno di questi processi viene interrotto o ne viene avviato uno nuovo, top dovrà essere informato dei nuovi.
 
Interruzione di un processo
 
UCCIDI
 

 È interessante notare che non esiste un comando di arresto. In Linux, c'è il comando kill. Kill viene utilizzato per inviare un segnale a un processo. Il segnale più comunemente usato è "termina" (SIGTERM) o "kill" (SIGKILL). Tuttavia, ce ne sono molti di più. Di seguito sono riportati alcuni esempi. L'elenco completo può essere visualizzato con kill -L .
 
 1) Sighp 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP 
 6) SIGTRAPR 7) SIGBUS 8) SIGFPE 9) SIGKILL 10) SIGUSR1 
 11) SIGSEGV 12) SIGUSR2 13) SIGPIPE 14) SIGALRM     15) SIGTERM
 

 Notare che il segnale numero nove è SIGKILL. Di solito emettiamo un comando come kill -9 20896 . Il segnale predefinito è 15, che è SIGTERM. Tieni presente che molte applicazioni hanno il proprio metodo per l'arresto. Nginx usa un -s opzione per passare un segnale come "stop" o "reload". In genere, preferisco utilizzare il metodo specifico di un'applicazione per interrompere un'operazione. Tuttavia, dimostrerò il comando kill per interrompere il processo Nginx 20896 e quindi confermerò che è stato interrotto con pgrep. Il PID 20896 non viene più visualizzato.
 
alan@workstation:~$ kill -9 20896
 
alan@workstation:~$ pgrep nginx
20881
20882
20895
22123
 
PKILL
 

 Il comando pkill è simile a pgrep in quanto può cercare per nome. Ciò significa che devi stare molto attento quando usi pkill. Nel mio esempio con Nginx, potrei non scegliere di usarlo se voglio uccidere solo un'istanza di Nginx. Posso passare l'opzione Nginx -s fermati a un'istanza specifica per ucciderlo, oppure devo usare grep per filtrare l'output completo di ps.
 
/home/alan/web/prod/nginx/sbin/nginx -s stop

/home/alan/web/prod/nginxsec/sbin/nginx -s stop
 

 Se voglio usare pkill, posso includere -f opzione per chiedere a pkill di filtrare l'intero argomento della riga di comando. Questo ovviamente vale anche per pgrep. Quindi, prima posso controllare con pgrep -a prima di emettere il pkill -f .
 
alan@workstation:~$ pgrep -a nginx
20881 nginx:processo principale ./nginx -p /home/alan/web/prod/nginxsec
20882 nginx:processo di lavoro
 20895 nginx:processo master nginx
20896 nginx:processo lavoratore
 

 Posso anche restringere il mio risultato con pgrep -f . Lo stesso argomento utilizzato con pkill interrompe il processo.
 
alan@workstation:~$ pgrep -f nginxsec
20881
                                            
alan@workstation:~$ pkill -f nginxsec
 

 La cosa fondamentale da ricordare con pgrep (e soprattutto pkill) è che devi essere sempre sicuro che il tuo risultato di ricerca sia accurato in modo da non influenzare involontariamente i processi sbagliati.
 

 La maggior parte di questi comandi ha molte opzioni della riga di comando, quindi consiglio sempre di leggere la pagina man su ciascuno di essi. Sebbene la maggior parte di questi esista su piattaforme come Linux, Solaris e BSD, ci sono alcune differenze. Testare sempre ed essere pronti a correggere secondo necessità quando si lavora dalla riga di comando o si scrivono script.