Vraag Hoe werkt IPv4-subnetwerken?


Dit is een Canonical Question over IPv4-subnetten.

Verwant:

Hoe werkt Subnetting en hoe doe je dat met de hand of in je hoofd?  Kan iemand het zowel conceptueel als met verschillende voorbeelden uitleggen? Serverfout krijgt veel huiswerkvragen voor subnetwerken, dus we kunnen een antwoord gebruiken om ze te wijzen op Serverfout zelf.

  • Als ik een netwerk heb, hoe kom ik erachter uit hoe je het opsplitst?
  • Als ik een netmasker krijg, hoe kan ik dat weet waar het netwerkbereik voor is het?
  • Soms is er een schuine streep gevolgd bij een cijfer, wat is dat getal?
  • Soms is er een subnetmasker, maar ook een jokermasker, ze lijken hetzelfde, maar ze zijn anders?
  • Heeft iemand iets gezegd over het kennen van binary hiervoor?

422
2017-08-04 15:51


oorsprong




antwoorden:


IP-subnetten bestaan ​​om routers toe te staan ​​om de juiste bestemmingen voor pakketten te kiezen. U kunt IP-subnetten gebruiken om grotere netwerken op te splitsen om logische redenen (firewalling, enz.) Of fysieke behoefte (kleinere broadcastdomeinen, enz.).

Simpel gezegd, IP-routers gebruiken uw IP-subnetten om routeringsbeslissingen te nemen. Begrijp hoe deze beslissingen werken en u kunt begrijpen hoe u IP-subnetten plant.

Tellen tot 1

Als je al vloeiend binaire (basis 2) notatie hebt, kun je dit gedeelte overslaan.

Voor degenen onder u die over zijn: schaam je omdat je niet vloeiend bent in binaire notatie!

Ja, dat is misschien een beetje hard. Het is echt, heel gemakkelijk om te leren tellen in binair, en om snelkoppelingen te leren om binair naar decimaal en terug te converteren. Je zou echt moeten weten hoe je het moet doen.

Tellen in binaire getallen is zo eenvoudig omdat je alleen hoeft te weten hoe je tot 1 kunt tellen!

Denk aan de "kilometerteller" van een auto, behalve dat in tegenstelling tot een traditionele kilometerteller elk cijfer slechts tot 1 vanaf 0 kan tellen. Als de auto vers is uit de fabriek, luidt de kilometerteller "00000000".

Wanneer u uw eerste kilometer heeft gereden, luidt de kilometerstand "00000001". Tot nu toe, zo goed.

Wanneer u uw tweede mijl hebt gereden, rolt het eerste cijfer van de kilometerteller terug naar "0" (aangezien de maximale waarde "1" is) en het tweede cijfer van de teller overgaat naar "1", waardoor de teller wordt gelezen " 00000010" . Dit lijkt op het getal 10 in decimale notatie, maar het is eigenlijk 2 (het aantal mijlen dat je tot nu toe hebt gereden) in binaire notatie.

Als je de derde kilometer hebt gereden, luidt de kilometerstand "00000011", omdat het eerste cijfer van de kilometerteller weer verandert. Het getal "11", in binaire notatie, is hetzelfde als het decimale getal 3.

Eindelijk, als je je vierde mijl hebt gereden, gaan beide cijfers (die aan het eind van de derde mijl "1" waren) terug naar de nulpositie en rolt het derde cijfer naar de "1" positie, en geeft ons " 00000100" . Dat is de binaire weergave van het decimale getal 4.

Je kunt dat allemaal onthouden als je wilt, maar je moet het echt alleen maar begrijpen hoe de kleine kilometerteller "rolt" terwijl het aantal dat wordt geteld groter wordt. Het is precies hetzelfde als een traditionele decimale kilometerteller, behalve dat elk cijfer alleen "0" of "1" kan zijn op onze fictieve "binaire kilometerteller".

Om een ​​decimaal getal in binair getal om te zetten, kunt u de kilometerteller naar voren rollen, aanvinken, hardop tellen totdat u het een aantal keren hebt gegooid gelijk aan het decimale getal dat u naar het binaire getal wilt converteren. Wat er ook op de kilometerteller wordt weergegeven, na al dat couten en rollen is de binaire weergave van het decimale getal dat u hebt geteld.

Aangezien u begrijpt hoe de kilometerteller naar voren rolt, begrijpt u ook hoe deze achteruit rolt. Om een ​​binair getal op de kilometerteller terug naar decimaal te converteren, kunt u de kilometerteller een voor een achteruit laten rollen, totdat de kilometerteller "00000000" aangeeft. Als al dat tellen en rollen gedaan is, is het laatste getal dat u hardop zegt de decimale weergave van het binaire getal waarmee de kilometerteller is begonnen.

Het converteren van waarden tussen binair en decimaal zou zo zijn heel vervelend. Je zou het kunnen doen, maar het zou niet erg efficiënt zijn. Het is gemakkelijker om een ​​klein algoritme te leren om het sneller te doen.

Even terzijde: elk cijfer in een binair nummer staat bekend als een "bit". Dat is "b" van "binary" en "it" van "digit". Een bit is een binair cijfer.

Het converteren van een binair getal zoals bijvoorbeeld "1101011" naar decimaal is een eenvoudig proces met een handig klein algoritme.

Begin met het tellen van het aantal bits in het binaire getal. In dit geval zijn er 7. Maak 7 delingen op een vel papier (in je hoofd, in een tekstbestand, enz.) En begin ze van rechts naar links in te vullen. Voer in het meest rechtse vak het cijfer "1" in, omdat we altijd met "1" beginnen. Voer in het volgende vakje links de waarde in de sleuf naar rechts dubbel in (dus "2" in de volgende, "4" in de volgende) en ga door totdat alle slots vol zijn. (Uiteindelijk zul je deze getallen, de machten van 2, uit het hoofd leren, terwijl je dit steeds vaker doet. Ik heb wel 131.072 in mijn hoofd, maar ik heb daarna meestal een rekenmachine of papier nodig).

Dus je zou het volgende op je papier moeten hebben in je kleine slots.

 64    |    32    |    16    |    8    |    4    |    2    |    1    |

Transcriberen van de bits van het binaire getal onder de slots, zoals zo:

 64    |    32    |    16    |    8    |    4    |    2    |    1    |
  1          1          0         1         0         1         1

Voeg nu enkele symbolen toe en bereken het antwoord op het probleem:

 64    |    32    |    16    |    8    |    4    |    2    |    1    |
x 1        x 1        x 0       x 1       x 0       x 1       x 1
---        ---        ---       ---       ---       ---       ---
       +          +          +         +         +         +         =

Als je alle wiskunde doet, zou je moeten komen met:

 64    |    32    |    16    |    8    |    4    |    2    |    1    |
x 1        x 1        x 0       x 1       x 0       x 1       x 1
---        ---        ---       ---       ---       ---       ---
 64    +    32    +     0    +    8    +    0    +    2    +    1    =   107

Dat is het. "1101011" in decimaal is 107. Het zijn slechts eenvoudige stappen en eenvoudige wiskunde.

Decimaal converteren naar binair is net zo gemakkelijk en is hetzelfde basisalgoritme, uitgevoerd in omgekeerde volgorde.

Stel dat we het getal 218 naar binair willen converteren. Begin aan de rechterkant van een vel papier en schrijf het nummer "1" in. Naar links, verdubbel die waarde (dus "2") en ga verder naar links van het papier en verdubbel de laatste waarde. Als het aantal dat u gaat schrijven groter is dan het aantal dat wordt geconverteerd, stopt u met schrijven. ga anders door met het verdubbelen van het vorige nummer en schrijven. (Het omzetten van een groot getal, zoals 34.157.216.092, in binair met dit algoritme kan een beetje vervelend zijn, maar het is zeker mogelijk.)

Dus je zou op je papier moeten hebben:

 128    |    64    |    32    |    16    |    8    |    4    |    2    |    1    |

U bent gestopt met het schrijven van getallen bij 128 omdat verdubbeling 128, wat u 256 zou geven, groot zou zijn dan het getal dat wordt geconverteerd (218).

Beginnend vanaf het meest linkse cijfer, schrijf "218" erboven (128) en vraag jezelf af: "Is 218 groter dan of gelijk aan 128?" Als het antwoord ja is, kras dan een "1" onder "128". Zet boven "64" het resultaat van 218 minus 128 (90).

Kijk naar "64" en vraag jezelf af: "Is 90 groter dan of gelijk aan 64?" Dat is zo, dus je zou een "1" onder "64" schrijven, dan 64 aftrekken van 90 en dat schrijven boven "32" (26).

