Esta página se ha traducido con Cloud Translation API.

Crear un clúster multicliente con Terraform

Un clúster multi-tenant en Google Kubernetes Engine es un clúster de Kubernetes compartido por varios equipos o usuarios distintos, denominados tenants. Cada propietario suele tener su propio conjunto de recursos y aplicaciones en el clúster.

En este tutorial de Terraform se explica cómo crear rápidamente un clúster de GKE compartido por dos equipos, backend y frontend, que pueden desplegar cargas de trabajo específicas de cada equipo en el clúster. En este tutorial se da por hecho que ya conoces Terraform. Si no es así, puedes usar los siguientes recursos para familiarizarte con los conceptos básicos de Terraform:

Empezar a usar Terraform (vídeo)
Comandos de Terraform

Antes de empezar

Sigue estos pasos para habilitar la API de 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.
Ir a IAM
Selecciona el proyecto.
Haz clic en Conceder acceso.
En el campo Nuevos principales, introduce tu identificador de usuario. Normalmente, se trata de la dirección de correo de una cuenta de Google.
En la lista Selecciona un rol, elige un rol.
Para conceder más roles, haz clic en Añadir otro rol y añade cada rol adicional.
Haz clic en Guardar.

Preparar el entorno

En este tutorial, usarás Cloud Shell para gestionar los recursos alojados enGoogle Cloud. Cloud Shell tiene preinstalado el software que necesitas para este tutorial, como Terraform, kubectl y Google Cloud CLI.

Inicia una sesión de Cloud Shell desde la consola Google Cloud haciendo clic en el icono de activación de Cloud Shell Activar Cloud Shell . De esta forma, se inicia una sesión en el panel inferior de la consola Google Cloud .

Las credenciales de servicio asociadas a esta máquina virtual son automáticas, por lo que no tienes que configurar ni descargar una clave de cuenta de servicio.
Antes de ejecutar comandos, define tu proyecto predeterminado en la CLI de gcloud con el siguiente comando:
```
gcloud config set project PROJECT_ID
```
Sustituye PROJECT_ID por el ID de tu proyecto.

Clona el repositorio de GitHub:

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

Cambia al directorio de trabajo:

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

Revisar los archivos de Terraform

El Google Cloud proveedor es un complemento que te permite gestionar y aprovisionar Google Cloud recursos con Terraform. Actúa como puente entre las configuraciones de Terraform y las APIs deGoogle Cloud , lo que te permite definir de forma declarativa recursos de infraestructura, como máquinas virtuales y redes.

Consulta el archivo main.tf, que describe un recurso de clúster de GKE:

cat main.tf

El resultado debería ser similar al siguiente:

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
}

Crear un clúster y una base de datos SQL

En Cloud Shell, ejecuta este comando para verificar que Terraform está disponible:

terraform

La salida debería ser similar a la siguiente:

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

Inicializa Terraform:
```
terraform init
```
Opcional: Planifica la configuración de Terraform:
```
terraform plan
```
Aplica la configuración de Terraform
```
terraform apply
```
Cuando se te solicite, introduce yes para confirmar las acciones. Este comando puede tardar varios minutos en completarse. El resultado debería ser similar al siguiente:
```
Apply complete! Resources: 23 added, 0 changed, 0 destroyed.
```

Desplegar la aplicación del equipo de backend

Revisa el siguiente archivo de Terraform:

cat backend.yaml

La salida debería ser similar a la siguiente:

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

En este archivo se describen los siguientes recursos:

Una implementación con una aplicación de ejemplo.
Un servicio de tipo LoadBalancer. El servicio expone el Deployment en el puerto 80. Para exponer tu aplicación en Internet, configura un balanceador de carga externo quitando la anotación networking.gke.io/load-balancer-type.

En Cloud Shell, ejecuta el siguiente comando para suplantar la cuenta de servicio del equipo de backend:
```
gcloud config set auth/impersonate_service_account backend@PROJECT_ID.iam.gserviceaccount.com
```
Sustituye PROJECT_ID por el ID de tu proyecto.

