Use IPv4 Subnetting

0:00<v ->Hello, and welcome.</v>

0:01My name is Keith Barker,

0:03and in this skill we're gonna focus on the concept

0:05of IPv4 Subnetting.

0:07And that involves, first of all,

0:08identifying what is it and why do I care?

0:11Secondly, how to calculate and create logical IP subnets.

0:15And then third, I'm gonna put you in a hands-on lab,

0:18so you can not only confirm your understanding

0:20of the subnetting, but also confirm your ability

0:23to actually configure and implement it

0:24in an IP network using Cisco gear.

0:27So that's our lineup for what we have in store.

0:29I'll see you, my friend, in the next video.

0:00<v Instructor>So to help us better understand the concept</v>

0:02of what exactly is an IPv4 subnet,

0:04let's talk about something

0:05that we're probably already familiar with,

0:07and that is a city or a town with streets

0:10and various street names and so forth.

0:12So we'll call this a city plan,

0:13similar to what we did in a previous skill

0:15as we took a look at the foundation basics of IP addressing.

0:18And for this scenario, however, what I'd like

0:20to do is take one street, we'll call it 10th Street,

0:24and then we've got some houses on that street.

0:26So I'll put a couple here

0:28and a couple here and a couple here.

0:31This is how we're addressing all these devices live

0:33on the same street

0:33and then they have individual house numbers.

0:35For example, this could be 50 and 51 and 52

0:39and 100, although that's a big jump for two houses

0:43that are right next to each other.

0:44Then over here, let's go to use 61 and 62,

0:47but they all live on 10th Street.

0:48So their addresses would all include 10th Street

0:50'cause they're on the same street

0:51and then they'd have their individual house numbers.

0:53So at that plan in mind regarding 10th Street,

0:56all of a sudden, somebody comes up to us and says,

0:57"you know what?

0:58Instead of having, you know, one giant 10th street,

1:00what we'd love you to do is to go ahead

1:02and create three smaller and unique streets."

1:06So just to confirm, we say to them,

1:07"okay, you wanna take this one large street

1:10that we're planning out

1:11and instead of having one big street,

1:12you want three streets?"

1:14And they say yes.

1:15And then we ask them,

1:15"can we use any name we want for those new streets?"

1:18And they say, "nope, you have to all kind of make it fit

1:20or be similar to 10th Street

1:22because we don't have any numbers outside

1:24of 10th Street that we can give you."

1:26So as far as our plan goes, this is the before,

1:29here up on top with one giant street.

1:31And next let's go ahead and put in the after.

1:33So it might seem like an impossible task that you know,

1:36how can we make three different streets

1:38or three substreets out of 10th Street,

1:40but it'd be pretty easy to do.

1:42And here's how we could pull it off.

1:43First of all, we create the three logical streets

1:47and we'll put a couple houses on each street.

1:50And now comes the big question of

1:51what do we call these streets?

1:53Because if we have to use 10th Street for all of it,

1:56how can we make them unique?

1:57It goes something like this.

1:59Why don't we call this street right here, 10th Avenue

2:02and this street right here, let's call it 10th Lane.

2:05And for this one over here on the right, let's go ahead

2:07and call this 10th Court.

2:09So now we have unique names for each of 'em

2:11'cause we can say 10th Avenue or 10th Lane or 10th Court.

2:14And then the houses inside of 10th Avenue,

2:17if they wanna talk to each other, they'd be responsible

2:19for delivering those messages directly.

2:21And the same thing here for these two houses on 10th Lane.

2:23And the same thing for these houses here on 10th Court.

2:26However, if they wanna send messages, for example,

2:29from 10th Court or to 10th lane,

2:30or from 10th Avenue to 10th Lane

2:32or 10th Court, we're gonna need some help.

2:34So to assist in that, we're gonna have these devices

2:36that can actually route between the different streets.

2:39So this is gonna be router one and router two.

2:41And I know I'm breaking the analogy a little bit

2:43because that's literally what's happening here.

2:45The routers are directly connected to the various streets

2:48and they can make the routing decisions.

2:50So then for the actual host addresses

2:51or house numbers, this could be 10 and this could be 11

2:56and maybe the router is gonna be .1 here,

2:59that would be their default gateway.

3:01And maybe over here on 10th lane,

3:02we have the host addressing for R1.18

3:06and maybe R2 is .19.

3:08And then over here on the connection over here

3:10to 10th Court, which R2 is connected to,

3:12maybe over here, it's using house address 35.

3:15So fill in the other house numbers.

3:16Maybe this is 20 and 21,

3:18over here, maybe this is 40 and 41.

3:21So with this design, this plan in place, we go back

3:24to the people we report to at the city.

3:26We say "we did it."

3:27And they say, "you did what?"

3:28And we say, "well, we took the 10th Street,

3:30which was gonna be one giant street

3:32and we subdivided it into 10th Avenue

3:35and 10th Lane and 10th Court."

3:37And so now for the million dollar reveal, what has this got

3:41to do with IP subnetting?

3:43And the answer is, it's exactly the same

3:46because what we're doing

3:47with IP Subnetting is we're taking one network

3:49and let's go ahead and use 10.67.83.0

3:53with a 24 bit mass.

3:54That is what I like to call the parent's network.

3:57And if we are required

3:58to create three logical networks outta this address space,

4:02that's what the process of IPv4 subnetting does for us.

4:05It lets us take this parent network addressing space

4:08and then further subdivided into logical, smaller subnets.

0:00<v Narrator>In this video you and I get to take look</v>

0:01at the mechanism that's used to take one bigger network

0:05and then chop it up into smaller subnets.

0:07And in preparation for that, let me also go ahead

0:09and just review with you a couple of the basics

0:12regarding an IPv4 address.

0:13Also, there's a couple of skills previous to this

0:16regarding the fundamentals of IPv4,

0:18which I'm also encouraging you if you haven't already

0:21to take a look at those first before we continue

0:23on with the subnetting.

0:24So presuming a basic knowledge of IPv4

0:27from those previous skills, let's do a quick review.

0:29Here we have an example of an IPv4 network,

0:3310.67.83.0 with a 24 bit mask.

0:36It's in dotted decimal

0:38and behind the scenes that decimal number is really

0:41representing eight bits, so I've put the eight bits here

0:43in the same color and I put a little space

0:45between the first four and the second four

0:47in this one number, just for readability purposes.

0:51And just as a quick reminder, if we ever need

0:52to convert decimal to binary,

0:54we simply write out this string of numbers right here.

0:56This is the eight bit positions in a byte of data

0:59starting with on the right we have one,

1:01and you just keep doubling it, doubling it, doubling it,

1:03all the way 'till we get to the eighth position here

1:05and it has a value of 128.

1:07So we did cover this in a previous skill

1:08but just as a quick review,

1:10if we wanted to break down 10

1:12into binary, we play the game,

1:14can I subtract this?

1:15We're talking about can I subtract this value

1:18from the current number, so we have 10.

1:21And then we ask ourselves the question,

1:22can we subtract 128 from 10.

1:24The answer is no, so with binary,

1:26a one, think of it like a yes,

1:27and a zero, think of it like a no,

1:29like a light switch, on or off.

1:31And then we go to the next position here, 64.

1:33Can we subtract 64 from 10?

1:34Nope, we can't subtract 32, we can't subtract 16,

1:38but we can subtract eight, so we go ahead and put

1:40a yes there and then we do the math.

1:42Subtract eight and the remainder is two,

1:44so we continue on with our game,

1:46can I subtract four from the remainder?

1:48Nope.

1:48Can I subtract two from that remainder?

1:50The answer is yep, so we'll do the math,

1:52subtract two, the remainder is zero.

1:54So over here I put a one indicating I can subtract

1:56that two and then I put a zero here for the one's position.

1:59So that's how we can convert a decimal number into binary.

2:04So here's the result of that conversion.

2:06And here's that same result right here.

2:08Zero, zero, zero, zero, one, zero, one, zero,

2:11and let's also do one more example of that with 67.

2:14So I'll put 67 right here and we'll play the game.

2:16Can I subtract this from that decimal number?

2:18So 128, I can't take that away from 67

2:21without going negative, so that's no,

2:23and for 64, the answer is yes I can, so we'll do the math,

2:25minus 64 and the remainder is three.

2:28So for that remainder, 32 can't be taken away from that

2:31nor can 16, nor can eight, nor can four.

2:34However, two can, so we'll go ahead and put a one there.

2:36We'll subtract two.

2:37Now we have a remainder of one,

2:39so we'll put a bit on there in that position.

2:41We'll do our math, minus one,

2:43and the goal here is to get to zero

2:45and we've done that, so for 67 the binary equivalent

2:48is zero, one, zero, zero, as shown right here,

2:51followed by zero, zero, one, one,

2:53as shown right here.

2:54And then we can continue that for the 83 as well

2:57using the same process.

2:59And then for the mask for this network, I wrote it out

3:01as /24 which means the first 24 contiguous bits are on,

3:06so we can put a dividing line right there

3:08and everything to the left represents the network

3:10address space and everything to the right

