Start with 7 free days of training.

Gain instant access to our entire IT training library, free for your first week.
Train anytime on your desktop, tablet, or mobile devices.

The exam associated with this course was retired December 31, 2016. However, this course still retains value as a training resource....
The exam associated with this course was retired December 31, 2016. However, this course still retains value as a training resource.

Let Google know what you think of our training course with this survey.

This Google Compute Engine course with Garth Schulte covers the exam objectives for the Google Qualified Compute Engine Developer certification, and gets you up to speed on the Google Cloud Platform's Infrastructure-as-a-Service product. CBT Nuggets is a Google Cloud Platform - Training Partner.

Recommended skills:
  • Basic understanding of the cloud and IaaS concepts

Recommended equipment:
  • A machine running Windows, OSX, or Linux

Related certifications:
  • Google Qualified Compute Engine Developer

Related job functions:
  • Development
  • Administration
  • SysOps
  • DevOps
  • Cloud computing
  • Infrastructure-as-as-Service (IaaS)
  • World domination!

Wouldn't it be great if you could host your infrastructure on Google's global network? Well, now you can! Google Compute Engine enables anyone to create a network of virtual machines in the Google Cloud Platform to handle any kind of workload at an extremely low cost, all hosted and managed by Google. GCE's modular and flexible design makes it easy to develop a full blown IaaS solution, without the burden of managing that infrastructure.

This course is for Google Compute Engine and is designed from Google's internal instructor-led course to prepare you for the exam. It's ideal for beginner or advanced administrators, or developers looking to add cloud-based skills and Google-certified credentials to their resume. Google Qualified Developer is a new breed of developer-centric certifications for Google Cloud Platform products.
 show less
1. Introduction to Google Compute Engine (10 min)
2. Getting Started with GCE (11 min)
3. Demo: Getting Started with GCE (14 min)
4. Instances (14 min)
5. Demo: Instances (15 min)
6. Persistent Disks (16 min)
7. Demo: Persistent Disks (13 min)
8. Images and Snapshots (13 min)
9. Demo: Images (16 min)
10. Demo: Snapshots (12 min)
11. Startup Scripts and Metadata (14 min)
12. Demo: Startup Scripts and Metadata (16 min)
13. Networking (19 min)
14. Demo: Networking (11 min)
15. Advanced Networking (13 min)
16. Demo: Advanced Networking - Configuring a NAT Gateway (13 min)
17. Demo: Advanced Networking - Configuring Protocol Forwarding (11 min)
18. Load Balancing (15 min)
19. Demo: Load Balancing - Network Load Balancing (12 min)
20. Demo: Load Balancing - HTTP Load Balancing (17 min)
21. Monitoring (14 min)
22. Automation (9 min)
23. Programmatic GCE (16 min)
24. Demo: Programmatic GCE (20 min)
25. Upcoming GCE Features (14 min)
26. Google Cloud Platform Qualified Developer (9 min)

Introduction to Google Compute Engine


Introduction to Google Compute Engine. Welcome to Compute Engine my friends. Garth Schulte here from CBT Nuggets. In this Nugget, we're going to define what Compute Engine is all about. So we'll see what this infrastructure as a service offering entails inside of the Google Cloud Platform.


So we'll get familiar with the features and the benefits. We'll talk about the resources, which are really the building blocks that we can use to build our own infrastructure in Google's cloud. And then, we'll just talk about some of the cool things that we can do with it.


And I'll give you an example of how all these resources can come together to provide an infrastructure solution in Google's Cloud. Let's begin. Let's define Google Compute Engine. It is Google's infrastructure as a service offering in the Google Cloud Platform that allows us to create networks of virtual machines that run in Google's infrastructure, and are fully managed by Google.


Let's talk about some of the features that we get inside a Compute Engine, as well as some of those inherent features from running on the same infrastructure that powers all of Google's products. We get high performance virtual machines, and not only high performance, but consistently performing virtual machines.


And that's a big one. Something that other clouds have a tough time offering is consistent, predictable performance. And we'll talk about what that entails here in the future. Also, Google's Global Network, and this is a big one, again, because you're running on the same infrastructure that Google uses to power its products.


But on top of that, it's Google's private network that spans the entire globe, where other clouds, generally when you have communication across regions, it uses the public Internet for communication. Not Google's Cloud. It uses its own internal infrastructure.


So right away you get all the benefits that go along with that, performance, security, reliability, scalability-- all that stuff that's built into Google's internal infrastructure. Spinning up a virtual machine, or even a network or virtual machines, in Google's Cloud is extremely fast.


We're talking seconds, not minutes. And it's super easy, like to the point where you feel like there should be more to it. In fact, let me just give you a quick 20-second demo. So I'm in Google's Cloud here, in Compute Engine. I'm going to create an instance.


