Esta página foi traduzida pela API Cloud Translation.

Crie um cluster multiinquilino com o Terraform

Um cluster multi-inquilino no Google Kubernetes Engine é um cluster do Kubernetes partilhado por várias equipas ou utilizadores distintos, conhecidos como inquilinos. Normalmente, cada inquilino tem o seu próprio conjunto de recursos e aplicações no cluster.

Este tutorial do Terraform permite-lhe criar rapidamente um cluster do GKE partilhado por duas equipas, backend e frontend, que podem implementar cargas de trabalho específicas da equipa no cluster. Este tutorial pressupõe que já tem familiaridade com o Terraform. Caso contrário, pode usar os seguintes recursos para se familiarizar com os conceitos básicos do Terraform:

Introdução ao Terraform (vídeo)
Comandos do Terraform

Antes de começar

Siga os passos abaixo para ativar a API 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.

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 (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

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.

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 (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

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.

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

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

Check for the roles

In the Google Cloud console, go to the IAM page.
Go to IAM
Select the project.
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.
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

In the Google Cloud console, go to the IAM page.
Aceder ao IAM
Selecione o projeto.
Clique em Conceder acesso.
No campo Novos responsáveis, introduza o identificador do utilizador. Normalmente, este é o endereço de email de uma Conta Google.
Na lista Selecionar uma função, selecione uma função.
Para conceder funções adicionais, clique em Adicionar outra função e adicione cada função adicional.
Clique em Guardar.

Prepare o ambiente

Neste tutorial, vai usar o Cloud Shell para gerir recursos alojados no Google Cloud. O Cloud Shell está pré-instalado com o software necessário para este tutorial, incluindo o Terraform, o kubectl e a CLI do Google Cloud.

Inicie uma sessão do Cloud Shell a partir da Google Cloud consola clicando no ícone de ativação do Cloud Shell Ativar Cloud Shell . Esta ação inicia uma sessão no painel inferior da Google Cloud consola.

As credenciais de serviço associadas a esta máquina virtual são automáticas, pelo que não tem de configurar nem transferir uma chave de conta de serviço.
Antes de executar comandos, defina o seu projeto predefinido na CLI gcloud com o seguinte comando:
```
gcloud config set project PROJECT_ID
```
Substitua PROJECT_ID pelo seu ID do projeto.

Clone o repositório do GitHub:

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

Mude para o diretório de trabalho:

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

Reveja os ficheiros do Terraform

O Google Cloud fornecedor é um plug-in que lhe permite gerir e aprovisionar Google Cloud recursos através do Terraform. Serve como uma ponte entre as configurações do Terraform e as Google Cloud APIs, permitindo-lhe definir declarativamente recursos de infraestrutura, como máquinas virtuais e redes.

Reveja o ficheiro main.tf, que descreve um recurso de cluster do GKE:

cat main.tf

O resultado é semelhante ao seguinte:

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
}

Crie um cluster e uma base de dados SQL

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

terraform

O resultado deve ser semelhante ao seguinte:

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

Inicialize o Terraform:
```
terraform init
```
Opcional: planeie a configuração do Terraform:
```
terraform plan
```
Aplique a configuração do Terraform
```
terraform apply
```
Quando lhe for pedido, introduza yes para confirmar as ações. Este comando pode demorar vários minutos a ser concluído. O resultado é semelhante ao seguinte:
```
Apply complete! Resources: 23 added, 0 changed, 0 destroyed.
```

Implemente a aplicação da equipa de back-end

Reveja o seguinte ficheiro do Terraform:

cat backend.yaml

O resultado deve ser semelhante ao seguinte:

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 ficheiro descreve os seguintes recursos:

Uma implementação com uma aplicação de exemplo.
Um serviço do tipo LoadBalancer. O serviço expõe a implementação na porta 80. Para expor a sua aplicação à Internet, configure um balanceador de carga externo removendo a anotação networking.gke.io/load-balancer-type.

No Cloud Shell, execute o seguinte comando para se fazer passar pela conta de serviço da equipa de back-end:
```
gcloud config set auth/impersonate_service_account backend@PROJECT_ID.iam.gserviceaccount.com
```
Substitua PROJECT_ID pelo seu ID do projeto.

Obtenha as credenciais do cluster:

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

Aplique o manifesto da equipa de back-end ao cluster:
```
kubectl apply -f backend.yaml
```

Verifique se a aplicação de back-end está a funcionar

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

Aceda à página Workloads na Google Cloud consola:

Aceda a Cargas de trabalho
Clique na carga de trabalho backend. É apresentada a página de detalhes do podcast. Esta página mostra informações sobre o Pod, como anotações, contentores em execução no Pod, serviços que expõem o Pod e métricas, incluindo a utilização da CPU, da memória e do disco.
Clique no backend serviço LoadBalancer. É apresentada a página Detalhes do serviço. Esta página mostra informações sobre o Serviço, como os pods associados ao Serviço e as portas que o Serviço usa.
Na secção Pontos finais, clique no link IPv4 para ver o seu serviço no navegador. O resultado é semelhante ao seguinte:
```
Backend!
Hostname: backendweb-765f6c4fc9-cl7jx
Set Color: green
```
Sempre que um utilizador acede ao ponto final de back-end, o serviço escolhe aleatoriamente e armazena uma cor entre vermelho, verde ou azul na base de dados partilhada.

Implemente uma aplicação de equipa de front-end

Reveja o seguinte ficheiro do Terraform:

cat frontend.yaml

O resultado deve ser semelhante ao seguinte:

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 ficheiro descreve os seguintes recursos:

Uma implementação com uma aplicação de exemplo.
Um serviço do tipo LoadBalancer. O serviço expõe a implementação na porta 80. Para expor a sua aplicação à Internet, configure um balanceador de carga externo removendo a anotação networking.gke.io/load-balancer-type.

No Cloud Shell, execute o seguinte comando para se fazer passar pela conta de serviço da equipa de frontend:
```
gcloud config set auth/impersonate_service_account frontend@PROJECT_ID.iam.gserviceaccount.com
```
Substitua PROJECT_ID pelo seu ID do projeto.

Obtenha as credenciais do cluster:

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

Aplique o manifesto da equipa de front-end ao cluster:
```
kubectl apply -f frontend.yaml
```

Verifique se a aplicação de front-end está a funcionar

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

Aceda à página Workloads na Google Cloud consola:

Aceda a Cargas de trabalho
Clique na carga de trabalho frontend. É apresentada a página de detalhes do podcast. Esta página mostra informações sobre o Pod, como anotações, contentores em execução no Pod, serviços que expõem o Pod e métricas, incluindo a utilização da CPU, da memória e do disco.
Clique no frontend serviço LoadBalancer. É apresentada a página Detalhes do serviço. Esta página mostra informações sobre o Serviço, como os pods associados ao Serviço e as portas que o Serviço usa.
Na secção Pontos finais, clique no link IPv4 para ver o seu serviço no navegador. O resultado é semelhante ao seguinte:
```
Frontend!
Hostname: frontendweb-5cd888d88f-gwwtc
Got Color: green
```

Limpar

Para evitar incorrer em cobranças na sua Google Cloud conta pelos recursos usados nesta página, siga estes passos.

No Cloud Shell, execute este comando para anular a representação da conta de serviço:
```
gcloud config unset auth/impersonate_service_account
```
Execute o seguinte comando para eliminar os recursos do Terraform:
```
terraform destroy --auto-approve
```

O que se segue?

Explore os recursos do Terraform para o GKE.
Explore exemplos de configuração opinativos no repositório do GitHub do módulo do Terraform GKE.