Dentro del mundo de los servidores está habiendo una revolución en la automatización del despliegue de servidores. Proyectos como Ansible, Chef o Puppet se han convertido en herramientas fundamentales a la hora de gestionar servidores en masa de una manera eficiente. Pero con la llegada del mundo de la cloud se ha visto necesario automatizar la creación de los servidores y las herramientas que debemos instalar. En esta ocasión cómo crear una cluster EKS en AWS con  Terraform.

Recuerda que esta guía es una continuación de la primera parte para instalar y configurar terraform con AWS y DigitalOcean.  Ahora iremos viendo los recursos que son necesarios para el despliegue del cluster EKS en AWS. En esta ocasión nos apoyaremos en el módulo de terraform de eks.

Variables

Definir las variables nos permitirá que nuestro código de despliegue sea mucho más reutilizable, ya que cambiando estas variables podremos desplegar distintas máquinas con distintas configuraciones.

Las variables mínimas de funcionamiento que necesitamos para gestionar éste cluster EKS son las siguientes, por ejemplo en el main.tf:

variable "project_name" {}
variable "region" {}


• • Project name: sería como el nombre del proyecto, esto nos va a permitir que los nombres de los distintos recursos que tenemos que crear se relacionen entre sí editando los nombres o etiquetas de cada componente a desplegar.
  • Region name: es el nombre de la región donde queremos hacer el despliegue: en nuestro caso será eu-west-3 el data center de París. Es muy importante que revises usar l aregión correcta porque dependiendo de la región puedes disponer de recursos desplegados distintos.

Provider

Como siempre elegiremos el proveedor que necesitamos, en este caso aws:

provider "aws" {
region = var.region
}

Como se puede ver, usamos la variable definida var.region para rellenar el provider.  Recuerda que puedes definir esta variable en el fichero terraform.tfvars


region="eu-west-3"

Al igual que peudes definir todas las variables que necesites.

Versiones

Para verificar que tenemos acceso a todos los proveedores y versiones la incluiremos en el fichero:

terraform {
required_version = ">= 0.12"
}

provider “random” {
version = “~> 2.1”
}

provider “local” {
version = “~> 1.2”
}

provider “null” {
version = “~> 2.1”
}

provider “template” {
version = “~> 2.1”
}

VPC

Como la arquitecura interna de un cluster EKS es muy compleja y no queremos tocar la VPC por defecto para que no afecte a nuestros depsliegues anteriores tendremos que crear una nueva VPC. Las VPC son las redes asignadas a nuestra cuenta de AWS y tienen muchas configuraciones. Por lo que para simplificar el despliegue usaremos el módulo de vpc de aws para terraform.
Primero accedmos a las zonas disponibles en nuestra región, generamos una cadena random para generar el nombre del cluster y lo almacenamos en una variable local.

data "aws_availability_zones" "available" {}

resource “random_string” “suffix” {
length = 8
special = false
}

locals {
cluster_name = “${var.project_name}-eks-${random_string.suffix.result}”
}

Después crearemos la vpc en sí misma, usamos como fuente el módulo de vpc, modificamos su nombre para facilitar si seguimiento, creamos las redes privadas y públicas:

module "vpc" {
source = "terraform-aws-modules/vpc/aws"
version = "2.6.0"

name = “${var.project_name}-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-${local.cluster_name}” = “1”
}

private_subnet_tags = {
“kubernetes.io/cluster/${local.cluster_name}” = “shared”
“kubernetes.io/role/internal-elb-${local.cluster_name}” = “1”
}
}

Security Groups

Los segurity group son reglas de firewall para la red donde nos encontremos, que luego podremos aplicar a nuestras VPS de EC2. Vemos un ejemplo para aplicar acceso ssh a los nodos del cluster en cada red definida antes:


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”,
]
}
}

En este caso estamos definiendo una regla que permite el tráfico al puerto SSH (22) desde las distintas redes a nuestras subresed. Luego deberemos asociar estos grupos a nuestro cluster.


Cluster EKS

Ahora ya podemos definir nuestro nuevo cluster EKS.

En este caso, es donde asociamos todos los datos anteriores

module "eks" {
source = "terraform-aws-modules/eks/aws"
cluster_name = "${var.project_name}-${local.cluster_name}"
subnets = module.vpc.private_subnets

tags = {
Environment = “${var.project_name}-testing”
GithubRepo = “terraform-aws-eks”
GithubOrg = “terraform-aws-modules”
}

vpc_id = module.vpc.vpc_id

worker_groups = [
{
name = “worker-group-1”
instance_type = “t2.small”
additional_userdata = “echo foo bar”
asg_desired_capacity = 1
additional_security_group_ids = [aws_security_group.worker_group_mgmt_one.id]
},
{
name = “worker-group-2”
instance_type = “t2.medium”
additional_userdata = “echo foo bar”
additional_security_group_ids = [aws_security_group.worker_group_mgmt_two.id]
asg_desired_capacity = 1
},
]
}

Elementos definidos:

• módulo de EKS
• nombre del cluster
• las sub redes
• la VPC creada
• Los grupos de Workers:Ojo que cada grupo define el tamaño de la máquina y el número de máquinas por grupo, lo suyo serían al menos 3 en cada grupo
  • públicos
  • privados

Ouputs/Salidas

En este caso definiremos las variables necesarias para interactuar con la máquina:

output "cluster_endpoint" {
description = "Endpoint for EKS control plane."
value = module.eks.cluster_endpoint
}

output “cluster_security_group_id” {
description = “Security group ids attached to the cluster control plane.”
value = module.eks.cluster_security_group_id
}

output “kubectl_config” {
description = “kubectl config as generated by the module.”
value = module.eks.kubeconfig
}

output “config_map_aws_auth” {
description = “A kubernetes configuration to authenticate to this EKS cluster.”
value = module.eks.config_map_aws_auth
}

output “region” {
description = “AWS region”
value = var.region
}

output “cluster_name” {
description = “Kubernetes Cluster Name”
value = local.cluster_name
}

Despliegue

Ahora ya sólo nos faltaría hacer los pasos de siempre:

• $ terraform validate
• $ terraform plan
• $ terraform apply
• $ terraform apply -auto-approve
• y para borrar la infraestrcutura $ terraform destroy

Ojo que esta vez los depsliegues pueden llegar tardar fácilmente 10 minutos.