Criar um cluster e implantar uma carga de trabalho usando o Terraform

Prepare o ambiente

Neste tutorial, você usará o Cloud Shell para gerenciar recursos hospedados no Google Cloud. O Cloud Shell vem pré-instalado com o software necessário para este tutorial, incluindo Terraform, kubectl e a CLI do Google Cloud.

1. Inicie uma sessão do Cloud Shell no console do Google Cloud clicando no ícone de ativação Ativar o Cloud Shell . Isso inicia uma sessão no painel inferior do console do Google Cloud.

   As credenciais de serviço associadas a essa máquina virtual são automáticas. Dessa forma, não é necessário configurar nem fazer o download de uma chave de conta de serviço.

2. Antes de executar comandos, defina o projeto padrão na CLI gcloud usando o seguinte comando:

   gcloud config set project PROJECT_ID
   

   Substitua PROJECT_ID pelo ID do projeto.

3. Clone o repositório do GitHub:

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

4. Mude para o diretório de trabalho:

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

Revisar os arquivos do Terraform

O provedor do Google Cloud é um plug-in que permite gerenciar e provisionar recursos do Google Cloud usando o Terraform. Ele atua como uma ponte entre as configurações do Terraform e as APIs do Google Cloud, permitindo a definição de recursos de infraestrutura, como máquinas virtuais e redes, de maneira declarativa.

O cluster e o app de exemplo deste tutorial são especificados em dois arquivos do Terraform que usam os provedores do Google Cloud e do Kubernetes.

1. Revise o arquivo cluster.tf:

   cat cluster.tf
   

   A saída será assim

   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
   }

   Este arquivo descreve os seguintes recursos:

   • Uma rede VPC com IPv6 interno ativado.
   • Uma sub-rede de pilha dupla.
   • Um cluster do Autopilot de pilha dupla localizado em us-central1.

2. Revise o arquivo app.tf:

   cat app.tf
   

   O resultado será assim:

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

   Este arquivo descreve os seguintes recursos:

   • Uma implantação com uma imagem de contêiner de exemplo.
   • Um serviço do tipo LoadBalancer. O serviço expõe a implantação na porta 80.

(Opcional) Expor o app à Internet

Os arquivos do Terraform para o exemplo descrevem um app com um endereço IP interno, que só pode ser acessado pela mesma nuvem privada virtual (VPC) do app de exemplo. Se você quiser acessar a interface da Web do app de demonstração em execução pela Internet (por exemplo, no laptop), modifique os arquivos do Terraform para criar um endereço IP público antes de criar o cluster. Para isso, use um editor de texto diretamente no Cloud Shell ou o editor do Cloud Shell.

Para expor o app de demonstração à Internet:

1. Em cluster.tf, mude ipv6_access_type de INTERNAL para EXTERNAL.

   ipv6_access_type = "EXTERNAL"
   

2. Em app.tf, configure um balanceador de carga externo removendo a anotação networking.gke.io/load-balancer-type.

    annotations = {
      "networking.gke.io/load-balancer-type" = "Internal" # Remove this line
    }
   

Criar um cluster e implantar um aplicativo

1. No Cloud Shell, execute este comando para verificar se o Terraform está disponível:

   terraform
   

   A saída será semelhante a esta:

   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. Inicialize o Terraform:

   terraform init
   

3. Planeje a configuração do Terraform:

   terraform plan
   

4. Aplique a configuração do Terraform:

   terraform apply
   

   Quando solicitado, digite yes para confirmar as ações. Esse comando pode levar alguns minutos para ser concluído. O resultado será assim:

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

Verificar se o cluster está funcionando

Faça o seguinte para confirmar se o cluster está sendo executado corretamente:

1. Acesse a página Cargas de trabalho no console do Google Cloud.

   Acesse "Cargas de trabalho"

2. Clique na carga de trabalho example-hello-app-deployment. A página "Detalhes do pod" é exibida. Essa página mostra informações sobre o pod, como anotações, contêineres em execução nele, serviços que expõem o pod e métricas, incluindo uso de CPU, memória e disco.

3. Acesse a página Serviços e entradas no console do Google Cloud.

   Acesse "Serviços e Entrada"

4. Clique no serviço LoadBalancer example-hello-app-loadbalancer. A página "Detalhes do serviço" é exibida. Nesta página, mostramos informações sobre o serviço, como os pods associados a ele e as portas que os serviços usam.

5. Na seção Endpoints externos, clique no link IPv4 ou link IPv6 para exibir seu serviço no navegador. O resultado será assim:

   Hello, world!
   Version: 2.0.0
   Hostname: example-hello-app-deployment-5df979c4fb-kdwgr