00:00:00 - Ahhhhh. All right, are you ready for it? We have arrived at advanced
00:00:09 - TCP/IP: IP Subnetting, part one.
00:00:14 - If you haven't looked at the bottom of the window yet, this video
00:00:17 - will take a little extra time because I'm going to fully walk
00:00:21 - through multiple examples of subnetting based on network
00:00:25 - requirements. Four different ones to be exact and then leave
00:00:28 - you with a bunch of practice to do on your own. Now, one of
00:00:32 - the things that I've found is the best way to teach subnetting
00:00:36 - is not just to start talking about the -- the advanced pieces
00:00:39 - of it right away and -- and say oh this is, you know, this is what
00:00:43 - subnetting does and binary addition and all that. It's more so to apply
00:00:47 - it to the real world. So you can see that we have four separate
00:00:51 - scenarios, four different network requirements that we're going
00:00:54 - to walk through one by one as we determine how to break a
00:00:59 - network into multiple sub-networks one by one. Let's get going.
00:01:05 - Let's start off with network scenario number one. We have an
00:01:08 - organization, this organization has purchased a Class C address
00:01:12 - 216.21.5.0, so they've purchased
00:01:16 - that from the powers that be, the Internet, and they now want
00:01:19 - to use it to address this network. And this is a picture of
00:01:23 - their network. Now here's the trouble and this is why we need
00:01:27 - subnetting. They purchased a Class C network and let me just write it over
00:01:30 - here, 216.21.5.0.
00:01:37 - Now, when they bought that, it's a Class C network so the subnet
00:01:40 - mask is this. The question I have is how many networks do they
00:01:44 - get from that?
00:01:47 - Well, looking at it, it's just one. We draw our line boundary right
00:01:50 - there and 216.21.5 represents the
00:01:54 - one network they get; that's their network. And this over here
00:01:57 - represents the host. It goes from 0 to 255 maximum
00:02:01 - where you can't use zero and you can't use 255. You
00:02:04 - get everything in between; you can't use the first and last address
00:02:06 - from -- from the network range. So we have 254
00:02:10 - hosts on one network. Now look at their network diagram. How
00:02:14 - many networks do they need? Well, let's number them, one, two,
00:02:22 - three; and a lot of people forget these -- four and five. Remember
00:02:30 - every interface of a router is a network. So we need a network
00:02:35 - address or a sub-network -- a network -- for every single one of
00:02:38 - these locations. Here's maybe an office with an ethernet switch
00:02:42 - maybe that's in Arizona. We have an office across the WAN link
00:02:46 - to California. The WAN link to get there is considered a network
00:02:49 - and the office itself. Now we have a WAN link over from California to
00:02:53 - Florida, which we have an office right here and the WAN link
00:02:57 - itself to get there. So we have one network that we purchased
00:03:01 - but we need to break it in to five.
00:03:04 - So we know our network requirements now. Now here are the
00:03:08 - three steps of subnetting.
00:03:11 - Before we start working through this, let me give you a little disclaimer.
00:03:14 - First off, I wrote our network requirements up here. This
00:03:17 - was our Class C subnet mask that we needed and we know that we needed
00:03:20 - five networks or sub-networks based on what we saw on the
00:03:24 - previous slide. Now the disclaimer that I have is that there
00:03:28 - are more ways to subnet than there probably are grains of sand
00:03:32 - on the sea shore. I mean, literally I, even myself over the
00:03:36 - twelve years of teaching that I have been in, have taught this
00:03:38 - probably six or seven different ways. About five years ago, I
00:03:42 - came up with this little three step process that will work
00:03:45 - for just about any subnetting scenario you can throw at it. And you'll
00:03:49 - be able to -- to figure out the answer. Now the first time we work
00:03:53 - through this together, it's going to look a little weird and
00:03:57 - you're going to go, ah,
00:03:58 - I don't know about that. But I'm telling you after about the third or
00:04:02 - fourth example of this, you're gonna start going, oh, I see how this
00:04:05 - is working. And between this and the following video I hope to
00:04:09 - give you enough examples and practice that you can work on
00:04:12 - yourself, so that you'll be able to master the skill and master
00:04:15 - it quickly. So our first step in this subnetting scenario is
00:04:21 - to determine the number of networks and convert it to binary.
00:04:25 - We need to use this skill that we learned previously in the
00:04:27 - previous video, of binary conversion. So we know that we need
00:04:31 - five networks, let me write up our binary chart. 128,64,32,
00:04:35 - 8, 4, 2, 1. So five is a binary
00:04:41 - number is no, no, no, no, no, yes; there's our first one -- four
00:04:47 - zero one. So we know that five is zero, zero, zero, zero, zero -- five
00:04:52 - zeros -- 101; that's our binary equivalent. That's all there
00:04:55 - is to step one.
00:04:57 - The second step is the big one. Reserve the bits in the subnet
00:05:01 - mask and find your increment. Now I am going to show you something
00:05:06 - and I want to make sure that when you start working on this
00:05:09 - you don't skip this, this step or this part of the step. It
00:05:13 - may seem tedious at first, but you will greatly appreciate
00:05:17 - this after a little bit. We need to write our regional subnet mask
00:05:22 - right here, in all binary. So 255.255.255.0
00:05:26 - is Class C. Now what's 255 in binary? All ones;
00:05:31 - that's the biggest number we can have, right? So 8 ones
00:05:34 - dot -- this is the whole subnet mask; eight ones, one two three four five six
00:05:39 - seven, eight dot eight more ones; one, two, three, four, five, six,
00:05:43 - seven eight dot and now zero in binary is just all zeros. One
00:05:47 - two, three, four, five, six, seven, eight.
00:05:51 - Now I need to have you make a mental leap with me; a transition.
00:05:56 - We've been looking at subnet masks, like this, up till this
00:06:00 - point and we've been looking at them in decimal format. Everywhere
00:06:05 - we see 255, we go oh, well, that represents the network. So
00:06:08 - we know 216 represents part of the network. 255, oh 21
00:06:12 - is part of the network. So we've been relating 255
00:06:15 - equals network and wherever we see the zero, that represents
00:06:20 - the hosts. But here's the leap I need you to make. We need to
00:06:23 - start thinking in terms of binary, so can I say wherever I see ones
00:06:28 - as binary numbers that represents the network. And wherever
00:06:32 - I see zeros as binary numbers, that represents the host. Is
00:06:37 - that an okay leap to make? Good, so what -- the beauty of
00:06:42 - of video recordings as I can say, good; we're all on the same page
00:06:46 - and we are. So we have right here our -- our 24 ones that
00:06:51 - represent the network and our 8 zeros. Now what's our goal
00:06:55 - here? Our goal is to create more networks. Meaning, we only have
00:07:00 - one network and I need to create more, five of them to be exact.
00:07:04 - Now how many bits does it take to get the number five?
00:07:10 - Three of them. Three bits, right? You can't get the number five
00:07:15 - with any less than three bits. Now, when I asked that question,
00:07:18 - I know you may have been thinking, well, two bits, right? Because there's
00:07:22 - only two ones there. But if you look at this, if you only have
00:07:25 - two bits, what's the biggest number you can get?
00:07:28 - Three, right? If two plus one -- you can't -- you can't get the number
00:07:31 - five. So I'm not looking when I asked that question for how many
00:07:34 - ones do I have, I literally want to know how many bits does
00:07:37 - it take to get the number five and that is three bits;
00:07:40 - three bits total. So transition that back over. Our goal in this
00:07:44 - step is to reserve the bits in the subnet mask and find your increments.
00:07:48 - So when I say reserve the bits in the mask, what I mean is I
00:07:52 - know that I can't get the number five with any less than three
00:07:55 - bits. And I know that network bits are ones so what I need
00:08:00 - to do when I'm making this reservation is give myself three
00:08:04 - more network bits. So I pick up where the ones leave off and go
00:08:08 - one, two, three.
00:08:12 - Zero, zero, zero, zero, zero. Now I know, you're looking at this
00:08:16 - going whoa, wait a sec, that was a little weird. I'm not sure if I
00:08:20 - follow that the whole way. Don't worry, we'll get used to this as we go
00:08:23 - through it again and again and again. But let me just reiterate
00:08:27 - our goal is to create more networks because we only have
00:08:31 - one. And we know that it takes three bits to get our five networks
00:08:37 - that we needed and then partner that with we know that network
00:08:40 - bits are one bits it doesn't really matter that five was one
00:08:43 - zero one. I'm looking for three more network bits. So with that
00:08:47 - in mind I just add three more right where my network bits
00:08:51 - leave off left to right; one, two, three. At this point in the
00:08:55 - problem we already know what our subnet mask will be for
00:08:59 - the entire organization. It is
00:09:03 - 255 -- convert this back to decimal -- dot 255; that's what
00:09:07 - this one is -- dot --.255; that's the third one. That's
00:09:11 - what we had originally, dot and then we need to convert this
00:09:15 - last octet right here back to decimal. Now again using those
00:09:19 - skills from before if we line that back up to the binary chart
00:09:22 - that says we've got one 128; one 64; one 32;
00:09:26 - zero, zero, zero, zero, zero. So if I wanted to find
00:09:30 - out what this, right there, is in a decimal number, I would just
00:09:34 - take 128 plus 64 plus 32
00:09:40 - and that, if we add that all together, will be 224.
00:09:43 - So our subnet mask that we get for our entire organization is
00:09:48 - 255.255.255.224.
00:09:54 - Now that's fantastic. We know what every single PC, what
00:09:58 - every single router, what every single switch, every single device
00:10:02 - in our organization that is on the network will use this subnet
00:10:06 - mask. Woo hoo, you know, do the happy dance. But we don't know what
00:10:09 - that means yet, you know? Great we've got a subnet mask that's a key
00:10:13 - part of the equation, but we need to figure out what that subnet
00:10:16 - mask means and that's the second half of step two. Says reserve
00:10:20 - the bits in the subnet mask -- we just did that, and find your
00:10:24 - increment. The increment, this is the other weird part, is going to
00:10:28 - be the lowest network bit that you have
00:10:33 - converted back to a decimal number. So look at our network bits.
00:10:37 - Right here, this is a 128, right? 64 and a decimal
00:10:41 - 32, that is our lowest network bit converted back
00:10:46 - to a decimal number, 32.
00:10:49 - That is our increment. So with that in mind, we can move to
00:10:54 - step three, which says use the increment to find your network
00:10:59 - ranges. This is where the subnet mask becomes meaningful to
00:11:03 - us. So
00:11:05 - I just change my pen color here. Step three I'm gonna take what I started
00:11:08 - off with, meaning, the address that I purchased, 216.21.5.0.
00:11:13 - And then just begin adding
00:11:18 - my increment. Now my increment, right here, this 32 is
00:11:22 - in the fourth octet, so that's where I do my addition. 216.21
00:11:26 - .5.32.
00:11:31 - 216.21.5.64. You
00:11:36 - can see all I'm doing here is adding my increment. 216.21.5.96
00:11:40 - that's 64 plus
00:11:45 - 32. And so on and so on and so on we go. What this is
00:11:50 - when I'm looking at this, is the beginning of each network range.
00:11:54 - Now, all I have to do is fill in the end. What's the last IP
00:11:58 - address before I get 216.21.5.32,
00:12:02 - which is this one right here.
00:12:05 - Now it's not a trick question -- 31 just taken one away from
00:12:08 - 32. Put this through, 216.21.5.
00:12:12 - -- last IP address before 64 is 63.
00:12:18 - 216.21.5.95 and
00:12:23 - so on and so on and so on we would go; down and down and down until we found
00:12:26 - enough network ranges to fit our organization. These are actual
00:12:30 - reality to us. Meaning, let me -- let me do a quick sketch
00:12:34 - of that network diagram. The network diagram that organization
00:12:37 - had looks something like this, where we had three different
00:12:42 - networks that we were trying to address. Now what I can do
00:12:46 - is I can start assigning these network ranges to that organization.
00:12:49 - This one we'll address, I think this was Arizona that I put -- the Arizona
00:12:53 - router and they will use that range for this network
00:12:57 - right here. You can see what we've done is sacrificed the total
00:13:01 - number of hosts we have
00:13:03 - or to -- to get more networks. We originally had 254
00:13:06 - hosts with our Class C address up here. And now we've
00:13:10 - sacrificed that and said, well, I'll have less hosts, but more networks.
00:13:15 - The second network range can go ahead and address, I believe
00:13:18 - this was California down here and the third network range
00:13:22 - we'll address Florida up there in the upper right-hand corner.
00:13:25 - I won't draw the arrow across, just so it doesn't get too messy. The fourth
00:13:28 - network range would address the WAN link. And the fifth network range -- I didn't
00:13:32 - go that far because I ran out of space down here, but the fifth network
00:13:36 - range would address that WAN link right there. Those are the network
00:13:39 - ranges that I can assign to the devices. I would then assign
00:13:42 - IP addresses from these ranges to the computers in Arizona and
00:13:46 - assign IP addresses from this range to the computers in California. This
00:13:51 - is the meaning of subnetting; breaking our one network into
00:13:55 - multiple networks. We've got our new subnet mask that we use
00:13:58 - and our network ranges that can be assigned to the different
00:14:01 - devices. With that in place, I know, at this point it's like, okay,
00:14:06 - I'm seeing that; still a little fuzzy. Let's do another example.
00:14:11 - Network scenario number two. Instead of drawing this massive
00:14:16 - network, I just put our requirements in the upper right-hand
00:14:18 - corner. We have another organization that is using
00:14:22 - 195.5.20.0. It's a Class C network.
00:14:27 - And they need to break that one network; 195.5.20
00:14:30 - into 50 sub-networks or 50 smaller networks.
00:14:35 - It's a lot of networks; that's why I didn't want to draw a network diagram.
00:14:38 - So let's work through the steps again. Number one, determine
00:14:43 - the number of networks and convert that number to binary.
00:14:48 - 50 is how many networks we wanted. So I'll put our equals and
00:14:52 - let's draw up our binary chart. 128, 64, 32,
00:14:56 - 16, 8, 4, 2 and 1. So 50 networks; zero, zero,
00:15:04 - one,
00:15:06 - I can take 50 minus 32 and that would give me
00:15:10 - four -- eight --18; so, 18 left over. So I'd have a 1 and a 16
00:15:15 - that would leave me two -- 18 minus 16, so there's our
00:15:18 - two and that is our binary number. Zero, zero, one, one, zero, zero
00:15:24 - one, zero. Now let me ask you a question.
00:15:28 - How many bits does it take to get the number 50? Well,
00:15:33 - looking -- looking at this number I can just underline where the
00:15:35 - first one started and say that takes one, two, three, four, five,
00:15:41 - six bits.
00:15:44 - Good, because we're going to need that number when we do step two.
00:15:47 - So step two now says reserve the bits in the subnet mask and find your
00:15:52 - increment. Again, don't skip this first part.
00:15:57 - It may seem tedious, but that is the key to seeing what bits
00:16:02 - you have to work with. Our original subnet mask is Class C, so
00:16:06 - in binary it's 8 ones dot one, two, three, four, five, six, seven,
00:16:12 - eight ones dot one, two, three, four, five, six, seven, eight ones
00:16:17 - dot and then the most critical piece. Not all the ones, it's the zeros; one,
00:16:20 - two, three, four five, six, seven, eight because the zeros is where
00:16:25 - we can do our subnetting. We were given a Class C address so we
00:16:28 - can't change any of those first 24 ones right there.
00:16:31 - We can only play with the last eight zeros. So now we look
00:16:35 - at our requirements, it says reserve bits in the subnet mask and find
00:16:38 - your increment. Our organization wants to break this into 50
00:16:42 - sub-networks. We know that it takes six bits to get the number
00:16:46 - 50. And we know that ones are network bits. We need to change
00:16:50 - our subnet mask to where we have six more ones. So we do that;
00:16:55 - one, two, three, four, five, six. And the other two can remain zero
00:17:01 - zero, zero. We've stolen six network, or six host bits and made
00:17:06 - them network bits to meet our requirements. Just like that, poof.
00:17:10 - We know what our subnet mask will be for our whole organization.
00:17:14 - It's 255.255.255 dot, and
00:17:19 - then we need to convert this last one back to decimal. So we
00:17:23 - use our binary to decimal and decimal to binary conversion
00:17:26 - skills and I say I've got one 128; one 64;
00:17:31 - one 32; one 16; one 8; one 4; no twos no
00:17:37 - ones. So I can, by the way when you see this you can approach
00:17:41 - it one of two ways. I can either add all these numbers together
00:17:44 - 128, 64, 32, 16, 8, 4, 2
00:17:47 - or four, add all those up and I would end up, if I did that addition
00:17:51 - with the number 252. But that's a pretty long addition
00:17:55 - problem, adding all those values together. So one of the ways
00:17:59 - that I do this and find a little shortcut is I know if all of
00:18:03 - these are turned on to one, it's what number?
00:18:06 - 255; right? That's -- that's the maximum number I can get. And
00:18:10 - I can look at this and go, oh, well, there is no twos and there
00:18:13 - is no one, so I can just do 255 minus two, minus one
00:18:17 - or just add those together and just do 255 minus
00:18:20 - three and get 252. So whatever way works easier
00:18:25 - in your mind for you, either doing addition, adding all those
00:18:27 - together or knowing the maximum is 255 and just subtracting
00:18:31 - what's not turned on. That will give you your subnet mask. Now
00:18:37 - I'm trying to think should I add another piece at this point?
00:18:39 - No, I'm not going to. Let's -- let's keep working through this, I'll add it once we're
00:18:43 - done with this problem. It says reserve the bits in the mask
00:18:46 - and find your increment. So we've got the mask, we've reserved the
00:18:49 - bits, our increment is the lowest network bit,
00:18:54 - that guy, converted back to a decimal number. Now if we look in --
00:18:58 - in binary, this is or in decimal, this is one, two -- that one is a four. That is
00:19:04 - the decimal equivalent of the lowest network bit.
00:19:08 - That is our increment and that is what we need to find our
00:19:12 - network ranges. So the last step will be finding our network ranges.
00:19:17 - We start with what we were given; 195.5.20.0;
00:19:23 - that's the address that we purchased from
00:19:26 - the powers that be. And we want to use to address our whole organization.
00:19:29 - So now I just need to start adding my increment in whatever
00:19:32 - octet it's in. I notice that it's in the fourth octet right here. So I'll just
00:19:36 - do some simple math, 195.5.20.4; 195.5.20.8;
00:19:42 - and I'll just
00:19:47 - start shortening --.20.12;.20.16.
00:19:52 - You know this is the same the whole way down. That is the start of
00:19:55 - every single network range that I have. Now let's fill in the end.
00:19:59 - I'll go back to the top. The last IP address before I get
00:20:02 - to 195.5.20.4 down here
00:20:06 - is.3. The last IP address before I get to 195.5.20.8
00:20:10 - is.7 and down and
00:20:16 - down I go;.11 is the last one before 12;.15, you
00:20:20 - know, same thing. 195.5.20.11;.15 and so on.
00:20:22 - I just keep on going. I think the next one would be.19
00:20:26 - because.20 would be if I added four over here. And I
00:20:29 - would just keep finding all these network ranges. Now let
00:20:33 - me fill in a little more -- a little more information here
00:20:38 - about these network ranges. We've taken one Class C network,
00:20:42 - 195.5.20.0 with one network
00:20:46 - that could go all the way up to 255 and broken it into
00:20:50 - all these little sub-networks. Now there is a price to pay
00:20:55 - whenever you do subnetting. Here it is. When we had one network, we couldn't
00:20:59 - use the very first or the last IP address; right? Because the very
00:21:04 - first IP address identified the network. It's known as the network
00:21:08 - ID. You can not assign 195.5.0.20 -- or
00:21:12 - .20.0 to a PC or to a router or to any device because
00:21:15 - it identifies the network. We can't assign that IP address because
00:21:19 - that's the broadcast. Meaning, if I wanted to send a broadcast to
00:21:23 - everybody in that network, I would send it to that IP address.
00:21:27 - So I can not assign this IP address to any given host. Now
00:21:32 - what we've done is taken this one network and broken it down into
00:21:36 - mini sub-networks. But when we do that we can not use the first
00:21:42 - IP address or the last IP address from every single
00:21:46 - network range. So I can not assign 20.3 to a host because
00:21:51 - it's the broadcast for this first network right here. I can
00:21:54 - not assign 20.7 to a host because that's the broadcast
00:21:58 - for the second network and the third network and the fourth
00:22:01 - network. I can not assign the first or the last IP address from
00:22:05 - every single range to a host or a router or a switch or any device
00:22:09 - on that network. So what does that mean?
00:22:12 - That means when I really look at this, I have one through two;
00:22:17 - five through six; nine through ten. I have two usable hosts per network
00:22:25 - that I can actually assign -- one and two; five and six; nine and ten -- that
00:22:29 - I can actually give to a device. Now I know you might be looking at
00:22:32 - that going, that is stupid he-he. Why would you ever have
00:22:38 - a network of two hosts? Now with that being said, I can tell
00:22:43 - you that is the second most popular subnet mask in the world.
00:22:49 - I'm not kidding. This subnet mask that you just found 255.255.255.252,
00:22:52 - which gives you two usable
00:22:55 - hosts per network is the second most popular one in the world
00:22:59 - because it's perfect
00:23:05 - for those kind of networks right there. That is considered
00:23:09 - a point-to-point WAN link, meaning, you know, this -- I
00:23:14 - mean think of the diagram we had before where we had, you know, we've
00:23:17 - had some hosts over here and some hosts over here. And I said but
00:23:19 - this is a network, too. Well, that network will never have more
00:23:24 - than two hosts per network because there's only eight points.
00:23:27 - I'll put.1,.2, to point network right here. So I
00:23:32 - can assign this first network to that point-to-point WAN
00:23:36 - link. I have another point-to-point WAN link right here. I could assign
00:23:40 - this second network, maybe.5 is assigned to that router right there.
00:23:44 - And.6 is assigned to that router interface over there. That
00:23:47 - is a very popular subnet mask and very popular way to find network
00:23:51 - ranges for your WAN links. Now
00:23:55 - with that being said, that is the second network scenario that we've
00:23:58 - gone through that is a Class C address. I'd like to add one more
00:24:02 - piece of information that we can gather from this. That
00:24:06 - is a different way to write the subnet mask. You can see that
00:24:11 - I have the Class C subnet mask right here, 255.255.255.0.
00:24:14 - Now I don't know if I've written it this way
00:24:18 - in the past in this series, but you'll see this subnet mask,
00:24:23 - short-hand abbreviated, a lot of times a /24. Have you
00:24:27 - seen that before? When -- when people write a Class C subnet mask up here,
00:24:31 - they might write it 195 -- oops, 195.5.20.0/24,
00:24:37 - instead of actually writing
00:24:41 - 255.255.255.0; that's known, technically known
00:24:45 - as cider notation. Many people call it bit notation or slash
00:24:49 - notation. There's a lot of names for it, but all it is shorthand
00:24:53 - for writing the subnet mask. And now that we have this problem
00:24:56 - sitting right in front of us, we can explain why this shorthand
00:25:00 - notation means the same thing. When you see slash and a
00:25:04 - number, that is literally the number of ones in the subnet
00:25:08 - mask when you convert it to binary.
00:25:11 - Ha, seriously, look at this. Class C subnet mask -- 255.255.255.0.
00:25:14 - If you converted 255 to binary,
00:25:18 - how many ones is that?
00:25:20 - Eight, same thing here, eight, same thing there, eight. So if I take all of
00:25:25 - those ones and add them up, 8 plus 8 plus 8 is twenty four. It's
00:25:30 - shorthand. So if I were to look at a Class A subnet mask; that's
00:25:33 - 255.2 -- oops, or.0.0.0,
00:25:38 - that is abbreviated as a /8. A Class B subnet mask 255.255.0.0
00:25:43 - is abbreviated
00:25:48 - as a /16. Class C is /24; that's the bit
00:25:54 - notation. You're just looking at how many ones, 8 plus 8,
00:25:57 - or just 8 up here is in the subnet mask. And the same thing
00:26:01 - works for these custom subnet masks right here. 255.255.255.252
00:26:05 - can be shorthand notated, in
00:26:08 - cider notation or bit notation by saying, okay, we've got 8 -
00:26:12 - ones there; 8 - ones there; that's 24, 25,
00:26:16 - 26, 27, 28, 29, 30.
00:26:20 - /30 is shorthand bit notation for 255.255.255.252.
00:26:25 - When you are working
00:26:28 - on a CISCO device, there are many show
00:26:31 - commands that will show you the subnet mask in that format and
00:26:35 - there are many show commands that will show you the subnet mask
00:26:37 - in that format. So you need to be comfortable working with both.
00:26:41 - Same thing if you're preparing for the CCENT or CCNA
00:26:44 - exam, there are questions that will give you the subnet mask in both
00:26:48 - formats, one or the other. So you need to be very comfortable working
00:26:52 - with either one. So what I want to do as we work through these
00:26:55 - problems, we've got two more scenarios that I've got for this
00:26:58 - video that I want to work through, I want to show you the subnet
00:27:01 - mask both in decimal and bit notation so you can get comfortable
00:27:05 - working with the either.
00:27:08 - Now before we move on to network scenario number three, I
00:27:12 - wanna make a quick point. We just did two back-to-back network
00:27:15 - scenarios that are using Class C networks. I'm about to move
00:27:20 - into a Class B example. Now don't worry it's the same thing.
00:27:24 - It's the same three steps, same process that you work through.
00:27:27 - But I want to make sure before you jump into this one that
00:27:29 - you are comfortable with the Class C examples we just talked
00:27:32 - about. So if you would like, what I would propose is to pause
00:27:37 - the video right here, if you're still feeling like you -- you wanna
00:27:39 - see those again, rewind it and do the Class C examples one more
00:27:43 - time. That's the beauty of video; just watch -- watch me work through those two
00:27:47 - Class C examples, then come into this Class B. If you're feeling
00:27:50 - comfortable and -- and you're ready for a Class B example, feel
00:27:53 - free to keep on watching. I just wanted to make sure I mentioned that
00:27:56 - we are moving into another class of problem if you will. So
00:28:01 - here's our scenario,
00:28:03 - we are given a Class B network, 150. 5.0.0
00:28:08 - and the organization that we're working for has offered
00:28:12 - us a lucrative $16.3 million contract
00:28:16 - to break that into a hundred sub-networks. As of right now, you
00:28:20 - know, Class B network 150.5.0.0;
00:28:25 - 255.255.0.0. We've got one network;
00:28:29 - that's 150.5 and a whole bunch of hosts.
00:28:33 - 65,535 I believe to be exact.
00:28:36 - And that -- you know, that's way too many hosts. We want to break
00:28:39 - that into a hundred different sub-networks; that's our goal.
00:28:42 - So
00:28:43 - the process is the same. Number one determine the number of
00:28:47 - networks and convert to binary. 100 sub-networks;
00:28:51 - right? That in binary -- let me just write up our chart. 128, 64, 32, 16, 8,
00:28:56 - 4, 2, 1. So we convert it to
00:29:02 - binary; zero -- we can't subtract 128, so our first one
00:29:05 - goes right there. 100 minus 64, remember on CISCO
00:29:09 - exams there are no calculators. So that will be 9, -- six
00:29:14 - 36, right? So we can take our 32, that would leave us
00:29:18 - with four. Zero, zero, one, zero, zero. So a hundred as a binary number
00:29:23 - is 01100100.
00:29:29 - Now, let me freeze for a moment right there. I'm not all about
00:29:34 - teaching shortcuts. Meaning, you're going to find as you
00:29:37 - work through more and more examples, there's ways to -- to cut
00:29:40 - time by doing shortcuts. But there is one thing I do want to
00:29:44 - show you and that's how to save a little extra time right
00:29:47 - here. When I convert 100 to a binary number, remember I'm
00:29:51 - not so much after the binary number itself as I am after how many
00:29:56 - bits did it take to get to the number 100, right? Because that's
00:29:59 - what I'm wanting for the second step of the problem; that's why
00:30:02 - we do this binary conversion to start off with is we want to
00:30:05 - know how many bits it takes to get to the number 100.
00:30:08 - Now as soon as I find where my first one goes,
00:30:12 - do I know how many bits it's going to take? Well, sure I do. Soon
00:30:16 - as I know that my first one is 64, I know that I'm going
00:30:19 - to have one, two, three, four, five, six, seven bits. It doesn't matter
00:30:23 - what the rest of the binary, you know, comes out to. I know as soon
00:30:26 - as I know where that first one is that it takes seven bits
00:30:32 - to get the number 100. So a time saving shortcut right
00:30:36 - there, as soon as you look and find out where your first one
00:30:40 - goes in the binary equation, you can stop. You don't have to figure
00:30:44 - out and do subtraction and find the rest of it because you know, stop right
00:30:47 - there as soon as I know my first one is at 64, it takes
00:30:50 - seven bits to get to the number 100. That shortcut helps you
00:30:53 - save some time, it's great. If it confuses you, forget I ever
00:30:57 - said it. Just figure out the whole binary number. But you'll get comfortable
00:31:00 - with it as you work through it a couple more times. Here is the
00:31:03 - second set, reserve the bits in the subnet mask and find your increment.
00:31:07 - Now again, it becomes even more critical when you have a Class
00:31:12 - B example to write your subnet mask in all binary one, two, three,
00:31:16 - four, five, six, seven, eight. That's our first.255
00:31:22 - Eight, there's our second.255, now the host bits; one,
00:31:25 - two, three, four, five, six, seven, eight dot one, two, three, four,
00:31:30 - five, six, seven, eight. We have 16 network bits, it's a /16
00:31:35 - subnet mask by default and 16 host bits that are at our disposal.
00:31:39 - Now we're going back to our question. We want to take the Class
00:31:42 - B network and break it into a hundred sub-networks. We know
00:31:45 - that it takes seven or sorry, six bits to get the number 100.
00:31:50 - So we will pick up right where our ones leave off.
00:31:54 - This is the key don't -- don't start it's not a Class C example
00:31:57 - anymore. Don't start adding ones over here. We pick up where the
00:32:00 - ones leave off and say I need -- wait a sec, did I say six bits or
00:32:04 - seven bits? Seven bits; seven bits to get the number 100.
00:32:07 - Sorry; one, two, three, four, five, six, seven, zero dot and all these
00:32:14 - stay zero -- zero, zero, zero, zero, zero, zero, zero, zero. Eight zeros.
00:32:18 - There it is. Okay, 8 zeros. That is our new subnet mask when we're using
00:32:22 - a Class B example. Remember it's the same as it was before, it's
00:32:25 - just now we're working in this third octet, rather than the
00:32:28 - fourth because we started with a different subnet mask. So our
00:32:31 - new subnet mask, we now know that is 255.255. --
00:32:35 - if we were to convert this one back to decimal,
00:32:39 - we could either add all those up or just know that it's 255
00:32:42 - minus -- we don't have a one. It would be 254.0.
00:32:46 - So our new subnet mask is 255.255.254.0.
00:32:50 - Or if we're writing it in slash notation, it
00:32:54 - would be a /23. We had an original 16 bits --
00:32:59 - eight and eight, right there. And we just added seven more; that's
00:33:03 - the 254 or the seven bits right here. So you can just
00:33:06 - think of that as a /23 as shorthand notation.
00:33:09 - So that's the first part of step two, reserve the bits in the
00:33:12 - subnet mask and now find our increment. Our increment
00:33:17 - is the lowest network bit converted back to a decimal. Now don't
00:33:22 - start letting your mind go wild here, because I know you
00:33:25 - might think, okay, well, 128's right there, so is
00:33:29 - this like 256 now and stuff like that? No, the increments
00:33:33 - restart every single octet. So it's very simple; this is
00:33:37 - a one. This is a two, four, eight, you know, the decimal. I'm looking
00:33:41 - for the lowest network bit converted back to decimal number,
00:33:44 - that is simply a two.
00:33:47 - Now, step three; use the increment to find our network ranges. Just
00:33:52 - like the previous example, we're gonna write
00:33:55 - 150.5.0.0; that's the network that we started
00:34:00 - with and now we just start adding our increment. But before I do, I
00:34:03 - gotta ask the question what octet is the increment in?
00:34:08 - The third, right? This -- this octet right here is where our increment
00:34:11 - is at. Before when we were doing the Class C example, our increment
00:34:14 - was over here and that's why we added the number to our fourth octet.
00:34:17 - But since now our increments in our third octet; that's where
00:34:21 - our addition takes place. So we have 150.5.2.0,
00:34:25 - 150.5.4.0;.5.6.0;
00:34:30 - .5.8.0; forgive my penmanship getting
00:34:35 - a little sloppy as I go down. It's 150.5
00:34:38 - the whole way down and so on and so on and so on. We just
00:34:41 - keep adding to -- to that number.
00:34:44 - Now we fill in our end range and this is where it gets a
00:34:46 - little tricky. You look at this what -- and ask the question, what is
00:34:49 - the last IP address before I get to 150.5.2.0?
00:34:55 - Well, you look at it and go 150.5.1, and be
00:35:00 - careful right here because I know you might be thinking well,
00:35:02 - 1.0; right? Well, remember if we do 150.5.0.0
00:35:06 - through 150.5.1, if I put
00:35:10 - a zero right here, then
00:35:13 - that's where this first range ends and the next one picks up at
00:35:17 - 2.0. So let me ask the question what happens to
00:35:21 - the number 150.5.1.50 or
00:35:25 - 150.5.1.51; 52; or 53? What happens to
00:35:28 - all of the 150.5.1 numbers? Well, if you go
00:35:32 - to 150.5.1.0 as your end, you lose all of them.
00:35:35 - You can't -- can't do that. Think of some weird twisted
00:35:39 - math problem, 150.5.2.0; that's where our
00:35:43 - next one starts, if we were to subtract one from that, the last
00:35:46 - possible IP address before we get to 2.0 is actually
00:35:49 - 1.255.
00:35:52 - Ah-ah! This one goes through 150.5.3 --
00:35:57 - that's the last one before we get to 4.0.255.
00:36:01 - Again, last IP address before we get to four is
00:36:06 - 3.255. Last IP address before we get to 6.0,
00:36:09 - 150.5.5.255 and so on
00:36:15 - and so on and so on we go.
00:36:17 - Does that make sense? It's kinda weird, but that's -- that's the last IP address
00:36:20 - before we get to two and four and six and eight and so on and
00:36:23 - so on. It is going to be the 255 because that's how the
00:36:26 - binary works out.
00:36:28 - That is the answer to the problem. Now there's a couple more
00:36:32 - pieces I want to add as we have walked through this problem. The
00:36:35 - first one is this,
00:36:38 - as you look at these network ranges, we now have a network
00:36:42 - range that shows 150.5.0.0 through
00:36:45 - 150.5.1.255. We know that we can't use
00:36:49 - the last IP address from that range, right? 1.255
00:36:52 - because that's the broadcast, just like we saw on the previous
00:36:55 - one. We can't use the first one from each range either because
00:36:58 - that identifies the network. So those are unusable. Now here's
00:37:03 - the question, I'm looking at that first range; that's where my arrows
00:37:06 - drawing from, somewhere within that range I'm gonna run into the
00:37:09 - IP address 150.5.0.255, right?
00:37:17 - Do you see that? It's somewhere squished in the middle of that
00:37:20 - range. Can I actually assign that to a PC? Hmm.
00:37:25 - Well, on that same token before I answer that question, I'm also
00:37:28 - going to run into 150.5.1.0 somewhere
00:37:33 - in that range, you know, it's in between 0.0 and 1.255;
00:37:37 - that's -- that's an IP address in that range. Can I assign that
00:37:40 - one to a PC or to a router?
00:37:42 - The answer on both accounts is absolutely yes, you can. It's
00:37:49 - going to feel really weird when you're typing it in because
00:37:52 - we're -- we're geared in the decimal mindset. We're -- we're geared to think,
00:37:55 - oh, 255 you can't use that. That's -- that's a broadcast,
00:37:59 - right? You can't use that. And same thing with 1.0, you
00:38:02 - can't use that. You can't use zeros; that's -- that's the network.
00:38:05 - That's thinking in a decimal mindset. Those addresses are right
00:38:11 - in the middle of this range. They are completely valid addresses.
00:38:15 - Like I said it's going to feel really weird typing it in, but
00:38:18 - when you combine it with this subnet mask in your network properties
00:38:22 - field, it will work just fine. It's right in the middle. There's
00:38:26 - only one broadcast address and one network address for each
00:38:30 - range and that is it. We circled them right there on the screen.
00:38:33 - Everything that's in that squishy oreo center of that works
00:38:37 - just fine. That's something to get used to. And then I want you to already
00:38:41 - begin envisioning, if you're preparing for the certification
00:38:45 - exam a test question that says, which of the following addresses
00:38:49 - are valid and invalid; select all that apply. Well, when you see
00:38:53 - this you think, oh, that's invalid. Well, that's not true. You have
00:38:57 - to back up and say, well, what subnet mask are we working
00:39:00 - with, first of all. Based on that subnet mask, you'll be able to figure
00:39:03 - out which ones are valid and invalid. So that's the first piece
00:39:07 - I wanted to add to this is getting comfortable with those network
00:39:11 - ranges. The second piece that I want to add to this is what
00:39:15 - if -- what if somebody really wanted to know, you know? Okay, I can
00:39:19 - see that, you know, we wanted a hundred networks, but, you know,
00:39:23 - how many networks did this really give us? I mean, if we were
00:39:25 - to come up, here's one, here's two, here's three -- you know, if I wanted to
00:39:29 - know how many networks I could get using this subnet mask. Is there an
00:39:34 - easy way to do that without adding all of these up, you know,
00:39:37 - going through and writing all the ranges and then adding them up
00:39:39 - one by one? Well, the answer to that is also yes. We can figure
00:39:44 - that out by using a formula. And I know this is the first mathematical
00:39:48 - formula we've introduced here; it's known as the power formula.
00:39:52 - Two to the power of X is the formula that I want you to remember,
00:39:57 - where X is actually the number of subnet bits. Now
00:40:02 - if we look we added one, two, three, four, five, six, seven subnet bits.
00:40:07 - That's what we found right here. It takes seven bits. So if we do two
00:40:11 - to the power of seven that will tell us just how many subnets
00:40:17 - we're going to end up with if we were to count this all
00:40:20 - to the bottom. Now
00:40:22 - that's -- that's a painful equation when you're on a certification
00:40:26 - exam and don't have a calculator in front of you. So let me -- let
00:40:31 - me do this, let me show you two things. First off, I want
00:40:34 - to show you how to figure this out if you have a calculator
00:40:38 - and second, I want to show you how to figure out if you don't.
00:40:40 - If you have a calculator, let me bring this back into the screen;
00:40:45 - just clear off what we've got here, if you have a calculator
00:40:48 - the Windows calculator, all I need to do is go two, then move
00:40:52 - over here to these fuchsia numbers, x^y will do two to the
00:40:56 - power of seven and hit the equal sign
00:41:02 - and that will tell us exactly how many networks we get. If we
00:41:05 - were to follow this all the way to the bottom, we would end
00:41:08 - up with a 128 -- oops, I went out of the screen -- a 128
00:41:12 - different subnets that we could break this into.
00:41:16 - That's the way to do it with the calculator. If you don't have
00:41:19 - a calculator, the way to do it is using your binary chart.
00:41:24 - You might remember when I talked in the binary conversion video,
00:41:27 - I said these are actually the power of two. This one is two to
00:41:31 - the power of zero. Remember I said I don't know why two to the power
00:41:34 - of zero is one, but it is. Anything to the power of zero is one.
00:41:37 - So if you remember that, you can go okay, two to the power of one
00:41:40 - is two. Two to the power of two is four, three, four, five, six, seven.
00:41:46 - Ah-ha -- is 128. So I can look at two to the power of seven and
00:41:50 - say that is a hundred and 28 just by looking at my binary
00:41:54 - chart and realizing they're powers of two.
00:41:57 - Okay, are you comfortable with that? That is adding a couple of pieces
00:42:02 - to this, finding out that in between these network ranges
00:42:05 - we have some odd numbers that are valid and finding out the
00:42:08 - way that we can find how many networks we really get when we
00:42:11 - do subnetting. Using that same logic,
00:42:16 - let me just clear up some room -- I'm looking at this -- this screen right
00:42:21 - now, thinking how on earth can you learn anything from this
00:42:24 - mess? It's just a mess of numbers at this point. So let me just
00:42:27 - carve out a little extra space out for myself so I can do some
00:42:30 - writing here.
00:42:32 - I just showed you the equation, the two to the power of X equation
00:42:37 - to find the number of networks. But what if you were asked not --
00:42:41 - not for the number of networks, but how many hosts do I get
00:42:45 - in each one of those networks? Meaning, how many hosts do I get in
00:42:49 - between 150.5.0.0 and 150.5.1.255?
00:42:52 - Well, just looking at
00:42:55 - that, it's not very easy to just add those up and -- and figure that
00:42:58 - out. So you can use that same equation, slightly different to
00:43:02 - find the number of hosts. Two to the power of X, but this time
00:43:06 - X is how many zeros. We were using ones
00:43:11 - the find how many networks we get, so two to the power of X with
00:43:15 - zeros being the X this time will tell us how many hosts we get.
00:43:19 - But remember we have to do a minus two on there.
00:43:23 - We have to subtract two from whatever our value is because we
00:43:27 - cannot use the last nor can we use the first IP address from
00:43:30 - each range; that's why we subtract two. So in our case, two to the
00:43:34 - power of X, X is one, two, three, four, five, six, seven, eight,
00:43:40 - nine zeros. We have nine zeros left over in our subnet mask.
00:43:44 - So two to the power of nine minus two will give us that equation.
00:43:49 - Now again, if you've got your calculator that makes it a lot easier.
00:43:52 - We can go two; x^y -- this fuschia one, nine equals 512
00:43:59 - minus two, 510. So there are 510
00:44:04 - hosts per network here. If you don't have a calculator
00:44:08 - in front of you, you can say okay, well, I know two to the power of
00:44:11 - seven is 128, you know? You know where that leaves
00:44:14 - off. So two to the power of eight is 128 times two; that's
00:44:20 - 256. Two to the power of nine is 256 times two
00:44:26 - and that is 512. It will take a little extra math if
00:44:30 - you don't have a calculator, but that will be able to tell you
00:44:33 - how many hosts per subnet you have.
00:44:36 - All right. I have one more network scenario to work through with you.
00:44:39 - And after seeing the Class B one, it shouldn't be to bad, although, I've thrown in an extra
00:44:43 - little twist in here. We now have a Class A example. We
00:44:49 - have the network 10.0.0.0 and we would
00:44:52 - like to break that into 500 networks. Wow.
00:44:58 - All right. Same three steps; same process, just a little bit bigger
00:45:02 - numbers. We've got step one, determine the number of networks
00:45:06 - and convert to binary. So
00:45:08 - here's my hint for this one -- 500 is let's go ahead and write
00:45:12 - our binary table. 1, 2, 4, 8,
00:45:17 - 16. 32. 64, 128. Now stop
00:45:23 - right there, because I know that -- wait a second, I -- I can't get the number
00:45:27 - 500 with eight bits. I can only get 255; right? Right.
00:45:32 - So we need to keep going, 128, 256 -- I'm running outta room here --
00:45:37 - 512. Now, immediately I look and I go, oh 512 is
00:45:43 - bigger than 500. So I at -- my first one doesn't go there,
00:45:46 - I can't subtract 512 from 500. So my first one
00:45:49 - goes erk -- right there; 256. Now I can work that out and do
00:45:54 - 500 minus 256 and -- and find the whole binary
00:45:57 - number for what 500 is. But remember I just mentioned on the
00:46:00 - last slide, we're not after that binary number and exactly what
00:46:04 - it is. We just want to know how many bits did it take to get the
00:46:06 - number 500. And when I look and I go, oh, well, my first one
00:46:09 - went right there. I immediately know it took one, two, three, four, five,
00:46:13 - six, seven, eight, nine -- nine bits to get the number 500.
00:46:21 - Good? All right, second step, reserve the bits in the subnet mask and find your
00:46:26 - increment. Again, we now have a Class A network, so I need to
00:46:31 - write that subnet mask in all binarys. One, two, three, four, five,
00:46:34 - six, seven, eight, dot one, two, three, four, five, six, seven, eight
00:46:39 - dot one, two, three, four, five, six, seven, eight
00:46:44 - dot one, two, three, four, five, six, seven, eight. Trust me, it doesn't
00:46:49 - take you this long when you're not talking as you do it. It just -- it's
00:46:52 - hard to write and talk. So we have to 255.0.0.0
00:46:56 - written in all binary. I now need to ask, am I trying to get more
00:46:59 - networks here or am I trying to get more hosts per network? Now I -- I look at
00:47:04 - that and I say, well, I want more networks. Now I asked that
00:47:07 - question because in the next video I'm gonna show you the second style of subnetting, which
00:47:11 - is host per network. So we say I wanted 500 networks.
00:47:14 - 500 networks need nine bits and I know network bits
00:47:19 - are the ones, so I'll pick up right where the ones leave off and
00:47:23 - go one, two, three, four, five, six, seven, eight -- eight bits per octet -- dot
00:47:29 - nine. One, two, three, four, five, six, seven dot and then those all stay
00:47:35 - zero. So we actually bled past our octet. We moved into
00:47:39 - another octet. So I know my new subnet mask is 255. -- second
00:47:45 - octet is now 255. -- now, if I convert that third octet to
00:47:49 - binary, what is it? Or wait, to decimal? It is 128
00:47:53 - as a decimal number. One, zero, zero, they're all zeros.
00:47:56 - If we line that back up; that's 128. So that is our
00:48:00 - new subnet mask or in bit notation it's / -- we have eight - ones; eight - ones;
00:48:04 - that's 16, 17. /17 is our subnet mask. Wow;
00:48:09 - that's new. Now, here's the unique part about it, what is
00:48:13 - our increment? Lowest network bit converted back to a decimal
00:48:17 - number. Well, that network bit is
00:48:21 - 128. Wow. weird, So our increment is the same as our
00:48:26 - subnet mask. You bet it is. So now we have all the pieces
00:48:30 - that we need to move on to step three and find our network
00:48:33 - ranges. This is where it's going to take a slightly different
00:48:36 - look, but like I'm doing it, I'm adding more pieces on every single
00:48:40 - one of these problems. This is the last piece I need to add. So we
00:48:43 - have the increment to find our network ranges. We started with 10.0.0.0
00:48:46 - hang on,
00:48:50 - let me get a different color here. I know -- I know. Colors don't matter
00:48:55 - but to me they do; they stand out better. So 10.0.0.0 is
00:48:59 - what we were given and what we started with. Now we need to look back at
00:49:02 - this increment and identify what octet the increment is in.
00:49:07 - It's in octet number three. So I can just go and add 128
00:49:13 - to the third octet. 10.0.128.0
00:49:17 - 10.0. -- wait a sec,
00:49:20 - what happens if you add 128
00:49:25 - to 128? 128 plus 128,
00:49:30 - that gives you 256. You can't have 256 in an
00:49:35 - IP address. Well, here's -- here's where I want to show you. Now notice
00:49:38 - first off we added eight network bits. I know we're going to
00:49:43 - get way more than two network ranges with eight network bits. I mean,
00:49:47 - if we did two to the power of X where X is eight, we get
00:49:51 - a whole bunch of networks that are at our disposal with
00:49:54 - this; at least 500. So I know that I can't stop right here,
00:49:58 - so let's fill in the end ranges. Just kinda -- erk -- draw a line. Let's -- let's see where
00:50:02 - things end. This would go, what would be the last IP address
00:50:05 - before we got to 10.0.128.0?
00:50:08 - It would be 10.0.127.255,
00:50:15 - right? This would go through 10. -- well, let -- let's
00:50:19 - do the math as if it worked, right? Let's say that this went to
00:50:23 - 256.0, right? If we were just adding like we were before,
00:50:28 - what would be the last IP address before we get to 256.0?
00:50:32 - 10.0.255;
00:50:35 - that's the last one before you get there, right?.255
00:50:38 - But we know that we can't have 256, so let's --
00:50:44 - let's make a slight correction here.
00:50:48 - Erase that. When we have 255.255, if I
00:50:53 - were to do like a plus one -- think of this as, again that weird twisted
00:50:57 - math problem. I know that I can't go to 256, so this will be
00:51:00 - that'll zero it out, right? 255 plus one and carry
00:51:03 - the one. So we have a plus one there. You can't have 256 so
00:51:07 - zero it out, carry the one and now I have like this 10.1.0.0.
00:51:11 - Hmm; that's exactly what the next range starts
00:51:17 - at. 10.1.0.0
00:51:20 - and then just keep adding our increment. 10.1.128.0.
00:51:23 - 10 -- instead of doing
00:51:28 - this all over again, I will now recognize it and go, well I can't have 256
00:51:31 - so we move up to 10.2.0.0. Let's fill in some end
00:51:37 - ranges here. 10. -- this will be 10.1.127.255;
00:51:43 - that's the last IP address before I
00:51:46 - get to 10.1.128. This goes through 10.1.255.255.
00:51:51 - Last IP address before I get to 10.2.0.0.
00:51:55 - And so on and so on and so on we would go
00:51:59 - down and down and down the range; that's a tough one. I have
00:52:02 - to tell you, that's -- it takes a little logic and a little working
00:52:04 - through that to get it, but that is how you can find those network
00:52:07 - ranges is just identifying where the next one starts and subtract
00:52:11 - one to find where the last one would end up ending.
00:52:16 - Before we end this video, I want to make sure that you get
00:52:20 - some practice because doing subnetting, working through it again and again
00:52:25 - and again and again and again and again and again, is the only way that you're
00:52:28 - going to solidify this skill yourself. So what I have here
00:52:31 - is four problems to do on your own. I have two Class C examples,
00:52:35 - which are by far the most common subnetting styles. But then
00:52:38 - I have a Class B and a Class A example as well. And they do have their
00:52:42 - own little twist break into a thousand networks; break into 25
00:52:45 - networks and that sort of thing. So I want you to take some
00:52:49 - time, grab a piece of paper and work through these problems
00:52:52 - so that you can make sure you can not only observe this skill being
00:52:55 - done on the screen, but do it yourself. Now I know that
00:53:01 - examples or -- or practice problems without being able to know
00:53:04 - if you're right or not are of no use, so what I've done is I've
00:53:06 - actually worked through these problems on my own, and put up my
00:53:09 - results on NuggetLab.com. You'll actually see a file there
00:53:13 - named something like CCENT support files or it'll have some
00:53:17 - identifier that you'll be able to quickly CCENT something.
00:53:20 - And you can download that and you will be able to check your
00:53:23 - work and verify your answers. When I worked these out, I worked
00:53:26 - them out on -- I just did it in a Microsoft Word document. I saved it as a PDF
00:53:30 - file, so everybody can open it. And all I did was -- was walk through the
00:53:34 - three steps. So I have the results of the three steps that you
00:53:37 - would be walking through, you can compare your answers to mine
00:53:40 - and make sure that you're on the right track. This is the first
00:53:44 - style of subnetting that we must master before you move into the next style
00:53:47 - in the next video.
00:53:49 - I know that this video has been a little extra long compared
00:53:53 - to the traditional CBTNuggets video in this series, but I couldn't
00:53:57 - think of a better way to group everything together and show
00:53:59 - you enough examples where you can see at least four different
00:54:03 - scenarios working through different classes of subnetting, based
00:54:07 - on the number of networks. The benefit is you now have the chance
00:54:10 - to just sit down, let it soak in, review this video; review just
00:54:14 - sections of this video multiple times if you need to see some
00:54:17 - examples as you work through those practice problems. I'll also mention
00:54:21 - that when I created those practice problems, I didn't pull them from
00:54:25 - the book or something or -- or what -- what should I do? I just made
00:54:29 - them up and you can do the same thing. Don't -- don't think that
00:54:31 - those four practice problems are the only ones that you can
00:54:34 - do. Just think of a -- a network that you have, you know, 172.16.0.0
00:54:38 - and then just say I want 50, 90, 100
00:54:43 - different networks and then work out that subnetting problem. And
00:54:47 - figure out what the result will be. The key is not only to master
00:54:51 - the subnetting, meaning, come up with the subnet mask and find your network
00:54:54 - ranges, but to be able to do it quickly. I'll talk more about why
00:54:59 - that's essential in the next video. For now, I hope this has
00:55:02 - been informative for you and I'd like to thank you for viewing.