• 30 heures
  • Facile

Mis à jour le 24/04/2020

Le subnetting en pratique

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Maintenant que vous savez ce qu'est le subnetting, nous allons voir comment cela se fait. Faites chauffer vos méninges, cela demande du calcul ! ... Hé ne partez pas ! C'est facile, vous allez voir ! Restez, voyons ! :-°

Décimal vs binaire : un peu de pratique

Avant d'aller plus loin, il est nécessaire de connaitre un minimum le binaire. Si vous connaissez déjà, tant mieux ! Vous pouvez passer tout de suite à la sous-partie suivante !

Si vous ne connaissez pas, ne vous inquiétez pas, nous n'allons pas faire des calculs très très durs car nous sommes nuls en algèbre. :-°

Sérieusement, nous allons juste nous familiariser avec la conversion d'une adresse IP de sa notation binaire à sa notation décimale et vice versa ;)

Ça a une utilité ou c'est juste pour faire fonctionner nos neurones ?

Et bien, ça va nous préparer à faire des calculs plus intéressants dans la suite de cette 2ème partie, notamment quand nous allons personnaliser les masques de sous-réseaux, en empruntant quelques bits de la partie client de notre adresse IP (ceci est un spoiler à propos de ce qui va vous arriver ensuite :-° ).

Système décimal

Le système de numération décimale est le plus connu aujourd'hui. Oui, il s'agit bien de la fameuse suite des chiffres : 0, 1, 2, 3, 4, 5, 6, 7, 8 et 9. Ce système utilise la base 10.

Bon, ne trouvant vraiment pas quoi dire de plus sur cette technique de numération, nous allons nous contenter de citer Wikipédia pour les avantages et inconvénients de ce système (uniquement utile pour la culture hein, ce n'est pas à apprendre par cœur ;) ) :

Citation : Wikipédia

La base dix comporte quelques atouts :

  • Le compte sur les dix doigts est très intuitif

  • Elle est construite sur un nombre pair, et la division par deux est la plus courante

  • Son ordre de grandeur est satisfaisant, car il permet de réduire considérablement la longueur d'un grand nombre par rapport à une base deux, tout en conservant des tableaux d'additions et de multiplications mémorisables

  • Les normes internationales sont construites sur cette base

  • Elle est la plus courante

Cependant, la base dix n'est pas celle qui offre le meilleur bénéfice, car elle ne s'appuie pas sur un nombre ayant des propriétés avantageuses :

  • Un nombre comportant beaucoup de diviseurs (ex. : 12 ou 60) aurait eu un aspect pratique, or 10 n'en a que deux (2 et 5), et la division par cinq n'est pas la plus courante

  • Un nombre premier serait intéressant pour les mathématiques, car, dans une telle base, les nombres à virgule s'écriraient aisément sous forme de fraction irréductible, or dix n'est pas premier

  • Une puissance de deux serait adaptée à l'informatique, or dix n'est pas puissance de deux

Système binaire

Le système binaire est un système de numération, tout comme l'est le système décimal, sauf que le système binaire utilise une base de 2. Il n'y a que deux chiffres : 0 et 1.
Ces chiffres qui composent les nombres binaires sont appelés bits (combinaison des deux mots anglais BInary et digiT). Si vous vous rappelez bien, quand on a huit bits, on a un octet. ;)

Le système binaire est le système de base des calculs informatiques : votre processeur travaille sur une suite de 0 et 1, par exemple pour faire des vérifications. Si telle partie a du courant le bit vaudra 1 sinon le bit vaudra 0.
Donc, les adresses IP et les masques de sous-réseaux que nous avons vu jusqu'ici ne sont qu'une suite de 0 et 1. Et nous allons dans ce chapitre apprendre à faire la conversion d'une adresse IP écrite en binaire à une adresse IP écrite en décimal et vice versa.

C'est parti, touchons du binaire

