{"id":7619,"date":"2017-12-12T06:51:59","date_gmt":"2017-12-12T11:51:59","guid":{"rendered":"https:\/\/qxf2.com\/blog\/?p=7619"},"modified":"2021-02-16T06:14:54","modified_gmt":"2021-02-16T11:14:54","slug":"kubernetes-on-google-cloud-platform","status":"publish","type":"post","link":"https:\/\/qxf2.com\/blog\/kubernetes-on-google-cloud-platform\/","title":{"rendered":"Kubernetes on Google Cloud Platform"},"content":{"rendered":"

This is the second part in a series of posts about on getting started with Kubernetes. In my previous post<\/a>, I covered how to setup single node of Kubernetes Cluster locally using Minikube and discussed a few issues which I came across during its setup. Since Kubernetes comes with its own toolset, we can pretty much configure and run the software on multiple cloud providers, on-premise servers and even our local machine. This post is a step by step guide on setting up a highly available multi-zone Kubernetes cluster using Google Cloud Platform(GCP)<\/a>. Google Cloud Platform has excellent support for Kubernetes through the Google Container Engine(GKE)<\/a> that provides a Container Engine service built on top of Kubernetes. This makes managing a Kubernetes cluster a breeze. In this post, I am going to detail on how to spin up multi-node Kubernetes cluster on GKE (Google Container Engine).<\/p>\n

Kubernetes<\/a> is a container orchestration software that started at Google. A cluster has a set of nodes (think computers) on which we have pods, where each pod is a unit that contains several containers. In simple terms, it’s about managing a cluster (a set of machines) on which we have containers running. To follow this post, you should have a minimal understanding of Kubernetes and Google Container Engine.<\/p>\n

\n

Setup And Configure Google Cloud Platform<\/h3>\n

In this section, I will be talking about pre-requisites to configure Google Cloud Platform and different ways to communicate to Google Cloud platform. Note<\/strong><\/em>:-Users of Google Cloud Platform are eligible for a $300 free trial.<\/p>\n

Prerequisites<\/strong> – To follow this post,<\/p>\n

    \n
  1. You should have a Google Cloud account<\/a><\/li>\n
  2. Create a Google Cloud Project\n
      i) Go to Google Cloud Platform console<\/a><\/ol>\n
        ii) Create a project. My project is “kubernetes-project”. Every project has an id that you’re mostly working with. My PROJECT ID is “kubernetes-project-184510”. This is a unique name across all Google Cloud projects<\/ol>\n<\/li>\n<\/ol>\n

        Ways to communicate to Google Cloud platform. <\/strong><\/p>\n

      1. Once you are done with the basic setup, now we can create a cluster. One way of doing it is you can initialize and configure from a console window on the local window using Google Cloud SDK<\/a>(the Google command line interface for Google Cloud platform). If you don’t have Google Cloud SDK installed, you can follow this tutorial for the setup Google Cloud SDK<\/a>. It explains how to install the Google Cloud SDK, initialize it and run core gcloud commands from the command-line. Once you have installed the Google Cloud SDK, initialize and configure the gcloud CLI<\/a>. Once this set up is done your local system is communicating with your Google Cloud Platform account and project. After completing this step you will be able to create a Kubernetes cluster.<\/li>\n
      2. The second way of communicating with Google Cloud Platform is by using Google Cloud Shell<\/a>. Google Cloud interactive shell, is a browser-based command line environment running in the cloud. This Debian-based Docker container is loaded with all the development tools like docker, gcloud, kubectl. Google Cloud Shell comes pre-installed with the Google Cloud SDK. You can easily manage your projects and resources without having to install the Google Cloud SDK or other tools on your system. I have used Google Cloud interactive shell for executing the Kubernetes cluster creation commands in the below sections.<\/li>\n\n

        Creating Kubernetes Cluster On GKE<\/h3>\n

        GKE Cluster can be created in two ways: via the gcloud Interactive Shell or via the Cloud Platform Console<\/a>. Both the methods use Google Container Engine (GKE) for creating clusters. In below sections, I will provide you with the steps for setting up a single and multi-zone Kubernetes cluster using both the methods. <\/p>\n

        Cluster creation via Google Cloud Shell<\/h4>\n

        You can create GKE cluster by following simple commands on Google Shell.<\/p>\n

      3. Enable the Container and Compute Engine APIs<\/strong> Container Engine API<\/a> and Compute Engine API<\/a>.<\/li>\n
      4. Activate Google Cloud Shell<\/strong> – Activate Google Cloud Shell by selecting the project(in
        \nmy case ‘kubernetes-project’) created from the Google Cloud Platform dashboard. Then select the Activate Google Cloud Shell button in the top nav. Once connected, you are already authenticated and the PROJECT_ID environment variable is already set by default. Note<\/em><\/strong>: As mentioned earlier, Google Cloud Shell comes pre-installed with the Google Cloud SDK and built-in authorization for access to projects and resources hosted on Google Cloud Platform.<\/li>\n
        \"\"<\/a>
        Google Cloud Interactive Shell<\/figcaption><\/figure>\n
      5. Create Cluster using Gcloud shell<\/strong> – Below are the set of commands used to create one zone Kubernetes cluster using gcloud interactive shell.\n
        \r\n$ CLUSTER_NAME=kubernetes-lab1\r\n\r\n$ gcloud config set container\/cluster ${CLUSTER_NAME} \r\n\r\n$ MACHINE_TYPE=n1-standard-2   \r\n\r\n# By default this spins up a 3-node cluster. You can change the default with `--num-nodes VAL`\r\n$ gcloud container clusters create ${CLUSTER_NAME} --zone europe-west1-d --scopes storage-rw --machine-type ${MACHINE_TYPE}<\/pre>\n
        By default, if we do not specify the number of nodes and their types, then Container Engine will use three n1-standard-1 (1 vCPU, 3.75 GB memory) Compute Engine VMs for the cluster. In this example, I am creating a Kubernetes cluster in ‘europe-west1-d’ zone with three instances (nodes) per zone using machine type ‘n1-standard-2’. The actual command would look like the following.<\/p>\n
        \r\n$ gcloud container clusters create kubernetes-lab1 \\\r\n         --zone europe-west1-d \\\r\n         --scopes storage-rw \\\r\n         --machine-type n1-standard-2<\/pre>\n
        You can also create a multi-zone cluster using below command<\/p>\n
         \r\ngcloud container clusters create kubernetes-lab1 \\\r\n      --zone europe-west1-d \\\r\n      --additional-zones europe-west1-a,europe-west1-b \\\r\n      --scopes storage-rw \r\n      --machine-type n1-standard-2<\/pre>\n
        Note that –scopes<\/em> specifies scopes for the node instances. Multiple comma-delimited scopes can be specified. The scopes necessary for the cluster to function properly (compute-rw, storage-ro), are always added, even if not explicitly specified. I initially created the Kubernetes cluster without defining a permission scope. Hence I was getting “googleapi: Error 403: Insufficient Permission<\/strong><\/em>” error when I tried to access the node instances. If no scope is set when the cluster is created, the default scope is assigned and this only provides read permission for Cloud Storage. If you haven’t assigned your cluster with the correct scope, the nodes in the cluster would not have the required authorization\/permission to write to Google Cloud Storage. Later I managed to create a cluster with ‘storage-rw’ scope and everything worked as expected.<\/li>\n
        We can also check the status on the GCP Console. As a sanity check, to make sure the cluster is up and running via kubectl, use below command.<\/p>\n
        $ kubectl get all\r\nNAME             CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE\r\nsvc\/kubernetes   10.0.0.1             443\/TCP   22s\r\n<\/pre>\n
        Since the cluster is fully setup with the Kubernetes platform we can start interacting with it by using the kubectl command as shown below<\/p>\n
        $ kubectl cluster-info<\/pre>\n
        \"\"<\/a>
        Kubectl Cluster Information<\/figcaption><\/figure>\n
        As you can see, the details contain the Kubernetes Master URL and other URLs for various Kubernetes services, one of which is the Kubenetes-Dashboard which is the Web UI running on the Kubernetes Master. <\/p>\n
        The new cluster will also appear in the Container Engine -> Kubernetes cluster section within Google Cloud Platform:<\/p>\n
        \"\"<\/a>
        Container Engine – Kubernetes cluster<\/figcaption><\/figure>\n\n
        Cluster creation via Cloud Platform Console<\/h4>\n
         Creating a cluster using Google Cloud Console is pretty easy and straight forward.<\/p>\n
      6. Go to Container Engine page<\/a>, which can be found via the hamburger menu in the top left. Next, go to Container clusters and select Create a container cluster as shown in the below image\n
        \"\"<\/a>
        Cluster Creation using Google Cloud Console<\/figcaption><\/figure><\/li>\n
      7. In this example, I am creating a Kubernetes cluster in ‘us-central1-a’ zone with three instances (nodes) per zone using machine type ‘n1-standard-1’<\/li>\n
      8. Select Create<\/em> once you are done with the configuration. This will take a few minutes to complete. Once the cluster is created you should see something like this:\n
        \"\"<\/a>
        Cluster created in Google Cloud Console<\/figcaption><\/figure><\/li>\n
        The nodes are managed by Compute Engine VMs and Kubernetes master is managed by Container Engine. Since the nodes are managed by Compute Engine VMs, we can also SSH into them. However, you cannot SSH into Kubernetes Master. Now you have a Kubernetes Cluster ready to use! Make sure that you turn off the VM’s after you finish your work.<\/p>\n
        \"\"<\/a>
        Cluster Node created<\/figcaption><\/figure>\n
      9.  Once the cluster is up and running (this took few minutes to start up), we need to point kubectl to this cluster. Since the cluster is fully setup with the Kubernetes platform we can start interacting with it by using the kubectl command\n
        \r\n$ gcloud container clusters get-credentials kubernetes-lab2<\/pre>\n
        Note:<\/strong> If you are using an existing Kubernetes Engine cluster or if you have created a cluster through Google Cloud Platform Console, you need to run the above command to retrieve cluster credentials and configure kubectl command-line tool with them. If you have already created a cluster with the gcloud container clusters create command listed above, this step is not necessary.<\/p>\n\n
        In this post, we learned how to
        \n1) Setup and configure Google Cloud Platform
        \n2) Set up a kubernetes cluster using Google Cloud Shell and Google Cloud Console.<\/p>\n
        If you liked what you read, know more about Qxf2<\/a>.<\/strong><\/p>\n\n
        References<\/h3>\n
        1) Get Started With Kubernetes<\/a>
        \n2)         Spinning Up Your First Kubernetes Cluster on GKE<\/a>
        \n3)         googleapi: Error 403: Insufficient Permission<\/a><\/p>\n
        \n","protected":false},"excerpt":{"rendered":"
        This is the second part in a series of posts about on getting started with Kubernetes. In my previous post, I covered how to setup single node of Kubernetes Cluster locally using Minikube and discussed a few issues which I came across during its setup. Since Kubernetes comes with its own toolset, we can pretty much configure and run the […]<\/p>\n","protected":false},"author":16,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[140,152,150,151],"tags":[],"class_list":["post-7619","post","type-post","status-publish","format-standard","hentry","category-docker","category-google-container-engine","category-kubernetes","category-minikube"],"_links":{"self":[{"href":"https:\/\/qxf2.com\/blog\/wp-json\/wp\/v2\/posts\/7619","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/qxf2.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/qxf2.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/qxf2.com\/blog\/wp-json\/wp\/v2\/users\/16"}],"replies":[{"embeddable":true,"href":"https:\/\/qxf2.com\/blog\/wp-json\/wp\/v2\/comments?post=7619"}],"version-history":[{"count":70,"href":"https:\/\/qxf2.com\/blog\/wp-json\/wp\/v2\/posts\/7619\/revisions"}],"predecessor-version":[{"id":14843,"href":"https:\/\/qxf2.com\/blog\/wp-json\/wp\/v2\/posts\/7619\/revisions\/14843"}],"wp:attachment":[{"href":"https:\/\/qxf2.com\/blog\/wp-json\/wp\/v2\/media?parent=7619"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/qxf2.com\/blog\/wp-json\/wp\/v2\/categories?post=7619"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/qxf2.com\/blog\/wp-json\/wp\/v2\/tags?post=7619"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}