Quelles sont les choses les plus importantes à savoir pour utiliser les commandes du terminal Linux en toute sécurité et efficacement ?

Question

Accepted Answer

La grande règle de sécurité est la suivante : le terminal fait généralement exactement ce que vous avez tapé, pas ce que vous vouliez dire. `rm` n’a pas de corbeille, `>` écrase les fichiers, `dd` peut effacer des disques silencieusement, `sudo` transforme de petites erreurs en dégâts système majeurs, et `kill -9` arrête un processus sans nettoyage. Utilisez d’abord des étapes de prévisualisation : `pwd`, `ls`, `ls -l`, `lsblk`, `find ... -print`, et des options interactives comme `rm -i`, `cp -i` et `mv -i`.

## 1. Traitez les commandes de suppression comme des armes chargées

`rm` supprime définitivement les fichiers. Il ne les déplace pas dans une corbeille.

```bash
rm fichier.txt
```

supprime `fichier.txt`.

Pour les répertoires :

```bash
rm -r ancien_dossier
```

supprime un répertoire récursivement.

La version dangereuse est :

```bash
rm -rf nom_dossier
```

Cela signifie récursif + forcé. Pas de confirmation. Pas d’annulation. Cela supprime le dossier et tout son contenu.

Ne lancez jamais :

```bash
rm -rf /
```

ou :

```bash
sudo rm -rf /
```

Cela peut supprimer tout le système.

Habitudes plus sûres :

```bash
pwd
ls
rm -i fichier.txt
rm -ri ancien_dossier/
```

Utilisez `rm -i` pour demander confirmation avant chaque suppression.

Si vous voulez un comportement de type corbeille au lieu d’une suppression définitive :

```bash
trash-put fichier.txt
```

## 2. Faites attention aux écrasements

L’opérateur `>` écrase le fichier cible :

```bash
commande > fichier
```

Exemple :

```bash
ls -l > liste_fichiers.txt
```

Cela remplace le contenu précédent de `liste_fichiers.txt`.

Pour ajouter au lieu d’écraser :

```bash
commande >> fichier
```

Exemple :

```bash
echo "encore" >> fichier.txt
```

Pour rediriger uniquement les erreurs :

```bash
commande 2> fichier_erreurs
```

Pour rediriger à la fois la sortie normale et les erreurs :

```bash
cmd > fichier 2>&1
```

Une erreur grave est de rediriger la sortie vers un périphérique disque :

```bash
commande >/dev/sda
```

Cela peut écraser le disque.

## 3. Utilisez `sudo` uniquement quand c’est nécessaire

`sudo` exécute une commande avec des privilèges élevés :

```bash
sudo commande
```

C’est utile pour les tâches administratives, mais dangereux si vous ne comprenez pas la commande. Après `sudo su`, chaque commande s’exécute en root, ce qui signifie que même des erreurs normalement bénignes peuvent endommager le système.

Si vous avez oublié `sudo`, utilisez :

```bash
sudo !!
```

Cela relance la commande précédente avec les privilèges superutilisateur. Mais souvenez-vous : cela répète exactement la dernière commande.

## 4. Prévisualisez les commandes destructrices find avant de supprimer

Avant de faire ceci :

```bash
find /chemin/de/recherche -name "temp*.txt" -delete
```

ou ceci :

```bash
find /var/log -name "*.log" | xargs rm -f
```

prévisualisez d’abord :

```bash
find /var/log -name "*.log" -mtime +30 -print
```

Supprimez seulement après que la liste affichée correspond exactement à ce que vous attendez.

Quand vous utilisez `find` avec `-exec rm -rf`, limitez la recherche à un répertoire spécifique et vérifiez bien les correspondances avant.

## 5. Citez les chemins contenant des espaces ou caractères spéciaux

Cela crée deux répertoires :

```bash
mkdir another folder
```

Cela crée `another` et `folder`.

Cela crée un seul répertoire :

```bash
mkdir "another folder"
```

Utilisez des guillemets autour des chemins contenant des espaces ou caractères spéciaux :

```bash
mv "ancien fichier.txt" "nouveau fichier.txt"
```

Les guillemets simples préservent le texte littéral. Les guillemets doubles permettent l’expansion des variables.

## 6. Comprenez les glob avant de les utiliser avec `rm` ou `mv`

Les glob comme `*` et `?` s’étendent aux noms de fichiers correspondants.

```bash
rm *.log
```

supprime tous les fichiers `.log` correspondants dans le répertoire courant.

Avant d’utiliser un nouveau glob de façon destructive, testez-le :

```bash
ls *.log
```

Les fichiers cachés (dotfiles) nécessitent de la prudence. Pour correspondre aux entrées cachées sauf `.` et `..`, utilisez les deux :

```bash
.[!.]* ..?*
```

Si vous voulez un caractère générique littéral, échappez-le avec un antislash.

## 7. Préférez une terminaison de processus en douceur avant de forcer

