Calculateur de sous-réseau CIDR : calculer, agréger des plages et tester une IP

Calculateur de sous-réseau CIDR : calculer, agréger des plages et tester une IP

Calculez réseau, masque, plage d’hôtes et broadcast d’un CIDR, agrégez des plages en blocs minimaux et testez une IP, directement dans votre navigateur.

11.10.2026
18 min de lecture
Partager cet article:
RéseauSous-réseauCIDRIPSysadmin

Un bloc CIDR se résume à un début et une taille

Dès que vous planifiez un VPC, écrivez une règle de pare-feu ou dressez une liste d’adresses autorisées, vous manipulez des blocs comme 10.0.0.0/16. La notation CIDR cache un calcul : début et fin du bloc, nombre d’hôtes, chevauchement de deux blocs, réduction de dix entrées à deux. Le calculateur de sous-réseau prend une adresse et un préfixe (ou, en IPv4, un masque décimal). Il affiche le réseau, le masque, le masque inverse et le broadcast. Il donne aussi la première et la dernière adresse utilisable, le nombre d’hôtes et la classe de l’adresse, en IPv4 comme en IPv6. L’outil Agréger CIDR lit une liste d’un CIDR par ligne et la ramène aux blocs les moins nombreux qui couvrent exactement les mêmes adresses. L’outil IP dans un sous-réseau dit si une IP appartient à un bloc, ou si deux blocs se chevauchent. Les trois outils calculent dans votre navigateur et n’envoient aucune adresse à FastMinify. Ce guide rappelle comment un préfixe fixe la taille d’un bloc, comment lire chaque champ du résultat et comment agréger une liste sans rien inventer. Il décrit ensuite les erreurs qui coûtent cher, comme un sous-réseau trop petit ou deux VPC qui se chevauchent. Il refait enfin les mêmes calculs en Python, en Node et avec la fonction cidrsubnet de Terraform. Les outils voisins se trouvent dans le hub des outils réseau.

Calculateur de sous-réseau : IPv4 et IPv6, préfixe CIDR ou masque décimal (IPv4 seulement). Il affiche Network, Subnet mask, Wildcard, Broadcast, First usable, Last usable, Host count et Address class, avec une vue binaire en option
Deux façons de compter les hôtes, Utilisables ou Total. En IPv4, un /31 compte 2 hôtes (RFC 3021) et un /32 en compte 1. En IPv6, il n’y a pas de broadcast et le nombre utilisable égale le total
Agréger CIDR : fusionne les blocs qui se chevauchent et les blocs adjacents qui s’alignent. Il ne comble jamais un trou et ignore les lignes vides et celles qui commencent par #. Il s’arrête à la première ligne invalide en donnant son numéro
IP dans un sous-réseau : le mode contains dit si une IP appartient à un CIDR, le mode overlap si deux CIDR partagent une adresse. La famille se détecte seule ou se force en IPv4 ou en IPv6
Aucun accès réseau : les outils ne pingent rien, ne résolvent aucun nom et ne consultent aucun registre. Ils font de l’arithmétique sur les adresses que vous saisissez
Une limite de 64 Kio de saisie par outil, et un calcul qui reste dans l’onglet

Quel outil pour quelle question

Les bons usages

Ces outils font de l’arithmétique d’adresses. Ils servent à vérifier un plan avant de l’écrire dans une console cloud ou dans un fichier de règles.

