Criar um cluster multilocatário usando o Terraform

Criar um cluster multilocatário usando o Terraform

Um cluster multilocatário no Google Kubernetes Engine é um cluster do Kubernetes compartilhado por várias equipes ou usuários distintos, conhecidos como locatários. Cada locatário geralmente tem seu próprio conjunto de recursos e aplicativos no cluster.

Este tutorial do Terraform permite criar rapidamente um cluster do GKE compartilhado por duas equipes, backend e frontend, que podem implantar cargas de trabalho específicas da equipe no cluster. Este tutorial pressupõe que você já esteja familiarizado com o Terraform. Caso contrário, use os recursos a seguir para conhecer os conceitos básicos do Terraform:

• Introdução ao Terraform (vídeo, link em inglês)
• Comandos do Terraform

O que é o Terraform? A infraestrutura como código (IaC, na sigla em inglês) é uma prática de gerenciamento e provisionamento de recursos de infraestrutura de software usando código. O Terraform é uma ferramenta de IaC de código aberto conhecida, criada pela HashiCorp, que dá suporte a uma ampla variedade de serviços do Cloud, incluindo o GKE. Como administrador da plataforma GKE, é possível usar o Terraform para padronizar a configuração dos clusters do Kubernetes e otimizar os fluxos de trabalho de DevOps. Para saber mais, consulte o suporte do Terraform para o GKE.

Antes de começar

Siga estas etapas para ativar a API Kubernetes Engine:

Faça login na sua Google Cloud conta do. Se você começou a usar o Google Cloud, crie uma conta para avaliar o desempenho dos nossos produtos em situações reais. Clientes novos também recebem US $300 em créditos para executar, testar e implantar cargas de trabalho.

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. Verifique se você tem os seguintes papéis no projeto: roles/owner, roles/iam.serviceAccountTokenCreator

   Verificar os papéis

   1. No Google Cloud console, acesse a página IAM.

      Acessar IAM
   2. Selecione o projeto.

   3. Na coluna Principal, encontre todas as linhas que identificam você ou um grupo no qual você está incluído. Para saber em quais grupos você está incluído, entre em contato com o administrador.

   4. Em todas as linhas que especificam ou incluem você, verifique a coluna Papel para ver se a lista de papéis inclui os papéis necessários.

   Conceder os papéis

   1. No Google Cloud console, acesse a página IAM.

      Acessar IAM
   2. Selecione o projeto.
   3. Clique em Conceder acesso.

   4. No campo Novos principais, digite seu identificador de usuário. Normalmente, é o endereço de e-mail de uma Conta do Google.

   5. Clique em Selecionar um papel e pesquise o papel.
   6. Para conceder outros papéis, clique em Adicionar outro papel e adicione cada papel adicional.
   7. Clique em Salvar.

Prepare o ambiente

Neste tutorial, você usará o Cloud Shell para gerenciar recursos hospedados no Google Cloud. O Cloud Shell vem pré-instalado com o software necessário para este tutorial, incluindo Terraform, kubectl, e a a Google Cloud CLI.

1. Inicie uma sessão do Cloud Shell no Google Cloud console clicando no ícone de ativação Ativar o Cloud Shell . Isso inicia uma sessão no painel inferior do Google Cloud console.

   As credenciais de serviço associadas a essa máquina virtual são automáticas. Dessa forma, não é necessário configurar nem fazer o download de uma chave de conta de serviço.

2. Antes de executar comandos, defina o projeto padrão na CLI gcloud usando o seguinte comando:

   gcloud config set project PROJECT_ID
   

   Substitua PROJECT_ID pelo ID do projeto.

3. Clone o repositório do GitHub:

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

4. Mude para o diretório de trabalho:

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

Revisar os arquivos do Terraform

O Google Cloud provedor é um plug-in que permite gerenciar e provisionar Google Cloud recursos usando o Terraform. Ele atua como uma ponte entre as configurações do Terraform e Google Cloud APIs, permitindo a definição de recursos de infraestrutura como máquinas virtuais e redes, de maneira declarativa.

1. Revise o arquivo main.tf, que descreve um recurso de cluster do GKE:

   cat main.tf
   

   O resultado será assim:

   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
   }

Criar um cluster e um banco de dados SQL

1. No Cloud Shell, execute este comando para verificar se o Terraform está disponível:

   terraform
   

   A saída será semelhante a esta:

   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. Inicialize o Terraform:

   terraform init
   

