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.

Download Terraform

• 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.

Criar 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.

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:

  • Instalar 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 criar uma instância AWS

• 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