3:12is available for host addressing,

3:14and if we wrote the mask out in dotted decimal

3:16it'd be 255, dot 255, dot 255, dot zero.

3:22And if we ever needed to convert from binary

3:24over to decimal, we'd go ahead and simply

3:27put in a value, so if our mask is this,

3:29one, one, one, one, one, one, one, one

3:32we simply add up all those values.

3:33128 plus 64 plus 32 plus 16 plus eight

3:36plus four plus two plus one

3:38and that equals 255.

3:40So here a /24 simply means we have 24 contiguous bits

3:44in binary that are on and when those on bits stop

3:47so does the network portion

3:49and that means the rest of the address space

3:50or to the right of that line

3:52is the host addressing.

3:53So this address right here represents a network ID.

3:56The 10.67.83.0 network

3:59with a 24 bit mask.

4:00All right so now that we've had some fun

4:02with a quick review of binary to decimal

4:04and decimal to binary,

4:05and that IPv4 addresses are written in dotted decimals,

4:08but behind the scenes they're actually representing 32 bits

4:11and that the mask is the dividing line

4:13between the network portion on the left

4:15and the host portion on the right,

4:16let's talk about creating subnets.

4:18To create subnets, let's imagine that we've been given

4:21this network to use,

4:23and we've been told by the city planner

4:25or the network planner, "Hey everything you want

4:28"to create has to be created within this address space,

4:30"10.67.83."

4:33So by default here this is just one network,

4:35a 24 bit network, but what they're asking us to do

4:38is to create logical subnets.

4:40Now why would we ever want to take one giant street

4:43like this or one giant network

4:46and chop it up and do smaller networks?

4:47And there's lots of reasons.

4:48One is we don't want to have thousands of devices

4:52on a single network.

4:53Some of those reasons involve giant broadcast

4:56of (indistinct) where one device on the network

4:57sends a broadcast and everybody else on that network

4:59has to listen like an arp request,

5:01that's an example of a broadcast.

5:02We also may have some security concerns where we wanna have

5:05a firewall or a router with an attitude

5:08with some filtering in place that's restricting

5:10certain types of traffic between networks,

5:12and so by taking one giant network

5:14and then chopping it up into, for example,

5:17three networks, network A here, and network B here,

5:20and network C here, any traffic that's trying

5:22to go between those networks has to go through

5:24a layer three device, like a router or a firewall.

5:28So there's lots of great reasons why we might

5:30want to carve up our networks into smaller sections,

5:33or another example would be, we have an internet

5:36of things subnet for all of our internet things devices,

5:39because we want to keep them separate, for example,

5:41from our servers.

5:42So we could have one subnet

5:43that has all of our internet of things devices,

5:45we have another subnet maybe with our servers,

5:47and yet another subnet for a specific group in the company,

5:51like human resources or sales or some other department,

5:54and for the main emphasis of this video

5:56regarding how we're gonna do that,

5:58we are simply gonna go ahead and move

6:00to the right the mask,

6:02meaning the mask boundary.

6:03So currently if the mask boundary is right here,

6:05that's where all the one's stop in the mask,

6:07we're simply gonna go ahead and extend that mask

6:10and we're gonna take some of these bits that previously

6:13are gonna be used for host addressing

6:14and instead of allocating all of those for host addressing

6:17we're gonna take a few more of those

6:19to use for creating logical subnets.

6:21So let me give you an example of exactly

6:23what that looks like, so let's imagine

6:25that instead of having the mask right here

6:28between the 24th bit and the 25th bit,

6:31let's move the mask right here.

6:34And one of the important aspects is how do you

6:36indicate that you've moved the mask?

6:37And that is you just change the value here,

6:39so instead of this being a /24, which it was,

6:42now if we have three more bits, it'd be 25, 26, 27.

6:45So I'm gonna go ahead and simply modify that to 27

6:48for the mask and that also means that in binary

6:50the mask would change to this.

6:52It'd be three bits that are on there

6:54and then the remaining five bits would still

6:56be left as zeroes indicating that's the new dividing line.

6:59So we have this parent address space of 10.67.83

7:03and now we have additional bits here

7:05in this fourth octet, specifically these three bits

7:08right here that we can now play with

7:10and create logical subnetworks

7:12and also before we leave this video,

7:14I like to confirm that thought regarding moving

7:16the masks to the right, let's imagine we have

7:19a /16 mask

7:20and we want to move the mask three bits to the right.

7:24What would the new mask be

7:27in a slash notation?

7:28This is also sometimes referred to as a sider notation

7:31for classless interdomain routing.

7:33So that's the fancy way of saying that representation

7:35of the mask, but if we had a /16 bit mask

7:37and we're adding three more bits

7:39above and beyond that, the new mask would be 19,

7:42or if we started with a /22, and we need to add

7:46five more bits for the benefit of using IP subnetting

7:50and the new mask would be 22 plus five more,

7:52which would be 27.

7:54If we are going to do custom subnetting

7:56and create logical, new subnets from a parent network,

7:59the key is we are gonna move the mask to the right

8:03one or more bits, and whenever we configure an IP address

8:06on a device, we'll just simply specify that new mask.

8:09And that way the computers and the routers

8:10and the other devices that are using IPv4,

8:12they know exactly where that dividing line is.

0:00<v ->So from the previous video,</v>

0:01we now know that if we're doing custom subnetting,

0:03we're gonna take the original mask

0:05and we are going to grow it by one bit or by two bits

0:09or by three bits or by four bits.

0:11But where are we taking them away from?

0:13If we're starting here,

0:14that means we're taking bits that used to be used

0:17for host addressing and we're now allocating them

0:20to the network address portion.

0:22So if this was the original mask

0:24and there was eight bits left over for host addressing,

0:26and now we've moved the mask five positions,

0:29meaning adding five bits.

0:30So one, two, three, four, five.

0:32So the new mask is right here.

0:34So if it was a /24, it'd now be a /29.

0:37And then we'll go ahead

0:38and reflect those bits being on in the mask.

0:41So the new mask in dotted decimal would be 255 here.

0:44And here, it'd be 255, meaning all eight bits are on.

0:47And then here, it'd be 255.

0:49And then for this octet, we have a few options.

0:51Number one is we could just memorize what five bits

0:53on looks like with the last three bits off,

0:56or we could just go ahead

0:57and do a binary to decimal conversion.

0:59And that would look like this.

1:00It's this one, this one, this one, this one, and this one,

1:03and the other three are zeros like that.

1:05So to convert from binary to decimal,

1:08we'd simply take the values that are on,

1:10and that'd be 128 + 64 + 32

1:14+ 16 + 8.

1:17And if we add all that up, that equals a whopping 248.

1:20So our mask in dotted decimal

1:22for that last octet would be 248.

1:25So when in doubt,

1:26you can just go ahead and convert that

1:27from binary to decimal.

1:30Another really important aspect is that when we're dealing

1:32with a mask, the bits are gonna be on,

1:35on, on, on, on, on, on until they're not,

1:37and then they're not gonna turn on again later.

1:39They're gonna be contiguous, meaning in order,

1:41all ones until they stop being a one, and at which point,

1:44they go to zeros and they stay zeros all the way

1:46to the right.

1:47So you would not have something like 11111

1:50with five bits here, then a couple zeros,

1:53and then a one here.

1:54That's not a valid mask that we can use for an IP address.

1:58And because we're only dealing with one octet

2:00of data at a time as we represent the masks,

2:03let me share with you a little shortcut

2:04to remember the mask values.

2:06So for the mask,

2:07we start off with 00000000 as a possibility.

2:11That was the /24 for this octet

2:13where all the mask bits were zero.

2:15And because the bits that are on have to be contiguous

2:17from left to right, if we had another bit,

2:19that next bit would be one.

2:20And if it was all zeros after that, it'd be like this.

2:23And then it'd be like this 1, 1,

2:25and then 1, 1, 1, et cetera.

2:27So if you get a pinch,

2:28you can't remember what the dotted decimal equivalent is,

2:30you can just realize that again,

2:31the bits have to be all on contiguously until they're not.

2:35So one shortcut I'd like to share

2:36with you regarding the actual decimal values

2:38for the mask is we can take this first position,

2:40for example, let's say it's a one,

2:42and then all zeros, that's gonna be 128.

2:44That's gonna be the dotted decimal mask if it's one,

2:47and then seven zeros.

2:48And then to calculate the next value, if it was like 1, 1,

2:52you simply add 64, which would be 192.

2:56And then if there's three bits that are on,

2:58it'd be plus 32, which is 224.

3:01And if there's four bits on in a row,

3:03that'd be plus 16, which would be 240.

3:06And if we had five bits in a row,

3:08that'd be plus eight, which is 248.

3:10And if we had six bits in a row, that'd be plus four here.

3:13So the result there would be 252.

3:15And if seven bits were on in this octet,

3:18that'd be plus two more, and that's 254.

3:21And if all eight bits were on,

3:23it'd be plus one, which is 255.

3:25So for a mask value,

3:27the only possible dotted decimal values that are legal

