---
title: CLI pour les nuls
description: Comprendre comment une commande Linux est construite, apprendre les commandes essentielles du terminal, ce que veulent dire leurs noms, et repartir avec un aide-mémoire.
---


:ellipsis{left=0px width=40rem top=10rem blur=140px zIndex=60}

Un serveur n'a pas de bureau, pas d'icônes et pas de souris. Tout se passe dans un terminal, et cette fenêtre noire avec un curseur clignotant est principalement ce qui décourage les gens de se lancer de le self-hosting. À tort : le terminal n'est qu'un chat. Vous posez une question ou écrivez un ordre, la machine répond. Rien de plus complexe qu'une barre de recherche, sauf qu'il en fait bien plus et ne cache jamais une option derrière trois menus.

La bonne nouvelle, c'est que vous n'avez pas besoin de connaître des centaines de commandes. Une dizaine d'entre elles couvrent presque tout vos besoins sur un serveur maison, et elles suivent toutes le même schéma. Apprenez à lire ce schéma et chaque commande que vous croiserez par la suite deviendra lisible, même celles que vous n'avez jamais vues.

## Comment une commande est construite

Chaque ligne de commande, sans exception, est rédigée de la même manière : **quoi lancer**, **comment le lancer**, **sur quoi le lancer**.

```text [Anatomie d'une commande]
sudo apt install -y nano
│    │   │       │  └─ argument : ce sur quoi la commande travaille
│    │   │       └──── option : change son comportement
│    │   └──────────── sous-commande : ce que le programme doit faire
│    └──────────────── le programme que vous lancez
└───────────────────── le lancer avec les droits administrateur
```

Lue à voix haute, cette ligne dit « en tant qu'administrateur, demande au gestionnaire de paquets d'installer le paquet nano, et ne me demande pas de confirmer ». Ce sont les espaces qui séparent les parties, et c'est notamment pour ça qu'un dossier nommé `Mes Sauvegardes` doit être mis entre guillemets (`cd "Mes Sauvegardes"`), sinon le shell (le système utilisé par le terminal) y lit deux choses différentes.

### Les options, courtes et longues

Les options changent le comportement d'une commande. Elles existent en deux versions, et la plupart des commandes acceptent les deux :

- **Courtes**, un tiret et une seule lettre : `ls -a`. Elles peuvent s'empiler, donc `ls -l -a -h` s'écrit généralement `ls -lah`.
- **Longues**, deux tirets et un mot entier : `ls --all`. Plus longues à taper, mais vous saurez encore ce qu'elles font six mois plus tard, ce qui en fait le meilleur choix dans un script.

Certaines options attendent une valeur juste après elles : `ssh-keygen -t ed25519` (`-t` pour type), `rsync --exclude @eaDir`. Et la casse compte, toujours. Dans `ls`, `-r` inverse l'ordre de tri alors que `-R` descend dans les sous-dossiers. Deux choses différentes, pour une même lettre.

### Les arguments et les chemins

L'argument est la cible : un fichier, un dossier, un nom de paquet, une adresse. Beaucoup de commandes en acceptent plusieurs à la fois, séparés par des espaces, et c'est ce qui rend le terminal rapide : `rm fichier1.txt fichier2.txt fichier3.txt` supprime trois fichiers d'un coup.

Quand la cible est un endroit sur le disque, vous l'écrivez sous forme de chemin, et quelques raccourcis valent la peine d'être connus :

| Chemin | Signification |
| --- | --- |
| `/` | la racine de tout le système, tout vit en dessous |
| `~` | votre propre dossier personnel, `/home/utilisateur` |
| `.` | le dossier dans lequel vous vous trouvez |
| `..` | le dossier juste au-dessus |
| `/var/log` | un chemin **absolu**, même résultat depuis n'importe où |
| `logs/aujourdhui` | un chemin **relatif**, compris depuis là où vous êtes |

