103.5 Leçon 1

Certification :

LPIC-1

Version :

5.0

Thème :

103 Commandes GNU et Unix

Objectif :

103.5 Créer, surveiller et arrêter des processus

Leçon :

1 sur 2

Introduction

Chaque fois que nous invoquons une commande, un ou plusieurs processus sont lancés. Un administrateur système compétent doit non seulement créer des processus, mais aussi être capable d’en assurer le suivi et de leur envoyer différents types de signaux lorsque cela est nécessaire. Dans cette leçon, nous allons examiner le contrôle des tâches et la supervision des processus.

Gérer les tâches

Les tâches (jobs) sont des processus qui ont été lancés de manière interactive via un terminal, envoyés en arrière-plan et dont l’exécution n’est pas encore terminée. Vous pouvez obtenir des informations sur les tâches actives sur votre système Linux (ainsi que leur état) en exécutant jobs :

$ jobs

La commande jobs ci-dessus n’a rien affiché, ce qui signifie qu’il n’y a aucune tâche active pour le moment. Créons notre première tâche en lançant une commande qui prend un certain temps pour s’exécuter (la commande sleep avec un paramètre de 60) et — pendant l’exécution — appuyons sur kbd:[Ctrl+Z] :

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

L’exécution de la commande a été arrétée (ou — plus exactement — suspendue) et l’invite de commande est à nouveau disponible. Vous pouvez rechercher à nouveau des tâches et vous verrez maintenant celle qui est suspendue :

$ jobs
[1]+  Stopped                 sleep 60

Voici une explication du résultat :

[1]: Ce numéro correspond à l’identifiant (ID) de la tâche et peut être utilisé — précédé d’un symbole pourcent (%) — pour contrôler l’état de la tâche avec les outils fg, bg et kill (comme on vous le montrera plus tard).
+: Le signe plus indique la tâche actuelle, par défaut (c’est-à-dire la dernière à être suspendue ou envoyée en arrière-plan). La tâche précédente est identifiée par le signe moins (-). Les autres tâches antérieures ne sont pas marquées.
Stopped: Description de l’état de la tâche.
sleep 60: La commande ou la tâche en elle-même.

L’option -l permet d’afficher en plus l’ID du processus (PID) juste avant l’état :

$ jobs -l
[1]+  1114 Stopped                 sleep 60

Voici les autres options disponibles pour jobs :

-n: Affiche uniquement les processus qui ont changé d’état depuis la dernière notification. Les différents états possibles sont : Running (en cours d’exécution), Stopped (arrêté), Terminated (complété) ou Done (fini).
-p: Affiche les ID des processus.
-r: Affiche uniquement les tâches en cours d’exécution.
-s: Affiche uniquement les tâches arrêtées ou suspendues.

Note	Gardez à l’esprit qu’une tâche dispose d’un ID de tâche et d’un ID de processus (PID).

Spécifier une tâche

La commande jobs ainsi que d’autres outils comme fg, bg et kill (que vous verrez dans la section suivante) ont besoin d’une spécification de tâche (ou jobspec) pour agir sur une tâche en particulier. Comme nous venons de le voir, cela peut être - et c’est normalement le cas - l’ID de la tâche précédé de %. Cependant, d’autres spécifications sont également possibles. Voyons cela :

%n

Tâche dont l’identifiant est n :

$ jobs %1
[1]+  Stopped                 sleep 60

%str

Tâche dont la commande commence par str :

$ jobs %sl
[1]+  Stopped                 sleep 60

%?str

Tâche dont la commande contient str :

$ jobs %?le
[1]+  Stopped                 sleep 60

%+ ou %%

Tâche actuelle (celle qui a été lancée en dernier en arrière-plan ou suspendue depuis le premier plan) :

$ jobs %+
[1]+  Stopped                 sleep 60

%-

Tâche précédente (celle qui était %+ avant la tâche actuelle, par défaut) :

$ jobs %-
[1]+  Stopped                 sleep 60

Dans notre cas, étant donné qu’il n’y a qu’une seule tâche, elle est à la fois la plus récente et la précédente.

État d’une tâche : Suspension, premier plan et arrière-plan

Lorsqu’une tâche est en arrière-plan ou qu’elle a été suspendue, nous pouvons lui faire subir l’une des trois actions suivantes :

