Apprendre Linux depuis zéro : un plan de la première commande à l'administration d'un serveur

Apprendre Linux depuis zéro est plus simple qu'il n'y paraît, à condition de suivre le bon ordre et de pratiquer immédiatement. La principale erreur des débutants consiste à lire des descriptions de commandes sans les taper, ou à passer directement à Docker et Kubernetes sans comprendre ce qu'est un processus ni ce que sont les droits. Voici un plan en neuf étapes : ce qu'il faut étudier, ce qu'il faut pratiquer et comment reconnaître qu'une étape est acquise.

Comptez grossièrement de deux à quatre mois, à raison d'une heure par jour, mais le rythme varie d'une personne à l'autre. Plus que la vitesse, ce qui compte est de pouvoir, après chaque étape, faire quelque chose de concret par soi-même.

Étape 0. Préparez votre environnement

On apprend Linux sur Linux. Les options, de la plus simple à la plus réaliste :

• WSL2 sous Windows — un terminal Ubuntu en quelques minutes. Bien pour les commandes et les scripts, mais systemd et le réseau n'y fonctionnent pas comme sur un vrai serveur.
• Machine virtuelle (VirtualBox, VMware, UTM sur Mac) avec Ubuntu Server ou Debian. Vous pouvez tout casser sans conséquence et revenir aux instantanés.
• Un VPS économique chez un hébergeur cloud. Un vrai serveur avec une adresse IP publique est le meilleur terrain d'essai pour les étapes réseau et sécurité.

Pour débuter, prenez Ubuntu Server ou Debian : ce sont les distributions les mieux documentées et celles où l'on trouve le plus de réponses. Une interface graphique n'est pas nécessaire : les serveurs s'administrent dans le terminal, habituez-vous-y dès le premier jour.

Étape 1. Terminal et système de fichiers

L'objectif est de se déplacer dans le système et de manipuler des fichiers sans la souris.

• Navigation : pwd, ls -la, cd, chemins absolus et relatifs, ~, . et ...
• Fichiers : cp, mv, rm, mkdir -p, touch, affichage avec cat, less, head, tail -f.
• Recherche : find, which, locate.
• Aide : man, --help. Savoir lire les pages de manuel est une compétence qui sert toute la vie.
• Structure des répertoires : ce qui se trouve dans /etc, /var/log, /home, /usr, /proc, /dev ; ce qu'est un montage et un inode.
• Un éditeur de texte dans le terminal : nano pour commencer, puis les commandes de base de vim, présent sur presque tous les serveurs.

Exercice : trouvez tous les fichiers .conf de /etc modifiés au cours de la dernière semaine (find /etc -name "*.conf" -mtime -7). Ouvrez /etc/os-release et identifiez la version de votre système. Regardez ce que le système écrit dans /var/log.

Étape 2. Utilisateurs, groupes et droits

Les droits sont le fondement de la sécurité sous Linux et la source de la moitié des erreurs « Permission denied ».

• Lire la sortie de ls -l : type, droits, propriétaire, groupe.
• chmod sous forme symbolique et numérique, chown, umask.
• Les bits spéciaux : SUID, SGID, sticky bit — et pourquoi /tmp est accessible en écriture à tous, mais que les fichiers des autres n'y peuvent pas être supprimés.
• Utilisateurs et groupes : useradd, usermod -aG, passwd, les fichiers /etc/passwd, /etc/shadow, /etc/group.
• sudo, les règles de sudoers et la modification via visudo.

Exercice : créez deux utilisateurs et un dossier de projet commun dans lequel les deux peuvent créer des fichiers, tandis que les autres ne voient rien. Indice : un groupe, chmod 2770 et SGID pour l'héritage du groupe.

Étape 3. Bash et utilitaires de texte

L'administration consiste en grande partie à traiter du texte : journaux, fichiers de configuration, sorties de commandes. À cette étape, le terminal devient un véritable outil et non plus un simple ensemble de commandes.

• Redirections et tubes : >, >>, 2>&1, |, xargs.
• Filtres : grep (avec les expressions régulières), sort, uniq -c, wc, cut, sed, awk.
• JSON et HTTP en console : curl et jq.
• Scripts : shebang, variables, guillemets, conditions if et [[ ]], boucles, fonctions, codes de retour, set -euo pipefail.

Exercice : en une seule ligne, comptez les dix adresses IP qui ont envoyé le plus de requêtes dans le journal d'un serveur web :

awk '{print $1}' /var/log/nginx/access.log | sort | uniq -c | sort -rn | head

Écrivez ensuite un script qui sauvegarde un répertoire dans une archive dont le nom contient la date, supprime les archives de plus de sept jours et renvoie un code de retour non nul en cas d'erreur.

Étape 4. Paquets, environnement et planificateur

• Gestionnaire de paquets : apt update, apt install, apt remove, apt search, dpkg -l. Sur les systèmes de type RHEL — dnf. Comprendre ce qu'est un dépôt et à quoi servent les clés de signature.
• Variables d'environnement : env, export, PATH, les fichiers ~/.bashrc, ~/.profile, /etc/environment — et lequel est lu à quel moment.
• Planification : crontab -e, la syntaxe des cinq champs, et pourquoi une commande qui fonctionne dans le terminal « ne marche pas » dans cron (environnement et PATH différents).

Exercice : installez nginx depuis le dépôt, ajoutez votre répertoire de scripts au PATH, et configurez l'exécution du script de sauvegarde de l'étape 3 chaque nuit par cron, avec écriture de la sortie dans un journal.

Étape 5. Processus et systemd

C'est ici que vous commencez à comprendre ce qui se passe réellement dans le système.