Contrôler un plan d’adressage avant de créer les sous-réseaux : réseau, broadcast et nombre d’hôtes de chaque bloc, dans le <a href="/fr/subnet-calculator" class="text-primary hover:underline">calculateur de sous-réseau</a>
Traduire un masque lu sur un routeur ou dans une interface Windows (<code>255.255.240.0</code>) en préfixe (<code>/20</code>) et en masque inverse (<code>0.0.15.255</code>), celui qu’attendent les ACL de style Cisco
Réduire une liste de plusieurs dizaines d’adresses autorisées avant de la coller dans un groupe de sécurité, un WAF ou un pare-feu qui limite le nombre de règles, avec l’<a href="/fr/cidr-summarize" class="text-primary hover:underline">outil Agréger CIDR</a>
Tester une règle : l’IP <code>10.1.2.3</code> relève-t-elle de <code>10.1.0.0/16</code> ? L’<a href="/fr/ip-in-subnet" class="text-primary hover:underline">outil IP dans un sous-réseau</a> répond par une phrase
Vérifier avant un appairage de réseaux ou un VPN que deux plages ne se chevauchent pas
Comparer le sous-réseau d’un réseau Docker Compose (clé <code>ipam</code>) aux plages de votre VPN d’entreprise. Le <a href="/fr/blog/valider-docker-compose-env-en-ligne" class="text-primary hover:underline">guide Docker Compose</a> couvre la validation du reste du fichier
Ce qui relève d’autre chose

Chaque outil s’arrête là où un autre commence, ou là où commence votre propre outillage.

Passer une adresse en décimal, en binaire ou en hexadécimal : le <a href="/fr/ip-address-converter" class="text-primary hover:underline">convertisseur d’adresse IP</a>
Découper une plage comme <code>10.0.0.1-10.0.0.3</code> en blocs CIDR : le <a href="/fr/ip-range-to-cidr" class="text-primary hover:underline">convertisseur Plage IP → CIDR</a>
Changer de base un nombre quelconque : le <a href="/fr/number-base-converter" class="text-primary hover:underline">convertisseur de bases</a>
Savoir si une machine répond, quel chemin suit un paquet ou ce que résout le DNS : aucun de ces outils n’envoie de paquet
Retirer du compte les adresses que votre fournisseur cloud garde pour lui : la documentation du fournisseur fait foi (voir plus bas)
Écrire les blocs dans votre infrastructure : le <a href="/fr/blog/terraform-hcl-formater-valider-en-ligne" class="text-primary hover:underline">guide Terraform</a> et le <a href="/fr/blog/kubernetes-valider-manifests-yaml" class="text-primary hover:underline">guide Kubernetes</a> valident les fichiers eux-mêmes, et <code>cidrsubnet</code> est présenté plus bas

Lire les résultats sans se tromper

Le résultat du calculateur, champ par champ

Saisissez une adresse et un préfixe dans le calculateur de sous-réseau. Prenons 192.0.2.10 avec /24, puis 172.16.37.200 avec /20.

Network est l’adresse dont les bits d’hôte sont mis à zéro : <code>192.0.2.10/24</code> donne <code>192.0.2.0</code>. Vous n’avez pas besoin de connaître l’adresse du réseau pour la saisir
Broadcast est la dernière adresse du bloc. La première adresse utilisable est le réseau plus un, la dernière est le broadcast moins un : pour ce /24, de <code>192.0.2.1</code> à <code>192.0.2.254</code>, soit 254 hôtes
Wildcard est le masque inversé bit à bit : <code>0.0.0.255</code> pour un /24, <code>0.0.15.255</code> pour un /20. Les ACL de style Cisco et les instructions <code>network</code> d’OSPF s’écrivent avec lui
Le /20 de l’exemple donne le réseau <code>172.16.32.0</code>, le broadcast <code>172.16.47.255</code>, le masque <code>255.255.240.0</code> et 4 094 hôtes utilisables
Un /31 compte deux adresses, toutes deux utilisables sur une liaison point à point (RFC 3021), et un /32 désigne une seule adresse. Le calculateur applique ces deux cas au lieu de soustraire deux
Address class nomme la plage. Privé couvre 10.0.0.0/8, 172.16.0.0/12 et 192.168.0.0/16 (RFC 1918). NAT niveau opérateur couvre 100.64.0.0/10 (RFC 6598). Réservé couvre les plages de documentation, dont 192.0.2.0/24 (RFC 5737)
Agréger une liste de blocs