L’amener au premier plan avec fg :
```
$ fg %1
sleep 60
```
fg fait passer la tâche spécifiée au premier plan et en fait la tâche actuelle. Maintenant nous pouvons attendre qu’elle se termine, la stopper à nouveau avec kbd:[Ctrl+Z] ou la terminer avec kbd:[Ctrl+C].
L’amener en arrière-plan avec bg :
```
$ bg %1
[1]+ sleep 60 &
```
Une fois qu’elle est en arrière plan, la tâche peut être ramenée au premier plan avec fg ou tuée (voir ci-dessous). Notez l’esperluette (&) qui signifie que la tâche a été envoyée en arrière-plan. En fait, vous pouvez également utiliser l’esperluette pour démarrer un processus directement en arrière-plan :
```
$ sleep 100 &
[2] 970
```
En plus de l’ID de la nouvelle tâche ([2]), nous disposons maintenant de son ID de processus (970). Les deux tâches s’exécutent désormais en arrière-plan :
```
$ jobs
[1]-  Running                 sleep 60 &
[2]+  Running                 sleep 100 &
```
Un peu plus tard, la première tâche termine son exécution :
```
$ jobs
[1]-  Done                    sleep 60
[2]+  Running                 sleep 100 &
```
La terminer par le biais d’un signal SIGTERM avec kill :
```
$ kill %2
```
Pour être sûr que la tâche a été terminée, relancez jobs :
```
$ jobs
[2]+  Terminated                 sleep 100
```

Note	Lorsqu’aucune tâche n’est spécifiée, `fg` et `bg` vont agir sur la tâche actuelle par défaut. En revanche, `kill` a toujours besoin d’une spécification de tâche.

Détâcher des tâches : `nohup`

_ Les tâches que nous avons vues dans les sections ci-dessus étaient toutes attachées à la session de l’utilisateur qui les avait lancées. Cela signifie que si la session est terminée, les tâches disparaissent. Cependant, il est possible de détacher les tâches des sessions et de les faire tourner même après la fermeture de la session. Ceci est réalisé grâce à la commande nohup (no hangup, ne pas raccrocher). La syntaxe est la suivante :

nohup COMMAND &

N’oubliez pas que le "&" envoie le processus en arrière-plan et libère le terminal dans lequel vous travaillez.

Détachons la tâche en arrière-plan ping localhost de la session en cours :

$ nohup ping localhost &
[1] 1251
$ nohup: ignoring input and appending output to 'nohup.out'
^C

L’affichage nous montre l’ID de la tâche ([1]) et le PID (1251), suivis d’un message qui nous indique le fichier nohup.out. C’est le fichier par défaut où stdout et stderr seront enregistrés. Maintenant, nous pouvons appuyer sur kbd:[Ctrl+C] pour libérer l’invite de commande, fermer la session, en démarrer une autre et utiliser tail -f pour vérifier si la commande s’exécute et si la sortie est enregistrée dans le fichier par défaut :

$ exit
logout
$ tail -f /home/carol/nohup.out
64 bytes from localhost (::1): icmp_seq=3 ttl=64 time=0.070 ms
64 bytes from localhost (::1): icmp_seq=4 ttl=64 time=0.068 ms
64 bytes from localhost (::1): icmp_seq=5 ttl=64 time=0.070 ms
^C

Tip	Au lieu d’utiliser le fichier par défaut `nohup.out`, vous auriez pu spécifier un fichier de sortie de votre choix avec `nohup ping localhost > /chemin/vers/votre/fichier &`.

Si nous voulons terminer le processus, nous devons spécifier son PID :

$ kill 1251

Surveiller les processus

Un processus ou une tâche est une instance d’un programme en cours d’exécution. Ainsi, on crée de nouveaux processus chaque fois que l’on tape des commandes dans le terminal.

La commande watch exécute un programme à intervalles réguliers (2 secondes par défaut) et nous permet de garder à l’œil l’évolution de la sortie du programme dans le temps. Par exemple, nous pouvons surveiller les variations de la charge moyenne au fur et à mesure que des processus sont exécutés en tapant watch uptime :

Every  2.0s: uptime          debian: Tue Aug 20 23:31:27 2019

 23:31:27 up 21 min,  1 user,  load average: 0.00, 0.00, 0.00

La commande s’exécute jusqu’à ce qu’elle soit interrompue, nous devons donc l’arrêter avec kbd:[Ctrl+C]. Nous obtenons deux lignes en sortie : la première correspond à watch et nous indique la fréquence d’exécution de la commande (Every 2.0s : uptime), la commande ou le programme à surveiller (uptime) ainsi que le nom d’hôte et la date (debian : Tue Aug 20 23:31:27 2019). La deuxième ligne de sortie est celle de uptime et comprend l’heure (23:31:27), la durée de fonctionnement du système (up 21 min), le nombre d’utilisateurs actifs (1 user) et la charge moyenne du système ou le nombre de processus en exécution ou en état d’attente pour les 1, 5 et 15 dernières minutes (load average : 0.00, 0.00, 0.00).

De même, vous pouvez vérifier l’utilisation de la mémoire lors de la création de nouveaux processus avec watch free :

Every  2.0s: free            debian: Tue Aug 20 23:43:37 2019

 23:43:37 up 24 min,  1 user,  load average: 0.00, 0.00, 0.00
              total        used        free      shared  buff/cache   available
