Amazon Elastic Kubernetes Service (EKS)

A orquestração de contêineres tornou-se uma peça fundamental no desenvolvimento e implantação de aplicativos modernos e escaláveis. Com a crescente demanda por gerenciamento de contêineres em larga escala, surgiram várias soluções, incluindo o Kubernetes, um sistema de código aberto amplamente utilizado. No entanto, a implantação e o gerenciamento de um cluster Kubernetes podem ser complexos e desafiadores. É aqui que o Amazon Elastic Kubernetes Service (EKS) entra em cena.

Propósito do EKS

É um serviço gerenciado oferecido pela Amazon Web Services (AWS) que simplifica a implantação, a execução e o dimensionamento de aplicativos em contêineres usando o Kubernetes. O EKS remove a complexidade da configuração e gerenciamento de um cluster Kubernetes, permitindo que os desenvolvedores se concentrem em criar aplicativos, em vez de se preocuparem com a infraestrutura subjacente.

Vantagens do EKS

1. Facilidade de implantação: O EKS permite que os desenvolvedores implantem facilmente seus aplicativos em contêineres, sem a necessidade de configurar e gerenciar a infraestrutura do Kubernetes. A AWS cuida de tarefas complexas, como provisionamento de servidores, balanceamento de carga e escalonamento automático, simplificando a implantação e o gerenciamento de aplicativos.
2. Escalabilidade e disponibilidade: O EKS é altamente escalável e oferece alta disponibilidade para os aplicativos em contêineres. Ele monitora constantemente o estado do cluster e ajusta automaticamente a capacidade para atender à demanda do aplicativo. Isso garante que os aplicativos estejam sempre disponíveis, mesmo em momentos de tráfego intenso.
3. Segurança e conformidade: O EKS incorpora as práticas recomendadas de segurança da AWS. Ele oferece recursos avançados de segurança, como isolamento de rede, integração com serviços de autenticação da AWS e controles de acesso granulares. Além disso, o EKS é compatível com vários padrões de conformidade, como HIPAA, PCI DSS e ISO 27001, tornando-o uma escolha confiável para aplicativos sensíveis.

Comparação com a instalação On-premises

A instalação On-premises do Kubernetes requer que as organizações configurem e gerenciem seus próprios clusters Kubernetes em seu próprio data center. Isso envolve a aquisição de hardware, a configuração da infraestrutura, a instalação do Kubernetes e a manutenção contínua do cluster. Comparado a essa abordagem tradicional, o EKS oferece várias vantagens significativas, dentre elas está a menor complexidade: Com o EKS, as organizações podem evitar a complexidade de configurar e gerenciar a infraestrutura do Kubernetes. A AWS assume a responsabilidade de provisionar servidores, escalonamento automático e balanceamento.

Instalando um Cluster EKS utilizando Terraform

Configuração do ambiente

• Certifique-se de ter o Terraform instalado em sua máquina local.
• Instale a AWS CLI (Command Line Interface) e configure suas credenciais de acesso à AWS.

Estrutura do diretório

O projeto está disponibilizado no github. Faça o clone do repositório e siga os proximos passos.

.
└── ec2
    ├── curso
    │   ├── main.tf
    ├── infra
    │   ├── eks.tf
    │   ├── Provider.tf
    │   ├── securityGroup.tf
    │   ├── Variables.tf
    │   └── vpc.tf
    └── README.md

O arquivo main.tf é o arquivo inicial onde todas os module, datas e resources são definidos. Para uma melhor visualização e administração do código, estou dividindo as configurações em arquivos separados conforme a visão da estrutura de diretório acima. Os nomes utilizados aqui é escolha pessoal, então fique a vontade para definir os seus.

Vamos criar um diretório com dois sub-diretórios. Siga os passos.

mkdir -p kubernetes/{curso,infra}

No aquivo curso/main.tf vou apenas criar um módulo chamado prod para um cluster de produção e definir a localização do código junto com a variável que define o nome do cluster.

module "prod" {
  source       = "../infra"
  cluster_name = "scttic"
}

Definição da região e provedor:

No arquivo “infra/Provider.tf”, defina a região AWS que você deseja usar para o EKS.

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = ">= 4.47"
    }
  }

  required_version = ">= 0.14.9"
}

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

Configure o provedor AWS no arquivo, especificando suas credenciais e a região escolhida.

Definição de variáveis.

Criamos um arquivo onde definiremos as variáveis utilizada nos demais, arquivos “tf” que teremos. Bom para este projeto só criamos uma variável, mais no decorrer do curso isto pode mudar. O arquivo é “infra/Variables.tf”.

variable "cluster_name" {
  type    = string
  default = "mycluster"
}

Criando a VPC

VPC (Virtual Private Cloud) para EKS é um ambiente de rede virtual isolado na nuvem da AWS, no qual você pode implantar e executar clusters do EKS. Ele fornece controle total sobre a rede, permitindo que você defina suas próprias sub-redes, tabelas de roteamento e configurações de segurança. A VPC para EKS é altamente escalável e oferece recursos avançados de segurança, permitindo que os clusters EKS sejam executados de forma isolada e protegida em um ambiente controlado.

