Esta página foi traduzida pela API Cloud Translation.

Crie um cluster e implemente uma carga de trabalho com o Terraform

Autopilot

Um cluster do Kubernetes fornece computação, armazenamento, redes e outros serviços para aplicações, semelhante a um centro de dados virtual. As apps e os respetivos serviços associados que são executados no Kubernetes são denominados cargas de trabalho.

Este tutorial permite-lhe ver rapidamente um cluster do Google Kubernetes Engine em execução e uma carga de trabalho de exemplo, tudo configurado através do Terraform. Em seguida, pode explorar a carga de trabalho na Google Cloud consola antes de avançar para o nosso caminho de aprendizagem mais detalhado ou começar a planear e criar o seu próprio cluster pronto para produção. Este tutorial pressupõe que já conhece o Terraform.

Se preferir configurar o cluster e a carga de trabalho de exemplo na Google Cloud consola, consulte o artigo Crie um cluster na Google Cloud consola.

Antes de começar

Siga os passos abaixo para ativar a API Kubernetes Engine:

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.

Install the Google Cloud CLI.

Se estiver a usar um fornecedor de identidade (IdP) externo, tem primeiro de iniciar sessão na CLI gcloud com a sua identidade federada.

Para inicializar a CLI gcloud, execute o seguinte comando:

gcloud init

Create or select a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Create a Google Cloud project:
```
gcloud projects create PROJECT_ID
```
Replace PROJECT_ID with a name for the Google Cloud project you are creating.
Select the Google Cloud project that you created:
```
gcloud config set project PROJECT_ID
```
Replace PROJECT_ID with your Google Cloud project name.

Verify that billing is enabled for your Google Cloud project.

Enable the GKE API:

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

gcloud services enable container.googleapis.com

Install the Google Cloud CLI.

Se estiver a usar um fornecedor de identidade (IdP) externo, tem primeiro de iniciar sessão na CLI gcloud com a sua identidade federada.

Para inicializar a CLI gcloud, execute o seguinte comando:

gcloud init

Create or select a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Create a Google Cloud project:
```
gcloud projects create PROJECT_ID
```
Replace PROJECT_ID with a name for the Google Cloud project you are creating.
Select the Google Cloud project that you created:
```
gcloud config set project PROJECT_ID
```
Replace PROJECT_ID with your Google Cloud project name.

Verify that billing is enabled for your Google Cloud project.

Enable the GKE API:

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

gcloud services enable container.googleapis.com

Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/container.admin, roles/compute.networkAdmin, roles/iam.serviceAccountUser
```
gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE
```
Replace the following:
- PROJECT_ID: Your project ID.
- USER_IDENTIFIER: The identifier for your user account. For example, myemail@example.com.
- ROLE: The IAM role that you grant to your user account.

Prepare o ambiente

Neste tutorial, vai usar o Cloud Shell para gerir recursos alojados no Google Cloud. O Cloud Shell está pré-instalado com o software necessário para este tutorial, incluindo o Terraform, o kubectl e a CLI do Google Cloud.

Inicie uma sessão do Cloud Shell a partir da Google Cloud consola clicando no ícone de ativação do Cloud Shell Ativar Cloud Shell . Esta ação inicia uma sessão no painel inferior da Google Cloud consola.

As credenciais de serviço associadas a esta máquina virtual são automáticas, pelo que não tem de configurar nem transferir uma chave de conta de serviço.
Antes de executar comandos, defina o seu projeto predefinido na CLI gcloud com o seguinte comando:
```
gcloud config set project PROJECT_ID
```
Substitua PROJECT_ID pelo seu 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

Reveja os ficheiros do Terraform

O Google Cloud fornecedor é um plug-in que lhe permite gerir e aprovisionar Google Cloud recursos através do Terraform. Serve como uma ponte entre as configurações do Terraform e as APIs, permitindo-lhe definir declarativamente recursos de infraestrutura, como máquinas virtuais e redes. Google Cloud

O cluster e a app de exemplo para este tutorial são especificados em dois ficheiros do Terraform que usam os fornecedores Google Cloud e do Kubernetes.

Reveja o ficheiro cluster.tf:

cat cluster.tf

O resultado é semelhante ao seguinte

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 ficheiro descreve os seguintes recursos:

google_compute_network: uma rede VPC com IPv6 interno ativado.
google_compute_subnetwork: uma sub-rede de pilha dupla.
google_container_cluster: um cluster no modo de piloto automático de pilha dupla localizado em us-central1. A definição deletion_protection controla se pode usar o Terraform para eliminar este cluster. Se definir o valor no campo deletion_protection como false, o Terraform pode eliminar o cluster. Para ver detalhes, consulte a referência google_container_cluster.

Reveja o ficheiro app.tf:

cat app.tf

O resultado é semelhante ao seguinte:

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 ficheiro descreve os seguintes recursos:

A Implementação com uma imagem de contentor de amostra.
Um serviço do tipo LoadBalancer. O serviço expõe a implementação na porta 80.

(Opcional) Exponha a aplicação à Internet

Os ficheiros Terraform do exemplo descrevem uma aplicação com um endereço IP interno, que só pode ser acedido a partir da mesma nuvem virtual privada (VPC) que a app de exemplo. Se quiser aceder à interface Web da app de demonstração em execução a partir da Internet (por exemplo, a partir do seu portátil), modifique os ficheiros Terraform para criar um endereço IP público antes de criar o cluster. Pode fazê-lo através de um editor de texto diretamente no Cloud Shell ou através do Editor do Cloud Shell.

Para expor a aplicação de demonstração à Internet:

Em cluster.tf, altere ipv6_access_type de INTERNAL para EXTERNAL.
```
ipv6_access_type = "EXTERNAL"
```
No 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
 }
```

Crie um cluster e implemente uma aplicação

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

terraform

O resultado deve ser semelhante ao seguinte:

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
```
Planeie a configuração do Terraform:
```
terraform plan
```
Aplique a configuração do Terraform
```
terraform apply
```
Quando lhe for pedido, introduza yes para confirmar as ações. Este comando pode demorar vários minutos a ser concluído. O resultado é semelhante ao seguinte:
```
Apply complete! Resources: 6 added, 0 changed, 0 destroyed.
```

Verifique se o cluster está a funcionar

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

Aceda à página Workloads na Google Cloud consola:

Aceda a Cargas de trabalho
Clique na carga de trabalho example-hello-app-deployment. É apresentada a página Detalhes do grupo de anúncios. Esta página mostra informações sobre o Pod, como anotações, contentores em execução no Pod, serviços que expõem o Pod e métricas, incluindo a utilização da CPU, da memória e do disco.
Aceda à página Serviços e entrada na Google Cloud consola:

Aceda a Serviços e entrada
Clique no example-hello-app-loadbalancer serviço LoadBalancer. É apresentada a página de detalhes do serviço. Esta página mostra informações sobre o Serviço, como os Pods associados ao Serviço e as portas que os Serviços usam.
Na secção Pontos finais externos, clique no link IPv4 ou no link IPv6 para ver o seu serviço no navegador. O resultado é semelhante ao seguinte:
```
Hello, world!
Version: 2.0.0
Hostname: example-hello-app-deployment-5df979c4fb-kdwgr
```

Limpar

Para evitar incorrer em custos na sua Google Cloud conta pelos recursos usados nesta página, elimine o Google Cloud projeto com os recursos.

Se planeia fazer mais tutoriais ou explorar mais o exemplo, aguarde até terminar para executar este passo de limpeza.

No Cloud Shell, execute o seguinte comando para eliminar os recursos do Terraform:
```
terraform destroy --auto-approve
```

Resolva problemas de erros de limpeza

Se vir uma mensagem de erro semelhante a 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:

Elimine 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
```

O que se segue?

Explore o cluster e a carga de trabalho na Google Cloud consola para saber mais sobre algumas das principais definições e recursos da carga de trabalho que implementou.
Saiba como configurar e usar o Terraform com o GKE em Compatibilidade do Terraform com o GKE.
Experimente o nosso Percurso de aprendizagem: apps escaláveis mais detalhado.
Saiba como começar a usar a administração de clusters na vida real na nossa Vista geral da administração de clusters.