Using Google Kubernetes Engine (GKE) in Go: A Complete Guide

In recent years, Kubernetes has become the de facto standard for container orchestration platforms, and Google Kubernetes Engine (GKE) is a fully managed Kubernetes engine provided on Google Cloud Platform. It not only provides automated container orchestration, scalability and high availability, but also enables quick startup and adjustment, making code deployment easier. This article will introduce you to how to use GKE in the Go language. I hope this article can become a complete guide to using GKE.

Step 1: Create a project and enable GKE API

First, we need to create a Google Cloud Platform project. Before entering GKE, we need to enable the GKE API. There are many ways to enable GKE API, here we introduce two:

1. On the "API and Services" > "API" page of Google Cloud Console, filter "Kubernetes Engine API" and enable it.

2. In the cloud Shell or local terminal, enter the following command:

gcloud services enable container.googleapis.com

Step 2: Create a Kubernetes cluster

After enabling the GKE API, we need to create a Kubernetes cluster. The size and specification of the cluster can be adjusted according to specific needs. The following is an example containing 3 nodes with size n1-standard-1:

gcloud container clusters create example-cluster --zone=us-central1-a --num-nodes=3 --machine-type=n1-standard-1

When executing the above command, we need to replace "example-cluster" with the name of the cluster we need to create. Moreover, we also need to select a region to create our cluster, here we selected us-central1-a. The number and specifications of nodes in the Kubernetes cluster also need to be adjusted according to the actual situation.

Step 3: Install Kubernetes client tools

After creating the Kubernetes cluster, we need to install and configure the Kubernetes client tools to manage our cluster. Kubernetes client tools typically include kubectl and Helm. kubectl is a command-line tool for Kubernetes that can be used to manage Kubernetes clusters, Pods, and containers, and perform operations such as create, update, delete, and expand. Helm is a package manager that can be used to install and manage third-party libraries.

The method to install and configure kubectl is as follows:

1. Install kubectl in the local terminal:

gcloud components install kubectl

2. Configure kubectl with the current cluster:

gcloud container clusters get-credentials example-cluster --zone=us-central1-a

3. Then we can use the kubectl command line tool to manage the cluster, for example, run the following command to get all nodes in the Kubernetes cluster:

kubectl get nodes

The method of installing and configuring Helm is as follows:

1 .Download the Helm Binary file in the local terminal and install it:

curl https://raw.githubusercontent.com/kubernetes/helm/master/scripts/get-helm-3 | bash

2. Configure Helm with the current Kubernetes cluster:

kubectl create serviceaccount --namespace kube-system tiller
kubectl create clusterrolebinding tiller-cluster-rule --clusterrole=cluster-admin --serviceaccount=kube-system:tiller
helm init --service-account tiller --upgrade

Step 4: Deploy the Go application on GKE

Finally, we can deploy our Go application into the Kubernetes cluster. The following is an example of deploying a Go application using Deployment and Service resources:

1. Create a YAML file containing Deployment and Service resources, for example:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: go-app-deployment
  labels:
    app: go-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: go-app
  template:
    metadata:
      labels:
        app: go-app
    spec:
      containers:
        - name: go-app
          image: gcr.io/example-project/go-app:latest
          ports:
            - containerPort: 8080
              protocol: TCP
---
apiVersion: v1
kind: Service
metadata:
  name: go-app-service
  labels:
    app: go-app
spec:
  selector:
    app: go-app
  ports:
    - port: 80
      targetPort: 8080
      protocol: TCP
  type: LoadBalancer

Where, "go-app- deployment" is the name of the Deployment resource we created, "go-app" is the namespace we use, and "go-app-service" is the name of the Service resource we created. We need to specify a container image for the Deployment resource, such as "gcr.io/example-project/go-app:latest".

2. Use the kubectl command to apply this YAML file to the Kubernetes cluster:

kubectl apply -f go-app.yaml

3. Run the following command to get the external IP address created on GKE:

kubectl get service go-app-service

In the returned results, you can find the IP address in the "EXTERNAL-IP" field, which is the address of the Go application we deployed.

Summary

This article provides a complete guide to using GKE in the Go language. GKE is a fully managed Kubernetes engine that provides us with container orchestration for data automation, high availability, scalability, and an easy-to-use interface. Using the methods mentioned in this article, we can easily deploy Go applications to GKE and add automated deployment processes to make application deployment more convenient.

The above is the detailed content of Using Google Kubernetes Engine (GKE) in Go: A Complete Guide. For more information, please follow other related articles on the PHP Chinese website!