Picturesocial - Cmo desplegar un cluster de Kubernetes en AWS usando Terraform

En nuestro ltimo post descubrimos sobre Kubernetes y por qu lo estamos usando en Picturesocial. En este post vamos a aprender sobre infraestructura cmo cdigo, y especficamente sobre cmo desplegar un Amazon Elastic Kubernetes Service usando Terraform.

He trabajado en proyectos de TI por varios aos y algo recurrente, en mi experiencia, ha sido cmo los desarrolladores trabajan junto con los Sysadmins, especialmente cuando la aplicacin fuerza cambios en la infraestructura y en la forma en la que las cosas son hechas tradicionalmente, La aplicacin tiene que adaptarse a la infraestructura o la infraestructura debe adaptarse a la aplicacin?, Qu pasa si los cambios en infraestructura representan problemas para hacer rollback a versiones anteriores de la aplicacin de forma sencilla?

En el pasado, diseamos aplicaciones sabiendo que en la mayora de los casos la infraestructura era esttica, que tenamos que lidiar con las limitaciones como algo axiomtico e inamovible. A medida que avanzamos en nuestro camino a la computacin en la nube, ese paradigma comenz a romperse con la posibilidad de tener tericamente todo el poder de computo que necesitbamos al alcance de nuestras manos y casi de forma inmediata. Ese cambio ayud a crear un nuevo set de soluciones diseadas para esas nuevas capacidades, una de ellas fue Infraestructura como Cdigo (IaC)

Pero, Qu es infraestructura como cdigo?

Cuando estaba en el colegio me gustaba escribir historias de Calabozos y Dragones, donde el personaje principal tena que tomar decisiones irreversibles que eran seleccionadas por el lector, y dependiendo de la eleccin podras ir a travs una serie de aventuras que podan ser potencialmente largas y complejas o simplemente hacan que la historia termine en ese momento. As es como suceden las cosas con la infraestructura, comienzas con algunos supuestos que te obligan a elegir el tamao de tu infra, dimensionamiento de redes, uso de balanceadores, etc. La mayora de cambios que hagas sobre la infraestructura base son potencialmente irreversibles a menos que conozcas exactamente lo que pas desde el inicio y cada accin que se realiz. Esto significa que mantener versionamiento de la infraestructura y su configuracin en conjunto con la aplicacin puede ser posible pero se vuelve bastante difcil, y es ah donde la Infraestructura como Cdigo entra a la accin.

La Infraestructura como Cdigo te permite definir tu infraestructura y configuracin de manera similar a como los desarrolladores de software definen sus aplicaciones y est compuesto por archivos de configuracin. Estos archivos de configuracin son interpretados y transformados en infraestructura en tu ambiente de nube pblica o hbrida. IaC te permite mantener versionamiento de cada cambio, as como hacer rollback hacia versiones anteriores, incluso puedes crear pruebas para entender qu representan esos cambios antes de aplicarlos.

Para Picturesocial decid usar Hashicorp Terraform, para nuestras definiciones de IaC, debido a que es una herramienta que vengo usando por aos y me siento seguro de poder escalar mi arquitectura e infraestructura sin gastar mucho tiempo aprendiendo una nueva herramienta. Sin embargo, hay otras excelentes herramientas en el mercado como AWS Cloud Development Toolkit, AWS CloudFormation, Pulumi, Ansible, Chef, Puppet, entre otras. Estas herramientas tambin pueden ayudarte, la mejor opcin es la que te haga sentir ms cmodo y productivo.

Qu es Hashicorp Terraform?

Terraform es una herramienta de IaC creada por Hashicorp que te ayuda a definir una infraestructura completa de una forma en la que puedes versionarla y reutilizarla. Usa Hashicorp Configuration Language (HCL) para su estructura. Todos los archivos de configuracin de Terraform deben ser guardados con la extensin .tf

Algunas definiciones bsicas a tener en cuenta son:

