Réseau depuis le terminal

Réseau depuis le terminal#

Le terminal Linux est un outil de premier ordre pour interagir avec les réseaux : que ce soit pour télécharger des ressources, interroger des API web, administrer des serveurs distants, transférer des fichiers ou diagnostiquer des problèmes de connectivité. Maîtriser les outils réseau en ligne de commande est une compétence indispensable pour tout administrateur système, développeur DevOps ou ingénieur qui travaille sur des infrastructures sans interface graphique.

Ce chapitre couvre les principaux outils réseau : curl pour les requêtes HTTP et les API, wget pour les téléchargements, ssh pour les connexions sécurisées, scp et rsync pour les transferts de fichiers, les outils de diagnostic (ping, traceroute, mtr), l’inspection des connexions (ss, netstat), la résolution DNS (dig, nslookup) et la configuration réseau (ip).

`curl` : requêtes HTTP et API#

curl (Client URL) est l’outil universel pour effectuer des requêtes réseau depuis la ligne de commande. Il supporte des dizaines de protocoles (HTTP, HTTPS, FTP, SFTP, SMTP, etc.) et est devenu le standard de facto pour interagir avec les API REST.

Définition 40 (curl)

curl est un outil en ligne de commande pour transférer des données avec une syntaxe URL. Il supporte les méthodes HTTP (GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS), l’authentification (Basic, Bearer, OAuth, certificats), les cookies, la redirection automatique, la reprise de téléchargement, et bien d’autres fonctionnalités. Son homologue bibliothèque C, libcurl, est intégré dans des milliers d’applications.

Options essentielles#

# GET simple (comportement par défaut)
curl https://api.exemple.fr/status

# -o : enregistrer dans un fichier
curl -o page.html https://exemple.fr

# -O : enregistrer avec le nom du fichier distant
curl -O https://exemple.fr/fichier.tar.gz

# -L : suivre les redirections
curl -L https://exemple.fr/redirect

# -s : mode silencieux (pas de barre de progression)
curl -s https://api.exemple.fr/data

# -i : afficher les en-têtes de réponse
curl -i https://api.exemple.fr/status

# -I : HEAD uniquement (en-têtes sans corps)
curl -I https://exemple.fr

# -v : mode verbeux (pour le débogage)
curl -v https://api.exemple.fr/endpoint

# Combiner les options
curl -sL https://exemple.fr/install.sh | bash
curl -sSL -o /tmp/app.deb https://exemple.fr/app.deb

Méthodes HTTP et envoi de données#

# POST avec données de formulaire (application/x-www-form-urlencoded)
curl -X POST -d "nom=Alice&age=30" https://api.exemple.fr/users

# POST avec JSON (Content-Type: application/json)
curl -X POST \
  -H "Content-Type: application/json" \
  -d '{"nom": "Alice", "age": 30}' \
  https://api.exemple.fr/users

# POST avec un fichier JSON
curl -X POST \
  -H "Content-Type: application/json" \
  -d @payload.json \
  https://api.exemple.fr/users

# PUT pour mettre à jour une ressource
curl -X PUT \
  -H "Content-Type: application/json" \
  -d '{"nom": "Alice Dupont"}' \
  https://api.exemple.fr/users/42

# DELETE
curl -X DELETE https://api.exemple.fr/users/42

# PATCH
curl -X PATCH \
  -H "Content-Type: application/json" \
  -d '{"age": 31}' \
  https://api.exemple.fr/users/42

En-têtes personnalisées et authentification#

# En-tête personnalisée avec -H
curl -H "X-API-Key: mon_api_key_secret" \
     -H "Accept: application/json" \
     https://api.exemple.fr/data

# Authentification Basic
curl -u alice:motdepasse https://api.exemple.fr/protected
curl -u alice https://api.exemple.fr/protected    # Demande le mdp

# Authentification Bearer (token JWT)
curl -H "Authorization: Bearer eyJhbGci..." https://api.exemple.fr/data

# Cookie
curl --cookie "session=abc123" https://exemple.fr/profil