Wanneer je echter bij "32" komt, merk je dat 32 niet groter is dan of gelijk is aan 26. Schrijf in dit geval een "0" onder "32", kopieer het nummer (26) van boven de 32 "naar boven" 16 "en stel jezelf vervolgens dezelfde vraag met de rest van de cijfers.

Als je klaar bent, moet je:

 218         90         26         26        10         2         2         0
 128    |    64    |    32    |    16    |    8    |    4    |    2    |    1    |
   1          1          0          1         1         0         1         0

De cijfers bovenaan zijn slechts biljetten die worden gebruikt bij de berekening en betekenen niet veel voor ons. Aan de onderkant zie je echter een binair nummer "11011010". Inderdaad, 218, geconverteerd naar binair, is "11011010".

Na deze zeer eenvoudige procedures kunt u binair naar decimaal en weer terug zonder rekenmachine. De wiskunde is allemaal heel eenvoudig en de regels kunnen worden opgeslagen met slechts een beetje oefening.

Adressen opsplitsen

Denk aan IP-routering zoals pizzabezorging.

Wanneer je wordt gevraagd om een ​​pizza te bezorgen in "123 Main Street", is het voor jou als mens heel duidelijk dat je naar het gebouw met nummer "123" in de straat genaamd "Main Street" wilt gaan. Het is gemakkelijk om te weten dat je naar het 100-blok van Main Street moet gaan omdat het bouwnummer tussen 100 en 199 ligt en de meeste stadsblokken zijn genummerd in honderden. Je "weet" gewoon hoe je het adres opsplitst.

Routers leveren pakketten, geen pizza. Hun taak is hetzelfde als een pizzabestuurder: om de lading (pakketten) zo dicht mogelijk bij de bestemming te krijgen. Een router is verbonden met twee of meer IP-subnetten (alleszins nuttig). Een router moet IP-adressen van bestemmingen van pakketten onderzoeken en die bestemmingsadressen doorbreken in hun componenten "straatnaam" en "gebouwnummer", net als de pizzabestuurder, om beslissingen te nemen over levering.

Elke computer (of "host") op een IP-netwerk is geconfigureerd met een uniek IP-adres en subnetmasker. Dat IP-adres kan worden opgedeeld in een "gebouwnummer" -onderdeel (zoals "123" in het bovenstaande voorbeeld), het "host-ID" en een "straatnaam" -onderdeel (zoals "hoofdstraat" in het bovenstaande voorbeeld) genaamd de "netwerk identificatie". Voor onze menselijke ogen is het gemakkelijk om te zien waar het gebouwnummer en de straatnaam zich in "123 Main Street" bevinden, maar moeilijker om die indeling te zien in "10.13.216.41 met een subnetmasker van 255.255.192.0".

IP-routers "weten gewoon" hoe IP-adressen in deze componenten moeten worden opgesplitst om routeringsbeslissingen te nemen. Omdat we begrijpen hoe IP-pakketten worden gerouteerd, is het van belang dat we weten hoe we dit IP-adres kunnen verbreken. Gelukkig is het uitpakken van de host-ID en de netwerk-ID uit een IP-adres en subnetmasker eigenlijk vrij eenvoudig.

Begin met het uitschrijven van het IP-adres in het binaire bestand (gebruik een rekenmachine als je dit nog niet in je hoofd hebt geleerd, maar maak een notitie om te leren hoe het moet - het is echt heel gemakkelijk en maakt indruk op het andere geslacht op partijen):

      10.      13.     216.      41
00001010.00001101.11011000.00101001

Schrijf ook het subnetmasker in binair:

     255.     255.     192.       0
11111111.11111111.11000000.00000000

Geschreven naast elkaar kunt u zien dat het punt in het subnetmasker waar de "1-en" -stopregel zich naar een punt in het IP-adres uitstrekt. Dat is het punt dat de netwerk-ID en de host-ID splitsen. Dus in dit geval:

      10.      13.     216.      41
00001010.00001101.11011000.00101001 - IP address
11111111.11111111.11000000.00000000 - subnet mask
00001010.00001101.11000000.00000000 - Portion of IP address covered by 1's in subnet mask, remaining bits set to 0
00000000.00000000.00011000.00101001 - Portion of IP address covered by 0's in subnet mask, remaining bits set to 0

Routers gebruiken het subnetmasker om de bits bedekt door 1's in het IP-adres te "maskeren" (waarbij de bits die niet zijn "gemaskeerd" met 0's worden vervangen) om de netwerk-ID te extraheren:

      10.      13.     192.       0
00001010.00001101.11000000.00000000 - Network ID

