Comment Tuer un Processus sous Linux : Terminer des Processus avec les Commandes Kill et Killall

Lors de la gestion d'un serveur Linux, vous pouvez rencontrer des processus non reactifs ou dysfonctionnels qui consomment des ressources systeme, ralentissent votre travail et impactent negativement d'autres processus en cours. Savoir comment tuer un processus sous Linux est essentiel pour une administration systeme efficace.

Cet article vous guidera a travers diverses methodes pour terminer les processus non reactifs sous Linux. Que vous soyez debutant ou administrateur experimente, ces methodes vous aideront a gerer les processus efficacement dans un environnement Linux.

Qu'est-ce que le processus kill sous Linux ?

La commande kill sous Linux termine un processus en cours, non reactif ou dysfonctionnel de maniere controlee et securisee.

Comment Localiser un Processus sous Linux

Avant de terminer un processus, il est crucial de l'identifier correctement. Heureusement, le systeme Linux fournit divers outils a cet effet. Les commandes ps et top sont parmi les plus courantes.

La commande ps affiche un instantane de tous les processus en cours, vous permettant de trouver l'ID (PID) d'un processus specifique. Voici un format de base de la commande ps :

```bash

ps [options]

```

Les options les plus courantes a combiner avec la commande ps sont :

- `-a` : affiche les processus pour tous les utilisateurs.

- `-u` : affiche les processus de l'utilisateur actuel.

- `-x` : inclut les processus sans terminal.

Pour rendre la liste plus specifique, ajoutez la commande grep. Par exemple, la commande suivante affichera tous les processus Java en cours :

```bash

ps -aux | grep java

```

D'autre part, la commande top offre une vue dynamique de tous les processus en cours sous Linux et leur utilisation des ressources. Elle ne necessite pas d'arguments ou d'options supplementaires pour son utilisation principale.

Lorsque ps et top ne sont pas assez specifiques, pidof et pgrep offrent des capacites de recherche plus ciblees.

La commande pidof trouve le PID d'un processus par son nom. Voici le format de base de la commande :

```bash

pidof [opciones] [nombreproceso]

```

Par exemple, `pidof nginx` trouve le PID des processus NGINX. Certaines options peuvent etre incluses, comme :

- `-c` : assure que seuls les PIDs du repertoire racine actuel sont retournes.

- `-o` : omet les PIDs specifies des resultats.

- `-s` : retourne un seul PID, typiquement le plus ancien, parmi les processus correspondants.

La commande pgrep offre un mecanisme de recherche plus flexible par nom ou autres proprietes. Utilisez le format suivant :

```bash

pgrep [opciones] [patrón]

```

Par exemple, `pgrep -u nomutilisateur` localise les processus executes par un utilisateur specifique. Vous pouvez ajouter ces options pour filtrer la sortie :

- `-n` : retourne uniquement l'instance la plus recente parmi les processus correspondants.

- `-o` : retourne uniquement l'instance la plus ancienne parmi les processus correspondants.

- `-u` : correspond aux processus appartenant a l'utilisateur specifie.

Signaux de la Commande kill

Apres avoir identifie quel processus terminer, l'etape suivante est d'envoyer un signal approprie en utilisant la commande kill. Chaque type de signal sert un objectif different et affecte la facon dont un processus se termine.

Pour voir tous les signaux disponibles, utilisez la commande suivante :

```bash

kill -l

```

Cela liste tous les types de signaux de processus Linux, incluant :

- `SIGTERM (15)` : c'est la methode par defaut et la plus sure pour terminer un processus en cours sous Linux. Elle permet au processus de se terminer proprement.

- `SIGKILL (9)` : ce signal arrete immediatement tout processus principal ou d'arriere-plan sans lui permettre de faire le menage.

- `SIGSTOP (19)` : met en pause un processus actuel sans le terminer.

- `SIGHUP (1)` : ce signal indique que le terminal de l'utilisateur s'est deconnecte, entrainant souvent la terminaison du processus.

- `SIGINT (2)` : ce signal interrompt un processus, typiquement envoye depuis la combinaison de touches Ctrl+C.

Lors de l'utilisation des signaux kill, vous pouvez specifier le nom du signal ou sa valeur numerique. Il est crucial de choisir le bon signal kill en fonction du scenario et de l'impact souhaite sur le processus.

Par exemple, le signal SIGTERM est prefere pour un controle securise des processus sous Linux, permettant aux processus de sauvegarder leur etat et de quitter proprement. SIGKILL, bien que pratique, devrait etre utilise avec parcimonie car il peut entrainer une perte ou une corruption de donnees.

Comment Tuer un Processus sous Linux

Apres avoir compris les signaux, explorons les methodes pour tuer un processus en cours sous Linux. Si vous utilisez un serveur prive virtuel (VPS), accedez au serveur avec un client SSH, comme PuTTY.

Les clients VPS de Holy peuvent utiliser notre terminal de navigateur integre pour une terminaison efficace des processus. Disponible pour tous les plans d'hebergement VPS, cet outil fournit un moyen pratique de gerer votre serveur directement depuis le navigateur.

