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

Autopilot

Neste guia de início rápido, você aprenderá a criar um cluster do Autopilot do Google Kubernetes Engine (GKE) e implantar uma carga de trabalho usando o Terraform.

A infraestrutura como código (IaC, na sigla em inglês) é uma prática de gerenciamento e provisionamento de recursos de infraestrutura de software usando código. O Terraform é uma ferramenta de IaC de código aberto conhecida que oferece suporte a uma ampla gama de serviços do Cloud, incluindo o GKE. Como administrador da plataforma GKE, é possível usar o Terraform para padronizar a configuração dos clusters do Kubernetes e otimizar os fluxos de trabalho de DevOps. Para saber mais, consulte Suporte do Terraform para GKE.

Objetivos

Criar uma rede de nuvem privada virtual (VPC) IPv6
Criar um cluster do Autopilot do GKE
Implantar uma carga de trabalho no cluster
Expor a carga de trabalho usando um serviço

Antes de começar

Siga estas etapas para ativar a API do Kubernetes Engine:

Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

Acessar o seletor de projetos

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

Ative a API GKE.

Ative a API

No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

Acessar o seletor de projetos

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

Ative a API GKE.

Ative a API

Verifique se você tem os seguintes papéis no projeto: roles/container.admin, roles/compute.networkAdmin, roles/iam.serviceAccountUser
Verificar os papéis
1. No console do Google Cloud, abra a página IAM.
  Acessar IAM
2. Selecionar um projeto.
3. Na coluna Principal, encontre a linha que contém seu endereço de e-mail.
  
  Caso seu endereço de e-mail não esteja nessa coluna, isso significa que você não tem papéis.
4. Na coluna Papel da linha com seu endereço de e-mail, verifique se a lista de papéis inclui os papéis necessários.
Conceder os papéis
1. No console do Google Cloud, abra a página IAM.
  Acesse o IAM
2. Selecionar um projeto.
3. Clique em CONCEDER ACESSO.
4. No campo Novos participantes, digite seu endereço de e-mail.
5. Na lista Selecionar um papel, escolha um.
6. Para conceder outros papéis, clique em Adicionar outro papel e adicione cada papel adicional.
7. Clique em Save.

Você precisa ter noções básicas sobre o Terraform. Você pode usar os seguintes recursos:

Primeiras etapas com o Terraform (vídeo)
Comandos do 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.

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

Clone o repositório do GitHub:

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

Mude para o diretório de trabalho:

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

Revisar os arquivos do Terraform

O Google Cloud Provider é um plug-in que permite gerenciar e provisionar recursos do Google Cloud usando o Terraform, a ferramenta de infraestrutura como código (IaC, na sigla em inglês) da HashiCorp. Ele serve como uma ponte entre as configurações do Terraform e as APIs do Google Cloud, permitindo que você defina recursos de infraestrutura, como máquinas virtuais e redes, de maneira declarativa.

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"

  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.

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

  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. Para expor seu aplicativo na Internet, configure um balanceador de carga externo removendo a anotação networking.gke.io/load-balancer-type.

Criar um cluster e implantar um aplicativo

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

Inicialize o Terraform:
```
terraform init
```
Planeje a configuração do Terraform:
```
terraform plan
```
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:

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

Acesse "Cargas de trabalho"
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.
Acesse a página Serviços e entradas no console do Google Cloud.

Acesse "Serviços e Entrada"
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.
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
```

Limpar

Para evitar cobranças na conta do Google Cloud pelos recursos usados nesta página, siga estas etapas.

No Cloud Shell, execute o seguinte comando para excluir os recursos do Terraform:

terraform destroy --auto-approve

Se for exibida uma mensagem de erro parecida com esta The network resource 'projects/PROJECT_ID/global/networks/example-network' is already being used by 'projects/PROJECT_ID/global/firewalls/example-network-yqjlfql57iydmsuzd4ot6n5v', faça o seguinte:

Exclua as regras de firewall:

gcloud compute firewall-rules list --filter="NETWORK:example-network" --format="table[no-heading](name)" | xargs gcloud --quiet compute firewall-rules delete

Execute novamente o comando do Terraform:
```
terraform destroy --auto-approve
```

A seguir

Explore os recursos google_container_cluster e google_container_node_pool na documentação do Google Cloud Provider. Nestas páginas, documentamos os argumentos e atributos da configuração do cluster e do pool de nós do GKE que o Google aceita no Terraform.
Veja exemplos de configuração no repositório GitHub do módulo Terraform GKE.

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

Objetivos

Antes de começar

Verificar os papéis

Conceder os papéis

prepare o ambiente

Revisar os arquivos do Terraform

Criar um cluster e implantar um aplicativo

Verificar se o cluster está funcionando

Limpar

A seguir