Jumpstart Juniper—Intermediate

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