Crea un cluster ed esegui il deployment di un carico di lavoro 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 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 carico di lavoro 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 carico di lavoro 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. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Make sure that billing is enabled for your Google Cloud project.

  4. Enable the GKE API.

    Enable the API

    5.

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  6. Make sure that billing is enabled for your Google Cloud project.

  7. Enable the GKE API.

    Enable the API

    8.

  8. Make sure that you have the following role or roles on the project: roles/container.admin, roles/compute.networkAdmin, roles/iam.serviceAccountUser

    Check for the roles

    1. In the Google Cloud console, go to the IAM page.

      Go to IAM
    2. Select the project.

    3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.

    4. For all rows that specify or include you, check the Role column to see whether the list of roles includes the required roles.

    Grant the roles

    1. In the Google Cloud console, go to the IAM page.

      Vai a IAM
    2. Seleziona il progetto.
    3. Fai clic su Concedi l'accesso.

    4. Nel campo Nuovi principali, inserisci il tuo identificatore utente. In genere si tratta dell'indirizzo email di un Account Google.

    5. Nell'elenco Seleziona un ruolo, seleziona un ruolo.
    6. Per concedere altri ruoli, fai clic su Aggiungi un altro ruolo e aggiungi ogni ruolo aggiuntivo.
    7. Fai clic su Salva.

Prepara l'ambiente

In questo tutorial utilizzerai Cloud Shell per gestire le risorse ospitate su Google Cloud. In Cloud Shell è preinstallato il software di cui hai bisogno per questo tutorial, tra cui Terraform, kubectl e 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 console. Google Cloud

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

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

    gcloud config set project PROJECT_ID

    Sostituisci PROJECT_ID con il tuo 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 e eseguire il provisioning Google Cloud delle risorse utilizzando Terraform. Funge da ponte tra le configurazioni Terraform e le Google Cloud API, consentendoti di definire in modo dichiarativo le risorse di infrastruttura, come le macchine virtuali e le 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:

  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) Esponi l'applicazione a internet

I file Terraform per l'esempio descrivono un'applicazione con un indirizzo IP interno, a cui è possibile accedere solo dallo stesso Virtual Private Cloud (VPC) dell'app di esempio. Se vuoi accedere all'interfaccia web dell'app di 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 a 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 di 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 funzioni correttamente:

  1. Vai alla pagina Workload nella Google Cloud console:

    Vai a Carichi di lavoro

  2. 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, contenitori in esecuzione sul pod, servizi che espongono il pod e metriche, tra cui l'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 example-hello-app-loadbalancer LoadBalancer. Viene visualizzata la pagina dei dettagli del 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

Esegui la pulizia

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

Se prevedi di seguire altri tutorial o di esplorare ulteriormente il tuo sample, attendi di aver terminato prima di eseguire questo passaggio di pulizia.

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

    terraform destroy --auto-approve

Risolvere gli 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', 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