Deploy com Terraform, AWS, Docker e Spring Boot.
O Terraform é uma ferramenta de código aberto desenvolvido pela HashiCorp que permite criar, alterar e versionar infraestrutura de forma segura e eficiente. Ele é uma ferramenta de orquestração de infraestrutura que permite a criação e gerenciamento de recursos de infraestrutura de forma declarativa.
Com o Terraform, é possível criar e gerenciar infraestrutura de forma eficiente, segura e escalável. Ele permite que você defina sua infraestrutura na AWS, Azure, Google Cloud Platform, entre outros, usando uma linguagem de configuração simples e fácil de entender.
Para instalar o Terraform, basta acessar o site oficial da ferramenta.
- No MacOS, você pode instalar o Terraform usando o Homebrew:
brew tap hashicorp/tap
brew install hashicorp/tap/terraform
- Confirmar a instalação:
terraform --version
Para usar o Terraform com a AWS, é necessário criar uma conta na AWS.
- Deixar selecionado a região como Norte da Virginia (us-east-1).
Para criar uma aplicação Java/Spring Boot, basta acessar o site oficial do Spring Initializr.
-
Crie um projeto Maven com as seguintes dependências:
- Spring Web
- Java 21
-
O nome do projeto é deploy (app)
Para publicar a aplicação no Docker Hub, é necessário criar uma conta no site oficial.
Docker Hub
-
Crie um arquivo na raiz do projeto chamado Dockerfile:
-
Gere um jar do projeto:
mvn clean package
- Configurando o Dockerfile:
FROM openjdk:21
WORKDIR app
COPY target/deploy-0.0.1-SNAPSHOT.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]
- Criar a imagem do Docker:
docker build . -t mulhermaav/public-api:latest
- Faça o login no Docker Hub:
docker login
- Publicar a imagem no Docker Hub:
docker push mulhermaav/public-api:latest
- Executar a imagem do Docker:
docker run -p 8080:8080 mulhermaav/public-api:latest
Para configurar o Terraform, é necessário criar um arquivo chamado main.tf na raiz da pasta terraform.
- Configurando o main.tf:
provider "aws" {
region = "us-east-1"
}
- Inicializar o Terraform:
cd infra
terraform init
É criado uma pasta chamada .terraform, com as configurações do provider AWS.
-
Acesse o console da AWS e vá para o serviço IAM.
-
Selecione criar usuário (escolha um nome).
-
Selecione uma permission policy (AdministratorAccess).
-
Após a criação, na tela do usuário, clique em Criar chave de acesso.
-
Selecione o caso de uso local code (Programático).
-
Após criar a chave de acesso, copie a chave de acesso e a chave secreta (salve em local seguro).
-
Instale a AWS CLI:
-
- No MacOS, você pode instalar a AWS CLI usando o Homebrew:
brew install awscli
- Confirmar a instalação:
aws --version
-
-
Configurar o acesso programático:
aws configure
- Informe a chave de acesso e a chave secreta.
- Informe a região (us-east-1).
- Informe o formato de saída (json).
- Verificar a configuração:
aws sts get-caller-identity
É criado um arquivo dentro da pasta do usuário chamada .aws e dentro da pasta contém as credenciais.
- Configurando o main.tf:
-
Como saber a AMI (Amazon Machine Image):
- Acesse o console da AWS e vá para o serviço EC2.
- Selecione Catálogo de AMIs.
- Escolha a AMI e copie o ID.
-
Configurar o security group (firewall) para permitir acesso via HTTP (saída e entrada).
provider "aws" {
region = "us-east-1"
}
resource "aws_security_group" "securitygroup" {
name = "securitygroup"
description = "Permitir acesso HTTP e acesso a internet"
ingress {
from_port = 80
to_port = 80
protocol = "tcp"
cidr_blocks = ["0.0.0.0/0"] //defini os ranges de IPs que podem acessar a instância
}
egress {
from_port = 0
to_port = 65535
protocol = "tcp"
cidr_blocks = ["0.0.0.0/0"]
}
}
resource "aws_instance" "servidor" {
ami = "ami-0632bbd74ce561b38"
instance_type = "t2.nano"
vpc_security_group_ids = [aws_security_group.securitygroup.id]
}
Dentro do EC2 sempre que ele é inicializado, ele executa um arquivo de script chamado user_data.sh dentro da pasta infra.
- Cria um arquivo chamado user_data.sh dentro do diretório infra:
#!/bin/bash
- Configurando o main.tf:
resource "aws_instance" "servidor" {
ami = "ami-0632bbd74ce561b38"
instance_type = "t2.nano"
user_data = file("user_data.sh")
vpc_security_group_ids = [aws_security_group.securitygroup.id]
}
O script do user_data.sh, irá instalar o Docker, baixar a imagem da aplicação e rodar a imagem.
#!/bin/bash
sudo su
yum update -y
yum install -y docker
service docker start
usermod -a -G docker ec2-user
docker run -p 80:8080 mulhermarav/public-api:latest
-
Dentro da pasta infra:
- Identifica o arquivo main.tf e informa o que foi detectado e o que ele irá criar:
terraform plan
- Informa as alterações que irá fazer e pede permissão para prosseguir com as aplicações:
terraform apply
Após aplicação do main.tf, é gerado um arquivo no diretório de infra chamado terraform.tfstate, que armazena todo estado dos recursos e faz versionamento dos recursos.
O arquivo terraform.tfstate armazena esses dados para saber o que foi feito, o que não foi feito, para saber o que pode fazer.
- Teste a aplicação acessando o console da AWS e vá para o serviço EC2.
- Selecione a instância criada e copie o IP público.
- Acesse o navegador e cole o IP público da instância.
- Gerar uma chave pública e privada
ssh-keygen
- Configurar o arquivo main.tf dentro da pasta infra
- Crie um novo recurso key_pair, apontando para para a chave pública
resource "aws_key_pair" "keypair" {
key_name = "terraform-keypair"
public_key = file("~/.ssh/id_rsa.pub")
}
resource "aws_instance" "servidor" {
ami = "ami-00beae93a2d981137"
instance_type = "t2.nano"
user_data = file("user_data.sh")
key_name = aws_key_pair.keypair.key_name
vpc_security_group_ids = [aws_security_group.securitygroup.id]
}
- Libere o acesso a porta SSH
- Dentro de resource security group, crie um novo ingress
ingress {
from_port = 22
to_port = 22
protocol = "tcp"
cidr_blocks = ["0.0.0.0/0"]
}
- Depois aplique as alterações, dentro da pasta infra
terraform apply
O arquivo terraform.tfstate.backup, tende a ser o arquivo anterior do terraform.tfstate.
O Terraform derruba a máquina anterior e sobe uma nova máquina com as alterações.
No console da AWS é possível ver o key pair e security group criados na aba de network e security do EC2
ssh ec2-user@<ip-publico>.compute-1.amazonaws.com
- Comando Docker dentro da instância EC2 para confirmar o acesso remoto
docker ps
docker logs <id-container>
- Para sair do acesso remoto
exit
- Dentro da pasta infra
terraform destroy