3:30for an octet of data for the mask are these right here.

3:33So you can either write them out just

3:34by taking the first value plus the next one,

3:36plus the next one, et cetera.

3:37Or when it came down to it,

3:38you could just do the conversion from the binary

3:41from the mask, like this one, bump, bump, bump, bump, bump,

3:44over into decimal, doing it longhand.

3:46Either way is fine.

3:47So let's go back to the original parent network,

3:49this /24, this one giant street.

3:51And if we're gonna do subnetting,

3:53we are gonna need to move

3:54that mask one or more bits to the right.

3:56The question is how many bits to take,

3:58because we are literally taking these bits

4:01that were available for host addressing

4:03and we're reallocating them for the actual new subnet IDs.

4:07And let's just start with some common sense here.

4:09Let's imagine we have eight host bits originally like we do

4:13with the /24, and we take all of them. (laughs)

4:16So we move the mask to here,

4:18we change these bits to all ones, which in dotted decimal,

4:22will look like a 255 for the mask for that last octet.

4:26And now we have a /32.

4:27So my question is, if we have a 32-bit network,

4:31how many bits do we have available for host addressing?

4:34And the answer is none.

4:36Also, as a result,

4:38we don't have any room to put any possible hosts

4:41on the new network.

4:42So taking all the possible host bits and allocating 'em

4:45for the network is not a reasonable thing to do

4:48because we're not gonna have any host addressing space left.

4:51So regarding how many bits to take,

4:52we wanna take enough bits over here

4:54from the available host bits portion

4:57to support the number of new subnets that we need.

4:59And it's not a one-to-one mapping.

5:01For example, it's not, oh,

5:02if we take one bit from the host addressing,

5:05that means we can create one subnetwork.

5:07And that's because bits are in binary.

5:09They can be a zero or a one like a light switch.

5:11That means we could have zero or one,

5:13and that's two possible combinations.

5:15So effectively behind the scenes,

5:16that means that we can create two subnets

5:19by simply borrowing or stealing, I should say,

5:21one of the available host bits and allocating that

5:24to the actual network addressing space.

5:26So based on starting with a /24,

5:28this would be a /25 that could give us two new subnets.

5:31And if we take two bits, the /24 would now be a /26.

5:36Simply adding two to that.

5:37And with two bits, here's the combinations.

5:38We have the two bits that could be both be zeros,

5:41we have the bits could be like this

5:43or like this or like this.

5:45So if we take two bits,

5:46we could actually have four new subnets.

5:49And let's do one more example.

5:50Let's imagine that instead of taking two bits

5:53from the available host portion, we wanna take three.

5:55So if we have a /24 to begin with,

5:57we add three bits to that, that'd be a /27.

6:00And with three bits, we could have this combination,

6:03and we could have this combination,

6:05and we could have this one and this one and this one

6:08and this one and this one and this one,

6:11which is eight possibilities.

6:13So if we take three additional bits above

6:15and beyond the starting point here,

6:17we can create quantity-wise eight sub-networks

6:21because of the number of bits that we have to play with.

6:23And so when it comes to the question of quantity,

6:25for example, how many I came up?

6:27Well, probably more than a decade ago,

6:29I came up with this idea,

6:30this concept called the finger game.

6:33And I'd like you to play it with me right now,

6:35and it's terrific.

6:36Anytime you need to deal with the idea of quantity

6:39and how many bits should I take or how many bits are there,

6:42we can simply use the finger game.

6:43And it goes something like this.

6:44I'm gonna take a sharpie right here.

6:46And on my thumb, I'm gonna write down the number two.

6:49So funny story, yesterday I was gonna film this,

6:51so I actually put this on my thumb yesterday

6:53and then I forgot it was there,

6:54and I went out to a show last night

6:55and I got some strange looks when people saw my finger

6:58with a number two on it.

7:00So now that I have a number two on my thumb,

7:02I'd like you to imagine that your fingers represent bits.

7:05So how many bits do I have up? No bits, right?

7:08So let's imagine we didn't take any additional bits

7:10from the host portion, and as a result,

7:12we can't create any subnets.

7:13So our fingers are gonna represent bits.

7:16And the reason I'm putting a two on my thumb,

7:17which I'd like you to imagine as well,

7:19or if you wanna get into it,

7:20go ahead and put a two on your thumb as well,

7:23because what we're gonna do is we're gonna use our fingers

7:24to represent bits, and then we're verbally gonna count

7:28and specify how many new subnets we can create.

7:30And the starting point,

7:31which is probably the hardest part for most people,

7:33the starting point is to put your thumb in the air

7:35and you say two, that's the starting point,

7:37because one bit, again,

7:39our fingers and digits are representing bits.

7:41And with one bit being an on or off,

7:43we can have two possible subnets.

7:45So that's the starting point,

7:46and that's the hardest part of this game.

7:48And then if you need more than two subnets,

7:50we're gonna bring up another digit.

7:52So you bring up another digit

7:53and you simply double the number you spoke earlier.

7:56So if we started with a two and we double it,

7:58it would now be four.

7:59And if we bring up another digit,

8:00so there's our third digit,

8:01we simply double it again and we'd say eight.

8:04So we're just doubling two, four, eight.

8:06If we bring up another digit, that'd be 16.

8:09If we bring up another digit, that'd be 32.

8:12And we can continue that by using our other hand going

8:14to six and seven and eight and so forth.

8:16And that's the finger game.

8:17So anytime there's a question of quantity,

8:20for example, how many bits are gonna be required

8:22to make a certain number of subnets?

8:24Just think finger game.

8:25So let's go ahead and practice a few.

8:26Let's imagine that you and I have been given the task

8:28of creating three new subnets.

8:31So we've been given some parent network

8:33with an existing mask.

8:34My question is quantity-wise,

8:36how many bits do we need to take above

8:38and beyond the original mask?

8:40And the answer is the finger game.

8:41So if we need three new subnets,

8:43you put your first digit in the air and that'll give us two.

8:46It's not enough, so we bring up another digit

8:48and double the number as four.

8:50Hey, that's enough.

8:51So to create three new subnets,

8:52all we need to do is take two bits that were host bits

8:56and allocate them over for subnetting.

8:58And the way we do that is simply

8:59by moving the mask two bits.

9:01So let's do one more quantity question

9:02together regarding subnets.

9:03Let's imagine that you and I have stepped

9:05into the office one day

9:07and the manager says, "Hey, guess what? We need 30 subnets."

9:10So our question is how many bits do we need to allocate

9:13that were host bits and allocate them over for networking?

9:16So let's do it, so here is one bit that represents two,

9:19and that's not enough for 30.

9:21So we bring up another digit, and that's four, not enough.

9:24We bring up another digit, that's eight.

9:26Bring up another digit, that's 16.

9:27So we bring up another digit, and that's 32. You know what?

9:30We have a little bit extra room,

9:32but we have enough for 30 subnets.

9:34So my question is this,

9:35how many bits that were gonna be host bits do we need

9:37to reallocate for the purpose of subnetting?

9:40If you're saying, "Keith, you're holding up five,"

9:41you'd be absolutely right.

9:43So this finger game is a great opportunity

9:45to easily determine how many additional bits we need

9:48to use for subnetting based

9:50on how many new subnets we need to create.

0:00<v ->So our next step in this process is to identify,</v>

0:02okay, what exactly are the new subnets

0:05that we get when we allocate, for example,

0:07two or three or four additional bits

0:09for the purpose of subnetting?

0:11And so to bring this point home,

0:12let's imagine that we've been given this parent network

0:14of 10.67.83.0 with a 24-bit mask.

0:18And let's imagine that the requirement is,

0:20we need 10 new subnets.

0:23Perhaps we want one for our Internet of Things devices,

0:26we want one for our human resources department,

0:28we have one for our servers, and so forth.

0:30So if we need 10 new subnets, and there's our original mask,

0:34how many bits above and beyond the /24 do we need to take

0:39to go ahead and create up to 10 new subnets?

0:42So based on our previous video,

0:44to calculate how many bits we're gonna take

0:46to create 10 new subnets, we play the Finger Game.

0:48And we put up our thumb, so two subnets is not enough.

0:51We bring up another digit, we double it.

0:53That's four, not enough.

0:54We bring up another finger, that's eight,

0:56also not enough to reach 10.

0:58So we bring up our fourth digit, and we go to 16.

1:01That'll support it.

1:02So to pull this off, we need four additional bits

1:05above and beyond what the current mask is

1:07to support up to 10 subnets.

1:09And it'll give us 16 new subnets. That's okay.

1:12But we need at least four bits that we're gonna use

1:14to create at least 10 new subnets.

1:15So if we have a /24 and we're increasing it by four bits,

1:19that's gonna go ahead and be a /28.

1:21So that'll be our new mask.

1:23So this is now going to be a /28.

1:26And so the mask is gonna have those four bits on,

1:30representing that this is the new dividing line.

1:32And in dotted decimal for the mask, this would be 255.

1:36And the second octet for the mask here would be 255.

1:38And the third octet for the mask would still be 255.

