Nos artigos parte 1 e parte 2, mergulhamos profundamente no mundo dos Helm Charts, explorando seu papel crucial na simplificação e melhoria da implantação e gerenciamento de microsserviços Kubernetes.
Discutimos a importância do Helm e dos Helm Charts, bem como os desafios comuns que os Helm Charts ajudam a superar no contexto dos microsserviços Kubernetes.
Na segunda parte, focamos na criação e personalização de Helm Charts, destacando como eles podem ser adaptados para atender às necessidades específicas de diferentes micro serviços. Analisamos a estrutura de um Helm Chart, como criar um do zero e como personalizá-lo para um micro serviço específico.
Agora, na terceira parte desta série, vamos dar um passo adiante e explorar como podemos automatizar o gerenciamento de ambientes Kubernetes.
Vamos nos concentrar no uso do Terraform, uma ferramenta de infraestrutura como código, para gerenciar recursos Kubernetes no EKS da AWS. Abordaremos tópicos como a criação de um cluster EKS na AWS com Terraform, gerenciamento de Namespaces, criação de usuários e atribuição de permissões, e a implantação de ferramentas no cluster EKS usando Helm e Terraform.
Usando Terraform para gerenciar recursos Kubernetes no EKS da AWS
1. Introdução ao Terraform e ao provedor Kubernetes
O Terraform é uma ferramenta de infraestrutura como código (IaC) que permite definir e provisionar infraestrutura de data center usando uma linguagem de configuração declarativa. Aqui está um exemplo básico de como um recurso do Kubernetes pode ser definido usando o Terraform:
provider "kubernetes" {
config_path = "~/.kube/config"
}
resource "kubernetes_namespace" "example" {
metadata {
name = "example-namespace"
}
}
Neste exemplo, estamos usando o provedor Kubernetes para criar um novo namespace chamado “example-namespace”.
2. Criando um cluster EKS na AWS com Terraform
provider "aws" {
region = "us-west-2"
}
resource "aws_eks_cluster" "example" {
name = "example"
role_arn = aws_iam_role.example.arn
vpc_config {
subnet_ids = [aws_subnet.example.id]
}
depends_on = [
aws_iam_role_policy_attachment.example-AmazonEKSClusterPolicy,
]
}
resource "aws_eks_node_group" "example" {
cluster_name = aws_eks_cluster.example.name
node_group_name = "example"
node_role_arn = aws_iam_role.example.arn
subnet_ids = [aws_subnet.example.id]
scaling_config {
desired_size = 1
max_size = 1
min_size = 1
}
instance_types = ["t3.medium"]
depends_on = [
aws_iam_role_policy_attachment.example-AmazonEKSWorkerNodePolicy,
]
}
# Cria Kubeconfig
resource "local_file" "kubeconfig" {
content = templatefile("kubeconfig.tpl", {
endpoint = aws_eks_cluster.this.endpoint
certificate_authority_data = aws_eks_cluster.this.certificate_authority.0.data
cluster_name = aws_eks_cluster.this.name
})
filename = "${path.module}/kubeconfig.yaml"
}
Neste exemplo, estamos criando um cluster EKS chamado “example” na região “us-west-2”. O cluster terá um grupo de nós com uma capacidade desejada de 1 nó, uma capacidade máxima de 1 nó e uma capacidade mínima de 1 nó. Cada nó será uma instância “t3.medium”. Também é gerado um kubeconfig baseado no seguinte template:
apiVersion: v1
clusters:
- cluster:
server: ${endpoint}
certificate-authority-data: ${certificate_authority_data}
name: kubernetes
contexts:
- context:
cluster: kubernetes
user: aws
name: aws
current-context: aws
kind: Config
preferences: {}
users:
- name: aws
user:
exec:
apiVersion: client.authentication.k8s.io/v1beta1
command: aws-iam-authenticator
args:
- "token"
- "-i"
- "${cluster_name}"
3. Gerenciando Namespaces com Terraform
Namespaces no Kubernetes são como espaços de trabalho virtuais que permitem que você organize e separe recursos do cluster. Com o Terraform, você pode gerenciar namespaces de forma eficiente. Aqui está um exemplo de como criar um namespace usando o Terraform:
resource "kubernetes_namespace" "example" {
metadata {
name = "example-namespace"
}
}
Neste exemplo, estamos criando um namespace chamado “example-namespace”. Você pode criar quantos namespaces precisar, simplesmente replicando e ajustando este bloco de código.
4. Criando usuários e atribuindo permissões com Terraform
O Terraform pode ser usado para gerenciar usuários e suas permissões no Kubernetes. Por exemplo, você pode criar um Role e um RoleBinding para atribuir permissões a um usuário específico. Além disso, você pode gerar um arquivo kubeconfig para esse usuário, permitindo que ele interaja com o cluster. Aqui está um exemplo de como isso pode ser feito:
resource "kubernetes_role" "example" {
metadata {
name = "example-role"
namespace = "example-namespace"
}
rule {
api_groups = [""]
resources = ["pods"]
verbs = ["get", "list"]
}
}
resource "kubernetes_role_binding" "example" {
metadata {
name = "example-role-binding"
namespace = "example-namespace"
}
role_ref {
api_group = "rbac.authorization.k8s.io"
kind = "Role"
name = kubernetes_role.example.metadata[0].name
}
subject {
kind = "User"
name = "example-user"
api_group = "rbac.authorization.k8s.io"
}
}
output "kubeconfig" {
description = "Kubeconfig for the example user"
value = <
Neste exemplo, estamos criando um Role chamado “example-role” que permite ao usuário obter e listar pods. Em seguida, criamos um RoleBinding que atribui esse Role ao usuário “example-user”. Finalmente, geramos um arquivo kubeconfig para o usuário “example-user”. Este arquivo kubeconfig permite que o usuário “example-user” interaja com o cluster usando o comando kubectl.
Caso a automação do EKS esteja separada desta, é possível recuperar os dados da automação através do tfsate utilizando o data do EKS:
data "terraform_remote_state" "eks" {
backend = "local"
config = {
path = "../terraform.tfstate"
}
}
Assim, você pode substituir os campos das variáveis pelo data:
output "kubeconfig" {
description = "Kubeconfig for the example user"
value = <
5. Implantando ferramentas no cluster EKS usando Helm e Terraform
O Terraform, em conjunto com o Helm, pode ser usado para implantar ferramentas no seu cluster EKS. O Terraform tem um provedor Helm que permite gerenciar Helm Charts. Aqui está um exemplo de como implantar o Helm Chart do nginx-ingress usando o Terraform e definindo valores específicos.
Usando um arquivo values.yaml:
Se você tiver um arquivo values.yaml personalizado para o seu Helm Chart, você pode usar o argumento values para especificar o caminho para esse arquivo:
provider "helm" {
kubernetes {
config_path = "../kubeconfig.yaml"
}
}
resource "helm_release" "nginx_ingress" {
name = "nginx-ingress"
repository = "https://kubernetes.github.io/ingress-nginx"
chart = "ingress-nginx"
namespace = "default"
values = [
file("${path.module}/values.yaml")
]
}
Neste exemplo, o Terraform irá ler o arquivo values.yaml no mesmo diretório do arquivo Terraform e usar esses valores ao instalar o Helm Chart.
Usando o parâmetro “set”:
Se você quiser definir valores específicos diretamente no recurso helm_release, você pode usar o argumento set. Aqui está um exemplo:
provider "helm" {
kubernetes {
config_path = "../kubeconfig.yaml"
}
}
resource "helm_release" "nginx_ingress" {
name = "nginx-ingress"
repository = "https://kubernetes.github.io/ingress-nginx"
chart = "ingress-nginx"
namespace = "default"
set {
name = "controller.replicaCount"
value = "2"
}
set {
name = "controller.metrics.enabled"
value = "true"
}
}
Neste exemplo, estamos definindo o número de réplicas do controlador nginx-ingress para 2 e habilitando as métricas do controlador. Você pode adicionar quantos blocos set precisar para definir todos os valores necessários para o seu Helm Chart.
Conclusão
Nesta terceira e última parte desta série de artigos, exploramos como o Terraform pode ser usado para automatizar a criação e o gerenciamento de recursos do Kubernetes no EKS da AWS. Demonstramos como criar um cluster EKS, gerenciar namespaces, criar usuários e atribuir permissões, e implantar ferramentas usando o Helm, tudo isso usando o Terraform.
A automação é uma parte crucial da gestão eficiente de ambientes Kubernetes. Ao usar ferramentas como o Terraform, as equipes de desenvolvimento e operações podem economizar tempo, reduzir erros e garantir a consistência em todos os ambientes.
Esperamos que esta série forneça uma visão útil sobre como você pode aproveitar o poder do Helm e do Terraform para gerenciar seus micro serviços Kubernetes. Encorajamos você a experimentar essas ferramentas e técnicas em seus próprios projetos. Lembre-se, a prática leva à perfeição!
Todo o código usado nesta série de artigos está disponível no nosso repositório do GitHub. Convidamos você a visitar para explorar o código em detalhes, fazer fork do repositório e experimentar por conta própria.
Implemente soluções Kubernetes com a Vertigo Tecnologia
A Vertigo Tecnologia tem especialistas experientes na implementação de soluções Kubernetes, assim como parcerias que são reconhecidas por sua excelência no mercado.
Containerize suas aplicações e tenha uma infraestrutura automatizada, capaz de ser replicada para diversos ambientes, de forma prática e segura.
Fale com o nosso time de especialistas, estamos prontos para te ajudar.
–
Quem assina este artigo é o nosso Analista DevOps, Caio Barbieri.