Mem:       16274868      493984    14729396       35064     1051488    15462040
Swap:      16777212           0    16777212

Pour modifier l’intervalle de mise à jour de watch, utilisez les options -n ou --interval avec le nombre de secondes en argument :

$ watch -n 5 free

A présent, la commande free s’exécute toutes les 5 secondes.

Pour plus d’informations sur les options de uptime, free et watch, reportez-vous à leurs pages de manuel en ligne.

Note	Les informations fournies par `uptime` et `free` sont également intégrées dans des outils plus élaborés comme `top` et `ps` (voir ci-dessous).

Envoyer des signaux aux processus : `kill`

Chaque processus dispose d’un identifiant de processus unique ou PID. Une façon de trouver le PID d’un processus consiste à utiliser la commande pgrep suivie du nom du processus :

$ pgrep sleep
1201

Note	L’identifiant d’un processus peut également être obtenu par la commande `pidof` (par exemple `pidof sleep`).

Tout comme la commande pgrep, la commande pkill termine un processus en se basant sur son nom :

$ pkill sleep
[1]+  Terminated              sleep 60

La commande killall permet de terminer plusieurs instances d’un même processus :

$ sleep 60 &
[1] 1246
$ sleep 70 &
[2] 1247
$ killall sleep
[1]-  Terminated              sleep 60
[2]+  Terminated              sleep 70

pkill et killall fonctionnent de la même manière que kill en envoyant un signal au(x) processus spécifié(s). En l’absence de signal, c’est le signal par défaut SIGTERM qui est envoyé. Par contre, kill ne prend comme argument qu’un identifiant de tâche ou de processus.

Les signaux peuvent être spécifiés par :

Le nom :
```
$ kill -SIGHUP 1247
```
Le nombre :
```
$ kill -1 1247
```
L’option :
```
$ kill -s SIGHUP 1247
```

Pour faire fonctionner kill de la même manière que pkill ou killall (et nous épargner la recherche préalable des PIDs), nous pouvons utiliser la substitution de commande :

$ kill -1 $(pgrep sleep)

Comme vous le savez déjà, une syntaxe alternative est kill -1 $(pgrep sleep).

Tip	Pour une liste exhaustive de tous les signaux `kill` et de leurs codes, tapez `kill -l` dans le terminal. Utilisez `-SIGKILL` (`-9` ou `-s SIGKILL`) pour tuer les processus récalcitrants en cas d’échec de tous les autres signaux.

`top` et `ps`

Lorsqu’il s’agit de surveiller un processus, top et ps sont deux outils indispensables. Le premier produit des résultats dynamiques, tandis que le second le fait de manière statique. Quoi qu’il en soit, ce sont là deux excellents outils pour avoir une vue d’ensemble sur tous les processus du système.

Interagir avec `top`

Pour lancer top, tapez simplement top :

$ top

top - 11:10:29 up  2:21,  1 user,  load average: 0,11, 0,20, 0,14
Tasks:  73 total,   1 running,  72 sleeping,   0 stopped,   0 zombie
%Cpu(s):  0,0 us,  0,3 sy,  0,0 ni, 99,7 id,  0,0 wa,  0,0 hi,  0,0 si,  0,0 st
KiB Mem :  1020332 total,   909492 free,    38796 used,    72044 buff/cache
KiB Swap:  1046524 total,  1046524 free,        0 used.   873264 avail Mem

   PID USER      PR  NI    VIRT    RES    SHR S %CPU %MEM     TIME+ COMMAND
   436 carol     20   0   42696   3624   3060 R  0,7  0,4   0:00.30 top
     4 root      20   0       0      0      0 S  0,3  0,0   0:00.12 kworker/0:0
   399 root      20   0   95204   6748   5780 S  0,3  0,7   0:00.22 sshd
     1 root      20   0   56872   6596   5208 S  0,0  0,6   0:01.29 systemd
     2 root      20   0       0      0      0 S  0,0  0,0   0:00.00 kthreadd
     3 root      20   0       0      0      0 S  0,0  0,0   0:00.02 ksoftirqd/0
     5 root       0 -20       0      0      0 S  0,0  0,0   0:00.00 kworker/0:0H
     6 root      20   0       0      0      0 S  0,0  0,0   0:00.00 kworker/u2:0
     7 root      20   0       0      0      0 S  0,0  0,0   0:00.08 rcu_sched
     8 root      20   0       0      0      0 S  0,0  0,0   0:00.00 rcu_bh
     9 root      rt   0       0      0      0 S  0,0  0,0   0:00.00 migration/0
    10 root       0 -20       0      0      0 S  0,0  0,0   0:00.00 lru-add-drain
    (...)

