Jumpstart Juniper—Intermediate
![John Lusk Headshot](/content/dam/www/assets/mediaportal/speakers-hosts/2023/john-lusk.jpg/jcr:content/renditions/cq5dam.web.1280.1280.jpeg)
![Screenshot from the video showing an image of a man speaking in the lower right corner and text reading, “Think About It… which of the prefixes are part of the 10.1.0.0/20 aggregate route?” followed by a series of prefixes with a check mark and an X next to them.](https://i.ytimg.com/vi/JTPduAO31ug/hqdefault.jpg)
Uplevel your Junos® operating system OSPF configuration and monitoring operations in part two of the Jumpstart Juniper series.
It’s time to take your Junos OS skills to the next level. Watch part two of Juniper Networks’ Jumpstart Juniper series to gain a better understanding of OSPF (Open Shortest Path First) configuration and monitoring operations on Junos OS devices.
Read, “Day One: Deploying Junos Timing and Synchronization.”
You’ll learn
How to configure multi-area OSPF
How to adjust OSPF hello/dead timers
Who is this for?
Host
![John Lusk Headshot](/content/dam/www/assets/mediaportal/speakers-hosts/2023/john-lusk.jpg/jcr:content/renditions/cq5dam.web.1280.1280.jpeg)
Experience More
Transcript
0:00 even as wired and wireless devices sort the network Edge today's business critical Services require more
0:06 predictable reliable and measurable networks users demand a seamless personalized experience based on user
0:12 type and location it's no longer enough to Simply keep the network up and running it's about ensuring a great
0:19 experience across the network for every user and network device addressing problems before clients are even aware
0:25 of them how is this accomplished with an AI driven Enterprise only from juniper
0:30 Mist Juniper Mist transforms the network experience and simplifies operations with artificial intelligence while
0:37 delivering on strategic initiatives with virtual Bluetooth location-based services and Analytics now you can
0:44 report when users or devices are unhappy or analyze traffic patterns through a retail store alerting shoppers with
0:50 location-based special offers in real time all network data is ingested into the missed AI engine for continuous
0:57 learning and Improvement and Marvis the virtual Network assistant is the Alexa for it teams Marvis helps keep the
1:04 network running seamlessly and simplifies troubleshooting with recommended or self-driving actions across the WLAN Lan Wan and security
1:12 domains this is true AI driven Enterprise for Wired and wireless networks Juniper mist
1:19 is leading a new era of I.T that uses AI to save time and money deliver unprecedented scale and provide
1:26 unparalleled user experiences let us know when you have 15 minutes to learn more
1:33 welcome to jumpstart Juniper this is the intermediate course this is the second course in the series of junos routing
1:42 my name is John Lusk I am from the Juniper University Education Services Department and I'll be your instructor
1:50 for the day today we're going to go over protocol
1:55 independent routing and some ospf beginnings
2:00 so let's start with protocol independent routing we have a static route as most devices
2:08 can have so on junos we would put those static routes under the edit routing
2:13 options hierarchy now that hierarchy will allows to manually insert a route
2:19 into the system so for you to insert this route you'll need to have a prefix
2:26 a destination prefix that you're trying to get to and a next hop and the next hop is a directly connected interface
2:33 with the IP address that is not on the device so the the next hop typically has
2:41 an IP address on it but we can also add a couple other things we can add a discard or a reject now the discard Next
2:49 Top option throws away the packet instead of forwarding it and doesn't tell anybody it threw it away and the
2:56 reject it throws it away but then it sends a message back saying hey I threw your packet away I just wanted to let
3:02 you know and so for security reasons you usually want to use the discard so you're not telling people or stuff's thrown away at
3:10 we also have a qualified next top that we can add on instead of just a next top and this qualified next hub what it does
3:16 is it allows us to add a different preference value to a secondary next top for the same route
3:23 so this gives one route two different ways to go and then you can control which interface it should go out should
3:30 you go out the next top interface or the qualified Next Top interface when you're setting these up uh if you
3:39 don't see your next if you don't see your route inside of the routing table one of the biggest reasons for that is
3:44 probably you mistyped the next top address or that next hop addresses interface is not up at the time and
3:51 those are the two big reasons why you might not have a a Next Top Value
3:59 so let's look at our configuration example here here's some examples of an
4:04 ipv4 static route and then you see inside of here we have our defaults under the static routes and
4:12 the defaults let us know um let us set up the different uh default preference values and different
4:18 values that we might have in this case a static route if you remember has a value of five and we're going to change that
4:26 value up to 250 here so so basically what we're going to do here is we're
4:31 going to set this up so it says if all the dynamic their Dynamic routing protocols uh stop
4:39 working then I'm going to have a default uh static route to take over and and
4:44 move the traffic where I might want it to go so let's look at our first drought our first route is a default route it
4:51 has a next hop and it has a uh qualified next hop and if we see underneath that
4:57 qualified Next Top we have a preference value of 251. so since the default
5:03 preference is 250 the qualified Next Top was at 251 is less preferred right we
5:10 always prefer a lower number on those routes and then one of the last things we want
5:18 to look at is down here at the bottom we have this no re-advertise we have hooked
5:23 to it and there's no re-advertise what it does is it says hey even if you're supposed to
5:28 re-advertise this um route don't re-advertise it don't let it get
5:36 exported into ospf or into bgp and sent
5:41 on to another device this is really great for management networks for management interfaces and things like
5:47 that where you're trying to get information off of one device but you're not trying to tell another device how to
5:52 how to route back to this other network they should have their own route to that same network
5:58 so that's the no re-advertise then we have our IPv6 now the IPv6 works
6:06 exactly the same way as the ipv4 except for we need to put it into a different router information base and here we see
6:13 we put that into one called inet 6.0 that is the routing table uh for inet
6:20 for for IPv6 so here we see it we have our static route that's exactly the same
6:25 but then of course we use IPv6 addresses instead of ipv4 addresses and we can set
6:31 up our preference values on those also
6:37 all right so here's just a little test for you which next hop do you think is
6:42 going to be used as the primary link right so we have a next hop to the 172 30 25.1 and a next top to the 172 30
6:50 25.5 and we see that it has a preference value of 7 for the qualifying next top
6:56 so which one do you think it's going to be hopefully you got that right the
7:02 qualified Next Top is going to be the primary because it has a lower preference value than the defaults that
7:10 we set up right above there I have 180. now if we hadn't set up that uh that
7:17 default preference value up above then the default preference value would have been five and then the the next top to
7:24 172 30 25.1 would have been the uh address or the the next top we would
7:31 have taken for that one then made that one primary
7:38 all right our second little Theory test here is to do which of these static
7:44 routes are going to be exported if you look over the policy on the right hand side you see that there's a route policy
7:51 that we're going to put into ospf and that route policy has a 172 29 16 built
7:59 into it and what that is saying is that anything that starts 172.29 is going to
8:06 be accepted or it's going to match on this policy if we go look at our routes
8:11 we have a 172 29 12 a 172 29 13 and a 16
8:16 and a 20. so now that policy matches all of those right
8:22 but which one are they all going to go or is not all of them going to go so
8:27 again we have that no re-advertised there and you'll see that that one is not going to go
8:34 um over because of that no re-advertised but all the rest of the routes will be brought in and put into ospf from that
8:42 uh from that policy all right so that's our our static
8:48 routes we'll move on to our aggregate routes now aggregate routes is an
8:53 important skill for Network Engineers to have what
8:59 we're going to do is we're going to take our specific routes that we might have with inside of our company and what we
9:06 want to do is we want to make one generalized route or at least less generalized routes as we go out now one
9:13 rule that you really want to make sure you do is you don't want to advertise routes that you don't have control over
9:18 this has caused tons of issues across networks uh forever and so we want to
9:25 make sure that when you go ahead and you aggregate these routes that you're only sending over routes that you have
9:32 control of and so that's probably going to mean that you're going to have to send more routes over uh you can't
9:39 you're probably not going to be able to aggregate routes down into one route because if you did that you might
9:44 advertise routes that you don't own or you don't control
9:49 so go let's go ahead and take a look at an example here real quick
9:55 which of these prefixes is part of the 10100 20.
10:00 now it's easy when it's a slash 24 right we have 24 bits in our subnet mask and
10:07 when we take that it breaks it right at a decimal point but when we have something between 16
10:14 and 24 it doesn't break it right at a decimal point so it makes it a little bit harder to to calculate but one way
10:23 that you can look at this is this is a slash 20 right so we're losing four bits
10:28 and 16 there's four bits on that side so we got four bits on the network side and
10:34 four bits on the host side and so those four bits we know we can only get up to
10:39 15 right we can go from 0 to 15 uh with those four bits
10:47 and so what we want to look at here is we go oh that makes it easy if we look
10:52 at it that way the 10 114 and the 10 115 are going to be within that bit range
10:58 and the 10 116 and the 10 117 are not going to be outside of that range
11:05 now again we could have you know pushed out maybe a 19 10 1 0 19 but that would
11:13 have taken in what 32 different routes we'd have gone from um zero all the way up to 31 and and
11:21 that's way too many right we you can't send out routes that you don't have control over and so this is a good skill
11:29 and you'll you'll see here in the demo in a little bit how that uh junos can
11:35 help you aggregate the routes and understand what um what where's the aggregate what's the
11:41 best ad group you can use you can use junos to actually help you out with that
11:46 configuring aggregate routes is under the same hierarchy as a static crowd
11:51 it's under the routing options hierarchy aggregate routes must have at least one
11:59 contributing route that means that there's got to be a smaller route or a more specific route
12:06 for that aggregate route so in our demo here we have on the left hand side we
12:12 have three routes we have the 172 29 0 1 and 2 Networks and we created a
12:18 aggregate of 172.290. uh 0.0 22.
12:25 and that's what we're sending over to our ISP uh to be told about now uh we do
12:33 know from that we're probably we're sending off another one this 172 29 3.0
12:38 but let's say we have control over that we just haven't set that Network up yet
12:43 now down below here we do a show route protocol Aggregate and we see we do have
12:50 that aggregate route and we see the default is reject and the so there isn't
12:56 a next hop for an aggregate route the next hop for the aggregate route is one
13:02 of those contributing routes so you're using the aggregate to advertise or to
13:08 draw interest in a certain route so you say hey look send it to me I know where
13:14 that's at and so we will send that route over that that
13:19 packet over be based on the aggregate route but once it gets to R1 R1 is going
13:25 to find a more specific route to Route that into and not use the aggregate now
13:31 if we do use that Network D that we have down there the three 172 29 3 we'll get
13:38 a message back saying hey we dropped this because the R1 will drop it because there isn't a more specific route for
13:46 the 170 29.3
13:53 so here's our actual configuration for it again it's under routing options aggregate we can add defaults just like
14:00 we can for the static so we can change the preference values add communities there's a bunch of different things that
14:06 you can set up as defaults and then we have our route we have a route 172 2900
14:14 22 and that is 172.25 16 that we're
14:19 sending in all of these are are we have the two Aggregates and then you see on
14:24 the 17225 we don't want to reject it we want a discard and that discard says hey
14:30 look I'm just going to throw that packet away if it comes and there's not a a longer matched route or more specific
14:37 route and and then I'm just not going to tell anybody I threw it away
14:43 so that is what the discard does there but reject is is our default
14:50 um option so we can view the contributing routes
14:55 using the show route with whatever prefix that you have there and do an exact detail and you'll see that the
15:03 aggregate route comes up if you put the right prefix in there and so we see that once we do 2900 did show up here
15:12 it uh uh an aggregate so it has a a preference
15:17 of 130 and then we have the default uh hop type which is reject and so those
15:24 are set up but then down below you can see we have some contributing routes we have three of them and those
15:30 contributing routes let this aggregate route Go Active in our routing table
15:36 and so once we have those contributing routes we can we could go and dive into those a little bit and see what make
15:43 sure those are working right too if we're having some issues
15:49 all right so here we I've kind of talked about this already but R1 might have an
15:57 issue when packet B is received so we see packet B comes in and it's destined
16:03 to 172.29 3.5 and we don't have a network we don't have a more
16:10 a more precise or longer match route to go to and so we're gonna throw that away
16:17 we're going to reject that okay our last of our protocol independent routing is a generate route
16:25 a generate route is a route a very similar to an aggregate route but it uses a Next Top IP and that next
16:34 hub IP is given to it from the largest contributing route that it has just like
16:41 the aggregate routes had those contributing routes we have a contributing route and a generate route and when that's there we'll use whatever
16:49 the next top for that route is for the generate route now this generate route
16:54 is often used to create a default route or a or a route of Last Resort for your
17:02 your network and so for an example here we have here our tier one ISP down below
17:10 uh sends in a route through bgp and if we have that route what we want to do is
17:17 generate a a default route but if we don't have that route we'd like all of
17:22 the routers in our system to not have a default route so it'll just throw all those routes away and say look I don't
17:28 have a route to host why send traffic down a pipe if there's nowhere for it to go and so that's what we're looking for
17:35 we're looking for uh some type of a service that says hey if you are there
17:41 then I have I have service that works and I'm going to generate a route to send traffic down this pipe
17:48 so let's take a look at it here so here's our ISP on the right hand side it's going to send in this 10 16 route
17:56 through bgp and when it's present R1 will generate a uh default route to send
18:05 over to R2 and R3 so that R2 and R3 know how to get out but if R2 but if R1 loses that bgp route
18:16 from the ISP what we're assuming is that Lynch is down and we have no way to communicate
18:22 so why send all your data over to R1 just to be thrown away at R1 we could
18:27 throw it away at R2 and R3 just as easily since there's no way out of our Network
18:34 so let's see how we would set this up and configure this so here we're going to set up a policy
18:41 and in this policy what we want to do is we want to match that route that's coming in from our ISP so here in this
18:49 case we're going to match the 100 16. so when we have that in there we just go
18:56 ahead and hit accept there and then we have this term else reject
19:02 that is going to reject all other routes in this policy that we make so that this
19:08 so that it will not create a route when it's not there so then we have another policy that
19:15 we're going to make and this is to the policy to export the default policy and
19:20 so the a generate route is an aggregate route and so when we create a policy for
19:26 that we're going to create it under a the protocol aggregate and so then we're going to make a route
19:34 zero zero zero zero exit exact and then we'll accept that uh once it's created
19:43 so then we move over to routing options and we go ahead and create our route
19:49 route zero zero zero zero and then we apply the policy to the generated route
19:55 policy match contributing prefix there and then we're going to head and Export
20:02 that default route if it exists and so then we'll go down and create an export
20:08 an export default which will export a default route only when that generate
20:15 route is created and is working
20:20 so let's go ahead and take a look at it so we're going to do a show route 0 0 exact detail
20:26 and we see here we it's a again we see that it's an aggregate route
20:32 and but we have a next hop on that of 172 30 25.1 which we got from our
20:41 main route that came in right that was from our contributing route and so that is where that uh IP came
20:50 from and so then we see our contributing routes down below just like we did below and where it came from in this instance
20:57 it came from bgp so once we have that all running we know
21:03 it should be working so then we can go over to R2 and ask it if it has the
21:09 default route and voila it does it came in through ospf 150 because it wasn't
21:15 learned by ospf we put it in there through a policy and so it has a route
21:21 back to R1 so that it has a way out to the ISP
21:27 so that is generate route it's a fantastic way to manage your your
21:33 routing and have a default route and other types of routes when you need to
21:39 make sure there's another route further Downstream for your device and if that route goes away just go ahead and remove
21:46 that route out of the routing table all right we now have a static and
21:51 aggregate route demo in this demo we have two routers R1 and
21:57 R2 hooked together through the ge000 interfaces
22:03 and what we want to do is we want to be able to connect from the one loop back on our
22:09 one to the loop back on R2 so let's go ahead and take a look at
22:16 these routers and see what we have so here if we do an example here and we
22:23 try to Ping 192.168.1.2
22:32 there is no route to the host from this router and the same would be true if we
22:38 tried to come back the other way if we tried to Ping 192.168.1.1
22:44 it would not work either all right so but if we try to Ping just
22:51 the interface the ge000 interface that should work so we can do ping 170
22:58 2.30.25.1
23:04 and we can see that interface so if we do come here we can say do a
23:09 show route and we will see that we have a route to
23:16 this 172 30 25 it's a directly connected route right there that we have to the
23:24 ge000 interface so just because we have the IP address on that interface we get a a route in
23:32 the routing table so it knows how to locate that off the ge000 interface all
23:38 right so the first thing we want to do is we want to add a route to the loopback on R2 so let's go ahead and do
23:46 that we're going to go into configuration mode we're going to do set routing options
23:53 whoops I meant edit routing options Set static route and then we're going to
24:01 put the prefix or the IP of loopback 2
24:07 192.168.1.2 and we've got to do a slash 32 on that since it's a loopback
24:13 and then we got to do a Next Top and the next top is going to be the IP
24:18 address on ge000 on R2 so we'll go ahead and put
24:24 that on there 172.30 1.25 dot two
24:33 that's our next top so we add that in there let's just do a show real quick we can see we have our route and go ahead
24:41 and do a commit now if we try to go ahead and ping that
24:47 uh inter or the loopback again ping
24:52 192. whoops Dot 168.1.2
24:59 oh look see now we know how to get to that but we're not quite communicating between
25:06 loopbacks right now because if we come back over to our our slides here
25:14 what we're doing is we're actually picking up the IP address off ge000 is
25:20 the source so R2 knows how to get back to that Source address so let's go and
25:26 Source the Ping from the loopback address and see if it works now so we're going to come here and we're
25:32 going to do a Ron ping a
25:38 192.168.01.2 and then we're going to do Source One
25:44 7 192.168.1.1
25:50 oh and we don't get it doesn't work right now because what we don't have is we don't
25:57 have a way for it to come back if I come back over to R2 and I did a show route
26:04 it doesn't know how to get to the 192.168 1.1 so we need to add a route on
26:10 this side so we get full communication so we'll go into configuration mode here and do the same thing
26:18 and we're going to do Set static route uh
26:26 192.168.1.1 this time slash 32 next hop
26:31 is going to be 172.25 30. sorry 30.25.1
26:41 and we'll go ahead and commit that then as we come back over to our R1 and
26:49 we do that ping now we get replies back we have full communication reachability
26:55 from the loopback on R1 to the loop back
27:00 and on our two we'll bring that slide back up here so that is our static routing demo
27:10 all right we have our aggregate route demo now and we have a business partner and he's sitting out here on R1
27:18 and what we want to do is we want to be able to send all of our routes over we have the 10.1.0 to the 10.1.15
27:26 Network minus the 10.1.12 the 10.1.13 and the 10.1.14 networks
27:33 so we don't want to send that whole range over we need to make sure we don't send over networks that we don't own so
27:40 we don't cause any Mis routing out on the business partners Network
27:47 so we could just send over 13 routes we could send over a bunch of Slash 24s but
27:53 we would like to send the least amount of routes possible over to our business partner partner and so that's where this
27:59 aggregate routes demo comes in is we're going to try and send over one maybe two
28:04 three routes instead of uh 13 routes to cover all of our routing prefixes so
28:12 let's go ahead over to our routers and take a look at this all right so here on R1 let's go ahead
28:18 and look at our routing table so we can do a show route protocol or we'll just look at the
28:25 inet table I table inet dot zero table
28:31 here we see we have some directly connected routes on our device but we
28:36 don't have any routes uh coming in from the network that we need to send over
28:42 so we can come over to our our R2 router here
28:47 and let's see if we have the routes there so if we do the same thing we do show
28:52 route table inet.0
28:57 and there we have it we have a default route we also have our
29:03 10.1.0.1.2.3.4.5.6.7.8
29:10 all the way to 11 and then we have 15. and then we don't have but see you
29:17 notice there we do not have the 12 13 and 14 Network so we do not want to send those over and cause routing issues on
29:25 our partners Network so what we need to do is we need to make an aggregate route that would send those
29:31 over to our our business partner so let's go ahead and go ahead on R2 and
29:37 set up an aggregate route that would get sent over there so we'll go into configuration mode
29:43 and we'll do a set for routing options
29:49 uh aggregate route and then we'll set up the route 10.1 and I know if I do a
29:55 10.1.16 it's going to cover that whole range right so we'll go ahead and do that set next
30:02 top um aggregate oh aggregate route
30:08 10.1.16. so we'll do show routing options and we
30:15 see we have our aggregate route sitting there so if we go ahead and commit that
30:21 and come back over to our R1 here we'll see that we have a route now
30:29 they're the 10.1.0.016 route showed up now that's
30:34 way bigger than the networks we had but we just wanted to see that they were there so if I do a ping
30:40 and I do 10.1.1.1 that we know that's over there
30:47 um we'll go ahead and do that and we get a reply from there but what happens if we
30:54 ping one of those networks that we don't have we got a 10.1 dot uh let's see we
30:59 have a 13.1 oh we get an unreachable notice back
31:05 now we get an unreachable notice because of our aggregate route uh it it has this
31:13 anywhere the 10.1.0.0 if we go ahead and look at our routing table again let's
31:20 come over to R2 and look at that routing table again
31:26 I don't want to see run show route
31:32 and we see we have an aggregate route here for the 10.16
31:38 but if you notice it's reject and reject is what's sending these over here these
31:45 messages back so we could change that and we could say edit routing options
31:53 Aggregate and we do a show and we do just set route the 10.1.16 there's live
32:02 16 and we can say discard we go ahead and commit that
32:08 and once that's committed now if we do a ping over to a network that we don't own
32:15 or that they don't own we do not get a net unreachable message
32:20 back but now you got to remember the pings is still going across there right we're still using a bandwidth we just
32:25 don't get notified where we're getting lost at in in the mix here
32:31 so a little bit better on security a little less on what's actually going on
32:36 on our Network all right so let's come back over to R2
32:42 here real quick and take a look at our and and get rid of this aggregate route
32:48 right so let's just say delete and yes we want to delete everything at
32:54 this level and now we want to set a smaller route and we can actually use junos to help us
33:00 find uh and and do our routing here so if we do a show
33:07 we'll do a run Show run show route and we do a 1 or 10.1 slash 16. that's
33:15 what we set up to in the first place we see we get all of those routes and so we
33:21 could keep going 17 um we still have all of our routes right
33:27 1819 we'll Skip One there because this still has all of our routes and when we
33:33 get to a 20 we're getting closer to what we're really looking for there that still has all of our routes there
33:39 has um up to the 15 still so if we go to 21
33:47 oh there we go now we split those in half right so now we got from zero to
33:54 seven on on that route so we could go ahead and add that route in so let's go ahead
34:00 and do that we can do set route
34:06 10.1 slash Twenty One and uh we'll go ahead and put the
34:12 discard back on the back of that so now we have one of our routes in for
34:18 our aggregate but now we still need to get you know 8 to 11 and then 15 sent over so how are
34:27 we going to get that so what we can do is we're going to go ahead and do our
34:32 route run show route but now we need to switch up to the eight here slash 22
34:40 and we don't have any routes there 21
34:45 show route 10 Dot oh I did put that in the wrong spot
34:53 um 10.1 .8
34:58 slash 21. okay so there we have our 8 9 10 and 11.
35:07 uh but then we also are going to be sending over the other one so let's go one more 22.
35:13 there we go so there's our 8 9 10 and 11. so we want to go ahead and send that one too so let's go ahead and send set
35:21 that one up so we do set route 10.1.8
35:30 slash 22. and we'll go ahead and send that one
35:35 over and so now we just have the 15 so we can do set route
35:41 10.1.15 um slash 24.
35:49 so now if we go ahead and commit those
35:54 what we should see over here is we should see our routes that we want to see show
36:00 route table we see we have the 10.1.0 uh Slash 21 the
36:09 10.1.8 22 and the 10.1.15 24. so those
36:16 all got sent over and so we can break that down into three routes for us so
36:21 let's try the Ping here real quick again we have the 10.1.8.1
36:29 and we get a reply from that but what happens if we go to our uh our 13.1 again
36:38 and there's no route to host right so if there's another route that comes in it'll pick that up and send it where it
36:44 needs to go that's exactly what we'd like to see there so what we did is we basically just
36:51 instead of sending 13 routes we were able to break our subnets down into three routes that we were able to send
36:57 over to our business partner and that's our demo on aggregate routes
37:03 all right our next agenda item is load balancing load balancing consists of having two or
37:11 more equal cost links between two routers if this is a scenario we can use
37:17 equal cost multi-path to to send traffic across both of these links to utilize
37:24 both of them so it's also called ecmp equal cost
37:31 multi-path we can we can take this and use it we we
37:36 want to be able to use all the links that we have in a network so that we don't just set up links and they're just
37:42 sitting there it might be good for backup but why not be able to use it and while it's sitting there
37:50 so in the beginning Juniper used a per packet flow meaning that a packet the
37:58 one conversation coming from one computer to a server might send packet a across one link pack it B across the
38:04 other link packet C and it would round robin those packets across the different links this caused some issues and
38:12 packets arriving out of order and being able to keep up with uh different
38:17 protocols like voice and video uh it just didn't work out very well so back
38:23 in around 2000 Juniper changed the per packet flow into a per flow algorithm
38:30 now this per flow algorithm does kind of the same thing but when we start up a
38:36 conversation with one computer that conversation stays on one of the links and if we start up a second conversation
38:43 with another computer that conversation could go across a different link and so
38:48 here we're still using the same but now all of our packets don't arrive out of order and things worked out a lot better
38:58 so when we try to figure out which link we're going to take we take the source
39:03 IP address the destination IP address and the protocol and the incoming interface and we take this information
39:09 and we decide which link to put the conversation on on when we're when we're
39:15 sending data and so definitely if we're going to a different server that's a different destination IP address and so
39:21 we could get onto a different link with that information
39:28 so in Juniper they called it per packet inside of the configuration and it's
39:35 still called that today but by the end of 2022 we'll actually be able to say in
39:41 the configuration per uh flow load balancing instead of per packet load balancing but as of right now it's still
39:48 per packet load balancing that's going to be in the configuration but basically all of that's doing is turning it on or
39:54 turning it off and the Asics that are defined that that are placed inside the
40:00 device take that command and do what what they need to do now since
40:06 the year 2000 they have not done per packet load balancing so almost all of
40:12 your your gear and equipment that are out there is going to do the per flow load balancing
40:19 so by default junos does not load balance so we could have two three four
40:25 equal cost paths between two routers and Juniper is not going to use all
40:31 those links what it's going to do is it's going to find the longest match prefix and then it's going to find the
40:38 route preference and then if the routes are fine through the igp it's going to use a metric or cost on those or if it's
40:46 using bgp we're going to use the bgp route selection criteria that we'll talk
40:51 more about in the next course the advanced junos routing course so if at that point we get down to this
40:59 point and all three or four interfaces still have the same metrics and everything's equal then what junos does
41:07 is it just randomly selects an interface and puts that into the forwarding table for us
41:13 so that is how we do it by default so if we want to use this option we need to
41:19 actually go configure it and turn it on so let's look at our our routing table
41:27 here so if we do a show route on a link we see that we have a active route going
41:34 across there with the the little carrot to the side now this lets us know that
41:41 that route is going to go any traffic going to that prefix is going to go across g002
41:51 and what if we want to use more of our links to go across there well that's
41:57 where we're going to turn this on but we also look down here at the forwarding table really quick and we see that it
42:03 only picked the one interface to go to for that route so we see that we've only got that one
42:12 selected so what we want to do is we want to change the default behavior of junos at
42:20 this point to be able to pick multiple routes that might be equal cost and put
42:26 them into the forwarding table for us and so what we need to do is we need to create a policy to identify which routes
42:33 we'd want to load balance and then we need to apply that policy to the forwarding table
42:39 so let's look at the configuration here in the configuration we have a
42:45 statement up here under policy options policy statement called load balance all
42:51 and if you see inside this policy we do not have a from statement and since we do not have a from statement we're going
42:58 to match on all traffic going through the device
43:03 down here though we just want to load balance some of the destinations so we put some route filters in there and we
43:10 say hey look we want to load balance just these destinations that we're going
43:16 to and you can do that too now again we say per packet down here but depending
43:22 upon the device you have it's either going to be per packet or per flow which most of the equipment that's out there
43:29 live right now it's going to be per flow
43:35 so then what we need to do is once we have that policy created that we need to
43:40 apply that to the forwarding table and we do that under the routing options hierarchy and say hey look under the
43:47 forwarding table we want to export that um that policy that we just created on
43:53 the last slide and then we apply that and that way the forwarding table knows that it can go
44:00 and find multiple paths for that traffic
44:05 all right after we have those created we just want to verify that the load balancing is working correctly
44:12 and so we can go to our show route forwarding table and look at the
44:18 different uh prefixes that are being pushed into our forwarding table and here we see a prefix the 172 2400 and
44:27 we'll look for that you list type and under that it says hey look we have some
44:35 you cast um places where are we going to send this traffic and underneath of that
44:41 you'll see we have two different options there for the U cast meaning that we are
44:47 going to load balance across those two links any traffic that comes in
44:54 for those for that destination that we have there now if we use the the all of
45:00 them all of your destinations that show up inside of here should have the multi
45:05 uh path uh for you to send traffic across
45:12 now we use a hashing algorithm to decide which interface to send traffic across
45:18 and by default we're going to use the incoming interface we're going to use the source and destination
45:25 um IP address and we're going to use the protocol that's there now as you can
45:32 think through scenarios this knot might not be the best load balancing method right what if we added the port number
45:40 of that traffic also as one of the hashing algorithms then traffic going
45:45 between two machines could get load balanced across those a little bit easier and so we have an option for that
45:52 where we can maximize the algorithm and so underneath the forwarding options hash key family inet we can add layer 3
46:00 and layer four add that layer 4 there and so now we're going to add the source
46:06 and destination port numbers as part of that hashing algorithm which would definitely help us get uh traffic pushed
46:14 across the two interfaces and use both of those links hopefully more equally
46:21 we now have a load balancing demo we'd like to show you okay so you see here we
46:26 have a business partner and this business partner has two links uh that it could use and this business partner
46:32 wants to load balance across these two interfaces ge000 and ge001
46:40 and you see that one of them has a third octet of 25 and the second one has that third octet of 26 there
46:47 so let's go over to our terminal and take a look at this so here we are on R1 which is the
46:54 business partners router and we're going to go ahead and take a look and see if they have the routes that we need so
47:01 we'll go ahead and do a show bgp summary just to see if the routes are coming in
47:09 and it says that we have seven active routes here so we go ahead and take a
47:16 look at those routes show route
47:21 and we see that we do have some routes so we have some going from 10 1 0 23 10
47:28 2 10 1 4 10 1 6. so we have some of
47:34 these routes coming in and we see that each one of them has a couple routes
47:39 here we have one bgp route there and one bgp route here now this one here we notice that there's
47:45 two Next Tops for this one route uh but we're only going to use one of
47:50 those as our active route as it shows right here we have that little carrot on
47:55 the front going across ge000 is our active route for the ten one zero
48:01 Networks so what we want to do is we want to
48:06 build a load balance those across both of those let's take a look at just the
48:12 active paths we can get it this information just a little bit clearer I think show route active path
48:20 and this just brings it down a little bit better shows us our active routes so here's our active routes and there's the
48:27 next hop we're going to use same thing as we saw in the last thing just without all the extra information about the
48:33 other routes there so let's go ahead and look at our
48:39 forwarding table real quick show route 40 table
48:44 and we'll just do a destination here the destination if I can spell it and we'll
48:51 do a 10.1.1.0
48:57 and we do see that we do have a route for that we have a 10 1 0 0 23 route
49:03 and its next top is to go across the 25 Network which is on ge000 like in the in
49:11 the picture in the topology so we have that one route so what we
49:17 want to do is we want to be able to add a second forwarding option for our router
49:24 so to do this we need to go into configuration mode
49:30 and from configuration mode we're going to go ahead and create a policy and that policy will then be applied
49:39 onto the forwarding table to look for multiple routes if they exist that are
49:45 equal cost so we'll go ahead and do set policy options
49:51 policy statement load balance now this is just a name
49:59 and we're going to give it a term and we'll call it lb for load balance on
50:04 that term then load balance
50:10 per packet all right so again the per packet is just the
50:16 coding methodology inside of junos that's going to be changing by the end of the year but it's going to do a per
50:23 flow load balance because that's the way the Asics work on these devices so now once we have that policy let's go
50:30 ahead and look at it real quick and so it's a lot easier to see here we
50:35 do not have a from so that any traffic it's going to match anything that comes in it doesn't matter what the source or
50:43 destination addresses are it's going to match everything now we could have put froms and we could have said look we
50:49 only want to load balance certain traffic from certain places or to certain places right we could do
50:55 different things with that with those from statements maybe you only want to
51:01 load balance uh TCP traffic but UDP traffic you don't uh you could go ahead
51:07 and and make all sorts of things like that if you wanted to but we got this policy here this basically going to say
51:13 load balance everything across the links if we have them available and what we need to do now is we need to
51:19 apply that to our forwarding table so we'll go ahead and do a set routing
51:25 options forwarding table export
51:30 and then we're going to export that load balance
51:35 uh policy that we just made right here this low balance policy is this low balance right there and so we're going
51:42 to go ahead and Export that and now once it's exported we need to go
51:48 ahead and commit that so it goes active so we'll go ahead and commit those
51:54 now what we want to do is we want to look at that routing table again so let's just do the show
52:00 route well let's let's jump out of here there
52:05 we go show route um active paths and we're gonna see that's
52:14 exactly the same right because we applied this not to the routing table we applied this to the forwarding table so
52:21 let's jump out of there and let's go look at the forwarding table really quick
52:27 okay
52:36 here we see oh I typed in the wrong address
52:43 show route forwarding table 10.1 Dot 2.2
52:50 there you see now we have a destination here
52:56 um that we we typed in and we see that we have two different Next Tops under
53:01 the the ucast and that is showing that it's going to load balance across those
53:08 two links here g001 and ge000 let's look at one more really quick we can do a
53:15 show a route recording table destination and we'll do
53:22 10.1.5 dot so three again we have a route
53:30 and we have our destinations there all right well that is load balancing
53:42 our next section is routing instances all Juno's devices run a master routing
53:49 instance they act as a single device and Route and move everything from a single
53:54 routing table now each device does that fantastic but
54:00 you can take and move have multiple routing tables and multiple
54:05 instances inside of a junos device so it could act like three four five devices
54:10 and this way you could save money or you can have more security and more
54:17 separation of customers information so here in the example we have two
54:24 customers customer a customer B and we see that we have interfaces that have
54:30 been attached to that instance so when information comes in on that one of those interfaces that other routing
54:36 instance will be do the lookup to see where we're going to forward the traffic onto
54:42 and so you also can see that we can have routing protocols that run inside of there so we can have ospf tables for
54:49 each one of the routing instances that we set up
54:54 routing instances are defined under the routing instances hierarchy we give it a
55:00 name and there's a bunch of different instances we have instances for Layer
55:05 Two vpns for layer 3 vpns and for just creating a whole other router which is
55:11 the Virtual Router type so there are many different types of routing instances that you can use to
55:19 fulfill the needs for your network here we see an example of our
55:25 configuration and we'll see that we named our new instance new instance and
55:31 that it is a type of Virtual Router inside this Virtual Router we're going to have to put some interfaces and so we
55:38 go ahead and add those interfaces in there that we want we have a couple of them we've added and a loopback
55:45 so now we have a routing instance we have our device already set up but now
55:52 we might want to add some routing protocol information to that so down below here we see we have a static route
55:58 set up and we also have ospf setup so each one of these are independent of
56:04 this new instance that we have set up when we work with this we need to
56:10 remember that all the commands that we have in junos run off of the master
56:15 routing instance unless told otherwise and so here we see we have this show
56:20 interface terse which would show all of our interfaces but if we'd like to filter out just the interfaces that
56:27 belong to our new instance we can go ahead and add routing instance new instance on the end of that and now when
56:35 we do that we only see the few interfaces that we have there instead of the maybe hundreds of interfaces we have
56:40 on the device we next we have a ping here we have a that command ping is going to run off
56:47 the master routing instance it's going to go to the master routing instance to look up unless we add routing instance
56:53 on the back of that command this command SSH telnet all the other a lot of the
56:59 other commands that we have all run the same way if we want them to to look up
57:05 in the table of the routing instance we need to add that onto the end of the command
57:10 and then also we can just look at the route table and the route table is the
57:16 name of the instance Dot inet.0 and so we can have about as many instances as
57:22 we have that depends upon the hardware platform uh you'll have to look that up for each one of the different Hardware
57:28 platforms okay when we sometimes we need to route
57:36 between routing instances and when we go to route between these routing instances
57:42 we can do a couple things right we can actually go ahead and hook up an outside
57:48 interface to another outside interface that's in the other routing instance and just route normally like we might but
57:54 this uses up you know valuable asset that we have are the interface ports on our device
58:00 so junos has come up with a plan and that plan is to use a logical tunnel interface which is basically just a
58:07 virtual Network inside of the Juno's platform we can run these LT interfaces as a
58:15 group so we group them for the routing instance we have so here we have uh two
58:21 different interfaces lt000.0 and then we have lt000.1
58:28 now these get grouped together so that they basically become a point-to-point interface just like if you had attached
58:36 a cable between the two this allows us to send traffic between
58:41 the two routing instances there are also times when you want to
58:46 share routes between tables and have the same route in the in two different tables
58:53 junos does this by using what we call a rib group or a router information based
58:58 group this group is just basically a way to
59:03 find certain routes and then move them into another table these are helpful for different types of
59:10 deployments like filter based forwarding vpns and some multicast networks there's
59:16 other reasons you might use them but those are the main reasons that we're going to show
59:22 so the first thing we need to do is we need to Define this rib group this rib group gets defined under routing options
59:29 uh inside of our hierarchy and we're going to go ahead and we're going to make a Rube group give it a name and
59:36 then what we're going to do is we're going to list the routing tables now the first table in this routing table
59:43 section is where the routes will come from and then we put a second routing
59:48 table and the first would go into the second now if we had a third the first
59:54 would also go into the third so the first goes in the second the third the fourth As We Lay those out on that line
1:00:02 so we also have a policy that we can hook up and policy can basically Define
1:00:09 which routes we want to pull out of a table and move into the second table
1:00:15 so to look at this down here we have a little bit of an example here we put
1:00:21 this rib group inside of an ospf protocol and what we're going to do here
1:00:27 is we're going to look for ospf routes inside of the first table and move them
1:00:32 into the second table that we have defined so first we have to Define it
1:00:38 and then we have to apply it like I love it a lot of other objects that we have
1:00:43 inside of junos foreign
1:00:48 our next agenda item is filter-based forwarding filter-based forwarding is a way to
1:00:54 change the default behavior of your router Now by default the router wants
1:01:01 to look at the header of a packet find the destination address take that destination address to a route lookup
1:01:07 and then forward that packet based upon the routing table that you have based
1:01:12 upon that destination address now what we want to do is we want to maybe build a route on something
1:01:17 different let's say a source address inside that header so filter based forwarding allows us
1:01:24 this opportunity we can use a firewall filter and then we can sort through the
1:01:30 packet header find the information like when it matches we can put it into a
1:01:36 different forwarding instance or a different routing instance and then have a different route for that and so here
1:01:43 you see in this example we have a 172250 going through iSpa and we want a
1:01:50 172.25.1 going through ispb and so what we need to do is we need to put a filter on the front of that to accomplish this
1:01:58 task so here's our configuration that we need to set up we
1:02:06 need to create a routing instance and this is going to be a type of forwarding
1:02:11 and then we're going to need to activate the route that means we need to have a
1:02:16 plausible Next Top and then we're going to Define which traffic what traffic is going to go to
1:02:23 this next uh into this routing instance that we just created to be routed a different direction and we're going to
1:02:30 use that with a firewall filter okay so the first thing we need to do is
1:02:36 create a routing instance here we named it instance name and so we create this new routing instance and the type of
1:02:43 routing instance is forwarding now the forwarding routing instance does not need any interfaces inside of this
1:02:50 routing instance and we'll get to that on the next slide here but what we want to look at is we want to say look we
1:02:56 created this routing instance and then we created a default route and this default route has an IP address hooked
1:03:03 to it that is the IP address of the ispb out interface ge003
1:03:11 so now when any traffic gets pushed into this routing instance it's going to look
1:03:16 up that default route and push it out to ispb so we could also create a few more of
1:03:23 these routing instances if we wanted to to create a more complex routing structure through our route filters
1:03:32 the next step is to activate that route if you remember we have to have a valid
1:03:38 next hop if we're going to put a route an active route into the routing table
1:03:44 now what we need to have is an active Next Top is we need to have an interface
1:03:50 attached to our device that has some IP addresses on it but I just told you that we didn't have that inside of the
1:03:56 forwarding type routing instance so what we're going to do is we're going to go ahead and grab those routes from the
1:04:05 main routing instance that we want to and bring them over so here you see we
1:04:10 have uh inside of here we have this rib group under routing options in this rib group
1:04:17 allows us we're going to give it a name and then where it allows us to take the routes out of inet 0 and place them into
1:04:24 instancename.inet.0 what this does is allows us to have a
1:04:30 valid next hop for this routing instance and so we created this and see we see
1:04:36 that we have this inet 0 and then we have a and then the next time is instance name Dot inet.0 and this was
1:04:45 going to take whatever routes that we pick and push them from Ina 0 into instancesname.inet.0
1:04:54 so now the top piece up here allows us to um apply that and we go say hey look
1:05:00 under routing options there we want the interface route so all we want are the directly connected routes on those
1:05:07 interfaces to come into this group and so then we create that group name uh to
1:05:14 to tie those two pieces together and now when we run this we'll take all the
1:05:19 interface or the directly connected routes out of inet.0 and now place them in until our new instance or instance
1:05:26 name.inet.0 all right the last thing we need to do
1:05:31 is we need to create a firewall filter so here we have a firewall filter we got
1:05:37 to give it a name we need to set up some terms and then inside that term the
1:05:42 first term what we want to do is we want to have some match criteria and the main current match criteria that we're
1:05:47 talking about is we wanted to put that 172.25.1 Subnet in there so that when we
1:05:53 when a packet comes in we're going to grab that in the firewall filter we're going to look to see if it matches 172
1:05:59 25.1 in the source address and if it does what we want to do is take that now under the then and we're going to put
1:06:07 that into the instance name routing instance that we just created and then
1:06:12 it'll look up that default route that we created and push it out to ispb
1:06:18 so one thing we want to make sure you remember is that we want to have that
1:06:24 the next term there term else accept if we don't add that the only traffic
1:06:29 that's going to go through that interface is traffic from that source so
1:06:35 172.25.1 subnet now we want more traffic to come in than that and so we need to
1:06:42 have this term there because a firewall filter has an implicit deny at the end that throws everything away
1:06:49 so we need to make sure we don't throw everything away and then what we're going to do over on
1:06:54 the right hand side of this slide we need to apply that firewall filter once we have it created to ge001 as an input
1:07:02 filter and so we have that input filter put on there and now when traffic comes in we're going to run through this
1:07:08 firewall filter look for what we want if it doesn't match we're going to go down to the term else except it's just going
1:07:15 to go into the master routing instance and look up a route like it normally would but if we have a route from the
1:07:22 172 25.1 is going to come in match get put into the instance name routing
1:07:29 instance that we created and then forward it out to ispb and that is firewall filters
1:07:39 okay our next agenda item is ospf intermediate level
1:07:45 just as a overview and we have a ospf network down here we have four routers
1:07:52 there and ospf uses a link State advertisements within an autonomous
1:07:59 system or an as to communicate with each other to be able to pass information
1:08:05 neighbors use hello packets uh to their neighbors to find out if they're running
1:08:11 ospf and to form these adjacencies so when those routers get a Hello packet
1:08:16 they'll also answer back with a Hello packet to let them know
1:08:21 we have different types of interfaces we have point-to-point interfaces and then we have interfaces that are on a
1:08:28 broadcast system like ethernet and if they're on a broadcast system
1:08:33 we're going to go ahead and elect a Dr or a designated router so if we change
1:08:39 those ethernet interfaces to point to points we can or at least configure them
1:08:45 to be point to point as far as ospf is concerned then we won't have to do that
1:08:51 election that way so here you see that we have R5 on the same domain as R2 and
1:08:58 R4 and so we're going to have to select a designated router there but where the
1:09:04 other interfaces over here are set to point to point we will not have to elect
1:09:10 a Dr so through the process of forming an
1:09:17 adjacency uh there's a database of all the information learned remember that a
1:09:23 dynamic routing protocol the main thing it does not want to do is form a
1:09:30 loop inside of your network and so if everybody has the same information and
1:09:35 everybody does their calculations exactly the same way we should never have a loop that goes through our
1:09:40 Network we should always point in one direction for whatever route we're trying to get to and these routes are learned through
1:09:47 those lsas the link State advertisements that go back and forth and we'll talk more about those
1:09:53 and then we use the shortest pass the shortest path algorithm to find those
1:10:00 paths through the network and that database gets held in there
1:10:05 so we have some different packet types we have a type one is a hello at type
1:10:11 two is a database description type 3 is a link State advertisement type four is
1:10:17 a link State update and a type 5 is a link State acknowledgment and we use these packet types back and forth
1:10:23 between the routers to form these adjacencies and to transmit the information that we need to to get our
1:10:30 databases all up to speed so let's talk about each one of these foreign so the first message type is a Hello
1:10:37 message and so it just is a it's on a multicast
1:10:42 um uh protocol and we'll send that hello out and when the other router sees that
1:10:49 hello it's gonna go and make sure it has certain types of information that came
1:10:54 from the one router and it's going to go ahead and send that information about itself back and when we do that we're in
1:11:02 what we call the two-way state and then R1 will then go ahead and say
1:11:07 oh yes I'm okay with that we'll send the information back um and and we see we see we have the
1:11:14 network mask we have the hello interval the dead interval and the router options and and on the those
1:11:22 um on the the dead interval the hello interval and the network mask you can see that those all have to match exactly
1:11:30 um and then of course the router ID cannot match right each device is going to need its own router ID to look at
1:11:39 and so we use these hello messages um to start an initiation of our
1:11:47 adjacency and so we get to this two-way state we're then going to start to exchange
1:11:54 information we want to exchange these database description
1:11:59 um back and forth and basically what a database description is is a is a list of all the routes that each of the
1:12:06 routers know they're going to send that over and I like to think of it as kind of like a table of contents for a book I
1:12:12 got this table of contents and and they're going to set send more over and I say okay I got chapters one through
1:12:17 five and and and then the other router sends over chapter six through ten and
1:12:24 so I start to build up this table of contents and so that's kind of what this database description is doing is telling
1:12:29 them about all the the networks that it knows about now it doesn't know how to get there or
1:12:34 anything else at this point it just knows that there's some information that it needs to get and fill in the chapters
1:12:40 right this is just a table of contents not the actual the chapters themselves
1:12:45 so now what we're going to do is we're going to send out a link State request so if I have uh information from that
1:12:53 database descriptor about uh a chapter but I don't have the chapter I need to
1:13:00 have that information sent over so I have all these links that I know that I know they're out there but I don't have
1:13:06 the information about them how to get there so what I want to do is I want to get that router whoever sent me that
1:13:11 table of contents or that database descriptor to then send me the rest of the information because I don't have it
1:13:18 so we'll get that sent out and then when we we do a request and then of course
1:13:23 the link State update is the answer coming back with all the information to fill in my database so now I have I have
1:13:30 the the prefix and now I have all the information about how to get to the prefix and then we use the link State
1:13:36 acknowledgment to always acknowledge that we got the packets from the other side
1:13:41 and so that is the five message types so here we see that we have uh our
1:13:50 adjacency formation uh they start both down and the ospf is down and then we're
1:13:57 going to do in a knit which means hey we sent a hello packet over we see that packet we're going to send back our
1:14:03 hello back and now we're going to be in a two-way on one side and we're still in a knit until the packet comes back on
1:14:10 the other side and now we're in two-way on both sides once we're in two-way we can start our X start and start sending
1:14:16 data back and forth between the devices um to get that information exchanged across
1:14:23 there and so then here we have our link State request type 3 and our updates and
1:14:30 then our link State acknowledgments uh they go back and forth and then what we're hoping to get is that each router
1:14:37 on both sides of R1 and R2 will be in a full State uh when we're done with that and if when they're in a full state that
1:14:44 means they are ready they're routing and the ospf is happy
1:14:51 so on a broadcast domain we want to optimize our adjacencies so since all of
1:15:00 these routers that we see down here belong to the same device we would need to form adjacencies with
1:15:07 each of them and start passing information back and forth but all the information about that one network that
1:15:14 one link is the same for all of the devices so instead of
1:15:19 um using just instead of trying to create adjacencies to all those routers what we're going to
1:15:26 do is we're going to elect that Dr or that designated router and then of course the the protocol
1:15:33 needs a backup just in case the Dr has an issue or it dies or we lose contact
1:15:38 with it we have what we call a backup designated router and so there's an election process that
1:15:44 goes through and and then adjacencies from all the routers are only formed to
1:15:51 the Dr and to the bdr they're not formed to all the other routers and we'll see that here when we when we
1:15:59 go ahead and um look at some of these we will see how the adjacencies work with
1:16:05 those but when we use a point-to-point type uh we don't have to do that the two devices
1:16:11 know that they're the only two ospf devices on that link and now they'll
1:16:17 form adjacencies with each other's that saves some time it saves some problems out there and so I would recommend
1:16:24 putting on on your ethernet interfaces a point to point uh inside of your ospf if
1:16:30 you know there's only ever going to be one other ospf router on that link
1:16:37 all right so how does that designated router get figured out we have all these routers on there well there's a priority
1:16:44 range that you can set by default it's 128. so if you don't set it all your routers out there are set at 128 and the
1:16:51 priority if two routers share this the highest priority right which they would do if no if you didn't set them
1:16:57 and then whoever has the highest router ID is going to be elected now that election is non-deterministic
1:17:06 right so an existing Dr will not be replaced meaning that when I put a Dr
1:17:14 online and it goes down the backup Dr is
1:17:19 going to um the backup Dr is going to become the the Dr the the designated router and
1:17:27 when I get the Dr to come back online it crashed or whatever it had a problem we get it back online it's not going to
1:17:34 take back over it's going to wait back in this turn it has to go through the election process all over again and so
1:17:41 right now we already have a designated router and when the and when the first one went down that backup designated
1:17:47 router elected another backup for it because it became the designated router and so now when the designated router
1:17:54 comes back on it basically has to wait for the the designated router to go down
1:18:00 and then that backup will come online and then the designated router in the first place will then finally take over
1:18:08 and be the backup and then once that backup whenever the designated router then it goes down again then the main
1:18:16 first designated router tanks takes back over um so anyway that's uh that's kind of
1:18:24 how the election process works
1:18:30 so we have here I just wanted to show you that we have our ethernet uh segment out
1:18:39 here and we have these router IDs and we have a Dr and a bdr setup
1:18:46 but the R3 and R4 which are neither the bdr or the Dr they're going to form an
1:18:54 adjacency but it's not going to go to the full State it's only going to go to the two-way state so there are times
1:19:00 when you see that two-way State and that's what it should be we don't need to try to fix that so that's just
1:19:06 something to keep in mind uh as you're there the the routers know about each other but they know that they're not
1:19:13 supposed to form a real adjacency with them we're just waiting for the we're just talking the Dr and the bdr on that
1:19:19 Network all right ospf can be broken into areas
1:19:25 and these areas allow our link State database to be um smaller and that was the whole
1:19:32 purpose of the the different areas in the time was to make your your databases a little bit smaller
1:19:37 and so we need to have a backbone area which is
1:19:43 our area zero and so we see that area zero is usually in the middle and then you see on our
1:19:50 example here we have a area one and an area two on the left and the right side of our area zero
1:19:56 and so as we have these areas we are going to send all the data back and
1:20:02 forth between the areas to keep um the the the databases up to speed and
1:20:08 keep them so they have all the routes now what we want to do though is we can
1:20:13 use those areas to try and and Shrink our databases and we'll get into that in
1:20:19 a few slides so we can go ahead and look at our
1:20:26 um our logs and our ospf logs to see how often and how long the algorithm is run
1:20:33 so here you see we do show ospf log and we see that with each instance and when
1:20:39 it starts and how long it lasted um so we can get information about how
1:20:44 long it's taking for those and if those are taking a long time then maybe we need to break it into a smaller area
1:20:51 again because our resources are being used so in ospf we have a bunch of different
1:20:58 router names and types that we want to make sure we have defined so here we see
1:21:03 we have our area one on the left our area two on the right and our area zero in the middle
1:21:09 and that area in the middle is area zero which is called our backbone area and
1:21:15 any device that has a link in there uh is a backbone router so we can call that
1:21:22 a backbone router uh any or router that's not in the
1:21:27 backbone is called a non-backbone router okay and then we have like I said we have to
1:21:36 have at least one interface in that area area zero for that to be a backbone
1:21:42 router and then the we have routers that have an interface in the area zero and an
1:21:49 interface in another area these are called area border routers and they
1:21:54 transfer data in between the two areas and then we have an asbr and this takes
1:22:02 external routes let's say from a routing protocol other than ospf say bgp or rip
1:22:08 and takes those and puts those into ospf for us so that we can push all those
1:22:15 routes across all the ospf domain that we have
1:22:22 all right so ospf needs these link State advertisements to uh explain and
1:22:30 describe the links that it knows about and it has a few of them here so we have
1:22:36 the the router links which are type one the router links are links for a
1:22:41 point-to-point interface the network links which are type 2 are for links
1:22:46 that are hooked to a broadcast domain like ethernet
1:22:51 and then we have summary links we have some type 3 and type four these describe
1:22:57 other links so type threes are going to describe types one and two and we'll talk about those here in a few minutes
1:23:03 and then we have external links that come in from bgp or whatever and other
1:23:10 protocol of some sort and then we have type sevens now type sevens and type
1:23:15 fives are exactly the same but we have what we call this not so stubby area an
1:23:21 NSSA and what happens is an NSSA does not allow fives right it's it's not
1:23:28 allowed and so basically we're going to mask it with the type seven it's basically the same thing as a type five
1:23:34 so I call them a ninja seven right we're sneaking a five through this area but
1:23:40 the area you can't know what it is and so we hide it and it's a stealthy
1:23:45 um type five is a seven all right so let's take a look about how
1:23:52 these link State advertisements get sent around so here we have our ospf area zero and
1:23:59 inside our ospf area zero we have type 1 uh router see we have a couple
1:24:05 point-to-point links in there and so we're going to send those around we also have a broadcast area and so
1:24:12 we're going to have some type twos that are going around that are going to Define that link between R1 R3 and R4
1:24:19 those are going to get sent around now we're going to add another area and
1:24:25 that area also has Type ones but those type ones do not go into area zero they
1:24:31 only stay in area 10 over there on the left hand side in the green and then of course if we add another
1:24:39 broadcast domain we'll have Network types two over there also in area 10.
1:24:47 so to hook these two areas together we're going to add a ABR router in
1:24:53 between there or an area border router to to help facilitate Communications
1:24:58 between the two areas so we can also add another area over
1:25:04 here we're going to do Area 51 everybody needs a good area 51 with an ospf
1:25:09 install and again we'll add an ABR in between those to facilitate Communications
1:25:16 between there so now once we have these ABR set up we're going to start sending
1:25:21 summary routes around so uh area 0 uses abr9 to send summary
1:25:29 type threes over into area 10. and also into area 51.
1:25:36 so as you can see we put the blue in there to show off that it's area zero in
1:25:43 the in the text so uh Area 51 and area 10 are going to
1:25:51 send summaries into area zero so those summaries also get sent on to
1:26:00 the other areas so Area 51 sends them into zero area zero sends those summaries into area 10. so now all the
1:26:09 different areas still have all the the link State advertisements that are going on
1:26:15 now we're going to set up an asbr and we're going to bring rip into that asbr and what we want to do is we want to
1:26:23 send in ospf routes from that into our ospf Network and so these are external
1:26:28 routes that are coming in so that is a type 5 that gets sent around area 51.
1:26:35 now that ex same exact type 5 gets sent over to area zero and to area 10. so the
1:26:44 fives don't change across the the area the abrs they're the they just send them
1:26:50 along and add them to the databases but now what we're going to need is
1:26:55 we're going to need a Type 4 and this type 4 defines the asbr how do I get to
1:27:01 that asbr router in the first place so anytime I have a type 5 that comes across I'm going to create a Type 4 to
1:27:09 Define how to get back to that asbr router for that area
1:27:15 and so that summary will also get sent into area 10. so that is our our our setup and how
1:27:24 those lsas get sent around the network now we can change our area 51 into an NSSA
1:27:33 now that NSSA remember we can't have a type 5 right it's it's not allowed it's
1:27:39 part of the our the RFC and so we have a type seven and it's just a ninja right
1:27:45 it's it's a stealthy five running through that area so when anybody sees it it doesn't think that it's a five
1:27:51 and so we take those sevens and those will also get transferred as fives into
1:27:57 areas zero and area 10. and they're fives in Aries zero in area 10 because there's not an NSA area it can have
1:28:04 fives and like I said it's exactly the same thing so it's just just a stealth five inside of the NSSA area over there
1:28:12 in area 51. all right so ospf stub areas
1:28:19 stub areas are what we use to try and Shrink up the database a little bit
1:28:25 that's what I talked about just a little bit before we're going to shrink these database and so we have a stub area and
1:28:32 we have a totally stubby area so if you see in this totally stubby area we're
1:28:38 going to have our um uh inside of the stub area excuse me
1:28:43 we're going to send in a default route we'll also send in our our t3s right our
1:28:50 type threes from the backbone area and from the totally stubby area if we had them right so we will send those over
1:28:59 and and that default route is going to catch anything else that doesn't get
1:29:04 sent there in the totally stubby area we're going to send over the default
1:29:10 route into there but we're not going to send any of our type threes into there
1:29:15 we're just going to say hey everything inside the totally stubby area you're going to have your t1s and your your
1:29:20 types ones types twos and and you'll know how to route within your area and
1:29:26 then if you don't know where it goes just send it over into the backbone area in the backbone area you'll figure out
1:29:31 where to send that and so the the totally stubby area the the size that database can be really small compared to
1:29:39 the rest of the network and that way uh your all your calculations and things
1:29:44 are a lot quicker when it's trying to figure out how to pass traffic through there
1:29:50 so then we have our our NSSA areas are not so uh stubby areas
1:29:58 and so in our not so stubby areas uh we have
1:30:04 um where we can send in bgp routes and things but remember that's going to be a type seven so we have our t1s our t2s
1:30:11 and our t3s and then we'd have our our type sevens that come in so then inside of the
1:30:19 totally stubby area the the totally NSSA area we're not going to send the threes in
1:30:25 we're just going to send that default route in again um and not worry about all the other
1:30:30 summary routes coming from the other areas
1:30:38 so let's talk about ospf now with junos so in junos we support ospf2 and ospf3
1:30:46 now we talked a little bit about this in the fundamentals course ospf2 is the
1:30:52 32-bit version of ospf and version three is the 128-bit version for so it can run
1:30:59 with IPv6 so we run both of these both of them run
1:31:05 they can run together uh if you have version three on all your devices you
1:31:11 can run just version three because version three will run uh 32 bits for
1:31:16 ipv4 and 128-bit for IPv6 and so you wouldn't need to run version two and
1:31:22 three together but if you have a device there that's not ready to move up to version three you'd need to run version
1:31:29 two anyway so to keep it there so each one of those will support all the
1:31:35 features that you see there in the list we have all the different types of the areas we can do authentication we can do
1:31:42 summarization we can do the external prefix limit so if we do bring in bgp
1:31:47 routes we say hey look we only want a hundred of those uh to come in or however many you want to come in it just
1:31:54 helps make sure you're not going to overrun your databases and your capabilities of your network
1:31:59 we do graceful restart to help uh when there's a problem with the routers to
1:32:05 make sure the routing tables doesn't have to change and and and and and and come back up we can try to hide that and
1:32:13 to make things quicker and better on the on the routing tables and then we'll do
1:32:19 the the bi-directional forwarding detection on the on ospf
1:32:24 all right so how do we configure ospf we do this under protocols all the dynamic
1:32:30 Protocols are under protocols uh hierarchy and so we see under there we have ospf or we have ospf3 and then we
1:32:39 have to have an area number for each one of those uh and and set underneath the
1:32:44 area we're going to add the interfaces that we want to have as part of that area
1:32:51 um and so we can set that up again ospf3 will do uh the work for ipv4 and
1:32:59 IPv6 if you want to a router ID needs to be set up and if
1:33:06 you don't set one up it's going to pick the first interface that comes online uh
1:33:12 which would be either the loopback or usually ge000. uh so if you don't want it to work that
1:33:19 way you need to go ahead and set up a router ID I would recommend setting it up even if you did do a loopback and
1:33:26 you'd basically make the usually you're going to make the loopback and the
1:33:31 router ID the same IP address uh so um
1:33:38 yeah so make sure you have a router ID
1:33:43 topology and objectives here so what we want to do is we want to look at a way
1:33:48 that we can take this interface on the very left hand side ge001 has a 172 18
1:33:55 1.0 uh subnet and we want to put that into our ospf area but if you notice
1:34:01 that the area slices right down the middle of that router so g001 is not in
1:34:08 our ospf uh a network and so what we want to do is we want to
1:34:14 make those external routes and inject those into ospf so that everybody along that path knows how to get over to there
1:34:21 we would like to use the ge001 interface between R2 and R3 to send the traffic
1:34:30 across unless it goes down and then we'll use the ge002 interface so let's look at how that configuration would
1:34:36 work out uh for us here so here we have uh our configuration we
1:34:43 see that we have uh protocols here under protocols we see we have ospf our area
1:34:48 zero zero one uh we have our interface just ge001 with the loopback and then we
1:34:56 have under R2 uh we have our uh protocols again we're going to set up
1:35:03 ospf just the same way under area zero though here but you see under interface 2 under
1:35:10 interface 2 we set a metric of a hundred and we set that metric up so interface 2
1:35:16 looks not as enticing as interface one to go across and so when the routing
1:35:22 protocols on there uh run and we've tried to find our active route we're going to pick ge001 right we said we
1:35:29 wanted to use one instead of that and so on both routers three and two
1:35:34 we're going to set up that um that metric so that interface 2 looks
1:35:40 not as enticing as interface one and then on R4 we're going to set those
1:35:47 up now what this will do is this will basically set up our ospf areas
1:35:52 everywhere but now what we want to do is we want to push that route into our ospf
1:35:58 Network so here we're going to redistribute the route through that we need a policy so
1:36:04 we're going to do a policy and so we have this policy statement called to ospf uh you could name that whatever you
1:36:12 want from protocol direct right it's a directly connected and then we pick the IP address or the directly connected
1:36:19 network of that interface so we put in the 172 18 1.0 24 exact now so we Define
1:36:28 that now what we need to do is we need to apply that into ospf so we go to ospf
1:36:33 and we're going to apply an export policy to that policy that we made so we
1:36:40 say export to ospf now what that's going to do it's going to go and grab that default not the default sorry the direct
1:36:47 route on ge001 and put that into our routing table
1:36:53 so that's one way to do it we could also do it another way
1:36:58 we could include ge001 on R1 into the
1:37:04 ospf network but the thing was is we don't want any routers out off that
1:37:10 interface to form adjacencies with our router it's a security to make sure we
1:37:17 don't have anybody messing around out there and so what we're going to do is
1:37:23 we could go ahead and put this passive tag onto the end of our statement here for
1:37:31 the interface ge001 and what that says is hey I want ge001 and it's and its IP
1:37:39 addresses networks to come into ospf but I do not want anybody to form adjacencies with that if a router out
1:37:45 off of that sends a hello packet we're not going to respond we're just going to throw that packet away
1:37:52 all right so once we have that done we can go ahead and take a look and we can do a show route uh 172 18 1. and we see
1:38:01 that we have our uh our Network in there and it's a external network right it's
1:38:08 the 150 there because that's an external network on that preference value
1:38:13 so we can also see that we have uh our other routes that it wants to take ge001
1:38:20 because we put that metric of a hundred on interface two so we see that on R2
1:38:27 that it is going across the right interface that we wanted it to
1:38:34 all right now we have an ospf demo we would like to show you
1:38:39 okay so here we have in our ospf demo we have two different areas area zero and
1:38:45 area four and we're going to start off with them separated like this
1:38:51 but we will then go ahead and we'll put in an ABR between the two on router four
1:38:57 so that we can see the difference between uh a standalone area and an area
1:39:03 where there are multiple areas so let's go ahead and switch over to our
1:39:11 our terminal okay so here we have our
1:39:19 router 1 and let's go ahead and look at the configuration so we can do a show
1:39:24 configuration protocols ospf
1:39:30 and we see that we have our two interfaces interfaces one and two in there interface one is a point-to-point
1:39:37 interface two is a multi-access link now it is uh best practice to put the
1:39:45 loopback address inside of our ospf area and a lot of people ask you know should
1:39:52 we put a passive tag on the back of that or not so let's go ahead and uh just
1:39:57 take a look at that real quick and we'll add in the interface without it and then with it and we'll see the difference
1:40:03 here so let's go ahead and jump into configuration mode
1:40:10 and we're going to do set protocols ospf
1:40:16 area zero interface l0.0 we'll just leave it like that we
1:40:23 always put in The Logical interfaces let's go ahead and do a commit
1:40:32 and then we'll do a run show ospf interfaces
1:40:39 and you see our loopback zero zero there at the bottom is in a waiting State we
1:40:44 run it again it's still waiting because it's trying to do an election and find a Dr in bdr but
1:40:52 there is no neighbors right there the loopback isn't attached to anybody else so let's go ahead and run that same
1:41:00 command but on that one let's put passive
1:41:05 and do our commit again and now if we run our our show our
1:41:12 interfaces we see that it's a Dr other and that VR other just means that uh
1:41:19 it's not going it's it's basically saying it's the Dr but it's not really on a broadcast medium and so it was not
1:41:28 going to go out and search for those it it's going to quickly just go right in we're not waiting for any timeouts to
1:41:34 happen so yes it would be best practice to put the passive tag on your loopback
1:41:40 interfaces so then let's go ahead and let's look at
1:41:46 our database run show ospf database now
1:41:51 here we see we have uh some entries in here we see we have three router
1:41:57 networks and we have one multi or three router entries and a network entry which
1:42:03 is a multi-access entry and so we know that one of our interfaces is that multi-access entry
1:42:10 uh but if you look up above on ge002 here I'll highlight it
1:42:17 we see that we are the bdr and so this network came to us from the
1:42:24 the router on the other side of that link uh which is uh router number two
1:42:29 which is 192.168.1.2 and it and added that in there so only the Dr sends this network
1:42:37 around uh to all the other hosts that are in the ospf network so we see these
1:42:44 we also see we have this little asterisk here this asterisk points to the links
1:42:49 that the router that you're on at the time has put into the database so we've
1:42:55 added one link into the database so if we'd added more you would have had more asterisks right there and so that's what
1:43:03 all of those mean there and so we can we could look at our our interfaces show interfaces
1:43:11 and we'd see that we have uh these interfaces here
1:43:16 uh one two that are hooked up and like we said one we have is a multi
1:43:23 um uh as a point to point this one's a point point and number two is a multi-access
1:43:30 all right so let's go ahead and show you that we can dive into that just a little
1:43:37 bit more we're on uh show ospf at database router detail
1:43:48 so now we see we have this link that comes in this is the one we've added in
1:43:54 and we can actually go through and look at the different uh information about
1:44:00 that this router has sent to us uh the the one that we're on we see that we
1:44:06 have different links here we have the 1004 the 1001 right those are our two
1:44:13 different interfaces and then our loopback address there we can also see that we have the subnet
1:44:21 masks for some of those but not for the ones that are a network right the
1:44:28 network ones don't come across as as a subnet here
1:44:34 so we can see that in another place that the the subnet that comes across for
1:44:40 that but I just want to show you that we can jump in with this detail command and this this show ospf database router
1:44:49 detail and we can see each of the routers and the information that they're
1:44:55 sending to us all right let's jump over to router 5 real quick
1:45:02 and on router 5 we can do the same thing we can do our show configuration
1:45:08 uh protocol ospf and we see that we have our our two
1:45:14 interfaces there plus our loopback and we have the passive tag on that one is a
1:45:19 multi-access the g002 and the other one is a point to point
1:45:25 now if you see a difference here this is in area four instead of area zero
1:45:32 and so area four is another whole area within our our Network so if we go ahead
1:45:40 and we do a show ospf database we see that again we have about the same
1:45:47 setup here we have uh the r loop back right because we're on router five and
1:45:53 then we see we have six and seven that sent in information and then we also
1:45:58 have a multi-access network here and everybody in area four starts the next
1:46:05 octet here with the four so we could keep track of those pretty easy so when we see all the routes that are coming in
1:46:12 you'll know that the 10-4s are in the area four and that the 10 ones are in
1:46:19 the area is zero so let's go ahead and look over to our
1:46:25 ABR now so that is our router four okay and here we can do a show
1:46:32 configuration uh protocols ospf
1:46:38 and the first thing we want to note is that it is inactive we have not tied the
1:46:44 two areas together yet through this ABR because we wanted to show you that we
1:46:50 have the two areas area four and area zero and they're basically identical with each other and they would run just
1:46:59 fine as they are so but best practice is to put a standalone area is area zero
1:47:05 but if that area of four would run just fine by itself it is only if you want to
1:47:11 try to grow that you wouldn't you wouldn't have a backbone area to work off of here on our ABR we see we have our area
1:47:19 zero and we have our area four we have oh sorry I've grabbed the side there we
1:47:25 have our area four and with that you'll see that we have uh one
1:47:32 of the interfaces in g002 in in area four and interface ge001 and area zero
1:47:40 they're both point-to-point links and this inactive tag allows us in junos
1:47:46 to add code to our devices and then we can just turn it off it basically
1:47:52 comments it out so that if we want to like right now I wanted this code in
1:47:58 here I want to use this in the future but I didn't want it running at the time so we could show you the two different
1:48:04 areas individually so basically what I'm going to do is I'll go into configuration mode here
1:48:12 and all oh Let's do let's run real quick run show ospf interfaces and we'll see
1:48:20 that ospf is not running right it's just it's it's not there because it's all inactive
1:48:26 so we're going to say d we're going to say activate uh protocols ospf
1:48:34 we'll do a commit and now we can do a run show ospf
1:48:41 interface and now we are running right it doesn't say ospf instance is not running now it
1:48:48 says it is running and we see we have our our two links and they do have neighbors if we look on the right hand
1:48:55 side over here uh they do come up with uh the neighbors there now what we want
1:49:00 to do is we'll do a run we'll look at the neighbors real quick run show ospf neighbor and we see
1:49:08 we do have the two neighbors they're both in the full state so they are happy
1:49:14 they've they've sent all their information back and forth and are routing with ospf so let's go ahead and
1:49:21 look at the database
1:49:29 here the one thing you're going to notice is that we have area zero up here
1:49:36 and area four down here because this is the ABR this router is in both areas we
1:49:43 can look here we can see we have our our router types right the 10 the 192 168
1:49:49 1.1 we saw that one we saw the the two and the three and then we sit down here
1:49:54 we saw the five and the six and the Seven well then we turn four on and so now we see we have R4
1:50:01 in here in both areas because it's the ABR we see we have our
1:50:08 Network that's there okay but now look what we have in area
1:50:13 zero we have these summary routes we have these are type threes and we have
1:50:19 the all the different networks that are over in area four that are either ones or twos they came
1:50:26 across as type threes uh to us inside of area zero and also the other way here we
1:50:34 have our summary routes the other way we have our 10 zeros on this side that
1:50:39 point back over to the other side and so you can see all the different router or
1:50:45 the LSA types that are coming in we have our ones and our twos and our threes at this point that we're showing okay let's
1:50:53 move over to router uh number one again
1:50:58 and let's go ahead and take a look at the database now so we do a run show ospf database
1:51:07 now we see that we have our normal routes that were there right we have the
1:51:13 one two and three we're getting four from our ABR and we have our one network
1:51:20 that we always had but now look at all these summary routes that are coming in
1:51:25 and all these summary routes are routes from the
1:51:31 from from the other side right from area four that are coming in and so we see
1:51:37 that that ABR is working and that we are getting all the routes that are back and forth
1:51:42 Okay so we've seen so far uh LSA types one two and three so now what we're
1:51:49 going to do is let's go over to router number five and over here on router number five I
1:51:55 have configured up a static route show routing options and we have a
1:52:03 static route here and what we want to do is we want to inject that into our ospf database so to
1:52:11 do that we're going to need to make a policy for that show policy policy options
1:52:19 and I created one it basically says it's a name export static and then I have a
1:52:26 term right and then that's just the name static routes from protocol static
1:52:33 except so any of my static routes that I have in my routing table are going to be
1:52:38 accepted into wherever I put this so to make this work what I need to do is I need to go over
1:52:44 to my Proto my protocols show OS
1:52:50 the show protocols ospf and I got my area here right
1:53:00 but now what I need to do is I need to go ahead and set that in there so I'm going to do set
1:53:06 protocols ospf um export export
1:53:13 uh export static okay I go ahead and put
1:53:19 that in there of course I'm going to do my commit and now when I look at the database Show
1:53:26 run run show ospf database
1:53:32 I have a type external and you see that here we have this type external route
1:53:38 that goes all the way this this will be the same all the way across to our
1:53:44 entire network so let's go down to our R4 ABR and make
1:53:50 sure that it knows that it's there and we look and
1:53:56 it is it has it right here it has this ABR here this the external route
1:54:02 now remember when we make a five it says it needs to get back to this 1.5 but the
1:54:10 1.5 these routes are only locally known to the local area and so when we push that
1:54:17 into area zero up here we have to make an asbr summary here
1:54:26 because area Z area zero knows how to get to four but it doesn't know how to
1:54:31 get to five so so since it we have a 4 here we know how to get to four we say
1:54:37 hey to get to 5 send it to four okay that's what that number four is
1:54:43 this a SBR summary is a Type 4 for our type 5 down here
1:54:51 okay so let's go jump back on to router one and see if we got the route there so
1:54:56 we can go ahead and look at the database and sure enough we do have it we have this external route that says hey send
1:55:04 it to five to get to this network and but we don't know how to get to five
1:55:09 because it's not local and so we have this asbr summary here to send uh all
1:55:16 the fives to four and then the four knows how to get those across there so we see that this is the exact same route
1:55:22 though that's on uh router 5 router four and now router one this external type
1:55:29 route doesn't change it says type 5 everywhere it goes and it doesn't change as it goes around and so that is our
1:55:37 ospf demo well we've reached the end of this course and we're so happy that you've
1:55:44 taken time out of your busy schedule to be with us to learn more about Juniper Networks and the junos operating system
1:55:52 we sure hope that you have found this very useful but you might be thinking well what's
1:55:58 next now that I'm done with this course attend another jumpstart Juniper class you can sign up at the URL on the screen
1:56:06 we have six courses right now that cover junos please watch for more jumpstart
1:56:12 Juniper videos coming soon another fantastic resource is the learning portal at juniper.net
1:56:19 there you'll find a lot of resources that can help you one of those is the Juniper open
1:56:25 learning Juniper open learning is for certification and to help people get
1:56:31 started with their certifications Juniper open learning has live seminars where you can ask experts questions
1:56:38 about the things you might need to know about the certifications they also have some online videos that
1:56:45 you can watch that go over the certification information and help you
1:56:51 learn the things that you need to know they also have practice tests you can
1:56:57 receive vouchers if you pass those practice tests to receive a discount on
1:57:02 your test that you need to take to become Juniper certified so make sure
1:57:07 you check out Juniper open learning another thing is the learning paths that you can find on the learning portal the
1:57:14 learning paths help you decide which track is best for you is it security is
1:57:19 a service provider Enterprise what things do you want to learn from Juniper
1:57:25 Networks On The Learning portal you'll also find all the on-demand courses from
1:57:31 the course development team from Juniper Networks they have many courses for you
1:57:36 to take on the different technologies that Juniper Network provides so that
1:57:41 you can learn and grow in the path that you want there's also a list of class schedules
1:57:48 for scheduled classes that are led by an instructor last of all is the all access
1:57:54 pass this all access pass allows you to take any course the Juniper has this all
1:58:00 access pass is a yearly subscription for you so that you can take as many classes
1:58:06 you'd like throughout the year it's a single price and it also comes with a
1:58:13 few perks and one of those perks is that you can take a actual class from one of
1:58:19 the class schedules so you can take the on-demand course and then you can actually take it from the
1:58:25 instructor so that really helps you be able to find the path that you want to
1:58:31 take Juniper Networks has created a certification path just for you
1:58:37 this certification path will help you distinguish yourself amongst your colleagues that you know how Juniper
1:58:44 Networks operates and how to design and maintain networks built by Juniper
1:58:51 Networks equipment there's four levels within the certification path that you can take
1:58:57 there's an associate level a specialist level a professional level and an expert level
1:59:02 at each one of these levels you get to show how much you know about Juniper
1:59:08 Network's operating system and devices each one of these certifications can run
1:59:16 within a different track Juniper Networks has seven tracks that you can pick from to show your
1:59:23 Proficiency in Juniper network devices and configurations
1:59:28 these tracks are service provider routing and switching Enterprise routing
1:59:33 and switching data center Juno security Cloud Automation and devops data center
1:59:40 Wan security design so there's a track for you to be able to
1:59:46 move forward and show that you are proficient with Juniper Networks devices
1:59:53 thanks again for attending our jumpstart Juniper course today