Bon, avant tout, nous allons faire un petit rappel. Une adresse IP est une suite de 4 groupes de chiffres séparés par un point. Chaque "groupe" vaut 1 octet, soit 8 bits. Ce qui nous intéresse ici est le bit.
D'après les explications ci-dessus, un bit est un nombre qui ne peut prendre que 2 valeurs possibles : 0 ou 1. Comme nous avons 8 bits, nous allons donc représenter une adresse IP par 32 chiffres qui ne seront que des 0 et 1. En effet, chaque portion de l'adresse IP valant 8 bits, nous aurons 8 chiffres par portion. Et comme une adresse IP a 4 portions, nous aurons donc 8 * 4 chiffres, soit 32 chiffres dans la représentation binaire d'une adresse IP. ;)

Nous allons prendre une adresse simple pour commencer : 12.3.2.1.

Nous allons écrire cette adresse IP en binaire. Rappelez-vous, chaque portion (délimitée par un point) de l'adresse IP vaut 8 bits. Donc vous devez écrire 4 suites de 8 chiffres séparées par des points. Pour commencer, on va mettre tous ces chiffres à 0, pour voir pas à pas comment on procède. ;)

Nous avons donc :
0 0 0 0 0 0 0 0. 0 0 0 0 0 0 0 0. 0 0 0 0 0 0 0 0. 0 0 0 0 0 0 0 0

Voilà, nous y sommes presque. Nous avons écris 32 chiffres, donc 4 groupes de 8 chiffres.

Chacun de ces chiffres ne doit valoir que 1 ou 0. Ici nous n'avons qu'une suite de zéros, cela veut dire que sa valeur correspondante en décimal serait 0.0.0.0. Mais nous voulons représenter 12.3.2.1, alors comment faire ?

Vous aurez à la fin du chapitre un schéma qui va récapituler le processus, mais pour que vous compreniez bien le principe, nous allons faire sans schéma (torture volontaire :p ).

Dans un nombre en binaire, chaque bit, s'il vaut 1, correspond à un certain nombre en décimal. Ainsi, de la droite vers la gauche on a :

  • chiffre 1 : 1

  • chiffre 2 : 2

  • chiffre 3 : 4

  • chiffre 4 : 8

  • chiffre 5 : 16

  • chiffre 6 : 32

  • chiffre 7 : 64

  • chiffre 8 : 128

Ainsi, dans un nombre en binaire, pour avoir sa correspondance en décimal, il suffit de regarder quels bits sont allumés (toujours de la droite vers la gauche), de noter leur correspondance en décimal et de faire la somme des correspondances et hop, vous avez le nombre en décimal ! Avouez que c'est moins compliqué que ça en avait l'air tout à l'heure. :)
Pour passer d'un nombre décimal à son équivalent en binaire, il faut décomposer le nombre décimal en une somme faisant intervenir les nombres correspondants à certains bits allumés (en fonction des possibilités) et ensuite, d'allumer les bits dont les correspondances sont utilisées.

