00:00:00 - Let the adventure continue as we move into TCP/IP subnetting,
00:00:05 - Part 2. What we're going to do is build on the foundation that we
00:00:10 - laid in Part 1, which was the three steps of subnetting based
00:00:14 - on the number of networks, as in we had the number of networks
00:00:16 - that we needed and figured out our subnets from there. Well this video
00:00:21 - changes that scenario a little bit, flipping it on end and saying,
00:00:24 - we're going to subnet based on the number of hosts rather than
00:00:27 - the number of networks. Now this assumes that you did, you know you've
00:00:31 - gone through part one so I'm not gonna spend as much time reiterating
00:00:34 - the three steps, but I guarantee you that seeing this
00:00:38 - will not only help you with the scenarios we're presenting right
00:00:41 - here, with these four different scenarios, but you'll also get
00:00:44 - a better feel for even the scenarios from Part 1, because
00:00:47 - it is the same three steps and a very similar process. So let's
00:00:51 - get going.
00:00:53 - I'd like to start things off by a network scenario that's very
00:00:56 - similar to the one that we started the previous video with, so that
00:00:59 - you can see the differences. We have an organization that's
00:01:02 - purchased a Class C address, again 216.21.5.0,
00:01:06 - and would like to use it to create networks
00:01:10 - of up to 30 hosts each. So if you think back before, we were
00:01:16 - trying to work through this scenario based on creating five
00:01:19 - networks, one, two, three, four, five. But this scenario says I would
00:01:25 - like to create networks of 30 hosts each. So they're more
00:01:28 - focused on the number of hosts per network rather than the
00:01:31 - number of networks.
00:01:33 - When working through a subnetting problem of this slant, the
00:01:36 - steps are nearly identical as before. I should say the steps
00:01:40 - are identical, there's just a slight tweak as to what we're looking
00:01:43 - at. So step one was to determine the number of hosts and
00:01:47 - convert that to binary. Just like we saw with the number of networks.
00:01:51 - Here's our Class C subnet that we purchased. We know that we're
00:01:53 - trying to find networks of 30 hosts per network, so that's
00:01:58 - our host. Number of hosts: 30.
00:02:00 - With that in mind, let's break that down using the binary
00:02:04 - 128, 64, 32, 16, 8, 4, 2, 1. Now
00:02:10 - with these numbers in place, again we realize that we're
00:02:13 - only after the number of bits. So we don't need to figure out
00:02:16 - the whole number, although I will just for this example. 16
00:02:19 - plus 8, that's 24, plus 4, that's 28, plus
00:02:22 - two more, that's 30, and then we have a zero for the one. So
00:02:25 - the actual binary number for 30 is 0 0 0 1
00:02:30 - 1 1 1 0. But again, being that we're only after
00:02:34 - the number of bits, we're really focused on, it takes five bits
00:02:40 - to get the number 30. Step two is then to reserve the bits
00:02:45 - in the mask and find your increment. Here's where the slight
00:02:48 - tweak comes in. I'm going to take the original subnet mask, and we start
00:02:52 - off with a Class C example again, 255.255.255.0
00:02:55 - and write that in all binary
00:02:59 - so one, two, three, four, five, six, seven, eight; one, two, three, four,
00:03:03 - five, six, seven, eight; one, two, three, four, five, six, seven, eight;
00:03:07 - and one, two, three, four, five, six, seven, eight. I'll show you how to improve
00:03:12 - your speed on that in just a moment, on the next scenario.
00:03:15 - So we're looking at this right now in terms of, this is our
00:03:19 - original subnet mask and we need to do subnetting. Now in the previous
00:03:23 - video we were focused on, I need to more network bits because
00:03:28 - I needed five networks or 30 networks or 100 networks
00:03:31 - or whatever the scenario said. I was more focused on getting
00:03:35 - networks than I was on how many hosts were on each one of
00:03:39 - those networks. In this style, we're more focused on how many
00:03:44 - hosts we're getting - and yes, we're going to be doing subnetting, otherwise
00:03:48 - we wouldn't be here in the first place. We want to break it
00:03:50 - into networks but we're not as concerned with how many networks
00:03:54 - we get as we are with how many hosts can exist on each network.
00:03:58 - So when you're thinking of this, I want you to just say in your mind
00:04:02 - whenever you see how many hosts per network, just kind of like
00:04:05 - Save the Whales - save the hosts. You can scream it out
00:04:09 - loud, you know, whenever, wherever you want, because what we're
00:04:12 - focused on is saving the hosts. One, two, three, four, five, to
00:04:20 - be exact. Instead of working from left to right saying, I need
00:04:23 - five more network bits, I'm saying I can't get the number 30.
00:04:28 - I can't get 30 hosts without - or I should say
00:04:33 - with any less than five bits. We know that the host bits are
00:04:37 - zero, so we're saving five of them. Save the host, you can say it out
00:04:42 - loud. Now once we've saved the five host bits, the rest of them
00:04:48 - can become network bits. It can move over to the network
00:04:51 - side, the dark side of the force, because we're still doing subnetting.
00:04:55 - We still want to subnet but we're now focused on how many hosts
00:04:58 - we get rather than the specific number of the networks. So with
00:05:02 - that in mind, that is the only difference. So here we go, let's
00:05:06 - work through the subnet mask. Our new subnet mask is
00:05:09 - 255.255.255, and if we convert
00:05:14 - this one back to decimal, that will be.224. If
00:05:19 - we add up all those numbers. Or if we were using the bit notation,
00:05:23 - that would be a /24 plus three more, /27.
00:05:26 - Our increment is the lowest network bit, which is a
00:05:33 - 32.
00:05:35 - That's our increment. Now we can find our network ranges.
00:05:39 - We started with 216.21.5.0
00:05:45 - and then we just start adding 32.
00:05:48 - 216.21.5.32,.5.64,
00:05:53 - .96,.128,.160. You can just
00:05:57 - keep going you far as down as you'd like to go. Fill in the end ranges,
00:06:00 - last IP address before 32 - 31. Before 64 - 63.
00:06:05 - Now I'm really shorthand writing this right now, just to
00:06:08 - save the time, but this is filling in the end range for
00:06:11 - each one of them. It goes from 216.21.5.0
00:06:14 - through 216.21.5.31. Can't use the last
00:06:18 - one, can't use the first one, so we actually get one through 30
00:06:22 - that are usable in between, which is exactly
00:06:26 - the number of hosts that we were looking for. Just how many subnets do
00:06:30 - we get? Two to the power of - well we introduced three more subnet
00:06:35 - bits - two to the power of three will end up being
00:06:39 - this is two to the power of zero, one, two, three, so we end up with eight total
00:06:44 - if we were to work this down the whole way. And if we were to do
00:06:48 - two to the power of five, because there's five host bits that we
00:06:52 - saved, minus two, that leaves us with 30 hosts per subnet.
00:06:58 - Now you might notice that I'm moving through these a little bit
00:07:00 - faster, because we've seen the foundation of the previous video
00:07:05 - where I work through them step by step, working very slow, explaining
00:07:08 - everything as I go along. What I'd like to do here is not only
00:07:11 - of course, introduce the new concept, but to get you faster
00:07:15 - at this as well, to move a little bit quicker through these
00:07:17 - scenario. So if it seems like I'm going faster, I am.
00:07:21 - We have another scenario, same style. We've got network scenario
00:07:25 - number two, Class C example. We have the network
00:07:30 - 195.5.20, and the organization is looking for 50 hosts
00:07:35 - per network. So let's start it off again. Determine the number of
00:07:38 - hosts and convert to binary. I'll write up our binary chart over here
00:07:42 - eight, four, two, and one. We have 50 hosts. So I look right here,
00:07:48 - no, no, yes. Our first one goes at 32, so I immediately know
00:07:53 - it takes six bits
00:07:57 - to get the number 50.
00:08:00 - Sorry, let me just change my font that I'm writing with
00:08:03 - so it's a little thicker so it looks a little neater. We've got 50 hosts equals six bits.
00:08:09 - Now what we need to do is reserve the bits in the subnet mask
00:08:13 - and find out increment. So our original subnet mask is
00:08:18 - 255.255.255.0. I mentioned that I was going to show you a
00:08:21 - way to shorten this down, as well. Once you're comfortable doing this,
00:08:25 - you can look at this and say, well I can't really change the
00:08:29 - 255s, right, because since this was a Class C address
00:08:32 - to start off with, I can't change the original subnet mask.
00:08:35 - Meaning, I can't move it backwards, otherwise it wouldn't be a Class C
00:08:38 - address. So the way I do this is I just think okay, so that would
00:08:42 - be 24 ones, dot dot dot, dot one, two, three, four,
00:08:47 - five, six, seven, eight zeros, because the zeros are really
00:08:52 - your playground. That's where you can work. You can't change the
00:08:55 - original 24, so you can just kind of jot those up there
00:08:57 - like that, just quick shorthand instead of counting them all out.
00:09:01 - Now you have to ask the question, are we creating more networks
00:09:05 - or saving the hosts? And you have to put your hand in the air
00:09:08 - when you do that, it's required. We look and it's after the
00:09:11 - number of hosts. It's 50 hosts per network, so we are saving
00:09:15 - the hosts: one, two, three, four, five, six of them have been saved
00:09:22 - because we can't get the number 50 with any less than six
00:09:25 - bits. The other two host bits can change over to
00:09:29 - ones so that we can do our subnetting process. Once we do that,
00:09:33 - we know that our subnet mask will be
00:09:35 - 255.255.255. And we have two bits, if we add those
00:09:39 - together that would be.192 is our decimal subnet mask
00:09:43 - or a /26, which is the 24 original ones
00:09:48 - of the Class C, plus two more that we just added when we did our
00:09:52 - subnetting;/26 mask. Our increment - 64.
00:09:58 - Box, box, box, box, that is our number that we can use to find our ranges.
00:10:03 - So we say, 195.5.20.0, just
00:10:09 - start adding 64 to the fourth octet, because that's where
00:10:12 - we're at. 195.5.20-.64
00:10:17 - .128,.192, and if we add 64
00:10:22 - to 192, we'll actually get 256. Now immediately
00:10:28 - when you say that, and by this is the same all way down, I'm just
00:10:31 - shorthanding it here. When you see 256, you should immediately
00:10:35 - go okay, bing, I must have reached the end of something right
00:10:38 - there. So I just start filling in the end range, we get 63
00:10:41 - 127, 191, and this goes
00:10:48 - up to 255. There is no 256 because I'm done.
00:10:52 - Meaning I've reached my four network ranges that this will give
00:10:55 - me. I'm done - you might remember from the previous video
00:11:00 - where we actually started carrying over to the next octet. Well you
00:11:03 - can't do that here because you started with a Class C address.
00:11:06 - Meaning, you can't change the original network that you were given.
00:11:09 - You've just subnetted into four networks. And if you look at that, two the power
00:11:13 - of x being the subnet bits, so it'd just be two to the power of two; that's
00:11:17 - two times two is four. So that tells you you only get four network ranges
00:11:21 - with - it would be two to the power of six minus two, you actually end up
00:11:27 - with 62 hosts per subnet.
00:11:32 - Pretty cool, huh? Now a lot of this stuff that I'm doing, if like,
00:11:36 - adding 64 plus 64 plus 64 just comes
00:11:39 - from doing this a hundred thousand times. You'll - as you
00:11:43 - do this again and again and again, you'll practice. You'll get used to seeing
00:11:47 - what typical subnet values are, to where you can just see the
00:11:50 - two bits and go oh, that's 192. As a matter of fact, the longer
00:11:53 - you do this - I'm to the point in my subnetting where I've practiced
00:11:58 - this enough, and obviously teaching helps, so I'll tell you what - find
00:12:02 - a family relative and teach them how to subnet. They'll love
00:12:06 - you for it, and you'll learn it even better. But teaching this, I can just
00:12:09 - look at bits and say oh, that's 192. It's kind of like, have you ever
00:12:14 - see The Matrix, where the guy's looking at the matrix in an encoded
00:12:18 - format and he said, I don't even see the code anymore. I see
00:12:22 - you know, a guy, a girl walking, a blonde, a brunette, you know. It's
00:12:25 - just he's stared at the code for so long, it kind of fried his
00:12:29 - brain. You will get to the point where your brain is fried,
00:12:32 - and you will master subnetting.
00:12:35 - Now you might be noticing as we're working through these,
00:12:38 - I am emphasizing speed. Let me take just a moment and tell you why.
00:12:42 - Speed in the real world is not as critical. It's not like you'll
00:12:46 - be walking into a job where they're like, subnet this now, you've
00:12:48 - got 30 seconds, and that's what you've got to do. I just
00:12:52 - know that a lot of you are preparing for the CISCO certification
00:12:55 - exams. If you're getting ready for those, speed is of the essence.
00:13:00 - CCENT, CCNA, and even CCNP, just about anything
00:13:06 - you do in the CISCO world will have subnetting involved in it and
00:13:10 - you'll have to do it and have to do it fast. So just to give
00:13:14 - you an idea of where we've come from,
00:13:17 - I'm always watching the clock when I'm recording to
00:13:20 - make sure that we don't get too long or too short of things
00:13:22 - like that. When we first did the subnetting examples
00:13:25 - when we were in the previous video,
00:13:29 - we were at about 11 to 14 minutes per problem as
00:13:33 - I was working through and explaining what I'm doing as I go.
00:13:36 - The two problems that we've done so far, the two scenarios, we've
00:13:39 - spent - the first one was five minutes, and the last one was four
00:13:43 - and-a-half minutes working through those. So my recommendation
00:13:47 - is when you're working through these,
00:13:49 - obviously you're not going to have a voice in your head - well
00:13:52 - maybe you will - but explaining it as you go, and you'll be able
00:13:55 - to write much faster. But I would gauge your time and try to aim
00:13:58 - somewhere between two to three minutes per problem,
00:14:02 - when you get to one of these. That's when you know you've got
00:14:04 - it fast enough to prepare for the actual certification exam.
00:14:09 - All right, Network Scenario number three. We've got now a Class B network.
00:14:15 - I've changed it up a little bit, and someone was reading
00:14:18 - CISCO Best Practice Documentation and now it says I need
00:14:21 - 500 hosts per subnet. That's what CISCO says should
00:14:24 - be the maximum. So now we go with our 500, write out our binary
00:14:29 - chart - 1, 2, 4, 8, 16, 32, 64,
00:14:36 - 128 - but I know I must go further in order to get the
00:14:39 - number 500 because that's above eight bits. So I go
00:14:43 - 256 is my next one, double that and you've got 512.
00:14:47 - And immediately I can stop there because I've passed
00:14:51 - my 500. Now that's not where my first one goes. My first
00:14:54 - one goes right here, because I can't subtract 512 from
00:14:57 - 500. So just by drawing my initial one, I can see that
00:15:00 - it's going to take nine bits to get the number from 500.
00:15:04 - Second step, reserve the bits in the mask and find
00:15:09 - your network range. So original subnet mask, 255.255.255.0.
00:15:13 - We're going to write that in binary, which is 16
00:15:18 - ones, dot one, two, three, four, five, six, seven, eight zeros.
00:15:25 - You don't want to shortcut the zeros because that's really where you
00:15:28 - work. Eight. So we've got our 16 zeros. Now are we creating a
00:15:33 - 500 networks or saving
00:15:37 - the hosts. Saving the hosts. Not only is it more fun to say, but it's more fun to
00:15:41 - do. We have nine bits right to left, one, two, three, four, five,
00:15:46 - six, seven, eight, dot
00:15:50 - nine. We've crossed that octet boundary. The rest of them
00:15:54 - can become one. One, two, three, four, five, six, seven. That was the
00:15:58 - rest of those bits that were in the third octet. So with that
00:16:02 - in mind, I can look and say my new subnet mask is
00:16:06 - 255.255.254.0, is that guy,
00:16:12 - or a /23. I just think of Class C address with
00:16:16 - all these being one is a /24, so we subtract one. Our
00:16:20 - increment, circle that guy, that guy is two, in decimal.
00:16:24 - So we look at what octet that increment is in. It's in
00:16:28 - the third octet, so I start down here with 150.5.0.0
00:16:34 - and I'll increment in that third octet: 150.5.2.0;
00:16:39 - .5.4.0,.6.0,
00:16:45 - .8.0, and so on and so on we go. The end range goes
00:16:49 - through 150.5.1.255.
00:16:55 - This goes through 150.5.3.255.
00:17:00 - This goes through 5.255, and so on, whoop; 255.
00:17:04 - And so on and so forth we go down the way.
00:17:08 - If you were watching the clock on that previous network scenario
00:17:11 - number three, it was two minutes, 54 seconds we took, once I
00:17:16 - got out of my, you know, once we started actually working
00:17:19 - on the problem. Pretty good. That's the kind of time frame you
00:17:22 - need to be looking out for these. All right, now work scenario
00:17:25 - number four. Class A address, we have 10.0.0.0 and need
00:17:31 - 100 hosts per network. So 100, how many bits does it take
00:17:35 - to get that number? 128, 64, 32, 16,
00:17:39 - 8, 4, 2, 1. Our first one goes right there so immediately
00:17:44 - I know it is seven bits.
00:17:48 - Step two, our original subnet mask
00:17:50 - was 255.0.0.0, which is eight ones, dot
00:17:57 - one, two, three, four, five, six, seven, eight, dot one, two, three,
00:18:01 - four five six seven eight dot one two three four five six
00:18:06 - seven, eight. Can't really shortcut Class A subnet masks. So we've got 24
00:18:11 - zeros that we're working with. So with that in place, we know that
00:18:15 - we are needing seven bits and that we're after the number of
00:18:18 - hosts. So save the hosts, right to left: one, two, three, four, five,
00:18:24 - six, seven, one. So that's our eight bits of our last octet. What happens to
00:18:30 - all the rest of these bits? They change over to one. So we did quite
00:18:35 - a number of subnets when we went with this Class A address.
00:18:38 - So we ended up going to 255.255.255
00:18:42 - dot, and then the last octet is 128.
00:18:46 - Our increment is - circle that - 128. Happens
00:18:52 - to be the same as our subnet mask. So now with our network ranges, we start
00:18:57 - with 10.0.0.0. Now to find out where to increment,
00:19:01 - we need to look at where our increment is at. It's in the last
00:19:04 - octet over there. So I say, 10.0.0.128
00:19:10 - the fourth octet is where I increment. 10.0.; oh,
00:19:13 - stop right there. If I add 128 to
00:19:16 - to 128, I'll get 256. I know that's
00:19:20 - not possible, so
00:19:23 - if I fill in the end ranges I'll have 128 to -
00:19:27 - or zero to 127, is the previous one. This goes
00:19:30 - up to - if the next one was 256, this would be 255.
00:19:34 - So again, do that - we did this in the previous video, just
00:19:38 - kind of add the one, carry it over to the next octet, we start with
00:19:41 - 1.0, 1.128, 2.0, 2.128,
00:19:46 - and so on and so forth we go down the way. Fill in the
00:19:50 - end ranges. This goes through 10.1 - or 10.0.1.127
00:19:53 - through 10.0.1.255.
00:19:59 - Sorry, I'm - I was trying to beat the clock. I'm sorry. But that
00:20:04 - that's how we're going to work this. Sorry for the extreme
00:20:07 - shorthand, but this is working through a Class A
00:20:12 - example and we would keep on going, keep incrementing through
00:20:15 - all of the Class B and C octets. So if you wanted to find
00:20:19 - how many subnets you would have, it would be two to the power of - we converted
00:20:24 - one, eight, 16 - two to the power of
00:20:30 - 17. So that would be 17 bits total. I had to think about
00:20:33 - that one - will tell us how many networks you'll have. Thankfully
00:20:37 - if you're preparing for the exam, they will never have a question
00:20:40 - asking you that kind of math without a calculator. So I'll do two to
00:20:43 - the power of 17 equals - yeah, 131,000
00:20:48 - subnets are at our disposal when we subnet a class
00:20:52 - A address like that. Excellent.
00:20:57 - At this point, you should be getting a little better feel for
00:21:00 - how this subnetting works. As I did in the previous video, I have
00:21:04 - an on your own section. It's essentially homework to work through.
00:21:09 - Four different examples of, this time, breaking into networks
00:21:12 - based on host requirements rather than network requirements.
00:21:16 - As I did for the previous video, working through these without
00:21:19 - having an answer to check yourself isn't very helpful, so I've
00:21:22 - typed up a little walkthrough for each one of these, essentially
00:21:25 - the three steps we've been working through so far, so that when
00:21:28 - you finish them, you can compare your answers to what I have.
00:21:31 - That's available off of nuggetlab.com, and just look for the
00:21:35 - CCENT pack of some sort. It'll be a zip file where you can download
00:21:41 - all of this paperwork. We've got, after this, one more style of
00:21:45 - subnetting to show you. And in my mind, it's the easiest but
00:21:50 - it's the most common style that's out there.
00:21:54 - Let's talk about, before we get into the new style, where we've
00:21:58 - been so far. At this point, you should know how to subnet based
00:22:02 - on the number of networks, if you were given x number of networks
00:22:05 - you can break apart addresses and break them into subnets
00:22:08 - that meet those requirements. And you should be able to do that
00:22:12 - for hosts. When somebody says, I need this many hosts per network,
00:22:16 - then you can work through that, save the hosts, and
00:22:21 - meet those requirements and come up with a subnet mask and
00:22:23 - network ranges to deliver. I hope this has been informative for you
00:22:27 - and I'd like to thank you for viewing.