1:41And this fourth octet for the mask would be 1, 2, 3, 4 bits

1:45that are on, these bits right here, and these bits are off.

1:48So we could manually just say 128 plus 64 plus 32 plus 16.

1:52Or if we wrote out the chart with the mask,

1:54we do 128, 192, 224,

1:57240, 248, 252, 254, and 255.

2:03So the mask here would be 240 for that fourth octet.

2:07And that's dotted decimal

2:08representing that these first four bits are on

2:10and now gonna be used as part of the network addressing.

2:13So I'll go ahead and put that here as well.

2:15And again, our goal here is to create 10 new subnets.

2:18Now, if an individual happens to be, like, a genius

2:20or an expert in math and binary,

2:23they can do a lot of these calculations

2:25without even writing anything down.

2:27And I work with several people like that. They're amazing.

2:30However, for the average human, like myself,

2:32I'd like to share with you a pretty easy way

2:35to identify what those new subnet IDs are.

2:39And it starts by taking a look at the last bit here

2:43in the mask which is on.

2:44So all these bits here are on in the mask,

2:47all of 'em here, here.

2:48And these first four bits of this last octet

2:50based on our new mask, those four bits are on.

2:53And the least significant bit,

2:54the lowest valued one right here, is in this position.

2:57So I'm gonna write out this mask here, under our chart.

3:01And just to be consistent, there is the dividing line

3:04between the network bits here on the left

3:06and the host bits here over on the right.

3:09So to calculate the new subnets,

3:10because the 10 and the 64 and the 83

3:13are all locked in stone, they're not changing,

3:15the first three octets are gonna be identical.

3:18So we can just write them out.

3:20So for the new /28 networks,

3:21they're all gonna start with 10.67.83.

3:26And then the question is, okay, what are the new subnets,

3:29because we're now including these four bits?

3:32And for the first subnet that we have with this new /28,

3:36the secret of that is that it looks like

3:38the actual parent network.

3:40Think of it like a clone.

3:41So if this one is 10.67.83.0,

3:45the first new subnet would also be 10.67.83.0

3:50but have that new mask of /28.

3:52And the reason I point that out

3:53is because sometimes just starting is the hardest part.

3:56And so if you just write out the parent network

3:59with the new mask, that's your first subnet.

4:02Let me also in binary show you why

4:03that would be the first subnet.

4:05So up here, this represents the mask.

4:07And then below it, I'm gonna write down the subnet.

4:09So just for those four bits,

4:10if those four bits are starting with 0000,

4:15again, the dividing line hasn't changed,

4:16and these last bits are still available

4:18for host addressing, last four.

4:20So for these four bits, they're right here.

4:21We have zero 128s, zero 64s, zero 32s, zero 16s.

4:24And that's why this is zero. It's the starting point.

4:27So that's our first subnet.

4:29And then for the second subnet,

4:30the first three octets are locked in stone,

4:32so they're not gonna change, 10.67.83.

4:36However, for our next possible combination here,

4:38for this second subnet, it would be like this:

4:410001.

4:43We're just doing counting in binary.

4:45So if the first four bits of the subnet is 0001, like that,

4:50the value in decimal of that would be no 128s,

4:53no 64s, no 32s, but a 16,

4:56so the next subnet would be 16.

4:58And then for the next subnet,

4:59it would look like this in binary: 0010.

5:02So lemme update our address up here.

5:04So that's a 1 in that position.

5:06So if we look at that in decimal,

5:08that'd be no 128s, no 64s, one 32, and no 16s,

5:12so the next subnet would be 32.

5:15And let's do it again. So we have a 0011.

5:18So here's the binary with 0011.

5:21And the value in decimal for that would be no 128s, 64,

5:24we have one 32, plus 16 more, which would be 48,

5:28and the first three octets stay the same.

5:30And what is changing is these bits as we continue to count.

5:33So I'm gonna share with you a shortcut here

5:35in calculating the subnets.

5:37You simply take the mask,

5:39and you go all the way down until all the ones stop.

5:42And we're gonna take a look at that bit position

5:44where the last one in the mask is on,

5:46right at the dividing line.

5:48So in our case, that's the 16 value,

5:50and that's our block size.

5:51I usually call that BS, for block size. (laughs)

5:54No, really, that's what I refer to it as.

5:56So any networks that we have are gonna be 16 plus 16 plus 16

6:00because that's the value of the least significant bit,

6:02and that's how the binary works.

6:04So for the first subnet,

6:06it's gonna look like the parent subnet with the new mask.

6:08And then for the next subnet, you simply add 16.

6:11And for the next one

6:12in that same octet that we're dealing with,

6:13you simply add 16 and add 16 and add 16.

6:16And we just keep doing that.

6:17And eventually, we're gonna have a listing,

6:18if we go far enough, of all 16 new possible subnets,

6:22even though we only need 10.

6:24We're using four bits,

6:25which gives us a total possible 16 subnets

6:29that we can go ahead and play with.

6:30So I'd like to pose a question for you.

6:32If we were to take a look at the very next subnet,

6:34which would be 10.67.83.,

6:39what would be the next subnet?

6:41And there's a hard way and an easy way

6:43to calculate that new subnet.

6:44So the hard way, I think, would be to go to binary

6:47and say, "Okay, outta these four bits,

6:48the next bit position would be 0100."

6:52And that's if you're comfortable

6:53doing the counting with binary.

6:55And then based on this, you can take the values that are on.

6:57So we have a bit here in the 64 position,

7:00and the 128 and the 32 and 16 are all off.

7:02So that means that this subnet is 64.

7:05But I think a better way of doing that

7:06was simply to take this block size of 16

7:09and simply add 16, add 16, add 16,

7:12and that will give you your next

7:14and next and next and next subnets.

7:15So because we now have a /28,

7:17you take the last bit that's on in the mask,

7:19find out what that corresponding value is,

7:21and that's your block size.

7:22So as a quick test of that, let's just go ahead

7:24in this little section right here, let's use a new scenario.

7:27Let's say we have a /17 mask,

7:30and we're gonna use four additional bits

7:33to do custom subnetting.

7:35So my question for you is, what would the new mask be?

7:38Now, if you're saying, "Keith, I got this.

7:39It's 17 for the original, plus 4 more,

7:42and that's a whopping /21."

7:45So if we have a /21,

7:47what would the least significant bit be?

7:50The final one in the mask, what is its decimal value?

7:53So here, I have four, eight.

7:55This is 16, 17, 18, 19, 20, 21.

7:59We are in this position right here.

8:00So if that was the mask right here

8:02and that was the last bit that was on in the mask,

8:04that bit value has a value of eight.

8:08So for our subnets,

8:09the first subnet would look exactly like the parent network

8:12except with a new mask.

8:14And then for the next subnet, we'd add eight.

8:16And then for the next subnet, you'd add eight.

8:18And this time, we'd be adding eight to this third octet

8:21because that's where the dividing line is.

0:00<v ->So here's our first five subnets.</v>

0:02So for this video, I'd like to chat with you about

0:04what exactly are the ranges of addresses

0:07for each of those subnets.

0:08And if that's help reinforce this,

0:10I'm gonna walk you through it in binary

0:12for a couple of them.

0:13And then I'm gonna show you a really simple

0:15and easy way to do this that doesn't require the binary,

0:18but I want you to see it in binary,

0:19that we have a big picture, look at what's really happening.

0:22So let's focus our attention on these last four bits

0:24that we're gonna be using for host addressing.

0:26So the possible combinations here

0:28for these last four bits would be 0000.

0:31I'll start off with the easy ones.

0:32And then for the next possible combination in order

0:34we'll do 0001, and then 0010, and 0011 and 0100,

0:41and 0101, and 0110, and 0111.

0:47And then we go ahead and have a 1000.

0:49And that's gonna continue.

0:50And when it comes to the host bits,

0:52we have a similar process with the finger game.

0:54If you have four bits available for host addressing,

0:57you can use a game like the finger game

0:58to get an approximation with how many

1:01different hosts can fit in that space.

1:03So here I've just listed 1, 2, 3, 4, 5, 6, 7, 8

1:07of the 16 possible combinations for host addresses.

1:12But an easier way, rather than going to binary

1:14and all the possible combinations here for subnets

1:16is we could just go ahead

1:18and look at the first subnet here, which is 10.67.83.0,

1:20with the 28 bit mask.

1:23Take a look at the next subnet,

1:24which is the same first three octets, dot 16

1:27that we did in the previous video.

1:29So for this first subnet, we can see the range is starting

1:31here at this subnet, and it's gonna go up and to,

1:34but not into, this next subnet.

1:36So if the next subnet ends with 16 in this last octet,

1:40this subnet range is gonna be ending at 15.

1:43So think of it like a pizza.

1:45So we have individual pieces of pizza.

1:47And so if somebody has this piece of pizza,

1:50it is unique and separate from this piece

1:52and separate from this piece.

1:53And that's why we're not gonna have the same IP address

1:55in multiple subnets.

1:57So if we did it here for the second subnet, 10.67.83.16,

2:01it would go up to in just one less than the next subnet.

