WEBVTT

0:00:02.840000 --> 0:00:04.760000
 Hello and welcome to this video.

0:00:04.760000 --> 0:00:09.020000
 In this video, I'd like to talk about
 comparing traditional networks with

0:00:09.020000 --> 0:00:11.280000
 controller-based networking.

0:00:11.280000 --> 0:00:14.520000
 As far as topics we're going to cover,
 we're going to look at the management

0:00:14.520000 --> 0:00:18.100000
 of traditional networks and we're going
 to compare that with controller

0:00:18.100000 --> 0:00:21.580000
-based networks. I'm going to talk about
 something called the imperative

0:00:21.580000 --> 0:00:26.300000
 and declarative approaches of network
 controllers or SDN controllers.

0:00:26.300000 --> 0:00:30.780000
 We're going to finish up with
 the design impact of SDN.

0:00:30.780000 --> 0:00:34.480000
 In other words, when designing a network
 with software defined networking

0:00:34.480000 --> 0:00:41.580000
 in mind, how does that actually impact
 how you design the network?

0:00:41.580000 --> 0:00:46.360000
 So let's talk about managing
 traditional networks.

0:00:46.360000 --> 0:00:49.760000
 In a traditional network, you've
 got box by box management.

0:00:49.760000 --> 0:00:54.040000
 It's definitely CLI driven, possibly
 driven by a GUI, although a lot of

0:00:54.040000 --> 0:00:56.680000
 devices still rely on
 some sort of a CLI.

0:00:56.680000 --> 0:01:03.480000
 We have extensive use of Telnet,
 SSH, HTTP, possibly S&P.

0:01:03.480000 --> 0:01:07.120000
 And networking functions themselves are
 implemented in individual devices

0:01:07.120000 --> 0:01:09.700000
 using vendor proprietary ASICs.

0:01:09.700000 --> 0:01:11.360000
 What's this talking about?

0:01:11.360000 --> 0:01:13.280000
 Well, a lot of devices.

0:01:13.280000 --> 0:01:15.320000
 Let's take, for example,
 Cisco devices.

0:01:15.320000 --> 0:01:17.540000
 Let's take, for example,
 a Cisco switch.

0:01:17.540000 --> 0:01:24.000000
 Most Cisco switches up until today,
 at least, have been designed in that

0:01:24.000000 --> 0:01:29.000000
 the CPU or the brains of the switch is
 really designed for the background

0:01:29.000000 --> 0:01:33.700000
 tasks, like keeping spanning tree operational,
 maybe running the Cisco

0:01:33.700000 --> 0:01:37.660000
 Discovery protocol, maybe using the
 dynamic trunk protocol to bring up

0:01:37.660000 --> 0:01:39.040000
 and maintain links.

0:01:39.040000 --> 0:01:44.640000
 But a lot of the actual features that
 build the forwarding tables, the

0:01:44.640000 --> 0:01:48.580000
 MAC address tables and other tables,
 and maintain those tables and maybe

0:01:48.580000 --> 0:01:53.120000
 implement security policy in those
 tables, are features not running on

0:01:53.120000 --> 0:01:59.020000
 the CPU, but running on a vendor specific
 or Cisco proprietary ASIC.

0:01:59.020000 --> 0:02:01.940000
 Now, if you're not familiar with that
 term ASIC, ASIC stands for application

0:02:01.940000 --> 0:02:08.000000
 specific integrated circuit, application
 specific integrated circuit.

0:02:08.000000 --> 0:02:12.260000
 And ASIC is, it's a little chip that
 has millions or maybe billions of

0:02:12.260000 --> 0:02:13.540000
 transistors on it.

0:02:13.540000 --> 0:02:19.040000
 This designed electronically to do a
 very special task and to do it very,

0:02:19.040000 --> 0:02:22.880000
 very quickly. So the CPU, the software,
 doesn't have to be interrupted

0:02:22.880000 --> 0:02:24.220000
 to do that task.

0:02:24.220000 --> 0:02:26.820000
 It could be done in hardware.