Op dezelfde manier kan een router de host-ID extraheren door het subnetmasker te gebruiken om de bits die worden bedekt door nullen in het IP-adres te 'maskeren' (de bits die niet opnieuw worden 'gemaskeerd' door 0's):

       0.       0.      24.      41
00000000.00000000.00011000.00101001 - Portion of IP address covered by 0's in subnet mask, remaining bits set to 0

Het is niet zo eenvoudig voor onze menselijke ogen om de "onderbreking" te zien tussen de netwerk-ID en de host-ID als het is tussen het "bouwnummer" en de "straatnaam" in fysieke adressen tijdens de pizza-bezorging, maar het uiteindelijke effect is de dezelfde.

Nu u IP-adressen en subnetmaskers kunt opsplitsen in host-ID's en netwerk-ID's, kunt u IP-routes routeren zoals een router dat doet.

Meer terminologie

Je zult subnetmaskers zien geschreven op internet en in de rest van dit antwoord als (IP / nummer). Deze notatie staat bekend als "Classless Inter-Domain Routing" (CIDR) -notatie. "255.255.255.0" bestaat in het begin uit 24 bits van enen, en het is sneller om dat als "/ 24" te schrijven dan als "255.255.255.0". Als u een CIDR-nummer (zoals "/ 16") wilt converteren naar een subnetmasker met punten en decimalen, schrijft u dat aantal 1's op, deelt u het in groepen van 8 bits en converteert u het naar decimalen. (A "/ 16" is bijvoorbeeld "255.255.0.0")

Terug in de "oude dagen" werden subnetmaskers niet gespecificeerd, maar eerder afgeleid door te kijken naar bepaalde delen van het IP-adres. Een IP-adres dat begint met 0 - 127, bijvoorbeeld, had een impliciet subnetmasker van 255.0.0.0 (een "klasse A" IP-adres genoemd).

Deze impliciete subnetmaskers worden vandaag niet gebruikt en ik raad het af om er meer over te leren tenzij je de pech hebt gehad om te gaan met heel oude apparatuur of oude protocollen (zoals RIPv1) die geen klasseloze IP-adressering ondersteunen. Ik ga deze "klassen" van adressen niet verder noemen omdat het vandaag niet van toepassing is en verwarrend kan zijn.

Sommige apparaten gebruiken een notatie die "wildcard-maskers" wordt genoemd. Een "wildcardmasker" is niets meer dan een subnetmasker met alle 0's waar er enen zijn, en 1's waar 0's zouden zijn. Het "wildcard-masker" van a / 26 is:

 11111111.11111111.11111111.11000000 - /26 subnet mask
 00000000.00000000.00000000.00111111 - /26 "wildcard mask"

Meestal ziet u "jokertekens" die worden gebruikt om overeen te komen met host-ID's in toegangscontrolelijsten of firewallregels. We zullen ze hier verder niet bespreken.

Hoe een router werkt

Zoals ik eerder heb gezegd, hebben IP-routers een vergelijkbare functie als een pizzabezorger in die zin dat ze hun lading (pakketten) naar hun bestemming moeten krijgen. Wanneer een IP-router wordt aangeboden met een pakket voor adres 192.168.10.2, moet een IP-router bepalen welke van zijn netwerkinterfaces het beste dat pakket dichter bij zijn bestemming kan brengen.

Laten we zeggen dat u een IP-router bent en dat u interfaces hebt die met u zijn genummerd:

  • Ethernet0 - 192.168.20.1, subnetmasker / 24
  • Ethernet1 - 192.168.10.1, subnetmasker / 24

Als u een pakket ontvangt om af te leveren met een bestemmingsadres van "192.168.10.2", is het vrij eenvoudig om te zeggen (met uw menselijke ogen) dat het pakket de interface Ethernet1 moet worden verzonden, omdat het Ethernet1-interfaceadres overeenkomt met de pakketbestemming adres. Alle computers die zijn aangesloten op de Ethernet1-interface hebben IP-adressen die beginnen met "192.168.10.", Omdat de netwerk-ID van het IP-adres dat aan uw interface Ethernet1 is toegewezen, "192.168.10.0" is.

Voor een router wordt dit routekeuze-proces uitgevoerd door een routeringstabel te bouwen en de tabel te raadplegen telkens wanneer een pakket moet worden afgeleverd. Een routeringstabel bevat netwerk-ID- en bestemmingsinterfacenamen. U weet al hoe u een netwerk-ID kunt verkrijgen van een IP-adres en subnetmasker, zodat u op weg bent om een ​​routeringstabel te maken. Dit is onze routeringstabel voor deze router:

  • Netwerk-ID: 192.168.20.0 (11000000.10101000.00010100.00000000) - 24-bits subnetmasker - Interface Ethernet0
  • Netwerk-ID: 192.168.10.0 (11000000.10101000.00001010.00000000) - 24-bits subnetmasker - Interface Ethernet1

Voor ons inkomende pakket gebonden aan "192.168.10.2", hoeven we alleen het adres van dat pakket naar binair te converteren (als mens - de router krijgt het in eerste instantie als binair van de draad) en probeert het aan te passen aan elk adres in onze routing tabel (tot het aantal bits in het subnetmasker) totdat we een item matchen.

  • Inkomende pakketbestemming: 11000000.10101000.00001010.00000010

Vergelijk dat met de vermeldingen in onze routeringstabel:

11000000.10101000.00001010.00000010 - Destination address for packet
11000000.10101000.00010100.00000000 - Interface Ethernet0
!!!!!!!!.!!!!!!!!.!!!????!.xxxxxxxx - ! indicates matched digits, ? indicates no match, x indicates not checked (beyond subnet mask)

11000000.10101000.00001010.00000010 - Destination address for packet
11000000.10101000.00001010.00000000 - Interface Ethernet1, 24 bit subnet mask
!!!!!!!!.!!!!!!!!.!!!!!!!!.xxxxxxxx - ! indicates matched digits, ? indicates no match, x indicates not checked (beyond subnet mask)

De invoer voor Ethernet0 komt overeen met de eerste 19 bits boete, maar stopt dan met matchen. Dat betekent dat het niet de juiste bestemmingsinterface is. U kunt zien dat de interface Ethernet1 overeenkomt met 24 bits van het bestemmingsadres. Ah, ha! Het pakket is gebonden voor interface Ethernet1.

In een echte router wordt de routeringstabel op een dusdanige manier gesorteerd dat de langste subnetmaskers eerst op wedstrijden worden gecontroleerd (dwz de meest specifieke routes) en numeriek zodat zodra een overeenkomst wordt gevonden, het pakket kan worden gerouteerd en er zijn geen verdere koppelingspogingen nodig (wat betekent dat 192.168.10.0 als eerste zou worden vermeld en 192.168.20.0 nooit zou zijn gecontroleerd). Hier vereenvoudigen we dat een beetje. Mooie datastructuren en algoritmen zorgen voor snellere IP-routers, maar eenvoudige algoritmen zullen dezelfde resultaten opleveren.

Statische routes

Tot nu toe hebben we het gehad over onze hypothetische router met netwerken die er rechtstreeks mee verbonden zijn. Dat is natuurlijk niet hoe de wereld echt werkt. In de pizza-rijdende analogie, is de chauffeur soms niet verder in het gebouw toegelaten dan de receptie en moet hij de pizza aan iemand anders afgeven voor levering aan de uiteindelijke ontvanger (schort je ongeloof op en verdraag me terwijl Ik streef mijn analogie uit, alstublieft).

Laten we beginnen met het aanroepen van onze router uit de eerdere voorbeelden "Router A". U kent de routingtabel van RouterA al als:

  • Netwerk-ID: 192.168.20.0 (11000000.10101000.00010100.00000000) - subnetmasker / 24 - Interface RouterA-Ethernet0
  • Netwerk-ID: 192.168.10.0 (11000000.10101000.00001010.00000000) - subnetmasker / 24 - Interface RouterA-Ethernet1

Stel dat er een andere router is, "Router B", met de IP-adressen 192.168.10.254/24 en 192.168.30.1/24 toegewezen aan de Ethernet0- en Ethernet1-interfaces. Het heeft de volgende routeringstabel:

  • Netwerk-ID: 192.168.10.0 (11000000.10101000.00001010.00000000) - subnetmasker / 24 - Interface RouterB-Ethernet0
  • Netwerk-ID: 192.168.30.0 (11000000.10101000.00011110.00000000) - subnetmasker / 24 - Interface RouterB-Ethernet1

In mooie ASCII-kunst ziet het netwerk er als volgt uit:

               Interface                      Interface
               Ethernet1                      Ethernet1
               192.168.10.1/24                192.168.30.254/24
     __________  V                  __________  V
    |          | V                 |          | V
----| ROUTER A |------- /// -------| ROUTER B |----
  ^ |__________|                 ^ |__________|
  ^                              ^
Interface                      Interface
Ethernet0                      Ethernet0
192.168.20.1/24                192.168.10.254/24

Je ziet dat Router B weet hoe je een netwerk kunt "bereiken", 192.168.30.0/24, waar Router A niets vanaf weet.

Stel dat een pc met het IP-adres 192.168.20.13 verbonden met het netwerk verbonden met de Ethernet0-interface van router A een pakket verzendt naar router A voor bezorging. Ons hypothetisch pakket is bestemd voor het IP-adres 192.168.30.46, een apparaat dat is aangesloten op het netwerk dat is verbonden met de Ethernet1-interface van router B.

Met de bovenstaande routeringstabel komt geen van beide de routeringstabel Router A overeen met de bestemming 192.168.30.46, dus zal router A het pakket terugsturen naar de verzendende pc met het bericht "Bestemmingsnetwerk onbereikbaar".

Om Router A "bewust" te maken van het bestaan ​​van het 192.168.30.0/24 netwerk, voegen we de volgende invoer toe aan de routeringstabel op Router A:

  • Netwerk-ID: 192.168.30.0 (11000000.10101000.00011110.00000000) - subnetmasker / 24 - toegankelijk via 192.168.10.254

Op deze manier heeft router A een routeringstabel die overeenkomt met de 192.168.30.46-bestemming van ons voorbeeldpakket. Deze routeringstabel vermeldt effectief: "Als je een pakket krijgt voor 192.168.30.0/24, stuur het dan op naar 192.168.10.254 omdat hij weet hoe ermee om te gaan." Dit is de analoge "hand-off de pizza bij de receptie" actie die ik eerder heb genoemd - het pakket doorgeven aan iemand anders die weet hoe het dichter bij zijn bestemming te krijgen.

Het toevoegen van een invoer aan een routeringstabel "met de hand" staat bekend als het toevoegen van een "statische route".

Als router B pakketten wil verzenden naar het 192.168.20.0 subnetmasker 255.255.255.0 netwerk, heeft het ook een vermelding in zijn routeringstabel nodig:

  • Netwerk-ID: 192.168.20.0 (11000000.10101000.00010100.00000000) - subnetmasker / 24 - Toegankelijk via: 192.168.10.1 (IP-adres van router A in het 192.168.10.0-netwerk)

Dit zou een pad creëren voor levering tussen het 192.168.30.0/24 netwerk en het 192.168.20.0/24 netwerk over het 192.168.10.0/24 netwerk tussen deze routers.

U wilt er altijd zeker van zijn dat routers aan beide kanten van zo'n "interstitial network" een routeringstabel hebben voor het "verre" netwerk. Als router B in ons voorbeeld geen routeringstabel-invoer voor "veraf" -netwerk 192.168.20.0/24 gekoppeld aan router A bevatte, is ons hypothetisch pakket vanaf de pc 192.168.20.13 zou Ga naar het bestemmingsapparaat op 192.168.30.46, maar elk antwoord dat 192.168.30.46 probeerde terug te sturen, zou door router B als "Bestemmingsnetwerk onbereikbaar" worden geretourneerd. Eenrichtingsverkeer is over het algemeen niet wenselijk. Zorg er altijd voor dat u nadenkt over het binnenstromende verkeer beide aanwijzingen wanneer u denkt over communicatie in computernetwerken.

Je kunt veel kilometers uit statische routes halen. Dynamische routingprotocollen zoals EIGRP, RIP, enz., Zijn eigenlijk niets meer dan een manier voor routers om routeringsinformatie tussen elkaar uit te wisselen, die in feite kan worden geconfigureerd met statische routes. Een groot voordeel van het gebruik van dynamische routeringsprotocollen over statische routes is echter dat dynamische routeringsprotocollen dat wel kunnen dynamisch verander de routeringstabel op basis van netwerkomstandigheden (gebruik van bandbreedte, een interface "down", enz.) en als zodanig kan het gebruik van een dynamisch routeringsprotocol leiden tot een configuratie die storingen of knelpunten in de netwerkinfrastructuur "rondleidt". (Dynamische routingprotocollen zijn MANIER buiten de reikwijdte van dit antwoord.)

Je kunt daar vanaf hier niet komen

In het geval van ons voorbeeld Router A, wat gebeurt er als een pakket voor "172.16.31.92" binnenkomt?

Kijken naar de router Een routeringstabel, geen bestemmingsinterface of statische route komt overeen met de eerste 24 bits van 172.18.31.92 (dat is 10101100.00010000.00011111.01011100, BTW).

Zoals we al weten, zal Router A het pakket terugsturen naar de afzender via een bericht "Bestemmingsnetwerk niet bereikbaar".

Stel dat er een andere router (router C) op het adres "192.168.20.254" zit. Router C heeft een verbinding met internet!

                              Interface                      Interface                      Interface
                              Ethernet1                      Ethernet1                      Ethernet1
                              192.168.20.254/24              192.168.10.1/24                192.168.30.254/24
                    __________  V                  __________  V                  __________  V
((  heap o  ))     |          | V                 |          | V                 |          | V
(( internet )) ----| ROUTER C |------- /// -------| ROUTER A |------- /// -------| ROUTER B |----
((   w00t!  ))   ^ |__________|                 ^ |__________|                 ^ |__________|
                 ^                              ^                              ^
               Interface                      Interface                      Interface
               Ethernet0                      Ethernet0                      Ethernet0
               10.35.1.1/30                   192.168.20.1/24                192.168.10.254/24

Het zou mooi zijn als Router A pakketten die niet overeenkomen met een lokale interface tot Router C kan routeren, zodat router C ze naar internet kan sturen. Voer de "default gateway" -route in.

Voeg als volgt een regel aan het einde van onze routeringstabel toe:

  • Netwerk-ID: 0.0.0.0 (00000000.00000000.00000000.00000000) - subnetmasker / 0 - Bestemmingsrouter: 192.168.20.254

Wanneer we proberen '172.16.31.92' aan te passen aan elk item in de routeringstabel, raken we uiteindelijk dit nieuwe item. Het is aanvankelijk een beetje verwarrend. We willen nul bits van het bestemmingsadres matchen met ... wachten ... wat? Overeenkomende nul bits? Dus we zoeken helemaal geen match. Deze routeringstabel geeft in feite aan: "Als u hier aankomt, in plaats van op te geven bij aflevering, stuurt u het pakket naar de router op 192.168.20.254 en laat u het verwerken".

192.168.20.254 is een bestemming voor ons DO weet hoe je een pakket moet bezorgen. Wanneer we geconfronteerd worden met een pakket dat is gebonden aan een bestemming waarvoor we geen specifieke routeringstabel hebben, zal deze "default gateway" -vermelding altijd overeenkomen (aangezien het overeenkomt met nul bits van het bestemmingsadres) en ons een "laatste redmiddel" -plaats geeft die we kunnen verzend pakketten voor bezorging. U hoort soms de standaardgateway die de 'gateway of last resort' wordt genoemd.

Om ervoor te zorgen dat een standaard gateway-route effectief is, moet deze verwijzen naar een router die bereikbaar is via de andere vermeldingen in de routeringstabel. Als u bijvoorbeeld in router A een standaardgateway van 192.168.50.254 probeert op te geven, mislukt de levering aan een dergelijke standaardgateway. 192.168.50.254 is geen adres dat Router A weet hoe pakketten moeten worden afgeleverd aan het gebruik van een van de andere routes in de routeringstabel, dus een dergelijk adres zou niet werken als een standaardgateway. Dit kan beknopt worden gezegd: de standaardgateway moet worden ingesteld op een adres dat al bereikbaar is door een andere route in de routeringstabel te gebruiken.

Echte routers slaan de standaardgateway meestal op als de laatste route in hun routeringstabel, zodat deze overeenkomt met pakketten nadat ze niet alle andere items in de tabel hebben kunnen evenaren.

Stedenbouw en IP-routering

Het opsplitsen van een IP-subnet in kleinere IP-subnetten is een stedenbouwkundige planning. In stadsplanning wordt zonering gebruikt om zich aan te passen aan natuurlijke kenmerken van het landschap (rivieren, meren, enz.), Om de verkeersstromen tussen verschillende delen van de stad te beïnvloeden, en om verschillende soorten landgebruik (industrieel, residentieel, enz.) Te scheiden . IP-subnetwerken is eigenlijk hetzelfde.

Er zijn drie belangrijke redenen waarom u een netwerk zou subnetten:

  • Misschien wil je communiceren met verschillende ongelijke communicatiemedia. Als u een T1 WAN-verbinding hebt tussen twee gebouwen, kunnen IP-routers aan de uiteinden van deze verbindingen worden geplaatst om de communicatie over de T1 te vergemakkelijken. De netwerken aan elk uiteinde (en mogelijk het "interstitiële" netwerk op de T1 zelf) zouden worden toegewezen aan unieke IP-subnetten zodat de routers beslissingen kunnen nemen over welk verkeer over de T1-lijn moet worden verzonden.

  • In een Ethernet-netwerk kunt u subnetten gebruiken om de hoeveelheid broadcast-verkeer in een bepaald gedeelte van het netwerk te beperken. Applicatielaagprotocollen gebruiken de uitzendmogelijkheden van Ethernet voor zeer nuttige doeleinden. Naarmate er meer en meer hosts in hetzelfde Ethernet-netwerk zijn ingepakt, kan het percentage broadcast-verkeer op de draad (of in de ether, in draadloos Ethernet) echter zodanig toenemen dat er problemen ontstaan ​​voor de levering van niet-broadcast-verkeer. (Vroeger kon broadcast-verkeer de CPU van hosts overrompelen door hen te dwingen elk broadcast-pakket te bekijken. Dat is tegenwoordig minder waarschijnlijk.) Overmatig verkeer op switched Ethernet kan ook voorkomen in de vorm van "flooding van frames naar onbekende bestemmingen". Deze voorwaarde wordt veroorzaakt doordat een Ethernet-switch niet elke bestemming op het netwerk kan bijhouden en daarom de geschakelde Ethernet-netwerken niet kunnen schalen naar een oneindig aantal hosts. Het effect van flooding van frames op onbekende bestemmingen is vergelijkbaar met het effect van overmatig broadcastverkeer, met het doel van subnetting.

  • Misschien wilt u de soorten verkeer tussen verschillende groepen hosts 'controleren'. Misschien hebt u printerserver-apparaten en wilt u alleen geautoriseerde wachtwachtende servercomputers om taken naar hen te verzenden. Door het aantal toegestane verkeer naar het subnet van de afdrukserver te beperken, kunnen gebruikers hun pc niet configureren om rechtstreeks met de afdrukserverapparaten te praten om de afdrukaccounting te omzeilen. U kunt de printerserverapparaten allemaal in zichzelf in een subnet plaatsen en een regel maken in de router of firewall die aan dat subnet is gekoppeld om de lijst met hosts te beheren die toestemming hebben om verkeer naar de printerserverapparaten te verzenden. (Zowel routers als firewalls kunnen doorgaans beslissingen nemen over hoe of een pakket moet worden afgeleverd op basis van de bron- en bestemmingsadressen van het pakket.) Firewalls zijn meestal een ondersoort van een router met een obsessieve persoonlijkheid.Ze kunnen zeer, zeer bezorgd zijn over de payload van pakketten, terwijl routers meestal payloads negeren en alleen de pakketten leveren.)

