Mehrfachnutzercluster mit Terraform erstellen

Mehrfachnutzercluster mit Terraform erstellen

Ein mehrmandantenfähiger Cluster in der Google Kubernetes Engine (GKE) Enterprise-Version ist ein Kubernetes-Cluster, der von mehreren verschiedenen Teams oder Nutzern gemeinsam genutzt wird, die als Mandanten bezeichnet werden. Jeder Mandant hat in der Regel seine eigenen Ressourcen und Anwendungen innerhalb des Clusters.

In diesem Terraform-Tutorial können Sie schnell einen GKE Enterprise-Cluster erstellen, der von zwei Teams, backend und frontend, gemeinsam genutzt wird und auf dem teamspezifische Arbeitslasten bereitgestellt werden können. In dieser Anleitung wird davon ausgegangen, dass Sie mit Terraform vertraut sind. Falls nicht, können Sie sich mit den folgenden Ressourcen mit den Grundlagen von Terraform vertraut machen:

• Erste Schritte mit Terraform (Video)
• Terraform-Befehle

Was ist Terraform? Infrastructure as Code (IaC) ist ein Verfahren, mit dem Sie Software-Infrastrukturressourcen mithilfe von Code verwalten und bereitstellen können. Terraform ist ein beliebtes Open-Source-IaC-Tool von HashiCorp, das eine Reihe von Cloud-Diensten unterstützt, einschließlich GKE. Als GKE-Plattformadministrator können Sie mit Terraform die Konfiguration Ihrer Kubernetes-Cluster in der Produktion standardisieren und DevOps-Workflows optimieren. Weitere Informationen finden Sie unter Terraform-Unterstützung für GKE.

Hinweise

Führen Sie folgende Schritte aus, um die Kubernetes Engine API zu aktivieren:

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Make sure that billing is enabled for your Google Cloud project.

4. Enable the GKE, GKE Hub, Cloud SQL, Resource Manager, IAM, Connect gateway APIs.

   Enable the APIs

5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

6. Make sure that billing is enabled for your Google Cloud project.

7. Enable the GKE, GKE Hub, Cloud SQL, Resource Manager, IAM, Connect gateway APIs.

   Enable the APIs

8. Make sure that you have the following role or roles on the project: roles/owner, roles/iam.serviceAccountTokenCreator

   Check for the roles

   1. In the Google Cloud console, go to the IAM page.

      Go to IAM
   2. Select the project.

   3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.

   4. For all rows that specify or include you, check the Role column to see whether the list of roles includes the required roles.

   Grant the roles

   1. In the Google Cloud console, go to the IAM page.

      IAM aufrufen
   2. Wählen Sie das Projekt aus.
   3. Klicken Sie auf Zugriff erlauben.

   4. Geben Sie im Feld Neue Hauptkonten Ihre Nutzer-ID ein. Dies ist in der Regel die E-Mail-Adresse eines Google-Kontos.

   5. Wählen Sie in der Liste Rolle auswählen eine Rolle aus.
   6. Wenn Sie weitere Rollen hinzufügen möchten, klicken Sie auf Weitere Rolle hinzufügen und fügen Sie weitere Rollen hinzu.
   7. Klicken Sie auf Speichern.

Umgebung vorbereiten

In dieser Anleitung verwenden Sie Cloud Shell zum Verwalten von Ressourcen, die inGoogle Cloudgehostet werden. Die Software, die Sie für diese Anleitung benötigen, ist in Cloud Shell vorinstalliert, einschließlich Terraform, kubectl und der Google Cloud CLI.

1. Starten Sie eine Cloud Shell-Sitzung über die Google Cloud -Konsole. Klicken Sie dazu auf das Symbol zum Aktivieren von Cloud Shell Cloud Shell aktivieren . Dadurch wird im unteren Bereich der Google Cloud Console eine Sitzung gestartet.

   Die Dienstanmeldedaten, die dieser virtuellen Maschine zugeordnet sind, werden automatisch verwendet. Daher müssen Sie keinen Dienstkontoschlüssel einrichten oder herunterladen.

