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

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

Infrastructure as Code (IaC) è una pratica per la gestione e il provisioning delle risorse dell'infrastruttura software utilizzando il codice. Terraform è un noto strumento IaC open source che supporta un'ampia gamma di servizi cloud, incluso GKE. Come Amministratore della piattaforma GKE, puoi utilizzare Terraform per standardizzare la configurazione dei cluster Kubernetes e semplificare i flussi di lavoro DevOps. Per saperne di più, vedi 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 tuo cluster
  • Esposizione del carico di lavoro utilizzando un servizio

Prima di iniziare

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

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

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

    Go to project selector

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

  4. Attiva l'API GKE.

    Abilita l'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. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  7. Attiva l'API GKE.

    Abilita l'API

    8.

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

Avere familiarità con le nozioni di base di Terraform. Puoi utilizzare le seguenti opzioni di risorse:

prepara l'ambiente

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

  1. Avvia una sessione di Cloud Shell dalla console Google Cloud facendo clic su L'icona di attivazione di Cloud Shell Attiva Cloud Shell Pulsante Attiva shell. Questo avvia una sessione nel riquadro inferiore della console Google Cloud.

    Le credenziali di servizio associate a questa macchina virtuale sono automatiche in modo da non dover configurare o scaricare una chiave dell'account di servizio.

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

    gcloud config set project PROJECT_ID

    Sostituisci PROJECT_ID con 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

La Provider Google Cloud è un plug-in che consente di gestire ed eseguire il provisioning delle risorse Google Cloud usando Terraform, lo strumento Infrastructure as Code (IaC) di HashiCorp. Serve da è un bridge tra le configurazioni Terraform e le API Google Cloud. permettendoti di definire risorse dell'infrastruttura come macchine virtuali in modo dichiarativo.

  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
}

    In questo file vengono descritte le seguenti risorse:

    • Una rete VPC con IPv6 interno abilitato. Per esporre l'applicazione a internet, cambia ipv6_access_type in EXTERNAL. Se di apportare questa modifica, è necessario rimuovere anche Annotazione networking.gke.io/load-balancer-type nel file app.tf nel passaggio successivo.
    • Una subnet a doppio stack.
    • R Cluster Autopilot a doppio stack si trova in us-central1.

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

    In questo file vengono descritte le seguenti risorse:

    • R Deployment con un'immagine container di esempio.
    • R Servizio di tipo LoadBalancer. Il servizio espone Deployment sulla porta 80. Per esporre la tua applicazione a internet, e configurare un bilanciatore del carico esterno Annotazione networking.gke.io/load-balancer-type.

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. 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 confermare che il cluster sia in esecuzione correttamente:

  1. Vai alla pagina Carichi di lavoro nella console Google Cloud:

    Vai a Carichi di lavoro

  2. Fai clic sul carico di lavoro example-hello-app-deployment. Pagina dei dettagli del pod vengono visualizzati i video. 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 scheda Servizi e Pagina in entrata nella console Google Cloud:

    Vai a Servizi e In entrata

  4. Fai clic sul servizio LoadBalancer example-hello-app-loadbalancer. Il Servizio viene visualizzata la pagina dei dettagli. In questa pagina vengono visualizzate informazioni sul Servizio, come come i pod associati al servizio e le porte utilizzate dal servizio.

  5. Nella sezione Endpoint esterni, fai clic sul link IPv4 o sul Link IPv6 per visualizzare il Servizio nel browser. L'output è simile a le seguenti:

    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 per le risorse utilizzate in questa pagina, segui questi passaggi.

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzati in questa pagina, procedi nel seguente modo.

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

terraform destroy --auto-approve

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