Créer un cluster mutualisé à l'aide de Terraform

Créer un cluster mutualisé à l'aide de Terraform

Dans l'édition Enterprise de Google Kubernetes Engine (GKE), un cluster mutualisé est un cluster Kubernetes partagé par plusieurs équipes ou utilisateurs distincts, appelés locataires. Chaque locataire dispose généralement de son propre ensemble de ressources et d'applications dans le cluster.

Ce tutoriel Terraform vous permet de créer rapidement un cluster GKE Enterprise partagé par deux équipes, backend et frontend, qui peuvent déployer des charges de travail spécifiques à chaque équipe sur le cluster. Dans ce tutoriel, nous partons du principe que vous connaissez déjà Terraform. Sinon, vous pouvez utiliser les ressources suivantes pour vous familiariser avec les bases de Terraform :

• Premiers pas avec Terraform (vidéo)
• Commandes Terraform

Qu'est-ce que Terraform ? L'Infrastructure as Code (IaC) est une pratique qui consiste à gérer et à provisionner des ressources d'infrastructure logicielle à l'aide de code. Terraform est un outil IaC Open Source populaire créé par HashiCorp. Il est compatible avec un large éventail de services cloud, y compris GKE. En tant qu'administrateur de plate-forme GKE, vous pouvez utiliser Terraform pour standardiser la configuration de vos clusters Kubernetes en production et optimiser vos workflows DevOps. Pour en savoir plus, consultez la section Compatibilité de Terraform avec GKE.

Avant de commencer