Bij het plannen van een stad kun je plannen hoe straten elkaar kruisen en kun je alleen-draaiende, one-way en dead-end straten gebruiken om de verkeersstromen te beïnvloeden. Misschien wilt u dat Main Street 30 blokken lang is, met elk blok met maximaal 99 gebouwen elk. Het is vrij eenvoudig om uw straatnummer zodanig te plannen dat elk blok in Main Street een reeks straatnummers heeft die met 100 toenemen voor elk blok. Het is heel gemakkelijk om te weten wat het "startnummer" in elk volgend blok zou moeten zijn.

Bij de planning van IP-subnetten gaat het om het bouwen van het juiste aantal subnetten (straten) met het juiste aantal beschikbare host-ID's (bouwnummers) en het gebruik van routers om de subnetten met elkaar te verbinden (kruispunten). Regels over toegestane bron- en doeladressen die in de routers zijn opgegeven, kunnen de verkeersstroom verder regelen. Firewalls kunnen zich gedragen als obsessieve verkeersagenten.

Voor de toepassing van dit antwoord is het samenstellen van onze subnetten onze enige grote zorg. In plaats van in decimaal te werken, zoals je zou doen met stadsplanning, werk je in binary om de grenzen van elk subnet te beschrijven.

Vervolg op: Hoe werkt IPv4-subnetwerken?

(Ja ... we hebben de maximale grootte van een antwoord bereikt (30000 tekens).)


631
2017-08-04 15:58