2. Bevor Sie Befehle ausführen, legen Sie Ihr Standardprojekt in der gcloud CLI mit dem folgenden Befehl fest:

   gcloud config set project PROJECT_ID
   

   Ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID.

3. Klonen Sie das GitHub-Repository:

   git clone https://github.com/terraform-google-modules/terraform-docs-samples.git --single-branch
   

4. Wechseln Sie in das Arbeitsverzeichnis:

   cd terraform-docs-samples/gke/quickstart/multitenant
   

Terraform-Dateien prüfen

Der Google Cloud -Anbieter ist ein Plug-in, mit dem Sie Google Cloud -Ressourcen mit Terraform verwalten und bereitstellen können. Es dient als Bindeglied zwischen Terraform-Konfigurationen undGoogle Cloud APIs, sodass Sie Infrastrukturressourcen wie virtuelle Maschinen und Netzwerke deklarativ definieren können.

1. Prüfen Sie die Datei main.tf, in der eine GKE Enterprise-Clusterressource beschrieben wird:

   cat main.tf
   

   Die Ausgabe sieht in etwa so aus:

   resource "google_container_cluster" "default" {
     name               = "gke-enterprise-cluster"
     location           = "us-central1"
     initial_node_count = 3
     fleet {
       project = data.google_project.default.project_id
     }
     workload_identity_config {
       workload_pool = "${data.google_project.default.project_id}.svc.id.goog"
     }
     security_posture_config {
       mode               = "BASIC"
       vulnerability_mode = "VULNERABILITY_ENTERPRISE"
     }
     depends_on = [
       google_gke_hub_feature.policycontroller,
       google_gke_hub_namespace.default
     ]
     # Set `deletion_protection` to `true` will ensure that one cannot
     # accidentally delete this instance by use of Terraform.
     deletion_protection = false
   }
   
   resource "google_gke_hub_membership_binding" "default" {
     for_each = google_gke_hub_scope.default
   
     project               = data.google_project.default.project_id
     membership_binding_id = each.value.scope_id
     scope                 = each.value.name
     membership_id         = google_container_cluster.default.fleet[0].membership_id
     location              = google_container_cluster.default.fleet[0].membership_location
   }

Cluster und SQL-Datenbank erstellen

1. Führen Sie in Cloud Shell den folgenden Befehl aus, um zu prüfen, ob Terraform verfügbar ist:

   terraform
   

   Die Ausgabe sollte in etwa so aussehen:

   Usage: terraform [global options] <subcommand> [args]
   
   The available commands for execution are listed below.
   The primary workflow commands are given first, followed by
   less common or more advanced commands.
   
   Main commands:
     init          Prepare your working directory for other commands
     validate      Check whether the configuration is valid
     plan          Show changes required by the current configuration
     apply         Create or update infrastructure
     destroy       Destroy previously-created infrastructure
   

2. Initialisieren Sie Terraform:

   terraform init
   

3. Optional: Planen Sie die Terraform-Konfiguration:

   terraform plan
   

4. Wenden Sie die Terraform-Konfiguration an:

   terraform apply
   

   Geben Sie yes ein, wenn Sie aufgefordert werden, die Aktionen zu bestätigen. Die Ausführung dieses Befehls kann mehrere Minuten dauern. Die Ausgabe sieht in etwa so aus:

   Apply complete! Resources: 23 added, 0 changed, 0 destroyed.
   

Backend-Teamanwendung bereitstellen

