Creare un cluster multi-tenant utilizzando Terraform

Creare un cluster multi-tenant utilizzando Terraform

Un cluster multi-tenant in Google Kubernetes Engine è un cluster Kubernetes condiviso da più team o utenti distinti, noti come tenant. In genere, ogni tenant ha il proprio insieme di risorse e applicazioni all'interno del cluster.

Questo tutorial di Terraform ti consente di creare rapidamente un cluster GKE condiviso da due team, backend e frontend, che possono eseguire il deployment di workload specifici del team sul cluster. Questo tutorial presuppone che tu abbia già familiarità con Terraform. In caso contrario, puoi utilizzare le seguenti risorse per acquisire familiarità con le nozioni di base di Terraform:

• Inizia a utilizzare Terraform (video)
• Comandi Terraform

Che cos'è Terraform? Infrastructure as Code (IaC) è una pratica di gestione e provisioning delle risorse dell'infrastruttura software utilizzando il codice. Terraform è un popolare strumento IaC open source creato da HashiCorp che supporta una vasta gamma di servizi cloud, tra cui GKE. In qualità di amministratore della piattaforma GKE, puoi utilizzare Terraform per standardizzare la configurazione dei cluster Kubernetes in produzione e semplificare i flussi di lavoro DevOps. Per saperne di più, consulta Supporto di Terraform per GKE.

Prima di iniziare

Per abilitare l'API Kubernetes Engine, segui questi passaggi:

Accedi al tuo Google Cloud account. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti senza costi per l'esecuzione, il test e il deployment dei workload.

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

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

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

Verify that billing is enabled for your Google Cloud project.

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

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

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

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

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

Verify that billing is enabled for your Google Cloud project.

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

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

1. Assicurati di disporre dei seguenti ruoli per il progetto: roles/owner, roles/iam.serviceAccountTokenCreator

   Controlla i ruoli

   1. Nella Google Cloud console vai alla pagina IAM.

      Vai a IAM
   2. Seleziona il progetto.

   3. Nella colonna Entità, trova tutte le righe che identificano te o un gruppo di cui fai parte. Per scoprire i gruppi di cui fai parte, contatta l' amministratore.

   4. Per tutte le righe che ti specificano o ti includono, controlla la colonna Ruolo per verificare se l'elenco dei ruoli include i ruoli richiesti.

   Concedi i ruoli

   1. Nella Google Cloud console vai alla pagina IAM.

      Vai a IAM
   2. Seleziona il progetto.
   3. Fai clic su Concedi l'accesso.

   4. Nel campo Nuove entità, inserisci il tuo identificatore dell'utente. In genere si tratta dell'indirizzo email di un Account Google.

   5. Fai clic su Seleziona un ruolo, quindi cerca il ruolo.
   6. Per concedere altri ruoli, fai clic su Aggiungi un altro ruolo e aggiungi ogni ruolo aggiuntivo.
   7. Fai clic su Salva.

Prepara l'ambiente

In questo tutorial utilizzerai Cloud Shell per gestire le risorse ospitate su Google Cloud. Cloud Shell è preinstallato con il software necessario per questo tutorial, tra cui Terraform, kubectl, e il il Google Cloud CLI.

1. Avvia una sessione di Cloud Shell dalla Google Cloud console facendo clic sull'icona di attivazione di Cloud Shell Attiva Cloud Shell . Viene avviata una sessione nel riquadro inferiore della Google Cloud console.

   Le credenziali del servizio associate a questa macchina virtuale sono automatiche, quindi non devi configurare o scaricare una chiave del account di servizio.

2. Prima di eseguire i comandi, imposta il progetto predefinito in gcloud CLI utilizzando il comando seguente:

   gcloud config set project PROJECT_ID
   

   Sostituisci PROJECT_ID con l' ID progetto.

3. Clona il repository GitHub:

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

4. Passa alla directory di lavoro:

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

Esamina i file Terraform

Il Google Cloud provider è un plug-in che consente di gestire ed eseguire il provisioning delle Google Cloud risorse utilizzando Terraform. Funge da ponte tra le configurazioni Terraform e le Google Cloud API, consentendoti di definire in modo dichiarativo le risorse dell'infrastruttura, come macchine virtuali e reti.

1. Esamina il file main.tf, che descrive una risorsa del cluster GKE:

   cat main.tf
   

   L'output è simile al seguente:

   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
   }

Crea un cluster e un database SQL

1. In Cloud Shell, esegui questo comando per verificare che Terraform sia disponibile:

   terraform
   

   L'output dovrebbe essere simile al seguente:

   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. Inizializza Terraform:

   terraform init
   

