Découpe un /24 en sous-réseaux égaux

L’idée reçue

« Découper un /24 en quatre revient à choisir quatre groupes d’adresses approximatifs. »

Les blocs ont des frontières mathématiques précises. Une seule adresse placée du mauvais côté change le sous-réseau auquel la machine appartient.

La PME reçoit le réseau privé 192.168.10.0/24. Elle veut quatre segments de taille identique. Pour obtenir quatre blocs, tu empruntes deux bits aux hôtes : /24 → /26.

01Produire les quatre blocs

Calcul

Vérifie le découpage avec Python

python3 - <<'PY'
from ipaddress import ip_network

parent = ip_network("192.168.10.0/24")
for index, subnet in enumerate(parent.subnets(new_prefix=26), start=1):
  hosts = list(subnet.hosts())
  print(index, subnet, hosts[0], hosts[-1], subnet.broadcast_address)
PY

Observe

1 192.168.10.0/26   192.168.10.1   192.168.10.62  192.168.10.63
2 192.168.10.64/26  192.168.10.65  192.168.10.126 192.168.10.127
3 192.168.10.128/26 192.168.10.129 192.168.10.190 192.168.10.191
4 192.168.10.192/26 192.168.10.193 192.168.10.254 192.168.10.255

LAN A192.168.10.0/26.1 – .62

LAN B192.168.10.64/26.65 – .126

LAN C192.168.10.128/26.129 – .190

LAN D192.168.10.192/26.193 – .254

02Construire deux segments

Expérience 1

Crée deux bridges et quatre postes

for ns in a1 a2 b1 b2; do
sudo ip netns del "$ns" 2>/dev/null || true
sudo ip netns add "$ns"
sudo ip -n "$ns" link set lo up
done

sudo ip link del br-a 2>/dev/null || true
sudo ip link del br-b 2>/dev/null || true
sudo ip link add br-a type bridge
sudo ip link add br-b type bridge
sudo ip link set br-a up
sudo ip link set br-b up

for spec in "a1 br-a" "a2 br-a" "b1 br-b" "b2 br-b"; do
set -- $spec
ns=$1
br=$2
sudo ip link add "${ns}-host" type veth peer name "${ns}-eth"
sudo ip link set "${ns}-host" master "$br"
sudo ip link set "${ns}-host" up
sudo ip link set "${ns}-eth" netns "$ns"
sudo ip -n "$ns" link set "${ns}-eth" name eth0
sudo ip -n "$ns" link set eth0 up
done

03Attribuer les adresses

Expérience 2

Place deux postes dans chaque /26

sudo ip -n a1 addr add 192.168.10.10/26 dev eth0
sudo ip -n a2 addr add 192.168.10.20/26 dev eth0
sudo ip -n b1 addr add 192.168.10.70/26 dev eth0
sudo ip -n b2 addr add 192.168.10.80/26 dev eth0

sudo ip netns exec a1 ping -c 2 192.168.10.20
sudo ip netns exec b1 ping -c 2 192.168.10.80

Chaque paire communique dans son propre bridge et son propre sous-réseau.

04Tester entre les segments

Expérience 3

Essaie de joindre LAN B depuis LAN A

sudo ip -n a1 route get 192.168.10.70
sudo ip netns exec a1 ping -c 2 192.168.10.70

Aucune route ne relie les deux segments. Le découpage IPv4 produit des réseaux logiques distincts ; les deux bridges produisent aussi deux domaines Ethernet distincts.

05Comprendre FLSM

Décision	Résultat
Réseau parent	192.168.10.0/24
Nombre de sous-réseaux souhaités	4
Bits empruntés	2, car 2² = 4
Nouveau préfixe	/26
Adresses par bloc	64
Hôtes usuels par bloc	62

Cette méthode s’appelle FLSM : tous les sous-réseaux utilisent le même masque. Elle est simple, mais peut gaspiller des adresses si les services ont des besoins très différents.

Défi autonome

Découpe 10.40.0.0/22 en huit blocs égaux

détermine le nombre de bits à emprunter ;
trouve le nouveau préfixe ;
liste les huit réseaux ;
donne la capacité utile de chaque bloc ;
vérifie avec ipaddress.

06Nettoyer

for ns in a1 a2 b1 b2; do sudo ip netns del "$ns"; done
sudo ip link del br-a
sudo ip link del br-b

✓Ce que tu retiens

En empruntant deux bits à un /24, tu obtiens quatre /26 de 64 adresses. Le découpage est régulier et vérifiable. Deux sous-réseaux distincts ont besoin d’un routeur pour échanger.