• Processus : ps aux, top/htop, PID et PPID, états, priorités (nice), signaux et kill.
• Charge : load average, mémoire et swap (free -h), ce que signifie un « processus à l'état D ».
• Débogage : lsof — quels fichiers et ports un processus a ouverts ; strace — quels appels système il effectue et où il se bloque.
• systemd : unités, systemctl status/start/enable, votre propre fichier d'unité avec Restart=on-failure, timers à la place de cron.
• Journaux : journalctl -u, -f, -b, -p err, rotation, rsyslog ; statistiques de performance avec sysstat (sar, iostat).

Exercice : configurez une petite application (au minimum python3 -m http.server) comme service systemd sous un utilisateur dédié, tuez le processus avec kill -9 et vérifiez que systemd l'a relancé. Retrouvez l'entrée de redémarrage dans le journal.

Étape 6. Disques, LVM et RAID

• Périphériques et partitions : lsblk, blkid, fdisk ou parted, les systèmes de fichiers ext4 et XFS, mkfs.
• Montage : mount, /etc/fstab avec les UUID, vérification par mount -a.
• Espace : df -h, df -i, du -sh, recherche de ce qui occupe le disque.
• LVM : volumes physiques, groupes de volumes, volumes logiques et agrandissement d'une partition sans arrêt du système.
• RAID logiciel avec mdadm — compréhension des niveaux 0, 1, 5, 10, et du fait que le RAID n'est pas une sauvegarde.

Exercice : ajoutez deux disques à une machine virtuelle, créez un LVM dessus, un volume, montez-le via fstab, puis agrandissez-le avec lvextend -r.

Étape 7. Réseau

• Le modèle TCP/IP au niveau nécessaire au diagnostic : IP, masque, passerelle, port, TCP et UDP.
• Commandes : ip a, ip r, ss -tlnp, ping, traceroute/mtr, curl -v, nc.
• DNS : fonctionnement de la résolution, /etc/hosts, /etc/resolv.conf, dig, resolvectl.
• Configuration réseau de votre distribution (netplan sous Ubuntu, NetworkManager sur d'autres).
• Capture de trafic : tcpdump, pour les cas où tout le reste a échoué.

Exercice : déterminez quel processus écoute sur chacun des ports ouverts de votre serveur. Expliquez pourquoi un service qui écoute sur 127.0.0.1 est inaccessible de l'extérieur, puis corrigez cela.

Étape 8. Travail à distance : SSH et transfert de fichiers

• SSH : clés (ssh-keygen -t ed25519, ssh-copy-id), fichier ~/.ssh/config, ssh-agent, redirection de ports (ssh -L), bastion via ProxyJump.
• Copie : scp et rsync -avz --delete — et pourquoi rsync est préférable pour la synchronisation.
• Systèmes de fichiers réseau : NFS entre serveurs Linux, SMB (Samba) pour échanger avec Windows.

Exercice : configurez sur un VPS une connexion uniquement par clé, décrivez-la dans ~/.ssh/config sous un nom court, et mettez en place une synchronisation quotidienne d'un répertoire vers le serveur avec rsync.

Étape 9. Sécurité du serveur

• Pare-feu : le principe « tout interdire sauf ce qui est autorisé », ufw pour les cas simples, nftables — pour comprendre ce qui se passe réellement.
• fail2ban : bannissement d'une IP après une série de connexions échouées, vérifié avec fail2ban-client status sshd.
• Configuration de sshd : interdiction de la connexion par mot de passe et en root.
• Mises à jour de sécurité et leur installation automatique (unattended-upgrades sous Debian et Ubuntu).
• GPG : vérification des signatures de paquets et de fichiers, chiffrement des sauvegardes.

Exercice : n'ouvrez dans le pare-feu que les ports 22, 80 et 443, activez fail2ban, et après un jour consultez son statut pour voir combien d'adresses ont déjà été bloquées.

Projet final : montez un serveur complet

La meilleure vérification de votre maîtrise de Linux est de monter un serveur de zéro, sans aide :

1. Un nouveau VPS, votre propre utilisateur avec sudo, connexion par clé SSH, mots de passe et root désactivés.
2. Pare-feu et fail2ban, mises à jour de sécurité automatiques.
3. Serveur web et application en service systemd avec redémarrage automatique.
4. Un disque ou un volume dédié aux données, monté via fstab.
5. Sauvegarde planifiée (cron ou timer systemd) vers une autre machine via rsync, avec journal et test de restauration.
6. Une courte documentation : comment tout remonter à partir de zéro.

Si vous pouvez suivre cette liste et expliquer chaque étape, vous disposez des bases pour travailler comme administrateur ou ingénieur DevOps. La suite naturelle comprend les conteneurs, l'automatisation de la configuration et la supervision.

Comment apprendre plus efficacement

• Tapez les commandes vous-même. Ce qui est copié depuis un article ne se retient pas ; ce qui est tapé, avec ses erreurs, se retient.
• Cassez et réparez. Endommagez fstab ou les droits de ~/.ssh dans une machine virtuelle, puis restaurez le système. Cette expérience est appréciée en entretien.
• Tenez des notes. Votre propre carnet de commandes avec des exemples vaut plus que n'importe quel aide-mémoire d'un autre.
• Lisez les journaux. Presque tout problème sous Linux s'explique par le journal : prenez l'habitude d'y regarder en premier.

Synthèse

La réponse à la question de savoir comment apprendre Linux depuis zéro tient en une démarche par couches : terminal et fichiers, droits, bash, paquets, processus et systemd, disques, réseau, SSH, sécurité — et à chaque étape, résoudre une tâche pratique sur votre propre environnement. L'objectif final est de monter et de sécuriser seul un serveur avec un service en fonctionnement. C'est précisément ce parcours, de la leçon d'introduction au projet final, que suit notre cours sur Linux.