@ Josephph: Het is een lezing die ik te vaak heb afgeleverd voor mijn eigen bestwil. > smile <Ik zal naar je binaire gedeelte kijken. Ik vind het vervelend om te leren over wiskunde (wat eigenlijk binair begrijpen is - tellen in basis 2) omdat ik er niet erg goed in ben. - Evan Anderson
Mijn enige probleem met het opsplitsen van het antwoord is dat je moet begrijpen waarom subnetten bestaat (IP-routering) voordat men kan begrijpen hoe een IP-netwerk effectief kan worden onderverdeeld in subnetten. Ik heb nooit een goede manier gevonden om een ​​onderwerp afzonderlijk te bespreken. (Echt, het ontwerpen van een IP-netwerk met VLSM komt van nature en "is logisch" nadat je de IP-routering begrijpt ...) - Evan Anderson
Maak het niet kapot. - Joseph Kern
+1 voor de meest uitgebreide post ooit gezien op serverfault - Scott Lundberg
Opgewaardeerd, alleen al voor de metafoor van de kilometerteller. Nu weet ik hoe ik moet uitleggen hoe binary voor mensen werkt. - phuzion


Vervolg van: Hoe werkt IPv4-subnetwerken?

Uw internetprovider geeft u het bereik van de netwerk-ID 192.168.40.0/24 (11000000.10101000.00101000.00000000). U weet dat u een firewall / router wilt gebruiken om de communicatie tussen verschillende delen van uw netwerk (servers, clientcomputers, netwerkapparatuur) te beperken en daarom wilt u deze verschillende delen van uw netwerk opbreken in IP-subnetten (die de firewall / router kan omleiden).

Jij hebt:

  • 12 servercomputers, maar u krijgt mogelijk tot 50% meer
  • 9 schakelaars
  • 97 clientcomputers, maar mogelijk krijgt u meer

Wat is een goede manier om 192.168.40.0/24 in deze stukken op te splitsen?

Denkend aan zelfs krachten van twee, en werkend met de grotere aantallen mogelijke apparaten, kunt u verzinnen:

  • 18 servercomputers - het volgende grootste vermogen van twee is 32
  • 9 schakelaars - het volgende grootste vermogen van twee is 16
  • 97 clientcomputers - het volgende grootste vermogen van twee is 128

In een bepaald IP-subnet zijn er twee gereserveerde adressen die niet als IP-adressen van geldige apparaten kunnen worden gebruikt - het adres met alle nullen in het host-ID-gedeelte en het adres met alle adressen in het host-ID-gedeelte. Als zodanig is voor een gegeven IP-subnet het aantal beschikbare hostadressen twee tot de macht van de hoeveelheid van 32 minus het aantal bits in het subnetmasker, minus 2. Dus in het geval van 192.168.40.0/24 we kan zien dat het subnetmasker 24 bits heeft. Dat laat 8 bits beschikbaar voor host-ID's. We weten dat 2 tot en met 8 macht 256 is - wat betekent dat 256 mogelijke combinaties van bits in een 8-bit-slot passen. Omdat de combinaties "11111111" en "00000000" van die 8 bits niet zijn toegestaan ​​voor host-ID's, blijven er 254 mogelijke hosts over die kunnen worden toegewezen in het 192.168.40.0/24-netwerk.

Van die 254 hosts lijkt het erop dat we de clientcomputers, switches en servercomputers in die ruimte kunnen passen, toch? Laten we proberen.

U hebt 8 bits subnetmasker om "mee te spelen" (de resterende 8 bits van het IP-adres 192.168.40.0/24 vallen niet onder het subnetmasker dat door uw internetprovider wordt verstrekt). We moeten een manier bedenken om die 8-bits te gebruiken om een ​​aantal unieke netwerk-ID's te maken die geschikt zijn voor de bovenstaande apparaten.

Begin met het grootste netwerk - de clientcomputers. Je weet dat de volgende grotere macht van twee van het aantal mogelijke apparaten 128 is. Het getal 128, in binair, is "10000000". Gelukkig voor ons, dat past in de 8-bits slot die we gratis hebben (als dat niet het geval was, zou dat een aanwijzing zijn dat ons startende subnet te klein is om al onze apparaten te herbergen).

Laten we onze netwerk-ID nemen, zoals geleverd door onze ISP, en er een enkel stukje subnetmasker aan toevoegen, waarbij het opgedeeld wordt in twee netwerken:

11000000.10101000.00101000.00000000 - 192.168.40.0 network ID
11111111.11111111.11111111.00000000 - Old subnet mask (/24)

11000000.10101000.00101000.00000000 - 192.168.40.0 network ID
11111111.11111111.11111111.10000000 - New subnet mask (/25)

11000000.10101000.00101000.10000000 - 192.168.40.128 network ID
11111111.11111111.11111111.10000000 - New subnet mask (/25)

Kijk daarover totdat het logisch is. We hebben het subnetmasker met één bit verlengd, waardoor de netwerk-ID één bit bedekte die voor host-ID zou zijn gebruikt. Omdat dat ene bit nul of één kan zijn, hebben we ons 192.168.40.0-netwerk effectief gesplitst in twee netwerken. Het eerste geldige IP-adres in het 192.168.40.0/25-netwerk is de eerste host-ID met een "1" in de meest rechtse bit:

11000000.10101000.00101000.00000001 - 192.168.40.1 - First valid host in the 192.168.40.0/25 network

De eerste geldige host in het 192.168.40.128-netwerk zal ook de eerste host-ID zijn met een "1" in de meest rechtse bit:

11000000.10101000.00101000.10000001 - 192.168.40.129 - First valid host in the 192.168.40.128/25 network

De laatste geldige host in elk netwerk zal de host-ID met elk beetje zijn behalve de meest rechtse bit ingesteld op "1":

11000000.10101000.00101000.01111110 - 192.168.40.126 - Last valid host in the 192.168.40.0/25 network
11000000.10101000.00101000.11111110 - 192.168.40.254 - Last valid host in the 192.168.40.128/25 network

Dus op deze manier hebben we een netwerk gecreëerd dat groot genoeg is om onze clientcomputers te bevatten, en een tweede netwerk dat we dan hetzelfde principe kunnen toepassen om op te splitsen in nog kleinere netwerken. Laten we een notitie maken:

  • Clientcomputers - 192.168.40.0/25 - Geldige IP's: 192.168.40.1 - 192.168.40.126

Om nu het tweede netwerk voor onze servers en switches af te breken, doen we hetzelfde.

We hebben 12 servercomputers, maar we kunnen er tot 6 meer kopen. Laten we het op 18 stellen, wat ons het op één na hoogste vermogen van 2 als 32 laat. In binair getal is 32 "100000", wat 6 bits lang is. We hebben 7 bits subnetmasker over in 192.168.40.128/25, dus we hebben genoeg bits om door te gaan met "spelen". Als we nog een stukje subnetmasker toevoegen, hebben we nog twee netwerken:

11000000.10101000.00101000.10000000 - 192.168.40.128 network ID
11111111.11111111.11111111.10000000 - Old subnet mask (/25)

11000000.10101000.00101000.10000000 - 192.168.40.128 network ID
11111111.11111111.11111111.11000000 - New subnet mask (/26)
11000000.10101000.00101000.10000001 - 192.168.40.129 - First valid host in the 192.168.40.128/26 network
11000000.10101000.00101000.10111110 - 192.168.40.190 - Last valid host in the 192.168.40.128/26 network

11000000.10101000.00101000.11000000 - 192.168.40.192 network ID
11111111.11111111.11111111.11000000 - New subnet mask (/26)
11000000.10101000.00101000.11000001 - 192.168.40.193 - First valid host in the 192.168.40.192/26 network
11000000.10101000.00101000.11111110 - 192.168.40.254 - Last valid host in the 192.168.40.192/26 network

Dus nu hebben we 192.168.40.128/25 onderverdeeld in twee andere netwerken, die elk 26 bits subnetmasker hebben, of in totaal 62 mogelijke host-ID's - 2 ^ (32 - 26) - 2.

Dat betekent dat beide netwerken genoeg adressen hebben voor onze servers en switches! Laten we notities maken:

  • Servers - 192.168.40.128/26 - Geldige IP's: 192.168.40.129 - 192.168.40.190
  • Schakelaars - 192.168.40.192/26 - Geldige IP's: 192.168.40.193 - 192.168.40.254

Deze techniek wordt subnetmasking met variabele lengte (VLSM) genoemd en veroorzaakt, indien correct toegepast, "kernrouters" met kleinere routingtabellen (via een proces dat "routesamenvatting" wordt genoemd). In het geval van onze ISP in dit voorbeeld, kunnen ze zich totaal niet bewust zijn van hoe we 192.168.40.0/24 hebben overtroffen. Als hun router een pakket heeft voor 192.168.40.206 (een van onze switches), hoeven ze dit alleen door te geven aan onze router (aangezien 192.168.40.206 overeenkomt met de netwerk-ID en het subnetmasker 192.168.40.0/24 in de routingtabel van hun router) ) en onze router zal het naar de bestemming brengen. Hierdoor blijven onze subnetroutes uit hun routeringstabellen. (Ik vereenvoudig hier, maar je snapt het wel.)