2:04So that would be 31, and for 32 it would be going up

2:07to the next subnet minus one there would be 47.

2:11And then for this fourth subnet, which is the 10.67.83.48,

2:15with the slash 28 bit mask, it would go up

2:17and butt up against this next one,

2:19which would be through 63.

2:21And we could continue that game.

2:22So this is the range for those first four subnets.

2:25And again, the process is simplified by simply looking

2:28at the next subnet and then backing it off by one.

2:31And that's the ending point of the previous one.

2:33Now, in IP addressing, something that we haven't chatted

2:36about is the concept of a broadcast address.

2:40A broadcast address in IPV four is when all the host bits

2:43are all set to a one and at the tail end of the range

2:47for each of the subnets,

2:48that is also the broadcast address.

2:51So the broadcast address for the 10.67.83.0 network

2:54with a 28 bit mask is 15.

2:57And the broadcast address for this third network

3:00right here is 47.

3:02And in the fourth subnet, the broadcast address

3:04for that fourth subnet is 63.

3:05So that's a reserved address that you can't

3:08assign to a host.

3:09In fact, if you tried to, the Cisco router,

3:12and other networking devices would complain saying, whoa,

3:14that's a broadcast address based on the IP address

3:16and the mask you gave me,

3:18all the host bits are a one that's the broadcast address.

3:20And as a result, you can't assign this

3:22for an individual computer to use.

3:24So effectively it's reserved.

3:26And while we're talking about reserved addresses,

3:29this is the network ID right here.

3:31So we have the 10.67.83.0 network,

3:33and we have the 10.67.83.16 network and so forth.

3:36And for that network address space, that's also a situation

3:39where all the host bits are zeroed out.

3:42And that's also a reserved address that you can't assign

3:45to a computer or to a Cisco router interface,

3:49because if you do, the router will complain, hey,

3:50that's the network address, it's not a valid IP address.

3:53Which leads us to the next discussion.

3:55And that is valid host addresses, meaning IP addresses

3:59that you can assign to a, like a router interface,

4:02or to a computer.

4:03And the valid host addresses within a subnet

4:05is the subnet itself plus one.

4:08So for example, this would be 10.67.83.1

4:11'cause you can't use zero,

4:12'cause that's the actual network address.

4:14And the last valid host address would be

4:16the broadcast address minus one.

4:19So the valid IP addresses we can sign on the 10.67.83.0

4:22network with a 28 bit mask would be dot one.

4:25And the last valid address there would be dot 14.

4:28And let's also calculate that for the 10.67.83.16 subnet,

4:32the first valid host would be the network plus one,

4:36which would be 17.

4:36And the last valid host address would be the broadcast

4:38address minus one, which would be dot 30.

4:41And we'll do it one more time for the third subnet.

4:43The first valid host would be the subnet ID plus one,

4:47which would be 33.

4:48And the last valid IP address there would be

4:50the broadcast address minus one, which would be 46.

4:53I also wanna point out just for a moment,

4:55that sometimes our dividing line where the mask is,

4:58sometimes it may be in the third octet or the second octet,

5:01and we're gonna save that discussion,

5:03and how to calculate that as well for our discussions

5:06on variable length subnet masking,

5:08which we're gonna put in a separate skill.

5:09So for now, I'm gonna put all the examples,

5:12where the dividing line based on the new mask

5:14is somewhere here in this fourth octet.

5:16And to finish this off here for the fourth subnet,

5:19the starting valid IP address would be the subnet ID,

5:23which is 10.67.83.48 plus one. So that'd be 49.

5:28And that'll go all the way through the broadcast address

5:30for that subnet minus one.

5:32So that'd be through 62.

5:34So starting with a slash 24,

5:36and then taking four additional bits,

5:38and making it a slash 28, we've identified our subnets,

5:41or we've listed here are the first five of those.

5:44We've identified the range of addresses for those subnets,

5:46including the network address itself,

5:48and the broadcast address for each of those subnets.

5:50And then the valid host addresses that we can use

5:53inside of each of those subnets.

0:00<v Instructor>So in this video I'd like to chat with you</v>

0:01about how many possible hosts can fit on a given subnet.

0:06Now, one way of identifying that would be

0:07to write out the subnets, including the ranges,

0:10and then the first valid host address,

0:12which is the subnet plus one,

0:14and then the last valid host address,

0:16which is the broadcast minus one,

0:18and then manually counting those.

0:19But let me share with you a much better way of calculating

0:23quantity,

0:24and anytime an IPV4 addressing

0:26that I talk about quantity, I want you to think

0:29of the finger game.

0:30And the finger game is all about using our fingers

0:33and digits to represent bits,

0:35and verbally counting, starting

0:37with a two and then doubling that.

0:39So fingers and digits represent bits.

0:41And then we're speaking the actual quantity we can get

0:44based that number of bits.

0:45So let's imagine that we have four bits

0:48available as we do here.

0:49So if we're using a slash 28 for the network portion,

0:52we only have four bits left over for host addressing.

0:55So if we had four bits available for host addressing,

0:59how many possible combinations can we get with four bits?

1:03And the answer to that, my friend, is the finger game.

1:06So let's do this together.

1:07If we have four bits, we're gonna start off with a thumb,

1:10and with a number two on it.

1:12So with one bit, we have two combinations,

1:14and we're simply gonna play the finger game

1:16until we get to four bits.

1:17So 2, 4, 8, 16, stop.

1:21So with four bits, we have 16 possible combinations.

1:24What if we had seven bits for host bits?

1:27How many possible hosts could we have?

1:29Finger game, 2, 4, 8, 16, 32 64, 128.

1:33That's it. We can have 128 possible combinations if

1:36we have seven bits.

1:38So the finger game is useful a couple different times.

1:41Number one, if we're calculating how many bits to take

1:44for subnetting.

1:45So we use the finger game to calculate how many bits,

1:47and how many possible subnets.

1:49It's also super convenient when we come to hosts.

1:52We're looking at the host bits at the far right

1:54end of the IP address.

1:55And we're curious, based on a number of host bits,

1:57how many possible hosts we can have.

1:59The finger game, again, is a great solution

2:01with one little caveat, and that is

2:04because we cannot use the actual network address space

2:07or the broadcast address.

2:09You gotta do the finger game for host bits,

2:11and how many possible hosts.

2:12And then when you're done with the finger game,

2:14you do minus two 'cause you can't use the network

2:17or broadcast addresses.

2:18And let's do one more. Let's imagine that we have three bits

2:21that we have available for host addressing.

2:24How many possible hosts can we support

2:26with just three bits left over for host addressing?

2:29So we put our thumbs up, start with a two,

2:31and then we add a four, and then go to eight.

2:33Stop. That's three bits.

2:35So that's eight possible combinations.

2:37Can't use the network or broadcast address.

2:39So effectively it's eight minus two

2:41for those two reserved addresses.

2:42So that gives us six possible valid host addresses,

2:45if we only have three bits available for host addressing.

0:00<v Instructor>In this video,</v>

0:01I'd like to walk through a scenario

0:02where we've been given a network address base

0:05of 10.67.83 with a 24 bit mask.

0:08So above this line right here,

0:11this is the original network that we've been given.

0:13And let's imagine for our scenario

0:15that we need to create 16 new subnets.

0:17So with that in mind,

0:18our first step would then be to play the finger game

0:20regarding how many bits we need to move the mask.

0:23And upon doing the finger game,

0:24I have four fingers in the air.

0:25So that's four bits

0:27that we need to go ahead and move the mask by.

0:29So here in the first subnet,

0:30I've represented the fact that we are moving from a /24

0:33to a /28,

0:35which is four additional bits.

0:37So I've also represented what that mask looks like now.

0:39So prior in the mask, it stopped here

0:41and these bits were all available for host adressing.

0:43But now with the new mask of /28,

0:46the dividing line is right here.

0:47So for the first subnet, these four characters are all 0.

0:50And for the next subnet, we are then going 0001,

0:53and then it'd be 0010, et cetera, et cetera, et cetera,

0:56all the way through our 16 new subnets.

0:59Also in the videos as part of the skill up to this point,

1:01we also identified that the least significant bit

1:04of the mask in this case is this bit right here.

1:06If we look at that in binary,

1:08the bit value for that last bit that's on

1:10has a value of 16,

1:12also called the block size.

1:14And simply by using that,

1:16we can calculate the additional subnets.

1:18And now that we know the block size is 16,

1:20as we write out these new subnets,

1:22the first subnet, again,

1:23looks just like the parent subnet,

1:25except it has a longer mask.

1:27So if this is 10.67.83.0,

1:30the first subnet's gonna be 10.67.83.0,

1:33but the mask is gonna be the new mask.

1:35And that's because of all these bits right here

1:37that are now part of the network addressing space,

1:39they're gonna all be zeros.

1:40And that's our first subnet.

1:41And a long time ago, maybe a decade or more ago,

1:44they referred to this first subnet as subnet 0,

1:47because all of the subnet bits here are 0.

1:50We don't hear that too much anymore.

1:51But if you're looking at some old content

