Verwendung von Google Kubernetes Engine (GKE) in Go: Eine vollständige Anleitung

In den letzten Jahren hat sich Kubernetes zum De-facto-Standard für Container-Orchestrierungsplattformen entwickelt, und Google Kubernetes Engine (GKE) ist eine vollständig verwaltete Kubernetes-Engine, die auf der Google Cloud Platform bereitgestellt wird. Es bietet nicht nur automatisierte Container-Orchestrierung, Skalierbarkeit und hohe Verfügbarkeit, sondern ermöglicht auch eine schnelle Inbetriebnahme und Anpassung, wodurch die Codebereitstellung einfacher wird. In diesem Artikel erfahren Sie, wie Sie GKE in der Go-Sprache verwenden. Ich hoffe, dieser Artikel kann zu einer vollständigen Anleitung zur Verwendung von GKE werden.

Schritt 1: Erstellen Sie ein Projekt und aktivieren Sie die GKE-API.

Zuerst müssen wir ein Google Cloud Platform-Projekt erstellen. Bevor wir GKE betreten, müssen wir die GKE-API aktivieren. Es gibt viele Möglichkeiten, die GKE-API zu aktivieren. Hier stellen wir zwei vor:

1 Filtern Sie auf der Seite „API und Dienste“ > „API“ der Google Cloud Console nach „Kubernetes Engine API“ und aktivieren Sie sie.

2. Geben Sie in der Cloud-Shell oder im lokalen Terminal den folgenden Befehl ein:

gcloud services enable container.googleapis.com

Schritt 2: Erstellen Sie einen Kubernetes-Cluster

Nachdem wir die GKE-API aktiviert haben, müssen wir einen Kubernetes-Cluster erstellen. Die Größe und Spezifikation des Clusters kann je nach Bedarf angepasst werden. Das Folgende ist ein Beispiel mit 3 Knoten der Größe n1-standard-1:

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

Beim Ausführen des obigen Befehls müssen wir „example-cluster“ durch den Namen des Clusters ersetzen, den wir erstellen müssen. Darüber hinaus müssen wir auch eine Region auswählen, um unseren Cluster zu erstellen. Hier haben wir us-central1-a ausgewählt. Auch die Anzahl und Spezifikationen der Knoten im Kubernetes-Cluster müssen entsprechend der tatsächlichen Situation angepasst werden.

Schritt 3: Kubernetes-Client-Tools installieren

Nachdem wir den Kubernetes-Cluster erstellt haben, müssen wir die Kubernetes-Client-Tools installieren und konfigurieren, um unseren Cluster zu verwalten. Zu den Kubernetes-Client-Tools gehören typischerweise kubectl und Helm. kubectl ist ein Befehlszeilentool für Kubernetes, mit dem Kubernetes-Cluster, Pods und Container verwaltet und Vorgänge wie Erstellen, Aktualisieren, Löschen und Erweitern ausgeführt werden können. Helm ist ein Paketmanager, mit dem Bibliotheken von Drittanbietern installiert und verwaltet werden können.

Die Methode zum Installieren und Konfigurieren von kubectl ist wie folgt:

1. Installieren Sie kubectl im lokalen Terminal:

gcloud components install kubectl

3. Dann können wir das kubectl-Befehlszeilentool verwenden Um den Cluster zu verwalten, führen Sie beispielsweise den folgenden Befehl aus, um alle Knoten im Kubernetes-Cluster abzurufen:

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

Die Methode zum Installieren und Konfigurieren von Helm ist wie folgt:

1. Laden Sie die Helm-Binärdatei im lokalen Terminal herunter und installieren Sie sie it:

kubectl get nodes

2. Verbinden Sie Helm mit dem aktuellen Kubernetes-Cluster. Konfiguration:

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

Schritt 4: Go-Anwendung auf GKE bereitstellen

Schließlich können wir unsere Go-Anwendung im Kubernetes-Cluster bereitstellen. Das Folgende ist ein Beispiel für die Bereitstellung einer Go-Anwendung mithilfe von Bereitstellungs- und Serviceressourcen:

1. Erstellen Sie eine YAML-Datei mit Bereitstellungs- und Serviceressourcen, zum Beispiel:

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

wobei „go-app-deployment“ die von uns erstellte Bereitstellung ist Name der Ressource, „go-app“ ist der von uns verwendete Namespace und „go-app-service“ ist der Name der von uns erstellten Serviceressource. Wir müssen ein Container-Image für die Bereitstellungsressource angeben, z. B. „gcr.io/example-project/go-app:latest“.

2. Verwenden Sie den Befehl kubectl, um diese YAML-Datei auf den Kubernetes-Cluster anzuwenden:

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

3. Führen Sie den folgenden Befehl aus, um die auf GKE erstellte externe IP-Adresse abzurufen:

kubectl apply -f go-app.yaml

In den zurückgegebenen Ergebnissen finden Sie „EXTERNAL - IP“-Feld, diese Adresse ist die Adresse der von uns bereitgestellten Go-Anwendung.

Zusammenfassung

Dieser Artikel enthält eine vollständige Anleitung zur Verwendung von GKE in der Go-Sprache. GKE ist eine vollständig verwaltete Kubernetes-Engine, die uns Container-Orchestrierung für Datenautomatisierung, hohe Verfügbarkeit, Skalierbarkeit und eine benutzerfreundliche Schnittstelle bietet. Mit den in diesem Artikel erwähnten Methoden können wir Go-Anwendungen problemlos in GKE bereitstellen und automatisierte Bereitstellungsprozesse hinzufügen, um die Anwendungsbereitstellung komfortabler zu gestalten.

Das obige ist der detaillierte Inhalt vonVerwendung von Google Kubernetes Engine (GKE) in Go: Eine vollständige Anleitung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!