Je kunt op dezelfde manier zeer geografisch grote netwerken plannen. Zolang u de juiste "stadsplanning" vooraf uitvoert (anticiperend op het aantal hosts in elk subnetwerk met enige nauwkeurigheid en een oog voor de toekomst), kunt u een grote routeringshiërarchie creëren die, in de kernrouters, "samenvat "op een zeer klein aantal routes. Zoals we hierboven zagen, hoe meer routes er in de routeringstabel van een router zijn, des te langzamer deze zijn taak uitvoert. Het ontwerpen van een IP-netwerk met VLSM en het klein houden van routeringstabellen is een goed ding (tm).

Het onrealisme van voorbeelden

De fictieve wereld in dit antwoord is, natuurlijk, fictief. Normaal gesproken kunt u subnetten maken op modern geschakeld Ethernet met meer hosts dan 254 (afhankelijk van het verkeersprofiel). Zoals in opmerkingen is opgemerkt, is het gebruik van / 24-netwerken tussen routers niet consistent met Real Life (tm). Het zorgt voor leuke voorbeelden, maar is verspilling van adresruimte. Typisch, a / 30 of a / 31 (zie http://www.faqs.org/rfcs/rfc3021.html voor details over hoe / 31's werk-- ze zijn buiten de reikwijdte van dit antwoord zeker) netwerk wordt gebruikt op koppelingen die strikt point-to-point zijn tussen twee routers.


137
2017-08-04 15:53



Kleine fout: de code direct na 'De laatste geldige host ...' keert terug naar 'de eerste geldige host'. Ik neem aan dat dat nog steeds "laatste" moet zeggen. - JoeCool1986
@ JoeCool1986 - Goede vangst. - Evan Anderson
Ik ga dit antwoord opwaarderen om ervoor te zorgen dat twee antwoorden op orde blijven. - l46kok
Op het gedeelte waar u twee subnetten maakt van 192.168.40.128 en een netwerk-ID maakt van 192.168.40.192, waar komt de 192 vandaan? - user6607
@ user6607 Subnetten worden achterwaarts geteld (zonder gaten). Bijvoorbeeld het eerste subnet 0 wordt weergegeven als 00000000. Het tweede subnet is 128 zo 10000000 en het derde subnet 192 wordt weergegeven als 11000000, etc. Blijf gewoon achterwaarts tellen om nieuwe subnetten te vinden. - Joseph Kern


Sub-netten

Subnetten zijn niet moeilijk, maar het kan intimiderend zijn. Dus laten we beginnen met de eenvoudigst mogelijke stap. Leren tellen in binair getal.

Binair

Binair is een telsysteem met basis 2. Bestaande uit slechts twee nummers (1 en 0). Tellen verloopt op deze manier.

1 = 001 ( 0 + 0 + 1 = 1)
2 = 010 ( 0 + 2 + 0 = 2)
3 = 011 ( 0 + 2 + 1 = 3)
4 = 100 ( 4 + 0 + 0 = 4)
5 = 101 ( 4 + 0 + 1 = 5)

Dus als je je voorstelt dat elke 1 een plaatshouder is voor een waarde (alle binaire waarden zijn machten van twee)

1     1     1     1     1 = 31
16  + 8  +  4  +  2  +  1 = 31

Dus ... 100000 = 32. En 10000000 = 128. EN 11111111 = 255.

Als ik zeg: "Ik heb een subnetmasker van 255.255.255.0", bedoel ik echt: "Ik heb een subnetmasker van 11111111.11111111.11111111.00000000." We gebruiken subnetten als een korte hand.

De perioden in het adres scheiden elke 8 binaire cijfers (een octet). Dit is de reden waarom IPv4 bekend staat als een 32bit (8 * 4) adresruimte.

Waarom Subnet?

IPv4-adressen (192.168.1.1) zijn schaars. Subnetting biedt ons een manier om de hoeveelheid beschikbare netwerken (of hosts) te vergroten. Dit is om administratieve redenen en technische redenen.

Elk IP-adres is onderverdeeld in twee afzonderlijke delen, het netwerk en de host. Standaard gebruikt een Klasse C-adres (192.168.1.1) de eerste 3 octetten (192.168.1) voor het netwerkgedeelte van het adres. en het 4e octet (.1) als het hostgedeelte.

Standaard ziet een IP-adres en subnetmasker voor een klasse C-adres er als volgt uit

IP     192.168.1.1 
Subnet 255.255.255.0

In binary zoals deze

IP     11000000.10101000.00000001.00000001
Subnet 11111111.11111111.11111111.00000000

Bekijk het binaire voorbeeld opnieuw. Merk op hoe ik zei dat de eerste drie octetten worden gebruikt voor het netwerk? Merk op hoe het netwerkgedeelte allemaal is? Dat is allemaal subnetten. Laten we uitbreiden.

Gegeven dat ik een enkel octet heb voor mijn hostgedeelte (in het bovenstaande voorbeeld). Ik kan ALLEEN 256 hosts hebben (256 is de maximale waarde van een octet, geteld vanaf 0). Maar er is nog een kleine truc: u moet 2 hostadressen aftrekken van de beschikbare (momenteel 256). Het eerste adres in het bereik is voor het netwerk (192.168.1.0) en het laatste adres in het bereik is de uitzending (192.168.1.255). Dus je hebt echt 254 beschikbare adressen voor hosts in één netwerk.

Een case study

Laten we zeggen dat ik je het volgende stuk papier heb gegeven.

Create 4 networks with 192.168.1.0/24.

Laten we dit eens bekijken. De / 24 wordt de CIDR-notatie genoemd. In plaats van te verwijzen naar de 255.255.255.0 verwijzen we alleen naar de bits die we nodig hebben voor het netwerk. In dit geval hebben we 24 bits (3 * 8) nodig van een 32bit-adres. Dit uitschrijven in binair getal

11111111.11111111.11111111.00000000 = 255.255.255.0
8bits   + 8bits  + 8bits  + 0bits   = 24bits

Vervolgens weten we dat we moeten uitzoeken hoeveel subnetten we nodig hebben. Lijkt op 4. Omdat we meer netwerken moeten maken (op dit moment hebben we er maar één), kunnen we wat bits omdraaien

11111111.11111111.11111111.00000000 = 255.255.255.0   = 1 Network OR /24
11111111.11111111.11111111.10000000 = 255.255.255.128 = 2 Networks OR /25
11111111.11111111.11111111.11000000 = 255.255.255.192 = 4 Networks (remember powers of 2!) OR /26

Nu we hebben besloten dat op a / 26 we beginnen met het toewijzen van hosts. Een beetje eenvoudige wiskunde:

32(bits) - 26(bits) = 6(bits) for host addresses.

We hebben 6 bits om toe te wijzen in elk netwerk voor hosts. Vergeet niet dat we 2 voor elk netwerk moeten aftrekken.

h = host bits    
2^h - 2 = hosts available

2^6 - 2 = 62 hosts 

Finally we have 62 hosts in 4 networks, 192.168.1.0/26

Nu moeten we uitvinden waar de gastheren naartoe gaan. Terug naar het binaire bestand!

11111111.11111111.11111111.00,000000 [the comma is the new network/hosts division]

Begin to calculate:

11000000.10101000.00000001.00,000000 = 192.168.1.0 [First IP = Network Adress]
11000000.10101000.00000001.00,000001 = 192.168.1.1 [First Host IP]
11000000.10101000.00000001.00,000010 = 192.168.1.2 [Second Host IP]
11000000.10101000.00000001.00,000011 = 192.168.1.3 [Third Host IP]

And so on ... until ...

11000000.10101000.00000001.00,111110 = 192.168.1.62 [Sixty Second Host IP]
11000000.10101000.00000001.00,111111 = 192.168.1.63 [Last IP = Broadcast Address]

So ... On to the NEXT network ....

11000000.10101000.00000001.01,000000 = 192.168.1.64 [First IP = Network Address]
11000000.10101000.00000001.01,000001 = 192.168.1.65 [First Host IP]
11000000.10101000.00000001.01,000010 = 192.168.1.66 [Second Host IP]

And so on ... until ...

11000000.10101000.00000001.01,111110 = 192.168.1.126 [Sixty Second Host IP]
11000000.10101000.00000001.01,111111 = 192.168.1.127 [Last IP = Broadcast Address]

So ... On to the NEXT network ....

11000000.10101000.00000001.10,000000 = 192.168.1.128 [First IP = Network Address]
11000000.10101000.00000001.10,000001 = 192.168.1.129 [First Host IP]

Etc ...

Op deze manier kunt u het gehele subnet berekenen.

Wild kaarten Een wildcardmasker is een omgekeerd subnetmasker.

11111111.11111111.11111111.11000000 = 255.255.255.192 [Subnet]
00000000.00000000.00000000.00111111 = 0.0.0.63 [Wild Card]

Verder

Google voor de termen 'super-netting' en 'VLSM (variable length subnet mask)' voor meer geavanceerde onderwerpen.

Ik kan nu zien dat ik er te lang over deed om te antwoorden ... zucht


73
2017-08-04 15:12



"Aangezien ik een enkel octet heb voor mijn hostgedeelte (in het bovenstaande voorbeeld) .Ik kan ALLEEN 255 hosts hebben (255 is de maximale waarde van een octet). Maar er is nog een kleine truc: u moet 2 hostadressen aftrekken van de beschikbare (momenteel 255) .Het eerste adres in het bereik is voor het netwerk (192.168.1.0) en het laatste adres in het bereik is de uitzending (192.168.1.255). Dus je hebt echt 253 beschikbare adressen voor hosts in één netwerk. "... Dit is onjuist. - joeqwerty
Er zijn 256 mogelijke waarden voor het octet: 0 tot 255, voor een totaal van 256. 256 -2 (netwerk- en broadcast-adressen) = 254 mogelijke hostadressen. - joeqwerty
Oeps. Bedankt! :-) Eén voor één heb ik geen idee hoe ik die bepaalde prestatie heb gedaan. - Joseph Kern
-1 Sorry, maar sinds de RFC 1519 in 1993 zijn er geen "lessen" geweest, niemand zou buiten een historische context over hen moeten praten. Ze zijn verwarrend en veroorzaken veel misvattingen. - Chris S
Chris, je hebt waarschijnlijk gelijk, maar de lessen werden nog steeds gegeven tot begin 2000 in de CCNA en de meeste undergrad level-cursussen. - Joseph Kern


