Kubernetes

 

Terraform, es una de las herramientas mas potentes de hashicorp y hoy en día es usada por grandes compañías para mantener infraestructura en la nube.

Terraform destaca porque podemos trabajar con múltiples providers al mismo tiempo, ¿ que quiere decir esto ? que le podemos decir a terraform que cuando se cree una nueva instancia en GCP al mismo tiempo  genere un registro DNS en route53 en AWS, esto de una manera muy sencilla.

Pero hoy no vamos a hablar de AWS, hoy vamos a hablar de GCP, una nube muy poderosa que tiene características muy interesantes para tener en cuenta y en este caso, construiremos un cluster de Kubernetes en GCP usando terraform.

Conectandonos a Google Cloud platform:

Para conectarnos a GCP solo necesitamos determinar:

  • Credentials : En este caso tenemos que generar un account service y usar el archivo json que se genera con los permisos necesarios
  • Project  : Determinamos el proyecto en GCP en el cual vamos a trabajar
  • region : Determinamos la región por el cual vamos a trabajar.

Despues de determinar los valores mencionados anteriormente, los seteamos en el siguiente archivo.

variables.tf

En este archivo determinaremos las variables que vamos a necesitar

// General Variables

variable "credentials" {
type = "string"
default = "../key.json"
description = "Json Credentials file to connect GCP"
}

variable "linux_admin_username" {
type = "string"
description = "User name for authentication to the Kubernetes linux agent virtual machines in the cluster."
default = "glb-events"
}

variable "linux_admin_password" {
type ="string"
default = "MySecretPassTest123."
description = "The password for the Linux admin account."
}

// GCP Variables
variable "gcp_cluster_count" {
type = "string"
description = "Count of cluster instances to start."
default = "1"
}
variable "project" {
  type = "string"
  default = "MyProjectID"
}

variable "cluster_name" {
type = "string"
description = "Cluster name for the GCP Cluster."
default = "stack-kubernetes"
}

Despues seteamos el siguiente archivo el cual vamos a llamar las variables escritas en el archivo variables.tf,  en este archivo le diremos a terraform que trabajaremos con el provider de Google Cloud Platform

main.tf

provider "google" {
  credentials = "${file(var.credentials)}"
  project     = "${var.project}"
  region      = "us-west1"
}

Ahora escribimos el siguiente archivo, en este archivo creamos el cluster de Kubernetes y definiremos diferentes atributos necesarios:

kubernetes.tf

resource "google_container_cluster" "gcp_kubernetes" {
   name               = "${var.cluster_name}"
   zone               = "us-west1-a"
   initial_node_count = "${var.gcp_cluster_count}"

   additional_zones = [
     "us-west1-b",
     "us-west1-c",
   ]

   master_auth {
     username = "${var.linux_admin_username}"
     password = "${var.linux_admin_password}}"
   }

   node_config {
     oauth_scopes = [
       "https://www.googleapis.com/auth/compute",
       "https://www.googleapis.com/auth/devstorage.read_only",
       "https://www.googleapis.com/auth/logging.write",
       "https://www.googleapis.com/auth/monitoring",
     ]

     labels {
       this-is-for = "dev-cluster"
     }

     tags = ["dev", "work"]
   }
 }


     ## Connect to cluster after creating it

 resource "null_resource" "connect-cluster" {
 depends_on = ["google_container_cluster.gcp_kubernetes"]
 provisioner "local-exec" {
     command = "gcloud container clusters get-credentials ${var.cluster_name} --zone us-west1-a --project academy-193615"
     interpreter = ["bash", "-c"]
 }
 }

Una breve descripción de algunos atributos:

name:  Nombre del cluster que estamos creando, este valor lo definimos anteriormente en variables.tf

initial_node_count:  numero de instancias que se desplegaran por zonas, en este caso se desplegara una instancia por cada zona que definimos.

oauth_scopes:  Scopes necesarios para el buen funcionamiento de kubernetes y acceso a otros recursos.

 

Por ultimo, en este archivo se encuentra un recurso un poco particular ya que es un recurso tipo “null_resource” este recurso nos permite ejecutar comandos

gcloud container clusters get-credentials ${var.cluster_name} --zone us-west1-a --project academy-193615

Concluire que si ya hemos trabajado en GCP ya hemos realizado el join de gcloud de nuestra CLI asi que me saltare ese paso.

Con este comando le decimos a gcloud que establezcla la conexión de manera local a nuestro stack de kubernetes, asi que si queremos correr algun comando de kubectl hacia nuestro stack podemos hacerlo de manera local sin ningun inconveniente.

Ahora que todo esta listo, ejecutamos el siguiente comando para que terraform verifique los recursos a crear.

terraform plan

Si todo sale bien, se debe observar lo siguiente:

image2

Terraform verifica los recursos escritos en los archivos tf y su estado, en este momento el estado del cluster es que no esta creado y terraform, procedera a crearla. Para crear los recursos ejecutamos el siguiente comando:

terraform apply

Si los recursos se crearon satisfactoriamente, tendremos un output parecido a este:

image3

Verificamos los nodos de nuestro cluster:

kubect get nodes

image4

image5

De este modo desplegamos un stack de Kubernetes en GCP en segundos, listo para desplegar nuestros servicios.

Mas información:

https://www.terraform.io/docs/

https://kubernetes.io/docs/home/