3. Opcional: planeje a configuração do Terraform:

   terraform plan
   

4. Aplique a configuração do Terraform:

   terraform apply
   

   Quando solicitado, digite yes para confirmar as ações. Esse comando pode levar alguns minutos para ser concluído. O resultado será assim:

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

Implantar o aplicativo da equipe de back-end

1. Revise o arquivo do Terraform a seguir:

   cat backend.yaml
   

   A saída será semelhante a esta:

   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

   Este arquivo descreve os seguintes recursos:

   • Uma implantação com um aplicativo de amostra.
   • Um serviço do tipo LoadBalancer. O serviço expõe a implantação na porta 80. Para expor seu aplicativo na Internet, configure um balanceador de carga externo removendo a anotação networking.gke.io/load-balancer-type.

2. No Cloud Shell, execute o comando a seguir para representar a conta de serviço da equipe de back-end:

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

   Substitua PROJECT_ID pelo seu ID do projeto.

3. Recupere as credenciais do cluster:

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

4. Aplique o manifesto da equipe de back-end ao cluster:

   kubectl apply -f backend.yaml
   

Verificar se o aplicativo de back-end está funcionando

Faça o seguinte para confirmar se o cluster está sendo executado corretamente:

1. Acesse a página Cargas de trabalho no Google Cloud console:

   Acesse "Cargas de trabalho"

2. Clique na carga de trabalho backend. A página de detalhes do pod é exibida. Essa página mostra informações sobre o pod, como anotações, contêineres em execução nele, serviços que expõem o pod e métricas, incluindo uso de CPU, memória e disco.

3. Clique no serviço LoadBalancer backend. A página de detalhes do serviço é exibida. Nesta página, mostramos informações sobre o serviço, como os pods associados a ele e as portas que os serviços usam.

4. Na seção Endpoints, clique no link IPv4 para exibir seu serviço no navegador. O resultado será assim:

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

   Sempre que um usuário acessa o endpoint de back-end, o serviço escolhe e armazena aleatoriamente uma cor (vermelho, verde ou azul) no banco de dados compartilhado.

Implantar um aplicativo da equipe de front-end

1. Revise o arquivo do Terraform a seguir:

   cat frontend.yaml
   

   A saída será semelhante a esta:

   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

   Este arquivo descreve os seguintes recursos:

   • Uma implantação com um aplicativo de amostra.
   • Um serviço do tipo LoadBalancer. O serviço expõe a implantação na porta 80. Para expor seu aplicativo na Internet, configure um balanceador de carga externo removendo a anotação networking.gke.io/load-balancer-type.

2. No Cloud Shell, execute o comando a seguir para representar a conta de serviço da equipe de front-end:

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

   Substitua PROJECT_ID pelo seu ID do projeto.

3. Recupere as credenciais do cluster:

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

4. Aplique o manifesto da equipe de front-end ao cluster:

   kubectl apply -f frontend.yaml
   

Verificar se o aplicativo de front-end está funcionando

Faça o seguinte para confirmar se o cluster está sendo executado corretamente:

1. Acesse a página Cargas de trabalho no Google Cloud console:

   Acesse "Cargas de trabalho"

2. Clique na carga de trabalho frontend. A página de detalhes do pod é exibida. Essa página mostra informações sobre o pod, como anotações, contêineres em execução nele, serviços que expõem o pod e métricas, incluindo uso de CPU, memória e disco.

3. Clique no serviço LoadBalancer frontend. A página de detalhes do serviço é exibida. Nesta página, mostramos informações sobre o serviço, como os pods associados a ele e as portas que os serviços usam.

4. Na seção Endpoints, clique no link IPv4 para exibir seu serviço no navegador. O resultado será assim:

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

Limpar

Para evitar cobranças na conta do Google Cloud pelos recursos usados nesta página, siga as etapas abaixo.

1. No Cloud Shell, execute este comando para cancelar a identidade temporária de conta de serviço:

   gcloud config unset auth/impersonate_service_account
   

2. Execute o seguinte comando para excluir os recursos do Terraform:

   terraform destroy --auto-approve
   

A seguir

• Confira os recursos do Terraform para o GKE.

• Confira exemplos de configuração no repositório GitHub do módulo Terraform GKE (link em inglês).