Aller au contenu principal

Apprendre les commandes Linux avancées

Dans le chapitre précédent, nous avons vu les commandes de base permettant de découvrir le système d'exploitation Linux. Dans ce chapitre, nous allons voir des commandes, que nous allons appeler avancées, car elles vont vous permettre d'administrer réellement des serveurs Linux. La maîtrise de ces commandes est essentielle pour quiconque souhaite administrer efficacement des serveurs Linux.

Pour chacune des commandes Linux, je fournirai des conseils pratiques, des astuces et des exemples concrets pour vous aider à appliquer ces nouvelles connaissances.

Conseils d'apprentissage​

Pour bien apprendre, je vous conseille d'avoir un serveur Linux à disposition pour tester ces commandes. Le mieux est d'en virtualiser une sur votre poste de travail avec un outil comme Vagrant.

Informations système​

df (disk filesystem)​

La commande df affiche l'espace disque utilisé et disponible.

df [option]... [fichier]...

Les principales options à connaître :

  • -T : Affiche le type de filesystem.
  • -b|-k|-m|-g|-h|-H : Affiche soit la taille en bytes, soit en Ko, soit en Mo, soit en Go, soit dans un format lisible par un humain.
  • -i : Affiche le nombre d'inodes
df -TH
Sys. de fichiers Type     Taille Utilisé Dispo Uti% Monté sur
tmpfs            tmpfs      2,5G    2,7M  2,5G   1% /run
efivarfs         efivarfs   132k     14k  113k  11% /sys/firmware/efi/efivars
/dev/nvme0n1p3   ext4       482G    288G  170G  63% /
tmpfs            tmpfs       13G    839M   12G   7% /dev/shm
tmpfs            tmpfs      5,3M       0  5,3M   0% /run/lock
/dev/nvme0n1p2   vfat       4,3G    3,1G  1,3G  71% /recovery
/dev/nvme0n1p1   vfat       1,1G    410M  661M  39% /boot/efi
tmpfs            tmpfs       13G       0   13G   0% /run/qemu
tmpfs            tmpfs      2,5G    300k  2,5G   1% /run/user/1000

du (disk usage)​

La commande linux du affiche l'espace utilisé par les fichiers et les dossiers.

du [option]... [fichier]...
du [option]... --files0-from=F

Les principales options à connaître :

  • -s : Affiche la taille totale d'un répertoire et non pas son détail.
  • -b|-k|-m|-g|-h : Affiche soit la taille en bytes, soit en Ko, soit en Mo, soit en Go, soit dans un format lisible par un humain.

Cette commande associée à la commande sort permet de retrouver le dossier pouvant occuper le plus d'espace disque.

du -sm * |sort -n
1       babel.config.js
1       docusaurus.config.js
1       frontmatter.json
1       localhost-key.pem
1       localhost.pem
1       log.txt
1       package.json
1       package-lock.json
1       README.md
1       sidebars.js
1       src
1       tsconfig.json
1       tsconfig.json.old
2       docs
3       blog
90      static
238     build
2290    node_modules

free​

La commande linux free Affiche la mémoire libre et utilisée dans le système.

free [options]

Les principales options à connaître :

  • -b|-k|-m|-g|-h : Affiche soit la taille en bytes, soit en Ko, soit en Mo, soit en Go, soit dans un format lisible par un humain.
  • -s n : Rafraichis l'affichage tous les n secondes
free -h -s 2
               total       utilisé      libre     partagé tamp/cache   disponible
Mem:            22Gi        15Gi       3,3Gi       414Mi       4,4Gi       5,6Gi
Échange:       19Gi       4,1Gi        15Gi

               total       utilisé      libre     partagé tamp/cache   disponible
Mem:            22Gi        15Gi       3,3Gi       416Mi       4,4Gi       5,6Gi
Échange:       19Gi       4,1Gi        15Gi

uname​

La commande uname fournit des informations sur le système :

uname [option]