I'm going to leave all the defaults here. I'll change the zone to say U.S. Central, a little closer to myself. And then we'll hit create. Watch how fast this is. It's literally going to spin it up in under '20 seconds. Give it an external IP, and boom we could SSH into it, start installing software, and bang we've got a virtual machine in Google's Cloud.


And there it is. Look how fast that was. So here it is. Here's our instance in the zone with a disk attached to it, a boot disk-- associated with the default network, with an external IP that we could then hit to log into it and do anything we want on that virtual machine.


Pretty crazy, huh, how fast that was? So yeah, fast and easy is almost an understatement here in Compute Engine. Compute Engine comes equipped with some pretty impressive load balancing technology that is also very easy configure and use within your own private cloud networks.


So we can distribute traffic across pools of virtual machines. That's really the basis of load balancing, but Google's load balancer goes well above and beyond that. And we're really going to dig into it in our load balancing Nuggets. But just to break it down, we've got cross-region load balancing, which allows us to serve our content from our machines that are closest to our users.


Pretty crazy. And on top of that, we've got content-based load balancing. So now we can take certain types of traffic and have it handled by pools of virtual machines that are optimized for that traffic. Awesome, awesome stuff. And on top that, it's your own private, massively scalable load balancer that doesn't need any prewarming and can easily handle millions of requests per second.


Moving on Compute Engine and Google's infrastructure is extremely compliant and secure. They've completed and went well above and beyond most of the industry standard certifications out there. Plus, all of your data is encrypted in flight, as well as at rest, in Google's infrastructure.


Last, but certainly not least here, you're only going to pay for what you use. And while that's true of most clouds, most clouds bill by the hour. Google bills by the minute, with a 10-minute minimum, so that means if you need to spin up a network of machines to process a workload, if it takes 20 minutes, in Google's Cloud you're only paying for 20 minutes.


In other clouds, you would be paying for the full hour. Plus, Google has introduced sustained usage discount. So the more you use it, the less you pay. Let's dig a little deeper into Compute Engine. Whenever I talk about Compute Engine, I like to call it infrastructure as a service Legos.


We have all these resources in Compute Engine-- things like an instance, a virtual machine, a disk, a network, an IP address. And really, they're all Legos that you can bring together. It's a very modular system. And at a higher level, whenever I talk about the Google Cloud Platform, I like to call it cloud Legos because Google built a very modular system where all these products can be used alone, or you can mix and match them with other Google Cloud products to build a solution for your enterprise.


Down in Compute Engine, we call those building blocks resources. So we can build all these out individually. Then we can glue them all together to come up with our cloud infrastructure. So we have things like Instances. Instances are the virtual machines.


We have a Machine Type. Machine type is what we're going to use to determine the physical specification of our machine. And that may be different, again, depending on the kind of workload that's running on that machine. We may need more memory in one machine, more CPU in another machine, or we may need a good mix of both.


We've got disks, persistent disks, and we're going to use Disk to create a boot disk which is going to obtain an image, the operating system that we're going to use to run on virtual machines. We can also attach other disks, just data disks, to our virtual machines.


We got Networks, which is what we're going to use to tie our virtual machines together. We have Routes, which will determine inside of a network how traffic flows. We've got Firewall rules, which is going to determine the kind of traffic that we're going to let on to our instances.


We've got IP addresses, both internal and external, that we use to identify or machine both privately and publicly. Images contain the operating system that is going to power our virtual machine. And we've got lots of images to choose from, both Linux and Windows based.


We'll set up a boot disk, a persistent disk with a root file system that contains the image that we'll attach to our virtual machines. And we've got Snapshot resources, which allow us to preserve the state of a persistent disk. So those are your building blocks in a nutshell here in Compute Engine.


And we'll be digging deep into each one of these throughout our Compute Engine Nuggets. So with Compute Engine, it's your infrastructure, your way on Google's highway. Construct your network any way you want in Google's Cloud. You have your own private cloud network that you can then use to hook up to other cloud networks, or on premise networks, to enable the ultimate hybrid cloud solution.


Now, here's an example of one of the many networks we'll be building throughout the Compute Engine Nuggets that shows how these building blocks come together to form an infrastructure. So here we've got a network. Inside of our network, we've got four instances.


And here we've got a web server, a database server, and just kind of a placeholder instance that could be anything. Could be more web servers, more database servers, could be front end servers-- you name it. And we've also got a gateway machine out here that has two IP addresses on it.


So we've got an internal IP address so it can communicate with these internal virtual machines, and we've got an external IP address to communicate outside of our network. We've got a routes collection that determines how traffic flows internally and externally.


We could also set up our own routes to say, for instance, these internal VMs we could leave internal, meaning they-- nothing from the outside could see them. They couldn't hit the outside without going through our gateway. So we could set up a custom route that has it hop through to the gateway to get to the Internet.


We've got firewall rules that determine the kind of traffic we're going to allow onto our instances. Each instance has their own local disk for local storage. This is also the boot disk that contains the root file system. And something really neat that we can do Compute Engine is set up a read-only disk and attach it to multiple instances.