Obtén las credenciales del clúster:

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

Aplica el manifiesto del equipo de backend al clúster:
```
kubectl apply -f backend.yaml
```

Verificar que la aplicación backend funciona

Para confirmar que el clúster se está ejecutando correctamente, haz lo siguiente:

Ve a la página Cargas de trabajo de la Google Cloud consola:

Ve a Cargas de trabajo.
Haz clic en la carga de trabajo backend. Se muestra la página de detalles del pod. En esta página se muestra información sobre el pod, como las anotaciones, los contenedores que se ejecutan en el pod, los servicios que exponen el pod y las métricas, incluido el uso de CPU, memoria y disco.
Haz clic en el backend servicio LoadBalancer. Se mostrará la página Detalles del servicio. En esta página se muestra información sobre el servicio, como los pods asociados al servicio y los puertos que utiliza.
En la sección Endpoints (Endpoints), haz clic en el enlace IPv4 para ver tu servicio en el navegador. El resultado debería ser similar al siguiente:
```
Backend!
Hostname: backendweb-765f6c4fc9-cl7jx
Set Color: green
```
Cada vez que un usuario accede al endpoint de backend, el servicio elige y almacena aleatoriamente un color (rojo, verde o azul) en la base de datos compartida.

Desplegar una aplicación de equipo de frontend

Revisa el siguiente archivo de Terraform:

cat frontend.yaml

La salida debería ser similar a la siguiente:

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

En este archivo se describen los siguientes recursos:

Una implementación con una aplicación de ejemplo.
Un servicio de tipo LoadBalancer. El servicio expone el Deployment en el puerto 80. Para exponer tu aplicación en Internet, configura un balanceador de carga externo quitando la anotación networking.gke.io/load-balancer-type.

En Cloud Shell, ejecuta el siguiente comando para suplantar la cuenta de servicio del equipo de frontend:
```
gcloud config set auth/impersonate_service_account frontend@PROJECT_ID.iam.gserviceaccount.com
```
Sustituye PROJECT_ID por el ID de tu proyecto.

Obtén las credenciales del clúster:

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

Aplica el manifiesto del equipo de frontend al clúster:
```
kubectl apply -f frontend.yaml
```

Verificar que la aplicación frontend funciona

Para confirmar que el clúster se está ejecutando correctamente, haz lo siguiente:

Ve a la página Cargas de trabajo de la Google Cloud consola:

Ve a Cargas de trabajo.
Haz clic en la carga de trabajo frontend. Se muestra la página de detalles del pod. En esta página se muestra información sobre el pod, como las anotaciones, los contenedores que se ejecutan en el pod, los servicios que exponen el pod y las métricas, incluido el uso de CPU, memoria y disco.
Haz clic en el frontend servicio LoadBalancer. Se mostrará la página Detalles del servicio. En esta página se muestra información sobre el servicio, como los pods asociados al servicio y los puertos que utiliza.
En la sección Endpoints (Endpoints), haz clic en el enlace IPv4 para ver tu servicio en el navegador. El resultado debería ser similar al siguiente:
```
Frontend!
Hostname: frontendweb-5cd888d88f-gwwtc
Got Color: green
```

Limpieza

Para evitar que se apliquen cargos en tu cuenta de Google Cloud por los recursos utilizados en esta página, sigue estos pasos.

En Cloud Shell, ejecuta este comando para anular la suplantación de identidad de la cuenta de servicio:
```
gcloud config unset auth/impersonate_service_account
```
Ejecuta el siguiente comando para eliminar los recursos de Terraform:
```
terraform destroy --auto-approve
```

Siguientes pasos

Consulta los recursos de Terraform para GKE.
Consulta ejemplos de configuración con opiniones en el repositorio de GitHub del módulo de Terraform GKE.