On va tout de suite prendre un exemple avec notre conversion de 12.3.2.1 en binaire.
Commençons par 12. Décomposons le à partir des correspondances données ci-dessus : 12 = 8 + 4. Il nous faut donc allumer le bit dont la correspondance vaut 8 et celui dont la correspondance vaut 4 soit le 3ème et le 4ème en allant de la droite vers la gauche. Ce qui nous donne : 0 0 0 0 1 1 0 0. Et voilà, vous venez de représenter 12 en binaire.
Faites pareil pour les 3 autres octets (ce n'est vraiment pas dur ;) ).

Ceci nous donne au final :

  • 1er octet : 00001100

  • 2ème octet : 00000011

  • 3ème octet : 00000010

  • 4ème octet : 00000001

Donc, l'adresse 12.3.2.1 en binaire c'est :
00001100 . 00000011 . 00000010 . 00000001

Voici donc le schéma récapitulatif sur un octet de la correspondance des bits :

Image utilisateur

Comment ?

Maintenant que vous maitrisez les conversions d'adresses IP du binaire au système décimal et vice versa, que vous connaissez les puissances de deux et que les yeux fermés vous pouvez dire que 2^3 = 8, que vous savez ce qu'est le subnetting, et que vous comprenez parfaitement cette notion d'économie d'adresses, nous allons voir comment subnetter, comment avoir un masque de sous-réseau personnalisé.

Le comment du pourquoi

Pour personnaliser les masques de sous-réseau, il faut emprunter des bits de la partie host (client) de notre adresse IP. Revoyons d'abord en douceur ce que sont le host ID et le network ID.
D'abord, host ID signifie identité de l'hôte et network ID signifie identité du réseau. La règle de base à retenir est : plus on "monte" dans les masques (c'est à dire qu'on passe de 255.0.0.0 à 255.255.0.0, de 255.255.0.0 à 255.255.255.0, ...), plus le network ID devient grand : il gagne un octet de plus à chaque fois, et le host ID en perd un.

Faire du subnetting, c'est subdiviser un réseau en plusieurs sous-réseaux, diminuer le nombre d'adresses IP par sous-réseau.

Avec le masque 255.0.0.0, le premier octet correspond à l'identité du réseau. Avec 255.255.0.0, ce sont les deux premiers octets, et avec 255.255.255.0, les 3 premiers. C'est l'inverse pour l'identité de l'hôte :

Masque de sous-réseau

Adresse IP

255.0.0.0

75.10.2.4

255.255.0.0

135.5.0.7

255.255.255.0

220.42.3.6

En rouge : network ID, en vert : host ID

Donc, pour subnetter un réseau en plusieurs sous-réseaux, on se sert des bits disponibles du masque de sous-réseau, c'est-à-dire ceux qui valent 0.

Il est possible de procéder de plusieurs manières pour subnetter :

  • En partant du nombre de sous-réseaux désirés ;

  • En partant du nombre d'adresses IP désirées par sous-réseau

  • En combinant les deux, c'est-à-dire en prenant en compte le nombre de sous-réseaux désirés et le nombre d'adresses IP désirées par sous-réseau

Nous ne verrons pas tout de suite cette dernière possibilité, nous allons voir seulement les 2 premières. Ces méthodes sont valables pour toutes les adresses, néanmoins nous observerons quelques particularités relatives à l'ancienne classe C qui existent toujours.

À partir du nombre de sous-réseaux désirés

Avant de prendre un exemple concret, vous devez connaitre quelques généralités. Tout d'abord, quelle que soit la classe d'adresses dans laquelle vous allez travailler, la formule est la même :
S = 2^n - 1
Dans cette formule, S est le nombre de sous-réseaux désirés. À partir de S, vous devez déterminer n, qui est un nombre entier positif, et qui correspond au nombre de bits devant être masqués.

Masqués ? Comme au bal ?

Pas vraiment... :-° Masquer signifie, en gros, le mettre à 1 pour les besoins du subnetting. Comme vous le savez normalement, le subnetting consiste en l'emprunt des bits de la partie hôte pour créer des sous-réseaux. Ce processus d'emprunt de bits est appelé masquage. Masquer un bit, c'est donc l'emprunter, l'allumer.

En fait, S ne pourra pas toujours être égal au nombre de sous-réseaux désirés, nous verrons dans les exemples comment nous allons faire dans ce cas très courant.

À quoi sert le -1 dans la formule ?

Pour répondre à cette question, nous devons voir d'abord...

Le sous-réseau (subnet) zéro et la règle sur le dernier sous-réseau

Passons rapidement sur le subnet zéro : il s'agit d'ignorer une pratique obsolète qui consiste à ne pas utiliser le premier sous-réseau car il représente l'identité du réseau. Si on ne le prenait pas en compte, on devrait retrancher encore 1 à S. Mais ce n'est pas le cas, concentrons-nous plutôt sur le dernier sous-réseau.
Par convention, l'octet de l'adresse IP définissant le sous-réseau ne peut être supérieur ou égal à l'octet modifié du masque de sous-réseau personnalisé. Par exemple, si on a un réseau 198.15.2.0 et qu'on applique aux hôtes un masque 255.255.255.192, on ne pourra pas avoir de sous-réseau ayant pour identité 198.15.2.192.

Au vu de vos têtes sceptiques (enfin, on ne voit pas mais on devine :-° ), nous allons tout de suite faire un exemple, parce que la théorie, ça ne semble pas digeste.

Exemple de subnetting

Passons tout de suite au plus intéressant. Considérons le réseau 40.0.0.0. Nous voulons le diviser en 20 sous-réseaux. Déterminons le nombre de bits à masquer pour obtenir un masque de sous-réseau personnalisé, qui devra être appliqué à tous les hôtes.

:euh: ... o_O

Ah oui, on ne peut pas obtenir exactement 20 avec la formule 2^n - 1 ! Dans ce cas, nous allons prendre une valeur un peu supérieure pour avoir au moins 20 sous-réseaux. Allons-y doucement :

  • 2^4 - 1 = 15

  • 2^5 - 1 = 31

  • On a suffisamment de réseaux en masquant 5 bits, on arrête là.

On ne peut pas mélanger les 1 et les 0, tous les 1 doivent être à gauche, et les 0 à droite. Cela veut dire le masquage se fait de la gauche vers la droite.

Nous allons donc masquer 5 bits de cette manière. Nous avons les puissances suivantes (les 8 premières puissances de 2) :
2^7 = 128
2^6 = 64
2^5 = 32
2^4 = 16
2^3 = 8
2^2 = 4
2^1 = 2
2^0 = 1

Voilà donc les 8 premières puissances de deux, par ordre décroissant. Nous allons masquer les 5 bits qu'il nous faut pour obtenir 20. Donc, nous allons additionner les valeurs des 5 premières puissances ci-dessus. Cela nous donne donc :
2^7 + 2^6 + 2 ^5 + 2^4 + 2^3 = 248.
Nous avons masqué 5 bits du 2è octet de notre masque de sous-réseau. Schématiquement, ça nous donne ceci :

255

248

0

0

ssssssss

ssssshhh

hhhhhhhh

hhhhhhhh

s = subnet ; h = host

La valeur de notre nouveau masque de sous-réseau est à présent 255.248.0.0

Si vraiment vous n'avez pas compris comment le 248 a été obtenu :

2^7 = 128
2^6 = 64
2^5 = 32
2^4 = 16
2^3 = 8

128 + 64 = 192
192 + 32 = 224
224 + 16 = 240
240 + 8 = 248

Et voilà, soyez très heureux, nous avons réussi à personnaliser un masque de sous-réseau ! ;)
Maintenant il faudrait définir les limites de chaque sous-réseau, sinon ça ne va pas être très utile. Dans le cas présent, nous en avons 31, on va vous donner les 5 premières plages et la dernière, vous allez faire le reste vous-mêmes, il faut bien que vous fassiez quelque chose ! :-°

