Google Container Engine makes it easy to run docker containers in the cloud. Google Container Engine uses Kubernetes, an open source container scheduler, to ensure that your cluster is running exactly the way you want it to at all times.

Follow along this lab to learn how to launch a container on Google Container Engine.

What you'll learn

What you'll need

How will you use this tutorial?

Read it through only Read it and complete the exercises

How would rate your experience with Google Cloud Platform?

Novice Intermediate Proficient

Self-paced environment setup

If you don't already have a Google Account (Gmail or G Suite), you must create one. Sign-in to Google Cloud Platform console ( and create a new project from the Manage resources page :

Remember the project ID, a unique name across all Google Cloud projects (the name above has already been taken and will not work for you, sorry!). It will be referred to later in this codelab as PROJECT_ID.

Next, you'll need to enable billing in the Developers Console in order to use Google Cloud resources.

Running through this codelab shouldn't cost you more than a few dollars, but it could be more if you decide to use more resources or if you leave them running (see "cleanup" section at the end of this document). The Google Cloud Platform pricing calculator is available here.

New users of Google Cloud Platform are eligible for a $300 free trial.

In this section you'll create a Google Container Engine cluster.

Login to Google Cloud Console

Navigate to the the Google Cloud Console from another browser tab/window, to Use the login credential given to you by the lab proctor.

Setup Project Prerequisites

Enable APIs

Click on the menu icon in the top left of the screen and select API Manager from the drop down.

Search for "Google Compute Engine" in the search box. Click on "Google Compute Engine" in the results list that appears.

On the Google Compute Engine page click "Enable"

Once it has enabled click the arrow to go back.

Now search for "Google Container Engine API" and enable it as well.

Set Compute Zone

Launch Cloud Shell by clicking on the terminal icon in the top toolbar.

Cloud Shell is a browser based terminal to a virtual machine that has the Google Cloud Platform tools installed on it and some additional tools (like editors and compilers) that are handy when you are developing or debugging your cloud application.

We'll be using the gcloud command to create the cluster. First, though, we need to set the compute zone so that the virtual machines in our cluster are created in the correct region. We can do this using gcloud config set compute/zone. Enter the following in Cloud Shell.

$ gcloud config set compute/zone us-central1-b

Create a New Cluster

You can create a new container cluster with the gcloud command like this:

$ gcloud container clusters create hello-world --num-nodes 1

This command creates a new cluster called "hello-world" with one node (VM). Since we'll only be launching one container a single node is fine. If you wanted to launch multiple containers you could specify a different number of nodes when you create the cluster.

Launching the cluster may take a bit of time but once it is up you should see output in Cloud Shell that looks like this:

hello-world  us-central1-b  1.1.8   n1-standard-1  1.1.8         1          RUNNING

You can also verify that the cluster started successfully by checking the instances list:

$ gcloud compute instances list

The results should list one instance with a status of "RUNNING".

Now that we have a cluster running it is time to deploy a wordpress container to it. We'll be using the tutum/wordpress image. This image containers all you need to run a wordpress site, including a MySQL database in a single Docker Container.

Create Your Pod

A pod is one or more containers that "travel together". That might mean they are administered together or they have the same network requirements. For this example we only have one container in our pod.

Create the pod using kubectl

$ kubectl run wordpress --image=tutum/wordpress --port=80

This command starts up the docker image on one of the nodes in the cluster. You can see the pod running using kubectl as well.

$ kubectl get pods

You should get back a result that looks something like:

NAME                        READY     STATUS    RESTARTS   AGE
wordpress-297829341-pw6c4   1/1       Running   0          7m

Allow External Traffic

By default a pod is only accessible to other machines inside the cluster. In order to use the wordpress container that was created it needs to be exposed as a service.

Expose the pod with the kubectl expose command. The --type=LoadBalancer flag creates an external IP that this pod can use to accept traffic.

$ kubectl expose pod <pod name> --name=wordpress  --type=LoadBalancer

kubectl expose creates a service, the forwarding rules for the load balancer, and the firewall rules that allow external traffic to be sent to the pod. You can see more details of this by running kubectl describe.

$ kubectl describe services wordpress

Name:                   wordpress
Namespace:              default
Labels:                 run=wordpress
Selector:               run=wordpress
Type:                   LoadBalancer
LoadBalancer Ingress:
Port:                   <unnamed>       80/TCP
NodePort:               <unnamed>       31392/TCP
Session Affinity:       None

Note the value in the LoadBalancer Ingress field. This is how you can access your container from outside the cluster.

Note: It may take a minute or so for the LoadBalancer Ingress field to get populated.

Verify the Deployment

Open a new browser window or tab and navigate to the IP address in the LoadBalancer Ingress field from the previous step. You should see the wordpress launch page.

Google Container Engine and Kubernetes provide a powerful and flexible way to run containers on Google Cloud Platform. Kubernetes can also be used on your own hardware or on other Cloud Providers.

This example only used a single container but it is simple to setup multiple container environments or multiple instances of a single container as well.

What we've covered

Next Steps