Menggunakan Enjin Google Kubernetes (GKE) dalam Go: Panduan lengkap

Dalam beberapa tahun kebelakangan ini, Kubernetes telah menjadi standard de facto untuk platform orkestrasi kontena dan Google Kubernetes Engine (GKE) ialah enjin Kubernetes terurus sepenuhnya yang disediakan pada Google Cloud Platform. Ia bukan sahaja menyediakan orkestrasi kontena automatik, kebolehskalaan dan ketersediaan tinggi, tetapi juga membolehkan permulaan dan pelarasan pantas, menjadikan penggunaan kod lebih mudah. Artikel ini akan memperkenalkan anda kepada cara menggunakan GKE dalam bahasa Go. Saya harap artikel ini boleh menjadi panduan lengkap untuk menggunakan GKE.

Langkah 1: Buat projek dan dayakan API GKE

Mula-mula, kita perlu mencipta projek Google Cloud Platform. Sebelum memasuki GKE, kita perlu mendayakan API GKE. Terdapat banyak cara untuk mendayakan API GKE, di sini kami memperkenalkan dua:

1 Pada halaman "API dan Perkhidmatan" > "API" Google Cloud Console, tapis "API Enjin Kubernetes" dan dayakannya.

2. Dalam cloud Shell atau terminal setempat, masukkan arahan berikut:

gcloud services enable container.googleapis.com

Langkah 2: Buat gugusan Kubernetes

Selepas mendayakan API GKE, kita perlu buat gugusan Kubernetes. Saiz dan spesifikasi kluster boleh dilaraskan mengikut keperluan khusus. Berikut ialah contoh yang mengandungi 3 nod dengan saiz n1-standard-1:

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

Apabila melaksanakan arahan di atas, kita perlu menggantikan "example-cluster" dengan nama cluster yang perlu kita buat. Selain itu, kami juga perlu memilih rantau untuk membuat kluster kami, di sini kami memilih kami-central1-a. Bilangan dan spesifikasi nod dalam kelompok Kubernetes juga perlu diselaraskan mengikut situasi sebenar.

Langkah 3: Pasang alatan klien Kubernetes

Selepas mencipta kluster Kubernetes, kami perlu memasang dan mengkonfigurasi alatan klien Kubernetes untuk mengurus kluster kami. Alat klien Kubernetes biasanya termasuk kubectl dan Helm. kubectl ialah alat baris arahan untuk Kubernetes yang boleh digunakan untuk mengurus kelompok Kubernetes, Pod dan bekas serta melaksanakan operasi seperti mencipta, mengemas kini, memadam dan mengembangkan. Helm ialah pengurus pakej yang boleh digunakan untuk memasang dan mengurus perpustakaan pihak ketiga.

Kaedah untuk memasang dan mengkonfigurasi kubectl adalah seperti berikut:

1 Pasang kubectl dalam terminal setempat:

gcloud components install kubectl

2 >

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

3. Kemudian kita boleh menggunakan alat baris arahan kubectl untuk menguruskan kluster, contohnya, jalankan arahan berikut untuk mendapatkan semua nod dalam kluster Kubernetes:

kubectl get nodes

Kaedah memasang dan mengkonfigurasi Helm adalah seperti berikut:

1 .Muat turun fail Helm Binary dalam terminal tempatan dan pasang:

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

2. Konfigurasikan Helm dengan gugusan Kubernetes semasa:

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

Langkah 4: Pasang aplikasi Go pada GKE

Akhir sekali, kami boleh menggunakan aplikasi Go kami ke dalam kelompok Kubernetes. Berikut ialah contoh menggunakan aplikasi Go menggunakan sumber Deployment dan Perkhidmatan:

1 Cipta fail YAML yang mengandungi sumber Deployment dan Perkhidmatan, contohnya:

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

di mana, "go-app. - deployment" ialah nama sumber Deployment yang kami buat, "go-app" ialah ruang nama yang kami gunakan dan "go-app-service" ialah nama sumber Service yang kami buat. Kami perlu menentukan imej bekas untuk sumber Penggunaan, seperti "gcr.io/example-project/go-app:latest".

2. Gunakan perintah kubectl untuk menggunakan fail YAML ini pada kelompok Kubernetes:

kubectl apply -f go-app.yaml

3 Jalankan arahan berikut untuk mendapatkan alamat IP luaran yang dibuat pada GKE:

kubectl get service go-app-service

Dalam hasil yang dikembalikan, anda boleh menemui alamat IP dalam medan "IP-LUARAN", iaitu alamat aplikasi Go yang kami gunakan.

Ringkasan

Artikel ini menyediakan panduan lengkap untuk menggunakan GKE dalam bahasa Go. GKE ialah enjin Kubernetes terurus sepenuhnya yang memberikan kami orkestrasi kontena untuk automasi data, ketersediaan tinggi, kebolehskalaan dan antara muka yang mudah digunakan. Menggunakan kaedah yang dinyatakan dalam artikel ini, kami boleh menggunakan aplikasi Go ke GKE dengan mudah dan menambahkan proses penggunaan automatik untuk menjadikan penggunaan aplikasi lebih mudah.

Atas ialah kandungan terperinci Menggunakan Enjin Google Kubernetes (GKE) dalam Go: Panduan lengkap. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!