Files
docudjeex/content/fr/2.general/5.linux/3.handy-tools.md
T

262 lines
9.0 KiB
Markdown

---
title: Outils CLI pratiques
description: Une poignée d'outils en ligne de commande à installer sur un serveur maison, ce que chacun remplace, et les étapes pour les installer et s'en servir.
---
:ellipsis{left=0px width=40rem top=10rem blur=140px zIndex=60}
Une installation minimale de Debian embarque le strict minimum, ce qui veut dire que les outils fournis sont ceux de 1995. Ils fonctionnent, mais lire la sortie de `df` ou chercher ce qui a rempli un disque avec `du` est inutilement pénible quand de meilleures versions existent et ne coûtent rien à installer.
Tout ce qui suit sauf le dernier vient directement des dépôts Debian, il n'y a donc aucune source tierce à qui faire confiance et `apt` les maintient à jour en même temps que le reste du système.
::note{to="/general/linux/cli-basics"}
Toutes les commandes ici se tapent dans un terminal via SSH. Si `sudo`, `apt` et `cd` ne vous parlent pas encore, commencez par les **bases de la ligne de commande**.
::
## La version courte
| Outil | Remplace | À quoi ça sert |
| --- | --- | --- |
| `btop` | `top`, `htop` | Surveiller le CPU, la RAM et les processus |
| `duf` | `df -h` | L'espace libre, en lisible |
| `ncdu` | `du -sh` | Trouver ce qui a rempli le disque |
| `tldr` | `man` | Les cinq commandes dont vous avez vraiment besoin |
| `lazydocker` | `docker ps` et compagnie | Gérer les conteneurs en SSH |
| `ufw` | `iptables` brut | Un pare-feu réellement lisible |
## La version pressée
Une seule ligne installe tous ceux qui sont empaquetés, et chaque section ci-dessous explique ce que vous venez d'obtenir.
```bash [Terminal]
sudo apt update
sudo apt install btop duf ncdu tealdeer ufw
```
## `btop`, surveiller ce que fait la machine
Le remplaçant moderne de `top` et `htop` : CPU, RAM, disques, réseau et processus sur un seul écran, avec des graphiques, des couleurs et une souris qui marche. C'est ce que vous ouvrez quand quelque chose semble lent.
::steps{level="4"}
#### L'installer
```bash [Terminal]
sudo apt install btop
```
#### Le lancer
```bash [Terminal]
sudo btop
```
![btop affichant le CPU, la mémoire, les disques, le réseau et les processus](/img/global/linux/btop.png)
Cliquez sur un processus pour le sélectionner, :kbd{value="Esc"} ouvre le menu, :kbd{value="Q"} quitte. Les touches `+` et `-` replient et déplient les panneaux si l'écran paraît chargé.
#### Terminé !
::
## `duf`, l'espace disque qui se lit comme un tableau
`df -h` affiche tous les loop devices que Docker a créés un jour et vous laisse plisser les yeux sur les colonnes. `duf` montre les mêmes informations groupées, alignées et colorées, avec une barre d'utilisation par système de fichiers.
::steps{level="4"}
#### L'installer
```bash [Terminal]
sudo apt install duf
```
#### Le lancer
```bash [Terminal]
sudo duf
```
![duf listant les systèmes de fichiers locaux, réseau et spéciaux](/img/global/linux/duf.png)
Les disques locaux, les partages réseau et les montages système sont groupés séparément. Ajoutez `--only local` pour masquer les pseudo-systèmes de fichiers que Docker laisse derrière lui.
#### Terminé !
::
## `ncdu`, trouver ce qui a mangé le disque
Quand `duf` vous dit que le disque est plein, `ncdu` vous dit pourquoi. Il parcourt un dossier, trie tout par taille réelle, et vous laisse descendre avec les flèches au lieu de lancer `du -sh *` vingt fois.
::steps{level="4"}
#### L'installer
```bash [Terminal]
sudo apt install ncdu
```
#### Le pointer sur un dossier
```bash [Terminal]
sudo ncdu /srv/docker
```
Les flèches pour se déplacer, :kbd{value="Enter"} pour ouvrir un dossier, :kbd{value="D"} pour supprimer l'élément sélectionné, :kbd{value="Q"} pour quitter. Sur un gros disque le premier scan prend un moment, il lit tout.
::warning
:kbd{value="D"} supprime immédiatement, avec une seule confirmation et sans corbeille. Lancez `ncdu` sans `sudo` quand vous ne faites que regarder, comme ça une touche tapée de travers ne peut rien toucher de ce qui appartient au système.
::
#### Terminé !
::
## `tldr`, le manuel sans les 400 lignes
`man tar` est exhaustif et illisible. `tldr tar` vous donne les cinq commandes que les gens tapent vraiment, avec une ligne d'explication chacune. Ce sont des exemples maintenus par la communauté plutôt qu'un substitut au vrai manuel, et sur Debian le client est empaqueté sous le nom `tealdeer`.
::steps{level="4"}
#### L'installer
```bash [Terminal]
sudo apt install tealdeer
```
#### Télécharger le cache des pages
```bash [Terminal]
tldr --update
```
Les exemples sont récupérés une fois et stockés en local, la commande fonctionne donc hors ligne ensuite. À relancer tous les quelques mois.
#### Lui demander quelque chose
```bash [Terminal]
tldr rsync
```
#### Terminé !
::
## `lazydocker`, gérer ses conteneurs depuis le terminal
La seule exception : il n'est pas empaqueté par Debian. C'est une interface texte complète pour Docker, conteneurs, images, volumes et logs sur un seul écran, avec des touches pour redémarrer, arrêter ou suivre les logs de n'importe quoi. Pratique quand vous êtes déjà en SSH et que vous n'avez pas envie d'ouvrir Dockge.
::steps{level="4"}
#### Télécharger la dernière version
```bash [Terminal]
curl -Lo /tmp/lazydocker.tar.gz "https://github.com/jesseduffield/lazydocker/releases/latest/download/lazydocker_0.25.2_Linux_x86_64.tar.gz"
```
Vérifiez le numéro de version actuel sur la [page des releases](https://github.com/jesseduffield/lazydocker/releases), et prenez `arm64` au lieu de `x86_64` si le serveur est un Raspberry Pi ou équivalent.
#### Installer le binaire
```bash [Terminal]
sudo tar -xzf /tmp/lazydocker.tar.gz -C /usr/local/bin lazydocker
rm /tmp/lazydocker.tar.gz
```
`/usr/local/bin` est le dossier prévu pour les logiciels que vous installez vous-même, et c'est pour ça qu'`apt` n'y touche jamais.
#### Vérifier qu'il est bien là
```bash [Terminal]
lazydocker --version
```
#### Le lancer
```bash [Terminal]
sudo lazydocker
```
![lazydocker affichant les services, conteneurs, images, volumes et la config d'un conteneur](/img/global/linux/lazydocker.png)
Il a besoin d'accéder au socket Docker, d'où le `sudo` à moins que votre utilisateur soit dans le groupe `docker`. Les touches à connaître :
| Touche | Ce qu'elle fait |
| --- | --- |
| `1` à `6` | Aller à un panneau : projets, services, conteneurs, images, volumes, réseaux |
| Flèches | Se déplacer dans le panneau, la partie droite suit la sélection |
| :kbd{value="Enter"} | Passer sur le panneau principal à droite, :kbd{value="Esc"} revient |
| `x` | Ouvrir le menu de tout ce que vous pouvez faire avec la sélection |
| `m` | Suivre les logs |
| `s` / `r` / `p` | Arrêter, redémarrer, mettre en pause le conteneur sélectionné |
| `E` | Ouvrir un shell dans le conteneur |
| `d` | Le supprimer |
| `b` | Commandes groupées, dont le nettoyage des images et des volumes |
| `/` | Filtrer la liste |
| `+` et `_` | Agrandir ou réduire les panneaux |
| `q` | Quitter |
La casse compte : `E` ouvre un shell dans le conteneur, `e` masque ceux qui sont arrêtés.
La [liste complète](https://github.com/jesseduffield/lazydocker/blob/master/docs/keybindings/Keybindings_en.md) se trouve dans la documentation du projet.
::note
Être en dehors d'`apt` veut aussi dire qu'il ne sera pas mis à jour par `apt full-upgrade`. Refaites ces étapes quand vous voudrez une version plus récente.
::
#### Terminé !
::
## `ufw`, un pare-feu réellement lisible
Le pare-feu de Debian (`iptables`/`nftables` sous le capot) est puissant et illisible tel quel. `ufw`, *uncomplicated firewall*, est une fine couche par-dessus qui le transforme en règles courtes et compréhensibles : tout bloquer par défaut et n'ouvrir que ce que vous exposez réellement.
::steps{level="4"}
#### L'installer
```bash [Terminal]
sudo apt install ufw
```
#### Définir la politique par défaut
```bash [Terminal]
sudo ufw default deny incoming
sudo ufw default allow outgoing
```
Rien n'entre à moins qu'une règle ne l'autorise, tout ce que le serveur initie lui-même sort toujours normalement.
#### Autoriser ce dont vous avez réellement besoin
```bash [Terminal]
sudo ufw allow OpenSSH
sudo ufw allow 443/tcp
```
`OpenSSH` est un profil intégré qui correspond au port SSH, pas besoin de se souvenir duquel il s'agit. Ajoutez un `allow` par port que vous exposez, [SWAG](/serveex/core/swag) sur le `443` par exemple.
::warning
Autorisez SSH **avant** d'activer le pare-feu, à l'étape suivante. Activez-le d'abord et la connexion depuis laquelle vous tapez est coupée, sans plus aucun écran branché pour réparer.
::
#### L'activer
```bash [Terminal]
sudo ufw enable
```
#### Vérifier les règles
```bash [Terminal]
sudo ufw status verbose
```
```console [Sortie]
Status: active
Logging: on (low)
Default: deny (incoming), allow (outgoing), disabled (routed)
To Action From
-- ------ ----
22/tcp (OpenSSH) ALLOW IN Anywhere
443/tcp ALLOW IN Anywhere
```
#### Terminé !
::