top permet une certaine interaction à l’utilisateur. La sortie par défaut est classée par ordre décroissant du pourcentage de temps CPU utilisé par chaque processus. Ce comportement peut être modifié en appuyant sur les touches suivantes à partir de top :

M: Classer par utilisation de mémoire.
N: Classer par numéro de PID.
T: Classer par temps d’exécution.
P: Classer par pourcentage d’utilisation CPU.

Tip	Pour basculer entre le classement décroissant et croissant, il suffit d’appuyer sur `R`.

Voici d’autres raccourcis intéressants pour interagir avec top :

? ou h: Aide.
k: Envoyer un signal à un processus. top vous demandera le PID du processus à tuer ainsi que le signal à envoyer (SIGTERM ou 15 par défaut).
r: Modifier la priorité d’un processus (renice). top vous demandera la valeur de nice. Les valeurs possibles vont de -20 à 19, mais seul le super-utilisateur (root) peut définir une valeur négative ou inférieure à la valeur actuelle.
u: Afficher les processus d’un utilisateur en particulier (par défaut, les processus de tous les utilisateurs sont affichés).
c: Affiche les chemins absolus des programmes et distingue les processus en espace utilisateur de ceux du noyau (entre crochets).
V: Affichage en arborescence hiérarchique des processus.
t et m: Modifie l’aspect des relevés respectifs du CPU et de la mémoire selon un cycle en quatre étapes : les deux premières pressions affichent des barres de progression, la troisième masque ces barres et la quatrième les fait réapparaître.
W: Sauvegarder les paramètres de configuration dans ~/.toprc.

Tip	Une version plus sophistiquée et plus conviviale de `top` est `htop`. Une autre alternative, peut-être plus exhaustive, est `atop`. Si ces outils ne sont pas déjà installés sur votre système, utilisez votre gestionnaire de paquets pour les installer et essayez-les.

Petite explication de l’affichage de `top`.

Les informations fournies par top sont réparties en deux zones : la zone de synthèse et la zone des tâches.

La zone de synthèse de `top`

La zone de synthèse comprend les cinq lignes du haut et nous fournit les informations suivantes :

top - 11:10:29 up 2:21, 1 user, load average: 0,11, 0,20, 0,14
- l’heure actuelle (au format 24 heures) : 11:20:29
- uptime (durée de fonctionnement du système) : up 2:21
- nombre d’utilisateurs connectés et charge moyenne du CPU pour les 1, 5 et 15 dernières minutes, respectivement : load average: 0,11, 0,20, 0,14
Tasks: 73 total, 1 running, 72 sleeping, 0 stopped, 0 zombie (informations sur les processus)
- nombre total de processus en mode actif : 73 total
- en cours d’exécution : 1 running
- en veille (en attente de reprendre l’exécution) : 72 sleeping
- arrêtés (par un signal de contrôle de tâche) : 0 stopped
- zombie (ceux qui ont terminé leur exécution mais qui attendent que leur processus parent les supprime de la table des processus) :
%Cpu(s): 0,0 us, 0,3 sy, 0,0 ni, 99,7 id, 0,0 wa, 0,0 hi, 0,0 si, 0,0 st (pourcentage du temps CPU passé sur…)
- les processus utilisateurs : 0,0 us
- les processus du système/noyau : 0,4 sy
- les processus définis à une valeur nice — plus la valeur de nice est élevée, plus la priorité est faible : 0,0 ni
- rien — temps d’inactivité du CPU : 99,7 id
- les processus en attente d’opérations d’E/S : 0,0 wa
- les processus qui répondent aux interruptions matérielles - périphériques qui envoient au processeur des signaux qui requièrent son attention : 0,0 hi
- les processus qui répondent aux interruptions logicielles : 0,0 si
- les processus qui répondent aux tâches d’autres machines virtuelles dans un environnement virtuel, d’où une perte de temps : 0,0 st
KiB Mem : 1020332 total, 909492 free, 38796 used, 72044 buff/cache (informations sur la mémoire en kilo-octets)
- la quantité totale de mémoire : 1020332 total
- la mémoire non utilisée : 909492 free
- la mémoire utilisée : 38796 used
- la mémoire mise en tampon et dans le cache pour éviter les accès excessifs au disque : 72044 buff/cache
  
  Notez comment le total est la somme des trois autres valeurs — free, used et buff/cache — (environ 1 Go dans notre cas).
KiB Swap: 1046524 total, 1046524 free, 0 used. 873264 avail Mem (informations sur le swap en kilo-octets)
- la quantité totale d’espace swap : 1046524 total
- l’espace swap non utilisé : 1046524 free
- l’espace swap utilisé : 0 used
- la quantité de mémoire swap qui peut être allouée aux processus sans provoquer davantage de swapping : 873264 avail Mem

