Aprovechando el Módulo Terraform EKS para Crear un Clúster EKS

Tutoriales
Terraform

Si necesitas configurar un clúster de Servicio Elástico de Kubernetes de AWS (Amazon EKS) con Terraform, estás de suerte. Utilizando el módulo de Terraform para EKS y todos los demás recursos necesarios, puedes crear una configuración de Terraform y crear un clúster de AKS con código.

Amazon EKS es un servicio gestionado para ejecutar Kubernetes en AWS sin necesidad de instalar, operar y mantener tu propio clúster de Kubernetes. Construir un clúster de EKS con Terraform te permite crear recursos rápidamente, eficientemente y con un enfoque automatizado.

En este tutorial, aprenderás cómo construir y ejecutar una configuración de Terraform para crear un clúster de EKS con Terraform paso a paso. ¡Empecemos!

Requisitos previos

Esta publicación será un tutorial paso a paso. Si deseas seguirlo, asegúrate de tener lo siguiente en su lugar:

  • Una cuenta de Amazon Web Service (AWS).
  • A code editor – Even though you can use any text editor to work with Terraform configuration files, you should consider Visual Studio (VS) Code as it understands the HCL Terraform language well.
  • Terraform – Este tutorial utilizará Terraform v0.14.9 ejecutándose en Ubuntu 18.04.5 LTS, pero cualquier sistema operativo con Terraform debería funcionar.

Relacionado:Cómo Instalar Terraform en Windows

Construyendo la Configuración de Terraform para un Clúster AWS EKS

Terraform es una herramienta de infraestructura como código que te permite construir, cambiar y versionar la infraestructura de manera segura y eficiente. Terraform utiliza diferentes tipos de archivos de configuración. Cada archivo está escrito ya sea en formato de texto plano (.tf) o en formato JSON (.tfjson).

Primero creemos una configuración de Terraform que creará un clúster AKS desde cero al aplicarlo.

1. Abre una terminal.

2. Crea una carpeta llamada ~/terraform-eks-cluster-demo, luego cambia (cd) al directorio de trabajo a esa carpeta. Esta carpeta contendrá todos los archivos de configuración con los que trabajarás. 

mkdir ~/terraform-eks-cluster-demo
cd ~/terraform-eks-cluster-demo

3. A continuación, abre tu editor de código favorito y copia/pega la siguiente configuración, y guárdala en un archivo llamado main.tf dentro de ~/terraform-eks-cluster-demo. Este archivo main.tf es la configuración de Terraform para el clúster AKS.

El archivo main.tf contiene todos los recursos necesarios para aprovisionar un clúster EKS:

  • Un rol de Administración de Identidad y Acceso de AWS (IAM) (terraformekscluster) – Este recurso será administrado por Amazon EKS y realizará llamadas a otros servicios de AWS como AWS S3, CloudWatch, etc., en su nombre para gestionar los recursos que utiliza con el servicio.
  • Un grupo de seguridad de EC2 de AWS (recurso "aws_security_group" "eks-cluster") – Permite el tráfico de red entrante y saliente desde el clúster de AWS EKS. Lanzará un grupo de seguridad llamado SG-eks-cluster adjunto mediante un ID de VPC, permitiendo que todo el tráfico fluya hacia/desde el clúster. 0.0.0.0/0 es la dirección IP de Internet.
  • Clúster EKS (terraformEKScluster) – Este clúster EKS será de la versión 1.19.
  • Un rol IAM para los nodos de EKS para realizar llamadas a otros servicios de AWS (eks-node-group). Este rol está adjunto con una política que permite asumir las credenciales de seguridad temporales en la instancia para acceder a otros recursos de AWS.
  • Grupo de nodos del clúster EKS (node_group1) – Este recurso define el número de nodos que tendrá un clúster a través del atributo scaling_config.
# Creando rol IAM para clústeres de Kubernetes para realizar llamadas a otros servicios de AWS en tu nombre y gestionar los recursos que utilizas con el servicio.

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

# Adjuntando las políticas del clúster EKS al rol terraformekscluster.

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


# Grupo de seguridad para el tráfico de red hacia y desde el clúster AWS EKS.