Collez un CIDR par ligne dans l’outil Agréger CIDR. Prenons 10.0.0.0/25, 10.0.0.128/25, 10.0.1.0/24 et 10.0.2.0/24 : le résultat tient en deux lignes, 10.0.0.0/23 et 10.0.2.0/24.

Les lignes vides et celles qui commencent par <code>#</code> sont ignorées. La première ligne invalide arrête le calcul et l’erreur donne son numéro
Un CIDR sans préfixe (<code>10.0.1.0</code>) est refusé. Pour une adresse seule, écrivez <code>/32</code>
Les bits d’hôte sont ramenés au réseau : <code>10.0.0.5/24</code> et <code>10.0.0.77/24</code> donnent ensemble <code>10.0.0.0/24</code>
Deux blocs voisins ne fusionnent que s’ils s’alignent. <code>10.0.0.0/25</code> et <code>10.0.0.128/25</code> forment un /24, mais <code>10.0.1.0/24</code> et <code>10.0.2.0/24</code> restent deux lignes, car un /23 doit commencer à une adresse paire du troisième octet
Un trou n’est jamais comblé. <code>10.0.0.0/24</code> et <code>10.0.2.0/24</code> restent séparés : le résultat couvre exactement les mêmes adresses que l’entrée, ni plus ni moins
Un IPv4 et un IPv6 dans la même liste sont refusés (« Familles mixtes à la ligne 2 »). Agrégez les deux familles séparément
Avec l’option Fusionner désactivée, l’outil retire seulement les doublons exacts et ne fusionne rien
Tester une IP ou deux plages

L’outil IP dans un sous-réseau a deux modes, choisis avec le sélecteur Mode. Le verdict s’écrit en toutes lettres, par exemple « 10.1.2.3 est dans 10.1.0.0/16 ».

En mode contains, le premier champ reçoit une IP et le second un CIDR. En mode overlap, les deux champs reçoivent un CIDR
Deux blocs CIDR sont soit imbriqués, soit disjoints : ils ne se recouvrent jamais à moitié. <code>10.0.0.0/16</code> et <code>10.0.128.0/17</code> se chevauchent parce que le second est dans le premier, <code>10.0.0.0/16</code> et <code>10.1.0.0/16</code> ne se chevauchent pas
Les bits d’hôte du CIDR sont ignorés. Le bloc <code>10.1.5.9/16</code> est traité comme <code>10.1.0.0/16</code>, et <code>10.1.2.3</code> y figure bien
Les deux champs doivent être de la même famille. Une adresse IPv6 « mappée » comme <code>::ffff:10.1.2.3</code> n’est pas une IPv4 : face à un CIDR IPv4, l’outil répond que les familles diffèrent
Famille propose auto, IPv4 ou IPv6. Forcer une famille rejette l’autre au lieu de deviner
Un CIDR sans préfixe (<code>10.1.0.0</code>) est refusé comme CIDR invalide

Quatre erreurs qui coûtent un redéploiement

Écrire le préfixe dans le champ de l’adresse

Le calculateur a deux champs, Adresse IP et Préfixe. Si vous saisissez 192.0.2.10/24 dans le premier, il répond que l’adresse ne doit pas contenir de « / » et qu’il faut utiliser le champ préfixe. L’erreur est volontaire : un champ qui accepterait les deux formes laisserait passer des saisies ambiguës. En mode Masque, le second champ attend un masque contigu comme 255.255.240.0, et un masque comme 255.255.0.255 est refusé comme invalide.

Coller un CIDR complet dans le champ de l’adresse
Saisir un masque inverse (<code>0.0.15.255</code>) là où un masque est attendu
Choisir le mode Masque pour une adresse IPv6, qui n’a pas de masque décimal
Saisir <code>24</code> en mode Masque, ou <code>255.255.255.0</code> en mode CIDR
Mettez l’adresse seule dans le premier champ et le préfixe, ou le masque, dans le second. Pour un CIDR déjà écrit, séparez-le au niveau du « / ».
Se fier au nombre d’hôtes pour dimensionner un sous-réseau cloud