0:02:26.820000 --> 0:02:29.180000
 Well, this is in a traditional
 network.

0:02:29.180000 --> 0:02:32.720000
 In a traditional network, a lot of those
 types of tasks are not done by

0:02:32.720000 --> 0:02:36.120000
 the CPU. They're done
 by a specific ASIC.

0:02:36.120000 --> 0:02:40.560000
 And once that ASIC is created and put
 into the box, there's really not

0:02:40.560000 --> 0:02:44.900000
 much you can do externally when you're
 outside of the box to change the

0:02:44.900000 --> 0:02:47.320000
 behavior of that ASIC.

0:02:47.320000 --> 0:02:51.400000
 A lot of times you can't really change
 it to operate in a different way,

0:02:51.400000 --> 0:02:55.720000
 which makes working with that type
 of device very challenging from an

0:02:55.720000 --> 0:02:57.780000
 SDN perspective.

0:02:57.780000 --> 0:03:03.080000
 Devices also typically start out with
 minimal or no initial configs.

0:03:03.080000 --> 0:03:06.160000
 And so in order to make that device
 useful for something, you've got to

0:03:06.160000 --> 0:03:11.060000
 log into it with the CLI, possibly with
 a GUI if it comes up with at least

0:03:11.060000 --> 0:03:15.720000
 an IP address by default, and then apply
 some configuration commands to

0:03:15.720000 --> 0:03:20.960000
 add some complexity and usefulness
 to that device.

0:03:20.960000 --> 0:03:26.240000
 And often there are multiple disparate servers
 all over for network management.

0:03:26.240000 --> 0:03:27.580000
 So what am I talking about here?

0:03:27.580000 --> 0:03:30.800000
 Well, as far as managing the network,
 you might have over here in this

0:03:30.800000 --> 0:03:35.700000
 one section, your SNMP manager for collecting
 statistics and monitoring

0:03:35.700000 --> 0:03:39.140000
 the network. You might have over
 here your IP addressing server.

0:03:39.140000 --> 0:03:41.620000
 That would be your DHCP server.

0:03:41.620000 --> 0:03:46.320000
 You might have over here another server
 running your ICE, your ICE server

0:03:46.320000 --> 0:03:48.080000
 for security policies.

0:03:48.080000 --> 0:03:52.680000
 So in order to manage the network from
 a security perspective and addressing

0:03:52.680000 --> 0:03:57.860000
 perspective, a collection of statistics
 perspective, all being done on

0:03:57.860000 --> 0:04:00.600000
 different servers all
 in different places.

0:04:00.600000 --> 0:04:05.040000
 So this is traditional management
 of a network.

0:04:05.040000 --> 0:04:11.400000
 Now let's contrast that with a network
 that's managed by SDN controllers.

0:04:11.400000 --> 0:04:15.600000
 Number one, now you have the ability
 of having dynamic implementation

0:04:15.600000 --> 0:04:18.300000
 of initial configurations.

0:04:18.300000 --> 0:04:22.120000
 You no longer necessarily have to jump
 on that brand new box that was

0:04:22.120000 --> 0:04:25.100000
 just cable and just plugged in and
 spend a lot of time on the command

0:04:25.100000 --> 0:04:26.860000
 line configuring it.

0:04:26.860000 --> 0:04:31.100000
 Now you can use plug and play or zero
 touch provisioning, have that device

0:04:31.100000 --> 0:04:37.880000
 reach out to a controller and dynamically
 obtain a fully functional configuration.

0:04:37.880000 --> 0:04:41.500000
 You can have dynamic and automatic updates
 and changes to your configurations

0:04:41.500000 --> 0:04:44.060000
 based on pre-configured policies.

0:04:44.060000 --> 0:04:48.760000
 This is talking about a situation where
 normally if I have a router switch

0:04:48.760000 --> 0:04:51.500000
 that's been sitting in my network for
 a couple of weeks or a couple of

0:04:51.500000 --> 0:04:55.580000
 months and all of a sudden I have a need,
 something changes in my network

