1. Configuration #
Interfaces, adresses et routes.
Lire l'état #
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.confConfigurer 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 app01Bonne 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 #
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 WiresharkLire 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-allErreur Courante : Autorisez SSH avant d'activer le pare-feu, sinon vous vous enfermez dehors.
nftables #
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 ruleset4. SSH #
Administrer à distance en sécurité.
Clés #
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_keysConfiguration cliente #
# ~/.ssh/config
Host bastion
HostName bastion.example.com
User alice
Host app*
User alice
ProxyJump bastion
IdentityFile ~/.ssh/id_ed25519Copier et tunnels #
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 ponctuelle5. 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 #
| Outil | Principe | Idéal pour | Reprise / incrémental |
|---|---|---|---|
| scp | copie simple via SSH | un fichier ou un dossier, ponctuellement | non |
| sftp | session interactive de transfert via SSH | parcourir le serveur, scripts de dépôt | reprise avec reget / reput |
| rsync | synchronisation différentielle (via SSH) | arborescences, sauvegardes, migrations, déploiements | oui (seules les différences) |
| sshfs | monte un dossier distant comme un dossier local | éditer quelques fichiers distants | — |
| tar via ssh | archive envoyée dans le tuyau SSH | très nombreux petits fichiers | non |
| curl / wget | téléchargement HTTP(S), FTP | ré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),scputilise le protocole SFTP en interne au lieu de l'ancien protocole SCP, jugé fragile. L'option-Oforce 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.frrsync #
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)| Option | Effet |
|---|---|
-a | mode archive : récursif, conserve liens, droits, dates, propriétaire, groupe (= -rlptgoD) |
-v / -z | verbeux / compression pendant le transfert |
-P | reprise des fichiers partiels et affichage de la progression |
-n | simulation, n’écrit rien |
--delete | supprime à la destination ce qui a disparu de la source |
-H -A -X | liens durs, ACL, attributs étendus |
--link-dest=DIR | sauvegardes 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éedst/site/. Combinée à--delete, une erreur de barre oblique peut vider un dossier : lancez toujours-nd'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 dansauthorized_keysparcommand="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), utilisezrclone, qui reprend la logique de rsync.
Commandes à connaître #
| Action | Commande |
|---|---|
| Copier un fichier vers un serveur | scp fichier app01:/tmp/ |
| Copier un dossier depuis un serveur | scp -r app01:/etc/nginx ./nginx-app01 |
| Session de transfert interactive | sftp app01 |
| Synchroniser un dossier | rsync -avz src/ app01:/srv/src/ |
| Simuler un miroir exact | rsync -avzn --delete src/ app01:/srv/src/ |
| Gros fichier avec reprise | rsync -avP gros.iso app01:/tmp/ |
| Monter un dossier distant | sshfs app01:/srv ~/app01 |
| Archive en flux | tar czf - dossier | ssh app01 'tar xzf - -C /srv' |
TP : migrer un site web avec rsync #
- Sur
app01, créez/var/www/siteavec quelques centaines de fichiers (for i in $(seq 500); do head -c 20K /dev/urandom > f$i.bin; done). - Copiez le dossier vers
app02avecscp -r, puis recommencez : notez que tout est retransféré. - Remplacez scp par
rsync -avz --stats; lancez-le deux fois et comparez la ligne Total transferred file size. - Modifiez 3 fichiers et supprimez-en 2 à la source, simulez avec
-n --delete, puis appliquez. - 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.