La zone des tâches dans `top` : les champs et les colonnes

En dessous de la zone de synthèse se trouve la zone des tâches, où l’on trouve une série de champs et de colonnes qui fournissent des informations sur les processus en cours d’exécution :

PID: Identifiant du processus.
USER: Utilisateur ayant invoqué la commande qui a généré le processus.
PR: Priorité du processus pour le noyau.
NI: Valeur nice du processus. Les valeurs inférieures ont une priorité plus élevée que les valeurs supérieures.
VIRT: Quantité totale de mémoire utilisée par le processus (swap compris).
RES: Mémoire RAM utilisée par le processus.
SHR: Mémoire partagée par le processus avec d’autres processus.
S: État du processus. Les valeurs incluent : S (sleep interruptible — attente de la fin d’un événement), R (runnable — soit en cours d’exécution, soit dans la file d’attente pour être exécuté) ou Z (zombie — processus enfants terminés dont les structures de données n’ont pas encore été retirées de la table des processus).
%CPU: Pourcentage de CPU utilisé par le processus.
%MEM: Pourcentage de RAM utilisée par le processus, c’est-à-dire la valeur RES exprimée en pourcents.
TIME+: Durée totale de l’activité du processus.
COMMAND: Nom de la commande/du programme qui a généré le processus.

Afficher les processus en mode statique : `ps`

Comme nous l’avons dit plus haut, ps affiche un instantané des processus. Pour voir tous les processus dans un terminal (tty), tapez ps a :

$ ps a
  PID TTY      STAT   TIME COMMAND
  386 tty1     Ss+    0:00 /sbin/agetty --noclear tty1 linux
  424 tty7     Ssl+   0:00 /usr/lib/xorg/Xorg :0 -seat seat0 (...)
  655 pts/0    Ss     0:00 -bash
 1186 pts/0    R+     0:00 ps a
 (...)

Explication de la syntaxe des options et de l’affichage de `ps`

En ce qui concerne les options, ps accepte trois styles différents : BSD, UNIX et GNU. Voyons le fonctionnement de chacun de ces styles lors de la présentation d’informations sur un ID de processus donné :

BSD

Les options ne suivent pas un tiret initial :

$ ps p 811
  PID TTY      STAT   TIME COMMAND
  811 pts/0    S      0:00 -su

UNIX

Les options suivent un tiret initial :

$ ps -p 811
  PID TTY          TIME CMD
  811 pts/0    00:00:00 bash

GNU

Les options suivent un double tiret initial :

$ ps --pid 811
  PID TTY          TIME CMD
  811 pts/0    00:00:00 bash

Dans les trois cas, ps renvoie des informations sur le processus dont le PID est 811 — en l’occurrence bash.

De même, on pourra utiliser ps pour rechercher les processus lancés par un utilisateur donné :

ps U carol (BSD)
ps -u carol (UNIX)
ps --user carol (GNU)

Vérifions les processus lancés par carol :

$ ps U carol
  PID TTY      STAT   TIME COMMAND
  811 pts/0    S      0:00 -su
  898 pts/0    R+     0:00 ps U carol

Elle a lancé deux processus : bash (-su) et ps (ps U carol). La colonne STAT nous indique l’état du processus (voir ci-dessous).

Nous pouvons tirer le meilleur parti de ps en combinant certaines de ses options. Une commande très utile (avec une sortie similaire à celle de top) est ps aux (style BSD). Dans ce cas, les processus de tous les shells (et pas seulement le shell courant ) sont affichés. Voici la signification des options :

a: Affiche les processus attachés à un tty ou terminal.
u: Afficher le format orienté utilisateur.
x: Affiche les processus qui ne sont pas attachés à un tty ou terminal.

$ ps aux
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.1 204504  6780 ?        Ss   14:04   0:00 /sbin/init
root         2  0.0  0.0      0     0 ?        S    14:04   0:00 [kthreadd]
root         3  0.0  0.0      0     0 ?        S    14:04   0:00 [ksoftirqd/0]
root         5  0.0  0.0      0     0 ?        S<   14:04   0:00 [kworker/0:0H]
root         7  0.0  0.0      0     0 ?        S    14:04   0:00 [rcu_sched]
root         8  0.0  0.0      0     0 ?        S    14:04   0:00 [rcu_bh]
root         9  0.0  0.0      0     0 ?        S    14:04   0:00 [migration/0]
(...)

Voici une explication des colonnes :