Le calculateur applique la règle générale d’IPv4, soit le total moins l’adresse du réseau et le broadcast. Les fournisseurs cloud retirent davantage. Amazon VPC garde les quatre premières adresses et la dernière de chaque sous-réseau, soit cinq adresses. Un /24 offre alors 251 adresses, et un /28 en offre 11 au lieu de 14. Chez AWS, la taille d’un CIDR de VPC est aussi comprise entre /16 et /28. Les autres fournisseurs ont leurs propres réserves, que seule leur documentation donne. Le calculateur ne connaît pas ces plages réservées.

Prévoir un /28 pour 14 instances alors que seules 11 adresses sont libres
Oublier que les services gérés (équilibreur, passerelle NAT, interfaces réseau) consomment des adresses du même sous-réseau
Calculer un sous-réseau trop juste pour la montée en charge d’un groupe d’autoscaling
Reprendre les 254 hôtes d’un /24 dans un plan d’adressage cloud sans retirer les adresses réservées
Le sous-réseau est plein au pire moment, et un sous-réseau ne s’agrandit pas : il faut en créer un autre et déplacer les ressources.
Croire qu’agréger revient à élargir

L’agrégation de l’outil est exacte. Le résultat couvre les mêmes adresses que l’entrée, rien de plus, ce qui la rend sûre pour une liste d’autorisations. Écrire à la main un 10.0.0.0/22 pour remplacer 10.0.0.0/23 et 10.0.2.0/24 est autre chose : vous autorisez en plus 10.0.3.0/24, qui n’était pas dans la liste. Autre piège de lecture, le tri « Croissant » est un tri de texte. Pour la liste 10.0.0.0/8, 9.0.0.0/8, 172.16.0.0/12, le résultat s’affiche dans l’ordre 10.0.0.0/8, 172.16.0.0/12, 9.0.0.0/8.

Remplacer deux blocs séparés par un bloc plus large « pour simplifier », et ouvrir des adresses jamais voulues
Prendre le tri Croissant pour un tri numérique des adresses
Comparer deux listes agrégées sans les trier de la même façon
Agréger des listes IPv4 et IPv6 ensemble et s’étonner du refus
Laissez l’outil produire la liste exacte, et traitez tout bloc plus large comme une décision de sécurité, prise et relue comme telle.
Découvrir un chevauchement après avoir connecté les réseaux

Deux réseaux qui se chevauchent ne peuvent pas être reliés par un appairage, une passerelle de transit ou un VPN sans traduction d’adresses. Chez AWS, deux VPC dont les CIDR se chevauchent ne se relient ni par appairage ni par passerelle de transit. Le cas est fréquent. Tout le monde choisit 10.0.0.0/16, garde le VPC par défaut en 172.31.0.0/16 ou laisse Docker prendre 172.17.0.0/16, pendant que le réseau de bureau occupe 192.168.0.0/24. Le mode overlap répond en une phrase avant toute création de ressource.

Reprendre le CIDR par défaut d’un VPC de test pour la production
Allouer 10.0.0.0/16 à chaque projet d’une même organisation
Ne tester que les plages du cloud et oublier celles du bureau et du VPN
Mettre un sous-réseau Docker Compose dans une plage déjà utilisée par le réseau de l’entreprise
Il faut renuméroter un réseau déjà en service, ce qui veut dire recréer ses sous-réseaux et ses ressources.

Préfixes, plages spéciales et IPv6 en un coup d’œil

Préfixe, masque et taille du bloc

La taille d’un bloc IPv4 est une puissance de 2, déterminée par le préfixe. Chaque bit de préfixe ajouté divise le bloc par deux. Voici les tailles courantes, avec le nombre d’hôtes utilisables entre parenthèses.

