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

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 workload.

Questo tutorial ti consente di visualizzare rapidamente un cluster Google Kubernetes Engine in esecuzione e un workload di esempio, il tutto configurato utilizzando Terraform. Puoi quindi esplorare il workload nella Google Cloud console 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à dimestichezza con Terraform.

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

Prima di iniziare

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

  1. Accedi al tuo Google Cloud account. 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 workload.

  2. Installa Google Cloud CLI.

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

  4. Per inizializzare gcloud CLI, esegui questo comando: 

    gcloud init

  5. 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 su cui ti è stato concesso un ruolo.
    • Crea un progetto: per creare un progetto, devi disporre del ruolo Autore progetto (roles/resourcemanager.projectCreator), che contiene l' resourcemanager.projects.create autorizzazione. Scopri come concedere i ruoli.

    • Crea un Google Cloud progetto:

      gcloud projects create PROJECT_ID

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

    • Seleziona il Google Cloud progetto che hai creato:

      gcloud config set project PROJECT_ID

      Sostituisci PROJECT_ID con il nome del Google Cloud progetto.

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

  7. Abilita l'API GKE:

    Ruoli richiesti per abilitare le API

    Per abilitare le API, devi disporre del ruolo IAM Service Usage Admin (roles/serviceusage.serviceUsageAdmin), che contiene l' serviceusage.services.enable autorizzazione. Scopri come concedere i ruoli. 

    gcloud services enable container.googleapis.com

  8. Installa Google Cloud CLI.

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

  10. Per inizializzare gcloud CLI, esegui questo comando: 

    gcloud init

  11. 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 su cui ti è stato concesso un ruolo.
    • Crea un progetto: per creare un progetto, devi disporre del ruolo Autore progetto (roles/resourcemanager.projectCreator), che contiene l' resourcemanager.projects.create autorizzazione. Scopri come concedere i ruoli.

    • Crea un Google Cloud progetto:

      gcloud projects create PROJECT_ID

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

    • Seleziona il Google Cloud progetto che hai creato:

      gcloud config set project PROJECT_ID

      Sostituisci PROJECT_ID con il nome del Google Cloud progetto.

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

  13. Abilita l'API GKE:

    Ruoli richiesti per abilitare le API

    Per abilitare le API, devi disporre del ruolo IAM Service Usage Admin (roles/serviceusage.serviceUsageAdmin), che contiene l' serviceusage.services.enable autorizzazione. Scopri come concedere i ruoli. 

    gcloud services enable container.googleapis.com
    14.

  14. Concedi i ruoli al tuo account utente. Esegui il comando seguente 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, myemail@example.com.
    • 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 il il Google Cloud CLI.

  1. Avvia una sessione di Cloud Shell dalla Google Cloud console facendo clic sull'icona di attivazione di Cloud Shell Attiva Cloud Shell Pulsante Attiva Cloud Shell. Viene avviata una sessione nel riquadro inferiore della Google Cloud 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 Google Cloud provider è un plug-in che consente di gestire ed eseguire il provisioning delle Google Cloud 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. Google Cloud

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

  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:

(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 Google Cloud 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 Google Cloud 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

Libera spazio

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

Se prevedi di seguire altri tutorial o di esplorare ulteriormente l'esempio, attendi il completamento di questo passaggio di pulizia.

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

    terraform destroy --auto-approve

Risolvi gli errori di pulizia

Se visualizzi 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:

  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