::info 
L'usage des dossiers par l'OS est un sujet à part entière, traité dans [dossiers et partitions](/general/linux/filesystem).
::

L'invite de commande indique elle-même où vous êtes : dans `utilisateur@serveex:~/docker$`, vous êtes connecté en tant qu'`utilisateur` sur la machine nommée `serveex`, dans le dossier `docker` de votre home. Ce `$` final signifie que vous êtes loggé avec un utilisateur normal. Si vous voyez `#` à la place, c'est que vous êtes connecté avec l'utilisateur root et chaque faute de frappe compte double.

### Trouver de l'aide

Deux astuces vous rendront indépendant des tutoriels. `commande --help` affiche un résumé rapide de chaque option, et `man commande` ouvre le manuel complet (`man` pour *manual*), que vous quittez en appuyant sur :kbd{value="Q"}.

::tip{icon=""}
✨ __Astuce :__ trois réflexes clavier qui changent tout : :kbd{value="Tab"} complète le nom de fichier ou de dossier que vous avez commencé à taper, si bien que vous ne taperez presque jamais un chemin complet ; la flèche :kbd{value="Up"} rappelle vos commandes précédentes, ce qui évite de retaper une longue ligne pour un caractère ; et :kbd{value="Ctrl"} + :kbd{value="C"} arrête ce qui est en train de tourner.
::

### Enchaîner les commandes

Une fois le schéma compris, les commandes peuvent se combiner les unes aux autres :

- `&&` lance la suivante seulement si la précédente a réussi : `sudo apt update && sudo apt full-upgrade`
- `|`, le pipe, envoie la sortie d'une commande dans une autre : `ls -l | grep sauvegarde` liste le dossier, puis ne garde que les lignes contenant « sauvegarde »
- `>` écrit la sortie dans un fichier au lieu de l'écran, et `>>` l'ajoute à la fin de ce fichier : `df -h > rapport-disques.txt`

## Les commandes que vous utiliserez vraiment

La plupart des noms de commandes sont des abréviations. Une fois que vous savez ce qu'elles signifient, elles cessent de ressembler à des incantations obscures.

### `pwd`, print working directory

Vous dit où vous êtes. Elle ne change rien, elle répond juste à la question.

```bash [Terminal]
pwd
```

```console [Sortie]
/home/utilisateur/docker
```

### `ls`, list

Liste ce qu'il y a dans le dossier courant. Seule, elle n'affiche que les noms, elle est donc presque toujours utilisée avec des options : `-l` pour le format long avec tailles, dates et permissions, `-a` pour afficher aussi les fichiers cachés (ceux qui commencent par un point), `-h` pour des tailles en K/M/G plutôt qu'en octets bruts.

```bash [Terminal]
ls -lah
```

```console [Sortie]
total 20K
drwxr-xr-x  4 utilisateur utilisateur 4.0K Sep  5 10:12 .
drwxr-xr-x 18 utilisateur utilisateur 4.0K Sep  4 21:03 ..
-rw-r--r--  1 utilisateur utilisateur  512 Sep  5 10:12 .env
-rw-r--r--  1 utilisateur utilisateur 1.2K Sep  5 09:58 compose.yaml
drwxr-xr-x  3 utilisateur utilisateur 4.0K Sep  2 18:44 immich
```

La première colonne, ce sont les permissions, le `d` tout au début signifiant qu'il s'agit d'un dossier. Puis le propriétaire, la taille, la date de dernière modification, et le nom.

### `cd`, change directory

Permet de changer de repertoire. Lorsque vous indiquez un chemin, elle vous y rend. Avec `..` elle remonte d'un niveau, et sans rien du tout elle vous ramène dans votre dossier utilisateur.

```console [Terminal]
utilisateur@serveex:~/docker$ cd /var/log
utilisateur@serveex:/var/log$ cd ..
utilisateur@serveex:/$ cd
utilisateur@serveex:~$
```

