Criar um cluster multitenant usando o Terraform

Criar um cluster multitenant usando o Terraform

Um cluster multilocatário na edição Enterprise do Google Kubernetes Engine (GKE) é um cluster do Kubernetes compartilhado por várias equipes ou usuários distintos, conhecidos como locatários. Cada locatário geralmente tem o próprio conjunto de recursos e aplicativos no cluster.

Com este tutorial do Terraform, você cria rapidamente um cluster do GKE Enterprise compartilhado por duas equipes, backend e frontend, que podem implantar cargas de trabalho específicas da equipe no cluster. Neste tutorial, presumimos que você já conhece o Terraform. Caso contrário, use os seguintes recursos para conhecer os conceitos básicos do Terraform:

• Primeiras etapas com o Terraform (vídeo)
• Comandos do Terraform

O que é o Terraform? A infraestrutura como código (IaC) é 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 em produção e otimizar os fluxos de trabalho de DevOps. Para saber mais, consulte Suporte do Terraform para GKE.

Antes de começar

Siga estas etapas para ativar a API do Kubernetes Engine:

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.

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

Verify that billing is enabled for your Google Cloud project.

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

Enable the APIs

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

Verify that billing is enabled for your Google Cloud project.

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

Enable the APIs

1. 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.

      Acessar o 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. Na lista Selecionar papel, escolha um.
   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ê vai 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 Google Cloud CLI.

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

      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 serve como uma ponte entre as configurações do Terraform e as APIs doGoogle Cloud , permitindo que você defina de maneira declarativa recursos de infraestrutura, como máquinas virtuais e redes.

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

      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. Analise o seguinte arquivo do Terraform:

      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 à Internet, configure um balanceador de carga externo removendo a anotação networking.gke.io/load-balancer-type.

   2. No Cloud Shell, execute o seguinte comando 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 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 console Google Cloud :

      Acesse "Cargas de trabalho"

   2. Clique na carga de trabalho backend. A página "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 "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 ver 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 de equipe de front-end

   1. Analise o seguinte arquivo do Terraform:

      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 à 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 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 console Google Cloud :

      Acesse "Cargas de trabalho"

   2. Clique na carga de trabalho frontend. A página "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 "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 ver seu serviço no navegador. O resultado será assim:

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

   Limpar

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

   1. No Cloud Shell, execute este comando para cancelar a representação da 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 do GitHub do módulo Terraform GKE.