Een korte geschiedenisles: oorspronkelijk waren unicast IPv4-adressen verdeeld in 3 klassen, elk met een bijbehorende 'standaard' maskerlengte (het classful subnet-masker genoemd)

  • Klasse A: Alles in het bereik 1.0.0.0 -> 127.255.255.255. Classvol subnetmasker van 255.0.0.0 (/ 8 in CIDR-notatie)
  • Klasse B: alles in het bereik 128.0.0.0 -> 191.255.255.255. Classvol subnetmasker van 255.255.0.0 (/ 16 in CIDR-notatie)
  • Klasse C: alles in het bereik 192.0.0.0 -> 223.255.255.255. Classvol subnetmasker van 255.255.255.0 (/ 24 in CIDR-notatie)

Het idee was dat organisaties van verschillende grootte een andere klasse IP-adressen konden krijgen om efficiënt gebruik te kunnen maken van IP-adresruimte.

Naarmate IP-netwerken groeiden, werd echter duidelijk dat deze aanpak problemen had. Om er maar drie te noemen:

In een klassevolle wereld, alle subnetten had om een ​​masker te hebben van / 8, / 16, of / 24. Dit betekende dat het kleinste subnet dat kon worden geconfigureerd a / 24 was, waarmee 254 host-adressen waren toegestaan ​​(.0 en .255 zijn respectievelijk gereserveerd als het netwerk en uitzendadressen). Dit was enorm verspilling, met name op point-to-point links met slechts twee routers die eraan gekoppeld waren.

Zelfs nadat deze beperking was versoepeld, werden eerdere routeerprotocollen (bijv. RIPv1) adverteerde niet de maskerlengte die is gekoppeld aan een IP-voorvoegsel. Bij afwezigheid van een specifiek masker zou het ofwel het masker van een rechtstreeks verbonden interface in hetzelfde stijlvolle netwerk gebruiken, of terugvallen op het gebruik van het stijlvolle masker. Als u bijvoorbeeld het netwerk 172.16.0.0 wilt gebruiken voor interrouterlinks met / 30 maskers, allemaal subnetten van 172.16.0.0 - 172.16.255.255 zouden een / 30 masker moeten hebben (16384 subnetten, elk met 2 bruikbare IP's).

De routeringstabellen van internetrouters begonnen steeds meer geheugen op te nemen; dit was / staat bekend als de 'routing table explosion'. Als een provider bijvoorbeeld 16 aangrenzende / 24-netwerken had, dan zouden ze alle 16 voorvoegsels moeten adverteren in plaats van een enkele samenvatting die het hele bereik bestreek.

Twee gerelateerde verfijningen liet ons toe om verder te gaan dan de bovenstaande beperkingen.

  1. Subnet-maskers met variabele lengte (VLSM)
  2. CIDR (Classless inter domain routing)

VLSM verwijst naar het vermogen van een routeringsprotocol om verschillende subnetmaskers in hetzelfde stijlvolle netwerk te ondersteunen. Bijvoorbeeld:

192.168.1.0/24

Kan opgesplitst worden in:

192.168.1.0/25
192.168.1.128/26
192.168.1.192/27
192.168.1.224/27

Wat voor veel efficiënter gebruik van adresruimte toestond; subnetten kunnen de juiste grootte hebben voor het aantal hosts / routers dat eraan zou zijn gekoppeld.

CIDR neemt VLSM en breidt het op de andere manier uit; Naast het splitsen van een enkel klassevol netwerk in kleinere subnetten, maakt CIDR het mogelijk om meerdere klassevolle netwerken samen te voegen tot één samenvatting. Bijvoorbeeld de volgende klasse B (/ 16) -netwerken:

172.16.0.0/16
172.17.0.0/16
172.18.0.0/16
172.19.0.0/16

Kan samengevoegd / samengevat worden met een enkel voorvoegsel:

172.16.0.0/14

In termen van subnetting: een subnetmasker is 32 bits lang. De lengte van het masker geeft aan hoeveel bits het netwerkgedeelte van het adres identificeren. Bijvoorbeeld:

10.1.1.0/24
  • Het stijlvolle subnetmasker is / 8
  • Het eigenlijke subnetmasker is / 24
  • 16 bits (24-8) zijn 'geleend' voor het gebruik van subnetten.

Dit betekent dat, aangenomen dat het volledige 10.0.0.0/8-netwerk is onderverdeeld in / 24s, er binnen dit bereik 65536 (2 ^ 16) subnets zullen zijn. (Dit veronderstelt dat het platform dat u gebruikt subnetnummers van 0 en 255 ondersteunt. Zie Cisco's ip-subnet-zero).

Er zijn nog 8 bits over in het 'hostgedeelte' van het adres. Dit betekent dat er 256 beschikbare IP-adressen zijn (2 ^ 8), waarvan er 2 zijn gereserveerd (10.1.1.0 is het netwerkadres, 10.1.1.255 is het subnet gerichte broadcast-adres). Dit laat 254 bruikbare IP-adressen achter op dit subnet. ((2 ^ 8) - 2)


31



Er waren eigenlijk 5 klassen. - dbasnett
Klopt, maar moeten we echt ingaan op multicast en gereserveerde klasse E-adressering voor een 'intro to subnetting'-vraag? :) - Murali Suriar
Je bracht de geschiedenis in een introvraag ... Daarna liet je het onvolledig. Weet niet zeker wat erger is. - Chris S


Netwerk reeksen: netwerken worden altijd aangeduid met 2 nummers: één om het netwerk te bepalen en een andere om te bepalen welke computer (of host) zich op dat netwerk bevindt. Aangezien elk nertwerkadres 32 bits lang is, moeten beide nummers in deze 32 bits passen.

Netwerknummering is belangrijk, want dit is wat ICANN uitdeelt wanneer u om een ​​IP-bereik van een netwerk vraagt. Als we het niet hadden, zou niemand het verschil kunnen zien tussen mijn netwerk en AT & Ts. Dus hoewel deze nummers uniek moeten zijn, wil niemand anders nummers toewijzen aan de hosts die zich op mijn netwerk bevinden. Vandaar de splitsing - het eerste deel wordt beheerd door de netwerkmensen, het tweede deel is helemaal van mij te geven aan welke machines ik ook wil.

Het netwerknummer is niet voor een bepaald aantal bits gefixeerd - als ik bijvoorbeeld maar 200 machines had om mezelf te beheren, zou ik heel blij zijn met een netwerknummer dat 24 bits gebruikte, waardoor ik slechts 8 bits voor mezelf had - wat genoeg is voor maximaal 255 hosts. Omdat het netwerknummer 24 bits gebruikt, kunnen we er veel van hebben, wat betekent dat veel mensen hun eigen netwerken kunnen hebben.

In het verleden werd dit een klasse C-netwerk genoemd. (klasse B gebruikte 16 bits voor netwerknummer en klasse A gebruikte 8 bits, dus er bestaan ​​slechts enkele klasse A-netwerken).

Tegenwoordig is deze naamgevingsconventie uit de mode geraakt. Het werd vervangen door het concept CIDR. CIDR zet expliciet het aantal bits voor uw hosts na de slash. Dus mijn voorbeeld hierboven (de klasse C) wordt nu een CIDR / 24 genoemd.

Dit geeft ons wat meer flexibiliteit, voordat ik 300 hosts had om te beheren, zou ik een klasse B-netwerk nodig hebben! Nu kan ik gewoon een / 23 CIDR krijgen, dus ik heb 9 bits voor mij en 23 bits voor het netwerknummer. ICANN heeft dit soort netwerken mogelijk niet, maar als ik een intern netwerk heb, of een gedeeltelijk netwerk huurt bij een ISP, dan is dit gemakkelijker te beheren - vooral omdat aan al hun klanten een / 29 kan worden gegeven (mij verlaten). 3 bits of maximaal 8 machines) waarmee meer mensen hun eigen stukje van de beschikbare IP-adressen kunnen hebben. Tot we IPv6 krijgen, is dit vrij belangrijk.