USER: Propriétaire du processus.
PID: Identifiant du processus.
%CPU: Pourcentage d’utilisation du CPU.
%MEM: Pourcentage d’utilisation de la mémoire physique.
VSZ: Mémoire virtuelle du processus en Kio.
RSS: Mémoire physique hors swap utilisée par le processus en Kio.
TT: Terminal (tty) qui contrôle le processus.
STAT: Code représentant l’état du processus. En dehors de S, R et Z (que nous avons vus en décrivant la sortie de top), d’autres valeurs possibles incluent : D (uninterruptible sleep — généralement en attente d’E/S), T (stopped — normalement par un signal de contrôle). Quelques modificateurs supplémentaires incluent : < (haute priorité par rapport aux autres processus), N (basse priorité par rapport aux autres processus), ou + (dans le groupe de processus de premier plan).
STARTED: Heure à laquelle le processus a démarré.
TIME: Temps CPU accumulé.
COMMAND: Commande qui a démarré le processus.

Exercices guidés

oneko est un programme amusant qui affiche un chat en train de poursuivre le curseur de votre souris. S’il n’est pas déjà installé sur votre PC, installez-le en utilisant le gestionnaire de paquets de votre distribution. Nous allons l’utiliser pour étudier le contrôle des tâches.
- Lancez le programme. Comment faites-vous cela ?
- Déplacez le curseur de la souris pour voir comment le chat le prend en chasse. Maintenant, suspendez le processus. Comment faites-vous cela ? Quel est le résultat ?
- Vérifiez le nombre de tâches que vous avez actuellement. Qu’est-ce que vous devez taper ? Quel est le résultat ?
- Maintenant, envoyez-le en arrière-plan en spécifiant son ID de tâche. Quel est le résultat ? Comment pouvez-vous dire que la tâche est exécutée en arrière-plan ?
- Enfin, terminez la tâche en spécifiant son ID. Qu’est-ce que vous devez taper ?
Découvrez les PIDs de tous les processus engendrés par le serveur web Apache HTTPD (apache2) à l’aide de deux commandes distinctes :
Terminez tous les processus apache2 sans utiliser leurs PIDs et en utilisant deux commandes distinctes :
Supposons que vous devez mettre fin à toutes les instances de apache2 et que vous n’avez pas le temps de trouver leurs PIDs. Comment pouvez-vous faire cela en utilisant kill avec le signal SIGTERM par défaut en une seule ligne :
Démarrez top et interagissez avec lui en effectuant ce qui suit :
- Afficher une vue arborescente des processus :
- Afficher les chemins complets des processus en différenciant l’espace utilisateur et l’espace noyau :
Tapez la commande ps pour afficher tous les processus démarrés par l’utilisateur du serveur web Apache HTTPD (www-data) :
- En utilisant la syntaxte BSD :
- En utilisant la syntaxe UNIX :
- En utilisant la syntaxe GNU :

Exercices d’approfondissement

Le signal SIGHUP peut être utilisé comme un moyen de redémarrer certains démons. Avec le serveur web Apache HTTPD — par exemple — l’envoi de SIGHUP au processus parent (celui démarré par init) tue ses enfants. Le processus parent, cependant, relit ses fichiers de configuration, rouvre les fichiers journaux et crée un nouvel ensemble de processus enfants. Effectuez les tâches suivantes :
- Démarrez le serveur web :
- Assurez-vous de connaître le PID du processus parent :
- Faites redémarrer le serveur web Apache HTTPD en envoyant le signal SIGHUP à son processus parent :
- Vérifiez que le processus parent n’a pas été tué et que de nouveaux processus enfants ont été créés :
Bien que statique à la base, la sortie de ps peut être rendue dynamique en combinant ps et watch. Nous allons surveiller le serveur web Apache HTTPD pour détecter les nouvelles connexions. Avant d’effectuer les tâches décrites ci-dessous, il est recommandé de lire la description de la directive MaxConnectionsPerChild dans Apache MPM Common Directives.
- Ajoutez la directive MaxConnectionsPerChild avec une valeur de 1 dans le fichier de configuration de apache2 — dans la famille Debian et dérivées on le trouve dans /etc/apache2/apache2.conf ; dans la famille CentOS, c’est dans /etc/httpd/conf/httpd.conf. N’oubliez pas de redémarrer apache2 pour que les changements soient pris en compte.
- Tapez une commande qui utilise watch, ps et grep pour les connexions apache2.
- Maintenant, ouvrez un navigateur web ou utilisez un navigateur en ligne de commande comme lynx pour établir une connexion au serveur web via son adresse IP. Que voyez-vous dans l’affichage de watch ?
Comme vous l’avez vu, dans sa configuration par défaut, top trie les tâches par pourcentage d’utilisation du CPU par ordre décroissant (les valeurs les plus élevées en haut). Ce comportement peut être modifié avec les raccourcis interactifs M (utilisation de la mémoire), N (identifiant unique du processus), T (temps d’exécution) et P (pourcentage du temps CPU). Cependant, vous pouvez également trier la liste des tâches à votre convenance en lançant top avec l’option -o (pour plus d’informations, consultez la page man de top). Maintenant, effectuez les tâches suivantes :
- Lancez top de façon à ce que les tâches soient triées par utilisation de la mémoire :
- Vérifiez si vous avez tapé la bonne commande en mettant la colonne mémoire en surbrillance :
ps dispose également d’une option o pour spécifier les colonnes que vous souhaitez afficher. Examinez cette alternative et effectuez les tâches suivantes :
- Lancez ps de façon à ce que seules les informations sur l’utilisateur, le pourcentage de mémoire utilisée, le pourcentage de temps CPU utilisé et la commande complète soient affichées :
- Maintenant, lancez ps pour que les seules informations affichées soient celles de l’utilisateur et le nom des programmes qu’il utilise :

