Deploy de uma API Spring Boot na AWS EC2 com Docker e PostgreSQL
Neste artigo, apresento um passo a passo para publicar uma aplicação Java com Spring Boot na AWS utilizando uma instância EC2, Docker e PostgreSQL. O objetivo é demonstrar, de forma prática, como preparar a aplicação, criar o ambiente na AWS, configurar o banco de dados e disponibilizar a API para acesso externo.
Deploy de uma API Spring Boot na AWS usando Amazon EC2, Docker e Amazon ECR
Introdução
O desenvolvimento de uma aplicação backend não termina quando o código funciona localmente. Para disponibilizar uma API para usuários ou outros sistemas, é necessário preparar um ambiente capaz de executar a aplicação de forma confiável e segura.
Neste tutorial, vamos realizar o deploy de uma aplicação Java com Spring Boot em uma instância Amazon EC2, utilizando Docker para empacotamento e execução da aplicação e Amazon Elastic Container Registry (Amazon ECR) para armazenamento da imagem Docker.
Também veremos como configurar a aplicação para utilizar um banco de dados PostgreSQL por meio de variáveis de ambiente.
O objetivo é apresentar um fluxo prático de deploy e, ao mesmo tempo, explicar as decisões envolvidas na arquitetura.
Nota: este tutorial utiliza uma arquitetura simplificada para fins de aprendizado. Algumas configurações, como a exposição direta da porta da aplicação, são adequadas para um laboratório controlado, mas devem ser revisadas antes de serem utilizadas em um ambiente de produção.
Arquitetura
Ao final do tutorial, teremos uma arquitetura semelhante a esta:
Internet | v +---------------+ | Amazon EC2 | | | | Docker | | | | | v | | Spring Boot | +-------+-------+ | v PostgreSQL
O código da aplicação é transformado em um arquivo JAR, empacotado em uma imagem Docker e armazenado no Amazon ECR.
A instância EC2 obtém essa imagem do ECR e executa um container contendo a aplicação Spring Boot.
O banco PostgreSQL não precisa necessariamente estar na mesma máquina. Em um ambiente de produção, uma alternativa é utilizar o Amazon RDS for PostgreSQL, deixando o gerenciamento do banco separado da camada de aplicação.
1. Pré-requisitos
Para acompanhar este tutorial, é recomendável possuir:
- conhecimento básico de Java;
- conhecimento básico de Spring Boot;
- conhecimento básico de Linux;
- uma conta AWS;
- uma aplicação Spring Boot funcional;
- Git instalado;
- Docker instalado para realizar os testes localmente.
Os exemplos deste tutorial utilizam Java 17.
Os comandos podem precisar de pequenas adaptações dependendo da distribuição Linux utilizada na instância EC2.
2. Criando a aplicação Spring Boot
Para demonstrar o deploy, podemos utilizar uma API Spring Boot simples.
Um exemplo de controller:
@RestController@RequestMapping("/api")public class HelloController {
@GetMapping("/hello") public String hello() { return "Hello AWS!"; }}
Executando a aplicação localmente:
./mvnw spring-boot:run
A API estará disponível em:
http://localhost:8080/api/hello
Podemos testar:
curl http://localhost:8080/api/hello
A resposta esperada é:
Hello AWS!
Antes de prosseguir, é importante confirmar que a aplicação funciona corretamente localmente.
3. Gerando o arquivo JAR
O Spring Boot pode ser empacotado em um arquivo JAR executável.
Utilizamos:
./mvnw clean package
Após o processo, o arquivo será criado no diretório:
target/
Por exemplo:
target/minha-api-0.0.1-SNAPSHOT.jar
Esse arquivo será utilizado na construção da imagem Docker.
4. Criando o Dockerfile
Na raiz do projeto, criamos um arquivo chamado:
Dockerfile
Um exemplo:
FROM eclipse-temurin:17-jre
WORKDIR /app
COPY target/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]
Nesse arquivo:
-
FROMdefine a imagem base;
-
WORKDIRdefine o diretório de trabalho;
-
COPYcopia o JAR para dentro da imagem;
-
EXPOSEdocumenta a porta utilizada pela aplicação;
-
ENTRYPOINTdefine o processo iniciado pelo container.
O
EXPOSE não publica a porta automaticamente. A publicação da porta ocorre quando o container é executado com a opção -p .
5. Construindo e testando a imagem Docker
Depois de gerar o JAR, construímos a imagem:
docker build -t minha-api .
Podemos verificar a imagem:
docker images
Agora executamos o container:
docker run -d \ --name minha-api \ -p 8080:8080 \ minha-api
Verificamos se o container está em execução:
docker ps
E testamos:
curl http://localhost:8080/api/hello
Se a aplicação responder corretamente, podemos prosseguir para a AWS.
6. Criando um repositório no Amazon ECR
O Amazon ECR é um serviço gerenciado para armazenar e distribuir imagens de container.
Podemos criar um repositório utilizando o AWS Management Console ou a AWS CLI.
Com a AWS CLI configurada, um exemplo é:
aws ecr create-repository \ --repository-name minha-api \ --region us-east-1
A região deve ser substituída pela região AWS escolhida para o projeto.
Depois de criado, o repositório terá um endereço semelhante a:
ACCOUNT_ID.dkr.ecr.REGION.amazonaws.com/minha-api
7. Autenticando o Docker no Amazon ECR
Para enviar uma imagem ao ECR, o Docker precisa estar autenticado no registry.
Utilizamos:
aws ecr get-login-password --region us-east-1 | \docker login \--username AWS \--password-stdin ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com
O comando utiliza credenciais fornecidas pela AWS CLI para realizar a autenticação.
8. Criando uma tag para a imagem
A imagem local precisa receber uma tag correspondente ao endereço do repositório ECR.
docker tag minha-api:latest \ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/minha-api:latest
Podemos verificar:
docker images
A imagem agora possui uma referência compatível com o repositório ECR.
9. Enviando a imagem para o Amazon ECR
Agora podemos realizar o push:
docker push \ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/minha-api:latest
Após o envio, a imagem estará armazenada no Amazon ECR.
Isso permite que outras máquinas autorizadas possam obtê-la diretamente do registry.
10. Criando a instância Amazon EC2
Agora vamos criar uma instância EC2 para executar o container.
No AWS Management Console:
- Acesse o serviço Amazon EC2.
- Escolha Launch instance.
- Defina um nome para a instância.
- Selecione uma AMI Linux compatível.
- Escolha um tipo de instância adequado ao laboratório.
- Configure a chave utilizada para acesso SSH.
- Configure o Security Group.
- Crie a instância.
Para um laboratório, podemos permitir temporariamente:
SSHTCP 22Origem: seu IP
Custom TCPTCP 8080Origem: seu IP
Restringir a porta 8080 ao próprio IP é preferível a permitir
0.0.0.0/0 durante testes, pois reduz a exposição da aplicação.Em uma arquitetura de produção, normalmente não é necessário expor diretamente a porta 8080 à Internet.
11. Acessando a instância EC2
Depois que a instância estiver disponível, podemos acessar o servidor utilizando SSH.
Exemplo:
ssh -i minha-chave.pem ec2-user@IP_PUBLICO
O usuário pode variar de acordo com a AMI utilizada.
Depois de acessar:
uname -a
Podemos confirmar que estamos executando comandos diretamente na instância EC2.
12. Instalando o Docker
O procedimento de instalação depende da distribuição Linux utilizada.
Depois da instalação, verificamos:
docker --version
Também podemos executar:
docker info
para verificar o estado do Docker.
13. Permissões para acessar o Amazon ECR
A EC2 precisa de autorização para obter imagens privadas do Amazon ECR.
Uma prática recomendada é associar à instância uma IAM Role com as permissões necessárias para acessar o ECR.
Isso evita a necessidade de armazenar Access Keys de um usuário IAM diretamente na instância.
Para um cenário de leitura de imagens privadas, a política gerenciada
AmazonEC2ContainerRegistryPullOnly pode ser utilizada, quando disponível na conta/região, ou podem ser definidas permissões específicas seguindo o princípio do menor privilégio.A role deve ser associada à instância por meio de um IAM Instance Profile.
Essa abordagem permite que a aplicação na EC2 obtenha credenciais temporárias fornecidas pela AWS.
14. Autenticando a EC2 no ECR
Depois que a role estiver configurada e a AWS CLI estiver disponível na instância, podemos realizar o login:
aws ecr get-login-password \ --region us-east-1 | \docker login \ --username AWS \ --password-stdin \ ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com
Se a autenticação for concluída com sucesso, o Docker poderá acessar o repositório autorizado.
15. Obtendo a imagem na EC2
Agora podemos baixar a imagem:
docker pull \ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/minha-api:latest
Verificamos:
docker images
A imagem armazenada anteriormente no ECR estará disponível localmente na EC2.
16. Configurando o banco de dados
Aplicações Spring Boot frequentemente utilizam um banco de dados relacional.
O PostgreSQL pode ser executado de diferentes maneiras.
Para um laboratório, podemos utilizar um PostgreSQL em container.
Em uma arquitetura AWS voltada para produção, uma opção é utilizar o Amazon RDS for PostgreSQL.
A arquitetura seria:
Amazon EC2 | | Spring Boot | v Amazon RDS PostgreSQL
Essa separação permite tratar a camada de banco como um serviço independente da máquina que executa a aplicação.
17. Configurando a aplicação com variáveis de ambiente
As credenciais do banco não devem ser incorporadas diretamente ao código-fonte ou à imagem Docker.
Podemos configurar o Spring Boot utilizando variáveis de ambiente:
spring.datasource.url=${DATABASE_URL}spring.datasource.username=${DATABASE_USERNAME}spring.datasource.password=${DATABASE_PASSWORD}
Na execução do container:
docker run -d \ --name minha-api \ -p 8080:8080 \ -e DATABASE_URL="jdbc:postgresql://HOST:5432/minha_db" \ -e DATABASE_USERNAME="usuario" \ -e DATABASE_PASSWORD="senha" \ ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/minha-api:latest
Para ambientes de produção, credenciais sensíveis podem ser armazenadas em serviços como AWS Secrets Manager ou AWS Systems Manager Parameter Store, evitando manter segredos diretamente nos comandos ou arquivos de configuração.
18. Executando o container
Com a imagem disponível na EC2, executamos:
docker run -d \ --name minha-api \ -p 8080:8080 \ ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/minha-api:latest
Verificamos:
docker ps
Se o container não estiver em execução, podemos consultar os logs:
docker logs minha-api
Para acompanhar os logs em tempo real:
docker logs -f minha-api
19. Testando a API
Primeiro, podemos testar dentro da própria EC2:
curl http://localhost:8080/api/hello
Se estiver tudo funcionando, a resposta será:
Hello AWS!
Também podemos acessar a aplicação utilizando o endereço público da instância:
http://IP_PUBLICO_DA_EC2:8080/api/hello
Nesse caso, o Security Group precisa permitir o tráfego correspondente.
20. Atualizando a aplicação
Quando uma nova versão da aplicação estiver pronta, podemos repetir o processo.
Primeiro, geramos um novo JAR:
./mvnw clean package
Construímos uma nova imagem:
docker build -t minha-api .
Criamos uma nova tag:
docker tag minha-api:latest \ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/minha-api:v2
Enviamos para o ECR:
docker push \ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/minha-api:v2
Na EC2:
docker pull \ACCOUNT_ID.dkr.ecr.us-east-1.amazonaws.com/minha-api:v2
Depois podemos substituir o container em execução pela nova versão.
Em ambientes reais, esse processo normalmente é automatizado utilizando pipelines de CI/CD, evitando operações manuais.
21. Melhorando a arquitetura para produção
A arquitetura utilizada neste laboratório é propositalmente simples.
Para um ambiente de produção, existem diversos aspectos que podem ser aprimorados.
Uma arquitetura possível seria:
Internet | v Application Load Balancer | v Amazon EC2 | Docker | Spring Boot | v Amazon RDS PostgreSQL
Nesse cenário, podemos utilizar:
- Application Load Balancer para receber as requisições;
- HTTPS para proteger o tráfego;
- AWS Certificate Manager para gerenciamento de certificados;
- Amazon Route 53 para DNS;
- Amazon RDS para PostgreSQL;
- Amazon ECR para imagens;
- IAM Roles para autorização;
- AWS Secrets Manager ou Systems Manager Parameter Store para configurações sensíveis;
- Amazon CloudWatch para logs e monitoramento;
- Auto Scaling para aumentar ou reduzir a capacidade conforme a necessidade.
Outra possibilidade é substituir a administração direta dos containers na EC2 por um serviço de orquestração, como Amazon ECS.
22. Considerações de segurança
Ao disponibilizar uma aplicação na AWS, segurança deve fazer parte da arquitetura desde o início.
Algumas práticas importantes incluem:
Princípio do menor privilégio
As IAM Roles e políticas devem conceder apenas as permissões necessárias.
Não armazenar credenciais no código
Senhas, tokens e outras informações sensíveis não devem ser versionados no Git.
Restringir o acesso SSH
A porta 22 deve ser acessível somente a partir das origens necessárias.
Utilizar HTTPS
Aplicações que recebem dados de usuários devem utilizar HTTPS para proteger a comunicação.
Evitar exposição desnecessária
A porta utilizada internamente pelo Spring Boot, como 8080, não precisa necessariamente estar diretamente exposta à Internet.
Uma arquitetura com Load Balancer pode receber o tráfego externo em HTTPS e encaminhá-lo para a aplicação dentro da infraestrutura AWS.
Manter dependências atualizadas
A aplicação, as imagens Docker e os componentes utilizados na infraestrutura devem ser mantidos atualizados.
23. Monitoramento
Depois que a aplicação estiver funcionando, ainda é necessário acompanhar seu comportamento.
Podemos utilizar o Amazon CloudWatch para monitorar métricas e centralizar logs, dependendo da arquitetura adotada.
No próprio container, durante a fase de diagnóstico, podemos utilizar:
docker logs minha-api
Também podemos verificar os containers ativos:
docker ps
E consultar informações do container:
docker inspect minha-api
Esses comandos são especialmente úteis durante a implantação e investigação de problemas.
24. O que aprendemos
Ao concluir este laboratório, passamos por várias etapas comuns em um fluxo de deployment:
Código | vSpring Boot | vJAR | vDocker Image | vAmazon ECR | vAmazon EC2 | vDocker Container | vSpring Boot API | vPostgreSQL
Durante o processo, trabalhamos com conceitos importantes de desenvolvimento e cloud computing:
- aplicações Java;
- Spring Boot;
- Maven;
- Docker;
- containers;
- Amazon EC2;
- Amazon ECR;
- IAM;
- Security Groups;
- PostgreSQL;
- variáveis de ambiente;
- gerenciamento de credenciais;
- logs;
- monitoramento;
- conceitos de arquitetura em produção.
Conclusão
Realizar o deploy de uma aplicação Spring Boot na AWS é uma forma prática de compreender como desenvolvimento de software e computação em nuvem se conectam.
Neste tutorial, utilizamos o Amazon EC2 como ambiente de execução, o Docker para empacotar a aplicação e o Amazon ECR para armazenar a imagem do container. Também abordamos a integração com PostgreSQL e práticas importantes relacionadas a IAM, credenciais, rede e segurança.
A arquitetura apresentada é adequada como ponto de partida para aprendizado. À medida que os requisitos aumentam, a solução pode evoluir para utilizar serviços gerenciados e componentes adicionais da AWS, como Amazon RDS, Application Load Balancer, CloudWatch, Secrets Manager, Route 53 e Amazon ECS.
O principal objetivo não é apenas colocar uma aplicação no ar, mas entender como cada componente participa do processo de entrega e execução de uma aplicação em nuvem.
Esse conhecimento cria uma base sólida para projetos mais avançados envolvendo Java, Spring Boot, Docker, AWS, Cloud e DevOps.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article