Definimos as configurações no arquivo chamado “vpc.tf” que está no diretório “infra”.

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

  name = "VPC-EKS"
  cidr = "10.0.0.0/16"

  # azs             = ["us-west-2a", "us-west-2b", "us-west-2c"]
  # private_subnets = ["10.0.1.0/24", "10.0.2.0/24", "10.0.3.0/24"]
  # public_subnets  = ["10.0.101.0/24", "10.0.102.0/24", "10.0.103.0/24"]

  azs             = ["us-west-2a", "us-west-2b"]
  private_subnets = ["10.0.1.0/24", "10.0.2.0/24"]
  public_subnets  = ["10.0.3.0/24", "10.0.4.0/24"]
  intra_subnets   = ["10.0.5.0/24", "10.0.6.0/24"]

  create_database_subnet_group           = true
  create_database_subnet_route_table     = true
  create_database_internet_gateway_route = true

  enable_dns_hostnames = true
  enable_dns_support   = true

  enable_nat_gateway     = true
  single_nat_gateway     = true
  one_nat_gateway_per_az = false


  public_subnet_tags = {
    "kubernetes.io/role/elb" = 1
  }

  private_subnet_tags = {
    "kubernetes.io/role/internal-elb" = 1
  }

}

Security Group

Security Group na AWS é um recurso de segurança que atua como um firewall virtual para controlar o tráfego de entrada e saída de instâncias EC2 (Elastic Compute Cloud) e outros recursos da AWS. Ele permite definir regras de acesso baseadas em protocolos, portas e endereços IP, determinando quais conexões são permitidas ou bloqueadas. O Security Group é aplicado a nível de instância e fornece uma camada adicional de proteção para garantir a segurança dos recursos na nuvem.

Definimos apenas o acesso ssh de início, mais isso poderá mudar durante o curso. O arquivo criado é “infra/securityGroup.tf”.

resource "aws_security_group" "ssh_cluster" {
  name   = "ssh_cluster"
  vpc_id = module.vpc.vpc_id
}

resource "aws_security_group_rule" "ssh_cluster_in" {
  type              = "ingress"
  from_port         = 22
  to_port           = 22
  protocol          = "tcp"
  cidr_blocks       = ["0.0.0.0/0"]
  security_group_id = aws_security_group.ssh_cluster.id
}

resource "aws_security_group_rule" "ssh_cluster_out" {
  type              = "egress"
  from_port         = 0
  to_port           = 0
  protocol          = "-1"
  cidr_blocks       = ["0.0.0.0/0"]
  security_group_id = aws_security_group.ssh_cluster.id
}

EKS

Chegamos ao arquivo que utiliza o módulo do EKS para a criação do cluster, nele definiremos todos os recursos que vamos utilizar neste criação. Lembre-se que tudo poderia está em único arquivo chamado main.tf.

module "eks" {
  source = "terraform-aws-modules/eks/aws"

  cluster_name    = var.cluster_name
  cluster_version = "1.26"

  # cluster_endpoint_private_access = true
  cluster_endpoint_public_access = true

  vpc_id                   = module.vpc.vpc_id
  subnet_ids               = module.vpc.private_subnets
  control_plane_subnet_ids = module.vpc.intra_subnets

  eks_managed_node_group_defaults = {
    desired_size = 50
  }

  eks_managed_node_groups = {
    scttic = {
      min_size               = 1
      max_size               = 5
      desired_size           = 2
      vpc_security_group_ids = [aws_security_group.ssh_cluster.id]
      instance_types         = ["t3.small"]
    }
  }
}

Implantação do plano:

Execute o comando terraform init no diretório do projeto “curso” para inicializar o Terraform. Em seguida, execute o comando terraform validate para verificar se não há erros de sintaxe depois o terraform plan e verifique o plano de implantação e revise as alterações propostas.

cd curso
terraform validate

Apos este procedimento, você deverá excecutar um plan e identificar se existe alguma pendência.

terraform plan

Implantação do cluster EKS

Execute o comando terraform apply para iniciar a implantação do cluster EKS. O Terraform criará automaticamente os recursos definidos nos arquivos. Aguarde até que a implantação seja concluída.

Pronto agora é possível criar as instancia executando um apply e respondendo yes para proseguir. Ou caso esteja ciente de que vai aprovar, poderá adicionar a opção –auto-approve.

 terraform apply

Configuração do acesso ao cluster

Após a implantação, utilize a AWS CLI para configurar o acesso ao cluster EKS. Execute o comando aws eks --region <sua_região> update-kubeconfig --name <nome_do_cluster>.

aws eks --region us-west-2 update-kubeconfig --name scttic

Validação e testes

Execute comandos como kubectl get nodes para verificar se os nós do cluster estão ativos. Experimente implantar aplicativos e serviços no cluster EKS para garantir que tudo esteja funcionando corretamente.

kubectl run nginx –image=nginx

kubectl get pods