0:04:55.580000 --> 0:04:59.600000
 to where I say, oh, that device
 needs to operate differently.

0:04:59.600000 --> 0:05:02.980000
 I need to log into that device so I
 can slam on an access list really

0:05:02.980000 --> 0:05:07.240000
 quickly. Or I need to log into that
 device and change its QS policy so

0:05:07.240000 --> 0:05:10.940000
 that this application running over here
 will be a little bit happier and

0:05:10.940000 --> 0:05:13.540000
 get better service,
 a better contract.

0:05:13.540000 --> 0:05:16.340000
 Well, up until now that's been
 a purely manual process.

0:05:16.340000 --> 0:05:20.400000
 But with software defined networking,
 it is possible both in theory and

0:05:20.400000 --> 0:05:23.640000
 in practice somewhere to
 have that automated.

0:05:23.640000 --> 0:05:26.920000
 To have the device, the router switch
 report back to a controller all

0:05:26.920000 --> 0:05:31.540000
 by itself, hey, this type of
 traffic just came in on me.

0:05:31.540000 --> 0:05:33.300000
 What do you want me to do?

0:05:33.300000 --> 0:05:37.460000
 And the controller come back and say,
 oh, slam in this access list, apply

0:05:37.460000 --> 0:05:39.040000
 this quality of service.

0:05:39.040000 --> 0:05:41.280000
 Here's a route you can
 temporarily use.

0:05:41.280000 --> 0:05:47.560000
 All of that can be dynamic and automated
 in an SDN type of environment.

0:05:47.560000 --> 0:05:52.680000
 And in some cases, you can have relocation
 of the control plane functionality

0:05:52.680000 --> 0:05:56.780000
 sent to a central SDN controller.

0:05:56.780000 --> 0:06:01.000000
 In other words, the brains or logic
 of your router or switch that would

0:06:01.000000 --> 0:06:05.720000
 normally learn things like learn MAC
 addresses, learn routes, and put

0:06:05.720000 --> 0:06:10.160000
 them into the forwarding tables, that
 functionality can actually be removed,

0:06:10.160000 --> 0:06:14.660000
 or I should say moved over from the router
 switch to a central controller

0:06:14.660000 --> 0:06:20.420000
 instead. And these days, controllers
 can consolidate multiple management

0:06:20.420000 --> 0:06:22.600000
 services into one box.

0:06:22.600000 --> 0:06:28.120000
 So instead of having an ICE server over
 here for security and a DHCP server

0:06:28.120000 --> 0:06:32.040000
 over here for IP addressing and an SNMP
 server over here for collection

0:06:32.040000 --> 0:06:36.280000
 of your management statistics, all of
 that can be consolidated into one

0:06:36.280000 --> 0:06:43.320000
 single controller, one what Cisco and
 a lot of other single pane of glass.

0:06:43.320000 --> 0:06:46.960000
 You're looking through one monitor, one
 single pane of glass to see everything

0:06:46.960000 --> 0:06:49.120000
 and control everything.

0:06:49.120000 --> 0:06:54.240000
 Now, when it comes to implementing software
 defined networking controllers

0:06:54.240000 --> 0:07:00.440000
 or SDN controllers, there's two at a very
 high level, two flavors or approaches

0:07:00.440000 --> 0:07:02.240000
 to using controllers.

0:07:02.240000 --> 0:07:06.560000
 And we call these the imperative
 and declarative approaches.

0:07:06.560000 --> 0:07:10.440000
 Okay, so let's look at
 what each of these is.

0:07:10.440000 --> 0:07:13.100000
 This is a terminology that you
 need to be familiar with.

0:07:13.100000 --> 0:07:15.760000
 So when you're looking at a controller,
 if it says, oh, we use the imperative

0:07:15.760000 --> 0:07:19.760000
 approach, or we use the declarative
 approach, this will now make a lot

0:07:19.760000 --> 0:07:24.160000
 more sense to you as exactly what that controller
 is doing, how it's implementing

