Google Compute Engine

1. Introduction

Hello everyone, thanks for coming today! Ready to learn Google Compute Engine?

In this codelab, we will explore Compute Engine working through an example Guestbook application.

You'll create Compute Engine instances, deploy nginx, and finally put a network load balancer in the front. You can create a Compute Engine instance from either the graphical console or from the command line. This lab will walk you through using the command-line.

Google Compute Engine offers virtual machines running in Google's data centers connected to its worldwide fiber network. The tooling and workflow offered enables scaling from single instances to global, load-balanced cloud computing.

These VMs boot quickly, come with persistent disk storage, and deliver consistent performance. The machines are available in many configurations including predefined sizes and can also be created with Custom Machine Types optimized for your specific needs.

Finally, Compute Engine virtual machines are also the technology used by several other Google Cloud products (Kubernetes Engine, Cloud Dataproc, Cloud Dataflow, etc...).

2. Setup and Requirements

Self-paced environment setup

1. Sign-in to the Google Cloud Console and create a new project or reuse an existing one. If you don't already have a Gmail or Google Workspace account, you must create one.

• The Project name is the display name for this project's participants. It is a character string not used by Google APIs, and you can update it at any time.
• The Project ID must be unique across all Google Cloud projects and is immutable (cannot be changed after it has been set). The Cloud Console auto-generates a unique string; usually you don't care what it is. In most codelabs, you'll need to reference the Project ID (and it is typically identified as PROJECT_ID), so if you don't like it, generate another random one, or, you can try your own and see if it's available. Then it's "frozen" after the project is created.
• There is a third value, a Project Number which some APIs use. Learn more about all three of these values in the documentation.

Caution: A project ID must be globally unique and cannot be used by anyone else after you've selected it. You are the only user of that ID. If a project is deleted, that ID can never be used again.

Note: If you're using a Gmail account, you can leave the default location set to No organization. If you're using a Google Workspace account, then choose a location that makes sense for your organization.

2. Next, you'll need to enable billing in the Cloud Console in order to use Cloud resources/APIs. Running through this codelab shouldn't cost much, if anything at all. To shut down resources so you don't incur billing beyond this tutorial, follow any "clean-up" instructions found at the end of the codelab. New users of Google Cloud are eligible for the $300 USD Free Trial program.

Google Cloud Shell

While Google Cloud and Compute Engine can be operated remotely from your laptop, in this codelab we will be using Google Cloud Shell, a command line environment running in the Cloud.

This Debian-based virtual machine is loaded with all the development tools you'll need. It offers a persistent 5GB home directory and runs in Google Cloud, greatly enhancing network performance and authentication. This means that all you will need for this codelab is a browser (yes, it works on a Chromebook).

1. To activate Cloud Shell from the Cloud Console, simply click Activate Cloud Shell (it should only take a few moments to provision and connect to the environment).

Once connected to Cloud Shell, you should see that you are already authenticated and that the project is already set to your PROJECT_ID.

gcloud auth list

Command output

Credentialed accounts:
 - <myaccount>@<mydomain>.com (active)

Note: The gcloud command-line tool comes preinstalled in Cloud Shell and you'll surely enjoy its support for tab completion. For more information, see gcloud command-line tool overview.

gcloud config list project

Command output

[core]
project = <PROJECT_ID>

If, for some reason, the project is not set, simply issue the following command:

gcloud config set project <PROJECT_ID>

Looking for your PROJECT_ID? Check out what ID you used in the setup steps or look it up in the Cloud Console dashboard:

Cloud Shell also sets some environment variables by default, which may be useful as you run future commands.

echo $GOOGLE_CLOUD_PROJECT

Command output

<PROJECT_ID>

2. Finally, set the default zone and project configuration.

gcloud config set compute/zone us-central1-f

You can choose a variety of different zones. For more information, see Regions & Zones.

Note: When you run gcloud on your own machine, the config settings would've been persisted across sessions. But in Cloud Shell, you will need to set this for every new session or reconnection.

3. Create a Compute Engine instance

As discussed previously we will use the gcloud command- line in this codelab. Everything done here can be achieved using the console (available at console.cloud.google.com).

Let's first create an instance with default settings :

$ gcloud compute instances create myinstance
Created [...].
NAME: myinstance
ZONE: us-central1-f
MACHINE_TYPE: n1-standard-1
PREEMPTIBLE:
INTERNAL_IP: 10.128.X.X
EXTERNAL_IP: X.X.X.X
STATUS: RUNNING

Note down the EXTERNAL_IP - that's important later on.

Note: if you've omitted to specify a default zone in the setup steps, the command will respond suggesting a zone for you.

The instance is created using a number of defaults :