And finally, we've got the machine type. So the machine type is going to determine the physical specifications of our machine. And they can differ depending on the type of workload on that machine. So our web server, we may go for high CPU to handle all those incoming requests.


Our database server, we would probably go for high memory. And then, maybe we have a front-end server that's a good balance of both. So you can see it's a simple network, but it utilizes many of those building blocks that we're going to be working with throughout the Compute Engine Nuggets to build out an infrastructure.


So why use Google Compute Engine? Just to give you a couple reasons here, no upfront cost. Anybody can get into Google's Cloud right now and start building. It's very easy to do. Predictable pricing. We've got pricing calculators all over the place across Google's Cloud for every product, so you can easily predict what your infrastructure is going to cost you based on how many virtual machines you have, what kind of machine types are associated with those virtual machines, and all kinds of other metrics that you can choose.


We get automatic scalability. And this is already included in the App Engine, which is Google's platform as a service offering. Which means developers can write apps that scale based on traffic automatically, don't have to do anything. It's literally hands off scalability.


Compute Engine has a new feature called the Auto-scaler, which is virtually the same thing. So we can create this user-defined elastic infrastructure, which is very cool. Live Migration is a great feature that allows our virtual machines to migrate around maintenance events.


So if a data center were going to go under maintenance, normally in the past, what would happen is you would get an email from your cloud provider. And then, you would be responsible for migrating your instances around. Well Google has this live migration feature.


It's literally just a check box anytime we create an instance that will automatically migrate our instance around maintenance events. Really neat feature, and we'll certainly get into it. Flexible Design. This just goes along with those infrastructure as a service Legos.


Everything is its own entity, and we can attach them all together to build our solution. And also, not to mention the networks in the virtual machines themselves are flexible, because we can create VMs of any shape or size, and networks of any shape or size.


We've got many ways to play in Google's Cloud, meaning we've got tools for everyone. We've got a nice, easy to use web interface. We've got a command line interface, and we've got a restful API. And of course, one of the biggest benefits you see out there with the cloud revolution that's upon us is we focus on building.


They focus on managing. No worrying about hardware, and many times software either. Google takes care of all that. We just come up with designing and implementing our solutions. Finally, it is Google after all. This is the company that pioneered the Internet as we know it today.


They know infrastructure, big data, distributed systems, and they have storm troopers guarding their data centers. So we're in good hands. These guys breed innovation and break down barriers. New products and features are constantly getting pumped into their cloud platform and Compute Engine.


We have managed VMs, for instance, which is blending the platform as a service and infrastructure as a service arena to give us the best of both worlds. They also just recently announced Google container engine, which is a simple way to deploy and manage containerized docker apps, powered and fully managed by virtual machine clusters.


And the interesting part of all this? It's only the beginning. The cloud revolution has just begun. In this CBT Nugget, we took an introduction to Google Compute Engine. We saw what the infrastructure as a service offering in Google's Cloud is all about, the features the benefits.


We saw that everything's a resource, just building blocks that we can use to build our own private cloud infrastructure. And we took an example of what a network might look like constructed out of those building blocks. And finally, we answer that big question, why Google Compute Engine?


I hope this has been informative for you. And I'd like to thank you for viewing.

Getting Started with GCE

Demo: Getting Started with GCE


Demo: Instances

Persistent Disks

Demo: Persistent Disks

Images and Snapshots

Demo: Images

Demo: Snapshots

Startup Scripts and Metadata

Demo: Startup Scripts and Metadata


Demo: Networking

Advanced Networking

Demo: Advanced Networking - Configuring a NAT Gateway

Demo: Advanced Networking - Configuring Protocol Forwarding

Load Balancing

Demo: Load Balancing - Network Load Balancing

Demo: Load Balancing - HTTP Load Balancing



Programmatic GCE

Demo: Programmatic GCE

Upcoming GCE Features

Google Cloud Platform Qualified Developer

Please help us improve by sharing your feedback on training courses and videos. For customer service questions, please contact our support team. The views expressed in comments reflect those of the author and not of CBT Nuggets. We reserve the right to remove comments that do not adhere to our community standards.

comments powered by Disqus
Intermediate 6 hrs 26 videos


Training Features

Practice Exams
These practice tests help you review your knowledge and prepare you for exams.

Virtual Lab
Use a virtual environment to reinforce what you are learning and get hands-on experience.

Offline Training
Our iOS and Android mobile apps offer the ability to download videos and train anytime, anywhere offline.

Accountability Coaching
Develop and maintain a study plan with one-to-one assistance from coaches.

Supplemental Files
Files/materials that supplement the video training.

Speed Control
Play videos at a faster or slower pace.

Included in this course
Pick up where you left off watching a video.

Included in this course
Jot down information to refer back to at a later time.

Closed Captions
Follow what the trainers are saying with ease.
Garth Schulte
Nugget trainer since 2002