<code>/16</code> a pour masque <code>255.255.0.0</code> et compte 65 536 adresses (65 534 utilisables)
<code>/20</code> a pour masque <code>255.255.240.0</code> et compte 4 096 adresses (4 094)
<code>/24</code> a pour masque <code>255.255.255.0</code> et compte 256 adresses (254)
<code>/25</code> a pour masque <code>255.255.255.128</code> et compte 128 adresses (126)
<code>/26</code> a pour masque <code>255.255.255.192</code> et compte 64 adresses (62)
<code>/27</code> a pour masque <code>255.255.255.224</code> et compte 32 adresses (30)
<code>/28</code> a pour masque <code>255.255.255.240</code> et compte 16 adresses (14)
<code>/29</code> a pour masque <code>255.255.255.248</code> et compte 8 adresses (6)
<code>/30</code> a pour masque <code>255.255.255.252</code> et compte 4 adresses (2)
<code>/31</code> a pour masque <code>255.255.255.254</code> et compte 2 adresses, toutes deux utilisables (RFC 3021)
<code>/32</code> a pour masque <code>255.255.255.255</code> et désigne une adresse
Les blocs spéciaux que vous rencontrez le plus

Quelques plages ont un sens fixé par des RFC. Le calculateur les reconnaît dans le champ Address class.

<code>10.0.0.0/8</code>, <code>172.16.0.0/12</code> (de 172.16.0.0 à 172.31.255.255) et <code>192.168.0.0/16</code> sont les plages privées de la RFC 1918, classées Privé
<code>100.64.0.0/10</code> est l’espace partagé du NAT opérateur (RFC 6598), classé NAT niveau opérateur. Certains services de VPN maillé s’en servent aussi : ne le prenez pas pour du privé ordinaire
<code>127.0.0.0/8</code> est la boucle locale, <code>169.254.0.0/16</code> le lien local des adresses auto-configurées. Ni l’un ni l’autre ne se route
<code>192.0.2.0/24</code>, <code>198.51.100.0/24</code> et <code>203.0.113.0/24</code> sont réservés à la documentation (RFC 5737). Il en va de même de <code>2001:db8::/32</code> en IPv6 (RFC 3849). Le calculateur classe <code>192.0.2.10</code> et <code>2001:db8::1</code> comme Réservé, d’où ses valeurs d’exemple
<code>0.0.0.0/0</code> couvre tout l’espace IPv4. C’est la route par défaut, et la règle « ouvert à tous » d’un groupe de sécurité
IPv4 et IPv6 côte à côte

Les trois outils acceptent les deux familles, avec quelques différences à connaître.

IPv4 compte 32 bits, IPv6 en compte 128. Une adresse IPv6 s’écrit en hexadécimal, par groupes de 16 bits. Le signe <code>::</code> remplace une suite de groupes nuls, une seule fois par adresse
Le calculateur affiche les adresses IPv6 en forme compressée (RFC 5952), ce qui peut différer de ce que vous avez saisi
Un <code>/64</code> est la taille habituelle d’un segment local, parce que l’adressage automatique (SLAAC) suppose un identifiant d’interface de 64 bits. Il contient 18 446 744 073 709 551 616 adresses, que l’outil affiche en entier
Il n’y a pas de broadcast en IPv6 : le champ Broadcast disparaît du résultat, et Utilisables égale Total
Le mode Masque (<code>255.255.255.0</code>) n’existe qu’en IPv4. Le mode CIDR sert pour les deux familles
L’agrégation et le test d’appartenance marchent aussi en IPv6, à condition de ne pas mêler les deux familles dans une même liste

Les trois outils, pas à pas

Calculer un sous-réseau

Le calculateur de sous-réseau recalcule pendant la saisie. Il n’y a pas de bouton à presser.

1

Saisissez l’adresse

Une IPv4 ou une IPv6, sans « / ». L’adresse n’a pas besoin d’être celle du réseau : 192.0.2.10 convient pour le bloc 192.0.2.0/24.

2

Choisissez le préfixe

Le mode CIDR attend une longueur, par exemple 24. Le mode Masque attend un masque décimal comme 255.255.255.0, réservé à l’IPv4. Pour une IPv4, des boutons /32, /31, /30, /24, /16 et /8 remplissent le champ.