1. Sehen Sie sich die folgende Terraform-Datei an:

   cat backend.yaml
   

   Die Ausgabe sollte in etwa so aussehen:

   apiVersion: v1
   kind: ConfigMap
   metadata:
     name: backend-configmap
     namespace: backend-team
     labels:
       app: backend
   data:
     go.mod: |
       module multitenant
   
       go 1.22
   
       require github.com/go-sql-driver/mysql v1.8.1
   
       require filippo.io/edwards25519 v1.1.0 // indirect
   
     go.sum: |
       filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
       filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
       github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpvNJ1Y=
       github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg=
   
     backend.go: |
       package main
   
       import (
         "database/sql"
         "fmt"
         "log"
         "math/rand"
         "net/http"
         "os"
   
         _ "github.com/go-sql-driver/mysql"
       )
   
       func main() {
         mux := http.NewServeMux()
         mux.HandleFunc("/", frontend)
   
         port := "8080"
   
         log.Printf("Server listening on port %s", port)
         log.Fatal(http.ListenAndServe(":"+port, mux))
       }
   
       func frontend(w http.ResponseWriter, r *http.Request) {
         log.Printf("Serving request: %s", r.URL.Path)
   
         host, _ := os.Hostname()
         fmt.Fprintf(w, "Backend!\n")
         fmt.Fprintf(w, "Hostname: %s\n", host)
   
         // Open database using cloud-sql-proxy sidecar
         db, err := sql.Open("mysql", "multitenant-app@tcp/multitenant-app")
         if err != nil {
           fmt.Fprintf(w, "Error: %v\n", err)
           return
         }
   
         // Create metadata Table if not exists
         _, err = db.Exec("CREATE TABLE IF NOT EXISTS metadata (metadata_key varchar(255) NOT NULL, metadata_value varchar(255) NOT NULL, PRIMARY KEY (metadata_key))")
         if err != nil {
           fmt.Fprintf(w, "Error: %v\n", err)
           return
         }
   
         // Pick random primary color
         var color string
         randInt := rand.Intn(3) + 1
         switch {
         case randInt == 1:
           color = "red"
         case randInt == 2:
           color = "green"
         case randInt == 3:
           color = "blue"
         }
   
         // Set color in database
         _, err = db.Exec(fmt.Sprintf("REPLACE INTO metadata (metadata_key, metadata_value) VALUES ('color', '%s')", color))
         if err != nil {
           fmt.Fprintf(w, "Error: %v\n", err)
           return
         }
   
         fmt.Fprintf(w, "Set Color: %s\n", color)
       }
   
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: backendweb
     namespace: backend-team
     labels:
       app: backend
   spec:
     selector:
       matchLabels:
         app: backend
         tier: web
     template:
       metadata:
         labels:
           app: backend
           tier: web
       spec:
         containers:
         - name: backend-container
           image: golang:1.22
           command: ["go"]
           args: ["run", "."]
           workingDir: "/tmp/backend"
           volumeMounts:
             - name: backend-configmap
               mountPath: /tmp/backend/
               readOnly: true
         - name: cloud-sql-proxy
           image: gcr.io/cloud-sql-connectors/cloud-sql-proxy:2.11.4
           args:
             - "--structured-logs"
             - "--port=3306"
             - "$(CONNECTION_NAME_KEY)"
           securityContext:
             runAsNonRoot: true
           env:
           - name: CONNECTION_NAME_KEY
             valueFrom:
               configMapKeyRef:
                 name: database-configmap
                 key: CONNECTION_NAME
         volumes:
           - name: backend-configmap
             configMap: { name: backend-configmap }
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: backendweb
     namespace: backend-team
     labels:
       app: backend
     annotations:
       networking.gke.io/load-balancer-type: "Internal" # Remove to create an external loadbalancer
   spec:
     selector:
       app: backend
       tier: web
     ports:
     - port: 80
       targetPort: 8080
     type: LoadBalancer

   In dieser Datei werden die folgenden Ressourcen beschrieben:

   • Eine Bereitstellung mit einer Beispielanwendung.
   • Einen Dienst vom Typ „LoadBalancer“ Der Dienst gibt das Deployment über Port 80 frei. Konfigurieren Sie einen externen Load Balancer, um Ihre Anwendung im Internet freizugeben. Entfernen Sie dazu die Annotation networking.gke.io/load-balancer-type.

2. Führen Sie in Cloud Shell den folgenden Befehl aus, um sich als das Dienstkonto des Backend-Teams auszugeben:

   gcloud config set auth/impersonate_service_account backend@PROJECT_ID.iam.gserviceaccount.com
   

   Ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID.

