Infraestrutura como Código (IaC): Provisionando Instâncias EC2 na AWS com Terraform
O objetivo deste projeto é apresentar o uso da Amazon Web Services (AWS) com Terraform, uma ferramenta de Infrastructure as Code (IaC), para provisionar uma infraestrutura simples baseada em uma instância EC2, chave SSH e grupo de segurança.
Alguns Conceitos
[editar | editar código]- Provisionar: é o ato de criar e configurar automaticamente os recursos mínimos necessários para executar um sistema, aplicação ou serviço em um ambiente de computação, geralmente em nuvem, como a AWS
- Instância EC2: uma máquina virtual na nuvem AWS
- Grupo de Segurança: um conjunto de regras de firewall que controla o tráfego de entrada e saída da rede da instância EC2
- Par de Chaves SSH: chaves de criptografia que permitem uma conexão segura com a instância EC2
O que é Terraform e IaC?
[editar | editar código]Infrastructure as Code (Infraestrutura como Código) permite criar, modificar e gerenciar recursos de infraestrutura por meio de arquivos de configuração, ao invés de interfaces gráficas. Usar o Terraform oferece diversas vantagens em relação ao gerenciamento manual da sua infraestrutura:
- O Terraform permite gerenciar a infraestrutura em diversas plataformas de nuvem;
- A linguagem de configuração legível ajuda você a escrever código de infraestrutura rapidamente;
- Permite rastrear alterações de recursos ao longo de suas implantações, ou seja, possui controle de mudanças via sistema de versão;
- Você pode reutilizar e padronizar a infraestrutura.
Instalando Terraform
[editar | editar código]Você vai precisar instalar Terraform na sua máquina. Para isso, basta acessar a sua página oficial.
Introdução à AWS
[editar | editar código]Antes de usar o Terraform, será preciso criar uma conta AWS (o plano gratuito é suficiente para testes). Após criar sua conta, você deve criar uma conta IAM (Gerenciamento de Identidade e Acesso) para restringir permissões e garantir a segurança da infraestrutura na nuvem.
Criando um usuário do IAM
[editar | editar código]Adicione um novo usuário no IAM e então defina um nome de usuário (como terraform-user). Nas opções de permissões, podemos "Anexar políticas diretamente". As políticas necessárias para o Terraform são:
- AmazonEC2FullAccess
- AmazonVPCFullAccess
- IAMFullAccess
Gerando Chaves
[editar | editar código]Abra a página do novo usuário IAM e crie novas chaves de acesso (Access Key ID e Secret Access Key). A AWS solicitará a finalidade das chaves. Aqui, precisamos delas para o "Local Code". Lembre-se de guardar suas chaves.
Configuração do Ambiente Local
[editar | editar código]Para conectar o Terraform à sua conta AWS, o Terraform precisa acessar as credenciais da AWS do usuário do IAM criado. Para isso, precisamos configurá-las em seu ambiente local.
Linux/macOS
export AWS_ACCESS_KEY_ID="SUA_ACCESS_KEY" export AWS_SECRET_ACCESS_KEY="SUA_SECRET_KEY"
Windows
$env:AWS_ACCESS_KEY_ID = "SUA_ACCESS_KEY" $env:AWS_SECRET_ACCESS_KEY = "SUA_SECRET_KEY"
Após configurá-las, certifique-se de que os valores retornados são suas credenciais.
Linux/macOS
echo $AWS_ACCESS_KEY_ID echo $AWS_SECRET_ACCESS_KEY
Windows
echo $env:AWS_ACCESS_KEY_ID echo $env:AWS_SECRET_ACCESS_KEY
Observação
[editar | editar código]Esta configuração de variáveis de ambiente é temporária. Se você fechar o terminal, as variáveis serão perdidas. Para uma configuração permanente, você pode adicionar essas variáveis ao seu arquivo de configuração do shell.
Agora que configuramos o Terraform, podemos começar a escrever o código para criar uma infraestrutura na AWS.
Escrevendo o Código Terraform
[editar | editar código]O main.tf é o núcleo de um projeto Terraform. É onde você define os recursos que serão usados na AWS, como instâncias EC2, grupos de segurança, entre outros. Um exemplo básico inclui:
terraform {
required_providers {
aws = {
source = "hashicorp/aws"
version = "~> 4.0"
}
}
}
provider "aws" {
region = "sa-east-1" # América do Sul (São Paulo)
}
# ==============================
# Par de chaves SSH
# ==============================
resource "aws_key_pair" "chave_ssh" {
key_name = "minha-chave"
public_key = var.public_key
}
# ==============================
# Grupo de Segurança
# ==============================
resource "aws_security_group" "grupo_segurança" {
name = "grupo-seguranca-exemplo"
# Regra de entrada para SSH (porta 22)
ingress {
from_port = 22
to_port = 22
protocol = "tcp"
cidr_blocks = ["${var.public_ip}/32"] # SEU_IP
}
# Regra de entrada para Jupyter Notebook (porta 8888)
ingress {
from_port = 8888
to_port = 8888
protocol = "tcp"
cidr_blocks = ["${var.public_ip}/32"] # SEU_IP
}
# Regra de saída (todos os protocolos)
egress {
from_port = 0
to_port = 0
protocol = "-1"
cidr_blocks = ["0.0.0.0/0"]
}
}
# ==============================
# Instância EC2
# ==============================
resource "aws_instance" "instancia" {
ami = "ami-0a729bdc1acf7528b" # deve pegar para sua região - AMI é a distro da sua máquina virtual
instance_type = "t2.micro"
key_name = aws_key_pair.chave_ssh.key_name
security_groups = [aws_security_group.grupo_segurança.name]
tags = {
Name = "instancia-exemplo"
}
}
- terraform define as configurações do Terraform, como versão e provedores
- provider define o provedor da AWS (região)
- resource define os recursos que serão usados na AWS. Cada bloco de recurso tem um tipo (como “aws_key_pair”, “aws_security_group”, etc) e um nome.
Neste exemplo, nosso vamos provisionar uma instância EC2 que execute o Jupyter Notebook. Assim, cada aplicação usa uma porta específica:
- Porta 22 (SSH): permite acesso remoto à instância via terminal;
- Porta 8888 (Jupyter Notebook): permite acessar a interface web do Jupyter via navegador.
As regras de entrada (ingress) controlam quem pode acessar a instância. As regras de saída (egress) controlam o que a instância pode acessar na internet.
Após a execução do Terraform, a instância estará pronta para instalar e rodar o Jupyter Notebook.
Gerando a Chave SSH
[editar | editar código]Ao usar o Terraform para provisionar infraestrutura (por exemplo, instâncias do AWS EC2), precisamos configurar chaves SSH para que o Terraform possa se conectar automaticamente às instâncias.
Execute o seguinte comando na sua máquina local:
ssh-keygen -t rsa -b 4096 -C "terraform-key"
Isso cria:
- Chave privada: ~/.ssh/id_rsa
- Chave pública: ~/.ssh/id_rsa.pub
Para acessar a chave pública, use:
cat ~/.ssh/id_rsa.pub
Para descobrir seu IP público, use:
curl -s https://checkip.amazonaws.com
Adicione a chave pública no código Terraform e use a chave privada para se conectar via SSH.
terraform.tfvars
public_key = "cole-aqui-sua-chave-publica"
public_ip = "123.456.78.90"
variables.tf
variable "public_key" {
type = string
description = "SSH Public Key"
}
variable "public_ip" {
type = string
description = "Public IP"
}
Logo, você deve ter uma pasta como
terraform-tutorial/ ├── main.tf ├── terraform.tfvars └── variables.tf
Implantação da Infraestrutura
[editar | editar código]No terminal, dentro do diretório onde está o main.tf, faça:
terraform init # baixa os plugins necessários terraform apply # provisiona a infraestrutura e sua instância estará online na AWS
Após usar o comando terraform apply, digite yes para confirmar, isso criará o par de chaves, o grupo de segurança e uma instância EC2 pronta para uso.
Acesso à Instância
[editar | editar código]Depois do apply, a instância EC2 estará online. Agora, basta pegar a DNS Pública da instância e conectar-se usando:
ssh -i ~/.ssh/id_rsa ubuntu@DNS_DA_EC2
Este modelo pode ser adaptado para rodar qualquer aplicação, não apenas Jupyter. Basta instalar o que desejar na instância EC2.
Para se desconectar da instância EC2 basta digitar exit no terminal da máquina virtual.
Por fim, você pode liberar os recursos, caso queira, com:
terraform destroy