Notez l'invite de commande : elle montre toujours où vous vous trouvez, si bien qu'en pratique vous avez rarement besoin de `pwd`.

### `mkdir`, make directory

Crée un dossier. Plusieurs à la fois si vous les listez, et `-p` crée toute la chaîne de parents d'un coup, c'est la version que vous utiliserez vraiment.

```bash [Terminal]
mkdir sauvegardes
mkdir -p docker/immich/config
```

```console [Sortie]

```

La sortie n'affiche rien. Ce n'est pas un bug, c'est la règle : la plupart des commandes ne disent rien quand elles réussissent et ne se manifestent que si quelque chose se passe mal. Le silence est une bonne nouvelle, et `ls` confirme que le dossier est bien là.

### `cp` et `mv`, copy et move

`cp` copie, `mv` déplace. Même syntaxe dans les deux cas : d'abord la source, puis la destination. Copier un dossier demande `-r`, pour *recursive*, puisqu'un dossier veut dire tout ce qu'il contient aussi. `mv` sert également de commande pour renommer, parce que renommer un fichier revient simplement à le déplacer vers un nouveau nom.

```bash [Terminal]
cp compose.yaml compose.yaml.bak
cp -r config/ config-backup/
mv ancien-nom.txt nouveau-nom.txt
ls
```

```console [Sortie]
compose.yaml  compose.yaml.bak  config  config-backup  nouveau-nom.txt
```

Trois commandes silencieuses, et `ls` qui montre le résultat : la copie est à côté de l'original, le dossier a été dupliqué, et `ancien-nom.txt` a disparu parce que le déplacer vers un autre nom équivaut à le renommer/

### `rm`, remove

Supprime. Il n'y a pas de corbeille, pas d'annulation, pas de fenêtre de confirmation. `-r` supprime un dossier et son contenu, `-f` force sans demander.

::warning{to="/nonsense/bash/rm-confirmation"}
`rm -rf` est la commande qui efface les homelabs. Elle ne vérifie pas, ne prévient pas, et ne s'arrête pas. Relisez le chemin deux fois avant d'appuyer sur :kbd{value="Enter"}, surtout quand la ligne commence par `sudo` et contient un `/` ou un `*`. Vous pouvez aussi vous en prémunir en enveloppant `sudo` dans une petite fonction Bash qui demande **« êtes-vous sûr ? »** avant de laisser passer un `rm`, c'est le sujet de **rm confirmation guard**.
::

### `cat` et `nano`, lire et modifier

`cat` (abréviation de *concatenate*) déverse un fichier entier à l'écran, parfait pour une config courte. Pour tout ce qui est plus long, `less` le fait défiler. Pour quitter, tapez simplement :kbd{value="Q"}.

Pour éditer un fichier, `nano` ouvre un éditeur simple : les flèches pour se déplacer, :kbd{value="Ctrl"} + :kbd{value="O"} pour enregistrer, :kbd{value="Ctrl"} + :kbd{value="X"} pour quitter.

```bash [Terminal]
cat .env
```

```properties [Sortie]
PUID=1000
PGID=1000
TZ=Europe/Paris
```

### `grep`, chercher dans les fichiers

`grep` veut dire *global regular expression print*, une façon compliquée de dire « trouve-moi ce texte ». Vous lui donnez quoi chercher et où, et il affiche chaque ligne correspondante. `-r` cherche dans tout un dossier, `-i` ignore les majuscules et minuscules, `-n` affiche les numéros de ligne.

```bash [Terminal]
grep -rin "password" /home/utilisateur/docker
```

```console [Sortie]
/home/utilisateur/docker/immich/.env:6:DB_PASSWORD=changeme
/home/utilisateur/docker/vaultwarden/compose.yaml:14:  ADMIN_PASSWORD=hunter2
```

