GKE - Getting Started with Google Container Engine

Kubernetes provides orchestration for running containerized applications. In this tutorial we’ll walk through the basics of using Google Container Engine, or GKE, which provides managed Kubernetes services for your use.

Objectives

• Create a cluster
• Switching between clusters
• Deploy a docker application
• Expose the application as a Service
• Scale the application

Before you begin

This tutorial requires a few components to be setup and ready for use before starting.

Enable Container Engine

Take the following steps to enable the Google Container Engine API:

• Visit the Container Engine page in the Google Cloud Platform Console.
• Create or select a project.
• Wait for the API and related services to be enabled. This can take several minutes
• Enable billing for your project. ENABLE BILLING

Install Google Cloud SDK command line client

• Install gcloud, the Google Cloud SDK

Install kubectl command line client

Once your Google Cloud SDK is set up, you can install the kubernetes client, kubectl with the following command:

$ gcloud components install kubectl

Create a Cluster

Before we can start using GKE we’ll need to create the cluster

1. Set a default Compute Engine zone.

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

You can view your defaults in the gcloud command-line tool by running the following command:

$ gcloud config list

2. Create a cluster (this step can take a few minutes to complete).

$ gcloud container clusters create example-cluster

Switching Between Clusters

You may have access to multiple cluster in various projects. Often times its necessary to point your client between different clusters.

1. Review the clusters available in the project

$ gcloud container clusters list

2. Set the default cluster for gcloud container commands

$ gcloud config set container/cluster example-cluster

3. Configure kubectl

Google Container Engine uses the kubectl command to manage resources in your cluster. If you have more than one cluster, you must tell kubectl which cluster to target.

To tell kubectl to target a specific cluster, run the following command in your shell or terminal window:

$ gcloud container clusters get-credentials example-cluster

kubectl is configured to use Application Default Credentials to authenticate to the cluster. Ensure it has the right credentials by running

$ gcloud auth application-default login

This opens a browser window prompting you to log in with your desired account.

Deploy a Docker Application

In this step we’re going to deploy a prebuilt sample Node application described in the official docs. In future tutorials we’ll be creating our own Docker applications, building and deploying them.

1. Deploy and run the

$ kubectl run hello-node --image=gcr.io/google-samples/node-hello:1.0 --port=8080

2. Review the pod status

$ kubectl get pods
NAME                          READY     STATUS    RESTARTS   AGE
hello-node-3526609615-pl732   1/1       Running   0          15m

Expose the Application as a Service

At this point the application is running in our container. While other applications within the cluster can access it, we currently don’t have a way to access it from outside the cluster.

1. To expose the application externally we’ll define a Service for it

$ kubectl expose deployment hello-node --type="LoadBalancer"
service "hello-node" exposed

This command creates a Service resource within the cluster. The type=“LoadBalancer option in kubectl requests that Google Cloud Platform provision a load balancer for your container, which is billed per the regular Load Balancer pricing .

2. Copy the external IP address for the hello-node app

$ kubectl get service hello-node
NAME         CLUSTER-IP     EXTERNAL-IP      PORT(S)          AGE
hello-node   10.3.250.198   104.154.253.10   8080:32083/TCP   58s

View the app (replace EXTERNAL-IP with the external IP address you obtained in the previous step).

$ open http://EXTERNAL-IP:8080

Note: You might need to wait several minutes to get an external IP address. If you don’t get an external IP address, run kubectl get service hello-node again.

Scale the application

Scaling your application is typically manage by setting a base number of pods and then utilizing auto scaling capabilities. In this example though we’re going to demonstrate scaling manually.

If we list the application we’ll see ‘1/1 READY’. This means we requested one and there is indeed one running.

$ kubectl get pods
NAME                          READY     STATUS    RESTARTS   AGE
hello-node-3526609615-pl732   1/1       Running   0          45m

When we deployed the node application kubenetes also created a Replication Controller to manage how many replicas of the application are running. We can see this by listing the deployments

$ kubectl get deployments
NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-node   1         1         1            1           54m

Now lets scale the deployment so that we have 3 pods running

$ kubectl scale --replicas=3 deployment/hello-node
deployment "hello-node" scaled

And review that everything has now been updated

$ kubectl get deployments
NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-node   3         3         3            3           54m

$ kubectl get pods
NAME                          READY     STATUS    RESTARTS   AGE
hello-node-3526609615-cf9jn   1/1       Running   0          24s
hello-node-3526609615-p3nqk   1/1       Running   0          24s
hello-node-3526609615-pl732   1/1       Running   0          55m

Cleaning up

To avoid incurring charges to your Google Cloud Platform account for the resources used in this quickstart:

Delete the services you created to remove the load balancing resources that are provisioned to serve them:

$ kubectl delete service hello-node

Wait a few minutes for the service to spin down, then use the following command to delete the cluster you created:

$ gcloud container clusters delete example-cluster