# Aperçu des commandes Linux les plus importantes Comme la plupart des systèmes d’exploitation modernes, Linux fournit un **shell**, que vous pouvez utiliser pour contrôler votre système à l’aide de **commandes de ligne de commande**. Tous les paramètres que vous définissez via l’interface graphique utilisateur (GUI informatique) peuvent également être effectués sous forme de lignes de commande. Nous vous présentons les commandes Linux les plus importantes et expliquons leur fonction et leur application. ## Liste des 50 commandes Linux les plus importantes
Commande Description
sudo Exécuter des programmes avec les droits d’un autre utilisateur
ls Lister le contenu du répertoire
cd Naviguer dans l’arborescence des répertoires
touch Modifier les dates
mkdir Créer un répertoire
rm Supprimer un fichier
rmdir Supprimer un répertoire
mv Déplacer un fichier ou un répertoire
cp Copier des fichiers ou des répertoires
pwd Afficher la position actuelle dans l’arborescence des répertoires
zip Compresser des fichiers dans des archives zip
unzip Décompresser des fichiers dans des archives zip
ln Créer un lien vers un fichier ou un répertoire
cat Fusionner les contenus des fichiers
grep Rechercher dans les fichiers texte
diff Trouver les différences entre les fichiers texte
cmp Comparer les fichiers octet par octet
tar Écrire et extraire des fichiers dans des archives tar
echo Afficher une chaîne de caractère sur la sortie standard
clear Effacer le contenu du terminal
ssh Se connecter à un autre ordinateur via un « shell » sécurisé
wget Télécharger un fichier directement depuis Internet
ping Envoyer une requête au serveur et mesurer la latence
ftp, sftp Transférer des fichiers via (S)FTP
ip Consulter et configurer des interfaces réseau
apt/pacman/yum Télécharger et gérer les paquets logiciels
netstat Afficher l’état des interfaces réseau
traceroute Suivre les paquets de données
route Afficher et traiter les tables de routage IP
dig Consulter des informations sur le DNS
mount/unmount Monter/démonter les systèmes de fichiers
dd Copier des fichiers, des partitions ou des supports de données au niveau des bits
chmod Gérer les droits d’accès
chown Gérer les droits de propriété
adduser Ajouter/modifier un compte utilisateur
passwd Créer/modifier des mots de passe pour les comptes utilisateur
groupadd Créer des groupes d’utilisateurs
chattr Gérer les attributs des fichiers
lsattr Afficher les attributs des fichiers
chgrp Gérer les affiliations de groupe pour les fichiers et répertoires
man Consulter le manuel d’utilisation du système d’exploitation
shutdown, reboot Éteindre/redémarrer le système
top Vue d’ensemble dynamique des processus
lscpu Afficher les informations sur le processeur
lshw Afficher les informations sur le matériel
kill Arrêter et terminer un processus via son PID
killall Arrêter et terminer des processus par leur nom
nice Définir les priorités des processus
pgrep Identifier le PID via un terme de recherche
ps Afficher la liste de tous les processus en cours d’exécution
### La commande Linux sudo Exécuter des programmes avec les droits d’autres utilisateurs La [commande Linux `sudo`](https://www.ionos.com/fr-be/digitalguide/serveur/configuration/commande-linux-sudo/) (abréviation de *substitute user do*) peut être placée devant les appels de programme pour les exécuter avec les droits d’un autre utilisateur. Un mot de passe doit être en principe saisi à cet effet. La commande `sudo` exige toujours le mot de passe de l’utilisateur appelant. Si la commande est donnée sans nom d’utilisateur, le super-utilisateur *root* est utilisé comme cible. ```bash sudo -u NOMUTILISATEUR APPELPROGRAMME ``` ### La commande Linux ls La commande Linux ls (pour liste) sert à afficher le contenu d’un répertoire (les noms de tous les fichiers et dossiers du répertoire spécifié). La syntaxe de la commande est la suivante : ```bash ls [OPTIONS] REPERTOIRE ``` Si `ls` est utilisé sans spécification de répertoire, la commande liste le contenu du répertoire courant. À l’aide des options supplémentaires, vous pourrez définir quelles informations à afficher et comment. ### La commande Linux cd La [commande `cd`](https://www.ionos.com/fr-be/digitalguide/serveur/configuration/commande-linux-cd/) (pour *change directory*) est utilisée pour la navigation dans l’arborescence des répertoires. Voici la syntaxe de la commande : ```bash cd [OPTION] REPERTOIRE ``` Si aucun répertoire cible n’est spécifié, `cd` passe automatiquement au répertoire *home* de l’utilisateur. Si `cd` est utilisé avec un signe moins (-), il passe au répertoire précédent. ### La commande Linux touch La [commande `touch`](https://www.ionos.com/fr-be/digitalguide/serveur/configuration/commande-linux-touch/) permet de changer les dates d’accès et les modifications des fichiers. Si `touch` est appliquée à un fichier inexistant, ce dernier est automatiquement créé. La commande permet donc de créer des fichiers vides. Utilisez `touch` selon le schéma suivant : ```bash touch [OPTIONS] FICHIER ``` Pour régler un fichier à une date souhaitée, utilisez l’option `-t`, en spécifiant l’heure selon le format `[AA]MMJJhhmm[.ss]`. Exemple : ```bash touch -t 1803231037 fichier.txt ``` La date d’accès et de modification sera fixée au 23 mars 2018, à 10h37. La modification peut être appliquée simplement à l’accès ou à la modification de la date à l’aide des options respectives `-a` et `-m`. Si la commande `touch` est utilisée sans l’option `-t`, la date et heure actuelles sont prises en compte. ### La commande Linux mkdir La [commande Linux `mkdir`](https://www.ionos.com/fr-be/digitalguide/serveur/configuration/commande-linux-mkdir/) signifie *make directory*. Il permet aux utilisateurs de Linux d’établir de nouveaux répertoires. Utilisez la syntaxe suivante pour créer un nouveau répertoire dans le répertoire courant : ```bash mkdir [OPTION] NOMREPERTOIRE ``` Si vous voulez en créer un dans un répertoire cible spécifique, spécifiez le chemin absolu ou relatif vers le répertoire. ### La commande Linux rm La commande Linux rm (*remove*) supprime des fichiers ou des répertoires entiers de manière irrémédiable. L’appel de programme est basé sur le schéma suivant : ```bash rm [OPTIONS] FICHIER/REPERTOIRE ``` Si vous voulez supprimer un répertoire avec tous ses sous-répertoires, utilisez `rm` avec OPTION `-R` (*–recursive*). ### La commande Linux rmdir Si vous voulez supprimer un répertoire spécifique, utilisez la commande `rmdir` (*remove directory*) selon la syntaxe suivante : ```bash rmdir [OPTION] REPERTOIRE ``` Avec `rmdir`, vous ne pouvez supprimer que les répertoires vides. Pour supprimer un répertoire comprenant des fichiers et sous-dossiers, utilisez la commande `rm` (*remove*) avec l’option `-r`. Dans des articles séparés du Digital Guide, vous trouverez d’autres façons de supprimer un fichier Linux ou de supprimer un répertoire Linux. ### La commande Linux mv La [commande Linux `mv`](https://www.ionos.com/fr-be/digitalguide/serveur/configuration/commande-linux-mv/) (*move*) copie un fichier ou un répertoire et supprime l’élément d’origine. Si cela est fait dans le même répertoire, `mv` peut être utilisé pour renommer les fichiers. La commande est basée sur le schéma suivant : ```bash mv [OPTION] SOURCE CIBLE ``` ### La commande Linux cp La commande Linux cp (pour *copy*) est utilisée pour copier des fichiers et des répertoires. La syntaxe de base de la commande est : ```bash cp [OPTIONS] SOURCE CIBLE ``` Sous la SOURCE, on trouvera l’élément à copier. Comme CIBLE du processus de copie, on définira un fichier ou un répertoire. Si vous définissez un fichier existant comme fichier cible, son contenu sera écrasé par celui du fichier source. Autrement, vous pouvez créer un nouveau fichier pour la cible portant le nom de votre choix. ### La commande Linux pwd Utilisez la [commande Linux `pwd`](https://www.ionos.com/fr-be/digitalguide/serveur/configuration/commande-pwd/) (abréviation de *print working directory*) pour faire afficher le nom du répertoire de travail actuel. Voici la syntaxe de la commande : ```bash pwd [OPTIONS] ``` ### La commande Linux zip `zip` permet de compresser plusieurs fichiers dans une archive zip. La syntaxe de la commande est la suivante : ```bash zip FICHIER(S) DESTINATION ``` La DESTINATION est le nom ou le chemin d’accès du fichier zip correspondant. FICHIERS fait référence aux noms ou chemins d’accès des fichiers à compresser (séparés par des espaces). ### La commande Linux unzip Vous pouvez utiliser `unzip` pour extraire des fichiers d’archives zip. La syntaxe est la suivante : ```bash unzip FICHIER.zip -d DESTINATION ``` Ici, FICHIER fait référence à l’archive zip d’où les fichiers doivent être extraits. En option, vous pouvez utiliser l’option -d TARGET pour spécifier un répertoire cible dans lequel les fichiers correspondants doivent être stockés. Sinon, les fichiers sont stockés dans le répertoire habituel. ### La commande Linux ln La commande Linux ln (abréviation pour *link*) permet d’établir un lien vers un fichier ou un répertoire. Ainsi, une autre entrée vers le répertoire est établie, ce qui vous permet d’accéder au fichier correspondant via un autre chemin d’accès. `ln` doit toujours contenir au moins le chemin d’accès du fichier source. ```bash ln [OPTIONS] chemin/vers/fichiersource ``` Dans le cas ci-dessus, le lien est créé sous le même nom dans le répertoire sur lequel vous travaillez. Vous pouvez également spécifier un chemin d’accès cible et nommer le lien comme vous le souhaitez : ```bash ln [OPTIONS] chemin/vers/fichiersource chemin/vers/lien ``` ### La commande Linux cat La commande `cat` (abréviation de *concatenate*) a été développé comme un outil de fusion de contenu de fichier et peut être utilisé comme *pager* pour afficher du contenu dans le terminal. Utilisez la syntaxe suivante pour appeler la commande `cat` dans le terminal pour lire un fichier et le sortir sur `stdout` (sortie standard) : ```bash cat OPTIONS FICHIER ``` Si vous avez plusieurs fichiers, il sera nécessaire de les séparer par des espaces : ```bash cat OPTIONS FICHIER1 FICHIER2 ``` ### La commande Linux grep La commande Linux grep peut être utilisée pour faire une recherche dans les fichiers texte. N’importe quelle chaîne de caractères ou expression régulière peut être utilisée comme modèle de recherche. Utilisez `grep` selon la syntaxe suivante : ```bash grep [OPTIONS] MODELEDERECHERCHE [FICHIER(S)] ``` Si `grep` rencontre une chaîne de caractères correspondant au modèle de recherche, le numéro de ligne est édité dans le terminal avec le nom du fichier. En principe, la commande est appliquée à tous les fichiers du répertoire courant. L’option `-r` permet une recherche récursive dans les sous-répertoires. ### La commande Linux diff `diff` est utilisé pour comparer deux fichiers. Autrement, la commande `diff` peut également être utilisé pour déterminer si deux répertoires contiennent des fichiers identiques. L’appel de la commande dans le terminal est comme suit : ```bash diff [OPTIONS] FICHIER1 FICHIER2 ``` ### La commande Linux cmp `cmp` fait partie du paquet `diff` et est utilisé comme ce dernier pour comparer le contenu des fichiers. À la différence de `diff`, le réglage se fait toutefois octet par octet et est donc particulièrement adapté aux fichiers binaires. Utilisez `cmp` selon le schéma suivant : ```bash cmp [OPTIONS] FICHIER1 FICHIER2 ``` Si `cmp` trouve des différences, le programme en ligne de commande édite l’octet et le numéro de ligne de la première divergence dans le terminal. ### La commande Linux tar La commande `tar` permet d’écrire séquentiellement différents fichiers et répertoires dans un fichier tar et de les restaurer si nécessaire. Contrairement au format zip couramment utilisé sous Windows, tous les droits d’utilisateur du fichier archivé sont conservés même après que ce dernier est décompressé. `tar` est appelé selon la syntaxe suivante : ```bash tar [OPTIONS] FICHIERS ``` Si vous voulez créer une nouvelle archive, utilisez `tar` avec les options `-c` (*create new archive*) et `-f` (*write archive or read from specified file*). Pour en savoir plus, consultez notre article « Créer une sauvegarde avec tar : voici comment fonctionne l’archivage ». ### La commande Linux echo Utilisez la commande `echo` pour émettre des chaînes de caractères (strings) ligne par ligne sur la sortie standard (généralement le terminal). La syntaxe générale de la commande est : ```bash echo [OPTIONS] STRING ``` ### La commande Linux clear Utilisez la commande `clear` pour effacer le contenu de l’écran. ```bash clear ``` Vous obtiendrez un terminal vide avec une invite de commande (prompt). Au lieu d’utiliser cette commande, vous pouvez également vider votre terminal à l’aide de la combinaison de touches \[CTRL\] + \[L\]. ### La commande Linux ssh Vous pouvez utiliser `ssh` pour connecter votre ordinateur à un ordinateur externe via le protocole SSH, ce qui signifie que vous êtes alors dans le shell de l’autre ordinateur. La syntaxe est la suivante : ```bash ssh NOMUTILISATEUR@NOMHÔTE ``` Ici, NOMUTILISATEUR et NOMHÔTE désignent le nom d’utilisateur sous lequel vous souhaitez vous connecter et l’adresse de l’ordinateur externe. ### La commande Linux wget Vous pouvez utiliser la [commande Linux `wget`](https://www.ionos.com/fr-be/digitalguide/serveur/configuration/commande-linux-wget/) pour télécharger des fichiers depuis Internet. Utilisez la syntaxe suivante : ```bash wget [OPTION] LIEN ``` Ici, LIEN indique l’URL où le fichier peut être trouvé. Vous pouvez utiliser l’argument optionnel `-c` pour continuer un téléchargement qui a été interrompu. ### La commande Linux ping Utilisez la [commande Linux `ping`](https://www.ionos.com/fr-be/digitalguide/serveur/configuration/commande-linux-ping/) pour vérifier l’accessibilité des autres ordinateurs du réseau. La commande est basée sur la syntaxe suivante : ```bash ping [OPTIONS] CIBLE ``` En plus du temps aller-retour (*Round trip time*, RTT, ce qui désigne le temps écoulé entre l’envoi du paquet de données et la réception de la réponse), `ping` émet l’adresse IP du système cible sur le terminal. ### La commande Linux ftp ou sftp Cette commande vous permet d’échanger des fichiers entre le système local et un autre ordinateur du réseau. Utilisez FTP (File Transfer Protocol selon le schéma ci-dessous pour établir une connexion avec le serveur FTP de l’ordinateur cible. ```bash ftp [OPTIONS] [HOST[PORT]] ``` L’adressage s’effectue via le nom d’hôte ou l’adresse IP. La spécification d’un numéro de port n’est pas obligatoire. N’utilisez le protocole FTP que dans les réseaux auxquels vous faites confiance, car ce protocole n’est pas sécurisé. Pour des raisons de sécurité, il est presque toujours conseillé d’utiliser SFTP (SSH File Transfer Protocol). Le programme en ligne de commande `sftp` sert comme `ftp` au transfert de données dans le réseau, mais dans ce cas, le transfert est chiffré. SFTP utilise le protocole SSH (Secure Shell) par défaut, ainsi que ses méthodes d’authentification : nous vous expliquons comment utiliser les clés SSH pour votre connexion réseau dans un autre article. ### La commande Linux ip Le programme en ligne de commande `ip` fait partie de la série de programmes `iproute2`, avec laquelle les interfaces réseau peuvent être consultées et configurées via le terminal. La syntaxe générale de la commande est : ```bash ip [OPTIONS] OBJET [COMMANDE [ARGUMENTS]] ``` Pour définir quelle action est exécutée via `ip`, il est nécessaire d’utiliser des objets, des sous-commandes et leurs arguments. Le programme prend en charge divers objets tels que `address` (adresse IP), `link` (interface réseau), `route` (entrée dans la table de routage) ou `tunnel`, auxquels des sous-commandes comme `add`, `change`, `del`, `list` ou `show` peuvent être appliquées. Par exemple, si vous voulez obtenir l’adresse IP d’une interface réseau spécifique (par exemple eth0), utilisez la commande ip avec l’objet address, la commande `show` et l’argument `dev eth0` : ```bash ip address show dev eth0 ``` Découvrez comment afficher une adresse IP sous Linux plus en détail dans un autre article. ### Les commandes Linux apt, pacman et yum Chaque distribution Linux dispose d’un **Packet Manager** qui permet de télécharger et de gérer les paquets de logiciels. La syntaxe pour l’installation d’une application est la suivante : ```bash apt install [PACKET] # Distributions basées sur Debian comme Ubuntu pacman -S [PACKET] # Distributions basées sur Arch yum install [PACKET] # Distributions basées sur Red Hat ``` `[PACKET]` est le nom du paquet ou du programme que vous voulez installer. Dans la plupart des cas, ces commandes doivent être exécutées via `sudo` en mode root. Pour les autres distributions qui utilisent d’autres gestionnaires de paquets, les commandes peuvent être différentes. Chaque gestionnaire a également des commandes pour supprimer des paquets, mettre à jour la liste des paquets et mettre à jour tous les paquets installés, entre autres. Sur Ubuntu, ces commandes sont les suivantes : ```bash apt remove [PACKET] # supprimer un paquet apt update # mettre à jour la liste des paquets apt upgrade # mettre à jour les paquets ``` ### La commande Linux netstat Le programme en ligne de commande `netstat` est utilisé pour consulter l’état des interfaces réseau. La syntaxe générale de la commande est : ```bash netstat [OPTIONS] ``` Utilisez `netstat` sans option pour afficher toutes les sockets ouvertes dans le terminal. Vous pouvez également utiliser les options suivantes pour afficher les tables de routage (`-r`), les statistiques d’interface (`-i`), les connexions masquées (`-M`) ou les messages netlink (`-N`). Apprenez tout ce qu’il y a à savoir sur le sujet dans notre article d’introduction à netstat. ### La commande Linux traceroute Pour suivre le chemin de transfert d’un paquet de données IP entre votre système et un ordinateur cible, vous pouvez utiliser la commande Linux traceroute. Utilisez la syntaxe suivante : ```bash traceroute [options] NOMHOTE ``` `traceroute` peut être utilisé pour identifier quel routeur et points d’échange Internet un paquet IP traverse en allant vers l’ordinateur cible (par exemple pour rechercher la cause d’un retard). ### La commande Linux route Le programme en ligne de commande `route` peut être utilisé pour consulter et éditer les tables de routage IP du noyau. La commande est basée sur la syntaxe suivante : ```bash route [OPTIONS] [add|del] [-net|-host] CIBLE ``` Utilisez la commande sans option pour afficher la table de routage complète du noyau : ```bash route ``` Pour définir un itinéraire vers un réseau, utilisez la sous-commande `add`. ```bash route add -net 10.0.0.0 ``` ### La commande Linux dig `dig` est un outil de recherche permettant de consulter des informations des serveurs DNS et de les émettre dans le terminal. L’utilitaire en ligne de commande est généralement utilisé pour consulter l’adresse IP et d’autres informations DNS pour un nom de domaine donné. Le schéma suivant est alors utilisé : ```bash dig [@SERVER] [DOMAIN] [TYP] ``` SERVER est le serveur DNS dans lequel l’information désirée est recherchée. Si aucun serveur n’est spécifié, `dig` récupère le serveur DNS par défaut à partir de `/etc/resolv.conf`. DOMAIN représente le nom de domaine pour lequel l’information DNS doit être retrouvée. Avec TYP, le type de requête peut être fixé, par exemple ANY (toutes les entrées), A (enregistrement IPv4 d’un hôte) ou AAAA (enregistrement IPv6 d’un hôte). Le type défini par défaut est A. ### La commande Linux mount/unmount Si un système de fichiers doit être intégré dans la structure de répertoire du système d’exploitation, le programme en ligne de commande `mount` est utilisé sous Linux. La syntaxe générale de la commande est : ```bash mount [OPTIONS] PERIPHERIQUE MOUNTPOINT ``` PERIPHERIQUE = Le chemin d’accès du périphérique de stockage que vous voulez monter en tant que partition. MOUNTPOINT = L’emplacement de la structure de répertoire de votre système d’exploitation où vous voulez monter la partition. Le point de montage est généralement spécifié comme un chemin absolu. Exemple : ```bash mount /dev/sdd /media/usb ``` Le périphérique `sdd` est monté dans le répertoire `/media/usb`. ### La commande Linux dd Le programme en ligne de commande `dd` permet un processus de copie dans lequel les données sont lues bit par bit à partir d’un fichier d’entrée (`if`) et écrites dans un fichier de sortie (`of`). La syntaxe pour appeler le programme est la suivante : ```bash dd if=Source of=Cible [OPTIONS] ``` La source et la cible données peuvent très bien être des fichiers individuels, tout comme des partitions entières (par ex. `/dev/sda1`) ou un périphérique de stockage complet (par ex. `/dev/sda`). Exemple : ```bash dd if=/dev/sda5 of=/dev/sdb1 ``` ### La commande Linux chmod Le programme en ligne de commande `chmod` (abréviation de *change mode*) est utilisé pour attribuer des droits dans les systèmes de fichiers unixoid (par exemple ext2, ext3, ext4, reiser, xfs). La syntaxe générale de la commande est la suivante : ```bash chmod [OPTIONS] MODE FICHIER ``` ou : ```bash chmod [OPTIONS] MODE REPERTOIRE ``` Le MODE sert pour le masque de droits applicable. Pour en savoir plus, notre article sur l’attribution des droits d’accès avec chmod détaille la manière de s’y prendre. L’option `-R` permet d’étendre les permissions aux sous-dossiers et fichiers contenus dans un répertoire. ### La commande Linux chown La [commande `chown`](https://www.ionos.com/fr-be/digitalguide/serveur/configuration/commande-chown/) signifie *change owner* et permet donc de modifier les paramètres propriétaires. ```bash chown [OPTIONS] [UTILISATEUR][:[GROUPE]] FICHIER ``` ou : ```bash chown [OPTIONS] [UTILISATEUR][:[GROUPE]] REPERTOIRE ``` Il y a quatre combinaisons possibles pour définir les droits propriétaire pour les utilisateurs ou les groupes. Il est possible de réinitialiser le propriétaire et le groupe selon les spécifications suivantes : ```bash chown [OPTIONS] proprietaire_nom:groupes_nom fichier.txt ``` ```bash # Pour réinitialiser le groupe (l’utilisateur reste inchangé), on suivra : chown [OPTIONS] :groupes_nom fichier.txt # Pour réinitialiser le propriétaire (le groupe reste inchangé), on suivra : chown [OPTIONS] propriétaire_nom fichier.txt # Pour réinitialiser l’utilisateur en fonction de la spécification (e groupe est défini sur le groupe par défaut de l’utilisateur connecté), on suivra : chown [OPTIONS] propriétaire_nom: fichier.txt # Les modifications peuvent être étendues aux sous-répertoires en utilisant OPTION `-R`. ``` ### La commande Linux adduser La façon la plus simple de créer un compte utilisateur est d’utiliser le programme en ligne de commande `adduser`. Il s’agit d’un script Perl basé sur la [commande Linux `useradd`](https://www.ionos.com/fr-be/digitalguide/serveur/configuration/commande-linux-useradd/) et qui offre les mêmes fonctions de manière conviviale. La commande `adduser` nécessite les privilèges de l’utilisateur root et s’utilise selon la syntaxe suivante : ```bash adduser [OPTIONS] NOMUTILISATEUR ``` Si vous utilisez `adduser` sans options, un ID utilisateur, le répertoire d’accueil et un groupe d’utilisateurs du même nom seront automatiquement créés en plus du nouveau compte. ```bash adduser test ``` Un dialogue est ensuite généré, dans lequel vous pouvez définir le mot de passe et les informations utilisateur avancées (nom réel, numéro de bureau, numéros de téléphone, etc.). ### La commande Linux passwd Utilisez la [commande Linux `passwd`](https://www.ionos.com/fr-be/digitalguide/serveur/configuration/commande-passwd/) pour changer le mot de passe d’un utilisateur ou pour définir des intervalles de modification ou verrouillage de ce mot de passe. La commande est basée sur la syntaxe suivante : ```bash passwd [OPTIONS] NOMUTILISATEUR ``` Si vous voulez changer le mot de passe d’un autre utilisateur, vous avez besoin des droits root. Utilisez la commande passwd sans nom d’utilisateur pour changer votre propre mot de passe. Pour verrouiller le mot de passe de l’utilisateur sélectionné, utilisez la commande `passwd` avec l’option `-l` (*-lock*). D’autres options offrent la possibilité de définir une période d’expiration pour les mots de passe (`-x`) ainsi que des intervalles de temps pour les avertissements (`-w`) ou le verrouillage (`-i`) : ### La commande Linux groupadd La ligne de commande `groupadd` est utilisée pour établir de nouveaux groupes d’utilisateurs. Utilisez groupadd avec des droits root selon le schéma suivant : ```bash sudo groupadd [OPTIONS] GROUPE ``` Chaque groupe créé reçoit un ID de groupe unique (GID). Les ID de groupe compris entre 0 et 99 sont réservés aux groupes systèmes. Si vous voulez définir vous-même le GID d’un nouveau groupe d’utilisateurs, utilisez la commande `groupadd` avec l’option `-g` (GID). Si vous voulez créer un groupe système, utilisez l’option `-r` (root). ### La commande Linux chattr Le programme en ligne de commande `chattr` (abréviation de *change attribute*) permet d’octroyer des attributs aux fichiers ou répertoires. Utilisez `chattr` selon la syntaxe suivante pour définir un attribut : ```bash chattr [OPTIONS] +ATTRIBUT FICHIER ``` Remplacez le signe plus par un signe moins pour supprimer à nouveau les attributs. Par exemple, définissez l’attribut `-i` pour empêcher les changements (suppressions ou modifications) d’un fichier ou d’un répertoire. D’autres attributs et options possibles peuvent être trouvés dans la page d’aide du programme `chattr`. ### La commande Linux lsattr Si vous voulez afficher les attributs qui ont été définis pour un fichier ou un répertoire, utilisez la commande `lsattr` (abréviation de *list attributes*) selon le schéma suivant : ```bash lsattr [OPTIONS] FICHIER/REPERTOIRE ``` ### La commande Linux chgrp La commande `chgrp est l’abréviation de`*change group*. Elle est utilisée pour gérer les appartenances d’un groupe à des fichiers et répertoires. Pour appliquer `chgrp` à un fichier ou répertoire sélectionné, vous devez avoir des droits propriétaire ou root. En outre, seuls les groupes auxquels vous appartenez vous-même sont disponibles pour la sélection. `chgrp` est utilisé selon la syntaxe suivante : ```bash chgrp [OPTIONS] GROUPE FICHIER ``` ou : ```bash chgrp [OPTIONS] GROUPE REPERTOIRE ``` L’option `-R` inclut les sous-dossiers et les fichiers contenus dans un répertoire. ### La commande Linux man La commande `man` ouvre les pages de manuel de votre distribution Linux (*Man-Pages*) directement dans le terminal. Utilisez le schéma suivant pour accéder à une page de manuel : ```bash man [OPTION] SUJET ``` Les pages manuels Linux sont divisées en 10 domaines : commandes utilisateur, appel système, fonctions du langage de programmation C, fichiers spécifiques, formats de fichier, jeux, divers, commandes pour l’administration du système, fonctions cœur (noyau Linux), nouvelles commandes. ### La commande Linux shutdown La commande `shutdown` peut être utilisée par les utilisateurs root pour arrêter le système. Elle est basée sur la syntaxe suivante : ```bash shutdown [OPTIONS] [TEMPS] [MESSAGE] ``` Si vous souhaitez procéder à un arrêt du système, vous pouvez définir une heure. Utilisez un temps spécifique (hh:mm) ou un compte à rebours (+m). Les autres utilisateurs du système reçoivent une annonce d’arrêt. Si nécessaire, il peut être complété par un message individuel. Si la commande `shutdown` est utilisée avec l’option `-r`, un redémarrage suit l’arrêt du système. ### La commande Linux top Utilisez la commande `top` pour obtenir une vue d’ensemble dynamique de tous les processus en cours d’exécution. L’appel repose sur le schéma suivant : ```bash top [OPTIONS] ``` La sortie des informations des processus peut être personnalisée à l’aide de diverses options. En outre, l’aperçu des processus `top` prend en charge (entre autres choses) les touches de raccourci suivantes pour trier les sorties : - \[P\] = Trie les sorties par charge CPU - \[M\] = Trie les sorties en fonction de l’utilisation de la mémoire - \[N\] = Trie les sorties numériquement par PID - \[A\] = Trie les sorties suivant l’ancienneté - \[T\] = Trie les sorties en fonction du temps - \[U NOMUTILISATEUR ou UID\] = Trie les sorties en fonction de l’utilisateur Utilisez la touche de raccourci \[H\] pour afficher une page d’aide et \[Q\] pour quitter l’aperçu du processus. ### La commande Linux lscpu Utilisez `lscpu` (abréviation de *list cpu*) selon le schéma suivant pour afficher dans le terminal les informations sur l’architecture CPU. ```bash lscpu [OPTIONS] ``` Pour les options possibles, reportez-vous aux pages d’aide de votre système d’exploitation. ### La commande Linux lshw La commande `lshw` (pour *list hardware*) affiche des informations sur les composants hardware du terminal. Utilisez `lshw` selon le schéma suivant : ```bash lshw [OPTIONS] ``` La commande prend en charge différentes options pour personnaliser le format de sortie (`-html`, `-xml`, `-short`, `-businfo`) et la quantité d’informations (par exemple `-sanitize` pour cacher les informations sensibles). ### La commande Linux kill `kill` est un programme en ligne de commande qui peut être utilisé pour arrêter et mettre fin aux processus. La commande est passée selon le schéma ci-dessous en spécifiant le signal souhaité et l’ID du processus sélectionné. ```bash kill [OPTIONS] [-SIGNAL] PID ``` Les signaux courants sont : 1. `TERM` : fait en sorte qu’un processus se termine tout seul (par défaut) 2. `KILL` : force un processus à prendre fin (par le système) 3. `STOP` : arrête un processus 4. `CONT` : reprend un processus arrêté ### La commande Linux killall Utilisez la [commande Linux `killall`](https://www.ionos.com/fr-be/digitalguide/serveur/configuration/commande-killall/) avec un terme de recherche spécifique pour ne terminer que les processus dont les noms correspondent exactement (les 15 premiers caractères sont comparés). ```bash killall [OPTIONS] [-SIGNAL] [NOMPROCESSUS] ``` L’option `-e` (*–exact*) permet d’étendre le réglage à tous les caractères du nom du processus. ### La commande Linux nice La commande `nice` attribue une valeur comprise entre -20 et +19 à un processus au démarrage, après quoi la puissance de traitement disponible du système est distribuée. L’intervalle de -20 à +19 correspond aux niveaux de priorité Linux de 100 à 139. Un processus avec une valeur `nice` de -20 a ainsi une priorité plus élevée qu’un processus avec une valeur `nice` de 19. La syntaxe seule est : ```bash nice [OPTION] [COMMANDE] ``` Sans autre spécification, chaque processus commence avec une valeur `nice` de 0. Utilisez l’option `-n` pour définir les priorités du processus. Notez que les priorités négatives ne peuvent être assignées qu’avec des droits root. ### La commande Linux pgrep Le programme en ligne de commande `pgrep` compare la liste des processus en cours d’exécution à un terme de recherche et affiche leurs PID respectifs s’ils correspondent. La syntaxe générale de l’appel est : ```bash pgrep [OPTIONS] TERMEDERECHERCHE ``` Par défaut, `pgrep` édite les PID de tous les processus qui contiennent le terme de recherche. Si vous souhaitez limiter la recherche à des correspondances exactes, utilisez la commande avec l’option `-x`. Si vous voulez récupérer le nom du processus avec le PID, utilisez `pgrep` avec l’option `-l`. `pgrep` prend en compte (comme `grep`) les termes de recherche basés sur des expressions régulières. ### La commande Linux ps La [commande Linux `ps`](https://www.ionos.com/fr-be/digitalguide/serveur/configuration/commande-linux-ps/) affiche une liste de tous les processus en cours d’exécution dans le terminal. ```bash ps [OPTIONS] ``` Si vous avez besoin d’une sortie détaillée, utilisez `ps` avec les options `-f` (détaillé) ou `-F` (très détaillé). Vous trouverez d’autres options possibles dans les pages de manuel de votre système d’exploitation. ### Les commandes Linux de bases Dans ce chapitre, vous trouverez des commandes Linux essentielles à connaître qui sont utilisées pour **contrôler le terminal**. Apprenez comment effacer la zone de visualisation du terminal, récupérer des entrées de terminal précédentes depuis l’historique ou terminer la session du terminal. **1. exit** La commande `exit` termine la session en cours et ferme le terminal. ```bash exit ``` Vous pouvez également utiliser la combinaison de touches \[CTRL\] +\[D\]. **2. help** Utilisez la commande `help` pour afficher une liste de toutes les commandes shell intégrées. Utilisez `help` directement avec une commande shell pour afficher une courte description de la commande correspondante. ```bash help COMMANDE ``` **3. history** Dans le *bash*, les 500 dernières commandes que vous avez saisies (par ligne de commande) sont enregistrées dans l’historique (*history*). Cette fonction peut aider à la saisie des commandes. Elle permet en effet d’effectuer une recherche dans la liste des commandes précédemment saisies (grâce aux touches fléchées) et de les exécuter à nouveau. L’historique peut être recherché par mots-clés à l’aide de la combinaison \[CTRL\] +\[R\]. Vous avez également la possibilité d’afficher la liste complète numérotée dans le terminal. Utilisez la commande history sans options ni arguments : ```bash history ``` Si vous voulez filtrer la sortie, combinez *history* via le pipe Linux avec le programme en ligne de commande `grep` (voir les options de recherche) et un mot-clé. ```bash History | grep MOTDERECHERCHE ``` ### Pages d’aide Vous ne savez pas comment résoudre l’un de vos problèmes ? Pas de panique : sous Linux, diverses **pages d’aide et de documentation** telles que *Unix-Man-Pages* et les *pages d’information GNU* sont disponibles directement depuis le terminal. Celles-ci comprennent une description détaillée de tous les utilitaires en lignes de commande, les appels système, les fichiers de configuration, les formats de fichiers et le cœur des fonctions. Avec la [commande Linux `whatis`](https://www.ionos.com/fr-be/digitalguide/serveur/configuration/commande-whatis/) et `apropos`, vous pouvez trouver des programmes en ligne de commande dans la catégorie des pages d’aide, qui vous permettent ensuite de rechercher des mots-clés dans les pages de manuel de votre système d’exploitation. **1. apropos** Utilisez `apropos` pour rechercher des mots-clés dans les titres de pages et les descriptions des pages de manuel de votre système d’exploitation. Orientez-vous vers le schéma suivant : ```bash apropos [OPTIONS] MOTDERECHERCHE ``` La commande prend en charge différentes options. Limitez la recherche aux correspondances exactes avec l’option `-e` ou utilisez des caractères de remplacement (`-w'*MOTDERECHERCHE'`) et des expressions régulières (`-r`). **2. info** La commande `info` peut être utilisée pour produire des pages d’information GNU sur un sujet spécifique. Dans la plupart des cas, il s’agit de pages de manuel accessibles via `man`, mais à la différence de celles-ci, des liens vont faciliter la navigation dans le manuel. Utilisez la syntaxe suivante : ```bash info [OPTION] SUJET ``` Un appel sans option et sans sujet spécifié vous amène au menu principal des pages d’information GNU. **3. pinfo** `pinfo` est une variante du programme en lignes de commande `info`, centrée sur le navigateur Lynx et qui affiche des pages d’information avec des liens surlignés. Utilisez `pinfo` selon le même schéma que la commande `info` : ```bash pinfo [OPTIONS] SUJET ``` **4. whatis** Le programme en lignes de commande `whatis` est utilisé pour rechercher des mots-clés dans les pages de manuel. Appelez le programme avec le terme de votre choix pour rechercher des correspondances exactes dans le manuel de votre système d’exploitation. S’il trouve un équivalent, `whatis` émet une courte description dans le terminal. ```bash whatis [OPTIONS] MOTDERECHERCHE ``` `whatis` prend également en charge les mots de remplacement (`-w\'*MOTDERECHERCHE'`) et les expressions régulières (`-r`). ### Opérations sur les répertoires Les commandes Linux s’utilisent pour les opérations sur les répertoires ; elles permettent ainsi de créer, supprimer et gérer vos répertoires sur votre système via le terminal mais aussi de naviguer dans l’arborescence des répertoires. Parmi les commandes plus importantes de cette catégorie, on trouve `cd`, `ls`, `mkdir`, `rmdir`. **1. chroot** La commande `chroot` (abréviation de *change + root*) est utilisée pour exécuter une commande dans un autre répertoire racine. Par exemple, `chroot` peut isoler les programmes critiques du reste du système de fichiers. L’utilisation du programme nécessite des droits root. Il est basé sur le schéma suivant : ```bash chroot REPERTOIRE COMMANDE ``` **2. mkdirhier** Avec `mkdirhier`, vous pouvez créer des hiérarchies de répertoires entiers avec une seule ligne de commande : ```bash mkdirhier [OPTION] /home/user/repertoire1/repertoire2/repertoire3 ``` Si `repertoire1` et `repertoire2` existent déjà, `mkdirhier` crée simplement `repertoire3`. Autrement, ce sont les trois répertoires qui sont créés. **3. tree** Alors que `ls` ne liste que le contenu des répertoires, la hiérarchie complète peut être affichée de manière récursive sous la forme d’une arborescence grâce au programme en ligne de commande `tree`. L’appel est effectué selon la syntaxe suivante : ```bash tree [OPTIONS] [REPERTOIRE] ``` ### Opérations sur les fichiers Les commandes Linux de cette section vous permettent d’effectuer diverses opérations sur les fichiers à partir du terminal. Utilisez les commandes Linux de base telles que `cp`, `mv` et `rm` pour copier, déplacer, renommer ou supprimer des fichiers de votre système. **1. basetree** Un chemin d’accès est remis à la commande `basename`. Il renvoie directement au nom de fichier sans que le chemin d’accès antéposé ne doive être spécifié. La syntaxe de la commande correspond à la suivante : ```bash basename [OPTIONS] Chemin/vers/fichier [SUFFIXE] ``` La commande peut être étendue à plusieurs fichiers à l’aide d’options. **2. comm** Utilisez le programme en ligne de commande `comm` pour comparer des fichiers classés (par exemple avec `sort`) ligne par ligne. L’appel est basé sur la syntaxe suivante : ```bash comm [OPTIONS] FICHIER1 FICHIER2… ``` Le programme prend en charge trois options : - 1 = supprime les lignes uniquement présentes dans FICHIER1 - 2 = supprime les lignes uniquement présentes dans FICHIER2 - 3 = supprime toutes les lignes contenues dans les deux fichiers **3. cut** La commande `cut` vous permet d’extraire un contenu bloc par bloc à partir du texte d’un fichier (par exemple, les fichiers log ou CSV). La syntaxe de la commande correspond à : ```bash cut [OPTIONS] FICHIER ``` La position exacte de la section à extraire est définie à l’aide des options `-b` (position des octets), `-c` (position des caractères), `-d` (séparateur) et `-f` (champ). **4. dirname** `dirname` est la contrepartie de `basename`. Cette commande Linux permet d’extraire la partie du chemin d’accès vers le fichier et de l’émettre dans le terminal sans nom de fichier. La syntaxe de la commande est la suivante : ```bash dirname [OPTIONS] ``` **5. file** La commande `file` peut être utilisée pour fournir des informations sur le type d’un fichier. L’appel repose sur le schéma suivant : ```bash file [OPTIONS] FICHIER ``` **6. lsof** La [commande Linux `lsof`](https://www.ionos.com/fr-be/digitalguide/serveur/configuration/linux-lsof/) est l’abréviation de *list open files*, un programme d’aide qui affiche des informations sur les fichiers ouverts triés par le PID (identifiant de processus) dans le terminal. L’appel via le terminal s’effectue selon le schéma suivant : ```bash lsof [OPTIONS] ``` Puisque les systèmes unixoïdes comme Linux suivent le principe « Everything is a file » (Tout est un fichier), la liste des sorties `lsof` peut être longue. En règle générale, des options sont par conséquent utilisées pour limiter les sorties. **7. md5sum** La commande `md5sum` peut être utilisée pour calculer et vérifier les checksums MD5 ou l’empreinte d’un fichier. **8. paste** Tout comme `cat`, le programme en ligne de commande `paste` permet d’éditer des contenus de fichiers sur la sortie standard. Mais alors que `cat` ne fait qu’ajouter des contenus les uns aux autres, `paste` les relie par colonnes. Le schéma de base de la commande est le suivant : ```bash paste [OPTIONS] FICHIER1 FICHIER2 … ``` Le séparateur utilisé par `paste` peut être personnalisé à l’aide de l’option `-d`. Les tabulations servent de séparateur par défaut. L’option `-s` (mode sériel) permet d’activer un deuxième mode : dans ce mode, toutes les lignes des fichiers d’entrée sont transférées dans la sortie, chaque ligne contenant le contenu d’un seul fichier d’entrée. **9. rename** `rename` est un programme en ligne de commande qui vous permet de renommer des fichiers et dossiers en utilisant des expressions régulières (regex) compatibles perl. Contrairement à `mv`, `rename` convient aux opérations sur les fichiers où les noms de plusieurs fichiers doivent être partiellement ou complètement adaptés. Utilisez `rename` selon le schéma suivant : ```bash rename [OPTIONS] 'EXPRESSION_REGULIERES' FICHIERS ``` Les expressions régulières correspondent à la syntaxe suivante pour les remplacements : ```bash s/MODELEDERECHERCHE/REMPLACEMENT/MODIFIER ``` **10. shred** `shred` est un programme en ligne de commande qui vous permet de supprimer des fichiers en toute sécurité. Les éléments sélectionnés sont écrasés pendant le processus de suppression et ne peuvent pas être restaurés. La syntaxe générale de la commande est : ```bash shred [OPTIONS] FICHIER ``` **11. sort** Utilisez la commande `sort` pour trier les listes de fichiers et les sorties de programme ligne par ligne, numériquement et alphabétiquement. Voici la syntaxe générale de la commande : ```bash sort [OPTIONS] FICHIER ``` La méthode de tri peut être personnalisée à l’aide d’options : par exemple, de manière numérique (`-n`), aléatoire (`-R`) ou selon l’ordre inverse (`-r`). **12. split** La commande `split` est utilisée pour diviser des fichiers. La syntaxe sous-jacente est : ```bash split [OPTIONS] [INPUT [PREFIXE]] ``` La partie INPUT correspond au fichier à fractionner. Indiquez ensuite le préfixe pour les noms des fichiers divisés. Le préfixe est basé sur le schéma suivant : ```bash PREFIXEaa, PREFIXEab, PREFIXEac … ``` Si aucun préfixe n’est défini, `split` utilise le préfixe standard `x`. L’option `-b` (octets) peut être utilisée pour fixer la taille des fichiers divisés. La spécification peut être en octets (b), kilo-octets (k) ou mégaoctets (m). Exemple : ```bash split -b 95m archive.tgz split-archive.tgz. ``` **13. stat** La commande `stat` (*statut*) peut être utilisée pour afficher les dates des accès et modifications des fichiers et répertoires sélectionnés. La syntaxe générale de la commande est : ```bash stat [OPTIONS] FICHIER ``` Le format de sortie peut être ajusté à l’aide d’options. **14. uniq** La commande Linux `uniq` est généralement utilisée avec `sort` pour se débarrasser des lignes en double des fichiers triés. Dans l’exemple suivant, la commande `sort` est reliée à `uniq` par le pipe (`|`) pour trier tout d’abord le fichier et ensuite éliminer les doublons : ```bash sort fichier.txt | uniq ``` ### Options de recherche Linux offre diverses commandes avec lesquelles il est possible d’effectuer des recherches directement depuis le terminal. **1. find** La commande Linux find est un programme en ligne de commande utilisé pour rechercher des fichiers. L’appel de programme est basé sur la syntaxe suivante : ```bash find [OPTIONS] [REPERTOIRE] [CONDITIONSDERECHERCHE][ACTIONS] ``` Le répertoire spécifié est le point de départ de la recherche. La recherche est alors effectuée dans ce répertoire ainsi que ses sous-répertoires. Si vous ne spécifiez pas de répertoire, `find` lance la recherche à partir du répertoire courant. Les options vous permettent de définir des critères de recherche et des actions. L’action par défaut est `-print`, qui permet d’afficher les noms complets des fichiers correspondants sur la sortie standard, en général le terminal. Les critères de recherche courants sont le nom du fichier, un nom d’utilisateur, la taille du fichier, le jour de l’accès au fichier ou le jour des modifications effectuées. Elles sont listées dans la page de manuel Linux correspondante. **2. locate** Le programme en ligne de commande `locate` permet également de rechercher des fichiers via le terminal. Contrairement à `find`, cependant, ce n’est pas le répertoire de fichiers qui est fouillé, mais plutôt une base de données dédiée à cette fin et régulièrement mise à jour. Par conséquent, `locate` permet d’obtenir des résultats de recherche beaucoup plus rapidement que `find`. Pour rechercher un fichier spécifique dans la base de données, `locate` est appelé selon le schéma suivant : ```bash locate MODELEDERECHERCHE ``` Le modèle de recherche peut contenir des métacaractères tels que des caractères de remplacement (`*`). Mettez-les entre guillemets pour empêcher une interprétation par le Shell. **3. tre-agrep** `tre-agrep` est également utilisé pour rechercher sur la base de modèles de recherche des strings dans les fichiers texte. Contrairement à `grep`, non seulement les correspondances exactes sont émises, mais aussi les correspondances moins précises telles qu’avec des inversions de lettres ou autres coquilles. Le programme est basé sur la bibliothèque TRE. La syntaxe de `tre-agrep` correspond à celle de la commande `grep` : ```bash tre-agrep [OPTIONS] MODELEDERECHERCHE FICHIER(S) ``` Dans les options, vous pouvez définir le nombre maximum d’erreurs autorisées. Dans l’exemple suivant, un seul écart est toléré par rapport au modèle de recherche. ```bash tre-agrep -1 'Linux' test.txt ``` **4. updatedb** Une recherche via `locate` ne fonctionnera de manière fiable que si le fichier `/var/lib/locatedb` est continuellement tenu à jour. La commande `updatedb` permet donc de mettre à jour la base de données manuellement. Notez que vous avez besoin pour ce faire de disposer des droits root : ```bash updatedb ``` **5. whereis** Avec la commande `whereis`, vous pouvez localiser les fichiers binaires, de code source ou les manuels des programmes sélectionnés. La syntaxe générale de la commande est : ```bash whereis [OPTIONS] PROGRAMME ``` À l’aide des options, vous pouvez limiter la recherche à des types de fichiers ou des répertoires spécifiques. **6. which** Si vous voulez retrouver le fichier binaire d’un programme, utilisez la commande `which` selon le schéma ci-dessous, qui permet d’afficher le chemin dans le terminal. ```bash which [OPTIONS] PROGRAMME ``` En mode par défaut `which` émet le premier fichier qui est trouvé. Utilisez l’option `-a` pour afficher tous les fichiers qui correspondent au critère de recherche. ### Informations utilisateurs Utilisez les programmes en ligne de commande de la catégorie suivante pour obtenir des **informations détaillées sur les utilisateurs enregistrés dans le système** ainsi que leurs groupes et processus. **1. finger** Le programme en ligne de commande `finger` est utilisé pour récupérer des informations sur les utilisateurs. La commande `finger` est donnée avec le nom de l’utilisateur en question : ```bash finger [Options] [NOMUTILISATEUR] ``` Utilisez finger sans nom d’utilisateur pour récupérer des informations sur votre propre compte. **2. groups** La commande `groups` dresse la liste des membres d’un groupe d’un compte utilisateur sélectionné. Utilisez la commande en ligne de commande selon le schéma suivant : ```bash groups [OPTIONS] [NOMUTILISATEUR] ``` Utilisez `groups` sans nom d’utilisateur pour lister tous les groupes auxquels votre compte utilisateur appartient. **3. id** La commande `id` émet les identifiants d’utilisateur et de groupe du compte utilisateur sélectionné. Vous pouvez récupérer vos propres identifiants en passant la commande sans nom d’utilisateur. ```bash id [OPTIONS] [NOMUTILISATEUR] ``` La portée de la sortie peut être limitée à l’aide des options. **4. last** Utilisez la commande `last` selon le schéma ci-dessous pour obtenir la liste des utilisateurs qui se sont connectés en dernier, avec leur temps de connexion et de déconnexion : ```bash last [OPTIONS] ``` Les informations correspondantes sont extraites du fichier wtmp sous `/var/log/wtmp`. Si vous voulez seulement consulter les informations d’un compte spécifique, saisissez la commande avec le nom d’utilisateur de votre choix. ```bash last [OPTIONS] [NOMUTILISATEUR] ``` **5. w** La commande `w` affiche une liste de tous les utilisateurs connectés, avec l’ensemble des processus qu’ils exécutent. Utilisez `w` en combinaison avec un nom d’utilisateur pour restreindre la commande à cet utilisateur : ```bash w [OPTIONS] [NOMUTILISATEUR] ``` Si nécessaire, l’étendue et le format de la sortie peuvent être ajustés à l’aide des options. **6. who** La commande `who` permet d’afficher des informations détaillées sur les utilisateurs connectés sur le système. La syntaxe générale de l’appel est la suivante : ```bash who [OPTION] [FICHERSOURCE] ``` `who` prend en charge diverses options permettant d’ajuster la sortie d’informations. Par défaut, `who` recouvre à partir du fichier `/var/run/run/utmp` les données des utilisateurs alors connectés. Pour récupérer des informations sur les logins précédents, utilisez `who` avec le fichier source `/var/log/wtmp` : **7. whoami** Utilisez la commande `whoami` pour récupérer votre propre nom d’utilisateur. ```bash whoami [OPTIONS] ``` ### Gestion des comptes utilisateurs Linux offre une série de programmes avec lesquels vous pouvez créer, supprimer et gérer les comptes utilisateurs et groupes directement à partir du terminal. Nous avons compilé ci-dessous un aperçu des commandes Linux les plus importantes **pour la gestion des comptes utilisateurs**. Dans cette catégorie, vous trouverez également des commandes de terminal Linux qui vous permettent d’appeler des programmes avec les droits d’autres utilisateurs, y compris des super users Root. **1. chfn** La commande `chfn` (abréviation de *change finger*) permet de configurer les informations avancées d’un compte utilisateur telles que le nom réel, l’emplacement de son bureau et les numéros de téléphone privés et professionnels. La syntaxe générale de chfn est : ```bash chfn [OPTION "NOUVELLE VALEUR"] [NOMUTILISATEUR] ``` Vous pouvez définir les informations utilisateur que vous souhaitez remplacer par une nouvelle valeur à l’aide des options `-f` (nom réel), `-r` (emplacement de bureau), `-w` (numéro professionnel) et `-h` (numéro personnel). **2. chsh** La commande `chsh` (abréviation de *change shell*) modifie le shell de connexion d’un utilisateur sélectionné. Orientez-vous vers le schéma suivant lors de la saisie des données : ```bash chsh [OPTIONS] NOMUTILISATEUR ``` Pour ajuster le shell de connexion d’un utilisateur, `chsh` est utilisé avec l’option `-s`. **3. deluser** `deluser` permet de supprimer dans les fichiers du compte système toutes les entrées d’un compte utilisateur sélectionné. L’utilisation de deluser nécessite des droits root et est basée sur le schéma suivant : ```bash deluser [OPTIONS] NOMUTILISATEUR ``` Si vous souhaitez également supprimer tous les fichiers du répertoire personnel de l’utilisateur, utilisez la commande avec l’option `--remove-home`. Si tous les fichiers utilisateurs doivent être supprimés du système, l’option `--remove-all-files` est utilisée. **4. delgroup** La commande `delgroup` (abréviation de *delete group*) permet de supprimer un groupe d’utilisateurs existant. Les droits roots sont nécessaires pour pouvoir exécuter la commande. La syntaxe générale de `delgroup` est : ```bash delgroup [OPTIONS] GROUPE ``` **5. groupmod** Via `groupmod`, le nom et le GID d’un groupe d’utilisateurs existant peuvent être ajustés. La commande en ligne de commande est utilisée avec les droits root selon le schéma suivant : ```bash groupmod OPTIONS GROUPE ``` Utilisez `groupmod` avec l’option `-g` pour personnaliser le GID. L’utilisation de l’option `-n` permet de renommer le nom du groupe. **6. newgrp** `newgrp` (abréviation de *new group*) est une commande qui permet aux utilisateurs connectés de changer leur ID de groupe sans avoir à se connecter et se déconnecter à nouveau. La syntaxe générale de la commande est : ```bash newgrp [-] [GROUPE] ``` Si `newgrp` est remis avec le paramètre optionnel \[-\], le changement de groupe entraîne un redémarrage de l’environnement utilisateur, comme si l’utilisateur s’était reconnecté. Les utilisateurs qui utilisent `newgrp` sans spécification de groupe bascule vers le groupe par défaut spécifié dans `/etc/passwd`. **7. su** La commande `su` permet également à un utilisateur d’exécuter temporairement des appels de programme avec les droits d’un utilisateur cible. Contrairement à `sudo`, les commandes ne sont toutefois pas exécutées directement. En effet, c’est plutôt un changement d’identité qui est opéré. De plus, `su` ne demande pas le mot de passe de l’utilisateur appelant, mais celui de l’utilisateur cible. Pour appeler des programmes en tant que super-utilisateur, un utilisateur doit par conséquent avoir en principe besoin du mot de passe root du système. De plus, contrairement à `sudo`, `su` n’est pas limité à un ensemble d’appels de programme prédéfinis par l’administrateur. Voici la syntaxe générale de la commande : ```bash su [OPTIONS] [NOMUTILISATEUR] ``` Un appel sans NOMUTILISATEUR définit automatiquement root comme utilisateur cible. **8. usermod** La commande en ligne de commande `usermod` vous permet de remanier les comptes utilisateurs déjà créés. Utilisez `usermod` avec les privilèges root selon le schéma suivant : ```bash usermod [OPTIONS] NOMUTILISATEUR ``` Les options permettent de définir les modifications à apporter. Par exemple, vous pouvez modifier le nom d’utilisateur avec `-l NOUVEAU_NOM`. Pour plus d’options, consultez la page manuel correspondante. ### Commandes système Dans cette catégorie, nous vous présentons des commandes Linux de base pour le contrôle du système. Les commandes suivantes permettent de redémarrer et d’arrêter le système à partir du terminal, et ce à un moment spécifiquement choisi si besoin. La plupart des commandes en ligne du panneau de contrôle doivent être exécutées avec les privilèges root. **1. logger** Le programme en ligne de commande `logger` peut être utilisé pour créer des entrées dans le journal système. La commande `logger` suit le schéma suivant : ```bash logger "VOTRE MESSAGE" ``` Vous trouverez le journal système sous `/var/log/syslog`. **2. reboot** `reboot` est une commande qui permet de faire redémarrer le système. Pour lancer un redémarrage, la commande doit être exécutée avec les droits root. ```bash reboot [OPTIONS] ``` **3. rtcwake** `rtcwake` est une commande qui permet de planifier le démarrage et la veille du système. Elle est basée sur la syntaxe suivante : ```bash rtcwake [OPTIONS] [MODE] [Temps] ``` Sélectionnez un mode spécifique (`-m MODE`) sur lequel le système doit se mettre en veille pour une durée définie en secondes (`-s TEMPS EN SECONDE`). Autrement, vous avez aussi la possibilité de sortir votre système de la veille à une heure définie précisément selon l’heure UNIX (`-t`). ### Informations du système Dans cette rubrique, nous avons résumé les programmes en ligne de commande pour obtenir des informations et annonces de statuts, ainsi qu’une vue d’ensemble complète de l’état de votre système. **1. date** La commande `date` renvoie, comme son nom laisse le présager, à la date et heure du système. ```bash date [OPTIONS] [FORMATDESORTIE] ``` Si vous voulez travailler avec une certaine date dans un appel de programme (voir `rtcwake`), ceci peut être défini avec l’option ‘-d ‘DATE’`. Par ailleurs, diverses options pourront être prises en charge, avec lesquelles les informations de date et d’heure peuvent être communiquées dans le format souhaité. **2. df** Utilisez la commande `df` (*disk free*) selon le schéma suivant pour afficher l’espace disque disponible des partitions montées. ```bash df [OPTIONS] ``` Si la commande est utilisée avec un fichier spécifique, le système ne spécifie que l’espace libre de la partition sur laquelle se trouve le fichier. L’option `-l` (*local*) limite `df` aux systèmes de fichiers locaux. Des options sont également prises en charge pour personnaliser le format de sortie. De plus, des options permettant d’adapter le format de sortie sont également prévues. **3. dmesg** Le programme `dmesg` (abréviation de *display message*) émet dans le terminal des messages à partir de la mémoire tampon du noyau, ce qui vous permet de localiser les erreurs de matériel. Utilisez `dmesg` selon le schéma suivant : ```bash dmesg [OPTIONS] ``` La sortie `dmesg` contient tous les messages du processus de démarrage et est donc tout aussi longue. Le programme en ligne de commande est souvent utilisé en combinaison avec un pager tel que `more`, `less` ou `tail`. **4. free** La commande `free` émet des informations sur la mémoire vive. La syntaxe générale est : ```bash free [OPTIONS] ``` La sortie émet deux données : `Mem` (*Memory*) et `Swap`. `free` peut également se servir de l’option `-h` pour sortir les informations de la mémoire dans un format lisible par l’homme. **5. hostname** Utilisez la commande `hostname` selon le schéma ci-dessous pour afficher le nom DNS du système. ```bash hostname [OPTIONS] ``` **6. uname** La commande `uname` (pour `unix name`) est utilisée pour obtenir des informations système sur la machine d’exécution. La commande prend en charge différentes options permettant de filtrer les informations de la sortie. Vous les trouverez dans la page manuel Linux correspondante. ```bash uname [OPTIONS] ``` **7. uptime** Si vous voulez retrouver la durée d’exécution de votre système depuis le dernier processus de démarrage, utilisez la commande en ligne de commande uptime selon le schéma suivant : ```bash Uptime ``` **8. vmstat** L’outil de monitoring `vmstat` peut être utilisé pour récupérer des informations sur la mémoire virtuelle, les opérations de lecture/écriture du disque ainsi que l’activité du processeur (CPU). Pour faire afficher les valeurs moyennes depuis le dernier démarrage du système, appelez `vmstat` comme suit : ```bash vmstat [OPTIONS] ``` Autrement, `vmstat` permet un monitoring continue, dans lequel les valeurs du système sont appelées aussi souvent que nécessaire dans un intervalle de temps défini en secondes. ```bash vmstat [OPTIONS] [INTERVALE [REPETITIONS]] ``` ### Informations sur le matériel (hardware) Les commandes Linux de cette catégorie vous fournissent **des informations détaillées sur les composants matériels** sous-jacents à votre système. **1. lspci** Utilisez `lspci` (abréviation de *list pci*) selon le schéma suivant pour afficher des informations détaillées sur les périphériques PCI : ```bash lspci [OPTIONS] ``` Reportez-vous aux pages d’aide de votre système d’exploitation pour connaître les options possibles. **2. lsusb** Utilisez `lsusb` (abréviation de *list usb*) pour afficher dans le terminal des informations détaillées sur les périphériques USB. ```bash lsusb [OPTIONS] ``` Reportez-vous aux pages de manuel de votre système d’exploitation pour connaître les options possibles. ### Gestion des processus Sous Linux, l’instance d’un programme en cours d’exécution est appelée processus. Les commandes de terminal développées dans ce chapitre font partie du répertoire standard pour la gestion des processus. Elles permettent de *surveiller à partir du terminal tous les processus de votre système* et d’intervenir si nécessaire. **1. chrt** `chrt` est un programme en ligne de commande pour les contrôles de processus avancés qui permettent de déterminer et d’ajuster les attributs en temps réel (politique d’ordonnancement et priorité) des processus en cours d’exécution ou d’exécuter des commandes et leurs arguments avec des attributs en temps réel spécifiques. La syntaxe générale de la commande est : ```bash chrt [OPTIONS] [PRIORITE] PID/COMMANDE [ARGUMENTS] ``` Utilisez `chrt` sans spécifier de priorité mais avec l’option `-p` pour déterminer les attributs en temps réel des processus sélectionnés. De plus, `chrt` offre la possibilité de personnaliser ou de définir la règle de planification de l’exécution ou du redémarrage des processus à l’aide d’options. De plus amples informations à ce sujet sont disponibles dans la page de manuel correspondante. **2. ionice** La commande `ionice` est utilisée pour influencer la priorité d’un processus qui utilise l’interface d’E/S du noyau. La syntaxe générale de la commande est : ```bash ionice [OPTIONS] COMMANDE ``` Pour pouvoir exécuter `ionice`, des droits root sont nécessaires. La commande distingue trois classes d’ordonnancement qui sont passées avec l’option `-cNOMBRE`. Les valeurs numériques possibles sont 1, 2 et 3. - 1 = Temps réel : l’action E/S est exécutée immédiatement. - 2 = Best-Effort : l’action E/S est exécutée le plus rapidement possible. - 3 = Idle : l’action E/S n’est exécutée que si aucun autre processus ne prend en compte du temps E/S. **3. nohup** Normalement, tous les processus dépendants d’un utilisateur se terminent automatiquement dès que l’utilisateur ferme la session terminal (par exemple, via `exit`). La [commande Linux `nohup` ](https://www.ionos.com/fr-be/digitalguide/serveur/configuration/commande-nohup/) (abréviation de *no hangup*) déclenche un processus à partir de la session en cours et permet de poursuivre son exécution même si vous vous déconnectez du système. ```bash nohup COMMANDE ``` **4. pidof** La ligne de commande `pidof` affiche les numéros d’identification de tous les processus d’un programme (PID). Retrouver les PID via `pidof` selon le schéma suivant : ```bash pidof [OPTIONS] PROGRAMME ``` Si vous souhaitez seulement afficher le premier ID de processus, utilisez `pidof` avec l’option `-s` (abréviation de *single shot*). **5. pkill** Comme `kill`, `pkill` envoie aussi un signal à un processus sélectionné. Cependant, l’adressage ne s’effectue pas par le PID. À la place, un terme de recherche est comparé avec les noms des processus en cours d’exécution. Il peut être formulé comme une expression régulière. `pkill` utilise également par défaut le signal TERM si aucun autre signal n’a été défini. La syntaxe générale de la commande est : ```bash pkill [OPTIONS] [-SIGNAL] [TERMEDERECHERCHE] ``` Des options supplémentaires peuvent être utilisées pour restreindre la commande aux processus d’un utilisateur particulier (`-U UID`), aux processus enfants d’un processus parent spécifique (`-P PID`), ou encore aux processus les plus récents (`-n`) ou les plus anciens (`-o`). **6. pstree** Utilisez `pstree` pour afficher tous les processus en cours d’exécution dans une arborescence. La syntaxe générale de la commande est : ```bash pstree [OPTIONS] ``` Le format et l’étendue de la sortie peuvent être personnalisés à l’aide de différentes options. **7. renice** La commande `renice` permet d’ajuster la priorité d’un processus en cours d’exécution. La syntaxe générale est : ```bash renice PRIORITE [OPTIONS] ``` **8. sleep** La [commande Lunix `sleep`](https://www.ionos.com/fr-be/digitalguide/serveur/configuration/commande-sleep/) vous permet d’interrompre la session du terminal en cours pendant une période de temps donnée. La syntaxe générale de la commande est : ```bash sleep NOMBRE[SUFFIXE] ``` Si vous utilisez `sleep` sans suffixe, le nombre spécifié est interprété comme un temps en secondes (s). Toutefois, vous pouvez également interrompre la session du terminal pendant des minutes (m), heures (h) ou jours (d) donnés. **9. taskset** `taskset` est une commande pour les contrôles de processus avancés qui est utilisée pour les systèmes multiprocesseurs afin d’assigner des processus ou des commandes à des processeurs spécifiques. La commande nécessite des droits root et utilise l’un des schémas suivants : ```bash taskset [OPTIONS] MASQUE COMMANDE taskset [OPTIONS] -p PID ``` L’affectation de process/commande au processeur se fait à l’aide d’un masque en bits hexadécimaux. Comme une telle affectation des masques n’est pas très intuitive, `taskset` est généralement utilisé avec l’option `-c` (--cpu-list), qui permet un classement numérique des processeurs (par exemple 0, 5 7, 9-11). ### Pager (visionneur) Vous voulez garder un bon aperçu aussi pour les contenus de fichiers ayant plusieurs pages ? À l’aide des programmes en ligne de commande de ce chapitre, vous pouvez sélectionner les parties que vous voulez afficher dans le terminal et même, si nécessaire, feuilleter le fichier en mode interactif. **1. head** La commande Linux head est utilisé pour sortir la première partie d’un fichier. La syntaxe générale de la commande est : ```bash head [OPTIONS] Fichier ``` Utilisez l’option `-n NOMBRE_LIGNES` pour définir le nombre de lignes à éditer en commençant par la première ligne. **2. less** Le programme de ligne de commande `less` permet d’afficher le contenu d’un fichier texte dans le terminal. La syntaxe générale est : ```bash less [OPTIONS] FICHIER ``` La sortie est automatiquement en mode interactif. Ceci vous permet de parcourir plus facilement le document sélectionné ou d’effectuer des recherches par mots-clés. La touche \[Q\] met fin au mode lecture interactive. Pour d’autres touches de commande et les options possibles, reportez-vous au manuel du programme. **3. tail** Tandis que `head` affiche par défaut les 10 premières lignes d’un fichier sélectionné, `tail` affiche les 10 dernières. Les deux pagers sont utilisés selon le même schéma (voir `head`). ### Éditeurs Sous Linux, vous n’avez pas besoin d’un programme de traitement de texte graphique pour adapter les fichiers de configuration, travailler des sections de code ou rédiger des notes courtes. **Des éditeurs de texte simples et rapides** peuvent être utilisés dans le terminal. Nous vous présentons ci-dessous trois programmes que vous devriez connaître. **1. emacs** *Emacs* est un éditeur de texte indépendant de la plateforme. Il démarre par défaut avec une interface utilisateur graphique, mais peut aussi être ouvert dans le terminal en utilisant l’option `--no-window-system`. ```bash emacs --no-window-system ``` Emacs dispose d’un tutoriel intégré auquel vous pouvez accéder en appuyant sur \[CTRL\] + \[H\], \[T\]. **2. nano** Nano est un éditeur de texte basé sur un terminal. Si Nano offre une plus petite gamme de fonctions que les éditeurs comparables (par exemple *Vim*), il est particulièrement agréable à utiliser. Voici la syntaxe générale : ```bash nano [OPTIONS] FICHIER ``` Le programme ouvre le fichier spécifié dans une fenêtre Edit du terminal. Si vous appelez Nano sans nom de fichier, un nouveau fichier texte est créé et enregistré dans le répertoire actuellement sélectionné. **3. vim** Vim (abréviation de *Vi Improved*) est une suite de l’éditeur de texte *Vi*. Il se distingue par de nombreuses améliorations telles que le surlignement syntaxique, un système d’aide complet, un script natif, des autocomplétions du code et une sélection visuelle du texte. Le programme open source offre différents modes de fonctionnement pour le traitement de fichiers texte pur et peut être utilisé soit dans le terminal, soit comme application autonome avec interface utilisateur graphique (*GVim*). Le traitement du code de programme est au cœur du domaine d’application du programme. Si vous démarrez Vim dans la console, il est commandé par le clavier. Habituellement, le programme est appelé avec un fichier texte selon le schéma suivant : ```bash vim [OPTIONS] FICHIER ``` Une introduction complète à Vim est proposée par le programme `vimtutor`, que vous pouvez également lancer à partir de la ligne de commande. De plus, notre article sur les fondamentaux de l’éditeur de texte Vim vous aidera également sur son installation et les différents modes de fonctionnement du programme. ### Gestion de réseau La **gestion de réseau** sous Linux s’effectue également de manière simple depuis le terminal. Que vous souhaitiez vérifier la connexion, consulter des informations sur le DNS, configurer des interfaces ou transférer des fichiers vers un autre ordinateur du réseau, une seule commande suffit avec les programmes suivants. **1. arp** Le programme en ligne de commande `arp` vous permet de consulter le cache ARP de votre système d’exploitation et de le manipuler. Utilisez `arp` sans modificateur pour afficher le contenu de la table ARP dans le terminal. ```bash arp [OPTION] ``` Vous pouvez également limiter la sortie avec des options ou créer ou supprimer des entrées : - `-a HOSTNAME` = Limiter la sortie aux entrées pour des noms d’hôtes spécifiques (alternative à une adresse IP) - `-s HOSTNAME MAC_ADDRESS` = Créer une entrée ARP avec le nom d’hôte et l’adresse MAC. - `-d HOSTNAME` = Supprimer l’entrée ARP **2. iw** Le programme en ligne de commande `iw` est utilisé pour configurer les interfaces WLAN et s’est imposé comme une alternative plus moderne à `iwconfig`. La syntaxe est similaire à celle de la commande `ip` : ```bash iw [OPTIONS] OBJET [COMMANDE] ``` Les objets possibles sont : - dev NOM\_INTERFACE = interface réseau - phy NOM\_PERIPHERIQUE = périphérique réseau sans fil (via Nom) - phy#INDEX\_PERIPHERIQUE = périphérique réseau sans fil (via Index) - reg = regulatory agent pour la configuration des paramètres régionaux Une vue d’ensemble des commandes et options possibles peut être trouvée dans la page de manuel correspondante. **3. nslookup** Comme `dig`, `nslookup` est aussi utilisé pour consulter des informations sur le DNS. Le programme en ligne de commande est disponible selon deux modes : interactif et non interactif. Si vous voulez utiliser `nslookup` en mode non-interactif, appelez le programme en combinaison avec un nom d’hôte ou une adresse IP. ```bash nslookup [OPTIONS] [HOST/IP] ``` Pour lancer le mode interactif, entrez la commande `nslookup` dans le terminal sans aucune information supplémentaire, puis entrez les noms d’hôtes ou les adresses IP pour afficher les adresses IP ou les noms d’hôtes associés. Comme le programme est très ancien, il est recommandé aux utilisateurs d’utiliser `dig` à la place. **4. rsync** Le programme en ligne de commande `rsync` permet de synchroniser des fichiers localement ou sur un réseau. Tout d’abord, la taille et la date de modification des fichiers concernés sont comparés. Si la source et la cible sont sur le même système, des fichiers différents sont copiés dans leur intégralité. Lors de la synchronisation sur un réseau, `rsync` utilise un algorithme de transfert delta, de sorte que seules les parties de fichier modifiées soient transférées du support de données source vers le système cible. La syntaxe de l’appel est : ```bash rsync [OPTIONS] SOURCE(S) CIBLE ``` La commande `rsync` est généralement exécutée avec l’option `-a`, ce qui garantit que tous les sous-répertoires et liens symboliques sont également copiés ainsi que tous les droits d’utilisateur. **5. scp** La commande Linux scp (abréviation de *secure copy*) permet le transfert sécurisé des données dans le réseau directement via le terminal : `scp` copie les données d’un ordinateur à un autre, en utilisant également le protocole réseau SSH. Le programme client fonctionne de la même manière que l’option fichier `cp`, mais il est utilisé selon la syntaxe suivante : ```bash scp [OPTIONS] FICHIER [[user@]remote_host:]CHEMINACCES ``` Lorsque vous spécifiez le chemin d’accès de l’hôte distant, le nom d’utilisateur et le nom de l’hôte correspondant sont indiqués. Vous pouvez utiliser des chemins d’accès relatifs ou absolus pour les fichiers locaux. Exemple : ```bash scp /home/max/images/image.jpg max@exemple.com:/home/max/archiv ``` D’autres options vous permettent d’ajuster le mode de transfert et les paramètres de chiffrement. **6. tty** La commande `tty` émet le nom de fichier du terminal défini comme entrée par défaut. La syntaxe générale de la commande est : ```bash tty [OPTIONS] ``` ### Archivage et compression Linux offre diverses technologies avec lesquelles les fichiers peuvent être compressés et envoyés dans des archives. Veuillez noter que chaque **archivage** n’implique pas toujours une **compression**. Ainsi, le programme d’archivage de fichiers `tar` est généralement utilisé avec des programmes de compression tels que `gzip`, `bzip2` ou `xz`. **1. gzip** `gzip` est un programme qui facilite la compression et la décompression des fichiers. La syntaxe générale qui s’applique est : ```bash gzip [OPTIONS] FICHIER(S) ``` Notez que `gzip` supprime le fichier d’application original dans le cadre du processus de dézippage par défaut. Ceci peut être modifié avec l’option `-k`. Si nécessaire, le programme peut être appliqué à plusieurs fichiers en même temps. Chaque fichier source est converti en un fichier `gz` indépendant. Si vous voulez écrire plusieurs fichiers dans une seule archive compressée, utilisez `gzip` en combinaison avec le programme d’archivage `tar`. Si vous voulez décompresser un fichier gz, utilisez la commande `gzip` avec l’option `-d`. **2. bzip2** Une alternative populaire à `gzip` est le programme en ligne de commande `bzip2`. Il utilise la même syntaxe que `gzip`, mais est basé sur un processus de compression en trois étapes qui permet un niveau de compression bien plus élevé. Les fichiers compressés avec bzip2 vont porter l’extension `.bz2`. Voici le schéma pour compresser les fichiers : ```bash bzip2 [OPTIONS] FICHIER(S) ``` `bzip2` peut également être appliqué aux archives `tar`. La décompression se fait de la même manière que `gzip` avec l’option `-d`. **3. xz** Le programme en ligne de commande `xz` convertit les fichiers au format de compression de données du même nom `xz`. L’appel de programme suit le même schéma que pour `gzip` et `bzip2`. ```bash xz [OPTIONS] FICHIER(S) ``` Les fichiers qui sont compressés avec `xz` utilisent l’extension `.xz`. La décompression fonctionne comme avec `gzip` et `bzip` avec l’option `-d`. La commande `unxz` peut aussi être utilisée. Comme les fichiers `gz` et `bz2`, les fichiers `xz` ne sont pas des fichiers d’archive. Si vous voulez écrire plusieurs fichiers dans le même fichier `xz` compressé, vous devez également utiliser l’outil d’archivage `tar`. **4. cpio** `cpio` (abréviation de *copy in, copy out*) est un programme d’archivage avec lequel les données peuvent être écrites et extraites d’un fichier d’archives (`.cpio`). ### Gestion des partitions Si vous voulez accéder à un système de fichiers Linux sur une autre partition, vous devez d’abord l’inclure dans la structure de répertoire de votre système d’exploitation. C’est ce qu’on appelle le « **montage** » d’une partition. Si nécessaire, cela peut être fait via l’interface utilisateur graphique. Autrement, les programmes en ligne de commande tels que `lsblk`, `blkid` et `mount` offrent la possibilité de consulter des informations sur les périphériques de stockage connectés et de les monter ou démonter selon les besoins. **1. lsblk** Utilisez la commande `lsblk` (abréviation de *list block devices*) pour afficher tous les périphériques de stockage de type bloc et partitions connectés sous forme d’arborescence. L’appel est basé sur la syntaxe suivante : ```bash lsblk [OPTIONS] ``` Si nécessaire, la sortie peut être personnalisée à l’aide de l’option `-o` (*–output*) tout comme la liste des attributs souhaités pour récupérer des informations supplémentaires telles que le numéro d’identification (UUID), le système de fichiers (FSTYPE) ou l’état (STATE). Les périphériques de stockage vides sont ignorés par défaut. Si vous voulez les inclure tout de même dans votre visualisation, utilisez `lsblk` en combinaison avec l’option `-a` (*–all*). Si vous voulez seulement récupérer des informations sur un périphérique spécifique, utilisez lsblk selon le schéma suivant : ```bash lsblk [OPTIONS] PERIPHERIQUE ``` **2. blkid** Semblable à `lsblk`, `blkid` fournit également des informations sur les périphériques de stockage de type bloc connectés. Utilisez `blkid` selon la syntaxe ci-dessous pour récupérer le numéro d’identification (`UUID`) et le type de système de fichiers (`TYPE`) de tous les périphériques de stockage en bloc connectés. ```bash blkid [OPTIONS] ``` Pour obtenir un tableau, utilisez l’option `-o` avec la valeur `list`. `blkid` peut également être limité à un appareil sélectionné : ```bash blkid [OPTIONS] PERIPHERIQUE ``` ### Divers Voici d’autres commandes Linux standard qui ne s’appliquent pas aux autres catégories énumérées dans cet article. **1. alias** L’interaction avec le shell se fait généralement par le biais de commandes pouvant être utilisées pour appeler des **programmes de ligne de commande** du même nom. Vous appelez un programme pour chaque action que vous souhaitez effectuer via le terminal. La [commande Linux `alias`](https://www.ionos.com/fr-be/digitalguide/serveur/configuration/commande-linux-alias/) vous permet de définir des diminutifs pour appeler des programmes. Utilisez `alias` selon le modèle suivant : ```bash alias DIMINUTIF= 'COMMANDE' ```bash La mention COMMANDE ci-dessus peut alors être remplacée par n’importe quel programme en ligne de commande avec ses options comprises. La commande et ses options seront alors liées à la chaîne de caractères utilisée dans DIMINUTIF. **2. at** Pour exécuter une commande à un temps précis, appeler le programme en ligne de commande `at` selon la syntaxe suivante : ```bash at TEMPS ``` Entrez ensuite la commande à exécuter et fermez le mode interactif avec \[CTRL\] +\[D\]. **3. cal** Utilisez `cal` selon le schéma suivant pour afficher un calendrier dans le terminal : ```bash cal [OPTIONS] [[MOIS] Annee] ``` **4. pr** Utilisez le programme en ligne de commande `pr` pour préparer les fichiers texte à l’impression. La syntaxe générale de la commande est : ```bash pr [OPTIONS] Fichier ``` Par défaut, `pr` crée un en-tête de page contenant le nom du fichier, la date du jour et le numéro de page. **5. script** Le programme en ligne de commande `script` vous permet d’écrire une session de terminal dans le fichier `typescript`. Si `typescript` contient déjà un enregistrement d’une session précédente, il sera écrasé. L’enregistrement démarre automatiquement lorsque le programme est appelé : ```bash script ``` Utilisez les touches \[CTRL\] + \[D\] pour arrêter l’enregistrement. Si vous voulez enregistrer dans un fichier autre que `typescript`, utilisez `script` avec un nom de fichier ou un chemin d’accès. **6. seq** Utilisez la commande `seq` pour émettre une série de chiffres sur la sortie par défaut. Définissez une valeur de début, une valeur de fin et éventuellement un incrément. ```bash seq [OPTIONS] VALEURDEBUT INCREMENT VALEURFIN ``` **7. tasksel** Le programme en ligne de commande `tasksel` sert d’aide à l’installation pour les applications standard (serveur de messagerie, DNS, OpenSSH, LAMP, etc. Utilisez cet outil pour installer automatiquement et dans l’ordre approprié tous les paquets et programmes requis pour une tâche. Appelez `tasksel` avec l’option `--list-tasks` pour obtenir une liste de toutes les applications standard disponibles. ```bash tasksel --list-tasks ``` Si vous voulez obtenir plus d’informations sur une application standard de cette liste, utilisez `tasksel` avec l’option `--task-desc` et la tâche correspondante. Si vous voulez lister tous les paquets appartenant à la tâche « mail-server », utilisez `tasksel` avec l’option `--task-packages`. Pour installer tous les paquets d’une application standard, utilisez la sous-commande `install`. Des droits root sont nécessaires. **8. tee** La [commande Linux `tee`](https://www.ionos.com/fr-be/digitalguide/serveur/configuration/commande-linux-alias/) est un programme en ligne de commande qui peut être utilisé pour doubler la sortie d’un programme. Une sortie est émise à la sortie standard et une autre est écrite dans un fichier stipulé avec la commande `tee`. La syntaxe générale de la commande est la suivante : ```bash tee [OPTIONS] FICHIER ``` En règle générale, `tee` est utilisé avec la redirection pipe (`|`). ```bash ls | tee exemple.txt ``` **9. time** Utilisez la commande `time` selon le schéma suivant pour déterminer la durée d’exécution des programmes que vous lancez via le terminal. ```bash time [OPTIONS] Commande [ARGUMENTS] ``` **10. tr** Utilisez `tr` pour supprimer ou remplacer autant de caractères que souhaité par d’autres. Pour ce faire, `tr` lit le flux de données de l’entrée standard (par exemple un fichier) et l’écrit sur la sortie standard selon la modification souhaitée. Si un jeu de caractères doit être remplacé par un autre, `tr` est utilisé avec deux arguments. ```bash tr OPTION JEUDECARACTERE1 JEUDECARACTERE2 ``` Le deuxième argument (JEUDECARACTERE1) remplace le premier (JEUDECARACTERE1). Si vous voulez supprimer une chaîne de caractères, utilisez `tr` avec l’option `-d` et donnez comme argument la séquence à supprimer. ```bash tr -d JEUDECARACTERE ``` Le programme en ligne de commande est généralement utilisé en combinaison avec des opérateurs de redirection (< et >) pour ajuster les fichiers. ```bash tr 'a-z' 'A-Z' < exemple1.txt > exemple2.txt ``` `tr` lit le contenu du fichier `exemple1.txt`, remplace les lettres minuscules de a à z par des lettres majuscules et émet le résultat dans le fichier `exemple2.txt`. **11. wall** Le programme en ligne de commande `wall` vous permet d’envoyer un message à tous les utilisateurs connectés au système. Pour envoyer un message, le programme commence par : ```bash wall ``` Confirmez l’appel du programme avec \[Enter\] et écrivez votre message. Confirmez également avec \[Enter\] et validez l’envoi en appuyant sur les touches \[CTRL\]+\[D\]. Tous les utilisateurs connectés au système reçoivent votre message dans le terminal sous forme de broadcast message. Attention : pour recevoir des messages, vous devez autoriser les autres utilisateurs à accéder en écriture à votre terminal. Pour ce faire, utilisez la commande `mesg`. Si vous voulez envoyer le contenu d’un fichier à tous les utilisateurs connectés, utilisez `wall` avec une touche de redirection et le nom de fichier correspondant : ```bash wall < NOMFICHIER ``` **12. watch** Le programme en ligne de commande `watch` vous permet d’exécuter une commande à intervalles réguliers. La syntaxe pour le programme est la suivante : ```bash watch [OPTIONS] COMMANDE ``` L’intervalle de temps est défini à l’aide de l’option `-n SECONDES`. Pour mettre fin à `watch`, appuyez sur \[CTRL\] + \[C\]. **13. wc** La [commande Linux wc](https://www.ionos.com/fr-be/digitalguide/serveur/configuration/commande-linux-wc/) (abréviation de *word count*) affiche le nombre de lignes, de mots, de lettres, de caractères et/ou d’octets d’un fichier texte. La syntaxe générale de la commande est : ```bash wc [OPTIONS] FICHIER ``` Si `wc` est utilisé sans option, la sortie correspond au schéma `LIGNES MOTS CARACTÈRES FICHIER`. Pour filtrer la sortie, le programme en ligne de commande permet les options suivantes : `-l` (lignes), `-c` (octets), `-m` (caractères), `-L` (longueur de la ligne la plus longue) et `-w` (mots). **14. xargs** La [commande Linux `xargs`](https://www.ionos.com/fr-be/digitalguide/serveur/configuration/commande-xargs/) est utilisé pour passer une sortie de commande précédente en argument à une commande. En général, on fait appel au symbole (`|`). Voici la syntaxe générale de `xargs` : ```bash COMMANDE1 | xargs [OPTIONS] COMMANDE2 ``` `xargs` est par exemple utilisé avec la commande `find`. Ci-dessous, `find` identifie tous les fichiers du répertoire courant qui correspondent au modèle de recherche `.tmp` et émet leurs noms dans la sortie standard. Les noms de fichiers sont alors captés par `xargs` et passés en arguments à la commande `rm`. ```bash $ find . -name '*.tmp' | xargs rm ``` L’aperçu présenté dans cet article ne prétend pas être exhaustif, mais décrit simplement des commandes Linux de base avec des exemples d’application méticuleusement choisis pour pouvoir travailler quotidiennement avec les systèmes d’exploitation unixoid. Pour une description complète des programmes en ligne de commande énumérés ci-dessus et de toutes les autres commandes, vous pourrez vous référer aux pages de manuel de votre système d’exploitation. Une version en ligne de ces pages d’aide et de documentation est également proposée par Michael Kerrisk dans le cadre du projet Linux Man Pages sur [kernel.org/doc/man-pages](https://www.kernel.org/doc/man-pages/ "The Linux man-pages project (kernel.org)"). This is a markdown version of: [https://www.ionos.com/fr-be/digitalguide/serveur/configuration/commandes-linux/](https://www.ionos.com/fr-be/digitalguide/serveur/configuration/commandes-linux/) for AI/LLM consumption.