0:07:24.160000 --> 0:07:28.740000
 its job. So let's start with
 the imperative approach.

0:07:28.740000 --> 0:07:32.240000
 Now, this is not how
 Cisco does it.

0:07:32.240000 --> 0:07:34.980000
 Okay, Cisco controllers
 don't do this.

0:07:34.980000 --> 0:07:38.120000
 Other controllers out there by
 other vendors do sometimes.

0:07:38.120000 --> 0:07:44.020000
 So the imperative approach is very cool
 in concept and that the control

0:07:44.020000 --> 0:07:50.020000
 plane logic resides in the controller and
 has complete control over programming

0:07:50.020000 --> 0:07:51.260000
 the forwarding path of devices.

0:07:51.260000 --> 0:07:53.160000
 What does that mean?

0:07:53.160000 --> 0:07:54.740000
 Well, imagine this for a moment.

0:07:54.740000 --> 0:07:59.920000
 Imagine that in your traditional network,
 you've got 100 routers and those

0:07:59.920000 --> 0:08:03.700000
 100 routers are running, let's say,
 OSPF as a routing protocol.

0:08:03.700000 --> 0:08:09.720000
 So that means each router individually
 has a brain, has a CPU running

0:08:09.720000 --> 0:08:13.960000
 OSPF that router is responsible for
 learning of the other routers around

0:08:13.960000 --> 0:08:19.400000
 it, of exchanging routing information
 in this case would be LSA's with

0:08:19.400000 --> 0:08:24.180000
 each other. Once that router has collected
 the LSA's, it stores them on

0:08:24.180000 --> 0:08:29.220000
 that router. Then it has to piece them
 together to form a network map

0:08:29.220000 --> 0:08:34.660000
 that router has to learn where
 the best path is to everything.

0:08:34.660000 --> 0:08:38.180000
 And then finally after it's gone through
 all of that, the best paths can

0:08:38.180000 --> 0:08:41.480000
 be put into the forwarding table.

0:08:41.480000 --> 0:08:43.340000
 Now, this is what we call
 the control plane.

0:08:43.340000 --> 0:08:48.320000
 The control plane is all that logic,
 all that thinking and processing

0:08:48.320000 --> 0:08:53.100000
 that OSPF is doing to eventually discover
 the routes and put those routes

0:08:53.100000 --> 0:08:57.680000
 into what we call the forwarding plane,
 or the data plane, which is the

0:08:57.680000 --> 0:09:02.540000
 routing table. In the imperative approach,
 we basically take that brain

0:09:02.540000 --> 0:09:06.820000
 out of the router, or in this case,
 out of all 50 routers, and we put

0:09:06.820000 --> 0:09:09.960000
 it in one device called
 the controller.

0:09:09.960000 --> 0:09:15.380000
 The controller reaches out, discovers
 where everybody is, the controller

0:09:15.380000 --> 0:09:19.960000
 discovers how everybody is connected,
 the controller discovers all the

0:09:19.960000 --> 0:09:23.600000
 subnets that everybody is using, and
 then the controller, it might be

0:09:23.600000 --> 0:09:29.100000
 OSPF, it might be its own proprietary
 thing, but the now I know where

0:09:29.100000 --> 0:09:32.500000
 everybody is, I know how everybody is
 connected, the controller himself

0:09:32.500000 --> 0:09:36.760000
 figures out the best paths
 for every single thing.

0:09:36.760000 --> 0:09:38.960000
 And so this is typically how this
 works in this environment.

0:09:38.960000 --> 0:09:42.780000
 And in an imperative approach, let's
 go back to here, didn't want to do

0:09:42.780000 --> 0:09:48.920000
 that. So an imperative approach, this
 controller right here knows, let's

0:09:48.920000 --> 0:09:50.620000
 just say he's running OSPF.

0:09:50.620000 --> 0:09:53.800000
 So he's already looked at this network,
 he already knows where everybody

0:09:53.800000 --> 0:09:56.200000
 is connected, and all
 the different paths.