• The zone that you choose. All instances live in a zone. You can select a zone at instance creation time by using the --zone flag or you can set a default zone (as we did in the initial setup) and omit the --zone flag.
• The latest Debian GNU/Linux 9 (stretch) image. If you are using your own custom image, provide the image name here instead. For example, --image my-own-image.
• The n1-standard-1 machine type. You can select another machine type such as n1-highmem-4 or n1-highcpu-6. If none of the predefined machine types match your needs, use a custom machine type.
• A root persistent disk with the same name as the instance; the disk is automatically attached to the instance.

Run gcloud compute instances create --help to see all the options that are available.

Note: you can also create a new VM from an existing template.

4. Enable Firewall for Port 80

By default, Google Cloud Platform only allows few port accesses. Since we'll be installing Nginx soon - let's enable port 80 in the firewall configuration first.

$ gcloud compute firewall-rules create allow-80 --allow tcp:80
Created [...].
NAME: allow-80
NETWORK: default
DIRECTION: INGRESS
PRIORITY: 1000
ALLOW: tcp:80
DENY:
DISABLED: False

This will create a firewall rule named allow-80 that has a default list of IP address blocks that are allowed to make inbound connections (--source-ranges) are set to 0.0.0.0/0 (Everywhere).

Run gcloud compute firewall-rules create --help to see all the defaults and all the options available, including the ability to apply a firewall rules based on tags.

5. SSH Into the Instance

To SSH into the instance from the command line (still from Cloud Shell) :

$ gcloud compute ssh myinstance
Waiting for SSH key to propagate.
Warning: Permanently added 'compute.12345' (ECDSA) to the list of known hosts.
...

yourusername@myinstance:~#

That's it! pretty easy. (In production, make sure you enter a passphrase :)

Alternatively, you can also SSH into the instance directly from the console ( console.cloud.google.com), by navigating to Compute Engine > VM Instances, and clicking on SSH.

Note: you can also SSH into this VM using third-party tools as described here: https://cloud.google.com/compute/docs/instances/connecting-advanced#thirdpartytools

6. Install Nginx

Log into myinstance, the newly created instance, and install nginx:

$ sudo su - 
# apt update
# apt install -y nginx
# service nginx start
# exit

Test that the server is running using curl from myinstance:

$ curl -s localhost | grep nginx
<title>Welcome to nginx!</title>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
<a href="http://nginx.org/">nginx.org</a>.<br/>
<a href="http://nginx.com/">nginx.com</a>.</p>
<p><em>Thank you for using nginx.</em></p>

Find the external IP for your instance by listing your instances either via the web UI:

Make sure you exit from SSH, and run this command from Cloud Shell:

$ gcloud compute instances list
NAME: myinstance
ZONE: us-central1-f
MACHINE_TYPE: n1-standard-1
PREEMPTIBLE:
INTERNAL_IP: 10.128.X.X
EXTERNAL_IP: X.X.X.X
STATUS: RUNNING

Then navigate to http://EXTERNAL_IP/ where EXTERNAL_IP is the public IP of myinstance and you should be able to see the nginx page:

7. Startup Script

Rather than setting up the instance every time, you can use a startup script to initialize the instance upon startup.

Create a file named startup.sh with the following content (you can use your favorite text editor: vim, nano, or emacs):

#! /bin/bash
apt-get update
apt-get install -y nginx
service nginx start
sed -i -- 's/nginx/Google Cloud Platform - '"$HOSTNAME"'/' /var/www/html/index.nginx-debian.html

To create a new VM instance with this startup script simply type :

$ gcloud compute instances create nginx \
         --metadata-from-file startup-script=startup.sh 
Created [...].
NAME: nginx
ZONE: us-central1-f
MACHINE_TYPE: n1-standard-1
PREEMPTIBLE:
INTERNAL_IP: 10.128.X.X
EXTERNAL_IP: X.X.X.X
STATUS: RUNNING

Browse to http://EXTERNAL_IP/ and you should see the updated home page. If the page doesn't show immediately retry after a couple of seconds, the host might be still starting nginx.

8. Create a Cluster of Servers

To create a cluster of servers, you first need to create an Instance Template. Once an instance template is created, you can then create an instance group to manage the number of instances to create.

First, create an instance template using the startup script :

$ gcloud compute instance-templates create nginx-template \
         --metadata-from-file startup-script=startup.sh
Created [...].
NAME: nginx-template
MACHINE_TYPE: n1-standard-1
PREEMPTIBLE:
CREATION_TIMESTAMP: 2022-03-18T15:10:37.621-07:00

Note: this command uses many of the defaults that we described during a single instance creation.

Second, let's create a target pool. A target pool allows us to have a single access point to all the instances in a group and is necessary for load balancing in the future steps.