• Providers: Aqu es donde le dices a Terraform que ests usando un proveedor de nube especfico [providers (https://registry.terraform.io/browse/providers)], por ejemplo, si quieres desplegar tu infraestructura a AWS, necesitas definir un proveedor como en el ejemplo a continuacin. Tener en cuenta que especificar la versin del proveedor es opcional, si no la especificas usar la ltima disponible como versin por defecto.

terraform {  required_providers {    aws = {      source  = "hashicorp/aws"      version = ">= 3.20.0"    }  }}

• Resources: Ac es donde defines la infraestructura. Puedes definir los recursos como piezas de infraestructura tipo: instancias, redes, storage, etc. Un recurso necesita dos parametros declarativos: 1/ el tipo de recurso y 2/ el id del recurso. Por ejemplo, abajo estamos definiendo una instancia de AWS con un AMI especfico y tipo de instancia t2.micro.

resource "aws_instance" "web" {  ami           = "ami-a1b2c3d4"  instance_type = "t2.micro"}

• Variables:
  • Input: Estas son las variables que usas para solicitar informacin de los usuarios o runtime antes de aplicar algn cambio. Este tipo de variables son parmetros que debes ingresar en el Terraform CLI [CLI (https://www.terraform.io/cli)]

variable "project_code" {  type = string}variable "availability_zone" {  type    = list(string)  default = ["us-east-1a"]}

* Output: Estas son variables que retornarn informacin de la ejecucin. Por ejemplo, nombre del repositorio, id del cluster, etc.

output "ec2_ip" {  value = aws_instance.server.private_ip}

* Locals: Estas son variables que estableces en tu cdigo y pueden ser referenciadas en cualquier parte del proyecto. El ejemplo a continuacin crear una etiqueta comn para todos los recursos que creemos y concatenar los valores de las variables project_code y environment

locals {  project_code = "pso"  environment        = "dev"}common_tags = {  project_name = "pe-${local.project_code}-${local.environment}01"}

• Modules: Usamos los mdulos para agrupar diferentes recursos que son utilizados de forma conjunta en una arquitectura, de esa forma en vez de tener una plantilla de Terraform de 30 paginas y 2 volmenes, podemos estandarizar escenarios como un solo objeto. Por ejemplo: Cada Amazon EKS Cluster necesita una VPC con 6 subnets, 2 Elastic Load Balancers, 2 Worker Groups con al menos 3 instancias de EC2 cada grupo, etc. En vez de crear todos los recursos por cluster, podemos crear un mdulo y reutilizarlo para simplificar las creaciones futuras.

module "aws-vpc" {  source = "./mods/aws-vpc"  base_cidr_block = "11.0.0.0/16"}

Me gusta pensar en Terraform como una herramienta de IaC de 4 pasos (inclusive si tenemos ms opciones), vamos a usar 4 comandos bsicos que aplicarn a todos nuestros proyectos, esos pasos necesitan ser ejecutados en el siguiente orden:

1. terraform initUsa este comando para inicializar tu proyecto de Terraform, solo debes ejecutar este comando una vez por proyecto.
2. terraform planEste comando se usa para probar qu es lo que se crear, actualizar o eliminar en tu ambiente de nube y antes de ejecutar cualquier cambio.
3. terraform applyEste comando ejecuta terraform plan como paso 1 y luego en base a tu confirmacin, ejecuta los cambios finales en tu ambiente de nube.
4. terraform destroyCuando ya no necesitas tu ambiente de nube, puedes destruirlo por completo. Esto es sper til para ambientes de certificacin que solo son usados cuando sale un nuevo release, por ejemplo.

Ahora que entendemos algunos conceptos bsicos de IaC y Terraform Vamos a desplegar un Cluster de Amazon EKS desde el inicio!

Pre-requisitos

• Una cuenta de AWS, si no tienes puedes pedir una aqu: https://aws.amazon.com/free/
• Si ests usando Microsoft Windows te sugiero trabajar usando WSL2: https://docs.microsoft.com/en-us/windows/wsl/install
• Si no tienes Git, desde ac puedes instalarlo: https://github.com/git-guides/install-git
• Instala la lnea de comandos de Terraform https://learn.hashicorp.com/tutorials/terraform/install-cli
• Necesitars el AWS CLI v2 https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html
• Si esta es tu primera vez trabajando con AWS CLI o necesitas un refresh de como setear tus credenciales en el terminal te sugiero seguir este paso a paso: https://aws.amazon.com/es/getting-started/guides/setup-environment/. Si no quieres instalar todo desde cero, en este mismo link podrs seguir los pasos para configurar Amazon Cloud9 que es un entorno de desarrollo virtual, que incluye casi todo el toolset que necesitas para este paso a paso.

Paso a Paso

En este paso a paso vamos a crear un Cluster de Amazon EKS en la regin us-east-1 usando 3 zonas de disponibilidad, nuestra propia VPC, un worker group con 3 instancias t2.small y security rules para prevenir acceso no restringido a nuestro worker group. He creado este repositorio en Github https://github.com/aws-samples/picture-social-sample con todo el cdigo necesario para seguir este paso a paso. Asegrate de seleccionar la branch ep3.
In this walkthrough we are going to create an Amazon EKS Cluster on the us-east-1 region using 3 availability zones, our own VPC, a worker group with 3 t2.small instances and security rules to prevent unrestricted access to our worker group.
I created a repository on Github https://github.com/aws-samples/picture-social-sample with all the code needed to follow this walkthrough, make sure you select branch ep3.

• Primero, vamos a clonar nuestro repositorio base para tener todos los archivos de terraform que necesitaremos para crear nuestro cluster.

git clone https://github.com/aws-samples/picture-social-sample --branch ep3

• Una vez clonado, vayamos al directorio creado. Aseguremonos de siempre estar dentro de este directorio por el resto de esta gua, de esa forma todo se ejecutar sin problemas.

cd picture-social-sample

• Ahora que estamos en el directorio correcto y hemos clonado la branch, vamos a iniciar con el archivo config.tf. Este archivo contiene toda la configuracin bsica de nuestro proyecto de Terraform, como: regin por defecto de AWS, nombre del cluster, variables para generar valores aleatorios, etc. Podemos referencias cualquiera de estos valores en el proyecto.

variable "region" {  default     = "us-east-1"  description = "Region of AWS"}provider "aws" {  region = var.region}data "aws_availability_zones" "available" {}locals {  cluster_name = "picturesocial-${random_integer.suffix.result}"}resource "random_integer" "suffix" {  min = 100  max = 999}

• El archivo vpc.tf es donde configuramos nuestra red y zonas de disponibilidad. Si quieres aprender ms sobre VPC, puedes dar una mirada a este link: https://docs.aws.amazon.com/vpc/latest/userguide/vpc-getting-started.html

module "vpc" {  source  = "terraform-aws-modules/vpc/aws"  version = "3.2.0"  name                 = "picturesocial-vpc"  cidr                 = "10.0.0.0/16"  azs                  = data.aws_availability_zones.available.names  private_subnets      = ["10.0.1.0/24", "10.0.2.0/24", "10.0.3.0/24"]  public_subnets       = ["10.0.4.0/24", "10.0.5.0/24", "10.0.6.0/24"]  enable_nat_gateway   = true  single_nat_gateway   = true  enable_dns_hostnames = true  tags = {    "kubernetes.io/cluster/${local.cluster_name}" = "shared"  }  public_subnet_tags = {    "kubernetes.io/cluster/${local.cluster_name}" = "shared"    "kubernetes.io/role/elb"                      = "1"  }  private_subnet_tags = {    "kubernetes.io/cluster/${local.cluster_name}" = "shared"    "kubernetes.io/role/internal-elb"             = "1"  }}

• Ahora que hemos configurado nuestra VPC, vamos a crear los Security Groups. Estos sern los que tienen a cargo la autorizacin o denegacin del trfico a las instancias de EC2 de nuestro Amazon EKS. Para este caso habilitaremos el trafico al puerto 22 de entrada desde algunos segmentos de red llamados cidr_blocks

resource "aws_security_group" "worker_group_mgmt_one" {  name_prefix = "worker_group_mgmt_one"  vpc_id      = module.vpc.vpc_id  ingress {    from_port = 22    to_port   = 22    protocol  = "tcp"    cidr_blocks = [      "10.0.0.0/8",    ]  }}resource "aws_security_group" "worker_group_mgmt_two" {  name_prefix = "worker_group_mgmt_two"  vpc_id      = module.vpc.vpc_id  ingress {    from_port = 22    to_port   = 22    protocol  = "tcp"    cidr_blocks = [      "192.168.0.0/16",    ]  }}resource "aws_security_group" "all_worker_mgmt" {  name_prefix = "all_worker_management"  vpc_id      = module.vpc.vpc_id  ingress {    from_port = 22    to_port   = 22    protocol  = "tcp"    cidr_blocks = [      "10.0.0.0/8",      "172.16.0.0/12",      "192.168.0.0/16",    ]  }}

• El archivo eks-cluster.tf es donde se une todo lo que creamos en los pasos anteriores, usa un mdulo pblico de AWS que podemos reutilizar para simplificar la creacin de nuestro cluster. Vamos a establecer el nombre del cluster referenciando las variables que creamos en el config.tf, seleccionamos la versin de Kubernetes y referenciamos la VPC y subnets definidas en el archivo vpc.tf

module "eks" {  source          = "terraform-aws-modules/eks/aws"  version         = "17.24.0"  cluster_name    = local.cluster_name  cluster_version = "1.20"  subnets         = module.vpc.private_subnets  vpc_id = module.vpc.vpc_id  workers_group_defaults = {    root_volume_type = "gp2"  }  worker_groups = [    {      name                          = "group-1"      instance_type                 = "t2.small"      additional_security_group_ids = [aws_security_group.worker_group_mgmt_one.id]      asg_desired_capacity          = 3    },  ]}data "aws_eks_cluster" "cluster" {  name = module.eks.cluster_id}data "aws_eks_cluster_auth" "cluster" {  name = module.eks.cluster_id}

• Y finalmente vamos a revisar los outputs luego que se entregarn al finalizar la ejecucin del proyecto de Terraform en el archivo outputs.tf Este archivo producir el archivo Config de Kubernetes o kubeconfig, esto es neceario para que Kubectl o el Kubernetes REST API sepa quien eres, si tienes acceso y si puede confiar en ti. Y adems es una de las piezas ms importantes para obtener acceso al cluster de Amazon EKS.

output "cluster_id" {  value       = module.eks.cluster_id}output "cluster_endpoint" {  value       = module.eks.cluster_endpoint}output "cluster_security_group_id" {  value       = module.eks.cluster_security_group_id}output "kubectl_config" {  value       = module.eks.kubeconfig}output "config_map_aws_auth" {  value       = module.eks.config_map_aws_auth}output "region" {  value       = var.region}output "cluster_name" {  value       = local.cluster_name}

• Ahora asegurmonos que tenemos terraform correctamente instalado, vamos a ejecutar el comando a continuacin en el terminal que prefieras. Si todo est bien deberas recibir la versin de Terraform instalada, necesitas al menos la versin 1.1.7.

terraform version

• Ahora vamos a inicializar nuestro proyecto al ejecutar el siguiente comando:

terraform init

• El comando anterior descargar todos los mdulos pblicos y archivos que necesita el proveedor de Terraform para AWS. Si recibes el siguiente mensaje en la lnea de comandos Terraform has been successfully initialized!" entonces estamos listos para continuar. Si recibes algn error, revisa el mensaje de error donde te dirn la lnea y archivo que tienen problemas, no te preocupes el error suele ser un error en nombre de variable o que te falta una comilla :)
• Ahora vamos a probar nuestra configuracin:

terraform plan

• El comando plan retornar un resumen de todas las cosas que se agregarn, cambiarn o destruirn. Esto nos dar una buena idea de cmo funcionar todo antes de ejecutar cambios.

Terraform used the selected providers to generate the following execution plan. Resourceactions are indicated with the following symbols:  + create <= read (data resources)Terraform will perform the following actions:  # data.aws_eks_cluster.cluster will be read during apply  # (config refers to values not yet known) <= data "aws_eks_cluster" "cluster"  {      + arn                       = (known after apply)      + certificate_authority     = (known after apply)      + created_at                = (known after apply)      + enabled_cluster_log_types = (known after apply)      + endpoint                  = (known after apply)      + id                        = (known after apply)      + identity                  = (known after apply)      + kubernetes_network_config = (known after apply)      + name                      = (known after apply)      + platform_version          = (known after apply)      + role_arn                  = (known after apply)      + status                    = (known after apply)      + tags                      = (known after apply)      + version                   = (known after apply)      + vpc_config                = (known after apply)    }  #, . . .*Plan: 50 to add, 0 to change, 0 to destroy.*Changes to Outputs:  + cluster_endpoint          = (known after apply)  + cluster_id                = (known after apply)  + cluster_name              = (known after apply)  + cluster_security_group_id = (known after apply)  + config_map_aws_auth       = [      + {          + binary_data = null          + data        = (known after apply)          + id          = (known after apply)          + metadata    = [              + {                  + annotations      = null                  + generate_name    = null                  + generation       = (known after apply)                  + labels           = {                      + "app.kubernetes.io/managed-by" = "Terraform"                      + "terraform.io/module"          = "terraform-aws-modules.eks.aws"                    }                  + name             = "aws-auth"                  + namespace        = "kube-system"                  + resource_version = (known after apply)                  + uid              = (known after apply)                },            ]        },    ]  + kubectl_config            = (known after apply)  + region                    = "us-east-1"Note: You didn't use the -out option to save this plan, so Terraform can't guarantee to takeexactly these actions if you run "terraform apply"

• Ahora que estamos seguros, vamos a ejecutar los cambios en AWS. Para ello ejecutaremos el comando a continuacin. Debers escribir explcitamente yes para confirmar que ests de acuerdo con los cambios antes de ejecutarlos.

terraform apply

• Este proceso tardar alrededor de 15 a 20 minutos, pero dependiendo de tu propia configuracin puede ser significativamente ms o menos tiempo. Ten en cuenta que tu terminal necesita ser accesible y estar conectada a internet mientras el comando se ejecuta y finaliza la ejecucin. Es un bueno momento para hacerte un buen caf y ver videos de gatos cantando.
• Una vez que el comando termine de ejecutarse, debers recibir el siguiente mensaje:

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

• Vamos a extraer todos los outputs que configuramos en el archivo outputs.tf, esos outputs adems, son parte del mensaje que sale abajo de Apply complete! Todo esto ser usado para construir el kubeconfig. Para extraer esos valores usaremos el comando a continuacin:

aws eks --region $(terraform output --raw region) update-kubeconfig --name $(terraform output --raw cluster_name)

• Estamos Listos! Ahora confirmemos que el cluster ha sido creado correctamente ejecutando el siguiente comando:

aws eks list-clusters

• Si todo funcion como lo esperbamos entonces deberas tener un output similar a este:

{"clusters": ["picturesocial-129"]}

• Si tienes experiencia con Kubernetes y tienes una carga de trabajo que quieras probar, sientete libre de comenzar a jugar. Pero, si no tienes experiencia en cmo desplegar aplicaciones en Kubernetes te sugiero que elimines toda la infraestructura y la re-despliegues en el siguiente episodio, de esa forma evitas cargos innecesarios en tu cuenta por recursos que no usars. Puedes borrar todo ejecutando el siguiente comando:

terraform destroy

Wow! Realmente, este fue un artculo largo pero lo hicimos! Puedes reutilizar esta plantilla para crear tus propios clusters o incluso para crear tus propios mdulos en el futuro.

En el siguiente post aprenderemos a desplegar una aplicacin a Kubernetes y creo que es una de las partes ms satisfactorias de la serie porque es cuando vemos la aplicacin finalmente ejecutandose y aprovechando las ventajas de Kubernetes como self-healing, auto escalamiento, balanceo de carga, etc.

Espero que aprendieras leyendo este post, nos vemos en el siguiente!