Résumé

Dans cette leçon, vous avez découvert les tâches et le contrôle des tâches. Voici les notions et les concepts importants que vous devez retenir :

Les tâches sont des processus qui sont envoyés en arrière-plan.
En dehors de l'ID du processus, un ID de tâche est affecté aux tâches lors de leur création.
Pour contrôler les tâches, il faut une spécification de tâche (jobspec).
Les tâches peuvent être mises au premier plan, envoyées à l’arrière-plan, suspendues et terminées (ou tuées).
Une tâche peut être détachée du terminal et de la session dans laquelle elle a été créée.

De même, nous avons également abordé le concept de processus et de surveillance des processus. Voici les idées principales :

Les processus sont des programmes en cours d’exécution.
Les processus peuvent être surveillés.
Différents outils nous permettent de connaître l’ID des processus et de leur envoyer des signaux pour les arrêter.
Les signaux peuvent être spécifiés par un nom (comme -SIGTERM), un nombre (comme -15) ou une option (comme -s SIGTERM).
top et ps sont très efficaces lorsqu’il s’agit de surveiller des processus. La sortie du premier est dynamique et se met constamment à jour ; de son côté, ps affiche les résultats de manière statique.

Les commandes suivantes ont été abordées dans cette leçon :

jobs: Affiche les tâches actives et leur état.
sleep: Retarder pour une durée déterminée.
fg: Amener la tâche au premier plan.
bg: Déplacer la tâche vers l’arrière-plan.
kill: Envoyer un signal à la tâche.
nohup: Détacher la tâche de la session / du terminal.
exit: Quitter le shell en cours.
tail: Afficher les dernières lignes d’un fichier.
watch: Exécuter une commande de manière répétée (cycle de 2 secondes par défaut).
uptime: Afficher la durée de fonctionnement du système, le nombre d’utilisateurs actifs et la charge moyenne du système.
free: Afficher l’utilisation de la mémoire.
pgrep: Trouver l’ID d’un processus en fonction du nom.
pidof: Trouver l’ID d’un processus en fonction du nom.
pkill: Envoyer un signal à un processus par son nom.
killall: Envoyer un signal à un ou plusieurs processus par leur nom.
top: Afficher les processus Linux.
ps: Afficher un instantané des processus en cours.

Réponses aux exercices guidés

oneko est un programme amusant qui affiche un chat en train de poursuivre le curseur de votre souris. S’il n’est pas déjà installé sur votre PC, installez-le en utilisant le gestionnaire de paquets de votre distribution. Nous allons l’utiliser pour étudier le contrôle des tâches.
- Lancez le programme. Comment faites-vous cela ?
  
  En tapant oneko dans le terminal.
- Déplacez le curseur de la souris pour voir comment le chat le prend en chasse. Maintenant, suspendez le processus. Comment faites-vous cela ? Quel est le résultat ?
  
  En appuyant sur la combinaison de touches kbd:[Ctrl+z]:
  [1]+ Stopped oneko
- Vérifiez le nombre de tâches que vous avez actuellement. Qu’est-ce que vous devez taper ? Quel est le résultat ?
  $ jobs [1]+ Stopped oneko
- Maintenant, envoyez-le en arrière-plan en spécifiant son ID de tâche. Quel est le résultat ? Comment pouvez-vous dire que la tâche est exécutée en arrière-plan ?
  $ bg %1 [1]+ oneko &
  Le chat se déplace à nouveau.
- Enfin, terminez la tâche en spécifiant son ID. Qu’est-ce que vous devez taper ?
  $ kill %1
Découvrez les PIDs de tous les processus engendrés par le serveur web Apache HTTPD (apache2) à l’aide de deux commandes distinctes :
```
$ pgrep apache2
```
ou
```
$ pidof apache2
```
Terminez tous les processus apache2 sans utiliser leurs PIDs et en utilisant deux commandes distinctes :
```
$ pkill apache2
```
ou
```
$ killall apache2
```
Supposons que vous devez mettre fin à toutes les instances de apache2 et que vous n’avez pas le temps de trouver leurs PIDs. Comment pouvez-vous faire cela en utilisant kill avec le signal SIGTERM par défaut en une seule ligne :
```
$ kill $(pgrep apache2)
$ kill `pgrep apache2`
```
ou
```
$ kill $(pidof apache2)
$ kill `pidof apache2`
```
Note