3

Réglez le comptage et la vue binaire

Comptage bascule entre Utilisables et Total. L’option Binaire ajoute l’adresse, le réseau et le masque en binaire, pratique pour voir où le préfixe coupe un octet.

4

Copiez un champ ou tout le résultat

Chaque champ a son bouton Copier, et Tout copier reprend l’ensemble. La classe de l’adresse figure dans le résultat.

Agréger une liste avec Agréger CIDR

L’outil Agréger CIDR réduit une liste de blocs à son écriture minimale.

1

Collez la liste

Un CIDR par ligne, collé ou chargé depuis un fichier. Les lignes vides et les commentaires commençant par # sont ignorés, ce qui permet de coller un export annoté.

2

Choisissez Fusionner et le tri

L’interrupteur Fusionner, activé au départ, réunit les blocs qui se chevauchent et les blocs adjacents alignés. Tri propose Croissant (tri de texte) ou Aucun.

3

Lisez le résultat

Il se met à jour pendant la saisie et affiche la famille (IPv4 ou IPv6) et le nombre de blocs. Une ligne invalide s’affiche avec son numéro, et le calcul s’arrête là.

4

Copiez la liste

La liste résultante se colle telle quelle dans un groupe de sécurité, une règle de pare-feu ou un fichier de configuration.

Tester avec IP dans un sous-réseau

L’outil IP dans un sous-réseau répond par un verdict écrit.

1

Choisissez le mode

contains vérifie qu’une IP appartient à un CIDR. overlap vérifie que deux CIDR partagent au moins une adresse.

2

Remplissez les deux champs

Une IP et un CIDR en mode contains, deux CIDR en mode overlap. Les champs d’exemple (10.1.2.3 et 10.1.0.0/16) montrent le format.

3

Fixez la famille si besoin

Avec Auto, la famille se détecte seule. Forcer IPv4 ou IPv6 rejette une saisie de l’autre famille au lieu de la convertir.

4

Copiez le verdict

La phrase, par exemple « 10.0.0.0/16 et 10.0.128.0/17 se chevauchent », se colle dans un ticket ou une revue de configuration.

Ce que les outils ne font pas

Quelques limites à connaître avant de s’y fier.

Aucun paquet n’est envoyé : pas de ping, pas de résolution DNS, pas de consultation de registre d’adresses
Aucune plage réservée par un fournisseur cloud n’est retirée du nombre d’hôtes
Un bloc n’est pas découpé en sous-réseaux plus petits : un /16 contient 256 blocs /24, à énumérer vous-même ou avec cidrsubnet
L’agrégation ne lit que des CIDR avec préfixe. Une plage début-fin passe d’abord par Plage IP → CIDR
Le tri Croissant est un tri de texte, pas un tri numérique des adresses
La saisie est limitée à 64 Kio par outil

Les mêmes calculs en Python, en Node et avec Terraform

Le module ipaddress de Python

La bibliothèque standard fait tout ce que font les trois outils. Le piège classique est strict : par défaut, une adresse avec des bits d’hôte comme 192.0.2.10/24 lève une ValueError.

Exemple de base

import ipaddress # strict=False accepts host bits (192.0.2.10/24); the default strict=True raises ValueError net = ipaddress.ip_network('192.0.2.10/24', strict=False) print(net.network_address, net.broadcast_address) # 192.0.2.0 192.0.2.255 print(net.netmask, net.hostmask) # 255.255.255.0 0.0.0.255 (hostmask = wildcard) print(net.num_addresses) # 256 in total, 254 usable # Summarize: adjacent and overlapping blocks collapse, holes stay blocks = ['10.0.0.0/25', '10.0.0.128/25', '10.0.1.0/24', '10.0.2.0/24'] print(list(ipaddress.collapse_addresses(ipaddress.ip_network(b) for b in blocks))) # [IPv4Network('10.0.0.0/23'), IPv4Network('10.0.2.0/24')] # Contains and overlap print(ipaddress.ip_address('10.1.2.3') in ipaddress.ip_network('10.1.0.0/16')) # True print(ipaddress.ip_network('10.0.0.0/16').overlaps(ipaddress.ip_network('10.0.128.0/17'))) # True
La bibliothèque ipaddr.js avec Node

