Se usó la API de Cloud Translation para traducir esta página.

Crea un clúster multiusuario con Terraform

Un clúster multiusuario en la edición Enterprise de Google Kubernetes Engine (GKE) es un clúster de Kubernetes que comparten varios equipos o usuarios distintos, conocidos como usuarios. Por lo general, cada usuario tiene su propio conjunto de recursos y aplicaciones dentro del clúster.

En este instructivo de Terraform, puedes crear rápidamente un clúster de GKE Enterprise que comparten dos equipos, backend y frontend, que pueden implementar cargas de trabajo específicas del equipo en el clúster. En este instructivo, se supone que ya conoces Terraform. De lo contrario, puedes usar los siguientes recursos para familiarizarte con los conceptos básicos de Terraform:

Comienza a usar Terraform (video)
Comandos de Terraform

Antes de comenzar

Sigue los pasos que se indican a continuación 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.

Go to project selector

Make sure 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.

Go to project selector

Make sure 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

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.
  Ir a IAM
2. Selecciona el proyecto.
3. Haz clic en Grant access.
4. En el campo Principales nuevas, ingresa tu identificador de usuario. Esta suele ser la dirección de correo electrónico de una Cuenta de Google.
5. En la lista Seleccionar un rol, elige un rol.
6. Para otorgar funciones adicionales, haz clic en Agregar otro rol y agrega cada rol adicional.
7. Haz clic en Guardar.

Prepare el entorno

En este instructivo, usarás Cloud Shell para administrar recursos alojados en Google Cloud. Cloud Shell tiene preinstalado el software que necesitas para este instructivo, incluidos Terraform, kubectl y Google Cloud CLI.

Para iniciar una sesión de Cloud Shell desde la consola de Google Cloud, haz clic en el ícono de activación de Cloud Shell Activar Cloud Shell . Esto inicia una sesión en el panel inferior de la consola de 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, configura tu proyecto predeterminado en gcloud CLI con el siguiente comando:
```
gcloud config set project PROJECT_ID
```
Reemplaza PROJECT_ID por el ID del 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

Revisa los archivos de Terraform

El proveedorGoogle Cloud es un complemento que te permite administrar y aprovisionar recursos Google Cloud con Terraform. Sirve como un puente entre las opciones de configuración de Terraform y las APIs deGoogle Cloud , lo que te permite definir de forma declarativa los recursos de infraestructura, como máquinas virtuales y redes.

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

cat main.tf

El resultado es similar a este:

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 clúster y una base de datos de SQL

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

terraform

El resultado debería ser similar al siguiente ejemplo:

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 mediante este comando:
```
terraform init
```
Opcional: Planifica la configuración de Terraform:
```
terraform plan
```
Aplica la configuración de Terraform
```
terraform apply
```
Cuando se te solicite, ingresa yes para confirmar las acciones. Este comando puede tardar varios minutos en completarse. El resultado es similar a este:
```
Apply complete! Resources: 23 added, 0 changed, 0 destroyed.
```

Implementa la aplicación del equipo de backend

Revisa el siguiente archivo de Terraform:

cat backend.yaml

El resultado debería ser similar al siguiente ejemplo:

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:

Un Deployment con una aplicación de ejemplo.
Un Service de tipo LoadBalancer. El Service expone el objeto Deployment en el puerto 80. Para exponer tu aplicación a Internet, configura un balanceador de cargas externo a través de la eliminación de la anotación networking.gke.io/load-balancer-type.

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

Recupera 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
```

Verifica que la aplicación de backend funcione

Haz lo siguiente para confirmar que tu clúster se ejecute de forma correcta:

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

Ir a Cargas de trabajo
Haz clic en la carga de trabajo backend. Se mostrará 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 objetos Service que exponen el Pod y las métricas que incluyen el uso de CPU, memoria y disco.
Haz clic en el objeto Service LoadBalancer de backend. Se mostrará la página de detalles del servicio. En esta página, se muestra información sobre el objeto Service, como los Pods asociados con el Service y los puertos que usa el Service.
En la sección Extremos, haz clic en el vínculo IPv4 para ver tu servicio en el navegador. El resultado es similar a este:
```
Backend!
Hostname: backendweb-765f6c4fc9-cl7jx
Set Color: green
```
Cada vez que un usuario accede al extremo de backend, el servicio elige y almacena de forma aleatoria un color entre rojo, verde o azul en la base de datos compartida.

Implementa una aplicación de equipo de frontend

Revisa el siguiente archivo de Terraform:

cat frontend.yaml

El resultado debería ser similar al siguiente ejemplo:

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:

Un Deployment con una aplicación de ejemplo.
Un Service de tipo LoadBalancer. El Service expone el objeto Deployment en el puerto 80. Para exponer tu aplicación a Internet, configura un balanceador de cargas externo a través de la eliminación de la anotación networking.gke.io/load-balancer-type.

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

Recupera 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
```

Verifica que la aplicación del frontend funcione

Haz lo siguiente para confirmar que tu clúster se ejecute de forma correcta:

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

Ir a Cargas de trabajo
Haz clic en la carga de trabajo frontend. Se mostrará 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 objetos Service que exponen el Pod y las métricas que incluyen el uso de CPU, memoria y disco.
Haz clic en el objeto Service LoadBalancer de frontend. Se mostrará la página de detalles del servicio. En esta página, se muestra información sobre el objeto Service, como los Pods asociados con el Service y los puertos que usa el Service.
En la sección Extremos, haz clic en el vínculo IPv4 para ver tu servicio en el navegador. El resultado es similar a este:
```
Frontend!
Hostname: frontendweb-5cd888d88f-gwwtc
Got Color: green
```

Limpia

Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que usaste en esta página.

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

¿Qué sigue?

Explora los recursos de Terraform para GKE.
Explora muestras de configuración bien definidas en el repositorio de GitHub del módulo de GKE de Terraform.

Crea un clúster multiusuario con Terraform

Antes de comenzar

Check for the roles

Grant the roles

Prepare el entorno

Revisa los archivos de Terraform

Crea un clúster y una base de datos de SQL

Implementa la aplicación del equipo de backend

Verifica que la aplicación de backend funcione

Implementa una aplicación de equipo de frontend

Verifica que la aplicación del frontend funcione

Limpia

¿Qué sigue?