Bash
Emplois et processus

Liste des travaux en cours

$ tail -f /var/log/syslog > log.txt
[1]+  Stopped                 tail -f /var/log/syslog > log.txt

$ sleep 10 &

$ jobs
[1]+  Stopped                 tail -f /var/log/syslog > log.txt
[2]-  Running                 sleep 10 &

Gestion des travaux

Créer des emplois

Pour créer un travail, ajoutez juste un seul & après la commande:

$ sleep 10 &
[1] 20024

Vous pouvez également effectuer un traitement en cours en appuyant sur Ctrl + z :

$ sleep 10
^Z
[1]+  Stopped                 sleep 10

Arrière-plan et avant-plan d'un processus

Pour amener le processus au premier plan, la commande fg est utilisée avec %

$ sleep 10 &
[1] 20024

$ fg %1
sleep 10

Maintenant, vous pouvez interagir avec le processus. Pour le ramener en arrière-plan, vous pouvez utiliser la commande bg . En raison de la session de terminal occupée, vous devez d'abord arrêter le processus en appuyant sur Ctrl + z .

$ sleep 10
^Z
[1]+  Stopped              sleep 10

$ bg %1
[1]+ sleep 10 &

En raison de la paresse de certains programmeurs, toutes ces commandes fonctionnent également avec un seul % s'il n'y a qu'un processus ou pour le premier processus de la liste. Par exemple:

$ sleep 10 &
[1] 20024

$ fg %        # to bring a process to foreground 'fg %' is also working.
sleep 10

ou juste

$ %           # laziness knows no boundaries, '%' is also working.
sleep 10

De plus, il suffit de taper fg ou bg sans aucun argument pour gérer le dernier travail:

$ sleep 20 &
$ sleep 10 &
$ fg
sleep 10
^C
$ fg
sleep 20

Tuer des emplois en cours d'exécution

$ sleep 10 &
[1] 20024

$ kill %1
[1]+  Terminated              sleep 10

Le processus de veille s'exécute en arrière-plan avec l'ID de processus (pid) 20024 et le travail numéro 1 . Pour référencer le processus, vous pouvez utiliser soit le pid, soit le numéro de travail. Si vous utilisez le numéro de travail, vous devez le préfixer avec % . Le signal de suppression par défaut envoyé par kill est SIGTERM , ce qui permet au processus cible de sortir normalement.

Certains signaux de suppression courants sont présentés ci-dessous. Pour voir une liste complète, exécutez kill -l .

Démarrer et tuer des processus spécifiques

Le moyen le plus simple de tuer un processus en cours est de le sélectionner via le nom du processus, comme dans l'exemple suivant, en utilisant la commande pkill comme

pkill -f test.py

(ou) un moyen plus pgrep utiliser pgrep pour rechercher l'ID de processus réel

kill $(pgrep -f 'python test.py')

Le même résultat peut être obtenu en utilisant grep sur ps -ef | grep name_of_process puis en ps -ef | grep name_of_process le processus associé au pid résultant (identificateur de processus). La sélection d'un processus utilisant son nom est pratique dans un environnement de test mais peut être très dangereuse lorsque le script est utilisé en production: il est pratiquement impossible d'être sûr que le nom correspond au processus que vous souhaitez réellement tuer. Dans ces cas, l'approche suivante est en réalité beaucoup plus sûre.

Démarrez le script qui sera finalement tué avec l'approche suivante. Supposons que la commande que vous voulez exécuter et éventuellement tuer soit python test.py

#!/bin/bash

if [[ ! -e /tmp/test.py.pid ]]; then   # Check if the file already exists
    python test.py &                   #+and if so do not run another process.
    echo $! > /tmp/test.py.pid
else
    echo -n "ERROR: The process is already running with pid "
    cat /tmp/test.py.pid
    echo
fi

Cela créera un fichier dans le /tmp contenant le pid du processus python test.py Si le fichier existe déjà, nous supposons que la commande est déjà en cours d'exécution et que le script renvoie une erreur.

Ensuite, lorsque vous voulez le tuer, utilisez le script suivant:

#!/bin/bash

if [[ -e /tmp/test.py.pid ]]; then   # If the file do not exists, then the
    kill `cat /tmp/test.py.pid`      #+the process is not running. Useless
    rm /tmp/test.py.pid              #+trying to kill it.
else
    echo "test.py is not running"
fi

cela tuera exactement le processus associé à votre commande, sans compter sur aucune information volatile (comme la chaîne utilisée pour exécuter la commande). Même dans ce cas, si le fichier n'existe pas, le script suppose que vous souhaitez supprimer un processus non en cours d'exécution.

Ce dernier exemple peut être facilement amélioré pour exécuter la même commande plusieurs fois (en ajoutant le fichier pid au lieu de le remplacer, par exemple) et pour gérer les cas où le processus meurt avant d'être tué.

Liste tous les processus

Il existe deux méthodes courantes pour répertorier tous les processus sur un système. Tous deux listent tous les processus en cours d'exécution par tous les utilisateurs, bien qu'ils diffèrent par le format qu'ils produisent (la raison de ces différences est historique).

ps -ef   # lists all processes 
ps aux   # lists all processes in alternative format (BSD)

Cela peut être utilisé pour vérifier si une application donnée est en cours d'exécution. Par exemple, pour vérifier si le serveur SSH (sshd) est en cours d'exécution:

ps -ef | grep sshd

Vérifier quel processus s'exécute sur un port spécifique

Pour vérifier quel processus s'exécute sur le port 8080

lsof -i :8080

Recherche d'informations sur un processus en cours d'exécution

ps aux | grep <search-term> affiche les processus correspondant au terme de recherche

Exemple:

root@server7:~# ps aux | grep nginx
root       315  0.0  0.3 144392  1020 ?        Ss   May28   0:00 nginx: master process /usr/sbin/nginx
www-data  5647  0.0  1.1 145124  3048 ?        S    Jul18   2:53 nginx: worker process
www-data  5648  0.0  0.1 144392   376 ?        S    Jul18   0:00 nginx: cache manager process
root     13134  0.0  0.3   4960   920 pts/0    S+   14:33   0:00 grep --color=auto nginx
root@server7:~#

Ici, la deuxième colonne est l'identifiant du processus. Par exemple, si vous voulez tuer le processus nginx, vous pouvez utiliser la commande kill 5647 . Il est toujours conseillé d'utiliser la commande kill avec SIGTERM plutôt que SIGKILL .

Job de fond

$ gzip extremelylargefile.txt &
$ bg
$ disown %1

Cela permet à un processus de longue durée de continuer une fois que votre shell (terminal, ssh, etc.) est fermé.