Les principales options à connaître :

  • -s ou --kernel-name : Retourne le nom du noyau, Ici Linux.
  • -n ou --nodename : Retourne le nom d'hôte de votre machine, ici pop-os.
  • -r ou --kernel-release : Retourne la version actuelle du noyau , ici 6.5.6-76060506-generic.
  • -v ou --kernel-version : Retourne la date à laquelle a été compilé le noyau (date de mise à jours ou d'installation de la machine la plupart du temps) , ici #202310061235~1697396945~22.04~9283e32 SMP PREEMPT_DYNAMIC Sun O
  • -i ou --machine : Retourne le nom de l'architecture matérielle de la machine. ici x86_64
  • -o ou --operating-system : Retourne l'OS sur lequel on exécute la commande. ici GNU/Linux
  • -a ou --all : Retourne toutes les informations sur une seule ligne

Gestion des processus​

ps (process status)​

La commande ps permet de lister les processus en cours d'exécution sur un système. Elle fournit des informations détaillées sur les processus en cours d'exécution, tels que leur identifiant de processus (PID), leur état, leur utilisation de CPU, leur occupation mémoire, etc.

Voici la syntaxe de base de la commande ps :

ps [options]

Exemples d'utilisation courante de la commande ps :

1. Afficher les processus de l'utilisateur actuel : Pour afficher tous les processus appartenant à l'utilisateur actuellement connecté, vous pouvez simplement exécuter la commande ps sans options :

ps

Cette commande affichera une liste de processus avec des informations de base.

2. Afficher tous les processus du système : Pour afficher tous les processus du système, y compris ceux des autres utilisateurs, utilisez l'option -e :

ps -e

3. Afficher plus d'informations sur les processus : Vous pouvez utiliser l'option -f pour obtenir plus d'informations sur les processus, notamment le PID, le PPID (parent PID), le groupe de processus, l'utilisateur, l'utilisation de la CPU et de la mémoire, la date de démarrage, la commande complète, etc.

ps -ef

4. Afficher les processus d'un utilisateur spécifique : Si vous souhaitez afficher les processus d'un utilisateur spécifique, utilisez l'option -u suivie du nom d'utilisateur. Par exemple, pour afficher les processus de l'utilisateur "john" :

ps -u john

5. Afficher les processus d'un groupe de processus spécifique : Pour afficher les processus appartenant à un groupe de processus spécifique, utilisez l'option -g suivi de l'identifiant du groupe de processus (GID). Par exemple, pour afficher les processus du groupe de processus avec le GID 1000 :

ps -g 1000

6. Afficher les processus en temps réel : Pour afficher les processus en temps réel à mesure qu'ils sont exécutés, utilisez l'option -e avec la commande watch. Par exemple, pour afficher tous les processus toutes les 2 secondes :

watch -n 2 ps -e

7. Afficher les processus avec un format personnalisé : Vous pouvez personnaliser le format de sortie en utilisant l'option -o suivi d'une liste de champs à afficher. Par exemple, pour afficher le PID et la commande complète des processus :

ps -eo pid,cmd

top​

La commande top permet de surveiller en temps réel l'utilisation des ressources système, notamment l'utilisation CPU, de la mémoire par les processus en cours d'exécution.top est un outil précieux pour la surveillance en direct et le diagnostic des problèmes de performances. ps affiche aussi les informations suivantes :

  • L'heure actuelle.
  • Le temps écoulé depuis le démarrage du système. (uptime)
  • Le nombre total de tâches, de tâches en cours d'exécution, de tâches en mode utilisateur et en mode noyau.
  • L'utilisation actuelle de la CPU (en pourcentage) par les processus.
  • L'utilisation de la mémoire physique (RAM) et de la mémoire d'échange (swap).
  • Des informations sur la charge du système, le load average sur 1, 5 et 15 minutes.

Il suffit de lancer simplement top dans un terminal pour afficher une vue en direct des performances du système :

top

Pour trier la liste des processus par un critère différent, appuyez sur une des touches suivantes :

  • P : Trie par utilisation de la CPU.
  • M : Trie par utilisation de la mémoire.
  • N : Trie par PID (identifiant de processus).
  • T : Trie par temps cumulatif d'utilisation de la CPU.

Pour quitter top, appuyez simplement sur la touche [q].

kill​

La commande kill permet d'envoyer des signaux à des processus en cours d'exécution. Ces signaux peuvent être utilisés pour demander à un processus de s'arrêter, de redémarrer, de recharger sa configuration, ou pour effectuer d'autres actions spécifiques. kill est couramment utilisée pour gérer et contrôler les processus sur un système.

Voici la syntaxe de base de la commande kill :

kill [options] PID
  • PID : L'identifiant de processus (PID) du processus que vous souhaitez cibler. Vous pouvez obtenir le PID d'un processus en utilisant des commandes telles que ps, top vu précédemment.
  • options : Des options facultatives pour personnaliser le comportement de la commande kill. L'une des options les plus couramment utilisées est -s (ou --signal), suivie du numéro du signal à envoyer.

Exemples d'utilisation courante de la commande kill :

1. Arrêter un processus : Pour arrêter (terminer) un processus en cours d'exécution, vous pouvez utiliser la commande kill suivi du PID du processus. Par exemple, pour arrêter un processus avec le PID 12345 :

kill 12345

Par défaut, kill envoie le signal SIGTERM (signal de terminaison) au processus, ce qui demande au processus de s'arrêter proprement.

2. Forcer l'arrêt d'un processus : Si un processus ne répond pas ou si vous souhaitez forcer son arrêt, vous pouvez utiliser le signal SIGKILL (signal de destruction). Le signal SIGKILL met fin immédiatement au processus sans donner la possibilité de nettoyer ou de sauvegarder des données. Par exemple :

kill -9 12345

Notez que le signal SIGKILL doit être utilisé avec prudence, car il peut entraîner une perte de données ou des problèmes de cohérence du système de fichiers.

3. Redémarrer un processus : Certains processus peuvent être redémarrés en utilisant le signal SIGHUP (signal de hang-up). Par exemple, pour redémarrer le démon Apache sur un serveur Web :

kill -HUP 12345

Le comportement précis du signal SIGHUP dépend du processus spécifique et de la manière dont il gère ce signal.

4. Recharger la configuration d'un processus : Certains processus, tels que les serveurs web ou les serveurs de bases de données, peuvent être invités à recharger leur configuration sans interrompre leur activité en utilisant le signal SIGUSR1 (signal utilisateur défini). Par exemple :

kill -USR1 12345

Les commandes de filtre​

Les commandes de filtres sous Linux sont conçues pour traiter et manipuler des flux de texte. Elles sont couramment utilisées pour filtrer, transformer et formater des données textuelles. Voici quelques-unes des commandes de filtres les plus couramment utilisées sous Linux :

egrep​

Une version améliorée de la commande grep qui permet de rechercher des motifs en utilisant une version étendue des expressions régulières (?, +, {}, () et |). Pour information aussi accessible avec la commande grep -E.

Exemple :

Imaginons que nous ayons un fichier nommé fichier.txt contenant ces lignes :

1       2       3       4
5       6       7       8
9       10      11      12
101     102     103     104

egrep '1|3' fichier.txt
1       2       3       4
9       10      11      12

La commande ne retourne que les lignes contenant 1 ou 5.

fgrep​

La commande fgrep, également appelée avec la commande grep -F, utilise la recherche de motifs en texte brut, sans interpréter les métacaractères spéciaux et les expressions régulières. Cela signifie que tous les caractères spéciaux sont traités comme des caractères littéraux. Cela peut être utile lorsque vous voulez rechercher des motifs qui contiennent des caractères spéciaux tels que . ou * sans les avoir interprétés comme des expressions régulières.

Exemple :

fgrep '1.5*' fichier.txt

Avec le fichier précédent cela ne retourne aucune ligne.

cut​

La commande cut est utilisée pour extraire des portions spécifiques de lignes de texte à partir de fichiers ou de flux de données.

Voici la syntaxe de base de la commande cut :

cut [options] fichier
  • options : Des options facultatives qui permettent de personnaliser le comportement de cut. Les options couramment utilisées incluent -d pour spécifier le délimiteur, -f pour spécifier les champs à extraire, et d'autres options de formatage.
  • fichier : Le nom du fichier (ou le flux de données) sur lequel vous souhaitez appliquer cut.

Voici quelques exemples d'utilisation courante de la commande cut :

Exemple 1 : Extraire une colonne spécifique :

Vous pouvez utiliser cut pour extraire une colonne spécifique de données en spécifiant le numéro de champ à l'aide de l'option -f. Par exemple, pour extraire la deuxième colonne (champ) de chaque ligne de notre fichier :

cut -d $'\t' -f 2 fichier.txt

2
6
10

Dans cet exemple, -d $'\t' spécifie une tabulation comme délimiteur. et -f 2 indique que la deuxième colonne doit être extraite.

Exemple 2 : Extraire plusieurs colonnes :

Vous pouvez extraire plusieurs colonnes en spécifiant les numéros de champ séparés par des virgules. Par exemple, pour extraire les colonnes 1, 3 et 4 de notre fichier :

cut -f 1,3,4 fichier.txt

1       3       4
5       7       8
9       11      12

Dans cet exemple, -f 1,3,4 indique que les colonnes 1, 3 et 4 doivent être extraites.

Exemple 4 : Extraire une plage de caractères :

Vous pouvez également utiliser cut pour extraire une plage de caractères (plutôt qu'une colonne spécifique) en utilisant l'option -c. Par exemple, pour extraire les caractères de 5 à 10 de chaque ligne de notre fichier texte :

cut -c 5-10 fichier.txt

3       4
7       8
        11      12

Dans cet exemple, -c 5-10 indique que les caractères de la 5e à la 10e position de chaque ligne doivent être extraits.

sort​

La commande sort est utilisée pour trier les lignes d'un fichier ou de la sortie d'une commande en fonction de critères de tri spécifiés.

sort [options]... [fichier]...

Options courantes :

  • -r : Trie en ordre inverse (du plus grand au plus petit).
  • -n : Trie numériquement au lieu de lexicographiquement (pour trier correctement les nombres).
  • -u : Supprime les lignes en double lors du tri.
  • -k N : Trie en utilisant la colonne N comme clé (N étant un numéro de colonne).
  • -t CARACTERE : Spécifie un caractère de délimitation pour diviser les champs.

Exemple d'utilisation :

# Trier un fichier en ordre alphabétique
sort fichier.txt

# Trier un fichier CSV en fonction de la deuxième colonne numérique
sort -t ',' -k 2n fichier.csv

uniq​

La commande uniq est utile pour nettoyer les données en éliminant les doublons, en comptant les occurrences ou en effectuant d'autres opérations sur les lignes consécutives d'un fichier ou d'une sortie de commande. Elle offre plusieurs options pour personnaliser son comportement en fonction de vos besoins.

uniq [options]... [input [ouput]]

Options courantes :

  • -d : Affiche uniquement les lignes en double.
  • -u : Affiche uniquement les lignes uniques (c'est-à-dire supprime les doublons).
  • -c : Affiche le nombre de fois que chaque ligne apparaît dans le fichier.
  • -i : Ignore la casse lors de la comparaison des lignes.
  • -f N : Ignore les N premiers champs (séparés par des espaces ou des tabulations) lors de la comparaison des lignes.
  • -s N : Ignore les N premiers caractères de chaque ligne lors de la comparaison.

Exemple d'utilisation :

  1. Supprimer les lignes en double d'un fichier texte :
sort fichier.txt | uniq
  1. Afficher les lignes en double avec leur comptage :
sort fichier.txt | uniq -d -c
  1. Ignorer la casse lors de la comparaison :
sort fichier.txt | uniq -i

tr (translate)​

La commande tr, qui est principalement utilisée pour effectuer des transformations simples sur des caractères dans un flux de données ou un fichier texte. tr permet de traduire, de supprimer ou de remplacer des caractères spécifiques dans le texte.

Voici la syntaxe de base de la commande tr :

tr [options] 'set1' 'set2'
  • options : Des options facultatives qui permettent de personnaliser le comportement de tr.
  • set1 : Le jeu de caractères d'origine que vous souhaitez traiter ou traduire.
  • set2 : Le jeu de caractères de destination auquel vous souhaitez traduire ou remplacer les caractères de set1.

tr effectue des opérations de traduction en remplaçant chaque caractère de set1 par le caractère correspondant dans set2. Les caractères de set1 et set2 doivent être spécifiés dans le même ordre.

Voici quelques exemples d'utilisation courante de la commande tr :

Exemple 1 : Conversion de majuscules en minuscules :

Pour convertir toutes les lettres majuscules en minuscules dans un fichier texte, vous pouvez utiliser tr de la manière suivante :

tr 'A-Z' 'a-z' < fichier.txt

Dans cet exemple, A-Z représente toutes les lettres majuscules de l'alphabet, et a-z représente les lettres minuscules correspondantes. tr traduira toutes les lettres majuscules en minuscules.

Exemple 2 : Suppression de caractères :

Supposons que vous souhaitiez supprimer toutes les occurrences d'un caractère spécifique, comme les espaces, d'un fichier texte. Vous pouvez utiliser tr pour cela :

tr -d ' ' < fichier.txt

Dans cet exemple, l'option -d est utilisée pour supprimer tous les espaces de set1.

Exemple 3 : Remplacement de caractères :

Si vous souhaitez remplacer un caractère par un autre, vous pouvez utiliser tr. Par exemple, pour remplacer toutes les occurrences du caractère a par b dans un fichier texte :

tr 'a' 'b' < fichier.txt

Dans cet exemple, a dans set1 est remplacé par b dans set2.

wc (word count)​

La commande wc est principalement utilisée pour compter le nombre de lignes, de mots et d'octets (caractères) dans un fichier texte ou un flux de données.

wc [options] fichier
  • options : Des options facultatives qui permettent de personnaliser le comportement de wc. Les options couramment utilisées incluent -l pour compter les lignes, -w pour compter les mots et -c pour compter les octets (caractères).
  • fichier : Le nom du fichier (ou le flux de données) sur lequel vous souhaitez effectuer le comptage.

Voici quelques exemples d'utilisation courante de la commande wc :

Exemple 1 : Compter le nombre de lignes dans un fichier :

Pour compter le nombre de lignes dans un fichier texte, vous pouvez utiliser wc avec l'option -l de la manière suivante :

wc -l fichier.txt

Cela affichera le nombre de lignes dans le fichier fichier.txt.

Exemple 2 : Compter le nombre de mots dans un fichier :

Pour compter le nombre de mots dans un fichier texte, vous pouvez utiliser wc avec l'option -w de la manière suivante :

wc -w fichier.txt

Cela affichera le nombre de mots dans le fichier fichier.txt. Notez que wc considère les espaces, les tabulations et les sauts de ligne comme des délimiteurs de mots.

Exemple 3 : Compter le nombre d'octets (caractères) dans un fichier :

Pour compter le nombre d'octets (caractères) dans un fichier texte, vous pouvez utiliser wc avec l'option -c de la manière suivante :

wc -c fichier.txt

Cela affichera le nombre d'octets (caractères) dans le fichier fichier.txt, y compris les caractères d'espacement et les caractères de contrôle.

paste​

La commande paste est utilisée pour fusionner (coller) des lignes de fichiers côte à côte.

paste [option]... [fichier]...

Options courantes :

  • -d DELIM : Spécifie un délimiteur personnalisé pour séparer les colonnes.

Exemple d'utilisation :

# Fusionner deux fichiers ligne par ligne avec une tabulation comme délimiteur
paste -d $'\t' fichier1.txt fichier2.txt

join​

La commande join est utilisée pour combiner les lignes de deux fichiers en fonction d'un champ commun.

join [option]... fichier1 fichier2

Options courantes :

  • -t CARACTERE : Spécifie le caractère de séparation des champs.
  • -1 N : Spécifie la colonne du fichier 1 à utiliser comme clé de jointure.
  • -2 N : Spécifie la colonne du fichier 2 à utiliser comme clé de jointure.
  • -a FILENUM : Affiche également les lignes sans correspondance dans le fichier FILENUM.
  • -o FORMAT : Spécifie le format de sortie des lignes fusionnées.

Exemple d'utilisation :

# Fusionner deux fichiers CSV en fonction de la première colonne commune
join -t ',' -1 1 -2 1 fichier1.csv fichier2.csv

comm​

La commande comm est utilisée pour comparer deux fichiers texte ligne par ligne et afficher les lignes qui sont communes aux deux fichiers ainsi que celles qui sont uniques à chaque fichier. Elle est utile pour identifier les similitudes et les différences entre deux ensembles de données. Voici une explication de la commande comm avec ses options courantes :

comm [option]... fichier1 fichier2
  • fichier1 : Le premier fichier à comparer.
  • fichier2 : Le deuxième fichier à comparer.

Options courantes :

  • -1 : Supprime la colonne des lignes uniques à fichier1.
  • -2 : Supprime la colonne des lignes uniques à fichier2.
  • -3 : Supprime les colonnes des lignes communes.
  • -i : Ignore la casse lors de la comparaison.
  • -u : Affiche uniquement les lignes uniques à chaque fichier (ne montre pas les lignes communes).
  • -t : Utilise un caractère de délimitation de champ (par défaut, c'est la tabulation).

Exemple d'utilisation :

Supposons que vous ayez deux fichiers texte fichier1.txt et fichier2.txt avec le contenu suivant :

fichier1.txt :

apple
banana
cherry
date

fichier2.txt :

banana
cherry
date
elderberry

Vous pouvez utiliser comm pour comparer ces deux fichiers comme suit :

comm fichier1.txt fichier2.txt

Le résultat affiché serait :

                apple
        elderberry
        ^-- Cette colonne montre les lignes uniques à fichier2.txt
    ^-- Cette colonne montre les lignes uniques à fichier1.txt
^-- Cette colonne montre les lignes communes aux deux fichiers

Dans cet exemple, comm affiche les lignes communes dans la première colonne, les lignes uniques à fichier1.txt dans la deuxième colonne et les lignes uniques à fichier2.txt dans la troisième colonne.

Vous pouvez utiliser les options -1, -2, -3, -i et -u pour personnaliser davantage la sortie de comm en fonction de vos besoins de comparaison.

nl (numéro de ligne)​

La commande nl est utilisée pour numéroter les lignes d'un fichier texte ou de l'entrée standard (stdin) et afficher le résultat avec des numéros de ligne. Elle est généralement utilisée pour faciliter la référence et la recherche de lignes spécifiques dans un fichier. Voici une explication de base de la commande nl avec ses options courantes :

nl [options] fichier
  • fichier : Le fichier dont vous souhaitez numéroter les lignes. Si vous ne spécifiez pas de fichier, nl utilisera l'entrée standard (stdin).

Options courantes :

  • -b STYLE : Spécifie le style de numérotation des lignes. Les valeurs courantes incluent a (numérotation de toutes les lignes), t (numérotation des lignes non vides uniquement) et n (pas de numérotation).
  • -n FORMAT : Spécifie le format du numéro de ligne (par exemple, -n rz affiche des numéros de ligne à droite, remplissant avec des zéros).
  • -s SEPARATEUR : Utilise un séparateur personnalisé entre le numéro de ligne et le contenu de la ligne.

Exemple d'utilisation :

Supposons que vous ayez un fichier texte nommé exemple.txt avec le contenu suivant :

Ceci est une ligne.
Et voici une autre.

Vous pouvez utiliser nl pour numéroter les lignes de ce fichier comme suit :

nl exemple.txt

Le résultat affiché serait :

     1  Ceci est une ligne.
     2  Et voici une autre.

Dans cet exemple, nl a numéroté les lignes du fichier exemple.txt par défaut, en commençant par 1 et en ajoutant un espace comme séparateur entre les numéros de ligne et le contenu de chaque ligne.

Vous pouvez personnaliser davantage la manière dont les lignes sont numérotées en utilisant les options -b, -n et -s en fonction de vos besoins. Numérote les lignes d'un fichier ou d'un flux de données.

tee​

La commande tee est utilisée pour lire l'entrée standard (stdin), écrire cette entrée à la fois sur la sortie standard (stdout) et dans un ou plusieurs fichiers spécifiés. Elle est couramment utilisée pour afficher le contenu d'une commande à l'écran tout en l'enregistrant dans un fichier. Voici une explication de base de la commande tee avec ses options courantes :

tee [options] [fichier...]
  • [options] : Les options facultatives pour personnaliser le comportement de tee.
  • [fichier...] : Les noms des fichiers dans lesquels vous souhaitez écrire les données. Si vous ne spécifiez pas de fichiers, tee n'écrira que sur la sortie standard (écran).

Options courantes :

  • -a : Appending (ajout) au lieu d'écraser les fichiers existants. Cette option permet d'ajouter du contenu à des fichiers existants au lieu de les remplacer.
  • -i : Ignore les signaux interrupteurs, ce qui permet de continuer même si vous interrompez le processus.
  • -p : Préfixe chaque ligne de sortie avec le nom du fichier correspondant. Cette option ajoute le nom du fichier en préfixe à chaque ligne écrite dans les fichiers spécifiés.

Exemple d'utilisation :

  1. Lire l'entrée standard et l'écrire dans un fichier :
echo "Contenu de test" | tee fichier.txt

Cette commande prend la chaîne "Contenu de test" depuis l'entrée standard, l'affiche à l'écran et l'écrit également dans le fichier fichier.txt.

  1. Lire l'entrée standard et l'ajouter à un fichier existant :
echo "Nouveau contenu" | tee -a fichier.txt

Cette commande ajoute la chaîne "Nouveau contenu" à la fin du fichier fichier.txt grâce à l'option -a.

  1. Lire l'entrée standard, afficher sur l'écran avec le préfixe du nom de fichier et enregistrer dans deux fichiers :
echo "Données importantes" | tee -p fichier1.txt fichier2.txt

Cette commande écrit la chaîne "Données importantes" dans les fichiers fichier1.txt et fichier2.txt, tout en ajoutant un préfixe indiquant le nom du fichier d'origine à chaque ligne.

rev​

La commande rev est utilisée pour inverser l'ordre des caractères dans chaque ligne d'un fichier ou de la sortie d'une commande. Elle est principalement utilisée pour inverser le texte d'une ligne, ce qui peut être utile dans certaines situations de traitement de texte. Voici une explication de base de la commande rev avec quelques exemples :

rev [options] [fichier...]
  • [options] : Les options facultatives pour personnaliser le comportement de rev.
  • [fichier...] : Les noms des fichiers à inverser. Si vous ne spécifiez pas de fichiers, rev lira l'entrée standard (stdin).

Exemple d'utilisation :

  1. Inverser une ligne de texte :
echo "Hello, World!" | rev

Cette commande prend la chaîne "Hello, World!" depuis l'entrée standard, inverse l'ordre de ses caractères et affiche le résultat à l'écran. Le résultat sera "dlroW ,olleH!".

  1. Inverser le contenu d'un fichier texte :
rev fichier.txt

Cette commande inverse toutes les lignes du fichier fichier.txt et affiche le résultat à l'écran.

fold​

La commande fold est utilisée pour formater le texte en le pliant (coupant) en lignes de longueur spécifiée. Elle est généralement utilisée pour s'assurer que les lignes de texte restent sous une certaine longueur lors de l'affichage ou de l'impression. Voici une explication de base de la commande fold avec ses options courantes :

fold [options] [fichier...]
  • [options] : Les options facultatives pour personnaliser le comportement de fold.
  • [fichier...] : Les noms des fichiers à plier. Si vous ne spécifiez pas de fichiers, fold lira l'entrée standard (stdin).

Options courantes :

  • -b NUM ou -w NUM : Spécifie la largeur maximale de la ligne en fonction du nombre de caractères (-b) ou du nombre de colonnes (-w). Vous devez utiliser l'une de ces options pour définir la largeur maximale.
  • -s : Plie uniquement à des espaces ou des tabulations. Cette option permet de plier uniquement aux limites de mots, en évitant de couper les mots en deux.

Exemple d'utilisation :

  1. Plier un fichier texte en lignes de 80 caractères de largeur :
fold -w 80 fichier.txt

Cette commande plie le contenu du fichier fichier.txt en lignes de 80 caractères de largeur maximale. Si une ligne dépasse cette largeur, elle est coupée et le reste est placé sur la ligne suivante.

  1. Plier un texte en lignes de 30 caractères en évitant de couper les mots :
echo "Ceci est un exemple de texte à plier en utilisant fold. Assurez-vous de ne pas couper les mots." | fold -s -w 30

Cette commande prend la chaîne de texte donnée en entrée, la plie en lignes de 30 caractères de largeur maximale tout en évitant de couper les mots en deux. La sortie sera formatée en conséquence.

sed​

L'éditeur de flux (Stream EDitor) permet de modifier, de supprimer, de remplacer et de transformer des lignes de texte en utilisant des expressions régulières.

La commande sed, est principalement utilisée pour effectuer des manipulations de texte dans un flux de données ou dans un fichier texte. sed fonctionne en traitant le texte ligne par ligne et en appliquant des règles de substitution, de suppression, de recherche et d'autres opérations définies par l'utilisateur.

La syntaxe de base de la commande sed est la suivante :

sed [options] 'commande' fichier
  • options : Des options facultatives qui permettent de personnaliser le comportement de sed.
  • commande : L'expression sed qui spécifie les opérations à effectuer sur le texte. Cette expression peut inclure des commandes de modification, des motifs de recherche, des substitutions, etc.
  • fichier : Le nom du fichier (ou le flux de données) sur lequel vous souhaitez appliquer les modifications.

Voici quelques exemples d'utilisation courante de la commande sed :

Exemple 1 : Remplacement de texte :

Supposons que vous ayez un fichier texte contenant le mot "ancien_mot" que vous souhaitez remplacer par "nouveau_mot". Vous pouvez utiliser sed de la manière suivante :

sed 's/ancien_mot/nouveau_mot/g' fichier.txt

Dans cet exemple, s est une commande de substitution, /ancien_mot/nouveau_mot/ est le motif de recherche et de remplacement et g signifie que la substitution doit être appliquée à toutes les occurrences de "ancien_mot" dans chaque ligne.

Exemple 2 : Suppression de lignes :

Supposons que vous souhaitiez supprimer toutes les lignes d'un fichier contenant le mot supprimer. Vous pouvez utiliser sed de la manière suivante :

sed '/supprimer/d' fichier.txt

Dans cet exemple, /supprimer/ est un motif de recherche et d est une commande pour supprimer les lignes correspondant au motif.

Exemple 3 : Ajout de texte :

Supposons que vous souhaitiez ajouter une ligne après chaque ligne contenant le mot "ajouter". Vous pouvez utiliser sed de la manière suivante :

sed '/ajouter/a Nouvelle ligne à ajouter' fichier.txt

Dans cet exemple, /ajouter/ est un motif de recherche et a est une commande pour ajouter une ligne après les lignes correspondant au motif.

Exemple 4 : Numérotation des lignes :

Vous pouvez utiliser sed pour ajouter des numéros de ligne à un fichier. Par exemple, pour numéroter les lignes d'un fichier :

sed = fichier.txt | sed 'N; s/\n/ /'

La première commande sed ajoute les numéros de ligne et la deuxième commande sed fusionne ces numéros de ligne avec le texte.

awk​

awk est une des commandes à connaitre absolument. C'est un outil de traitement de fichiers par ligne très puissant. Elle est utilisée pour manipuler, traiter et formater des données textuelles, en particulier des données séparées par des caractères identiques, qu'on appelle séparateur ou délimiteur. Cela peut être une tabulation (par défaut), une virgule, point-virgule ou toute autre séquence de caractères.

awk fonctionne en lisant des lignes de texte ou la sortie standard, en les divisant en champs, puis en effectuant des opérations sur ces champs. Elle est largement utilisée pour effectuer des tâches de traitement de données, d'analyse de fichiers de données et de génération de rapports.

La syntaxe de base de la commande awk est la suivante :

awk '[pattern] { action }' fichier
  • pattern : Un motif qui spécifie les lignes sur lesquelles l'action doit être appliquée. Si vous omettez le motif, l'action sera appliquée à chaque ligne.
  • action : Les opérations que vous souhaitez effectuer sur les lignes correspondant au motif. Les actions sont généralement délimitées par des accolades {}.
  • fichier : Le nom du fichier (ou le flux de données) sur lequel vous souhaitez appliquer awk.

Voici quelques exemples d'utilisation courante de la commande awk :

Exemple 1 : Afficher la première colonne d'un fichier avec des données séparées par des tabulations :

Supposons que vous ayez un fichier texte nommé fichier.txt contenant avec plusieurs colonnes,

1       2       3       4
5       6       7       8
9       10      11      12

Vous souhaiteriez afficher la première colonne (champ) de chaque ligne. Vous pouvez utiliser awk de la manière suivante :

awk '{print $1}' fichier.txt
1
5
9

Dans cet exemple, $1 fait référence au premier champ de chaque ligne, et print affiche ce champ.

Exemple 2 : Calculer la somme d'une colonne numérique :

Supposons que vous vous souhaiteriez calculer la somme de la seconde colonne. Vous pouvez utiliser awk pour cela :

awk '{sum += $2} END {print sum}' fichier.txt
18

Dans cet exemple, $2 fait référence au deuxième champ de chaque ligne (la colonne numérique) et sum accumule les valeurs de ce champ. L'action END \{print sum\} est exécutée après avoir traité toutes les lignes et affiche la somme totale.

Exemple 3 : Filtrer les lignes qui correspondent à un motif :

Supposons que vous souhaitiez afficher uniquement les lignes d'un fichier qui contienne un mot spécifique. Vous pouvez utiliser awk de la manière suivante :

awk '/1/ {print}' fichier.txt
1       2       3       4
9       10      11      12

Dans cet exemple, /1/ est un motif de recherche qui correspond aux lignes contenant le chiffre "1" et print affiche ces lignes.

Exemple 4 : Manipuler la structure des données :

awk permet également de manipuler la structure des données. Par exemple, vous pouvez réorganiser les colonnes, ajouter des en-têtes, ou générer des rapports formatés à partir de données brutes.

awk '{print $2, $1}' fichier.txt
2 1
6 5
10 9

Cette commande réorganise les colonnes en affichant d'abord le deuxième champ suivi du premier champ.

awk offre de nombreuses autres fonctionnalités et possibilités, notamment les expressions régulières, les variables d'awk, les fonctions intégrées et bien plus encore. C'est un outil très flexible et puissant pour le traitement de données textuelles. Pour en savoir plus sur awk et ses capacités, vous pouvez consulter la page de manuel en utilisant la commande man awk.

diff​

La commande diff permet de comparer le contenu de deux fichiers ou de deux répertoires et d'afficher les différences entre eux. diff est souvent utilisée pour trouver les modifications apportées à un fichier texte, à un code source ou à un répertoire entre deux versions différentes.

Exemple de commandes avancées​

Rechercher et afficher les 10 commandes que vous utilisez le plus :

history | awk '{a[$2]++}END{for(i in a){print a[i] " " i}}' | sort -rn | head

Génération d'un mot de passe aléatoire d'une longeur de 30 caractères

strings /dev/urandom | grep -o '[[:alnum:]]' | head -n 30 | tr -d '\n'; echo

Autres commandes utiles​

watch​

La commande watch permet d'exécuter périodiquement une autre commande et d'afficher sa sortie de manière répétée dans un terminal. Cela permet de surveiller en temps réel l'évolution d'une commande ou d'une tâche sans avoir à la relancer manuellement à plusieurs reprises.

Voici la syntaxe de base de la commande watch :

watch [options] commande

Par exemple, si vous souhaitez surveiller la présence d'un processus particulier à intervalles réguliers de 2 secondes, vous pouvez utiliser la commande suivante :

watch -n 2 "ps -ef | grep [s]shd"

donne l'affichage suivant :

Toutes les 2,0s: ps -ef | grep [s]shd                                                                                                                            pop-os: Sat Nov  4 17:31:12 2023

root        1251       1  0 oct.27 ?       00:00:00 sshd: /usr/sbin/sshd -D [listener] 0 of 10-100 startups

Si la commande possède un pipe, il faut la mettre entre double quote.

L'astuce pour ne pas retrouver la commande grep dans la liste des process avec l'utilisation de l'expression régulière.

Pour quitter, il suffit d'utiliser la séquence de touche [Ctrl] + [c].Kubernetes

Plus loin​

Nous avons vu dans ce chapitre des commandes permettant d'administrer des serveurs Linux, mais dans un contexte DevOps où un des premiers principes est d'automatiser pour éviter les erreurs humaines entre autre, vous serez amené à exécuter ces commandes que sur des environnements dits hors production. Sur la production, on fera appel à des scripts Shell par exemple pour réaliser ces tâches. Dans le chapitre suivant, nous allons voir comment développer ces scripts Shell.