resource "aws_security_group" "eks-cluster" {
  name        = "SG-eks-cluster"
  vpc_id      = "vpc-123456789"  

# Egress permite el tráfico saliente desde el clúster EKS a Internet.

  egress {                   # Regla de salida
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
# Ingress permite el tráfico entrante al clúster EKS desde Internet.

  ingress {                  # Regla de entrada
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }

}

# Creando el clúster EKS

resource "aws_eks_cluster" "eks_cluster" {
  name     = "terraformEKScluster"
  role_arn =  "${aws_iam_role.iam-role-eks-cluster.arn}"
  version  = "1.19"

# Agregando configuración de VPC

  vpc_config {             # Configurar EKS con VPC y configuraciones de red
   security_group_ids = ["${aws_security_group.eks-cluster.id}"]
   subnet_ids         = ["subnet-1312586","subnet-8126352"] 
    }

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

# Creando rol IAM para nodos EKS para trabajar con otros servicios de AWS.


resource "aws_iam_role" "eks_nodes" {
  name = "eks-node-group"

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

# Adjuntando diferentes políticas a los miembros del nodo.

resource "aws_iam_role_policy_attachment" "AmazonEKSWorkerNodePolicy" {
  policy_arn = "arn:aws:iam::aws:policy/AmazonEKSWorkerNodePolicy"
  role       = aws_iam_role.eks_nodes.name
}

resource "aws_iam_role_policy_attachment" "AmazonEKS_CNI_Policy" {
  policy_arn = "arn:aws:iam::aws:policy/AmazonEKS_CNI_Policy"
  role       = aws_iam_role.eks_nodes.name
}

resource "aws_iam_role_policy_attachment" "AmazonEC2ContainerRegistryReadOnly" {
  policy_arn = "arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryReadOnly"
  role       = aws_iam_role.eks_nodes.name
}

# Crear grupo de nodos del clúster EKS

resource "aws_eks_node_group" "node" {
  cluster_name    = aws_eks_cluster.eks_cluster.name
  node_group_name = "node_group1"
  node_role_arn   = aws_iam_role.eks_nodes.arn
  subnet_ids      = ["subnet-","subnet-"]

  scaling_config {
    desired_size = 1
    max_size     = 1
    min_size     = 1
  }

  depends_on = [
    aws_iam_role_policy_attachment.AmazonEKSWorkerNodePolicy,
    aws_iam_role_policy_attachment.AmazonEKS_CNI_Policy,
    aws_iam_role_policy_attachment.AmazonEC2ContainerRegistryReadOnly,
  ]
}

4. Crear otro archivo en ~/terraform-eks-cluster-demo nómbralo provider.tf y pega el contenido a continuación. El archivo del proveedor define proveedores como AWS, Oracle o Azure, etc., para que Terraform pueda conectarse con los servicios en la nube correctos.

El tutorial creará recursos en la región us-east-2. 

provider "aws" {
   region = "us-east-2"
 }

5. Verifique que todos los archivos requeridos a continuación estén presentes en la carpeta ejecutando el comando tree.

The folder structure of Terraform files

Creación del clúster AWS EKS con un Módulo Terraform EKS

Ahora que tiene el archivo de configuración Terraform y los archivos de variables listos para usar, es hora de iniciar Terraform y crear el clúster. Para aprovisionar el clúster AKS, al igual que con todas las demás configuraciones de Terraform, Terraform utiliza tres comandos (terraform init → terraform plan → terraform apply).

Vamos a repasar cada etapa ahora.

1. Abra una terminal y navegue hasta el directorio ~/terraform-eks-cluster-demo. cd ~/terraform-eks-cluster-demo

cd ~/terraform-eks-cluster-demo

2. Ejecute el comando terraform init en el mismo directorio. El comando terraform init inicializa los complementos y proveedores necesarios para trabajar con recursos.

terraform init

Si todo va bien, deberías ver el mensaje Terraform se ha inicializado correctamente en la salida, como se muestra a continuación.

Initializing the terraform

3. Ahora, ejecuta el comando terraform plan. Ejecutar terraform plan no es necesario, pero es una acción recomendada para asegurarte de que la sintaxis de tus archivos de configuración sea correcta y te brinde un plan de los recursos que se aprovisionarán en tu infraestructura. 

terraform plan

Si tienes éxito, deberías ver un mensaje como Plan: “X” para agregar, “Y” para cambiar o “Z” para destruir en la salida.

Running the plan command in Terraform

4. A continuación, ejecuta terraform apply para quitar las ruedas de entrenamiento e invocar a Terraform para crear el clúster AKS. Invocar terraform apply lee cada archivo de configuración (*.tf) en el directorio actual para compilar un archivo de estado enviado a AWS para construir el clúster EKS y otros componentes.

AWS cobra $0.10 por hora por cada clúster EKS. ¡Asegúrate de destruir cualquier clúster de prueba que hayas creado una vez terminado! 

terraform apply
Running the Terraform apply command

Verificación del Clúster AWS EKS

En este punto, deberías tener un clúster AKS funcional construido, pero verifiquemos para estar seguros en la Consola de Administración de AWS.

1. Abre tu navegador web favorito, ve a la Consola de Administración de AWS e inicia sesión.

2. Haz clic en la barra de búsqueda en la parte superior, busca EKS y haz clic en la opción de Elastic Kubernetes Service. Deberías ver el clúster EKS terraformEKScluster.

Navigating to the EKS service
Checking the terraformEKS Cluster

3. Haz clic en Configuración, y deberías ver que cada componente se ha creado correctamente según lo que definiste en la configuración de Terraform, como se muestra a continuación.

Node Role and EKS cluster role.
Security group applied on EKS Cluster.
Node group node_group1

Conclusión

En este tutorial, has aprendido cómo usar Terraform para implementar un clúster AWS EKS y sus componentes. ¡Ahora estás listo para usar este clúster EKS y desplegar aplicaciones!

¿Qué aplicaciones planeas implementar en tu recién creado clúster?

Source:
https://adamtheautomator.com/terraform-eks-module/