Comment calculer les plages ?

C'est relativement simple. Pour calculer les plages, il faut retrancher le nombre calculé du nouveau masque de sous-réseau à 256. Ce nombre est 248, 256 - 248 = 8. Donc nos sous-réseaux seront séparés par un intervalle de 8.
Concrètement, reprenons le réseau que nous avions choisi à la base : 40.0.0.0.
Le premier sous-réseau est 40.0.0.0, le deuxième est 40.8.0.0, le troisième 40.16.0.0, le quatrième 40.24.0.0, etc. ;)

Pour calculer les plages, il faut savoir que la dernière adresse d'un sous-réseau donné est toujours égale à l'adresse de l'identité du prochain sous-réseau moins 1. :-° Un exemple concret ? Dans notre cas, notre premier sous-réseau est 40.0.0.0. La première adresse IP adressable (pouvant être donnée à un hôte) est donc 40.0.0.1 et la dernière... 40.7.255.254. o_O

Nous avons donc :

Ordinal

Adresse du sous-réseau

Première adresse IP d'hôte

Dernière adresse IP d'hôte

1er

40.0.0.0

40.0.0.1

40.7.255.254

2ème

40.8.0.0

40.8.0.1

40.15.255.254

3ème

40.16.0.0

40.16.0.1

40.23.255.254