1:53and it talks about subnet 0,

1:55there's somebody talking about the first subnet.

1:57So I'm gonna make a note

1:57that these are all gonna be with our new mask /28.

2:01That's where the dividing line is.

2:02And because that first octet is not gonna change

2:04for any of our subnets,

2:05I'm just gonna put a little x

2:06to indicate that that is the same value

2:09and it's in this fourth octet where things are gonna change.

2:11So for our first subnet, from a numerical perspective,

2:14it looks like the parent subnet,

2:16except it's gonna have the new mask of /28

2:18to indicate we're using the first 28 bits as the network,

2:21leaving the last four bits for host adressing.

2:23So then based on the block size,

2:25and that's in the value of 16

2:26for this last octet here was simply a 16.

2:28And then we'll add 16 more, which is 32,

2:31we'll add 16 more, which is 48.

2:34So be careful we're not doubling each of these.

2:36We're simply adding the block size, add, add, add.

2:39And then for the range for this 10.67.83.0 network,

2:43it would butt up all the way next to the next subnet.

2:45So it would be ending in .15,

2:49and that'd be the broadcast address.

2:50And then the 16 subnet would be going all the way up to,

2:54but not including the next subnet.

2:55So that's gonna be 31, so 0 through 15 there,

2:5816 through 31.

3:00Then 32 is gonna go through 47,

3:02which is one less than the next subnet.

3:04And then subnet 48 gonna go all the way up to,

3:06but not including 64.

3:07So that'd be a do .63

3:09and we can continue that as well to figure out our ranges.

3:12Also for this range,

3:13the last one in the range is the broadcast address.

3:16So it's reserved, you can't assign it to a host.

3:18And this first address in the range

3:20represents the actual network.

3:21Think of it like the street.

3:22So it's street 10.67.83.0/28

3:26and street 10.67.83.16/28 et cetera, et cetera.

3:30So these are the street names or network IDs themselves

3:33for our subnets.

3:35So here, if we put valid hosts,

3:37meaning valid host addresses on each of those subnets,

3:40it would be the subnet plus one,

3:42which is the first valid host address.

3:43So for this subnet, it'd be .1

3:46and the last valid host address

3:47would be the broadcast address, which is reserved,

3:49minus one.

3:50So that'd be .14.

3:51And then for the 16 network, it'd be .17 through 30.

3:55And for the 32 subnet it would be 33 through 46.

4:00And for the 48 network, it'd be 49 through 62.

4:04And if we're ever curious, okay,

4:05how many hosts will fit on a given subnet?

4:08You simply take a look at how many bits are available.

4:10In this case, there's four bits for host addressing

4:12and it's the finger game.

4:14So we bring up our fingers,

4:15we calculate based on those bits, what that quantity is.

4:18So it's the finger game regarding host quantity minus two.

4:22Because we can't assign the actual network address

4:24like the street name or the actual broadcast address

4:27on one of those streets

4:28to an individual interface on an IPv4 network.

4:31In fact, I think it'd be very, very valuable

4:33for you to see what it looks like

4:35if we were to try to assign

4:37any of these network address spaces

4:39or the actual broadcast addresses

4:42to an individual interface.

4:43So as a demonstration,

4:44I'd like to go ahead and attempt

4:46to assign this second network address space of 16

4:50to an interface.

4:50It'll complain, it won't let us do it.

4:52Let's also go ahead and try to assign

4:54the IP address of 10.67.83.31

4:57to an interface with the /28.

4:59And it's gonna complain if we try either one of those.

5:02However, if we try one of the addresses of 17 through 30,

5:06it'll be fine because those are valid host addresses

5:08within that 10.67.83.16 subnet.

5:12So here's an example of that.

5:13Let's do a show ip interface brief.

5:15And this router has nothing assigned to it.

5:18Let's go ahead and take Gigabit 0/0.

5:20So we'll go into configuration mode with config t.

5:22We'll then go further into interface gigabitEthernet 0/0.

5:26Now we're in interface configuration mode.

5:28We'll do a no shutdown to bring up that interface.

5:30And then let's attempt

5:32to go ahead and assign it the network address

5:34for that 16 network.

5:36So we'll do ip address 10.67.83.16,

5:41and then we'll put in the mask of 255.255.255.

5:45That's the first three octets,

5:46and then 240 in dotted decimal.

5:49And that 240 says,

5:49"Hey, the first four bits of that last octet

5:52are part of the network address tool," press enter.

5:54And that's where it's saying that's a bad mask.

5:56So the /28,

5:57it simply says that's the actual network ID.

5:59If we hit the up arrow key

6:00and we tried the broadcast address,

6:02let me go ahead and put it in 31 here and press enter.

6:05That also is complaining.

6:07However, if we tried one of the valid IP address

6:09between 16 and 31,

6:11let's go ahead and use for example, 30.

6:14So I'll go ahead and put a 30 in that position

6:15and press enter.

6:16No problem whatsoever.

6:18And we'll type in end

6:19and then a show ip route and press enter.

6:21And here it's showing us

6:23that we are directly connected to this 10.67.83.16 network

6:28with a 28 bit mask.

6:29So just as a confirmation,

6:31we cannot assign the actual network address space

6:34or the actual broadcast

6:35on one of those networks to an interface.

6:37So based on the subnets and the ranges,

6:41if we wanted to test and verify this,

6:43we could actually implement these subnets on our network.

6:46So let's go ahead and use the following three subnets.

6:49The first, second, and third.

6:50The 10.67.83.0

6:52we'll have is this network right here.

6:54The 10.67.83.16 we'll have is this network here.

6:57And for the 10.67.83.32 network with the 28 bit mask,

7:00we'll have this one right here.

7:02So I've currently got Router 1 and Router 2.

7:04They don't have any IP addresses assigned whatsoever.

7:06So let's imagine that we wanna give R1

7:09the first valid host address on each of those subnets.

7:12So I'll go ahead and label that first.

7:14So on the 10.67.83 network,

7:16that'd be .1 over here, I'll note that.

7:19And then on the 10.67.83.16 subnetwork over here

7:23off Gig 1/0.

7:25If we give it the first IP address on that subnet,

7:28that would be .17.

7:30And then over here on R2,

7:31let's give R2 the second valid IP address

7:33on each of those subnets.

7:34So for this network segment, 10.67.83.16,

7:38the second valid IP address would be do .18.

7:41So the first valid address is 17, the second would be 18.

7:44And then over here on the 10.67.83.32 subnet,

7:47if we stuck with the same logic

7:49of using that second valid IP address

7:52over here on the 32 subnet,

7:53the first valid IP address is 33.

7:55So the second valid IP address would be 34.

7:58And then for the client over here on this 10.67.83 network,

8:02let's go ahead and just for fun,

8:03let's give it the last valid IP address

8:06on the 10.67.83 network,

8:08which if we look at that network,

8:09the last valid IP address is .14

8:12that we can assign to a host.

8:13And on this client PC,

8:14we'd also specify for a default gateway

8:16to use this IP address of R1 on its Gig 0/0

8:19as its default gateway.

8:21That's if the client ever needs to forward packets

8:23off of its local network.

8:24So with that game plan in mind, in the next video,

8:27let's walk through the configuration and verification

8:30of our IP Subnetting plan.

0:00<v Instructor>All right, in the previous video</v>

0:01we put a game plan together.

0:03In this video, we're gonna execute on that game plan

0:05by going to our routers, router one and router two,

0:07configuring the IP addresses in each

0:09of those respective subnets

0:10and configuring the client PC

0:12with an IP address on the 10.67.83.0 subnet.

0:16So let's go over to router one and let's get to work.

0:19So here on router one, we'll start

0:20by doing a show ip interface brief

0:23and everything is down, fantastic,

0:26and there's no IP addresses.

0:27So let's go ahead and go into configuration mode

0:29with configure terminal

0:31and then further go into interface gigabit 0/0

0:34and then here at interface gig 0/0,

0:35we'll do a no shutdown command to go ahead and bring it up.

0:38And then we'll also assign the IP address based on our plan,

0:40which is IP address 10.67.83.1

0:46with a 28-bit mask.

0:48So in dotted decimal,

0:49a 28-bit mask looks like 255.255.255.240.

0:55That's the first four bits of that last octet

0:57being on in the mask.

0:58And we'll press enter and it said,

1:00"Hey, Keith, you have a little typo there."

1:02So I typed in 225 for that third octet

1:04and it's showing me here that that's no good.

1:06The bits in a mask have to be contiguous,

1:09meaning on, on, on, on until they're off,

1:11until let me hit the upper arrow key.

1:12I'll go back and I'll change that 225 to 255, press enter

1:16and we are good to go.

1:17Then we'll go to interface gigabit 1/0.

1:20We'll do a no shutdown there.

1:22So now that's coming up.

1:23We'll give the IP address

1:24on the 10.67.83.16 network of 10.67.83.

1:30And the first valid IP address on that subnet is 17.

1:33And then we'll specify the same 28-bit mask

1:36and we'll do that in dotted decimal.

1:38That looks great.