Puisque SIGTERM (15) est le signal par défaut, ce n’est pas la peine de passer des options à kill.
Démarrez top et interagissez avec lui en effectuant ce qui suit :
- Afficher une vue arborescente des processus :
  
  Taper V.
- Afficher les chemins complets des processus en différenciant l’espace utilisateur et l’espace noyau :
  
  Taper c.
Tapez la commande ps pour afficher tous les processus démarrés par l’utilisateur du serveur web Apache HTTPD (www-data) :
- En utilisant la syntaxte BSD :
  $ ps U www-data
- En utilisant la syntaxe UNIX :
  $ ps -u www-data
- En utilisant la syntaxe GNU :
  $ ps --user www-data

Réponses aux exercices d’approfondissement

Le signal SIGHUP peut être utilisé comme un moyen de redémarrer certains démons. Avec le serveur web Apache HTTPD — par exemple — l’envoi de SIGHUP au processus parent (celui démarré par init) tue ses enfants. Le processus parent, cependant, relit ses fichiers de configuration, rouvre les fichiers journaux et crée un nouvel ensemble de processus enfants. Effectuez les tâches suivantes :
- Démarrez le serveur web :
  $ sudo systemctl start apache2
- Assurez-vous de connaître le PID du processus parent :
  $ ps aux | grep apache2
  Le processus parent est celui lancé par l’utilisateur root. Dans notre cas, celui dont le PID est 1653.
- Faites redémarrer le serveur web Apache HTTPD en envoyant le signal SIGHUP à son processus parent :
  $ sudo kill -SIGHUP 1653
- Vérifiez que le processus parent n’a pas été tué et que de nouveaux processus enfants ont été créés :
  $ ps aux | grep apache2
  Maintenant vous devriez voir le processus parent apache2 avec deux nouveaux processus enfants.
Bien que statique à la base, la sortie de ps peut être rendue dynamique en combinant ps et watch. Nous allons surveiller le serveur web Apache HTTPD pour détecter les nouvelles connexions. Avant d’effectuer les tâches décrites ci-dessous, il est recommandé de lire la description de la directive MaxConnectionsPerChild dans Apache MPM Common Directives.
- Ajoutez la directive MaxConnectionsPerChild avec une valeur de 1 dans le fichier de configuration de apache2 — dans la famille Debian et dérivées on le trouve dans /etc/apache2/apache2.conf ; dans la famille CentOS, c’est dans /etc/httpd/conf/httpd.conf. N’oubliez pas de redémarrer apache2 pour que les changements soient pris en compte.
  
  La ligne à inclure dans le fichier de configuration est MaxConnectionsPerChild 1. Une façon de redémarrer le serveur web est de taper sudo systemctl restart apache2.
- Tapez une commande qui utilise watch, ps et grep pour les connexions apache2.
  $ watch 'ps aux | grep apache2'
  ou
  $ watch "ps aux | grep apache2"
- Maintenant, ouvrez un navigateur web ou utilisez un navigateur en ligne de commande comme lynx pour établir une connexion au serveur web via son adresse IP. Que voyez-vous dans l’affichage de watch ?
  
  Un des processus enfants appartenant à www-data disparaît.
Comme vous l’avez vu, dans sa configuration par défaut, top trie les tâches par pourcentage d’utilisation du CPU par ordre décroissant (les valeurs les plus élevées en haut). Ce comportement peut être modifié avec les raccourcis interactifs M (utilisation de la mémoire), N (identifiant unique du processus), T (temps d’exécution) et P (pourcentage du temps CPU). Cependant, vous pouvez également trier la liste des tâches à votre convenance en lançant top avec l’option -o (pour plus d’informations, consultez la page man de top). Maintenant, effectuez les tâches suivantes :
- Lancez top de façon à ce que les tâches soient triées par utilisation de la mémoire :
  $ top -o %MEM
- Vérifiez si vous avez tapé la bonne commande en mettant la colonne mémoire en surbrillance :
  
  Appuyez sur x.
ps dispose également d’une option o pour spécifier les colonnes que vous souhaitez afficher. Examinez cette alternative et effectuez les tâches suivantes :
- Lancez ps de façon à ce que seules les informations sur l’utilisateur, le pourcentage de mémoire utilisée, le pourcentage de temps CPU utilisé et la commande complète soient affichées :
  $ ps o user,%mem,%cpu,cmd
- Maintenant, lancez ps pour que les seules informations affichées soient celles de l’utilisateur et le nom des programmes qu’il utilise :
  $ ps o user,comm