La forme normale :

```bash
kill 1234
```

envoie SIGTERM, signal 15. Cela demande au processus de s’arrêter proprement.

Équivalent :

```bash
kill -15 1234
```

Si cela échoue, utilisez :

```bash
kill -9 1234
```

`kill -9` envoie SIGKILL. Il ne peut pas être intercepté ou ignoré, et le processus n’a pas la possibilité de se nettoyer.

Pour les noms de processus :

```bash
pkill nginx
```

tue les processus correspondants.

De force :

```bash
pkill -9 application_non_reactive
```

Mais vérifiez d’abord les correspondances :

```bash
pgrep nom_processus
```

Pour une correspondance complète en ligne de commande :

```bash
pkill -f 'python3 /opt/myapp/server.py'
```

Soyez prudent : un mauvais motif peut tuer le mauvais processus.

## 8. Sachez que les processus zombies ne peuvent pas être tués directement

Un processus zombie est déjà mort. Il reste seulement parce que son parent n’a pas récupéré son statut de sortie.

Trouvez les zombies :

```bash
ps -eo pid,ppid,stat,comm | grep -w Z
```

Vous ne pouvez pas en corriger un avec `kill -9` sur le zombie lui-même. Au lieu de cela, incitez le parent :

```bash
kill -SIGCHLD <pid_parent>
```

Si nécessaire, corrigez ou terminez le parent pour que PID 1 puisse récupérer le zombie.

## 9. Vérifiez deux fois les périphériques disque avant d’utiliser `dd`, `mkfs` ou `wipefs`

`dd` ne demande pas de confirmation. Si vous inversez entrée et sortie, vous pouvez détruire des données.

Exemple de copie brute :

```bash
dd if=/dev/sda of=/dev/sdb bs=4M
```

Avant de l’exécuter :

```bash
lsblk
```

Confirmez la source et la cible exactes.

Pour surveiller la progression en toute sécurité dans un pipeline :

```bash
pv fichier.iso | dd of=/dev/sdb
```

Les commandes comme celles-ci effacent les données :

```bash
dd if=/dev/zero of=/dev/sda
mkfs.ext3 /dev/sda
wipefs -a /dev/sdx
```

Utilisez délibérément le chemin complet du disque ou de la partition.

## 10. Utilisez la protection interactive contre l’écrasement avec copie et déplacement

Par défaut, `cp` et `mv` peuvent écraser des fichiers existants.

Copiez un fichier :

```bash
cp source destination
```

Copiez avec confirmation d’écrasement :

```bash
cp -i source destination
```

Ne jamais écraser :

```bash
cp -n source destination
```

Copiez un répertoire récursivement :

```bash
cp -r dossier_source dossier_destination
```

Préservez permissions, propriété et horodatages :

```bash
cp -p /source/fichier /destination/
```

Copie style archive :

```bash
cp -a source destination
```

Déplacez ou renommez :

```bash
mv ancien_nom nouveau_nom
```

Demandez confirmation avant écrasement :

```bash
mv -i source destination
```

Ne jamais écraser :

```bash
mv -n ancien.txt nouveau.txt
```

Forcer l’écrasement :

```bash
mv -f source cible
```

Aussi : `mv` ne supporte pas `-R`.

## 11. Utilisez le bon outil de permissions

`chmod` change les permissions :

```bash
chmod u+x script.sh
```

ou :

```bash
chmod 600 secret.key
```

`chown` change le propriétaire :

```bash
sudo chown utilisateur:utilisateur fichier.txt
```

Récursivement :

```bash
chown -R utilisateur:groupe dossier
```

Soyez très prudent avec les changements récursifs de permissions. C’est dangereux :

```bash
chmod -R 777 /
```

Cela donne les droits lecture, écriture et exécution à tout le monde sur tout le système.

Également dangereux :

```bash
chown -R utilisateur:utilisateur /
```

Les fichiers système critiques nécessitent une propriété spécifique.

## 12. Rendez les scripts exécutables correctement

Commencez un script Bash par :

```bash
#!/bin/bash
```

Rendez-le exécutable :

```bash
chmod u+x monScriptBash.sh
```

Exécutez-le comme un exécutable :

```bash
./monScriptBash.sh
```

Nuance importante : le shebang est utilisé quand vous lancez le script comme exécutable. Si

Manuel de l'utilisateur Linux sur les commandes terminal et la sécurité du système

À propos de cette capsule

Couvert dans cette capsule

IA générique vs cette capsule

1. Traitez les commandes de suppression comme des armes chargées

Tags

Similaires dans Technologie

L’IA comme assistant : confidentialité, contrôle et jugement humain

Distorsion de la Chaleur Analogique : La Vérité sur la Qualité Supérieure

Guide du propriétaire pour le contrôle de la maison intelligente

Économie de la Ruée vers l’IA : Profits, Coûts Informatiques et Risque de Bulle