1:39So after typing in end, we'll do a show ip interface brief,

1:42press enter just to confirm that those two interfaces

1:45are both up

1:46and they have the addresses that we planned on.

1:48Also, we gonna do a show ip route

1:50and that will also confirm for us

1:51that we have this directly connected network of 10.67.83.0

1:55with a 28-bit mask

1:57and also a 10.67.83.16 with a 28-bit mask.

2:01Fantastic. Let's go on to router two.

2:03So here on R2, we'll do a show ip interface brief

2:06just to confirm where we're starting at.

2:08So we wanna configure gigabitEthernet2/0

2:12to be on the 10.67.83.0 subnet.

2:15That's the same one that R1 is on.

2:17And then its gigabit 0/0 interface

2:19will be on the 10.67.83.32 subnet.

2:23So let's go into configuration mode

2:24by typing in configure terminal.

2:26Let's start off with gigabitEthernet2/0.

2:29So we'll type in from global config,

2:30we'll type in interface gig 2/0 and press enter.

2:35Then here, we'll do a no shutdown to bring it up

2:37and then we'll assign it the IP address

2:39with the command ip address.

2:42And for the IP address, it's gonna be 10.67.83 dot,

2:47and this is the 16 subnet.

2:49And we're looking for the second valid IP address

2:52on that subnet.

2:53So that is gonna be 18.

2:55And then we'll put in the mask of 255.255.255.240

2:59to represent a 28-bit mask and press enter.

3:02And then we'll go over to interface gig 0/0

3:05by typing in interface gig 0/0

3:08and doing a no shutdown.

3:10And then we'll give it the IP address of 10.67.83

3:15and this is the 32 subnet.

3:16We're looking for the second valid address on the 32 subnet,

3:19which is 34.

3:21And we'll put on the 28-bit mask just like that

3:24and press enter and then we'll type an end

3:27and then we'll verify our work with a show ip route.

3:30Or we could have also done a show ip interface brief first,

3:32but the routing table's also gonna tell a tale.

3:35So here we have a directly connected network, 10.67.83.16

3:39with a 28-bit mask.

3:41That's the right subnet that's connecting over to R1

3:45and the 10.67.83.32, and that is also correct for gig 0/0.

3:49So let's go ahead and do a show ip interface brief

3:52and that'll confirm the actual IP addresses

3:54involved as well.

3:55So there's gig 0/0 and there's gig 2/0.

3:58And then let's also now configure our client PC

4:01with the IP address 10.67.83.14 with a 28-bit mask

4:05and a default gateway saying to use 10.67.83.1.

4:10So let's go to the client PC right now

4:12and finish it up and do a quick test.

4:14So here's the client PC.

4:15Let's go ahead and open up a command prompt

4:17and do ipconfig.

4:18See where we're starting from.

4:19Looks like its interface is down,

4:21there's nothing showing here regarding IP addressing.

4:23So we'll type in ncpa.cpl,

4:26a quick way of getting to the control panel for networking.

4:28We'll right click on this NIC 10.10 interface.

4:30We'll enable it and then we'll go ahead

4:32and once it's enabled,

4:34we'll right click on that interface again.

4:36Go to properties

4:37and we'll double click on the IPv4

4:39to configure the properties of IPv4

4:41with a specific address of 10.67.83 dot,

4:46and based on our plan, we're using 14.

4:48And then for the mask, it's 255.255.255.240.

4:52And then for the default gateway, it's 10.67.83.1.

4:57And okay, and we'll go ahead and close that.

5:01So in the background, I have a routing protocol running.

5:03So the two routers know

5:05how to forward packets back and forth.

5:06So from this PC, we should be able

5:08to ping this interface right here on R2,

5:11which is 10.67.83.34.

5:15So let's use that as a test.

5:16Unfortunately, because we just changed

5:18all the IP addressing, the other devices in this network

5:21have the incorrect IP addresses

5:23and as a result won't be able

5:24to communicate all the way across the network

5:26until we change them.

5:27So for now, let's ping from the PC

5:29to router two's gig 0/0 address, which is 10.67.83.34.

5:35So here at the client, let's go ahead

5:36and do a ping to 10.67.83 dot,

5:40and it is 34 and we'll press enter.

5:43So that looks great. The ping works.

5:44Let's also do a tracert, which is on Windows

5:48how we spell traceroute.

5:49We'll go ahead and do a -d

5:50for don't bother doing reverse lookups for DNS.

5:53And let's put in that same target of 10.67.83.34,

5:59and press enter.

6:00So this is showing us that the first hop

6:02was our default gateway, R1, at 10.67.83.1,

6:06and then the next top was 10.67.83.34.

6:09So now that we've taken a look at building

6:12and actually implementing

6:13and verifying an IP subnetting plan,

6:15in the next video,

6:16I'd like to present a hands-on lab that you can use

6:19to get practice both with subnetting

6:21and applying that subnetting configuration

6:23on a Cisco router.

6:25So I'll see you in the next video in just a minute.

0:00In this hands-on lab, we have the opportunity to do both a planning phase for

0:05subnetting

0:05and then to actually apply IP addresses based on our plan.

0:09So this is the topology we're going to be working with.

0:11And the parent network is the 1067.83 network with a 24-bit mask.

0:16And from that network address space, we want to create nine subnets.

0:21As far as where the subnets are going to be used, we're going to use the first

0:24subnet

0:24here, second subnet here, third there, and so forth.

0:29So part one of this lab is the actual planning out and the writing out of all

0:32those individual

0:33subnets, including the ranges if we want to regarding which IP addresses can be

0:38used.

0:38And then once we have that plan and we know what the nine subnets are, then

0:42like you do

0:43apply that knowledge by going to each of the routers.

0:45And I thought to myself, self, instead of having to configure all the

0:49interfaces on each router,

0:50which is a lot of work, instead, I've configured all the interfaces already

0:55except for gigabit

0:56two slash zero on each of the router interfaces.

0:59So those are right here, here, and here.

1:02So effectively, that's the interface facing the various clients.

1:06So we have client PC down here.

1:07That's our Windows 11 computer.

1:09I've got a little virtual machine called PC 20, a machine called PC 30, and the

1:13server

1:14here connected on the ninth subnet.

1:17And once again, all these subnets are already in place.

1:19However, what isn't in place is the actual IP address, the first IP address in

1:24that respective

1:24subnet to be applied to the gig two zero interface.

1:28So our one would get the first IP address in the first subnet here, our two

1:32would get

1:32the first IP address in the fourth subnet here, router three, we get the first

1:36IP address

1:37in the seventh subnet and router four, we get the first IP address in the ninth

1:41subnet.

1:42And as I mentioned, all the other IP addresses are configured and also routing

1:45is enabled.

1:46So if we are correct in our game plan for calculating what those nine subnets

1:51are, and

1:52furthermore, we're correct in implementing those IP addresses respectively on

1:56the routers,

1:56we should have full connectivity across the network.

1:59So for testing, here's what we could do.

2:01We could go to this Windows client computer right here.

2:03That's our client nug machine.

2:05It's already configured for is default gateway pointing to our ones gig two

2:08zero interface.

2:09And the server in the upper right is at 10 dot 67 dot 83 dot 130.

2:14So we should be able to ping from the client to that server.

2:17We should also be able to do a trace.

2:19And I would also encourage you on the Windows client to do a dash D is going to

2:22go a lot

2:23faster if it's not trying to do reverse lookups every hop of the way and do a

2:26trace route

2:27and it'll verify what the IP addresses are of the routers in the path as that

2:31traffic

2:31goes from the client to the server.

2:34So have some fun in calculating the nine subnets and then secondly, have more

2:39fun in

2:40configuring the gigabit ethernet two slash zero interface on each of the

2:44routers with

2:44the first available IP address in those respective subnets.

2:48when you are ready, join me in the walkthrough video.

0:00In this walkthrough, we're first going to plan out what the nine subnets are we

0:03can use using the parent network of 10, 67, 8, 3, 0.

0:07And then once we identify what those subnets are, we'll apply the first IP

0:11address from the respective subnets on each of the routers interface gig two

0:15slash zero.

0:16So here is the lab environment. Let me go ahead and open up the topology.

0:19And if we want to make that bigger or smaller, we can let me go ahead and make

0:22that a little bit bigger.

0:23In fact, let me go ahead and maximize it.

0:25And I'm going to use this as my workspace to write out the actual subnets.

0:29And then we can go ahead and minimize it and come back.

0:31So let's begin the very first thing I'm going to do is I'm going to write out

0:35my values in one byte of data.

0:37So 128, 64, 32, 16, 8, 4, 2 and 1.

0:43And that's going to come in super handy anytime we're dealing with IP subnet

0:47ting.

0:48And because we're starting with a slash 24, all these bits are going to be in

0:52the last octet.

0:53So if we need nine new subnets, we're going to play the finger game to identify

0:58how many additional bits above and beyond the 24,

1:01we need to go ahead and use four network bits.

1:04So if our goal is nine subnets, I'm going to start with my thumb and say two

1:08and then add another digit and say four and eight and 16.