C’est la bibliothèque qu’utilisent les outils. Elle calcule le réseau et le broadcast d’un CIDR, et match() répond à la question « cette IP est-elle dans ce bloc ».

Exemple de base

import ipaddr from 'ipaddr.js' const cidr = '172.16.37.200/20' console.log(ipaddr.IPv4.networkAddressFromCIDR(cidr).toString()) // 172.16.32.0 console.log(ipaddr.IPv4.broadcastAddressFromCIDR(cidr).toString()) // 172.16.47.255 console.log(ipaddr.IPv4.subnetMaskFromPrefixLength(20).toString()) // 255.255.240.0 // match() is the "contains" check const ip = ipaddr.parse('10.1.2.3') console.log(ip.match(ipaddr.parseCIDR('10.1.0.0/16'))) // true console.log(ip.match(ipaddr.parseCIDR('10.2.0.0/16'))) // false
La fonction cidrsubnet de Terraform

Dans un plan Terraform, cidrsubnet découpe un bloc au lieu de recopier des CIDR à la main. Le guide Terraform traite le formatage et la validation des fichiers ; vérifiez ici le résultat de chaque découpe avant de l’appliquer.

Exemple de base

locals { vpc_cidr = "10.0.0.0/16" # cidrsubnet(prefix, newbits, netnum): 16 + 8 new bits = a /24, and netnum 2 is the third one app_subnet = cidrsubnet(local.vpc_cidr, 8, 2) # "10.0.2.0/24" db_subnet = cidrsubnet(local.vpc_cidr, 8, 3) # "10.0.3.0/24" }
Les outils réseau de FastMinify

Rien à installer et rien d’envoyé. Le calculateur de sous-réseau, l’outil Agréger CIDR et l’outil IP dans un sous-réseau couvrent le calcul, la réduction et le test d’une liste de blocs. Leurs limites tiennent en trois points : pas de plages réservées par le cloud, pas de découpage en sous-réseaux, un tri de texte. Pour voir une adresse en décimal, en binaire et en hexadécimal, utilisez le convertisseur d’adresse IP. Le hub des outils réseau regroupe l’ensemble.

Conclusion

Un CIDR est un début et une taille, et presque tout le reste en découle. Le masque, le broadcast, le nombre d’hôtes, la fusion de deux blocs et le chevauchement s’en déduisent. Le calculateur de sous-réseau donne ces valeurs pour IPv4 et IPv6. L’outil Agréger CIDR réduit une liste sans jamais combler un trou. L’outil IP dans un sous-réseau répond à deux questions, « cette adresse est-elle dans ce bloc » et « ces deux blocs se touchent-ils ». Le calcul ignore les adresses que votre fournisseur cloud réserve. Un bloc plus large que la liste d’origine est aussi un choix, pas une simplification. Contrôlez les chevauchements avant de relier deux réseaux, pas après. Le hub des outils réseau réunit les outils voisins.

Saisissez l’adresse et le préfixe dans deux champs, et lisez le réseau, le broadcast et le nombre d’hôtes avant de créer un sous-réseau
Retirez les adresses réservées par votre fournisseur cloud du nombre d’hôtes : cinq par sous-réseau chez AWS
Agrégez une liste d’autorisations avec l’outil, qui reste exact, et considérez tout bloc plus large comme une décision de sécurité
Testez le chevauchement de deux plages avant un appairage ou un VPN, y compris avec les réseaux du bureau et de Docker
Agrégez IPv4 et IPv6 séparément, et ne vous fiez pas à l’ordre du tri Croissant
Partager cet article
Partager cet article: