WEBVTT

0:00:02.840000 --> 0:00:07.480000
 Hello and welcome to this video titled
 an introduction to virtualization.

0:00:07.480000 --> 0:00:11.560000
 In this video I'm going to cover something
 called the typical compute

0:00:11.560000 --> 0:00:15.480000
 architecture. This is just a term I
 made up and we'll get into that and

0:00:15.480000 --> 0:00:16.760000
 what that means.

0:00:16.760000 --> 0:00:22.300000
 We'll talk about the challenges and problems
 about systems before virtualization

0:00:22.300000 --> 0:00:26.300000
 was invented. Then of course we'll
 talk about what is virtualization.

0:00:26.300000 --> 0:00:29.740000
 Let's define it and let's talk about
 some of the benefits of it.

0:00:29.740000 --> 0:00:33.480000
 And now let's three common
 virtual machine terms.

0:00:33.480000 --> 0:00:36.920000
 There's a lot of terminology that goes
 along with virtualization but there's

0:00:36.920000 --> 0:00:40.660000
 three terms in particular that you're
 going to see over and over and over

0:00:40.660000 --> 0:00:43.300000
 again so it's good for you to
 know what those terms mean.

0:00:43.300000 --> 0:00:47.480000
 So let's start with just what I've
 defined here as the typical compute

0:00:47.480000 --> 0:00:52.240000
 architecture. And what I'm referring to
 here is not necessarily just computers

0:00:52.240000 --> 0:00:58.020000
 as in a PC or a laptop or a server but
 anything that underneath the hood

0:00:58.020000 --> 0:01:01.920000
 has the common elements that
 a computer would have.

0:01:01.920000 --> 0:01:06.880000
 So for example routers, firewalls,
 switches, lots of different things

0:01:06.880000 --> 0:01:10.760000
 fall into the sort of generic
 general model here.

0:01:10.760000 --> 0:01:16.660000
 So the basic computing architecture
 whether it be a laptop, a tablet,

0:01:16.660000 --> 0:01:20.460000
 a smartphone or router or
 a switch looks like this.

0:01:20.460000 --> 0:01:24.580000
 So you've got on the top there several
 applications that are running,

0:01:24.580000 --> 0:01:28.880000
 whatever those applications might be,
 one might be a web browser, one

0:01:28.880000 --> 0:01:34.120000
 might be some sort of text editing software,
 another might be a spreadsheet

0:01:34.120000 --> 0:01:39.700000
 application but all of those applications
 are written to work with what's

0:01:39.700000 --> 0:01:41.880000
 below it which is an
 operating system.

0:01:41.880000 --> 0:01:48.480000
 So this is why for example if you have
 a Microsoft specific application

0:01:48.480000 --> 0:01:53.820000
 like Microsoft Paint or something that's
 written to go with the Microsoft

0:01:53.820000 --> 0:01:55.140000
 operating system.

0:01:55.140000 --> 0:01:59.400000
 That's why you can't take that application
 and install it on a Unix based

0:01:59.400000 --> 0:02:03.060000
 system or a Mac notebook
 or something like that.

0:02:03.060000 --> 0:02:07.540000
 So in a typical architecture here we've
 got these applications are specifically

0:02:07.540000 --> 0:02:10.400000
 written to go with an
 operating system.

0:02:10.400000 --> 0:02:15.040000
 They have code that knows how to
 talk to the operating system.

0:02:15.040000 --> 0:02:19.260000
 Now the operating system in turn all
 of this stuff has been installed

0:02:19.260000 --> 0:02:21.620000
 on some physical hardware.

0:02:21.620000 --> 0:02:26.900000
 Some physical hardware that has RAM,
 a hard disk drive, input output for

0:02:26.900000 --> 0:02:34.220000
 like keyboards and mouse, a CPU, network
 interface cards and so the operating

0:02:34.220000 --> 0:02:40.600000
 system is the software that has the
 hooks into these physical things.

0:02:40.600000 --> 0:02:45.040000
 So the application itself, whatever
 that application is, it needs some

0:02:45.040000 --> 0:02:50.700000
 memory. It needs some CPU processing time
 but it can't access those physical

0:02:50.700000 --> 0:02:52.480000
 resources directly.

0:02:52.480000 --> 0:02:56.420000
 It has to talk to the operating system
 and say hey, here's something I

0:02:56.420000 --> 0:02:58.420000
 need you to send down to the CPU.

0:02:58.420000 --> 0:03:00.900000
 Here's some stuff I need
 you to store in memory.

0:03:00.900000 --> 0:03:03.900000
 Here's some stuff I need you to direct
 to the network interface card.

0:03:03.900000 --> 0:03:08.700000
 And then the operating system in turn
 has direct connections into those

0:03:08.700000 --> 0:03:10.580000
 physical resources.

0:03:10.580000 --> 0:03:13.740000
 So that is your typical
 compute architecture.

0:03:13.740000 --> 0:03:16.400000
 So everything is tied together.

0:03:16.400000 --> 0:03:19.460000
 The applications are dependent
 upon the operating system.

0:03:19.460000 --> 0:03:25.420000
 The operating system is tied into the
 actual physical hardware itself.

0:03:25.420000 --> 0:03:31.140000
 Okay, so that is our typical architecture
 before virtualization was ever

0:03:31.140000 --> 0:03:35.080000
 invented. Well, but with this architecture
 and this architecture work

0:03:35.080000 --> 0:03:37.440000
 fine for a long, long time.

0:03:37.440000 --> 0:03:41.180000
 But there were some challenges
 that were presented with it.

0:03:41.180000 --> 0:03:45.940000
 For example, let's say for example that
 I want to work with two different

0:03:45.940000 --> 0:03:51.040000
 applications. This application right here
 was designed to work with Microsoft

0:03:51.040000 --> 0:03:55.420000
 Windows. However, this other application
 that I also really want to work

0:03:55.420000 --> 0:04:00.240000
 with was designed to work on a Mac
 based system like a Mac notebook or

0:04:00.240000 --> 0:04:02.040000
 a Mac book or something.

0:04:02.040000 --> 0:04:03.760000
 How do I do that?

0:04:03.760000 --> 0:04:08.680000
 Well, in the typical architecture,
 there are really only two ways you

0:04:08.680000 --> 0:04:12.300000
 could do it. Method number one was
 you could take your hard disk drive

0:04:12.300000 --> 0:04:15.500000
 and divide it into multiple
 partitions.

0:04:15.500000 --> 0:04:19.280000
 And you could say, okay, when I boot
 my laptop or boot my computer using

0:04:19.280000 --> 0:04:23.220000
 this partition of the hard drive,
 it will boot up into Windows.

0:04:23.220000 --> 0:04:26.060000
 And I can use my Windows
 based applications.

0:04:26.060000 --> 0:04:29.480000
 But if I want to use my Mac application,
 then I got to shut my laptop

0:04:29.480000 --> 0:04:34.360000
 down, boot it up again, but this time
 have it boot into this other section

0:04:34.360000 --> 0:04:38.780000
 of the hard drive where I have the
 Mac operating system loaded.

0:04:38.780000 --> 0:04:42.920000
 And now when Mac OS loads up,
 I can use those applications.

0:04:42.920000 --> 0:04:45.960000
 But still, that didn't solve the problem
 of what if I want to use them

0:04:45.960000 --> 0:04:47.280000
 both at the same time?

0:04:47.280000 --> 0:04:50.640000
 What if I want to be able to easily
 shuffle back and forth between them,

0:04:50.640000 --> 0:04:54.800000
 having to power off and restart, power
 off and restart my laptop so I

0:04:54.800000 --> 0:04:58.060000
 can access these different sections
 of the hard drive where these two

0:04:58.060000 --> 0:05:02.640000
 different operating systems are stored,
 that's not very feasible.

0:05:02.640000 --> 0:05:05.380000
 And this is going to have a
 lot of delay induced in it.

0:05:05.380000 --> 0:05:09.860000
 Well, the other alternative before virtualization
 was, hey, you just got

0:05:09.860000 --> 0:05:13.160000
 to buy yourself two laptops, have sitting
 right in front of you, a laptop

0:05:13.160000 --> 0:05:17.080000
 running Windows and a Mac
 book running Mac OS, OS X.

0:05:17.080000 --> 0:05:20.880000
 And then you can just multitask with your
 fingers on two different keyboards

0:05:20.880000 --> 0:05:23.220000
 and access those two
 different apps.

0:05:23.220000 --> 0:05:26.260000
 So that worked, but now we're
 talking about cost, right?

0:05:26.260000 --> 0:05:28.060000
 That costs more money to do that.

0:05:28.060000 --> 0:05:31.520000
 So that was one of the challenges
 with the norm.

0:05:31.520000 --> 0:05:33.140000
 Here's another challenge.

0:05:33.140000 --> 0:05:37.500000
 What if I had one application, okay,
 one application may be a database

0:05:37.500000 --> 0:05:43.300000
 application, but I had separate groups
 of users, maybe payroll, want to

0:05:43.300000 --> 0:05:47.320000
 use that database and marketing
 want to use that database.

0:05:47.320000 --> 0:05:49.220000
 But here's my goal.

0:05:49.220000 --> 0:05:53.340000
 When payroll and marketing use that database,
 I want to keep them completely

0:05:53.340000 --> 0:05:55.860000
 and utterly separate.

0:05:55.860000 --> 0:05:59.980000
 In other words, when payroll is logged
 into my system, marketing could

0:05:59.980000 --> 0:06:04.280000
 be logged in at exactly the same time,
 but they won't even know that they

0:06:04.280000 --> 0:06:07.880000
 exist. Payroll can do what they want
 to do, marketing can do whatever

0:06:07.880000 --> 0:06:08.940000
 they want to do.

0:06:08.940000 --> 0:06:11.300000
 They can both access
 this database.

0:06:11.300000 --> 0:06:12.900000
 Their data is kept separate.

0:06:12.900000 --> 0:06:14.780000
 It's not touching each other.

0:06:14.780000 --> 0:06:19.420000
 How do you do that in your typical
 compute architecture?

0:06:19.420000 --> 0:06:22.160000
 It's virtually impossible
 to accomplish that.

0:06:22.160000 --> 0:06:25.360000
 Most of the time what you'd have to really
 end up doing is providing different

0:06:25.360000 --> 0:06:27.140000
 physical machines.

0:06:27.140000 --> 0:06:30.980000
 You'd have to have one server that's dedicated
 for payroll with that database

0:06:30.980000 --> 0:06:32.900000
 application on the server.

0:06:32.900000 --> 0:06:34.300000
 Payroll goes to that server.

0:06:34.300000 --> 0:06:38.240000
 You'd have to have another physical
 server, totally different system for

0:06:38.240000 --> 0:06:40.320000
 marketing that they got into.

0:06:40.320000 --> 0:06:42.920000
 So that's how you'd
 have to do that.

0:06:42.920000 --> 0:06:46.000000
 Okay, and then okay, well, how do I
 prevent payroll from accidentally

0:06:46.000000 --> 0:06:48.120000
 getting onto the marketing server?


0:06:48.120000 --> 0:06:50.000000
 Because I don't want them
 having any access to that.

0:06:50.000000 --> 0:06:53.640000
 Well, now you'd have to have different
 access credentials, different usernames

0:06:53.640000 --> 0:06:57.060000
 and passwords. Now you'd have to get into
 your network and start implementing

0:06:57.060000 --> 0:07:02.160000
 access lists and all sorts of other
 things to keep them separated from

0:07:02.160000 --> 0:07:06.860000
 each other. So, these were some challenges
 with the typical norms.

0:07:06.860000 --> 0:07:12.840000
 So, the problem that spawned this idea
 of virtualization was that prior

0:07:12.840000 --> 0:07:17.700000
 to virtualization, we had to have dedicated
 physical devices which produced

0:07:17.700000 --> 0:07:22.380000
 geographically dispersed systems in
 your building over here in this one

0:07:22.380000 --> 0:07:26.320000
 corner over here would be a bunch of
 servers that were maintained and

0:07:26.320000 --> 0:07:28.280000
 operated by the marketing
 department.

0:07:28.280000 --> 0:07:31.580000
 Over here in another corner of the building
 were different set of servers

0:07:31.580000 --> 0:07:33.180000
 owned by the payroll department.

0:07:33.180000 --> 0:07:36.920000
 Over there are the engineering
 servers.

0:07:36.920000 --> 0:07:40.140000
 And so, we also had some
 resource challenges here.

0:07:40.140000 --> 0:07:45.440000
 For example, application downtime as,
 you know, if we started saying,

0:07:45.440000 --> 0:07:47.900000
 you know what, the server over
 here, we need to upgrade it.

0:07:47.900000 --> 0:07:49.280000
 He's running out of memory.

0:07:49.280000 --> 0:07:51.240000
 Let's add some new memory to him.

0:07:51.240000 --> 0:07:55.500000
 Let's add a better video processor
 or graphics card to that guy.

0:07:55.500000 --> 0:07:59.380000
 Well, we're going to have to take that
 server offline to do that, which

0:07:59.380000 --> 0:08:02.860000
 means that the applications that were
 running on that server are no longer

0:08:02.860000 --> 0:08:06.260000
 accessible until that server is put
 back in a production and it's been

0:08:06.260000 --> 0:08:07.880000
 upgraded and it's ready to go.

0:08:07.880000 --> 0:08:10.440000
 So, there was some downtime
 involved with that.

0:08:10.440000 --> 0:08:14.640000
 You also had a lot of underutilization
 of hardware.

0:08:14.640000 --> 0:08:19.180000
 You might have the server over here
 that had 25 different applications

0:08:19.180000 --> 0:08:24.140000
 on it, but at any given point in time,
 maybe only two or three of them

0:08:24.140000 --> 0:08:25.440000
 were actually being used.

0:08:25.440000 --> 0:08:31.160000
 So, you've got all this memory, all
 this CPU power that you put onto the

0:08:31.160000 --> 0:08:36.100000
 server to support all these applications,
 but in reality, most of that

0:08:36.100000 --> 0:08:40.500000
 CPU processing time, most of that
 memory is not being utilized.

0:08:40.500000 --> 0:08:44.680000
 It's sort of like an airplane that's
 got 300 seats, but only sells five

0:08:44.680000 --> 0:08:49.020000
 tickets. Yeah, it's got the capability
 of carrying 300 people, but right

0:08:49.020000 --> 0:08:53.100000
 now, only five people are sitting in
 that airplane, a lot of underutilized

0:08:53.100000 --> 0:08:57.400000
 space. Same type of problem
 here with resources.

0:08:57.400000 --> 0:09:00.060000
 And then when everything was based
 on hardware, well, hardware becomes

0:09:00.060000 --> 0:09:03.600000
 obsolete. The latest and greatest
 servers come out, right?

0:09:03.600000 --> 0:09:07.240000
 The latest and greatest routers come
 out and we have to recycle this stuff

0:09:07.240000 --> 0:09:11.140000
 and now pay more money
 to get more hardware.

0:09:11.140000 --> 0:09:15.340000
 Or maybe as applications, you know,
 there's a lot of applications that

0:09:15.340000 --> 0:09:20.140000
 newer versions come out every year or
 so and sometimes what application

0:09:20.140000 --> 0:09:25.160000
 developers will say is they'll have this
 next version of this application

0:09:25.160000 --> 0:09:28.480000
 we're going to come out with, you know,
 version nine of whatever this

0:09:28.480000 --> 0:09:33.880000
 app is, is no longer supported on
 this, this and this hardware.

0:09:33.880000 --> 0:09:35.580000
 And so you're thinking,
 okay, great.

0:09:35.580000 --> 0:09:39.120000
 I've been using that application from
 version one up until version eight.

0:09:39.120000 --> 0:09:42.300000
 I've been having it sit on this server
 and now they're telling me that

0:09:42.300000 --> 0:09:45.960000
 when the next version comes out that
 I really need to got bug fixes in

0:09:45.960000 --> 0:09:49.520000
 it and features in it that I need that
 I'm not going to be able to run

0:09:49.520000 --> 0:09:50.880000
 it on my existing hardware.

0:09:50.880000 --> 0:09:53.860000
 I'm going to have to replace my hardware
 just so I can use this newer

0:09:53.860000 --> 0:09:56.920000
 upgraded version of this software
 that I've been using.

0:09:56.920000 --> 0:10:00.820000
 So this was another problem with having
 your applications tied into your

0:10:00.820000 --> 0:10:03.900000
 operating system, which was
 tied into your hardware.

0:10:03.900000 --> 0:10:05.760000
 Lots of problems here.

0:10:05.760000 --> 0:10:09.040000
 Also, let's go back up to that first
 bullet point there for a second.

0:10:09.040000 --> 0:10:13.820000
 So with geographically dispersed systems,
 that was a hard time to monitor

0:10:13.820000 --> 0:10:17.680000
 all that stuff. What if you were the
 IT guy and it was your job to monitor

0:10:17.680000 --> 0:10:22.320000
 and maintain all these servers but
 they're spread all over the campus?

0:10:22.320000 --> 0:10:25.100000
 You've got some servers in building
 one, building three, the first floor

0:10:25.100000 --> 0:10:28.900000
 building seven, the seventh floor
 building seven all over the place.

0:10:28.900000 --> 0:10:32.880000
 Really hard to keep your finger on
 the pulse of all this stuff and how

0:10:32.880000 --> 0:10:36.820000
 it's doing and if it needs maintenance
 or monitoring when it's all over

0:10:36.820000 --> 0:10:44.080000
 the place. So these were the challenges
 that were presented among many

0:10:44.080000 --> 0:10:50.540000
 others as well. So this is why
 virtualization was developed.

0:10:50.540000 --> 0:10:53.120000
 So what exactly is virtualization?


0:10:53.120000 --> 0:10:55.300000
 Well here's the idea behind
 virtualization.

0:10:55.300000 --> 0:11:00.640000
 We're essentially combining
 multiple machines into one.

0:11:00.640000 --> 0:11:03.280000
 Let's go back to my example here as
 I had at the beginning of the video

0:11:03.280000 --> 0:11:06.860000
 where I said, hey, I've got two different
 applications I want to use.

0:11:06.860000 --> 0:11:08.120000
 But here's my problem.

0:11:08.120000 --> 0:11:11.380000
 Application A uses the Windows
 operating system.

0:11:11.380000 --> 0:11:15.720000
 Application B uses like maybe
 a Linux operating system.

0:11:15.720000 --> 0:11:20.160000
 Okay, well prior to virtualization
 we talked about that.

0:11:20.160000 --> 0:11:23.600000
 Two different partitions on my hard
 drive and boot from one to the other

0:11:23.600000 --> 0:11:27.800000
 or just go out and buy two different
 laptops or two different servers

0:11:27.800000 --> 0:11:30.400000
 and shuffle back and
 forth between them.

0:11:30.400000 --> 0:11:33.540000
 Virtualization says, hey,
 you don't have to do that.

0:11:33.540000 --> 0:11:36.080000
 Let's just buy one
 set of hardware.

0:11:36.080000 --> 0:11:40.380000
 Let's buy one service, got a lot of memory,
 a lot of CPU, a lot of physical

0:11:40.380000 --> 0:11:45.600000
 resources. And then what we're going
 to do is we'll actually load both

0:11:45.600000 --> 0:11:48.080000
 of those operating
 systems onto it.

0:11:48.080000 --> 0:11:51.040000
 Now you say, but Keith, how do you
 have both operating systems running

0:11:51.040000 --> 0:11:52.840000
 at the same time?

0:11:52.840000 --> 0:11:54.920000
 Here's the deal with
 virtualization.

0:11:54.920000 --> 0:11:59.620000
 Instead of having the operating systems
 tied into the physical hardware

0:11:59.620000 --> 0:12:03.620000
 of like the CPU and the memory,
 there's something in the middle.

0:12:03.620000 --> 0:12:06.340000
 And this is what we
 call a hypervisor.

0:12:06.340000 --> 0:12:08.560000
 Now hypervisor is not
 a physical thing.

0:12:08.560000 --> 0:12:09.980000
 You can't see it and touch it.

0:12:09.980000 --> 0:12:11.800000
 It's a software component.

0:12:11.800000 --> 0:12:14.620000
 Think of it as like another
 operating system.

0:12:14.620000 --> 0:12:18.240000
 Just like you've got Windows and macOS,
 which are operating systems.

0:12:18.240000 --> 0:12:21.380000
 Well, there are operating systems
 that are called hypervisors.

0:12:21.380000 --> 0:12:26.640000
 And so what you do is when you buy this
 server with all the CPU and memory

0:12:26.640000 --> 0:12:30.820000
 space and stuff, instead of loading
 your typical operating system on it

0:12:30.820000 --> 0:12:36.680000
 like Windows Server or Linux or Unix,
 instead you load this operating

0:12:36.680000 --> 0:12:40.240000
 system called a hypervisor
 onto it.

0:12:40.240000 --> 0:12:45.920000
 Now the hypervisor is tied into your
 physical CPU, memory, all that good

0:12:45.920000 --> 0:12:50.480000
 stuff. And now what makes the hypervisor
 special and unique is I can go

0:12:50.480000 --> 0:12:53.960000
 in there and I can say, okay hypervisor,
 I want to load an instance of

0:12:53.960000 --> 0:12:57.920000
 Windows. And then I want to have Windows
 running and I can have my Windows

0:12:57.920000 --> 0:13:02.420000
 apps. At the same time, at exactly the
 same time, I want to load another

0:13:02.420000 --> 0:13:12.560000
 instance of macOS and have that
 running at the same time.

0:13:12.560000 --> 0:13:14.880000
 So you can have all these
 virtual machines.

0:13:14.880000 --> 0:13:18.840000
 I can have a Windows virtual machine
 running at the same time as a Mac

0:13:18.840000 --> 0:13:23.320000
 virtual machine, as the same time
 as Ubuntu virtual machine.

0:13:23.320000 --> 0:13:24.960000
 They're all separate.

0:13:24.960000 --> 0:13:26.400000
 They don't see each other.

0:13:26.400000 --> 0:13:28.620000
 They don't even know
 each other exists.

0:13:28.620000 --> 0:13:34.800000
 Each virtual machine believes it has
 access to the CPU of the device,

0:13:34.800000 --> 0:13:35.920000
 the memory of the device.

0:13:35.920000 --> 0:13:41.340000
 What the virtual machine doesn't know is
 that between itself and the physical

0:13:41.340000 --> 0:13:45.900000
 hardware, there's this thing that's
 coordinating everything, which is

0:13:45.900000 --> 0:13:48.000000
 called the hypervisor.

0:13:48.000000 --> 0:13:52.120000
 So that's what virtualization is about,
 is we can have one physical box

0:13:52.120000 --> 0:13:58.440000
 that has, that's emulating multiple
 logical boxes inside of it all at

0:13:58.440000 --> 0:14:02.640000
 the same time. And we maintain
 the logical separation.

0:14:02.640000 --> 0:14:05.580000
 Now you might say, but Keith, if I have
 these virtual machines running,

0:14:05.580000 --> 0:14:10.340000
 like let's say I've got four Microsoft
 virtual machines, maybe a couple

0:14:10.340000 --> 0:14:12.560000
 of Mac virtual machines.

0:14:12.560000 --> 0:14:14.840000
 How do I do networking?

0:14:14.840000 --> 0:14:17.860000
 How do I say, well, I want the four Microsoft
 virtual machines to actually

0:14:17.860000 --> 0:14:21.420000
 be on the same subnet and be able to
 talk to each other as if they were

0:14:21.420000 --> 0:14:24.600000
 four physical laptops on a LAN.

0:14:24.600000 --> 0:14:27.840000
 I want to emulate that
 inside this box.

0:14:27.840000 --> 0:14:29.380000
 How do I do that?

0:14:29.380000 --> 0:14:32.960000
 And how do I keep them separate from
 the Mac machines so where they don't

0:14:32.960000 --> 0:14:37.360000
 talk to them? Well, there's another
 logical entity running inside this

0:14:37.360000 --> 0:14:42.300000
 box, which ties everything together,
 which is called a virtual switch.

0:14:42.300000 --> 0:14:45.680000
 So some terminology I want you to take
 away from this, and we're going

0:14:45.680000 --> 0:14:49.580000
 to go into the details of all this stuff
 a little bit later, is the concept

0:14:49.580000 --> 0:14:53.420000
 of host operating system and
 guest operating system.

0:14:53.420000 --> 0:14:59.280000
 So when you purchase your physical
 server, and you put your hypervisor

0:14:59.280000 --> 0:15:03.800000
 on there, so your hypervisor is the
 operating system that's coordinating

0:15:03.800000 --> 0:15:09.140000
 all that stuff, the hypervisor would
 be considered the host operating

0:15:09.140000 --> 0:15:14.220000
 system. So the physical server is the
 host and the individual virtual

0:15:14.220000 --> 0:15:18.520000
 machines, whether they be virtual machines
 of Windows machines, Linux

0:15:18.520000 --> 0:15:23.940000
 machines, Mac machines, or maybe virtualized
 routers, virtualized firewalls,

0:15:23.940000 --> 0:15:29.320000
 whatever they are, their operating
 systems are called guest operating

0:15:29.320000 --> 0:15:35.000000
 systems. Think of it as like a hotel,
 where the hotel is the host, and

0:15:35.000000 --> 0:15:36.380000
 what is it hosting?

0:15:36.380000 --> 0:15:42.400000
 It's hosting individual guests
 inside individual rooms.

0:15:42.400000 --> 0:15:47.280000
 So you can probably start to see here
 that there's a lot of benefits to

0:15:47.280000 --> 0:15:48.800000
 using virtualization.

0:15:48.800000 --> 0:15:51.060000
 Number one, reduced
 hardware costs.

0:15:51.060000 --> 0:15:56.420000
 Instead of having five physical servers
 for five different departments,

0:15:56.420000 --> 0:16:00.940000
 I can just have one physical server and
 have each department have a logical

0:16:00.940000 --> 0:16:06.860000
 server, a virtualized machine, inside
 that one host, reduce my hardware

0:16:06.860000 --> 0:16:12.120000
 costs. Also reduce the cost of my cabling
 and reduce the cost of how much

0:16:12.120000 --> 0:16:16.660000
 air conditioning I need, and all that
 stuff that I would normally need

0:16:16.660000 --> 0:16:20.860000
 with five or 10 or
 15 different hosts.

0:16:20.860000 --> 0:16:24.060000
 It's more efficient utilization
 of the hardware.

0:16:24.060000 --> 0:16:28.820000
 If I've got a box that's got all the
 CPU power and all this RAM that I

0:16:28.820000 --> 0:16:33.000000
 spent a lot of money on, it makes more
 sense to have that thing running

0:16:33.000000 --> 0:16:35.260000
 close to peak capacity.

0:16:35.260000 --> 0:16:38.760000
 Now I don't want it running at 100% because
 then things are going to start

0:16:38.760000 --> 0:16:43.260000
 choking and dying, but maybe it's a
 good idea that on average, I have

0:16:43.260000 --> 0:16:47.860000
 the CPU and the memory sort of utilize
 it around 75 or 80% throughout

0:16:47.860000 --> 0:16:51.960000
 the time. Well, if I've got all these
 virtual machines running on it,

0:16:51.960000 --> 0:16:56.220000
 I can get much closer to that goal, whereas
 if I had individual standalone

0:16:56.220000 --> 0:16:59.540000
 servers, each one of those standalone
 servers might only be operating

0:16:59.540000 --> 0:17:05.060000
 at 15 or 20% of its
 average efficiency.

0:17:05.060000 --> 0:17:09.680000
 Elasticity. So this is basically a term
 that says, hey, we need to build

0:17:09.680000 --> 0:17:11.420000
 things out quickly.

0:17:11.420000 --> 0:17:12.940000
 So think about this for a second.

0:17:12.940000 --> 0:17:18.320000
 Imagine if, back in the old days, if a new
 department or an existing department,

0:17:18.320000 --> 0:17:22.260000
 if payroll came to you and said, hey,
 we need you to buy us a server because

0:17:22.260000 --> 0:17:25.440000
 we got this new app that we need to
 run and we need new server for it.

0:17:25.440000 --> 0:17:27.560000
 Well, that'd be very
 time consuming.

0:17:27.560000 --> 0:17:30.540000
 First of all, they'd have to submit
 to you a purchase request specifying

0:17:30.540000 --> 0:17:36.120000
 the make and model of the server, what
 type of CPUs, what type of memory,

0:17:36.120000 --> 0:17:41.120000
 all that stuff. Then you'd have
 to go find a buying agent.

0:17:41.120000 --> 0:17:45.180000
 You'd have to go buy it from someplace,
 look at different quotes and things.

0:17:45.180000 --> 0:17:49.340000
 Then you'd have to wait a week or six
 weeks or a month for the actual

0:17:49.340000 --> 0:17:51.040000
 hardware to come in.

0:17:51.040000 --> 0:17:54.080000
 Then there'd be some time, okay, where
 am I going to install this thing?

0:17:54.080000 --> 0:17:55.840000
 I got to cable it up,
 got to install.

0:17:55.840000 --> 0:18:00.160000
 So from the time the person actually
 said, hey, I need this software,

0:18:00.160000 --> 0:18:05.000000
 till the time when the software was
 actually available might be months.

0:18:05.000000 --> 0:18:08.500000
 But with virtualization, the person
 can come to you and they can say,

0:18:08.500000 --> 0:18:10.080000
 hey, I need this software.

0:18:10.080000 --> 0:18:10.720000
 Well, guess what?

0:18:10.720000 --> 0:18:15.040000
 I've got this host right here that's
 already got 15 VMs on it.

0:18:15.040000 --> 0:18:16.780000
 It's got plenty of capacity.

0:18:16.780000 --> 0:18:22.040000
 It's not anywhere near 80 or
 85% of its total CPU and RAM.

0:18:22.040000 --> 0:18:24.220000
 Let's just add another virtual
 machine to that.

0:18:24.220000 --> 0:18:27.600000
 You can have a new virtual machine
 running in a matter of minutes and

0:18:27.600000 --> 0:18:30.960000
 give them access to that software that
 would have taken them possibly

0:18:30.960000 --> 0:18:36.620000
 months if you had actually buy new
 hardware to support that software.

0:18:36.620000 --> 0:18:40.540000
 That's what we mean by elasticity is
 that new VMs can be built on the

0:18:40.540000 --> 0:18:44.420000
 fly. Sometimes they can be built dynamically
 with there's technologies

0:18:44.420000 --> 0:18:47.820000
 out there that can monitor a VM.

0:18:47.820000 --> 0:18:51.420000
 And if a VM, if a virtual machine, let's
 say you've got a window server

0:18:51.420000 --> 0:18:52.980000
 virtual machine.

0:18:52.980000 --> 0:18:55.900000
 And if it's monitoring that virtual
 machine, it says, okay, that virtual

0:18:55.900000 --> 0:19:00.140000
 machine is getting to about
 90% of its capacity.

0:19:00.140000 --> 0:19:04.940000
 The memory that we've assigned to that
 virtual machine, how much processing

0:19:04.940000 --> 0:19:09.420000
 power that individual virtual machine
 can consume, we're like 90%.

0:19:09.420000 --> 0:19:13.860000
 There's software out there that can
 dynamically see that and then spawn

0:19:13.860000 --> 0:19:18.220000
 another virtual machine
 to take up the slack.

0:19:18.220000 --> 0:19:22.640000
 And then if the demand goes down, it
 can shut off that virtual machine

0:19:22.640000 --> 0:19:24.980000
 so it's no longer using
 any resources.

0:19:24.980000 --> 0:19:30.480000
 So that's very much more elastic
 than physical machines.

0:19:30.480000 --> 0:19:32.740000
 And management centralization.

0:19:32.740000 --> 0:19:36.860000
 Now instead of having physical servers
 or whatever they are, firewalls,

0:19:36.860000 --> 0:19:40.120000
 routers spread all throughout the campus
 and throughout the building,

0:19:40.120000 --> 0:19:43.340000
 you can have them located in
 one central data center.

0:19:43.340000 --> 0:19:45.480000
 And it's a lot easier
 to monitor them.

0:19:45.480000 --> 0:19:49.200000
 You can go into this one physical host,
 this one physical server running

0:19:49.200000 --> 0:19:51.200000
 your hypervisor software.

0:19:51.200000 --> 0:19:54.800000
 And there's tools and management software
 that gives you real great visibility

0:19:54.800000 --> 0:20:00.760000
 into all the VMs that's inside
 that box and how they're doing.

0:20:00.760000 --> 0:20:02.840000
 And redundancy and backups.

0:20:02.840000 --> 0:20:08.000000
 You can have it set to where if one physical
 host fails, all the VMs that

0:20:08.000000 --> 0:20:12.820000
 were on that host automatically get replicated
 and start up on a redundant

0:20:12.820000 --> 0:20:16.140000
 host that's sitting there
 in a standby state.

0:20:16.140000 --> 0:20:22.200000
 Now the last thing I want to talk about
 in this video are three very common

0:20:22.200000 --> 0:20:28.040000
 terms that you'll see when it comes to
 virtualization and virtual machines.

0:20:28.040000 --> 0:20:30.620000
 One is called a snapshot.

0:20:30.620000 --> 0:20:32.620000
 So let me show you what
 this looks like.

0:20:32.620000 --> 0:20:37.760000
 So here I have a type
 of a hypervisor.

0:20:37.760000 --> 0:20:43.280000
 We'll talk about different types coming
 up called a type two hypervisor.

0:20:43.280000 --> 0:20:46.340000
 This is Oracle's virtual box.

0:20:46.340000 --> 0:20:49.260000
 So this is actually something that
 you can download for free.

0:20:49.260000 --> 0:20:52.520000
 It's supported in both
 Mac and Windows.

0:20:52.520000 --> 0:20:55.320000
 And with virtual box,
 this is software.

0:20:55.320000 --> 0:20:56.580000
 This is a hypervisor.

0:20:56.580000 --> 0:21:00.000000
 And so within it, you
 can build various VMs.

0:21:00.000000 --> 0:21:03.000000
 For example, you can see here I've
 got four virtual machines.

0:21:03.000000 --> 0:21:04.920000
 Right now all of them
 are turned off.

0:21:04.920000 --> 0:21:07.460000
 I've got a virtual machine that if
 I turn it on will give me a Windows

0:21:07.460000 --> 0:21:11.320000
 7 device as if I had
 a Windows 7 laptop.

0:21:11.320000 --> 0:21:15.620000
 I've got another one that if I turn
 it on will give me an Arista virtual

0:21:15.620000 --> 0:21:20.240000
 router. I've got another one that if
 I turn it on will give me a Windows

0:21:20.240000 --> 0:21:26.160000
 10 device and another one which will
 give me an Ubuntu desktop system.

0:21:26.160000 --> 0:21:28.560000
 Now look at the Ubuntu
 here for just a second.

0:21:28.560000 --> 0:21:30.920000
 And let's scroll in here
 for a little bit.

0:21:30.920000 --> 0:21:34.440000
 Notice it has these things
 called snapshots.

0:21:34.440000 --> 0:21:39.640000
 And pretty much every hypervisor that
 you can get gives you this ability

0:21:39.640000 --> 0:21:41.340000
 in one form or another.

0:21:41.340000 --> 0:21:49.440000
 What a snapshot is it's a picture of the
 saved state of this virtual machine

0:21:49.440000 --> 0:21:52.000000
 at a certain point in time.

0:21:52.000000 --> 0:21:55.520000
 For example, you can see
 this first snapshot here.

0:21:55.520000 --> 0:21:58.020000
 It doesn't really have any kind
 of creative name or anything.

0:21:58.020000 --> 0:21:59.760000
 It's called snapshot one.

0:21:59.760000 --> 0:22:04.760000
 This was taken at 4.37 pm and when the
 snapshot was taken, this virtual

0:22:04.760000 --> 0:22:06.840000
 machine was actually
 in the running state.

0:22:06.840000 --> 0:22:08.600000
 It was it was on.

0:22:08.600000 --> 0:22:13.900000
 So if I start up this virtual machine
 from this point in time from this

0:22:13.900000 --> 0:22:17.320000
 snapshot, the virtual
 machine will be on.

0:22:17.320000 --> 0:22:20.540000
 For example, I won't have to
 type in my login credentials.

0:22:20.540000 --> 0:22:23.000000
 It'll automatically dump
 me right in there.

0:22:23.000000 --> 0:22:28.520000
 It'll be on. Now if I go to the second
 snapshot, if I start with the machine

0:22:28.520000 --> 0:22:31.520000
 in this state, the machine
 will be off.

0:22:31.520000 --> 0:22:34.260000
 And it'll actually go through the power
 cycle process and I'll have to

0:22:34.260000 --> 0:22:38.060000
 log in with my username and
 password credentials.

0:22:38.060000 --> 0:22:44.040000
 So snapshots are a very powerful
 tool for virtual machines.

0:22:44.040000 --> 0:22:48.500000
 Have you ever had a situation where
 you were working on your PC or your

0:22:48.500000 --> 0:22:49.320000
 laptop or whatever?

0:22:49.320000 --> 0:22:53.640000
 Your smartphone, your tablet and all
 of a sudden you it started acting

0:22:53.640000 --> 0:22:55.760000
 weird, started acting buggy.

0:22:55.760000 --> 0:22:57.000000
 And you thought, you know what?

0:22:57.000000 --> 0:22:59.860000
 I'll bet you it's because I
 just loaded that software.

0:22:59.860000 --> 0:23:03.940000
 I just loaded this app or I just
 loaded this whatever it is.

0:23:03.940000 --> 0:23:06.940000
 And now my thing is acting
 all screwy and messed up.

0:23:06.940000 --> 0:23:11.720000
 Man, I wish I could just go back in
 time and revert my device to what

0:23:11.720000 --> 0:23:14.520000
 was like before I did that.

0:23:14.520000 --> 0:23:16.720000
 That's exactly what a snapshot is.


0:23:16.720000 --> 0:23:20.780000
 So typically when a device is operating
 in a way that you want, you would

0:23:20.780000 --> 0:23:22.580000
 create a snapshot of it.

0:23:22.580000 --> 0:23:27.160000
 And now as you start changing that device
 by adding apps or changing settings

0:23:27.160000 --> 0:23:33.180000
 or whatever, if that produces some undesired
 results, you can just revert

0:23:33.180000 --> 0:23:34.800000
 back to your previous snapshot.

0:23:34.800000 --> 0:23:37.820000
 You can tell that VM, hey,
 I'm going to turn you off.

0:23:37.820000 --> 0:23:41.340000
 And the next time I turn you on virtual
 machine, I want you to start from

0:23:41.340000 --> 0:23:44.780000
 this point in time when
 I took this snapshot.

0:23:44.780000 --> 0:23:46.600000
 That's one example.

0:23:46.600000 --> 0:23:48.000000
 Of a use of snapshots.

0:23:48.000000 --> 0:23:52.200000
 Now, if you're a networking engineer,
 maybe you're creating a virtual

0:23:52.200000 --> 0:23:55.060000
 machine of a router as an example.


0:23:55.060000 --> 0:23:58.660000
 So normally we think of routers as being
 physical things that we can hold

0:23:58.660000 --> 0:24:00.520000
 in our hands and we
 have to rack mount.

0:24:00.520000 --> 0:24:06.080000
 But if I have a server, this got 30
 different VMs in it, okay, owned by

0:24:06.080000 --> 0:24:06.840000
 different departments.

0:24:06.840000 --> 0:24:09.640000
 Maybe I got some VMs which
 are the payroll VMs.

0:24:09.640000 --> 0:24:13.680000
 These are like Linux servers
 running payroll applications.

0:24:13.680000 --> 0:24:18.020000
 I got 10 more VMs which are owned by
 engineering running various things,

0:24:18.020000 --> 0:24:20.920000
 okay? But they're all in
 this one physical box.

0:24:20.920000 --> 0:24:25.400000
 Well, you might want to install another
 VM in there, which is a virtual

0:24:25.400000 --> 0:24:29.360000
 router. And then all these other VMs
 are tied into the virtual routers.

