Crea un cluster ed esegui il deployment di un workload utilizzando Terraform

Prepara l'ambiente

In questo tutorial utilizzerai Cloud Shell per gestire le risorse ospitate su Cloud de Confiance by S3NS. Cloud Shell è preinstallato con il software necessario per questo tutorial, tra cui Terraform, kubectl, e il il Google Cloud CLI.

1. Avvia una sessione di Cloud Shell dalla Cloud de Confiance console facendo clic sull'icona di attivazione di Cloud Shell Attiva Cloud Shell . Viene avviata una sessione nel riquadro inferiore della Cloud de Confiance console.

   Le credenziali di servizio associate a questa macchina virtuale sono automatiche, quindi non devi configurare o scaricare una chiave del account di servizio.

2. Prima di eseguire i comandi, imposta il progetto predefinito in gcloud CLI utilizzando il comando seguente:

   gcloud config set project PROJECT_ID
   

   Sostituisci PROJECT_ID con l' ID progetto.

3. Clona il repository GitHub:

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

4. Passa alla directory di lavoro:

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

Esamina i file Terraform

Il Cloud de Confiance by S3NS provider è un plug-in che consente di gestire ed eseguire il provisioning delle Cloud de Confiance risorse utilizzando Terraform. Funge da ponte tra le configurazioni Terraform e le API, consentendoti di definire in modo dichiarativo le risorse dell'infrastruttura, come macchine virtuali e reti. Cloud de Confiance

Il cluster e l'app di esempio per questo tutorial sono specificati in due file Terraform che utilizzano i Cloud de Confiance by S3NS provider e Kubernetes.

1. Esamina il file cluster.tf:

   cat cluster.tf
   

   L'output è simile al seguente

   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
   }

   Questo file descrive le seguenti risorse:

   • google_compute_network: una rete VPC con IPv6 interno abilitato.
   • google_compute_subnetwork: una subnet a doppio stack.
   • google_container_cluster: un cluster in modalità Autopilot a doppio stack situato in us-central1. L'impostazione deletion_protection controlla se puoi utilizzare Terraform per eliminare questo cluster. Se imposti il valore nel campo deletion_protection su false, Terraform può eliminare il cluster. Per maggiori dettagli, consulta il google_container_cluster riferimento.

2. Esamina il file app.tf:

   cat app.tf
   

   L'output è simile al seguente:

   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"
   }

   Questo file descrive le seguenti risorse:

   • Un deployment con un'immagine container di esempio.
   • Un servizio di tipo LoadBalancer. Il servizio espone il deployment sulla porta 80.

(Facoltativo) Esporre l'applicazione su internet

I file Terraform per l'esempio descrivono un'applicazione con un indirizzo IP interno, a cui è possibile accedere solo dalla stessa rete VPC (Virtual Private Cloud) dell'app di esempio. Se vuoi accedere all'interfaccia web dell'app demo in esecuzione da internet (ad esempio dal tuo laptop), modifica i file Terraform per creare un indirizzo IP pubblico prima di creare il cluster. Puoi farlo utilizzando un editor di testo direttamente in Cloud Shell o utilizzando l'editor di Cloud Shell.

Per esporre l'applicazione demo su internet:

1. In cluster.tf, modifica ipv6_access_type da INTERNAL a EXTERNAL.

   ipv6_access_type = "EXTERNAL"
   

2. In app.tf, configura un bilanciatore del carico esterno rimuovendo l' networking.gke.io/load-balancer-type annotazione.

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

Crea un cluster ed esegui il deployment di un'applicazione

1. In Cloud Shell, esegui questo comando per verificare che Terraform sia disponibile:

   terraform
   

   L'output dovrebbe essere simile al seguente:

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

   terraform init
   

3. Pianifica la configurazione Terraform:

   terraform plan
   

4. Applica la configurazione Terraform

   terraform apply
   

   Quando richiesto, inserisci yes per confermare le azioni. Il completamento di questo comando potrebbe richiedere alcuni minuti. L'output è simile al seguente:

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

Verifica il funzionamento del cluster

Per verificare che il cluster sia in esecuzione correttamente:

1. Vai alla pagina Workload nella Cloud de Confiance console:

   Vai a Carichi di lavoro

2. Fai clic sul workload example-hello-app-deployment. Viene visualizzata la pagina dei dettagli del pod. Questa pagina mostra informazioni sul pod, come annotazioni, container in esecuzione sul pod, servizi che espongono il pod e metriche tra cui utilizzo di CPU, memoria e disco.

3. Vai alla pagina Servizi e Ingress nella Cloud de Confiance console:

   Vai a Servizi e Ingress

4. Fai clic sul servizio LoadBalancer example-hello-app-loadbalancer. Viene visualizzata la pagina dei dettagli del servizio. Questa pagina mostra informazioni sul servizio, come i pod associati al servizio e le porte utilizzate dai servizi.

5. Nella sezione Endpoint esterni, fai clic sul link IPv4 o sul link IPv6 per visualizzare il servizio nel browser. L'output è simile al seguente:

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