Chaque ligne indique le fichier, puis le numéro de ligne à l'intérieur, puis la ligne correspondante elle-même. Très pratique le jour où vous ne vous souvenez plus dans quelle stack se trouve un réglage.

### `sudo`, lancer en privilèges administrateur

*Substitute user do*. Afin d'éviter de casser votre serveur par accident, un utilisateur normal ne peut pas toucher aux fichiers du système. Préfixer une commande par `sudo` lance cette seule commande avec les droits administrateur. Cette commande vous demandera votre mot de passe au moins une fois par session, et parfois plusieurs fois selon le temps qui se sera écoulé depuis sa dernière utilisation.

```bash [Terminal]
nano /etc/ssh/sshd_config
```

```console [Sortie]
Error writing /etc/ssh/sshd_config: Permission denied
```

```bash [Terminal]
sudo nano /etc/ssh/sshd_config
```

```console [Sortie]
[sudo] password for utilisateur:
```

::note
Lordsqu'une commande répond `Permission denied`, c'est quasiment certain que c'est parce qu'elle a besoin des privilèges administrateurs : il lui fallait `sudo`. Cependant, résistez tout de même au réflexe de mettre `sudo` partout, un fichier créé avec les privilèges root continuera de vous embêter par la suite parce que votre utilisateur normal n'en sera plus propriétaire.
::

## Aide-mémoire

Les commandes qui valent la peine d'être gardées sous la main, et d'où viennent leurs noms.

| Commande | Abréviation de | Ce qu'elle fait |
| --- | --- | --- |
| `pwd` | print working directory | Affiche où vous êtes |
| `ls` | list | Liste les fichiers et les dossiers |
| `cd` | change directory | Vous déplace ailleurs |
| `mkdir` | make directory | Crée un dossier |
| `touch` | mot anglais courant | Crée un fichier vide, ou rafraîchit sa date |
| `cp` | copy | Copie un fichier ou un dossier |
| `mv` | move | Déplace ou renomme |
| `rm` | remove | Supprime, définitivement |
| `cat` | concatenate | Affiche un fichier à l'écran |
| `less` | jeu de mots sur `more` | Fait défiler un fichier long |
| `nano` | l'éditeur qui remplace Pico | Modifie un fichier |
| `grep` | global regular expression print | Cherche du texte |
| `find` | mot anglais courant | Cherche des fichiers par nom, taille ou date |
| `man` | manual | Ouvre la documentation complète d'une commande |
| `df` | disk free | Affiche l'espace libre par partition |
| `lsblk` | list block devices | Dessine l'arbre des disques et des partitions |
| `du` | disk usage | Affiche ce que pèse un dossier |
| `ps` | process status | Liste les processus en cours |
| `htop` | le `top` de Hisham | Vue en direct du CPU, de la RAM et des processus |
| `kill` | mot anglais courant | Arrête un processus par son numéro |
| `chmod` | change mode | Change les permissions d'un fichier |
| `chown` | change owner | Change le propriétaire d'un fichier |
| `sudo` | substitute user do | Lance une commande en administrateur |
| `apt` | advanced package tool | Installe, met à jour et supprime des paquets |
| `systemctl` | control systemd | Démarre, arrête et active des services |
| `ssh` | secure shell | Ouvre une session sur une machine distante |
| `scp` | secure copy | Copie des fichiers via SSH |
| `tar` | tape archive | Empaquette et dépaquette des archives |
| `wget` | web get | Télécharge un fichier depuis une URL |
| `curl` | client URL | Envoie une requête à une URL |
| `history` | mot anglais courant | Liste les commandes tapées précédemment |

::tip{icon=""}
✨ __Astuce :__ Rassurez-vous, personne ne retient tout ça. Dans la réalité, vous rechercherez les trois mêmes options pendant des semaines, puis un jour vous réaliserez que vous les tapez sans réfléchir. En attendant, `--help` et ce tableau seront vos meilleurs amis.
::
