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

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

Autopilot

Un cluster Kubernetes fornisce risorse di calcolo, archiviazione, networking e altri servizi per le applicazioni, come un data center virtuale. Le app e i relativi servizi in esecuzione in Kubernetes sono chiamati carichi di lavoro.

Questo tutorial ti consente di visualizzare rapidamente un cluster Google Kubernetes Engine in esecuzione e un carico di lavoro di esempio, il tutto configurato utilizzando Terraform. Puoi quindi esplorare il workload nella console Google Cloud prima di passare al nostro percorso di apprendimento più approfondito o iniziare a pianificare e creare il tuo cluster pronto per la produzione. Questo tutorial presuppone che tu abbia già familiarità con Terraform.

Se preferisci configurare il cluster e il workload di esempio nella console Google Cloud , consulta Creare un cluster nella console Google Cloud .

Che cos'è Terraform? Infrastructure as Code (IaC) è una pratica di gestione e provisioning delle risorse dell'infrastruttura software utilizzando il codice. Terraform è un popolare strumento IaC open source creato da HashiCorp che supporta una vasta gamma di servizi cloud, tra cui GKE. In qualità di amministratore della piattaforma GKE, puoi utilizzare Terraform per standardizzare la configurazione dei cluster Kubernetes in produzione e semplificare i flussi di lavoro DevOps. Per saperne di più, consulta la pagina Supporto di Terraform per GKE.

Prima di iniziare

Per abilitare l'API Kubernetes Engine, segui questi passaggi:

Accedi al tuo account Google Cloud . Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti senza costi per l'esecuzione, il test e il deployment dei carichi di lavoro.

Installa Google Cloud CLI.

Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.

Per inizializzare gcloud CLI, esegui questo comando:

gcloud init

Crea o seleziona un Google Cloud progetto.

Ruoli richiesti per selezionare o creare un progetto

• Seleziona un progetto: la selezione di un progetto non richiede un ruolo IAM specifico. Puoi selezionare qualsiasi progetto per il quale ti è stato concesso un ruolo.
• Crea un progetto: per creare un progetto, devi disporre del ruolo Autore progetto (roles/resourcemanager.projectCreator), che contiene l'autorizzazione resourcemanager.projects.create. Scopri come concedere i ruoli.

Nota: se non prevedi di conservare le risorse che crei in questa procedura, crea un progetto invece di selezionarne uno già esistente. Una volta completata questa procedura, puoi eliminare il progetto e tutte le relative risorse.

• Creare un progetto Google Cloud :

  gcloud projects create PROJECT_ID

  Sostituisci PROJECT_ID con un nome per il progetto Google Cloud che stai creando.

• Seleziona il progetto Google Cloud che hai creato:

  gcloud config set project PROJECT_ID

  Sostituisci PROJECT_ID con il nome del progetto Google Cloud .

Verifica che la fatturazione sia attivata per il tuo progetto Google Cloud .

Abilita l'API GKE:

Ruoli richiesti per abilitare le API

Per abilitare le API, devi disporre dell'autorizzazione serviceusage.services.enable. Se hai creato il progetto, probabilmente disponi già di questa autorizzazione tramite il ruolo Proprietario (roles/owner). In caso contrario, puoi ottenere questa autorizzazione tramite il ruolo Amministratore utilizzo dei servizi (roles/serviceusage.serviceUsageAdmin). Scopri come concedere i ruoli.

gcloud services enable container.googleapis.com

Installa Google Cloud CLI.

Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.

Per inizializzare gcloud CLI, esegui questo comando:

gcloud init

Crea o seleziona un Google Cloud progetto.

Ruoli richiesti per selezionare o creare un progetto

• Seleziona un progetto: la selezione di un progetto non richiede un ruolo IAM specifico. Puoi selezionare qualsiasi progetto per il quale ti è stato concesso un ruolo.
• Crea un progetto: per creare un progetto, devi disporre del ruolo Autore progetto (roles/resourcemanager.projectCreator), che contiene l'autorizzazione resourcemanager.projects.create. Scopri come concedere i ruoli.

Nota: se non prevedi di conservare le risorse che crei in questa procedura, crea un progetto invece di selezionarne uno già esistente. Una volta completata questa procedura, puoi eliminare il progetto e tutte le relative risorse.

