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

Este post será um tutorial passo a passo. Se você quiser acompanhar, certifique-se de ter o seguinte em vigor:

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 rodando 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 a infraestrutura com segurança e eficiência. O Terraform utiliza diferentes tipos de arquivos de configuração. Cada arquivo é escrito em formato de texto simples (.tf) ou formato JSON (.tfjson).

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

1. Abra um terminal.

2. Crie uma pasta chamada ~/terraform-eks-cluster-demo, e depois altere (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 seu editor de código favorito e copie/cole a seguinte configuração e salve-a em um arquivo 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 funções de Identidade e Acesso da AWS (IAM) (terraformekscluster) – Este recurso será gerenciado pelo Amazon EKS e fará chamadas a outros serviços da AWS, como AWS S3, CloudWatch, etc., em seu nome para gerenciar os recursos que você usa com o serviço.
Um grupo de segurança do AWS EC2 (resource “aws_security_group” “eks-cluster”) – Permite o tráfego de rede de entrada e saída 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 e para fora do cluster. 0.0.0.0/0 é o endereço IP da Internet.
Cluster EKS (terraformEKScluster) – Este cluster EKS será a versão 1.19.
Um papel IAM para nós EKS fazerem chamadas a 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á através do atributo scaling_config.

# Criando função IAM para clusters Kubernetes fazerem chamadas a outros serviços AWS em seu nome para gerenciar os recursos que você usa com o 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 tráfego de rede de e para o Cluster AWS EKS.

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 vindo 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 de VPC

  vpc_config {             # Configurar EKS com vpc e configurações de 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 nós EKS trabalharem com outros serviços 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 do nó.

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. Criar outro arquivo em ~/terraform-eks-cluster-demo nomeá-lo 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 EKS Terraform

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

Vamos seguir 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 arquivos de configuração esteja correta e fornecer um esboço dos recursos que serão provisionados em sua infraestrutura.

terraform plan

Se 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 os dispositivos 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 criados!

terraform apply

Verificando o Cluster AWS EKS

Neste ponto, você deve ter um cluster AKS funcionando, mas vamos verificar para garantir na Console de Gerenciamento da AWS.

1. Abra seu navegador da web favorito, navegue até a Console de Gerenciamento da AWS e faça login.

2. Clique na barra de pesquisa no topo, pesquise por EKS e clique no item de menu Elastic Kubernetes Service. Você deve 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, como 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?