4ème

40.24.0.0

40.24.0.1

40.31.255.254

5ème

40.32.0.0

40.32.0.1

40.39.255.254

...

...

...

...

Dernier

40.240.0.0

40.240.0.1

40.247.255.254

Vous êtes capables de faire le reste maintenant. :)

Si vous pouvez encore suivre, nous allons voir comment subnetter à partir du nombre d'adresses IP d'hôtes désiré. N'hésitez pas à faire une pause si vous pensez en avoir déjà beaucoup fait pour le moment.

À partir du nombre d'adresses d'hôtes désirées

Parés à affronter cette méthode ? Dans ce cas, voici une bonne et une mauvaise nouvelle. On commence par la mauvaise ? La formule et la méthode changent ! La bonne nouvelle ? Elles ne changent que très peu, et vous allez comprendre pourquoi !

Explications sur l'adresse de broadcast et l'identité du réseau

La nouvelle formule est :
S = 2^n - 2
Cette fois, S correspond au nombre d'hôtes désiré par sous-réseau. La raison du changement dans la formule est simple : on retranche une première unité pour l'identité du réseau car elle n'est pas assignable. Si l'adresse 40.16.0.0 identifie un réseau, elle ne peut pas identifier un hôte !
Une autre unité est retranchée car on ne peut pas non plus assigner l'adresse de broadcast.

Ces explications sont facilement vérifiables lorsqu'on détermine les plages d'un réseau subnetté dans l'ancienne classe C, vous aurez l'occasion de le voir. Pour le moment, voyons une application de cette méthode avec un exemple.

Un autre exemple de subnetting

Prenons le réseau 158.37.0.0. Commençons par décider du nombre d'adresses IP que l'on souhaite avoir par sous-réseau.

Considérons que nous voulons 1800 hôtes par sous-réseau. Déterminons n :

  • 2^10 - 2 = 1022

  • 2^11 - 2 = 2046

n vaut donc 11. C'est là que ça change : comme nous voulons un nombre précis d'adresses par sous-réseaux, 11 bits doivent être libres pour les hôtes ! Ce qui signifie que 11 bits doivent valoir 0. Il y a 32 bits par masque, pour connaître le nombre de bits devant valoir 1, on fait 32 - 11 = 21. Notre nouveau masque doit donc comporter 21 bits allumés, écrivons-le en binaire :
11111111 . 11111111 . 11111000 . 00000000
Ce qui nous donne en décimal 255.255.248.0. L'intervalle entre chaque sous-réseau est de 256 - 248 = 8.

Dressons maintenant le tableau des plages :

Ordinal

Adresse du sous-réseau

Première adresse IP d'hôte

Dernière adresse IP d'hôte

1er

158.37.0.0

158.37.0.1

158.37.7.254

2ème

158.37.8.0

158.37.8.1

158.37.15.254

3ème

158.37.16.0

158.37.16.1

158.37.23.254

...

...

...

...

Dernier

158.37.240.0

158.37.240.1

158.37.247.254

Voilà donc un certain nombre de sous-réseaux avec 2046 adresses d'hôtes dans chaque. On n'en voulait que 1800, mais ce n'était pas possible de les avoir précisément, donc on a pris la valeur possible immédiatement supérieure.

Faisons maintenant un autre exemple, mais cette fois, il doit y avoir moins de 254 hôtes par sous-réseau. La méthode reste la même, mais nous allons voir quelques particularités, dont une qui permet de vérifier facilement la formule de départ.

Exemple de subnetting avec moins de 254 hôtes par sous-réseau

