Aproveitando o Módulo Terraform EKS para Criar um Cluster EKS – techsyncer

Se você precisa configurar o cluster AWS Elastic Kubernetes Service (Amazon EKS) com Terraform, está com sorte. Usando o módulo Terraform EKS e todos os outros recursos necessários, você pode criar uma configuração Terraform e criar um cluster AKS com código.

O Amazon EKS é um serviço gerenciado para executar o Kubernetes na AWS sem instalar, operar e manter seu próprio cluster Kubernetes. Construir um cluster EKS com Terraform permite criar recursos rapidamente, de forma eficiente e com uma abordagem automatizada.

Neste tutorial, você aprenderá como construir e executar uma configuração Terraform para criar um cluster EKS com Terraform passo a passo. Vamos começar!

Pré-requisitos

Esta postagem será um tutorial passo a passo. Se deseja acompanhar, certifique-se de ter o seguinte em mãos:

Uma conta 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 usará o Terraform v0.14.9 em execução no Ubuntu 18.04.5 LTS, mas qualquer sistema operacional com Terraform deve funcionar.

Construindo a Configuração do Terraform para um Cluster AWS EKS

O Terraform é uma ferramenta de infraestrutura como código que permite construir, alterar e versionar infraestrutura de forma segura e eficiente. O Terraform utiliza diferentes tipos de arquivos de configuração. Cada arquivo é escrito ou no formato de texto simples (.tf) ou no formato JSON (.tfjson).

Vamos primeiro criar uma configuração do Terraform que irá criar um cluster AKS do zero quando aplicado.

1. Abra um terminal.

2. Crie uma pasta chamada ~/terraform-eks-cluster-demo, e depois mude (cd) o diretório de trabalho para essa pasta. Esta pasta conterá todos os arquivos de configuração com os quais você estará trabalhando.

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

3. Em seguida, abra o seu editor de código favorito e copie/cole a seguinte configuração, e salve-a em um arquivo chamado main.tf dentro de ~/terraform-eks-cluster-demo. Este arquivo main.tf é a configuração do Terraform para o cluster AKS.

O arquivo main.tf contém todos os recursos necessários para provisionar um cluster EKS:

Um papel de Gerenciamento de Identidade e Acesso (IAM) da Amazon Web Services (AWS) (terraformekscluster) – Este recurso será gerenciado pelo Amazon EKS e fará chamadas para outros serviços da AWS, como AWS S3, CloudWatch, etc., em seu nome para gerenciar os recursos que você utiliza com o serviço.
Um grupo de segurança AWS EC2 (resource "aws_security_group" "eks-cluster") – Permite tráfego de entrada e saída da rede do cluster AWS EKS. Você lançará um grupo de segurança chamado SG-eks-cluster anexado via um ID de VPC, permitindo que todo o tráfego flua para dentro/saia do cluster. 0.0.0.0/0 é o endereço IP da Internet.
Cluster EKS (terraformEKScluster) – Este cluster EKS será da versão 1.19.
Um papel IAM para nós EKS fazerem chamadas para outros serviços da AWS (eks-node-group). Este papel está anexado a uma política que permite assumir as credenciais de segurança temporárias na instância para acessar outros recursos da AWS.
Grupo de nós do cluster EKS (node_group1) – Este recurso define o número de nós que um cluster terá via o atributo scaling_config.

# Criando função IAM para os clusters Kubernetes realizar chamadas em seu nome para gerenciar os recursos que você utiliza no serviço.

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
}

# Anexando as políticas do EKS-Cluster à função 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 segurança para o tráfego de rede de e para o AWS EKS Cluster.

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

# Egress permite tráfego de saída do cluster EKS para a Internet

  egress {                   # Regra de saída
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
# Ingress permite tráfego de entrada para o cluster EKS da Internet

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

}

# Criando o cluster EKS

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

# Adicionando Configuração VPC

  vpc_config {             # Configurar o EKS com as configurações de VPC e rede
   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",
   ]
}

# Criando função IAM para os nós do EKS trabalharem com outros serviços da 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
}

# Anexando diferentes políticas aos membros dos nós.

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
}

# Criar grupo de nós do cluster 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. Crie outro arquivo em ~/terraform-eks-cluster-demo, nomeie-o provider.tf e cole o conteúdo abaixo. O arquivo do provedor define provedores como AWS, Oracle, ou Azure, etc., para que o Terraform possa se conectar aos serviços em nuvem corretos.

O tutorial criará recursos na região us-east-2.

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

5. Verifique se todos os arquivos necessários abaixo estão presentes na pasta executando o comando tree.

Criando o Cluster AWS EKS com um Módulo Terraform EKS

Agora que você tem o arquivo de configuração Terraform e os arquivos de variáveis prontos para serem usados, é hora de iniciar o Terraform e criar o cluster. Para provisionar o cluster AKS, como em todas as outras configurações do Terraform, o Terraform utiliza três comandos (terraform init → terraform plan → terraform apply).

Vamos passar por cada etapa agora.

1. Abra um terminal e navegue até o diretório ~/terraform-eks-cluster-demo. cd ~/terraform-eks-cluster-demo

cd ~/terraform-eks-cluster-demo

2. Execute o comando terraform init no mesmo diretório. O comando terraform init inicializa os plugins e provedores necessários para trabalhar com recursos.

terraform init

Se tudo correr bem, você deverá ver a mensagem O Terraform foi inicializado com sucesso na saída, como mostrado abaixo.

3. Agora, execute o comando terraform plan. Executar terraform plan não é necessário, mas é uma ação recomendada para garantir que a sintaxe dos seus arquivos de configuração esteja correta e forneça um plano dos recursos que serão provisionados na sua infraestrutura.

terraform plan

Se for bem-sucedido, você deverá ver uma mensagem como Plano: “X” para adicionar, “Y” para alterar ou “Z” para destruir na saída.

4. Em seguida, execute terraform apply para remover as rodas de treinamento e invocar o Terraform para criar o cluster AKS. Invocar terraform apply lê cada configuração (*.tf) no diretório atual para compilar um arquivo de estado enviado para a AWS para construir o cluster EKS e outros componentes.

A AWS cobra $0,10 por hora para cada cluster EKS. Certifique-se de destruir quaisquer clusters de teste que você tenha criado uma vez concluídos!

terraform apply

Verificando o Cluster AWS EKS

Neste ponto, você deverá ter um cluster AKS funcional construído, mas vamos verificar para ter certeza no Console de Gerenciamento da AWS.

1. Abra seu navegador da web favorito, vá para o Console de Gerenciamento da AWS e faça login.

2. Clique na barra de pesquisa no topo, procure por EKS e clique no item de menu Elastic Kubernetes Service. Você deverá ver o cluster EKS terraformEKScluster.

3. Clique em Configuração, e você deverá ver cada componente criado com sucesso que você definiu na configuração do Terraform, conforme mostrado abaixo.

Conclusão

Neste tutorial, você aprendeu como usar o Terraform para implantar um Cluster AWS EKS e seus componentes. Agora você está pronto para usar este Cluster EKS e implantar aplicativos!

Quais aplicativos você planeja implantar em seu novo cluster?