RousselTMLEARNING

Systèmes & Linux

Réseau sous Linux : configuration, diagnostic, pare-feu et SSH

Configurer et dépanner le réseau Linux : ip, ss, netplan et NetworkManager, DNS, diagnostic par couches avec ping, dig, curl, tcpdump, pare-feu nftables, ufw et firewalld, et SSH (clés, configuration, tunnels).

1. Configuration #

Interfaces, adresses et routes.

Lire l'état #

Couches réseau et commandes
Un ping qui passe valide la couche réseau, pas le port ni l'application.
ip -br addr               # interfaces et adresses, format court
ip link                   # état des liens (UP/DOWN), MAC
ip route                  # table de routage, passerelle par défaut
ip -s link show eth0      # compteurs, erreurs
hostname -I
resolvectl status         # serveurs DNS utilisés (systemd-resolved)
cat /etc/hosts /etc/resolv.conf

Configurer de façon persistante #

Les commandes ip modifient la configuration en mémoire uniquement. La configuration permanente dépend de la distribution : netplan (Ubuntu), NetworkManager (RHEL, postes), /etc/network/interfaces (Debian classique).

# /etc/netplan/50-static.yaml (Ubuntu)
network:
  version: 2
  ethernets:
    eth0:
      addresses: [192.168.10.20/24]
      routes:
        - to: default
          via: 192.168.10.1
      nameservers:
        addresses: [192.168.10.1, 1.1.1.1]
sudo netplan try          # applique avec retour arrière automatique après 120 s sans confirmation
nmcli con show            # NetworkManager
sudo nmcli con mod eth0 ipv4.method manual ipv4.addresses 192.168.10.20/24 ipv4.gateway 192.168.10.1 ipv4.dns 1.1.1.1
sudo nmcli con up eth0
sudo hostnamectl set-hostname app01
Bonne Pratique : À distance, préférez netplan try ou gardez une console hors bande (iLO, console du cloud) : une erreur réseau coupe votre propre session SSH.

2. Diagnostiquer #

Une méthode par couches.

La méthode #

Méthode de diagnostic réseau
On remonte les couches et on s'arrête à la première qui échoue.

Les outils #

ping -c 3 192.168.10.1            # joignabilité
tracepath 8.8.8.8 ; mtr -rw example.com   # chemin et pertes
dig +short example.com ; dig @1.1.1.1 example.com MX
getent hosts api.interne           # résolution comme le fait le système (inclut /etc/hosts)
ss -tlnp                           # ports TCP en écoute et processus
ss -tnp state established          # connexions établies
nc -zv db.interne 5432             # le port distant est-il ouvert ?
curl -v https://api.interne/health # TLS, en-têtes, code HTTP
curl -o /dev/null -s -w '%{time_connect} %{time_starttransfer} %{http_code}\n' https://example.com
sudo tcpdump -i eth0 -nn port 53   # capturer le trafic DNS
sudo tcpdump -i any -w capture.pcap host 10.0.0.5   # pour Wireshark

Lire ss -tlnp #

0.0.0.0:8080 ou *:8080 : écoute sur toutes les interfaces. 127.0.0.1:8080 : uniquement en local, invisible depuis le réseau — cause fréquente du « ça marche sur le serveur mais pas depuis mon poste ».

3. Pare-feu #

Tout refuser, puis ouvrir le nécessaire.

ufw et firewalld #

# Ubuntu : ufw
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow OpenSSH
sudo ufw allow from 10.0.0.0/8 to any port 5432 proto tcp
sudo ufw enable && sudo ufw status numbered

# RHEL : firewalld
sudo firewall-cmd --get-active-zones
sudo firewall-cmd --permanent --add-service=https
sudo firewall-cmd --permanent --add-rich-rule='rule family=ipv4 source address=10.0.0.0/8 port port=5432 protocol=tcp accept'
sudo firewall-cmd --reload && sudo firewall-cmd --list-all
Erreur Courante : Autorisez SSH avant d'activer le pare-feu, sinon vous vous enfermez dehors.

nftables #

Évaluation des règles nftables
Accepter les connexions établies en premier évite de bloquer les réponses.