Maar ... terwijl ik weet dat een / 24 CIDR het equivalent is van het oude Class C-netwerk, en a / 16 is klasse B en a / 8 is een klasse A ... Ik ben nog steeds stumped om een ​​/ 22 te berekenen in mijn hoofd. Gelukkig zijn er hulpmiddelen die dit voor mij doen :)

Maar - als je weet dat a / 24 8 bits is voor hosts (en 24 bits voor netwerk), dan weet ik dat a / 23 me een extra bit geeft dat het aantal hosts verdubbelt.


6



-1 Sorry, maar het noemen van klassen buiten een 'historische' referentie is deze dagen ongepast. Ze raakten niet "uit de mode", ze werden officieel afgekeurd door RFC 1519 in 1993. Ze zijn verwarrend als alle anderen en veroorzaken een hoop misvattingen. - Chris S
Sommige implementaties van dynamische routeringsprotocollen vatten samen langs classieke grenzen, dus het is nog steeds nuttig om ze te kennen. - Ben


Hoewel het bovenstaande correct is (sorry, TL; DR), veroorzaakt het berekenen van subnetten nog steeds veel netwerkbeheerders veel verdriet. Er is eigenlijk een heel eenvoudige manier om subnetberekeningen uit te voeren, je kunt het meeste in je hoofd doen en er is heel weinig dat je moet onthouden. Voor de meeste toepassingen is het zelfs niet nodig om de binaire weergave te begrijpen, hoewel dit nuttig is voor een volledig begrip van subnetting. Hier zal ik alleen IPv4 bespreken; IPv6 valt buiten het bereik van deze discussie.

Onthoud dit:

Er zijn drie belangrijke dingen om te onthouden: alle subnetten zijn gebaseerd op machten van twee en er zijn twee sleutelnummers: 256 en 32. Daarover later meer.

Laten we eerst kijken naar een tabel met machten van 2:

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

Het berekenen van de machten van 2 is eenvoudig: elk geheel getal van de macht verdubbelt het resultaat. 1 + 1 = 2, 2 + 2 = 4, 4 + 4 = 8, 8 + 8 = 16, enzovoort. Het totale aantal adressen in een subnet moet altijd een macht van 2 zijn.

Aangezien elk octet van een IPv4-subnet oploopt tot 256, 256 is een heel belangrijk nummer


3



dank u. Maar ik ben nog steeds vaag over hoe de pc het subnetmasker gebruikt. Wanneer een toepassing op een pc gegevens wil verzenden, wordt deze in een pakket ingekapseld. Bepaalt het subnetmasker hoe een pakket wordt ingekapseld? Als de pc bijvoorbeeld een pakket op het lokale net wilde verzenden, zou het een ethernetframe gebruiken en.wikipedia.org/wiki/Ethernet_frame en als het buiten het netwerk wilde, zou het een TCP-pakket gebruiken en.wikipedia.org/wiki/... ? - aquagremlin
Kortom, ik weet niet HOE een pc bepaalt waar zijn gegevens naartoe moeten worden verzonden. Het ethernet-netwerk is als een bus-het gaat overal naartoe. Een pakket uitzetten via de ethernet-aansluiting van een pc is een generieke gebeurtenis - daarom moet het pakket zelf bepalen wie erop reageert. Een pakket dat is bestemd om te worden opgepikt door een lokaal apparaat (switch of een andere pc op de LAN) moet er anders uitzien dan een pakket dat door een router wordt opgehaald. - aquagremlin
Dit gebeurt op een laag onder TCP. Elk apparaat heeft een hardwareadres (MAC) dat is gekoppeld aan een IP-adres in de ARP-tabel van elk apparaat. Dit wordt gebouwd door middel van ontdekking. Wanneer een pakket is bestemd voor een host op het lokale netwerk, is het getagd met de MAC voor het bestemmingsapparaat. Wanneer een pakket is bestemd voor een externe host, is het getagd met de MAC voor de router op het lokale netwerk. Bij het passeren van de router wordt de MAC gestript en vervolgens gemerkt met de MAC van de volgende hop-router. Het subnet definieert alleen de reikwijdte van het lokale netwerk. (Dat is de eenvoudige <500-karakterversie.) - Jonathan J


Ik ben ook van mening dat er ten minste sprake moet zijn van NAT's, omdat ze zo vaak worden gebruikt in moderne netwerken in plaats van Subnetten, onder meer vanwege uitputting van IPv4-adressen. (Ook toen ik voor het eerst over subnetten aan het leren was, was ik erg in de war over de manier waarop subnetten betrekking hebben op de netwerken die door WiFi-routers zijn gemaakt).

NAT (network address translation) is een techniek die (vaak) wordt gebruikt om privénetwerken te creëren door een adresruimte (IP: Port) aan een andere toe te wijzen. Dit wordt met name gebruikt om een ​​privé-netwerk van meerdere privé-IP's achter één openbaar adres te maken, bijvoorbeeld in wifi-routers, door organisaties (zoals een universiteit of een bedrijf) of soms door internetproviders.

De daadwerkelijke adresomzetting is voltooid transparant in NAT-geschikte knooppunten, meestal routers. Het kan van vele vormen zijn, Full Cone, Address Restricted, Port restricted etc. of een combinatie hiervan, die dicteert hoe de verbindingen over het knooppunt kunnen worden geïnitieerd.

Volledige details zijn te vinden op Wikipedia, maar denk bijvoorbeeld eens aan een wifi-router met twee apparaten die erop zijn aangesloten. Het openbare IP-adres van de router is 10.9.20.21/24en het IP-adres van de apparaten (Private IP's) zijn A: 192.168.0.2, B: 192.168.0.3 en die van de router is R: 192.168.0.1. Dus als A wil verbinding maken met de server S: 10.9.24.5/24, (die zich hier op een ander subnet bevindt dan de router):

  1. A stuurt een IP-pakket naar R(wat de standaardgateway zou zijn) met het bron-IP 192.168.0.2, src poort (zeg maar) 14567en bestemmings-IP: 10.9.24.5 (Hoewel port feitelijk een deel van de TCP-header is).
  2. De router (die NAT-compatibel is) brengt de poort in kaart 14567 naar apparaat A en verandert de bron op het IP-pakket in 10.9.20.21(dat is het openbare IP-adres van de router). Dit staat in contrast met subnetting zoals hierboven beschreven, waar de IP-pakketten eigenlijk nooit zijn veranderd.
  3. S ontvangt de reeks TCP-pakketten (met src IP: 10.9.20.21, src Poort: 14567) en verzend antwoordpakketten met die waarden in de bestemmingsvelden.
  4. R controleert de bestemmingshaven, dat is 14567 en stuurt het pakket door naar A.
  5. A ontvangt het antwoordpakket.

In de bovenstaande situatie, als B geprobeerd om een ​​verbinding op dezelfde bronpoort te openen (14567), zou het worden toegewezen aan een andere poort door R(en de poort in het uitgaande pakket is gewijzigd) voor verzending naar S. Dat wil zeggen, er zou ook poortvertaling zijn in plaats van alleen IP.

Twee dingen om op te merken hier:

  1. Vanwege deze adresvertaling is het vaak niet mogelijk om een ​​verbinding tot stand te brengen met apparaten in het particuliere netwerk zonder een aantal speciale technieken te gebruiken.
  2. De beperking van de totale TCP-verbindingen van hetzelfde apparaat naar een server (65536 = 2 ^ 16) is nu collectief van toepassing op alle apparaten achter de NAT, in de NAT-vorm die hierboven wordt gebruikt.

1