1:11We need at least four more bits to be used for networking.

1:15So the mask is going to go from a 24 plus four more and that's going to be a 28

1:20bit mask.

1:21And so that would look like this one, two, three, four.

1:24So now the dividing line between network on the left and host on the right is

1:28right here at the 16 bit mark.

1:31So that's all net and over on the right, we have four bits left for hosted

1:34dresses.

1:35And hopefully that's going to be enough space for hosts on the network.

1:39But our main concern right here is carving out the nine new subnet.

1:42So as far as what those subnets are, the very first subnet from this parent

1:46network looks identical numerically.

1:48So it's going to be 10 dot 67 dot 83 dot zero, except it's going to have the

1:54new mask slash 28.

1:55And that is our first subnet right there.

1:59We simply take the block size, which is 16, the value of the least significant

2:03bit in the new mask.

2:04And we simply add that on and since we're in the fourth octet, the first second

2:08and third octets are going to stay the same for all of our subnets.

2:12But the next subnet is going to be 16 more in that last octet. So it's going to

2:16be 16. So that's going to be seven at two of 10 dot 67 dot 83 dot 16.

2:21And then for subnet three, we're simply going to add 16 more to be 32.

2:25And for seven at four, we simply add 16 more and then be 48.

2:29And then for subnet five, we simply add 16 more.

2:32So 48 plus 16 more would be 64.

2:35And then for subnet six and subnet seven and seven eight and seven at nine,

2:39making sure I have enough room here.

2:41The first three octets against the same and put some dividing lines in there.

2:45And we simply keep on adding the block size for the next subnet.

2:48So 64 plus 16 more is 80 like that.

2:52And 80 plus 16 more is 96 and 96 plus 16 more is one 12 and one 12 plus 16 more

2:59is one 28.

3:00So the very first IP address in each of these subnets would be the actual sub

3:04net identifier plus one more.

3:06So this be dot one is be dot 17 and dot 33 and dot 49 and dot 65 and not 81 and

3:15dot 97 and 113 and 129 for the first valid IP address.

3:21So using this knowledge of the subnet IDs and the first valid IP address in

3:26each of the subnets,

3:26let's go ahead and plug some numbers in.

3:28So over here in our one on gig two zero, the first subnet is the 1067 a three

3:34zero and the first valid IP addresses

3:36dot one.

3:37So here we'll have dot one and let's go up to our two.

3:39So our two it's gig two zero interfaces connected to the fourth subnet.

3:43That's right here.

3:44That's going to be a dot 49.

3:45So we'll put a dot 49 right there.

3:48And then on our three it's gig two zero interfaces connected to the seventh sub

3:52net.

3:52And so that seventh subnet is the 96 network.

3:55First thought IP address is 97.

3:57So we'll put that there and then our four is connected to the ninth subnet on

4:01its gig two zero interface or it will be once we can figure it.

4:04Ninth subnet is the 128 subnet and the first thought IP address there is dot

4:09one 29.

4:09So we'll make a note of that as well.

4:11All right.

4:12So with that in mind, let's go ahead and configure those four interfaces with

4:15those four IP addresses and the mask is going to be a slash 28 or in dot a

4:20decimal.

4:20That'll be two fifty five dot two fifty five dot two forty and we had memorized

4:25this slash twenty eight would be a two forty that lost octet.

4:28We could add up one twenty eight plus sixty four plus thirty two plus sixteen

4:32and that's going to equal to forty.

4:34All right.

4:35So with all of that in mind, let's go to the router interfaces and let's

4:38configure gig two zero on each of the four router interfaces.

4:42So to do that, let's open up server nug.

4:44That'll give us access to the router interfaces and here is the tab for our one

4:50and our two and our three and our four.

4:53So let's start here on router one and let's do a show IP interface brief and

4:57see what we're starting with.

4:59So there's gigabit to slash zero. It's currently on the sign regarding an IPV

5:03four address and it is also down.

5:05So we'll go into configuration mode with config T. We'll go into interface

5:09configuration mode for gigabit ethernet to slash zero by typing in interface

5:13gig to slash zero.

5:15And let's go ahead and bring it up with a no shutdown command and let's give

5:18the IP address that we planned on, which is ten dot sixty seven dot eighty

5:22three dot and I'm looking at my notes and that's going to be a dot one.

5:25And then the mask is going to be a twenty eight bit mask, which is eight bits

5:29there and eight bits there and eight bits there and four bits like that and we

5:33are good to go.

5:34So type it and and we'll do a show IP route is just to make sure that we got

5:38the mask correct. We can do a show IP route and we can specify connected and

5:43that'll just show us the connected routes on this router.

5:45So here showing the ten sixty seven eight three dot zero slash twenty eight

5:49directly connected to gigabit ethernet to slash zero and that's a direct result

5:53of us just configuring the IP address on that interface.

5:57All right, our one looks good. Let's go over to our two. So we'll hit the tab

6:01for our two. We'll go ahead and do a show IP interface brief to see where we're

6:05starting from here is gigabit to slash zero on that router, not configured and

6:10it's down.

6:10So we'll go into configuration mode interface gig to slash zero. We'll do a

6:15note shutdown to bring it up and then we'll give the IP address based on our

6:19plan, which is ten dot sixty seven eighty three dot and that is sub network

6:22forty eight.

6:23So we're going to go ahead and use the first thought I could dress, which is

6:27forty nine and then the mask of two fifty five dot two fifty five dot two forty

6:31, which represents a slash twenty eight and press enter.

6:34And that looks good. Well, type it in. Let's do a show IP route and say

6:38connected just to verify we have the mask correct. So here on gig two zero, we

6:43have the network forty eight with a slash twenty eight bit mask.

6:46Fantastic. Let's move on to router three. So at router three, let's do a show

6:51IP interface brief currently not configured and down for interface gig two zero

6:56.

6:56So we'll type in config T to go into configuration mode interface gig to slash

7:01zero to go into interface configuration mode for gig two zero, and that is the

7:05seventh subnet and sales first of all bring it up.

7:08We'll do a note shutdown and we'll give the IP address of ten dot sixty seven

7:12eight three because everything starts with that. And then for the last octet

7:16there in subnet ninety six, we're going to use dot ninety seven.

7:20And that is a twenty eight bit mask as well. Press enter type end to a show IP

7:24route connected and was validate that that's the right network. So that's the

7:29ten sixty seven eight three ninety six subnet with a twenty eight bit mask,

7:32which is our seventh subnet looking good.

7:34And for the actual configuration, we use the dot ninety seven so we can verify

7:38that again with a show IP interface brief.

7:40And there's the actual IP address that we configured fantastic. So we have one

7:43more to go. And that is router four.

7:45And here in router four, let's do a show IP interface brief to see where we're

7:49starting at. And there is gig two zero on assigned as far as the IP address and

7:53also down. So we'll go into configuration mode.

7:55We'll go further into interface gig two slash zero. We'll do a note shutdown to

8:00bring it up. And then that's the ninth subnet, which is the subnet one twenty

8:04eight.

8:04So the IP address the first valid IP address on that subnet is going to be ten

8:09dot sixty seven dot eighty three dot one twenty nine with a twenty eight bit

8:14mask, which in dot a decimal looks like that.

8:17And just to verify we'll do a show IP route and tag on connected press center

8:23and on this gig two zero interface. There is the ten sixty seven eight three

8:27one twenty eight network with a twenty eight bit mask.

8:29Now in the background, I already have a routing protocol configured. So presum

8:34ing that we configured those gigabit interfaces correctly, we should have full

8:39connectivity across the network.

8:40So here in the lab, we're asked to go ahead and validate our connectivity by

8:44going to our client windows computer right here. That's client nug and doing a

8:50ping.

8:50Then we can also do a trace just to validate our path to the network. So let's

8:55go to the windows client and try that right now. All right. So back in the lab

8:58environment here at client nug in the bottom left hand side of our topology.

9:01Let's do a quick IP config to confirm our IP address. So our IP address is ten

9:06sixty seven eight three dot two or default gateway is our ones gig two zero

9:10interface.

9:11So let's do a ping up to the server in the upper right and that's a ten dot

9:15sixty seven dot eighty three dot one thirty and that ping is working. So let's

9:19also do a trace route from the windows computer that spelled T R A C E R T

9:23space.

9:23And we'll do a dash D to not bother doing name resolution and we'll do that

9:27same destination of ten dot sixty seven dot eighty three dot one thirty press

9:31center and that's our path to the network.

9:33So the first router is dot one which is R one and then dot eighteen which is

9:38probably R two and we can go verify the interfaces to verify that as well. And

9:43then dot sixty six is R three and dot one fourteen is the gig one slash zero

9:47interface on R four.

9:47And then we finally have complete reachability up to the server itself at one

9:52thirty. So thanks for joining me in this hands on labs. We've validated our

9:55skills and working with fixed legs subnetting and I look forward to seeing you

9:59my friend in another set of videos very, very soon.

10:01Until then I hope this has been informative and I'd like to thank you for

10:05viewing.

10:06[no audio]