Créer un cluster et déployer une charge de travail à l'aide de Terraform

Préparer l'environnement

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

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

   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/autopilot
   

Examiner les fichiers Terraform

Le Cloud de Confiance by S3NS fournisseur est un plug-in qui vous permet de gérer et de provisionner des Cloud de Confiance ressources à l'aide de Terraform. Il sert de passerelle entre les configurations Terraform et les Cloud de Confiance API, 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.

Le cluster et l'exemple d'application de ce tutoriel sont spécifiés dans deux fichiers Terraform qui utilisent les fournisseurs Cloud de Confiance by S3NS et Kubernetes.

1. Examinez le fichier cluster.tf :

   cat cluster.tf
   

   Le résultat ressemble à ce qui suit :

   resource "google_compute_network" "default" {
     name = "example-network"
   
     auto_create_subnetworks  = false
     enable_ula_internal_ipv6 = true
   }
   
   resource "google_compute_subnetwork" "default" {
     name = "example-subnetwork"
   
     ip_cidr_range = "10.0.0.0/16"
     region        = "us-central1"
   
     stack_type       = "IPV4_IPV6"
     ipv6_access_type = "INTERNAL" # Change to "EXTERNAL" if creating an external loadbalancer
   
     network = google_compute_network.default.id
     secondary_ip_range {
       range_name    = "services-range"
       ip_cidr_range = "192.168.0.0/24"
     }
   
     secondary_ip_range {
       range_name    = "pod-ranges"
       ip_cidr_range = "192.168.1.0/24"
     }
   }
   
   resource "google_container_cluster" "default" {
     name = "example-autopilot-cluster"
   
     location                 = "us-central1"
     enable_autopilot         = true
     enable_l4_ilb_subsetting = true
   
     network    = google_compute_network.default.id
     subnetwork = google_compute_subnetwork.default.id
   
     ip_allocation_policy {
       stack_type                    = "IPV4_IPV6"
       services_secondary_range_name = google_compute_subnetwork.default.secondary_ip_range[0].range_name
       cluster_secondary_range_name  = google_compute_subnetwork.default.secondary_ip_range[1].range_name
     }
   
     # Set `deletion_protection` to `true` will ensure that one cannot
     # accidentally delete this instance by use of Terraform.
     deletion_protection = false
   }

   Ce fichier décrit les ressources suivantes :

   • google_compute_network: réseau VPC avec IPv6 interne activé
   • google_compute_subnetwork : sous-réseau à double pile
   • google_container_cluster : cluster en mode Autopilot à double pile situé dans us-central1 Le paramètre deletion_protection indique si vous pouvez utiliser Terraform pour supprimer ce cluster. Si vous définissez la valeur du champ deletion_protection sur false, Terraform peut supprimer le cluster. Pour en savoir plus, consultez la google_container_cluster référence.

2. Examinez le fichier app.tf :

   cat app.tf
   

   Le résultat ressemble à ce qui suit :

   data "google_client_config" "default" {}
   
   provider "kubernetes" {
     host                   = "https://${google_container_cluster.default.endpoint}"
     token                  = data.google_client_config.default.access_token
     cluster_ca_certificate = base64decode(google_container_cluster.default.master_auth[0].cluster_ca_certificate)
   
     ignore_annotations = [
       "^autopilot\\.gke\\.io\\/.*",
       "^cloud\\.google\\.com\\/.*"
     ]
   }
   
   resource "kubernetes_deployment_v1" "default" {
     metadata {
       name = "example-hello-app-deployment"
     }
   
     spec {
       selector {
         match_labels = {
           app = "hello-app"
         }
       }
   
       template {
         metadata {
           labels = {
             app = "hello-app"
           }
         }
   
         spec {
           container {
             image = "us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0"
             name  = "hello-app-container"
   
             port {
               container_port = 8080
               name           = "hello-app-svc"
             }
   
             security_context {
               allow_privilege_escalation = false
               privileged                 = false
               read_only_root_filesystem  = false
   
               capabilities {
                 add  = []
                 drop = ["NET_RAW"]
               }
             }
   
             liveness_probe {
               http_get {
                 path = "/"
                 port = "hello-app-svc"
   
                 http_header {
                   name  = "X-Custom-Header"
                   value = "Awesome"
                 }
               }
   
               initial_delay_seconds = 3
               period_seconds        = 3
             }
           }
   
           security_context {
             run_as_non_root = true
   
             seccomp_profile {
               type = "RuntimeDefault"
             }
           }
   
           # Toleration is currently required to prevent perpetual diff:
           # https://github.com/hashicorp/terraform-provider-kubernetes/pull/2380
           toleration {
             effect   = "NoSchedule"
             key      = "kubernetes.io/arch"
             operator = "Equal"
             value    = "amd64"
           }
         }
       }
     }
   }
   
   resource "kubernetes_service_v1" "default" {
     metadata {
       name = "example-hello-app-loadbalancer"
       annotations = {
         "networking.gke.io/load-balancer-type" = "Internal" # Remove to create an external loadbalancer
       }
     }
   
     spec {
       selector = {
         app = kubernetes_deployment_v1.default.spec[0].selector[0].match_labels.app
       }
   
       ip_family_policy = "RequireDualStack"
   
       port {
         port        = 80
         target_port = kubernetes_deployment_v1.default.spec[0].template[0].spec[0].container[0].port[0].name
       }
   
       type = "LoadBalancer"
     }
   
     depends_on = [time_sleep.wait_service_cleanup]
   }
   
   # Provide time for Service cleanup
   resource "time_sleep" "wait_service_cleanup" {
     depends_on = [google_container_cluster.default]
   
     destroy_duration = "180s"
   }

   Ce fichier décrit les ressources suivantes :

   • Un déploiement avec un exemple d'image de conteneur.
   • Un service de type LoadBalancer. Le service expose le déploiement sur le port 80.

(Facultatif) Exposer l'application sur Internet

Les fichiers Terraform de l'exemple décrivent une application avec une adresse IP interne, accessible uniquement à partir du même cloud privé virtuel (VPC) que l'exemple d'application. Si vous souhaitez accéder à l'interface Web de l'application de démonstration en cours d'exécution depuis Internet (par exemple, depuis votre ordinateur portable), modifiez les fichiers Terraform pour créer une adresse IP publique à la place avant de créer le cluster. Vous pouvez le faire à l'aide d'un éditeur de texte directement dans Cloud Shell ou à l'aide de l'éditeur Cloud Shell.

Pour exposer l'application de démonstration sur Internet :

1. Dans cluster.tf, remplacez ipv6_access_type par EXTERNAL au lieu de INTERNAL.

   ipv6_access_type = "EXTERNAL"
   

2. Dans app.tf, configurez un équilibreur de charge externe en supprimant l' networking.gke.io/load-balancer-type annotation.

    annotations = {
      "networking.gke.io/load-balancer-type" = "Internal" # Remove this line
    }
   

Créer un cluster et déployer une application

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. Planifiez la configuration Terraform :

   terraform plan
   

4. Appliquez 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: 6 added, 0 changed, 0 destroyed.
   

Vérifier que le cluster fonctionne

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

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

   Accéder à la page Charges de travail

2. Cliquez sur la charge de travail example-hello-app-deployment. 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. Accédez à la page Services et entrées dans la Cloud de Confiance console :

   Accéder à la page Services et entrées

4. Cliquez sur le Service LoadBalancer example-hello-app-loadbalancer. 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.

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

   Hello, world!
   Version: 2.0.0
   Hostname: example-hello-app-deployment-5df979c4fb-kdwgr