ufw et firewalld sont des surcouches de nftables, le pare-feu du noyau (successeur d'iptables).

# /etc/nftables.conf
table inet filter {
  chain input {
    type filter hook input priority 0; policy drop;
    ct state established,related accept
    iif lo accept
    tcp dport { 22, 443 } accept
    icmp type echo-request limit rate 5/second accept
  }
}
sudo nft -c -f /etc/nftables.conf && sudo nft -f /etc/nftables.conf   # vérifier puis charger
sudo nft list ruleset

4. SSH #

Administrer à distance en sécurité.

Clés #

Connexion SSH par clé et bastion
La clé privée ne quitte jamais le poste de l'administrateur.
ssh-keygen -t ed25519 -C "alice@poste"     # paire de clés (avec phrase de passe)
ssh-copy-id alice@app01                     # installer la clé publique
ssh-add ~/.ssh/id_ed25519                   # agent : saisir la phrase une fois
chmod 700 ~/.ssh ; chmod 600 ~/.ssh/authorized_keys

Configuration cliente #

# ~/.ssh/config
Host bastion
    HostName bastion.example.com
    User alice
Host app*
    User alice
    ProxyJump bastion
    IdentityFile ~/.ssh/id_ed25519

Copier et tunnels #

Tunnel SSH local
psql -h localhost -p 5433 sur le poste atteint la base distante.
scp fichier app01:/tmp/ ; rsync -avz --progress dossier/ app01:/srv/dossier/
ssh -L 5433:localhost:5432 app01   # tunnel : la base distante devient localhost:5433
ssh -D 1080 bastion                # proxy SOCKS
ssh app01 'df -h /'                # commande ponctuelle

5. Transférer des fichiers : scp, sftp, rsync et les autres #

Copier vers et depuis un serveur, en toute sécurité et efficacement.

Vue d'ensemble #

OutilPrincipeIdéal pourReprise / incrémental
scpcopie simple via SSHun fichier ou un dossier, ponctuellementnon
sftpsession interactive de transfert via SSHparcourir le serveur, scripts de dépôtreprise avec reget / reput
rsyncsynchronisation différentielle (via SSH)arborescences, sauvegardes, migrations, déploiementsoui (seules les différences)
sshfsmonte un dossier distant comme un dossier localéditer quelques fichiers distants—
tar via ssharchive envoyée dans le tuyau SSHtrès nombreux petits fichiersnon
curl / wgettéléchargement HTTP(S), FTPrécupérer un fichier publiéreprise avec -C - / -c
À savoir : scp, sftp, rsync et sshfs réutilisent votre configuration SSH : clés, port, utilisateur et alias du fichier ~/.ssh/config, rebond par bastion (ProxyJump). Configurez SSH une fois, tous les outils en profitent.

scp #

scp copie des fichiers entre deux machines via SSH. La syntaxe est celle de cp, avec hôte:chemin pour le côté distant.

scp rapport.pdf app01:/tmp/                     # local -> distant
scp app01:/var/log/nginx/access.log .            # distant -> local
scp -r conf/ admin@app01:/etc/monapp/            # dossier entier (-r)
scp -P 2222 -i ~/.ssh/id_ed25519 f.txt app01:    # port et clé explicites (P majuscule)
scp -p fichier app01:/srv/                       # conserve dates et droits
scp -J bastion fichier app01:/tmp/               # rebond par un bastion
scp -3 app01:/srv/dump.sql app02:/srv/           # entre deux serveurs, via le poste local
scp -l 8000 gros.iso app01:/tmp/                 # limiter le débit (Kbit/s)
À savoir : Depuis OpenSSH 9.0 (2022), scp utilise le protocole SFTP en interne au lieu de l'ancien protocole SCP, jugé fragile. L'option -O force l'ancien protocole pour les vieux serveurs. Pour les transferts répétés ou volumineux, préférez rsync.

sftp #

sftp ouvre une session interactive, à la manière d'un client FTP, mais chiffrée par SSH. Il permet de parcourir le serveur et sert aussi de cible pour des comptes de dépôt limités (ForceCommand internal-sftp et ChrootDirectory dans sshd).

sftp app01
sftp> ls -l /srv            # commandes distantes : ls, cd, mkdir, rm, rename
sftp> lls ; lcd ~/Bureau    # commandes locales : préfixe l
sftp> put rapport.pdf       # envoyer (put -r pour un dossier)
sftp> get -r /srv/logs      # récupérer
sftp> reget gros.iso        # reprendre un téléchargement interrompu
sftp> bye

# Non interactif : un fichier de commandes
printf 'cd /depot\nput export.csv\n' > lot.txt
sftp -b lot.txt depot@partenaire.exemple.fr

rsync #

Algorithme de rsync

rsync synchronise une source vers une destination en ne transférant que ce qui a changé : les fichiers identiques (même taille et même date) sont ignorés, et pour un gros fichier modifié seuls les blocs différents circulent. Il passe par SSH dès que l'un des chemins contient hôte:.

rsync -avz projet/ app01:/srv/projet/                 # synchroniser un dossier
rsync -avzP gros.iso app01:/tmp/                       # -P = --partial --progress (reprise + progression)
rsync -avz --delete site/ web01:/var/www/site/         # miroir exact : supprime ce qui n'existe plus à la source
rsync -avzn --delete site/ web01:/var/www/site/        # -n (--dry-run) : simuler d'abord !
rsync -avz --exclude '.git/' --exclude '*.log' src/ app01:/srv/src/
rsync -avz -e 'ssh -p 2222 -J bastion' data/ app01:/srv/data/   # options SSH
rsync -aHAX --numeric-ids /srv/ /mnt/backup/srv/       # copie fidèle : liens durs, ACL, attributs étendus
rsync -av --bwlimit=10m backups/ nas:/volume1/backups/ # limiter le débit à 10 Mo/s
rsync -av --backup --backup-dir=../old-$(date +%F) conf/ app01:/etc/app/   # garder les versions remplacées
rsync -avc src/ dst/                                   # -c : comparer par somme de contrôle (plus lent)
OptionEffet
-amode archive : récursif, conserve liens, droits, dates, propriétaire, groupe (= -rlptgoD)
-v / -zverbeux / compression pendant le transfert
-Preprise des fichiers partiels et affichage de la progression
-nsimulation, n’écrit rien
--deletesupprime à la destination ce qui a disparu de la source
-H -A -Xliens durs, ACL, attributs étendus
--link-dest=DIRsauvegardes incrémentales : les fichiers inchangés sont des liens durs vers la sauvegarde précédente
Erreur courante : Oublier la barre oblique finale. rsync -a site/ dst/ copie le contenu de site dans dst ; rsync -a site dst/ crée dst/site/. Combinée à --delete, une erreur de barre oblique peut vider un dossier : lancez toujours -n d'abord.
Bonne pratique : rsync doit être installé des deux côtés. Pour une sauvegarde planifiée, utilisez une clé SSH dédiée, limitée dans authorized_keys par command="rrsync -ro /srv" (script fourni avec rsync), afin que la clé ne puisse rien faire d'autre.

sshfs, tar via ssh et téléchargements #

# Monter un dossier distant (paquet sshfs), puis le démonter
mkdir -p ~/app01 && sshfs app01:/srv ~/app01 -o reconnect
fusermount3 -u ~/app01

# Des milliers de petits fichiers : une seule archive en flux, sans fichier intermédiaire
tar czf - /srv/photos | ssh nas 'tar xzf - -C /volume1/photos'
ssh app01 'tar czf - /etc' > etc-app01.tar.gz           # sauvegarder /etc distant en local

# Copier un disque ou une image
ssh app01 'sudo dd if=/dev/vdb bs=4M status=progress' | gzip > vdb.img.gz

# Télécharger depuis le web (avec reprise)
curl -fLO -C - https://exemple.fr/iso/debian.iso
wget -c https://exemple.fr/iso/debian.iso
sha256sum debian.iso                                    # toujours vérifier l'empreinte publiée
À savoir : Pour un très gros volume, ce sont souvent le CPU (chiffrement, compression) et la latence qui limitent le débit, pas le réseau. Sur un réseau local rapide, désactivez la compression (pas de -z) ; sur un lien lent, gardez-la. Pour synchroniser avec un stockage objet (S3, Azure, Google Drive), utilisez rclone, qui reprend la logique de rsync.

Commandes à connaître #

ActionCommande
Copier un fichier vers un serveurscp fichier app01:/tmp/
Copier un dossier depuis un serveurscp -r app01:/etc/nginx ./nginx-app01
Session de transfert interactivesftp app01
Synchroniser un dossierrsync -avz src/ app01:/srv/src/
Simuler un miroir exactrsync -avzn --delete src/ app01:/srv/src/
Gros fichier avec reprisersync -avP gros.iso app01:/tmp/
Monter un dossier distantsshfs app01:/srv ~/app01
Archive en fluxtar czf - dossier | ssh app01 'tar xzf - -C /srv'

TP : migrer un site web avec rsync #

  1. Sur app01, créez /var/www/site avec quelques centaines de fichiers (for i in $(seq 500); do head -c 20K /dev/urandom > f$i.bin; done).
  2. Copiez le dossier vers app02 avec scp -r, puis recommencez : notez que tout est retransféré.
  3. Remplacez scp par rsync -avz --stats ; lancez-le deux fois et comparez la ligne Total transferred file size.
  4. Modifiez 3 fichiers et supprimez-en 2 à la source, simulez avec -n --delete, puis appliquez.
  5. Planifiez la synchronisation toutes les 15 minutes avec un timer systemd, en utilisant une clé dédiée.

Résultat attendu : la seconde synchronisation rsync ne transfère que les changements, et le miroir reste identique à la source.

Articles liés

Architecture d'un système Linux : noyau, démarrage et arborescence

Comprendre comment fonctionne un serveur Linux : noyau et espace utilisateur, séquence de démarrage UEFI, GRU…

Le shell Bash et les fichiers : navigation, redirections, pipes et traitement de texte

Maîtriser la ligne de commande Linux : chemins, manipulation de fichiers, jokers, redirections, pipes, recher…

Utilisateurs, groupes, sudo et permissions sous Linux

Gérer les comptes Linux (useradd, usermod, passwd, chage), les groupes, sudo et visudo, les permissions rwx e…

Pour aller plus loin

Soutenir

♥ SOUTENIR

Soutenez RousselTM Learning

Les formations, articles, TP et attestations restent gratuits et sans publicité intrusive. Une contribution libre, du montant de votre choix, finance l’hébergement, les environnements de TP et l’écriture de nouveaux contenus.

Contribuer avec PayPal Montant libre · carte bancaire ou compte PayPalEn savoir plus
QR code PayPal
Ou scannez ce QR code avec votre téléphone

Merci, chaque contribution compte !