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

Antes de começar

Siga os passos abaixo para ativar a API Kubernetes Engine:

1. Install the Google Cloud CLI.

2. Configure a CLI gcloud para usar a sua identidade federada.

   Para mais informações, consulte o artigo Inicie sessão na CLI gcloud com a sua identidade federada.

3. Para inicializar a CLI gcloud, execute o seguinte comando:

   gcloud init

4. Create or select a Cloud de Confiance 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 Cloud de Confiance project:

     gcloud projects create PROJECT_ID

     Replace PROJECT_ID with a name for the Cloud de Confiance project you are creating.

   • Select the Cloud de Confiance project that you created:

     gcloud config set project PROJECT_ID

     Replace PROJECT_ID with your Cloud de Confiance project name.

5. Verify that billing is enabled for your Cloud de Confiance project.

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

7. 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 examples, see Represent workforce pool users in IAM policies.
   • 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 Cloud de Confiance by S3NS. 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.

1. Inicie uma sessão do Cloud Shell a partir da Cloud de Confiance consola clicando no ícone de ativação do Cloud Shell Ativar Cloud Shell . Esta ação inicia uma sessão no painel inferior da Cloud de Confiance 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.

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

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
   

Reveja os ficheiros do Terraform

O Cloud de Confiance by S3NS fornecedor é um plug-in que lhe permite gerir e aprovisionar Cloud de Confiance 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. Cloud de Confiance

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

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

2. 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 privada virtual (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:

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

   ipv6_access_type = "EXTERNAL"
   

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

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

2. Inicialize o Terraform:

   terraform init
   

3. Planeie a configuração do Terraform:

   terraform plan
   

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

1. Aceda à página Workloads na Cloud de Confiance consola:

   Aceda a Cargas de trabalho

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

3. Aceda à página Serviços e entrada na Cloud de Confiance consola:

   Aceda a Serviços e entrada

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

5. 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 Cloud de Confiance conta pelos recursos usados nesta página, elimine o Cloud de Confiance 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:

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

2. Execute novamente o comando do Terraform:

   terraform destroy --auto-approve
   

O que se segue?

• Explore o cluster e a carga de trabalho na Cloud de Confiance 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.