0:09:56.200000 --> 0:10:01.160000
 Now the way this would work is that if
 this device right here, let's just

0:10:01.160000 --> 0:10:07.340000
 call him A, want to talk to this device
 over here, which is B, once his

0:10:07.340000 --> 0:10:13.620000
 very first packet hit this networking
 device, this networking device's

0:10:13.620000 --> 0:10:17.140000
 forwarding table might start out completely
 empty, or maybe all he knows

0:10:17.140000 --> 0:10:20.640000
 is his directly connected paths, but
 what he would do is he would send

0:10:20.640000 --> 0:10:26.160000
 that packet, so right now he might just
 know of this link, and this link,

0:10:26.160000 --> 0:10:27.360000
 and that's all he knows.

0:10:27.360000 --> 0:10:30.200000
 Remember, he doesn't have a brain, he
 doesn't have a control plane, all

0:10:30.200000 --> 0:10:32.200000
 he knows is what he's
 directly connected to.

0:10:32.200000 --> 0:10:36.140000
 Now he also knows about the controller,
 he knows how to get there, so

0:10:36.140000 --> 0:10:40.080000
 he gets this single packet,
 sends it to the controller.

0:10:40.080000 --> 0:10:45.040000
 The controller has the brain, he knows
 where everybody's living, he knows

0:10:45.040000 --> 0:10:50.240000
 the routes to everything, and he knows,
 oh okay, well that packet actually

0:10:50.240000 --> 0:10:54.560000
 needs to get over here, so the controller
 would now program the forwarding

0:10:54.560000 --> 0:11:01.280000
 paths of all these devices with a suitable
 route to get that packet to

0:11:01.280000 --> 0:11:05.580000
 its destination, and now that route
 could be used forever more unless

0:11:05.580000 --> 0:11:09.140000
 the controller decided to send an instruction
 saying hey remove that,

0:11:09.140000 --> 0:11:12.420000
 we don't need any more, oh
 hey, here's a better route.

0:11:12.420000 --> 0:11:17.220000
 So the main point here is that in the
 imperative approach, all of the

0:11:17.220000 --> 0:11:21.960000
 logic of the control plane, of learning
 where devices are and the best

0:11:21.960000 --> 0:11:27.000000
 path to devices is done in the controller,
 and then the controller directly

0:11:27.000000 --> 0:11:32.240000
 programs the forwarding tables, whether
 it be routing tables, or Mac tables,

0:11:32.240000 --> 0:11:35.680000
 or some other type of table, directly
 programs that on the networking

0:11:35.680000 --> 0:11:40.940000
 devices itself. This is for example what
 the open flow protocol was designed

0:11:40.940000 --> 0:11:44.580000
 to do, if you ever read about open flow,
 this is open flow is a protocol

0:11:44.580000 --> 0:11:48.740000
 for the controller to talk to the routers
 and switches to be able to allow

0:11:48.740000 --> 0:11:52.540000
 it to program the
 forwarding tables.

0:11:52.540000 --> 0:11:56.240000
 Now I mentioned that Cisco devices
 don't take this approach, my guess

0:11:56.240000 --> 0:12:00.260000
 is probably because Cisco already has
 a huge embedded base in the world,

0:12:00.260000 --> 0:12:04.620000
 there's probably billions of routers
 and switches out there, and all these

0:12:04.620000 --> 0:12:06.540000
 devices already have a brain.

0:12:06.540000 --> 0:12:09.700000
 Cisco for years has been selling routers
 and switches that have the capability

0:12:09.700000 --> 0:12:16.300000
 on their own to run OSPF, EIGRP, Dynamic
 Mac Learning, and so the imperative

0:12:16.300000 --> 0:12:20.020000
 approach wouldn't really work for them,
 so instead they took something

0:12:20.020000 --> 0:12:27.520000
 different, they decided to take an approach
 which is called the declarative

0:12:27.520000 --> 0:12:31.960000
 approach. So in the declarative approach,
 the control plane logic still

0:12:31.960000 --> 0:12:36.500000
 resides within the individual device, so
 what's the function of the controller?

0:12:36.500000 --> 0:12:42.660000
 The controller declares the requirements
 of applications, for example

0:12:42.660000 --> 0:12:47.100000
 an application might talk to this controller,
 this APIC ACI controller,

0:12:47.100000 --> 0:12:53.840000
 and say hey, when I send my data through
 your network, I need a path that

0:12:53.840000 --> 0:12:57.760000
 has the least congestion possible, or
 I need a path with certain bandwidth

0:12:57.760000 --> 0:13:02.500000
 requirements. Now that the controller
 is aware of that application and

0:13:02.500000 --> 0:13:07.120000
 aware of what the needs are of that
 application, he can actually talk

0:13:07.120000 --> 0:13:11.680000
 to the switches and say hey, this is
 what I need, I need a path set up

0:13:11.680000 --> 0:13:16.760000
 between for example server A on the
 left and server Z on the right, and

0:13:16.760000 --> 0:13:20.880000
 I need that path set up with the least
 congestion possible, so he has

0:13:20.880000 --> 0:13:26.400000
 declared what he needs to have happen,
 he hasn't actually impacted the

0:13:26.400000 --> 0:13:30.560000
 folding table himself, and now the
 individual networking devices have

0:13:30.560000 --> 0:13:36.140000
 to decide on their own how to translate
 that into functional actions.

0:13:36.140000 --> 0:13:39.340000
 The individual devices might decide
 that they're going to implement a

0:13:39.340000 --> 0:13:43.460000
 new route to make that a reality, maybe
 they'll decide to implement some

0:13:43.460000 --> 0:13:47.900000
 new QoS policy temporarily
 to make that a new reality.

0:13:47.900000 --> 0:13:52.960000
 So the controller has basically declared
 what he needs, or I should say

0:13:52.960000 --> 0:13:56.900000
 what the application needs, and the
 networking devices themselves have

0:13:56.900000 --> 0:14:02.720000
 to translate that into a functional
 command to make it happen, and this

0:14:02.720000 --> 0:14:09.180000
 is how Cisco's device, this is
 how Cisco's SDN solution works.

0:14:09.180000 --> 0:14:13.000000
 So let's finally talk about
 designing a network.

0:14:13.000000 --> 0:14:18.500000
 So I want to, let's say I've got a new
 site, I just bought this new building,

0:14:18.500000 --> 0:14:22.400000
 a 200,000 square foot building with
 office spaces and warehouse and all

0:14:22.400000 --> 0:14:26.460000
 sorts of stuff, it's empty right now,
 but I want to put a network in there,

0:14:26.460000 --> 0:14:28.560000
 and it's my job to architect
 a network.

0:14:28.560000 --> 0:14:31.980000
 Now I think to myself, okay, well I
 would like to use software defined

0:14:31.980000 --> 0:14:36.300000
 networking. As I build this network
 out, I want to use the benefits of

0:14:36.300000 --> 0:14:40.840000
 SDN to automatically provision my devices,
 to automatically slam in security

0:14:40.840000 --> 0:14:43.840000
 and access list policies
 if I want.

0:14:43.840000 --> 0:14:50.620000
 So knowing that in advance, how does
 that impact how I design or architect

0:14:50.620000 --> 0:14:53.540000
 this network from the ground up?

0:14:53.540000 --> 0:14:55.100000
 And that's what we're
 looking at right here.

0:14:55.100000 --> 0:14:57.720000
 So here are the considerations
 you have to have.

0:14:57.720000 --> 0:15:03.820000
 Number one, we have to know what kind
 of controller am I going to use?

0:15:03.820000 --> 0:15:05.620000
 What do I want it to do?

0:15:05.620000 --> 0:15:08.220000
 That will impact do I get
 Cisco's controller?

0:15:08.220000 --> 0:15:10.900000
 Cisco offers like three or four different
 kinds of controllers, which

0:15:10.900000 --> 0:15:14.760000
 one do I want? Do I want a controller
 made from somebody else like Juniper

