AWS Builder Center

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.

Utilizo tecnologia para desenvolver soluções seguras, eficazes e escaláveis.

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:
  •  FROM  define a imagem base;
  •  WORKDIR  define o diretório de trabalho;
  •  COPY  copia o JAR para dentro da imagem;
  •  EXPOSE  documenta a porta utilizada pela aplicação;
  •  ENTRYPOINT  define 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:
  1. Acesse o serviço Amazon EC2.
  1. Escolha Launch instance.
  1. Defina um nome para a instância.
  1. Selecione uma AMI Linux compatível.
  1. Escolha um tipo de instância adequado ao laboratório.
  1. Configure a chave utilizada para acesso SSH.
  1. Configure o Security Group.
  1. Crie a instância.
Para um laboratório, podemos permitir temporariamente:
SSH
TCP 22
Origem: seu IP

Custom TCP
TCP 8080
Origem: 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
|
v
Spring Boot
|
v
JAR
|
v
Docker Image
|
v
Amazon ECR
|
v
Amazon EC2
|
v
Docker Container
|
v
Spring Boot API
|
v
PostgreSQL

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.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article