Crea un clúster de GKE y, luego, implementa una carga de trabajo con Terraform

Crea un clúster de GKE y, luego, implementa una carga de trabajo con Terraform

Autopilot

---

En esta guía de inicio rápido, aprenderás a crear un clúster de Autopilot de Google Kubernetes Engine (GKE) y a implementar una carga de trabajo con Terraform.

La infraestructura como código (IaC) es una práctica que consiste en administrar y aprovisionar recursos de infraestructura de software con un código. Terraform es una herramienta popular de IaC de código abierto que admite una amplia gama de servicios de Cloud, incluido GKE. Como administrador de la plataforma de GKE, puedes usar Terraform para estandarizar la configuración de los clústeres de Kubernetes y optimizar los flujos de trabajo de DevOps. Si deseas obtener más información, consulta Compatibilidad con Terraform para GKE.

Objetivos

• Crear una red de nube privada virtual (VPC) IPv6
• Crea un clúster de GKE Autopilot
• Implementar una carga de trabajo en el clúster
• Exponer la carga de trabajo con un Service

Antes de comenzar

Sigue los pasos que se indican a continuación para habilitar la API de Kubernetes Engine:

1. Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

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

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

4. Enable the GKE API.

   Enable the API

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

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

6. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

7. Enable the GKE API.

   Enable the API

8. Make sure that you have the following role or roles on the project: roles/container.admin, roles/compute.networkAdmin, roles/iam.serviceAccountUser

   Check for the roles

   1. In the Google Cloud console, go to the IAM page.

      Go to IAM
   2. Select the project.

   3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.

   4. For all rows that specify or include you, check the Role colunn to see whether the list of roles includes the required roles.

   Grant the roles

   1. In the Google Cloud console, go to the IAM page.

      Ir a IAM
   2. Selecciona el proyecto.
   3. Haz clic en Grant access.

   4. En el campo Principales nuevas, ingresa tu identificador de usuario. Esta suele ser la dirección de correo electrónico de una Cuenta de Google.

   5. En la lista Seleccionar un rol, elige un rol.
   6. Para otorgar funciones adicionales, haz clic en Agregar otro rol y agrega cada rol adicional.
   7. Haz clic en Guardar.

   Debes conocer los conceptos básicos de Terraform. Puedes usar los siguientes recursos:

   • Comienza a usar Terraform (video)
   • Comandos de Terraform

Prepare el entorno

En este instructivo, usarás Cloud Shell para administrar recursos alojados en Google Cloud. Cloud Shell tiene preinstalado el software que necesitas para este instructivo, incluidos Terraform, kubectl y Google Cloud CLI.

1. Para iniciar una sesión de Cloud Shell desde la consola de Google Cloud, haz clic en el ícono de activación de Cloud Shell Activar Cloud Shell . Esto inicia una sesión en el panel inferior de la consola de Google Cloud.

   Las credenciales de servicio asociadas a esta máquina virtual son automáticas, por lo que no tienes que configurar ni descargar una clave de cuenta de servicio.

2. Antes de ejecutar comandos, configura tu proyecto predeterminado en gcloud CLI con el siguiente comando:

   gcloud config set project PROJECT_ID
   

   Reemplaza PROJECT_ID por el ID del proyecto.

3. Clona el repositorio de GitHub:

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

4. Cambia al directorio de trabajo:

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

Revisa los archivos de Terraform

El proveedor de Google Cloud es un complemento que te permite administrar y aprovisionar recursos de Google Cloud con Terraform, la herramienta de infraestructura como código (IaC) de HashiCorp. Sirve como puente entre las opciones de configuración de Terraform y las APIs de Google Cloud, lo que te permite definir recursos de infraestructura, como máquinas virtuales y redes, de manera declarativa.

1. Revisa el archivo cluster.tf:

   cat cluster.tf
   

   El resultado es similar al que se muestra a continuación:

   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
   }

   En este archivo, se describen los siguientes recursos:

   • Una red de VPC con IPv6 interno habilitado. Para exponer tu aplicación a Internet, cambia ipv6_access_type por EXTERNAL. Si realizas este cambio, también debes quitar la anotación networking.gke.io/load-balancer-type en el archivo app.tf en el siguiente paso.
   • Una subred de pila doble.
   • Un clúster de Autopilot de pila doble ubicado en us-central1.

2. Revisa el archivo app.tf:

   cat app.tf
   

   El resultado es similar al siguiente:

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

   En este archivo, se describen los siguientes recursos:

   • Un Deployment con una imagen de contenedor de muestra.
   • Un Service de tipo LoadBalancer. El Service expone el objeto Deployment en el puerto 80. Para exponer tu aplicación a Internet, configura un balanceador de cargas externo a través de la eliminación de la anotación networking.gke.io/load-balancer-type.

Crea un clúster y, luego, implementa una aplicación

1. En Cloud Shell, ejecuta este comando para verificar que Terraform esté disponible:

   terraform
   

   El resultado debería ser similar al siguiente ejemplo:

   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. Inicializa Terraform mediante este comando:

   terraform init
   

3. Planifica la configuración de Terraform:

   terraform plan
   

4. Aplica la configuración de Terraform

   terraform apply
   

   Cuando se te solicite, ingresa yes para confirmar las acciones. Este comando puede tardar varios minutos en completarse. El resultado es similar al siguiente:

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

Verifica que el clúster funcione

Haz lo siguiente para confirmar que tu clúster se ejecute de forma correcta:

1. Ve a la página Cargas de trabajo en la consola de Google Cloud:

   Ir a Cargas de trabajo

2. Haz clic en la carga de trabajo example-hello-app-deployment. Se mostrará la página de detalles del Pod. En esta página, se muestra información sobre el Pod, como las anotaciones, los contenedores que se ejecutan en el Pod, los objetos Service que exponen el Pod y las métricas que incluyen el uso de CPU, memoria y disco.

3. Ve a la página Ingress y Services en la consola de Google Cloud.

   Ir a Ingress y Service

4. Haz clic en el objeto Service LoadBalancer de example-hello-app-loadbalancer. Se mostrará la página de detalles de Service. En esta página, se muestra información sobre el objeto Service, como los Pods asociados con el Service y los puertos que usa el Service.

5. En la sección Extremos externos, haz clic en el vínculo IPv4 o en el vínculo IPv6 para ver tu Service en el navegador. El resultado es similar a lo siguiente:

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

Completado correctamente: Creaste un clúster de forma correcta y, además, implementaste una carga de trabajo en GKE con Terraform.

Limpia

Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que usaste en esta página.

Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que usaste en esta página.

En Cloud Shell, ejecuta el siguiente comando para borrar los recursos de Terraform:

terraform destroy --auto-approve

Si ves un mensaje de error similar a The network resource 'projects/PROJECT_ID/global/networks/example-network' is already being used by 'projects/PROJECT_ID/global/firewalls/example-network-yqjlfql57iydmsuzd4ot6n5v', haz lo siguiente:

1. Borra las reglas de firewall:

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

2. Vuelve a ejecutar el comando de Terraform:

   terraform destroy --auto-approve
   

¿Qué sigue?

• Explora los recursos google_container_cluster y google_container_node_pool en la documentación del proveedor de Google Cloud. En estas páginas, se documentan los argumentos y atributos para la configuración del clúster de GKE y del grupo de nodos que Google admite en Terraform.
• Consulta muestras de configuración bien definidas en el repositorio de GitHub del módulo de GKE de Terraform.