header_lecciones_v5

Cómo realizar el despliegue de Clusters para EKS desde Terraform

por Alejandro López, el 30 de junio de 2020

Cómo realizar el despliegue de Clusters para EKS desde Terraform

¿Qué es EKS?

Amazon Elastic Kubernetes Service (Amazon EKS) es un servicio es un servicio almacenado en la nube que te permite ejecutar Kubernetes sin necesidad de crear ni mantener su propio plano de control de Kubernetes. Kubernetes es un sistema de código abierto utilizado para administración y automatización de las aplicaciones en contenedores.

Cómo funciona Amazon Elastic Kubernetes Service (Amazon EKS)

¿Qué es Terraform?

Software utilizado para crear infraestructura como código. Permite a los usuarios definir y configurar la infraestructura en un lenguaje, generando un plan de ejecución para aprovisionar los recursos de infraestructura en proveedores de nube tales como AWS, IBM Cloud.

Para realizar el lanzamiento del clusters es necesario realizar la descarga y la instalación de Terraform como se muestra a continuación.

Instalación de Terraform

A continuación compartimos un tutorial de los pasos para de instalación de terraform para Linux:

1. Descargar el paquete

Descargar el paquete según la plataforma. El paquete puede descargarse desde https://www.terraform.io/downloads.html

Sistemas operativos compatibles con Terraform:

Linux: 32­bit | 64­bit | Arm
Windows: 32­bit | 64­bit
Mac OS X: 64­bit

Para nuestro caso realizaremos la instalación en un sistema operativo Linux, Seleccionamos el sistema operativo y procedemos con la instalación:

Crear un directorio para los binarios de Terraform:

[user@pc Descargas]# mkdir /opt/terraform

Mover el archivo descargado anteriormente al interior del directorio:

[user@pc Descargas]# mv terraform_0.12.24_linux_amd64.zip /opt/terraform/

Nos situamos en el directorio terraform y descomprimimos los binarios:

[user@pc Descargas]# cd /opt/terraform/
[user@pc terraform]# unzip terraform_0.12.24_linux_amd64.zip
Archive: terraform_0.12.24_linux_amd64.zip
inflating: terraform

Exportamos las variables de entorno para añadir el directorio de Terraform al PATH del sistema (variable $PATH):

[user@pc terraform]# export PATH="$PATH:/opt/terraform"

Por último comprobamos que se ha instalado bien ejecutando el comando siguiente:

[user@zenbook terraform]# terraform --version
terraform_0.12.24

Despliegue de cluster EKS v 1.15

Primero es necesario definir variables para nuestra configuración y así tener una mejor implementación del EKS, para ello vamos a crear un archivo llamado variable.tf (Extension Terraform) los cuales van a contener los siguientes datos:

Explicar cada variable

//Las Variables aws access y secret Key son solicitadas para el ingreso a nuestra de AWS donde vamos a desplegar:

variable "aws_access_key" {}
variable "aws_secret_key" {}

//Con esta variable definimos el Nombre de nuestro cluster
variable "cluster-name" {
default = "eks-prueba"
type = "string"
}
//Con esta variable definimos nuestra Subnet
variable "private_net_cidr" {
description = "CIDR for the Private Subnet 1"
default = "/16"
}
//Esta Variable se define para establecer la región es North Virginia(us-east-1))
variable "aws_region" {
description = "AWS Region to launch servers."
default = "us-east-1"
}
//Esta variable es utilizada para definir la versión del EKS para Utilizar
variable "eks_version" {
description = "AWS eks_version"
default = "1.15"
}

// Esta Variable es Utilizada para Indetificar Responbles, Marcar, Ambiente, etc (TAGS)
variable "responsable" {
default = "Kappa"
}

En el siguiente archivo nombrado como vpceks.tf vamos a definir todos los parámetros necesarios para crear las subnets de la VPC que definamos, las cuales van a asociarse a la configuración de nuestro cluster en EKS, a continuación Se procede a crear una VPC para luego desde el recurso “aws_subnet” con el parámetro “count” definir qué cantidad de subnets se van a crear para luego asociarlas al cluster del EKS.

data "aws_availability_zones" "available" {}

resource "aws_vpc" "prueba_eks" {
cidr_block ="${var.private_net_cidr}"

tags = "${
map(
"Name", "terraform-eks-prueba",
"kubernetes.io/cluster/${var.cluster-name}", "shared",
"Responsable", var.responsable,
)
}"
}
//privadas
resource "aws_subnet" "prueba_eks" {
count = 3
availability_zone = "${data.aws_availability_zones.available.names[count.index + 1]}"
cidr_block = "10.60.${count.index + 4}.0/24"
vpc_id = "${aws_vpc.prueba_eks.id}"
map_public_ip_on_launch = "true"
tags = "${
map(
"Name", "terraform-eks-prueba",
"kubernetes.io/cluster/${var.cluster-name}", "shared",
"Responsable", var.responsable,
)
}"
lifecycle {
ignore_changes = ["cidr_block"]
}

También como requisito es necesario crear un grupo de seguridad para controlar quién puede acceder a nuestro cluster de EKS