$ gcloud compute target-pools create nginx-pool
Created [...].
NAME: nginx-pool
REGION: us-central1
SESSION_AFFINITY: NONE
BACKUP:
HEALTH_CHECKS:

Finally, create an instance group using the template:

$ gcloud compute instance-groups managed create nginx-group \
         --base-instance-name nginx \
         --size 2 \
         --template nginx-template \
         --target-pool nginx-pool
Created [...].
NAME: nginx-group
LOCATION: us-central1-f
SCOPE: zone
BASE_INSTANCE_NAME: nginx
SIZE: 0
TARGET_SIZE: 2
INSTANCE_TEMPLATE: nginx-template
AUTOSCALED: no

This will create two additional VM instances with names that are prefixed with nginx-.

You should now be able to see all of the instances created!

$ gcloud compute instances list
NAME: myinstance
ZONE: us-central1-f
MACHINE_TYPE: n1-standard-1
PREEMPTIBLE:
INTERNAL_IP: 10.128.X.X
EXTERNAL_IP: X.X.X.X
STATUS: RUNNING

NAME: nginx
ZONE: us-central1-f
MACHINE_TYPE: n1-standard-1
PREEMPTIBLE:
INTERNAL_IP: 10.128.X.X
EXTERNAL_IP: X.X.X.X
STATUS: RUNNING

NAME: nginx-frpl
ZONE: us-central1-f
MACHINE_TYPE: n1-standard-1
PREEMPTIBLE:
INTERNAL_IP: 10.128.X.X
EXTERNAL_IP: X.X.X.X
STATUS: RUNNING

NAME: nginx-ztg4
ZONE: us-central1-f
MACHINE_TYPE: n1-standard-1
PREEMPTIBLE:
INTERNAL_IP: 10.128.X.X
EXTERNAL_IP: X.X.X.X
STATUS: RUNNING

9. Create a Network Load Balancer

There are several types of load balancers in Google Cloud Platform including :

• a L3 Network Load Balancer
• a L7 HTTP(S) Load Balancer

Let's create a regional network load balancer targeting our instance group:

$ gcloud compute forwarding-rules create nginx-lb \
         --ports 80 \
         --target-pool nginx-pool
Created [...].

$ gcloud compute forwarding-rules list
NAME: nginx-lb
REGION: us-central1
IP_ADDRESS: X.X.X.X
IP_PROTOCOL: TCP
TARGET: us-central1/targetPools/nginx-pool

You can then visit the load balancer from the browser http://IP_ADDRESS/ where IP_ADDRESS is the address shown as the result of running the previous command.

Since all our instances are located in the same zone, we decided to use a regional load-balancer. Google Cloud also offers a global option discussed here: https://cloud.google.com/load-balancing/docs/load-balancing-overview

Due to the time, we will not be creating a HTTP load balancer today.

Optional: Run your favorite application server

If there is free time, you can run your favorite application servers on Google Compute Engine, such as Wildfly, Tomcat, Jetty, etc. Try using any free time to start one before we continue!

10. Clean up the Cluster

Don't forget to shut down your cluster, otherwise they'll keep running and accruing costs. The following commands will delete the Google Compute Engine instances, Instance Group, Targeting Group, and the Load Balancer.

$ gcloud compute forwarding-rules delete nginx-lb

$ gcloud compute instance-groups managed delete nginx-group

$ gcloud compute target-pools delete nginx-pool

$ gcloud compute instance-templates delete nginx-template

$ gcloud compute instances delete nginx

$ gcloud compute instances delete myinstance

$ gcloud compute firewall-rules delete allow-80

Each of the commands above should ask you to confirm the deletion of the resource.

11. What's next?

Congratulations, you've completed this Compute Engine codelab!

More Compute Engine features

Google Compute Engine has a rich set of features. You may want to dive into some of these :

• Preemptible VMs - https://cloud.google.com/compute/docs/instances/create-start-preemptible-instance
• Sole-tenant nodes - https://cloud.google.com/compute/docs/nodes/create-nodes
• GPUs & TPUs - https://cloud.google.com/compute/docs/gpus/add-gpus
• Windows instances - https://cloud.google.com/compute/docs/instances/windows/creating-managing-windows-instances
• Labeling Resources - https://cloud.google.com/compute/docs/labeling-resources
• Migrating VMs to Compute Engine - https://cloud.google.com/compute/docs/vm-migration/

Google Kubernetes Engine

Google Kubernetes Engine (GKE) is Google Cloud's hosted and fully-managed Kubernetes offering. There are several codelabs available to help you start with GKE. Here's a good one to start with :

• Google Kubernetes Engine codelab - https://codelabs.developers.google.com/codelabs/cloud-gke-workshop-v2

Give us your feedback

• Please take a moment to complete our very short survey