3. Rufen Sie die Clusteranmeldedaten ab:

   gcloud container fleet memberships get-credentials gke-enterprise-cluster --location us-central1
   

4. Wenden Sie das Manifest des Backend-Teams auf den Cluster an:

   kubectl apply -f backend.yaml
   

Prüfen, ob die Backend-Anwendung funktioniert

So prüfen Sie, ob der Cluster ordnungsgemäß ausgeführt wird:

1. Rufen Sie in der Google Cloud Console die Seite Arbeitslasten auf:

   Zu Arbeitslasten

2. Klicken Sie auf die Arbeitslast backend. Die Seite mit den Pod-Details wird angezeigt. Diese Seite enthält Informationen zum Pod, z. B. Annotationen, auf dem Pod ausgeführte Container, Dienste, die den Pod verfügbar machen, und Messwerte, darunter CPU-, Arbeitsspeicher- und Laufwerknutzung.

3. Klicken Sie auf den LoadBalancer-Dienst backend. Die Seite mit den Dienstdetails wird angezeigt. Auf dieser Seite werden Informationen zum Dienst angezeigt, z. B. die mit dem Dienst verknüpften Pods und die von den Diensten verwendeten Ports.

4. Klicken Sie im Bereich Endpunkte auf den IPv4-Link, um den Dienst im Browser aufzurufen. Die Ausgabe sieht in etwa so aus:

   Backend!
   Hostname: backendweb-765f6c4fc9-cl7jx
   Set Color: green
   

   Wenn ein Nutzer auf den Back-End-Endpunkt zugreift, wählt der Dienst zufällig eine Farbe aus (rot, grün oder blau) und speichert sie in der freigegebenen Datenbank.

Frontend-Teamanwendung bereitstellen

1. Sehen Sie sich die folgende Terraform-Datei an:

   cat frontend.yaml
   

   Die Ausgabe sollte in etwa so aussehen:

   apiVersion: v1
   kind: ConfigMap
   metadata:
     name: frontend-configmap
     namespace: frontend-team
     labels:
       app: frontend
   data:
     go.mod: |
       module multitenant
   
       go 1.22
   
       require github.com/go-sql-driver/mysql v1.8.1
   
       require filippo.io/edwards25519 v1.1.0 // indirect
   
     go.sum: |
       filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
       filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
       github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpvNJ1Y=
       github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg=
   
     frontend.go: |
       package main
   
       import (
         "database/sql"
         "fmt"
         "log"
         "net/http"
         "os"
   
         _ "github.com/go-sql-driver/mysql"
       )
   
       func main() {
         mux := http.NewServeMux()
         mux.HandleFunc("/", frontend)
   
         port := "8080"
   
         log.Printf("Server listening on port %s", port)
         log.Fatal(http.ListenAndServe(":"+port, mux))
       }
   
       func frontend(w http.ResponseWriter, r *http.Request) {
         log.Printf("Serving request: %s", r.URL.Path)
   
         host, _ := os.Hostname()
         fmt.Fprintf(w, "Frontend!\n")
         fmt.Fprintf(w, "Hostname: %s\n", host)
   
         // Open database using cloud-sql-proxy sidecar
         db, err := sql.Open("mysql", "multitenant-app@tcp/multitenant-app")
         if err != nil {
           fmt.Fprint(w, "Error: %v\n", err)
           return
         }
   
         // Retrieve color from the database
         var color string
         err = db.QueryRow("SELECT metadata_value FROM metadata WHERE metadata_key='color'").Scan(&color)
         switch {
         case err == sql.ErrNoRows:
           fmt.Fprintf(w, "Error: color not found in database\n")
         case err != nil:
           fmt.Fprintf(w, "Error: %v\n", err)
         default:
           fmt.Fprintf(w, "Got Color: %s\n", color)
         }
       }
   
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: frontendweb
     namespace: frontend-team
     labels:
       app: frontend
   spec:
     selector:
       matchLabels:
         app: frontend
         tier: web
     template:
       metadata:
         labels:
           app: frontend
           tier: web
       spec:
         containers:
         - name: frontend-container
           image: golang:1.22
           command: ["go"]
           args: ["run", "."]
           workingDir: "/tmp/frontend"
           volumeMounts:
             - name: frontend-configmap
               mountPath: /tmp/frontend/
               readOnly: true
         - name: cloud-sql-proxy
           image: gcr.io/cloud-sql-connectors/cloud-sql-proxy:2.11.4
           args:
             - "--structured-logs"
             - "--port=3306"
             - "$(CONNECTION_NAME_KEY)"
           securityContext:
             runAsNonRoot: true
           env:
           - name: CONNECTION_NAME_KEY
             valueFrom:
               configMapKeyRef:
                 name: database-configmap
                 key: CONNECTION_NAME
         volumes:
           - name: frontend-configmap
             configMap: { name: frontend-configmap }
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: frontendweb
     namespace: frontend-team
     labels:
       app: frontend
     annotations:
       networking.gke.io/load-balancer-type: "Internal" # Remove to create an external loadbalancer
   spec:
     selector:
       app: frontend
       tier: web
     ports:
     - port: 80
       targetPort: 8080
     type: LoadBalancer

   In dieser Datei werden die folgenden Ressourcen beschrieben:

   • Eine Bereitstellung mit einer Beispielanwendung.
   • Einen Dienst vom Typ „LoadBalancer“ Der Dienst gibt das Deployment über Port 80 frei. Konfigurieren Sie einen externen Load Balancer, um Ihre Anwendung im Internet freizugeben. Entfernen Sie dazu die Annotation networking.gke.io/load-balancer-type.

