« Chaque service doit recevoir un /24 : c’est plus simple. »
C’est simple à court terme, mais souvent coûteux et peu lisible. VLSM permet d’adapter la taille des blocs aux besoins réels tout en gardant une réserve de croissance.
La PME possède 10.30.0.0/24 et formule ces besoins :
| Zone | Besoin actuel | Capacité retenue |
|---|---|---|
| Direction & bureaux | 50 hôtes | /26 → 62 hôtes |
| Production | 25 hôtes | /27 → 30 hôtes |
| Équipe IT | 12 hôtes | /28 → 14 hôtes |
| Serveurs | 6 hôtes | /29 → 6 hôtes |
01Choisir les préfixes
Trouve le plus petit bloc suffisant
Pour un besoin donné, cherche le plus petit nombre de bits hôte dont la capacité utile est suffisante :
/26 : 64 adresses, 62 hôtes
/27 : 32 adresses, 30 hôtes
/28 : 16 adresses, 14 hôtes
/29 : 8 adresses, 6 hôtes02Allouer du plus grand au plus petit
Évite de fragmenter l’espace
- trie les besoins par taille décroissante ;
- place le plus grand bloc au début du réseau parent ;
- aligne chaque bloc sur une frontière valide ;
- continue avec le prochain espace disponible ;
- conserve la fin du parent comme réserve.
03Livrer le plan
| Zone | Réseau | Passerelle proposée | Plage DHCP / statique | Broadcast |
|---|---|---|---|---|
| Bureaux | 10.30.0.0/26 | 10.30.0.1 | 10.30.0.10–62 | 10.30.0.63 |
| Production | 10.30.0.64/27 | 10.30.0.65 | 10.30.0.70–94 | 10.30.0.95 |
| IT | 10.30.0.96/28 | 10.30.0.97 | 10.30.0.100–110 | 10.30.0.111 |
| Serveurs | 10.30.0.112/29 | 10.30.0.113 | 10.30.0.114–118 statiques | 10.30.0.119 |
Les adresses 10.30.0.120–255 restent disponibles. Elles ne doivent pas être distribuées au hasard : la réserve doit être documentée.
04Automatiser le contrôle
Fais calculer une allocation décroissante
python3 - <<'PY'
from ipaddress import ip_network
from math import ceil, log2
parent = ip_network("10.30.0.0/24")
needs = [
("Bureaux", 50),
("Production", 25),
("IT", 12),
("Serveurs", 6),
]
cursor = int(parent.network_address)
for name, hosts_needed in sorted(needs, key=lambda item: item[1], reverse=True):
total_needed = hosts_needed + 2
host_bits = ceil(log2(total_needed))
prefix = 32 - host_bits
block_size = 2 ** host_bits
if cursor % block_size:
cursor += block_size - (cursor % block_size)
subnet = ip_network((cursor, prefix))
if not subnet.subnet_of(parent):
raise RuntimeError("Le réseau parent est trop petit")
hosts = list(subnet.hosts())
print(f"{name:12} {subnet} {hosts[0]} → {hosts[-1]}")
cursor += block_size
PY05Détecter un chevauchement
Analyse ce mauvais plan
Bureaux 10.30.0.0/26
Production 10.30.0.32/27
IT 10.30.0.64/28.32, mais cette adresse appartient encore au bloc Bureaux .0–.63. Les deux allocations se chevauchent.Vérifie par le code :
python3 - <<'PY'
from ipaddress import ip_network
a = ip_network("10.30.0.0/26")
b = ip_network("10.30.0.32/27", strict=False)
print(a, b, "chevauchement =", a.overlaps(b))
PYCrée ton propre plan
À partir de 172.20.8.0/23, alloue des zones pour 120, 60, 28, 12 et 6 hôtes.
- calcule le préfixe de chaque zone ;
- alloue du plus grand au plus petit ;
- réserve la première adresse utilisable comme passerelle ;
- sépare DHCP et adresses statiques ;
- documente la réserve restante ;
- prouve l’absence de chevauchement avec Python.
✓Ce que tu retiens
VLSM adapte chaque sous-réseau au besoin réel. Une allocation fiable commence par les plus grands blocs, respecte les frontières, réserve les passerelles et conserve une marge de croissance documentée.