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:

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.

En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.

Ir al selector de proyectos

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

Habilita la API de GKE.

Habilita la API

En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.

Ir al selector de proyectos

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

Habilita la API de GKE.

Habilita la API

Asegúrate de tener los siguientes roles en el proyecto: roles/container.admin, roles/compute.networkAdmin, roles/iam.serviceAccountUser
Verifica los roles
1. En la consola de Google Cloud, ve a la página IAM.
  Ir a IAM
2. Selecciona el proyecto.
3. En la columna Principal, busca la fila que tiene tu dirección de correo electrónico.
  
  Si tu dirección de correo electrónico no está en esa columna, no tienes ningún rol.
4. En la columna Función de la fila con la dirección de correo electrónico, verifica si la lista de roles incluye los roles necesarios.
Otorga los roles
1. En la consola de Google Cloud, ve a la página IAM.
  Ir a IAM
2. Selecciona el proyecto.
3. Haz clic en Grant access.
4. En el campo Principales nuevas, ingresa tu dirección de correo electrónico.
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.

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

Clona el repositorio de GitHub:

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

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.

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"

  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.
Una subred de pila doble.
Un clúster de Autopilot de pila doble ubicado en us-central1.

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 = false

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

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

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

Inicializa Terraform mediante este comando:
```
terraform init
```
Planifica la configuración de Terraform:
```
terraform plan
```
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:

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

Ir a Cargas de trabajo
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.
Ve a la página Ingress y Services en la consola de Google Cloud.

Ir a Ingress y Service
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.
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
```

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.

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:

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

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.

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

Objetivos

Antes de comenzar

Verifica los roles

Otorga los roles

Prepare el entorno

Revisa los archivos de Terraform

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

Verifica que el clúster funcione

Limpia

¿Qué sigue?