• Creare un progetto Google Cloud :

  gcloud projects create PROJECT_ID

  Sostituisci PROJECT_ID con un nome per il progetto Google Cloud che stai creando.

• Seleziona il progetto Google Cloud che hai creato:

  gcloud config set project PROJECT_ID

  Sostituisci PROJECT_ID con il nome del progetto Google Cloud .

Verifica che la fatturazione sia attivata per il tuo progetto Google Cloud .

Abilita l'API GKE:

Ruoli richiesti per abilitare le API

Per abilitare le API, devi disporre dell'autorizzazione serviceusage.services.enable. Se hai creato il progetto, probabilmente disponi già di questa autorizzazione tramite il ruolo Proprietario (roles/owner). In caso contrario, puoi ottenere questa autorizzazione tramite il ruolo Amministratore utilizzo dei servizi (roles/serviceusage.serviceUsageAdmin). Scopri come concedere i ruoli.

gcloud services enable container.googleapis.com

1. Concedi ruoli al tuo account utente. Esegui il seguente comando una volta per ciascuno dei seguenti ruoli IAM: roles/container.admin, roles/compute.networkAdmin, roles/iam.serviceAccountUser

   gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE

   Sostituisci quanto segue:

   • PROJECT_ID: il tuo ID progetto.
   • USER_IDENTIFIER: l'identificatore del tuo account utente . Ad esempio: [e-mail].
   • ROLE: il ruolo IAM che concedi al tuo account utente.

Prepara l'ambiente

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

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

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

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
   

Rivedi i file Terraform

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

Il cluster e l'app di esempio per questo tutorial sono specificati in due file Terraform che utilizzano i provider Google Cloud 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 dual-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 riferimento google_container_cluster.

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 Virtual Private Cloud (VPC) 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'annotazione networking.gke.io/load-balancer-type.

    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 diversi minuti. L'output è simile al seguente:

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

Verificare il funzionamento del cluster

Per verificare che il cluster sia in esecuzione correttamente:

1. Vai alla pagina Workload nella console Google Cloud :

   Vai a Carichi di lavoro

2. Fai clic sul carico di lavoro example-hello-app-deployment. Viene visualizzata la pagina dei dettagli del pod. Questa pagina mostra informazioni sul pod, ad esempio 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 console Google Cloud :

   Vai a Servizi e Ingress

4. Fai clic sul servizio example-hello-app-loadbalancer LoadBalancer. Viene visualizzata la pagina Dettagli servizio. Questa pagina mostra informazioni sul servizio, ad esempio 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
   

Operazione riuscita: hai creato correttamente un cluster ed eseguito il deployment di un carico di lavoro su GKE utilizzando Terraform.

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questa pagina, elimina il progetto Google Cloud con le risorse.

Se prevedi di seguire altri tutorial o di esplorare ulteriormente il campione, esegui questo passaggio di pulizia solo al termine.

• In Cloud Shell, esegui questo comando per eliminare le risorse Terraform:

  terraform destroy --auto-approve
  

Risolvere i problemi relativi agli errori di pulizia

Se viene visualizzato un messaggio di errore simile a The network resource 'projects/PROJECT_ID/global/networks/example-network' is already being used by 'projects/PROJECT_ID/global/firewalls/example-network-yqjlfql57iydmsuzd4ot6n5v', fai quanto segue:

1. Elimina le regole firewall:

   gcloud compute firewall-rules list --filter="NETWORK:example-network" --format="table[no-heading](name)" | xargs gcloud --quiet compute firewall-rules delete
   

2. Esegui di nuovo il comando Terraform:

   terraform destroy --auto-approve
   

Passaggi successivi

• Esplora il cluster e il carico di lavoro nella console Google Cloud per scoprire alcune delle impostazioni e delle risorse chiave del carico di lavoro di cui hai eseguito il deployment.

• Scopri di più su come configurare e utilizzare Terraform con GKE in Supporto di Terraform per GKE.

• Prova il nostro percorso di apprendimento più approfondito: app scalabili.

• Scopri come iniziare a utilizzare l'amministrazione del cluster nella vita reale nella nostra panoramica dell'amministrazione del cluster.