0:15:14.760000 --> 0:15:16.580000
 or something else?

0:15:16.580000 --> 0:15:19.400000
 Now that I've selected the controller
 I want that has a functionality

0:15:19.400000 --> 0:15:24.140000
 I want, now I have to think about how
 does that controller talk to my

0:15:24.140000 --> 0:15:28.900000
 devices? What types of protocols or
 languages does it use to talk to my

0:15:28.900000 --> 0:15:30.620000
 Cisco routers or switches?

0:15:30.620000 --> 0:15:32.820000
 That will help me select
 my hardware.

0:15:32.820000 --> 0:15:35.420000
 I certainly don't want to select a
 router or switch that doesn't have

0:15:35.420000 --> 0:15:40.720000
 the ability to speak the same language
 as what the controller speaks.

0:15:40.720000 --> 0:15:45.060000
 I definitely want some redundant
 paths to and from my controller.

0:15:45.060000 --> 0:15:49.160000
 If I only have one path and that path
 goes down, I just wasted $80,000

0:15:49.160000 --> 0:15:53.800000
 in a controller that
 nobody can get to.

0:15:53.800000 --> 0:15:57.840000
 If I have multiple data centers spread
 throughout the state or spread

0:15:57.840000 --> 0:16:02.220000
 throughout the country, then I have to
 plan for how are all my sites going

0:16:02.220000 --> 0:16:03.400000
 to reach my controllers?

0:16:03.400000 --> 0:16:07.420000
 Maybe I have a controller in each data
 center or maybe I want one centralized

0:16:07.420000 --> 0:16:10.480000
 controller that's going to talk to
 all those different data centers.

0:16:10.480000 --> 0:16:12.300000
 How do I plan for that
 geographically?

0:16:12.300000 --> 0:16:16.420000
 That's going to impact what type of
 WAN circuits I purchase, how much

0:16:16.420000 --> 0:16:22.220000
 redundancy I want to have in my WAN
 provisioning I should probably buy

0:16:22.220000 --> 0:16:24.660000
 more than one controller.

0:16:24.660000 --> 0:16:28.200000
 I've read a lot of documents to say
 at minimum you should have three.

0:16:28.200000 --> 0:16:33.720000
 You should have three controllers configured
 in a cluster for redundancy.

0:16:33.720000 --> 0:16:36.460000
 Security is critical.

0:16:36.460000 --> 0:16:42.440000
 Remember, these controllers have major impact
 over my networking infrastructure.

0:16:42.440000 --> 0:16:46.260000
 I do not want under any circumstances
 anyone to have the ability to hack

0:16:46.260000 --> 0:16:51.440000
 into or otherwise damage or
 bring down my controller.

0:16:51.440000 --> 0:16:54.660000
 So I have to think about how am I going
 to implement security in my network

0:16:54.660000 --> 0:16:59.760000
 to prevent people from doing those
 types of terrible things.

0:16:59.760000 --> 0:17:02.860000
 And then lastly, don't
 forget about training.

0:17:02.860000 --> 0:17:05.120000
 Am I going to be the
 only one doing this?

0:17:05.120000 --> 0:17:08.160000
 Or am I going to have a staff or a team
 of network engineers and admins

0:17:08.160000 --> 0:17:09.740000
 are going to build this stuff up?

0:17:09.740000 --> 0:17:12.420000
 How many people are going to be responsible
 for that controller and getting

0:17:12.420000 --> 0:17:15.340000
 onto it? Do I have training
 available to give them?

0:17:15.340000 --> 0:17:16.360000
 Am I going to give them books?

0:17:16.360000 --> 0:17:18.840000
 Am I going to send them
 to courses and classes?

0:17:18.840000 --> 0:17:22.280000
 This is all going to be part
 of architecting this network.

0:17:22.280000 --> 0:17:24.840000
 So that brings us to the
 end of this video.

0:17:24.840000 --> 0:17:27.260000
 Thank you for watching and I
 hope it was useful to you.