# Sauvegarder et renvoyer les cookies
curl -c cookies.txt https://exemple.fr/login -d "user=alice&pass=secret"
curl -b cookies.txt https://exemple.fr/profil

# Certificat client (mTLS)
curl --cert client.crt --key client.key https://api.secure.exemple.fr/

Traitement des réponses JSON avec `jq`#

jq est l’outil incontournable pour analyser et transformer le JSON en ligne de commande. Bien qu’il ne fasse pas partie de curl, les deux sont très souvent utilisés ensemble.

# Installer jq
sudo apt install jq

# Parser une réponse JSON
curl -s https://api.exemple.fr/users | jq '.'

# Extraire un champ
curl -s https://api.github.com/users/torvalds | jq '.name'

# Extraire depuis un tableau
curl -s https://api.exemple.fr/users | jq '.[0].nom'
curl -s https://api.exemple.fr/users | jq '.[].email'

# Filtres et transformations
curl -s https://api.exemple.fr/users \
  | jq '[.[] | {nom: .name, email: .email}]'

# Valeur brute (sans guillemets)
nom=$(curl -s https://api.github.com/users/torvalds | jq -r '.name')
echo "Nom : $nom"

Exemple 25 (Script d’interrogation d’API REST)

Un script complet pour interroger une API avec gestion des erreurs :

#!/usr/bin/env bash
set -euo pipefail

API_BASE="https://jsonplaceholder.typicode.com"
TOKEN="${API_TOKEN:-}"

requete_api() {
    local methode="$1"
    local endpoint="$2"
    local data="${3:-}"
    local args=(-s -f -X "$methode")

    [[ -n "$TOKEN" ]] && args+=(-H "Authorization: Bearer $TOKEN")
    args+=(-H "Content-Type: application/json")
    args+=(-H "Accept: application/json")
    [[ -n "$data" ]] && args+=(-d "$data")
    args+=("${API_BASE}${endpoint}")

    local reponse code_http
    reponse=$(curl "${args[@]}" -w '\n%{http_code}')
    code_http=$(echo "$reponse" | tail -1)
    corps=$(echo "$reponse" | head -n -1)

    if (( code_http >= 400 )); then
        echo "Erreur HTTP $code_http pour $endpoint" >&2
        return 1
    fi
    echo "$corps"
}

# Lister les utilisateurs
utilisateurs=$(requete_api GET "/users")
echo "$utilisateurs" | jq '.[].username'

## `wget` : téléchargements et miroirs

`wget` est spécialisé dans le téléchargement de fichiers et de sites web entiers. Moins polyvalent que `curl` pour les API, il excelle dans les téléchargements récursifs et la reprise de téléchargements interrompus.

```bash
# Téléchargement simple
wget https://exemple.fr/fichier.tar.gz

# Téléchargement en arrière-plan
wget -b https://exemple.fr/gros_fichier.iso
tail -f wget-log    # Suivre la progression

# Reprendre un téléchargement interrompu
wget -c https://exemple.fr/gros_fichier.iso

# Enregistrer sous un nom différent
wget -O mon_fichier.zip https://exemple.fr/archive.zip

# Téléchargement silencieux
wget -q https://exemple.fr/script.sh

# Suivre les redirections (activé par défaut)
wget --max-redirect=5 https://exemple.fr/redirect

# Limiter la vitesse de téléchargement
wget --limit-rate=500k https://exemple.fr/fichier.iso

# Télécharger une liste de fichiers
wget -i liste_urls.txt

# Téléchargement récursif d'un site web
wget -r -l 2 https://exemple.fr/docs/   # récursif, profondeur 2

# Miroir complet d'un site
wget --mirror --convert-links --adjust-extension \
     --page-requisites --no-parent \
     https://exemple.fr/

# Télécharger sans vérifier le certificat SSL (à éviter en production)
wget --no-check-certificate https://self-signed.exemple.fr/fichier

Remarque 35

wget et curl se complètent plutôt qu’ils ne se remplacent. wget est préférable pour les téléchargements récursifs, les miroirs de sites, la reprise automatique (-c), et les cas où l’on télécharge des fichiers sans besoin de manipulation de requêtes. curl est préférable pour les interactions avec des API, les requêtes HTTP complexes (headers personnalisés, méthodes variées, authentification), et lorsqu’on souhaite piper la sortie vers d’autres outils (curl ... | jq, curl ... | bash).

`ssh` : connexion sécurisée#

ssh (Secure Shell) est le protocole standard pour accéder à distance à un système Linux de façon sécurisée. Il chiffre toutes les communications et supporte plusieurs mécanismes d’authentification.

Connexion de base#

# Connexion à un serveur distant
ssh alice@serveur.exemple.fr

# Port non standard (22 par défaut)
ssh -p 2222 alice@serveur.exemple.fr

# Exécuter une commande sans ouvrir un shell interactif
ssh alice@serveur.exemple.fr "df -h"
ssh alice@serveur.exemple.fr "ls /var/log/*.log | wc -l"

# Avec allocation de pseudo-terminal (pour les commandes interactives)
ssh -t alice@serveur.exemple.fr "sudo bash"

# Rediriger les données via ssh
ssh alice@serveur.exemple.fr "cat /etc/passwd" > passwd_distant
tar czf - /var/www | ssh alice@serveur.exemple.fr "cat > /backup/www.tar.gz"

Authentification par clé#

L’authentification par clé publique est bien plus sécurisée que par mot de passe et permet l’automatisation sans intervention humaine.

# Générer une paire de clés (ED25519 recommandé, RSA toujours courant)
ssh-keygen -t ed25519 -C "alice@machine-locale"
ssh-keygen -t rsa -b 4096 -C "alice@machine-locale"

# La clé privée est dans ~/.ssh/id_ed25519
# La clé publique est dans ~/.ssh/id_ed25519.pub

# Copier la clé publique vers le serveur distant
ssh-copy-id alice@serveur.exemple.fr
ssh-copy-id -i ~/.ssh/id_ed25519.pub alice@serveur.exemple.fr

# Alternative manuelle
cat ~/.ssh/id_ed25519.pub | ssh alice@serveur.exemple.fr \
  "mkdir -p ~/.ssh && chmod 700 ~/.ssh && \
   cat >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys"

# Vérifier la connexion sans mot de passe
ssh alice@serveur.exemple.fr echo "Connexion sans mot de passe réussie"

Le fichier `~/.ssh/config`#

Le fichier de configuration SSH permet de définir des alias de connexion avec des paramètres spécifiques à chaque hôte.

# Exemple de ~/.ssh/config
Host prod
    HostName serveur-prod.exemple.fr
    User deploiement
    Port 2222
    IdentityFile ~/.ssh/id_ed25519_prod
    ServerAliveInterval 60

Host bastion
    HostName bastion.exemple.fr
    User alice
    IdentityFile ~/.ssh/id_ed25519

Host interne
    HostName 192.168.1.100
    User admin
    ProxyJump bastion         # Se connecter via le bastion

Host *.dev.exemple.fr
    User alice
    IdentityFile ~/.ssh/id_ed25519_dev
    StrictHostKeyChecking no  # Pour les VMs de développement

# Avec le fichier de configuration
ssh prod                  # Connexion à serveur-prod.exemple.fr en tant que deploiement
ssh interne               # Connexion via le bastion automatiquement

Tunnels SSH#

# Tunnel local (port forwarding) : accéder à un service distant comme s'il était local
# Accéder à une base de données sur le serveur via le port local 5433
ssh -L 5433:localhost:5432 alice@serveur.exemple.fr

# Tunnel distant (reverse forwarding) : exposer un service local sur le serveur
# Rendre accessible le port local 8080 via le port 8080 du serveur
ssh -R 8080:localhost:8080 alice@serveur.exemple.fr

# Proxy SOCKS5 : faire passer tout le trafic via le serveur distant
ssh -D 1080 alice@serveur.exemple.fr
# Configurer le navigateur pour utiliser SOCKS5 sur 127.0.0.1:1080

# Tunnel persistant en arrière-plan
ssh -fNL 5433:localhost:5432 alice@serveur.exemple.fr
# -f : passer en arrière-plan, -N : pas d'exécution de commande

# Agent SSH (pour propager les clés dans les connexions enchaînées)
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519
ssh -A alice@bastion   # -A : activer le forwarding d'agent

`scp` et `rsync` : transfert de fichiers#

`scp`#

scp (Secure Copy) copie des fichiers entre machines locales et distantes via SSH.

# Copier un fichier local vers un serveur distant
scp fichier.txt alice@serveur.exemple.fr:/home/alice/

# Copier depuis un serveur distant vers local
scp alice@serveur.exemple.fr:/var/log/app.log .

# Copier un répertoire entier (récursif)
scp -r ./projet alice@serveur.exemple.fr:/home/alice/

# Port non standard
scp -P 2222 fichier.txt alice@serveur.exemple.fr:/tmp/

# Entre deux serveurs distants (via la machine locale)
scp alice@serveur1.exemple.fr:/tmp/data.csv bob@serveur2.exemple.fr:/tmp/

`rsync`#

rsync est bien plus puissant que scp : il ne transfère que les différences entre la source et la destination, ce qui le rend extrêmement efficace pour la synchronisation de répertoires volumineux et les sauvegardes.

Définition 41 (rsync)

rsync (remote sync) est un outil de synchronisation de fichiers qui utilise un algorithme de delta-compression pour ne transférer que les parties modifiées des fichiers. Il peut fonctionner localement (plus rapide que cp pour les grandes arborescences) ou à distance via SSH. Il supporte la préservation des attributs, les exclusions, la suppression des fichiers absents de la source, et les simulations à blanc (--dry-run).

# Synchroniser un répertoire local vers un serveur (avec SSH)
rsync -avz ./projet/ alice@serveur.exemple.fr:/home/alice/projet/

# Options courantes
# -a : archive (préserve permissions, dates, symlinks, propriétaire)
# -v : verbeux
# -z : compression pendant le transfert
# -P : progression + reprise (--partial --progress)
# --delete : supprimer les fichiers de la destination absents de la source
# --exclude : exclure des fichiers/répertoires
# --dry-run (-n) : simulation sans transfert réel

# Sauvegarde avec suppression des fichiers supprimés
rsync -avz --delete /home/alice/ alice@backup.exemple.fr:/backups/alice/

# Exclure des fichiers
rsync -avz --exclude='*.log' --exclude='node_modules/' \
      ./projet/ alice@serveur.exemple.fr:/deploiement/

# Exclusions depuis un fichier
rsync -avz --exclude-from='.rsyncignore' \
      ./projet/ alice@serveur.exemple.fr:/deploiement/

# Copie locale (plus rapide que cp -r sur les gros répertoires)
rsync -av --delete /var/www/ /backup/www/

# Port SSH non standard
rsync -avz -e "ssh -p 2222" ./fichier alice@serveur.exemple.fr:/tmp/

# Simulation à blanc (voir ce qui serait transféré sans le faire)
rsync -avz --dry-run ./projet/ alice@serveur.exemple.fr:/deploiement/

# Synchronisation avec progression détaillée
rsync -avzP ./gros_dossier/ alice@serveur.exemple.fr:/destination/

Diagnostic réseau#

`ping`#

# Test de connectivité de base
ping exemple.fr

# Nombre limité de paquets
ping -c 4 exemple.fr

# Intervalle entre les paquets (en secondes)
ping -i 0.2 exemple.fr

# Taille des paquets
ping -s 1024 exemple.fr

# Timeout (arrêter après N secondes)
ping -w 10 exemple.fr

# Tester si un hôte est accessible (dans un script)
if ping -c 1 -W 2 exemple.fr &>/dev/null; then
    echo "Hôte accessible"
else
    echo "Hôte inaccessible"
fi

`traceroute` et `mtr`#

# traceroute : afficher le chemin des paquets
traceroute exemple.fr

# Utiliser ICMP au lieu d'UDP
traceroute -I exemple.fr

# Résolution inverse DNS désactivée (plus rapide)
traceroute -n exemple.fr

# mtr : combinaison de ping et traceroute (temps réel)
mtr exemple.fr

# Mode rapport (une seule passe)
mtr --report -n exemple.fr
mtr --report --report-cycles 10 exemple.fr

# Format JSON
mtr --json -n exemple.fr

Remarque 36

mtr (My TraceRoute) est souvent préféré à traceroute car il affiche en continu les statistiques de latence et de perte de paquets pour chaque saut, permettant d’identifier précisément où se produit un problème réseau. Il combine en temps réel le chemin de routage (comme traceroute) et les statistiques de latence (comme ping), ce qui en fait l’outil de diagnostic le plus informatif pour les problèmes de connectivité.

`ss` et `netstat` : connexions et ports#

`ss` (socket statistics)#

ss est le successeur moderne de netstat, plus rapide car il interroge directement le noyau.

# Toutes les connexions TCP
ss -t

# Toutes les connexions UDP
ss -u

# Tous les ports en écoute
ss -l

# Connexions TCP en écoute avec PID et programme
ss -tlnp

# Toutes les connexions (listening + established)
ss -an

# Connexions établies (ESTABLISHED)
ss -t state established

# Filtrer par port
ss -t dst :443         # Connexions vers le port 443
ss -t src :22          # Connexions depuis le port 22
ss -lp | grep :8080    # Vérifier si le port 8080 est en écoute

# Statistiques résumées
ss -s

# Options combinées courantes
ss -tlnp    # Ports TCP en écoute, sans résolution DNS, avec PID
ss -ulnp    # Ports UDP en écoute
ss -antup   # Toutes les connexions TCP et UDP avec PID

`netstat`#

netstat est l’outil classique, encore présent dans beaucoup de distributions.

# Ports en écoute TCP
netstat -tlnp

# Toutes les connexions
netstat -an

# Statistiques par protocole
netstat -s

# Table de routage
netstat -r

`dig` et `nslookup` : résolution DNS#

`dig`#

dig (Domain Information Groper) est l’outil de référence pour interroger les serveurs DNS.

Définition 42 (Enregistrements DNS)

Le DNS (Domain Name System) traduit les noms de domaine en adresses IP et stocke diverses informations dans des enregistrements (records) de types différents :

A : adresse IPv4 associée à un nom
AAAA : adresse IPv6
CNAME : alias vers un autre nom
MX : serveurs de messagerie (Mail eXchanger)
TXT : texte libre (SPF, DKIM, vérification de domaine, etc.)
NS : serveurs de noms autoritaires pour la zone
PTR : résolution inverse (IP → nom)
SOA : informations d’autorité sur la zone

# Résolution A basique
dig exemple.fr

# Enregistrement spécifique
dig exemple.fr A          # Adresse IPv4
dig exemple.fr AAAA       # Adresse IPv6
dig exemple.fr MX         # Serveurs de messagerie
dig exemple.fr TXT        # Enregistrements TXT (SPF, DKIM, etc.)
dig exemple.fr NS         # Serveurs de noms
dig exemple.fr SOA        # Start of Authority
dig exemple.fr CNAME      # Alias

# Sortie courte (sans les commentaires)
dig +short exemple.fr
dig +short exemple.fr MX

# Interroger un serveur DNS spécifique
dig @8.8.8.8 exemple.fr          # Google DNS
dig @1.1.1.1 exemple.fr          # Cloudflare DNS
dig @9.9.9.9 exemple.fr          # Quad9

# Résolution inverse (IP → nom)
dig -x 93.184.216.34
dig +short -x 8.8.8.8

# Trace complet de la résolution (pour le débogage)
dig +trace exemple.fr

# Sans récursion (interroger directement les serveurs autoritaires)
dig +norecurse exemple.fr @a.root-servers.net

# Tous les enregistrements
dig exemple.fr ANY

# Vérifier la propagation DNS (plusieurs serveurs)
for ns in 8.8.8.8 1.1.1.1 9.9.9.9 208.67.222.222; do
    echo -n "$ns : "
    dig +short @$ns exemple.fr
done

`nslookup`#

# Mode interactif
nslookup
> exemple.fr
> set type=MX
> exemple.fr
> exit

# Mode non interactif
nslookup exemple.fr
nslookup -type=MX exemple.fr
nslookup -type=TXT exemple.fr 8.8.8.8   # Via Google DNS

`ip` : configuration réseau#

La commande ip est l’outil moderne (suite iproute2) qui remplace les anciennes commandes ifconfig, route et arp.

# Afficher les interfaces réseau et leurs adresses
ip addr
ip addr show
ip addr show eth0    # Interface spécifique
ip -4 addr           # IPv4 uniquement
ip -6 addr           # IPv6 uniquement

# Afficher la table de routage
ip route
ip route show
ip -4 route          # Routes IPv4

# Afficher les informations de couche liaison
ip link
ip link show eth0

# Afficher les voisins ARP/NDP
ip neigh
ip neigh show

# Statistiques réseau
ip -s link

# Ajouter/supprimer une adresse IP (temporaire jusqu'au redémarrage)
sudo ip addr add 192.168.1.100/24 dev eth0
sudo ip addr del 192.168.1.100/24 dev eth0

# Activer/désactiver une interface
sudo ip link set eth0 up
sudo ip link set eth0 down

# Ajouter/supprimer une route
sudo ip route add 10.0.0.0/8 via 192.168.1.1
sudo ip route del 10.0.0.0/8

# Route par défaut
sudo ip route add default via 192.168.1.1

Exemple 26 (Script de diagnostic réseau complet)

Un script de diagnostic rapide utilisable pour investiguer des problèmes de connectivité :

#!/usr/bin/env bash
set -euo pipefail

cible="${1:-8.8.8.8}"
domaine="${2:-google.com}"

echo "=== Interfaces réseau ==="
ip -4 addr show | grep -E "^[0-9]|inet "

echo -e "\n=== Table de routage ==="
ip route | head -5

echo -e "\n=== Test de connectivité vers $cible ==="
if ping -c 3 -W 2 "$cible" 2>/dev/null; then
    echo "OK : $cible est accessible"
else
    echo "ÉCHEC : $cible inaccessible"
fi

echo -e "\n=== Résolution DNS de $domaine ==="
dig +short "$domaine" A || echo "Résolution DNS échouée"

echo -e "\n=== Ports en écoute ==="
ss -tlnp | grep -v "^State" | head -10

echo -e "\n=== Connexions établies ==="
ss -tn state established | wc -l
echo "connexions TCP établies"

## Visualisation : outils réseau par couche OSI

```{code-cell} python
:tags: [hide-input]

fig, ax = plt.subplots(figsize=(16, 10))
ax.set_xlim(0, 16)
ax.set_ylim(0, 10)
ax.axis('off')
ax.set_title('Outils réseau Linux par couche du modèle OSI',
             fontsize=14, fontweight='bold', pad=15)

palette = sns.color_palette("muted", 10)

# Définition des couches OSI
couches = [
    (7, "Application",    "#e74c3c", ["curl", "wget", "ssh", "scp", "rsync", "dig", "nslookup"]),
    (6, "Présentation",   "#e67e22", ["openssl", "curl --cert", "ssh (chiffrement)"]),
    (5, "Session",        "#f39c12", ["ssh (sessions)", "tmux", "screen"]),
    (4, "Transport",      "#27ae60", ["ss", "netstat", "nmap", "iperf3"]),
    (3, "Réseau",         "#2980b9", ["ip route", "ping", "traceroute", "mtr"]),
    (2, "Liaison",        "#8e44ad", ["ip link", "arp", "ip neigh", "ethtool"]),
    (1, "Physique",       "#7f8c8d", ["ethtool", "mii-tool", "lshw -C network"]),
]

layer_height = 1.1
start_y = 1.0

for i, (num, nom, couleur, outils) in enumerate(couches):
    y = start_y + i * layer_height

    # Rectangle de la couche
    rect = patches.FancyBboxPatch(
        (0.3, y), 4.2, layer_height * 0.85,
        boxstyle="round,pad=0.1", linewidth=2,
        edgecolor=couleur, facecolor=couleur, alpha=0.2
    )
    ax.add_patch(rect)
    border = patches.FancyBboxPatch(
        (0.3, y), 4.2, layer_height * 0.85,
        boxstyle="round,pad=0.1", linewidth=2,
        edgecolor=couleur, facecolor='none'
    )
    ax.add_patch(border)

    # Numéro de couche
    ax.text(1.0, y + layer_height * 0.425, f"Couche {num}", ha='center',
            va='center', fontsize=10, fontweight='bold', color=couleur)
    ax.text(2.7, y + layer_height * 0.425, nom, ha='center',
            va='center', fontsize=10, color='#333')

    # Outils correspondants
    for j, outil in enumerate(outils[:4]):  # Limiter à 4 par couche
        x_outil = 5.5 + j * 2.5
        tool_box = patches.FancyBboxPatch(
            (x_outil - 1.0, y + 0.12), 2.0, layer_height * 0.6,
            boxstyle="round,pad=0.1", linewidth=1.5,
            edgecolor=couleur, facecolor=couleur, alpha=0.35
        )
        ax.add_patch(tool_box)
        ax.text(x_outil, y + layer_height * 0.42, outil, ha='center',
                va='center', fontsize=8.5, fontweight='bold',
                fontfamily='monospace', color='#1a1a2e')

# Flèche montrant la direction (bas = physique, haut = application)
ax.annotate('', xy=(15.5, 9.5), xytext=(15.5, 1.0),
            arrowprops=dict(arrowstyle='->', color='#555', lw=2.5))
ax.text(15.7, 5.3, 'Abstraction\ncroissante', va='center', ha='left',
        fontsize=9, color='#555', style='italic', rotation=90)

# Légende protocoles
legend_y = 0.3
ax.text(0.3, legend_y, 'Bleu = niveau réseau  |  Vert = transport  |  Rouge = application',
        fontsize=8.5, color='#555', style='italic')

plt.tight_layout()
plt.show()

Résumé#

Ce chapitre a couvert l’ensemble des outils réseau essentiels disponibles depuis le terminal Linux :

curl est l’outil universel pour les requêtes HTTP : GET, POST, PUT, DELETE, headers personnalisés, authentification Bearer, envoi de JSON. Combiné à jq, il permet d’interagir complètement avec les API REST depuis le terminal.
wget excelle pour les téléchargements simples et récursifs : reprise automatique, miroirs de sites, téléchargements en lot depuis une liste d’URLs.
ssh fournit un accès sécurisé aux machines distantes. L”authentification par clé et le fichier ~/.ssh/config sont essentiels pour l’automatisation. Les tunnels SSH permettent de sécuriser n’importe quel trafic.
rsync surpasse scp pour les transferts de fichiers en ne transmettant que les différences, avec support de l’exclusion, de la simulation et de la progression.
ping, traceroute et mtr permettent de diagnostiquer la connectivité et d’identifier les goulots d’étranglement réseau.
ss (et l’ancien netstat) inspecte les connexions actives et les ports en écoute.
dig est l’outil de référence pour les requêtes DNS (A, AAAA, MX, TXT, NS) et le débogage de la propagation.
ip est la commande moderne pour configurer et inspecter les interfaces réseau, la table de routage et les voisins ARP.

Le chapitre suivant explore la gestion des paquets sous Debian/Ubuntu : apt, dpkg, snap, flatpak, et la compilation depuis les sources.

Réseau depuis le terminal

Contenu

Réseau depuis le terminal#

curl : requêtes HTTP et API#

Options essentielles#

Méthodes HTTP et envoi de données#

En-têtes personnalisées et authentification#

Traitement des réponses JSON avec jq#

ssh : connexion sécurisée#

Connexion de base#

Authentification par clé#

Le fichier ~/.ssh/config#

Tunnels SSH#

scp et rsync : transfert de fichiers#

scp#

rsync#

Diagnostic réseau#

ping#

traceroute et mtr#

ss et netstat : connexions et ports#

ss (socket statistics)#

netstat#

dig et nslookup : résolution DNS#

dig#

nslookup#

ip : configuration réseau#