resource "aws_security_group" "eks-prueba-cluster" {
name = "prueba-Cluster-sg"
description = "Cluster communication with worker nodes"
vpc_id = "${aws_vpc.prueba_eks.id}"

egress {
from_port = 0
to_port = 0
protocol = "-1"
cidr_blocks = ["0.0.0.0/0"]
}
ingress {
from_port = 0
to_port = 0
protocol = "-1"
cidr_blocks = ["10.50.0.0/16"]
}

tags = {
Name = "eks-prueba"
Responsable = var.responsable
}
}

# OPTIONAL: Allow inbound traffic from your local workstation external IP
#to the Kubernetes. You will need to replace A.B.C.D below with
#your real IP. Services like icanhazip.com can help you find this.
resource "aws_security_group_rule" "eks-cluster-ingress-workstation-https" {
cidr_blocks = ["0.0.0.0/0"]
description = "Allow workstation to communicate with the cluster API Server"
from_port = 443
protocol = "tcp"
security_group_id = "${aws_security_group.eks-prueba-cluster.id}"
to_port = 443
type = "ingress"
}

Para finalizar nuestros requisitos es necesario crear un archivo nombrado role.tf, donde se realiza la creación del rol con la asociación de las políticas requeridas para el funcionamiento del cluster de nuestro EKS

resource "aws_iam_role" "ekspruebacluster" {
name = "eks-prueba-cluster"

assume_role_policy = <<POLICY
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "eks.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
POLICY
}

resource "aws_iam_role_policy_attachment" "eks-cluster-AmazonEKSClusterPolicy" {
policy_arn = "arn:aws:iam::aws:policy/AmazonEKSClusterPolicy"
role = "${aws_iam_role.ekspruebacluster.name}"
}

resource "aws_iam_role_policy_attachment" "eks-cluster-AmazonEKSServicePolicy" {
policy_arn = "arn:aws:iam::aws:policy/AmazonEKSServicePolicy"
role = "${aws_iam_role.ekspruebacluster.name}"
}

Luego de realizar el aprovisionamiento de los prerrequisitos para crear el cluster del EKS, procedemos a crear un archivo nombrado eks_cluster.tf donde se definen los parámetros configurados anteriormente

resource "aws_eks_cluster" "prueba_eks" {
name = "${var.cluster-name}"
role_arn = "${aws_iam_role.eksprueba.arn}"
versión = "${var.eks version}"

vpc_config {
security_group_ids = ["${aws_security_group.eks-cluster-familia.id}"]
subnet_ids = "${aws_subnet.familia_eks_dev.*.id}"
endpoint_private_access = "true"
endpoint_public_access = "true"
}

tags = {
Name = var.cluster-name
Marca = var.marca
Submarca = var.submarca
Ambiente = var.ambiente
Responsable = var.responsable
}

depends_on = [
"aws_iam_role_policy_attachment.eks-cluster-AmazonEKSClusterPolicy",
"aws_iam_role_policy_attachment.eks-cluster-AmazonEKSServicePolicy",
]
}

Luego de realizar la configuración de nuestro cluster almacenamos todo estos archivos en una misma carpeta desde allí vamos a ejecutar nuestro cluster desde el terraform, para nuestro caso creamos una carpeta llama eks_prueba utilizando el siguiente comando:

mkdir eks_prueba

y allí almacenamos todos nuestros archivos:

prerrequisitos para crear el cluster del eks

Como se puede observar se tiene un archivo llamado aws.tf, contiene el siguiente código

provider "aws" {
access_key = "${var.aws_access_key}"
secret_key = "${var.aws_secret_key}"
region = "${var.aws_region}"
}

Este “provider” se utiliza para poder interactuar con con los servicios de AWS donde se realiza el setup de las credenciales.

Antes de empezar es necesario realizar la creación del perfil con las credenciales para acceder a los servicios, en esta lección de academia se explica cómo realizarlo:

  1. Modos de Acceso a los Recursos de AWS
  2. Luego de realizar la configuración del perfil, nos dirigimos para nuestra carpeta
  3. Ya allí ubicados realizamos la activación de el Terraform esto sea hace con el comando: Terraform init
  4. Con este comando iniciamos todo el proceso en el directorio, luego de lanzar el comando anterior, ejecutamos el comando Terraform Plan
  5. Con el comando anterior podemos observar qué cambios o qué servicios vamos lanzar, para finalizar ejecutamos el comando Terraform apply
  6. Para aplicar los cambios o realizar el despliegue de los servicios que se evidencian en el tTrraform plan
  7. Y listo tenemos nuestro Cluster en AWS desplegado desde Terraform

Nueva llamada a la acción

Temas:Desarrollo de Software

Lecciones Pragma

Lecciones en Academia Pragma

Aquí encontrarás tutoriales técnicos para que apliques en temas de desarrollo de software, cloud, calidad en software y aplicaciones móviles. 

También puedes visitar nuestro Blog con contenido actual sobre Transformación Digital, Marketing, Conocimiento de Usuario y más. 

Blog

Suscríbete a la academia

Descarga la Guía para trabajar con ambientes IBM Websphere Portal