Comment Tuer un Processus en Utilisant le VPS de Holy

Voici comment vous pouvez tuer un processus via hPanel :

1. Connectez-vous a hPanel et allez dans la section VPS.

2. Selectionnez le serveur que vous souhaitez gerer et accedez a l'onglet d'acces SSH. Vous trouverez le nom d'utilisateur et le mot de passe SSH necessaires pour entrer dans le terminal.

3. Cliquez sur le bouton Terminal du Navigateur. Cela ouvrira une nouvelle fenetre de terminal dans un nouvel onglet.

4. Connectez-vous au serveur en tapant les identifiants SSH obtenus.

5. Apres vous etre connecte, vous pouvez utiliser la commande kill pour terminer les processus. Par exemple :

```bash

kill 63772

```

Ou 63772 est le PID du processus que vous souhaitez fermer. Vous pouvez egalement utiliser d'autres methodes fournies dans les sections suivantes dans le terminal du navigateur Holy.

Une fois termine, accedez au bouton flottant Masquer/Afficher la barre de controle et cliquez sur Deconnecter pour arreter la connexion.

Comment Tuer un Processus en Utilisant la Commande kill avec un PID

Tuer un seul processus sous Linux est simple lorsque vous connaissez son PID. Executez la commande `kill [PID]`, par exemple :

```bash

kill 123

45

```

Cela enverra un signal SIGTERM au processus avec le PID 12345, tentant de le terminer proprement. C'est utile pour tuer un processus d'arriere-plan sous Linux.

Si le processus ne se termine pas avec le SIGTERM par defaut, vous devrez peut-etre forcer la terminaison. Cela se fait en ajoutant l'option `-9`, qui envoie un signal SIGKILL. Par exemple :

```bash

kill -9 12345

```

Comment Tuer Plusieurs Processus

Vous pouvez tuer plusieurs processus a la fois sous Linux en utilisant la meme commande kill. Passez plusieurs PIDs a la commande, par exemple :

```bash

kill 12345 67890 13579

```

Cela envoie simultanement un signal de terminaison aux PIDs 12345, 67890 et 13579.

Dans les situations ou vous devez tuer des processus avec des caracteristiques similaires, vous pouvez utiliser des jokers avec des commandes comme pgrep. Par exemple :

```bash

kill $(pgrep patrón)

```

Cette commande tuera tous les processus correspondant au modele donne.

Comment Tuer un Processus en Utilisant la Commande pkill

La commande pkill sous Linux offre une approche plus flexible pour tuer des processus par nom ou autres caracteristiques. Elle est avantageuse lorsque vous ne connaissez pas un PID specifique.

Pour forcer la terminaison d'un processus par nom sous Linux, executez `pkill [nomprocessus]`. Par exemple :

```bash

pkill apache

```

Cette commande terminera tous les processus contenant le nom apache.

De plus, vous pouvez utiliser les options suivantes avec pkill :

- `-u [nomutilisateur]` : tue les processus appartenant a un utilisateur specifique.

- `-t [terminal]` : tue les processus attaches a un terminal specifique.

- `-l` : fournit une liste detaillee des processus avec le PID.

Utilisez pkill avec precaution, car il peut affecter plusieurs processus. Par exemple, si vous avez des processus nommes apache et apache-helper, executer `pkill apache` terminera les deux. Assurez-vous toujours de cibler le nom exact du processus pour eviter des interruptions non desirees.

### Comment Tuer un Processus en Utilisant la Commande killall

La commande killall est similaire a pkill mais a une methode distincte de terminaison de processus sous Linux.

Tandis que pkill est efficace pour tuer des processus bases sur une correspondance partielle du nom, la commande killall requiert le nom de correspondance exact du processus. Cela rend killall plus specifique et moins susceptible de terminer des processus non voulus.

Pour utiliser cette commande, tapez `killall [nomprocessus]`. Par exemple :

```bash

killall apache

```

Cela terminera tous les processus avec le nom apache. C'est particulierement utile pour tuer les processus d'arriere-plan simultanement.

La commande killall peut etre personnalisee avec des options d'horodatage, qui incluent :

- `-o [temps]` : ne tue que les processus plus anciens que le temps specifie.

- `-y [temps]` : ne tue que les processus plus recents que le temps specifie.

La specification de `[temps]` dans ces options est generalement donnee au format s pour secondes, m pour minutes, h pour heures, d pour jours, w pour semaines, M pour mois et y pour annees.

Par exemple, cette commande termine tous les processus en cours nommes chrome qui fonctionnent depuis plus de 30 minutes :

```bash

killall -o 30m chrome

```

Conclusion

Dans ce guide, nous avons explore plusieurs methodes pour tuer un processus sous Linux en utilisant un script shell. Nous avons couvert differents signaux et les commandes pkill, killall et kill. Ces techniques sont cruciales pour faciliter un arret securise sous Linux et prevenir l'instabilite du systeme.

Maitriser ces competences est vital pour gerer les processus d'arriere-plan de maniere sure et precise, ce qui est cle pour une gestion efficace des taches sous Linux.