3. (Facoltativo) Pianifica la configurazione Terraform:

   terraform plan
   

4. Applica la configurazione Terraform

   terraform apply
   

   Quando richiesto, inserisci yes per confermare le azioni. Il completamento di questo comando potrebbe richiedere diversi minuti. L'output è simile al seguente:

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

Esegui il deployment dell'applicazione del team di backend

1. Esamina il seguente file Terraform:

   cat backend.yaml
   

   L'output dovrebbe essere simile al seguente:

   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

   Questo file descrive le seguenti risorse:

   • Un deployment con un'applicazione di esempio.
   • Un servizio di tipo LoadBalancer. Il servizio espone il deployment sulla porta 80. Per esporre l'applicazione a internet, configura un bilanciatore del carico esterno rimuovendo l'annotazione networking.gke.io/load-balancer-type.

2. In Cloud Shell, esegui questo comando per rappresentare il account di servizio del team di backend:

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

   Sostituisci PROJECT_ID con l' ID progetto.

3. Recupera le credenziali del cluster:

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

4. Applica il manifest del team di backend al cluster:

   kubectl apply -f backend.yaml
   

Verifica che l'applicazione di backend funzioni

Per verificare che il cluster sia in esecuzione correttamente:

1. Vai alla pagina Carichi di lavoro nella Google Cloud console:

   Vai a Carichi di lavoro

2. Fai clic sul workload backend. Viene visualizzata la pagina dei dettagli del pod. Questa pagina mostra informazioni sul pod, come annotazioni, container in esecuzione sul pod, servizi che espongono il pod e metriche tra cui utilizzo di CPU, memoria e disco.

3. Fai clic sul servizio LoadBalancer backend. Viene visualizzata la pagina dei dettagli del servizio. Questa pagina mostra informazioni sul servizio, come i pod associati al servizio e le porte utilizzate dai servizi.

4. Nella sezione Endpoint, fai clic sul link IPv4 per visualizzare il servizio nel browser. L'output è simile al seguente:

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

   Ogni volta che un utente accede all'endpoint di backend, il servizio seleziona e memorizza in modo casuale un colore tra rosso, verde o blu nel database condiviso.

Esegui il deployment di un'applicazione del team di frontend

1. Esamina il seguente file Terraform:

   cat frontend.yaml
   

   L'output dovrebbe essere simile al seguente:

   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

   Questo file descrive le seguenti risorse:

   • Un deployment con un'applicazione di esempio.
   • Un servizio di tipo LoadBalancer. Il servizio espone il deployment sulla porta 80. Per esporre l'applicazione a internet, configura un bilanciatore del carico esterno rimuovendo l'annotazione networking.gke.io/load-balancer-type.

2. In Cloud Shell, esegui questo comando per rappresentare il account di servizio del team di frontend:

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

   Sostituisci PROJECT_ID con l' ID progetto.

3. Recupera le credenziali del cluster:

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

4. Applica il manifest del team di frontend al cluster:

   kubectl apply -f frontend.yaml
   

Verifica che l'applicazione di frontend funzioni

Per verificare che il cluster sia in esecuzione correttamente:

1. Vai alla pagina Carichi di lavoro nella Google Cloud console:

   Vai a Carichi di lavoro

2. Fai clic sul workload frontend. Viene visualizzata la pagina dei dettagli del pod. Questa pagina mostra informazioni sul pod, come annotazioni, container in esecuzione sul pod, servizi che espongono il pod e metriche tra cui utilizzo di CPU, memoria e disco.

3. Fai clic sul servizio LoadBalancer frontend. Viene visualizzata la pagina dei dettagli del servizio. Questa pagina mostra informazioni sul servizio, come i pod associati al servizio e le porte utilizzate dai servizi.

4. Nella sezione Endpoint, fai clic sul link IPv4 per visualizzare il servizio nel browser. L'output è simile al seguente:

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

Libera spazio

Per evitare che al tuo Google Cloud account vengano addebitati costi relativi alle risorse utilizzate in questa pagina, segui questi passaggi.

1. In Cloud Shell, esegui questo comando per annullare la simulazione dell'identità dei account di servizio:

   gcloud config unset auth/impersonate_service_account
   

2. Esegui questo comando per eliminare le risorse Terraform:

   terraform destroy --auto-approve
   

Passaggi successivi

• Esplora le risorse Terraform per GKE.

• Esplora gli esempi di configurazione basati su opinioni nel repository GitHub del modulo Terraform GKE.