Procédez comme suit pour activer l'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.

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.

      Accéder à IAM
   2. Sélectionnez le projet.
   3. Cliquez sur Accorder l'accès.

   4. Dans le champ Nouveaux comptes principaux, saisissez votre identifiant utilisateur. Il s'agit généralement de l'adresse e-mail d'un compte Google.

   5. Dans la liste Sélectionner un rôle, sélectionnez un rôle.
   6. Pour attribuer des rôles supplémentaires, cliquez sur Ajouter un autre rôle et ajoutez chaque rôle supplémentaire.
   7. Cliquez sur Enregistrer.

   Préparer l'environnement

   Dans ce tutoriel, vous utilisez Cloud Shell pour gérer les ressources hébergées surGoogle Cloud. Cloud Shell est préinstallé avec les logiciels dont vous avez besoin dans ce tutoriel, y compris Terraform, kubectl et Google Cloud CLI.

   1. Lancez une session Cloud Shell depuis la console Google Cloud en cliquant sur l'icône d'activation Cloud Shell Activer Cloud Shell . Une session s'ouvre dans le volet inférieur de la console Google Cloud .

      Les identifiants de service associés à cette machine virtuelle sont automatiques. Vous n'avez donc pas besoin de configurer ni de télécharger une clé de compte de service.

   2. Avant d'exécuter des commandes, définissez votre projet par défaut dans gcloud CLI à l'aide de la commande suivante :

      gcloud config set project PROJECT_ID
      

      Remplacez PROJECT_ID par votre ID de projet.

   3. Clonez le dépôt GitHub.

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

   4. Accédez au répertoire de travail :

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

   Examiner les fichiers Terraform

   Le fournisseurGoogle Cloud est un plug-in qui vous permet de gérer et de provisionner des Google Cloud ressources à l'aide de Terraform. Il sert de passerelle entre les configurations Terraform et les APIGoogle Cloud , ce qui vous permet de définir de manière déclarative des ressources d'infrastructure, telles que des machines virtuelles et des réseaux.

   1. Examinez le fichier main.tf, qui décrit une ressource de cluster GKE Enterprise :

      cat main.tf
      

      Le résultat ressemble à ce qui suit :

      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
      }

   Créer un cluster et une base de données SQL

   1. Dans Cloud Shell, exécutez la commande suivante pour vérifier que Terraform est disponible :

      terraform
      

      La sortie devrait ressembler à ce qui suit :

      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. Initialisez Terraform :

      terraform init
      

   3. Facultatif : Planifiez la configuration Terraform :

      terraform plan
      

   4. Appliquer la configuration Terraform

      terraform apply
      

      Lorsque vous y êtes invité, saisissez yes pour confirmer les actions. Cette commande peut prendre plusieurs minutes. Le résultat ressemble à ce qui suit :

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

   Déployer l'application de l'équipe de backend

   1. Examinez le fichier Terraform suivant :

      cat backend.yaml
      

      La sortie devrait ressembler à ce qui suit :

      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

      Ce fichier décrit les ressources suivantes :

      • Un déploiement avec un exemple d'application.
      • Un service de type LoadBalancer. Le service expose le déploiement sur le port 80. Pour exposer votre application sur Internet, configurez un équilibreur de charge externe en supprimant l'annotation networking.gke.io/load-balancer-type.

   2. Dans Cloud Shell, exécutez la commande suivante pour emprunter l'identité du compte de service de l'équipe backend :

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

      Remplacez PROJECT_ID par votre ID de projet.

   3. Récupérez les identifiants du cluster à l'aide de la commande suivante :

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

   4. Appliquez le fichier manifeste de l'équipe backend au cluster :

      kubectl apply -f backend.yaml
      

   Vérifier que l'application backend fonctionne

   Procédez comme suit pour vérifier que votre cluster fonctionne correctement :

   1. Accédez à la page Charges de travail dans la console Google Cloud  :

      Accéder à la page Charges de travail

   2. Cliquez sur la charge de travail backend. La page des détails du pod s'affiche. Cette page affiche des informations sur le pod, telles que les annotations, les conteneurs s'exécutant sur le pod, les services exposant le pod, mais aussi les métriques telles que l'utilisation du processeur, de la mémoire et du disque.

   3. Cliquez sur le Service LoadBalancer backend. La page "Informations sur le service" s'affiche. Cette page affiche des informations sur le service, telles que les pods associés et les ports utilisés par les services.

   4. Dans la section Points de terminaison, cliquez sur le lien IPv4 pour afficher votre service dans le navigateur. Le résultat ressemble à ce qui suit :

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

      Chaque fois qu'un utilisateur accède au point de terminaison du backend, le service sélectionne et stocke de manière aléatoire une couleur (rouge, vert ou bleu) dans la base de données partagée.

   Déployer une application d'équipe frontend

   1. Examinez le fichier Terraform suivant :

      cat frontend.yaml
      

      La sortie devrait ressembler à ce qui suit :

      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

      Ce fichier décrit les ressources suivantes :

      • Un déploiement avec un exemple d'application.
      • Un service de type LoadBalancer. Le service expose le déploiement sur le port 80. Pour exposer votre application sur Internet, configurez un équilibreur de charge externe en supprimant l'annotation networking.gke.io/load-balancer-type.

   2. Dans Cloud Shell, exécutez la commande suivante pour emprunter l'identité du compte de service de l'équipe chargée de l'interface :

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

      Remplacez PROJECT_ID par votre ID de projet.

   3. Récupérez les identifiants du cluster à l'aide de la commande suivante :

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

   4. Appliquez le fichier manifeste de l'équipe frontend au cluster :

      kubectl apply -f frontend.yaml
      

   Vérifier que l'application frontend fonctionne

   Procédez comme suit pour vérifier que votre cluster fonctionne correctement :

   1. Accédez à la page Charges de travail dans la console Google Cloud  :

      Accéder à la page Charges de travail

   2. Cliquez sur la charge de travail frontend. La page des détails du pod s'affiche. Cette page affiche des informations sur le pod, telles que les annotations, les conteneurs s'exécutant sur le pod, les services exposant le pod, mais aussi les métriques telles que l'utilisation du processeur, de la mémoire et du disque.

   3. Cliquez sur le Service LoadBalancer frontend. La page "Informations sur le service" s'affiche. Cette page affiche des informations sur le service, telles que les pods associés et les ports utilisés par les services.

   4. Dans la section Points de terminaison, cliquez sur le lien IPv4 pour afficher votre service dans le navigateur. Le résultat ressemble à ce qui suit :

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

   Effectuer un nettoyage

   Pour éviter que les ressources utilisées sur cette page soient facturées sur votre compte Google Cloud , procédez comme suit :

   1. Dans Cloud Shell, exécutez cette commande pour annuler l'usurpation d'identité du compte de service :

      gcloud config unset auth/impersonate_service_account
      

   2. Exécutez la commande suivante pour supprimer les ressources Terraform :

      terraform destroy --auto-approve
      

   Étapes suivantes

   • Explorez les ressources Terraform pour GKE.

   • Explorez des exemples de configuration rigoureuses dans le dépôt GitHub du module Terraform GKE.