Procédons de la même manière. Dans le réseau 203.68.5.0, nous voulons 14 hôtes par sous-réseau.
2^4 - 2 = 14 ! Super, on tombe juste sur 14 ! (Bon d'accord, c'était fait exprès pour éviter de chercher... :-° )

On a donc n = 4, il nous faut 4 bits valant zéro. Comme ici on ne va modifier que le dernier octet, on peut faire directement 8 - 4 = 4 pour connaître sa nouvelle valeur. 11110000(2) = 240(10), notre nouveau masque est donc 255.255.255.240. L'intervalle est de 256 - 240 = 16, on détermine les plages :

Ordinal

Adresse du sous-réseau

Première adresse IP d'hôte

Dernière adresse IP d'hôte

Adresse de broadcast

1er

203.68.5.0

203.68.5.1

203.68.5.14

203.68.5.15

2ème

203.68.5.16

203.68.5.17

203.68.5.30

203.68.5.31

3ème

203.68.5.32

203.68.5.33

203.68.5.46

203.68.5.47

...

...

...

...

...

Dernier

203.68.5.224

203.68.5.225

203.68.5.238

203.68.5.239

Vous remarquez probablement une différence : la dernière adresse IP d'hôte de chaque sous-réseau ne se termine pas par 254 ! De plus, vous voyez bien maintenant l'intérêt du -2 de la formule : l'adresse du réseau et celle de broadcast sont bien visibles ici.

Remarquez que le masque de sous-réseau ne peut être 255.255.255.255. En effet, dans ce cas, il n'y a que l'adresse même du sous-réseau dans chaque sous-réseau, donc aucune adresse disponible pour les hôtes ! D'ailleurs, si on prend comme masque 255.255.255.254, il n'y a qu'une adresse disponible par sous-réseau, on est donc obligé de supprimer le broadcast (ce qui n'est pas grave vu qu'il n'y a qu'un hôte).

Allez, vous avez bien travaillé, vous avez droit... à la suite ! :D

La notation du masque

Cette sous-partie ne comportera rien de fameux, nous allons juste vous fournir quelques explications sur les éventuelles notations que vous rencontrerez probablement dans le monde du réseau.

La notation "classique"

Cette notation dite "classique" est la notation "normale" d'une adresse IP. C'est en fait une notation qui couple l'adresse IP et son masque de sous-réseau associé. Par exemple, vous pourrez rencontrer une expression telle que 192.168.1.45/255.255.255.0. C'est assez évident à comprendre, n'est-ce pas ? Cela veut simplement dire qu'à l'adresse IP 192.168.1.45 est attribué un masque 255.255.255.0. C'est une notation que nous pourrons qualifier de "obsolète" car elle a laissé sa place à...

La notation avec un slash ( / )

Cette notation suit le même modèle que la notation classique. C'est à dire, que c'est un couplage de l'adresse IP d'un hôte à son masque de sous-réseau. Mais le point particulier ici, c'est qu'au lieu de donner l'expression "brute" du masque de sous-réseau dans la notation, on se contente de spécifier le nombre de bits masqués pour obtenir ce masque. La notation précédente en notation avec un slash devient 192.168.1.45/24.
Cela veut dire que l'adresse IP 192.168.1.45 est associée à un masque ayant 24 bits de masqués.
La notation avec un slash semble devenir la plus courante et la plus utilisée aujourd'hui notamment avec le succès du CIDR (Classless Inter Domain Routing) que nous allons aborder très bientôt. En fait, la notation avec un slash n'est rien d'autre que ce qu'on appelle officiellement la notation CIDR. ;)

Voila, vous savez tout sur les notations que vous pouvez rencontrer. Il va sans dire que vous préférerez sûrement utiliser la notation avec un slash. C'est plus pratique : on peut se contenter d'écrire 130.14.56.3/16 par exemple au lieu de 130.14.56.2/255.255.0.0. ;)

Reposez-vous avant de passer au chapitre suivant. Car vous allez encore faire des calculs, d'un autre genre cette fois ! ;)

Exemple de certificat de réussite
Exemple de certificat de réussite