2. Führen Sie in Cloud Shell den folgenden Befehl aus, um sich als das Dienstkonto des Frontend-Teams auszugeben:

   gcloud config set auth/impersonate_service_account frontend@PROJECT_ID.iam.gserviceaccount.com
   

   Ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID.

3. Rufen Sie die Clusteranmeldedaten ab:

   gcloud container fleet memberships get-credentials gke-enterprise-cluster --location us-central1
   

4. Wenden Sie das Manifest des Frontend-Teams auf den Cluster an:

   kubectl apply -f frontend.yaml
   

Prüfen, ob die Front-End-Anwendung funktioniert

So prüfen Sie, ob der Cluster ordnungsgemäß ausgeführt wird:

1. Rufen Sie in der Google Cloud Console die Seite Arbeitslasten auf:

   Zu Arbeitslasten

2. Klicken Sie auf die Arbeitslast frontend. Die Seite mit den Pod-Details wird angezeigt. Diese Seite enthält Informationen zum Pod, z. B. Annotationen, auf dem Pod ausgeführte Container, Dienste, die den Pod verfügbar machen, und Messwerte, darunter CPU-, Arbeitsspeicher- und Laufwerknutzung.

3. Klicken Sie auf den LoadBalancer-Dienst frontend. Die Seite mit den Dienstdetails wird angezeigt. Auf dieser Seite werden Informationen zum Dienst angezeigt, z. B. die mit dem Dienst verknüpften Pods und die von den Diensten verwendeten Ports.

4. Klicken Sie im Bereich Endpunkte auf den IPv4-Link, um den Dienst im Browser aufzurufen. Die Ausgabe sieht in etwa so aus:

   Frontend!
   Hostname: frontendweb-5cd888d88f-gwwtc
   Got Color: green
   

Bereinigen

Mit den folgenden Schritten vermeiden Sie, dass Ihrem Google Cloud -Konto die in dieser Anleitung verwendeten Ressourcen in Rechnung gestellt werden:

1. Führen Sie in Cloud Shell den folgenden Befehl aus, um die Identitätsdiebstahl-Funktion für Dienstkonten zurückzusetzen:

   gcloud config unset auth/impersonate_service_account
   

2. Führen Sie den folgenden Befehl aus, um die Terraform-Ressourcen zu löschen:

   terraform destroy --auto-approve
   

Nächste Schritte

• Terraform-Ressourcen für GKE

• Im GitHub-Repository für Terraform GKE-Module finden Sie zielgerichtete Konfigurationsbeispiele.