Questa pagina è stata tradotta dall'API Cloud Translation.

Crea un cluster GKE ed esegui il deployment di un carico di lavoro utilizzando Terraform

Autopilot

In questa guida rapida, imparerai a creare un cluster Google Kubernetes Engine (GKE) Autopilot ed eseguire il deployment di un carico di lavoro utilizzando Terraform.

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

Obiettivi

Crea una rete Virtual Private Cloud (VPC) IPv6
Crea un cluster GKE Autopilot
Esegui il deployment di un carico di lavoro sul cluster
Esponi il carico di lavoro utilizzando un servizio

Prima di iniziare

Segui questi passaggi per abilitare l'API Kubernetes Engine:

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 gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

Vai al selettore progetti

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

Attiva l'API GKE.

Abilita l'API

Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

Vai al selettore progetti

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

Attiva l'API GKE.

Abilita l'API

Assicurati di disporre dei seguenti ruoli nel progetto: roles/container.admin, roles/compute.networkAdmin, roles/iam.serviceAccountUser
Verifica i ruoli
1. Nella console Google Cloud, vai alla pagina IAM.
  Vai a IAM
2. Seleziona il progetto.
3. Nella colonna Entità, individua la riga contenente il tuo indirizzo email.
  
  Se il tuo indirizzo email non è in questa colonna, significa che non disponi di alcun ruolo.
4. Nella colonna Ruolo per la riga contenente il tuo indirizzo email, controlla se l'elenco dei ruoli include quelli richiesti.
Concedi i ruoli
1. Nella console Google Cloud, vai alla pagina IAM.
  Vai a IAM
2. Seleziona il progetto.
3. Fai clic su Concedi l'accesso.
4. Nel campo Nuove entità, inserisci il tuo indirizzo email.
5. Nell'elenco Seleziona un ruolo, scegli un ruolo.
6. Per concedere altri ruoli, fai clic su Aggiungi un altro ruolo e aggiungi ciascun ruolo aggiuntivo.
7. Fai clic su Salva.

Dovresti avere familiarità con le nozioni di base di Terraform. Puoi utilizzare le seguenti risorse:

Getting Started with Terraform (video)
Comandi Terraform

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.

Avvia una sessione di Cloud Shell dalla console Google Cloud facendo clic sull'icona di attivazione di Cloud Shell Attiva Cloud Shell . In questo modo viene avviata una sessione nel riquadro inferiore della console Google Cloud.

Le credenziali di servizio associate a questa macchina virtuale sono automatiche, quindi non è necessario configurare o scaricare una chiave dell'account di servizio.
Prima di eseguire i comandi, imposta il progetto predefinito in gcloud CLI utilizzando questo comando:
```
gcloud config set project PROJECT_ID
```
Sostituisci PROJECT_ID con il tuo ID progetto.

Clona il repository GitHub:

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

Passa alla directory di lavoro:

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

Esamina i file Terraform

Il provider Google Cloud è un plug-in che consente di gestire ed eseguire il provisioning delle risorse Google Cloud utilizzando Terraform, lo strumento Infrastructure as Code (IaC) di HashiCorp. Funge da ponte tra le configurazioni Terraform e le API Google Cloud e consente di definire le risorse dell'infrastruttura, ad esempio macchine virtuali e reti, in modo dichiarativo.

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:

Una rete VPC con IPv6 interno abilitato. Per esporre la tua applicazione a internet, modifica ipv6_access_type in EXTERNAL. Se apporti questa modifica, devi anche rimuovere l'annotazione networking.gke.io/load-balancer-type nel file app.tf nel passaggio successivo.
Una subnet a due stack.
Un cluster Autopilot a due stack situato in us-central1.

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. Per esporre l'applicazione a internet, configura un bilanciatore del carico esterno rimuovendo l'annotazione networking.gke.io/load-balancer-type.

Crea un cluster ed esegui il deployment di un'applicazione

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

Inizializza Terraform:
```
terraform init
```
Pianifica la configurazione di Terraform:
```
terraform plan
```
Applicare 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.
```

Verifica che il cluster funzioni

Segui questi passaggi per verificare che il cluster sia in esecuzione correttamente:

Vai alla pagina Carichi di lavoro nella console Google Cloud:

Vai a Carichi di lavoro
Fai clic sul carico di lavoro example-hello-app-deployment. Viene visualizzata la pagina Dettagli pod. Questa pagina mostra informazioni sul pod, ad esempio annotazioni, container in esecuzione nel pod, servizi che espongono il pod e metriche tra cui CPU, memoria e utilizzo del disco.
Vai alla pagina Servizi e Ingress nella console Google Cloud:

Vai a Servizi e Ingress
Fai clic sul servizio LoadBalancer example-hello-app-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.
Nella sezione Endpoint esterni, fai clic sul link IPv4 o sul link IPv6 per visualizzare il tuo servizio nel browser. L'output è simile al seguente:
```
Hello, world!
Version: 2.0.0
Hostname: example-hello-app-deployment-5df979c4fb-kdwgr
```

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questa pagina, segui questi passaggi:

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questa pagina, segui questi passaggi.

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

terraform destroy --auto-approve

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', procedi nel seguente modo:

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

Esegui nuovamente il comando Terraform:
```
terraform destroy --auto-approve
```

Passaggi successivi

Esplora le risorse google_container_cluster e google_container_node_pool nella documentazione del provider Google Cloud. Queste pagine documentano gli argomenti e gli attributi per la configurazione del cluster GKE e del pool di nodi che Google supporta su Terraform.
Consulta esempi di configurazione "guidata" nel modulo GKE Terraform nel repository GitHub.

Crea un cluster GKE ed esegui il deployment di un carico di lavoro utilizzando Terraform

Obiettivi

Prima di iniziare

Verifica i ruoli

Concedi i ruoli

prepara l'ambiente

Esamina i file Terraform

Crea un cluster ed esegui il deployment di un'applicazione

Verifica che il cluster funzioni

Esegui la pulizia

Passaggi successivi