0:24:29.360000 --> 0:24:33.740000
 Like you've got a little mini network
 logically built inside your server

0:24:33.740000 --> 0:24:37.320000
 itself. And so you can have a virtual machine
 as a router, which is connecting

0:24:37.320000 --> 0:24:38.960000
 all these other VMs.

0:24:38.960000 --> 0:24:42.500000
 And in the router, you can configure
 it for access lists and IP subnets

0:24:42.500000 --> 0:24:43.680000
 and all this stuff.

0:24:43.680000 --> 0:24:45.620000
 Well, you might say,
 hey, you know what?

0:24:45.620000 --> 0:24:48.160000
 I want to have some snapshots
 of my router.

0:24:48.160000 --> 0:24:51.780000
 I want to have a snapshot of my router
 back when it was in its default

0:24:51.780000 --> 0:24:54.640000
 state. When I had no IP
 addresses, nothing.

0:24:54.640000 --> 0:24:56.380000
 I'll have that as a snapshot.

0:24:56.380000 --> 0:25:00.820000
 Now that I put my IP addresses on there
 and some basic routing information,

0:25:00.820000 --> 0:25:04.680000
 maybe snapshot that so I can revert
 back to that state at any point in

0:25:04.680000 --> 0:25:10.160000
 time. Now as I start adding my access
 list and my firewall rules, snapshot

0:25:10.160000 --> 0:25:14.840000
 it there. So with these various snapshots,
 you can revert back your virtual

0:25:14.840000 --> 0:25:18.280000
 router to any point in
 time that you want to.

0:25:18.280000 --> 0:25:24.100000
 So snapshots are a very powerful tool
 of virtual machine technology.

0:25:24.100000 --> 0:25:28.180000
 Another term that you'll see is
 something called a cluster.

0:25:28.180000 --> 0:25:34.260000
 So if I have one physical host and
 all my virtual machines are loaded

0:25:34.260000 --> 0:25:38.780000
 onto that one physical host, I'm going
 to be in a world of pain if that

0:25:38.780000 --> 0:25:41.320000
 physical host crashes and dies.

0:25:41.320000 --> 0:25:44.740000
 Because then all those virtual machines
 will go up in a puff of smoke

0:25:44.740000 --> 0:25:46.820000
 along with that host.

0:25:46.820000 --> 0:25:51.460000
 So for redundancy sake, you might want
 to have two or three or four hosts

0:25:51.460000 --> 0:25:54.460000
 all grouped together in a cluster.


0:25:54.460000 --> 0:25:57.680000
 So basically a cluster is just a group
 of hosts are providing redundancy

0:25:57.680000 --> 0:25:59.820000
 and backup for each other.

0:25:59.820000 --> 0:26:03.700000
 And so you can have some dynamic ways
 where maybe this particular physical

0:26:03.700000 --> 0:26:08.300000
 server right here, this host is currently
 running the active VMs.

0:26:08.300000 --> 0:26:12.000000
 But if something happens on that host
 and that host dies, another host

0:26:12.000000 --> 0:26:17.620000
 will detect it. And another host will
 spin up the exact same set of VMs.

0:26:17.620000 --> 0:26:21.420000
 So hopefully it'll be completely transparent
 to the end users out there

0:26:21.420000 --> 0:26:26.060000
 that the VMs have actually migrated from
 one physical host over to another

0:26:26.060000 --> 0:26:29.480000
 physical host. So a cluster
 is exactly that.

0:26:29.480000 --> 0:26:34.720000
 It's a grouping of hosts that are all
 providing redundancy for each other.

0:26:34.720000 --> 0:26:37.080000
 And the last term I want to talk about
 is something you'll hear of called

0:26:37.080000 --> 0:26:38.960000
 a virtual appliance.

0:26:38.960000 --> 0:26:45.300000
 So in the world of networking, if you
 buy an appliance, for example, if

0:26:45.300000 --> 0:26:49.500000
 you buy a firewall appliance,
 what are you actually getting?

0:26:49.500000 --> 0:26:53.120000
 Well, you're getting a box and when
 you open up the box, there's a piece

0:26:53.120000 --> 0:26:58.100000
 of hardware in there, you can take
 out and you rack mount it.

0:26:58.100000 --> 0:27:02.540000
 And that hardware has an operating
 system in it that's optimized to be

0:27:02.540000 --> 0:27:05.060000
 a firewall. It's optimized
 to do a certain thing.

0:27:05.060000 --> 0:27:10.100000
 So an appliance, a physical appliance,
 is a physical box that is designed

0:27:10.100000 --> 0:27:12.620000
 to do a very specialized task.

0:27:12.620000 --> 0:27:13.780000
 Well, guess what?

0:27:13.780000 --> 0:27:15.760000
 We can virtualize that stuff.

0:27:15.760000 --> 0:27:19.980000
 Like when I talked about a virtual router,
 you can have an appliance that's

0:27:19.980000 --> 0:27:21.040000
 a virtual router.

0:27:21.040000 --> 0:27:24.880000
 So if someone says, hey, I've got
 a VM virtual router appliance.

0:27:24.880000 --> 0:27:29.100000
 Basically what that is, is that's a VM
 that's designed to do a very special

0:27:29.100000 --> 0:27:34.120000
 task, like routing or another virtual
 machine that's designed to be a

0:27:34.120000 --> 0:27:38.360000
 special task, a firewall, or an intrusion
 detection system, or even a

0:27:38.360000 --> 0:27:42.860000
 virtual switch. So these are what we
 call virtual appliances as opposed

0:27:42.860000 --> 0:27:46.460000
 to a physical hardware appliance.

0:27:46.460000 --> 0:27:50.560000
 So that's all I have for this section on
 an introduction of virtual machines.

0:27:50.560000 --> 0:27:51.720000
 I hope you liked it.

0:27:51.720000 --> 0:27:52.520000
 I hope you learned a lot.

