# App Node com React na EC2 com Docker Compose, passo a passo

> Suba uma aplicação Node com React e PostgreSQL numa instância EC2 com Docker Compose: clone, ajuste do Dockerfile, porta 80 e migrate do banco.

- Autor: Henrylle Maia, consultor AWS
- Publicado em: 2026-10-15
- Assuntos: Containers
- URL: https://pages.formacaoaws.com.br/blog/app-node-react-na-ec2-com-docker/
- Aula de origem: "Como rodar uma app em Node com React numa EC2 usando Docker" (https://www.youtube.com/watch?v=FGniGJbyvEA)

Se o projeto não roda na sua máquina por causa de pacote do NPM ou de requisito do Docker no Windows, rode-o numa instância EC2. Neste passo a passo, uma aplicação em Node com React e PostgreSQL, já containerizada, sobe com `docker-compose up` e responde na porta 80.

> **Importante:** gravei esta aula em 26 de janeiro de 2022. A tela de lançamento da EC2, a imagem `node:14` e o comando `docker-compose` (com hífen) são os daquela época. Confira o lançamento de instância no [guia oficial da EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstancesLinux.html) e a instalação do Compose na [documentação do Docker](https://docs.docker.com/compose/). Desde 1º de fevereiro de 2024, a AWS cobra todo IPv4 público, inclusive o da instância deste passo a passo: veja [IP público cobrado na AWS](https://pages.formacaoaws.com.br/blog/ip-publico-ipv4-cobrado-na-aws/).

## A aplicação e o ponto de partida

A aplicação se chama BIA. É um projeto em Node com React e PostgreSQL, com estrutura containerizada, que eu usei no evento Bootcamp Imersão AWS com Docker. O código está no [repositório `henrylle/bia`](https://github.com/henrylle/bia), no GitHub.

Nesse evento, parte do pessoal teve problema de ambiente: o Windows reclamava de requisito, de pacote do NPM ou de alguma coisa do Docker. A saída que mostro aqui é rodar o projeto direto numa EC2.

O projeto tem um `Dockerfile` e um `docker-compose.yml`. O Compose é o que sobe vários containers de uma vez: aqui, o servidor web e o banco PostgreSQL. Se você nunca trabalhou com Docker, comece por [o que é Docker](https://pages.formacaoaws.com.br/blog/o-que-e-docker/).

## Passo 1: lance a instância

Lancei uma instância com estas escolhas:

- **Imagem:** Amazon Linux, arquitetura x86.
- **Tipo:** t3.micro.
- **Rede:** IP público habilitado (Auto-assign Public IP). Os padrões já atendem.
- **Disco:** 8 GB, mais que suficiente.
- **Nome:** `bia-na-ec2`.
- **Security group:** liberar a **porta 80**, para ver a aplicação rodando, e a **porta 22**, para o acesso por SSH.
- **Chave PEM:** a que você já tem, guardada com cuidado.

Usei um security group que já existia na minha conta. Se você não tem, crie um novo com essas duas regras. Os detalhes de security group e de chave PEM eu mostrei em outras aulas de lançamento de instância Linux, e o pré-requisito aqui é saber o básico de EC2.

## Passo 2: conecte por SSH e instale Docker, Compose e Git

No console da EC2, selecione a instância, clique em **Connect** e abra a aba **SSH client**. Ela mostra o comando pronto. No terminal, vá para a pasta onde está a sua chave `.pem` e execute esse comando, com a chave e o endereço da instância.

Para instalar o Docker eu segui a sequência da aula de Docker na EC2, que está em [Docker na EC2 com Amazon Linux](https://pages.formacaoaws.com.br/blog/docker-na-ec2/). Em resumo, foram estes passos: instalar o pacote do Docker, iniciar o serviço, habilitá-lo para subir após reinício, dar permissão ao `ec2-user` para não trabalhar como root e reiniciar a instância. O reboot levou uns 15 a 20 segundos.

Conferi com o `docker run hello-world`. Funcionou, e o Docker estava pronto.

O Docker Compose entrou na sequência: baixei o binário com `wget` e dei permissão de execução com `chmod`. Conferi a instalação pela versão. Aqui eu não repito os comandos, porque a mesma sequência está na aula de Docker Compose.

Por fim, o Git, para baixar o projeto. Atualizei os pacotes e instalei:

```bash
sudo yum update
sudo yum install git -y
git --version
```

O `yum update` atualiza os pacotes, o `install` instala o Git (o `-y` evita a pergunta de confirmação) e a última linha confere a versão.

## Passo 3: clone o projeto e ajuste dois arquivos

Estando na home do `ec2-user`, clonei o projeto e entrei na pasta:

```bash
git clone https://github.com/henrylle/bia.git
cd bia
```

Dois arquivos importam: o `Dockerfile`, com as instruções para gerar a imagem, e o `docker-compose.yml`. Fiz duas edições, com o `nano`.

**No Dockerfile**, troquei o endereço da API que o front-end usa. A linha do `RUN` que faz o build do cliente vinha apontando para `localhost`. Pus no lugar o IP público da instância, que aparece nos detalhes dela no console:

```dockerfile
# antes
RUN REACT_APP_API_URL=http://localhost:3001 SKIP_PREFLIGHT_CHECK=true npm run build --prefix client
# depois
RUN REACT_APP_API_URL=http://<ip-publico-da-instancia> SKIP_PREFLIGHT_CHECK=true npm run build --prefix client
```

**No docker-compose.yml**, mudei a porta do servidor para a 80, para acessar a aplicação sem digitar porta na URL. O mapeamento, que era `3001:8080`, ficou `80:8080`: a porta 80 da instância entra na 8080 do container.

![docker-compose.yml no nano: o serviço server publicado em 80:8080 e o serviço database com a imagem postgres:10.17](https://pages.formacaoaws.com.br/blog/assets/posts/app-node-react-na-ec2-com-docker/compose-porta-80.webp)

> **Importante:** o Compose do projeto traz usuário e senha `postgres` em texto no arquivo. Para tirar senha do arquivo, veja [senha em variável de ambiente com o Secrets Manager](https://pages.formacaoaws.com.br/blog/senha-em-variavel-de-ambiente-secrets-manager/).

## Passo 4: suba os containers

Com os dois arquivos salvos, um comando faz o resto:

```bash
docker-compose up -d
```

O `-d` roda em segundo plano (modo detached). O Compose baixa o Node, executa cada passo do Dockerfile, instala as dependências e faz o build do projeto, e sobe o banco. Na primeira vez demora. Quando termina, ele cria a rede, o banco e o servidor.

**Fluxo:** Instância EC2 (Amazon Linux, portas 22 e 80) → Docker e Git (instalados via SSH) → Projeto (clone, Dockerfile e Compose) → docker-compose up (app e PostgreSQL) → Migrate (cria as tabelas)

## Passo 5: rode o migrate do banco

Abri o IP público da instância no navegador e a aplicação carregou. O cadastro de tarefa, porém, deu erro: faltava criar a estrutura do banco. Isso é o **migrate**, que cria as tabelas.

Liste os containers para ver o nome do servidor:

```bash
docker ps
```

Entre no container do servidor e rode o migrate com o Sequelize:

```bash
docker exec -ti bia-server-1 bash
npx sequelize db:migrate
```

O primeiro comando abre um terminal dentro do container `bia-server-1`. O segundo cria a estrutura do banco. Depois, atualizei a página e tudo funcionou: cadastrei uma tarefa de teste e ela apareceu na lista.

![A aplicação BIA rodando na EC2, com a tarefa "Tarefa teste BIA na EC2", Dia 1, salva e listada](https://pages.formacaoaws.com.br/blog/assets/posts/app-node-react-na-ec2-com-docker/app-bia-rodando.webp)

O resultado: uma aplicação Node com React, com banco PostgreSQL, rodando em Docker Compose numa EC2, sem depender do ambiente da sua máquina.

## E se a aplicação precisar de mais de uma instância?

Aqui é uma instância só, com app e banco juntos. No evento, usei esse mesmo projeto numa prática de alta disponibilidade, que expliquei em [Docker com alta disponibilidade na AWS](https://pages.formacaoaws.com.br/blog/docker-alta-disponibilidade-na-aws/). Para subir container no serviço de containers da AWS, leia [primeiro container em produção no ECS](https://pages.formacaoaws.com.br/blog/primeiro-container-em-producao-no-ecs/).

## Checklist

- Lance uma instância Amazon Linux x86 com IP público, 8 GB e security group com as portas 80 e 22.
- Conecte por SSH pelo comando da aba SSH client do console.
- Instale o Docker, dê permissão ao `ec2-user`, reinicie e confira com `docker run hello-world`.
- Instale o Docker Compose e o Git, e confira as versões.
- Clone o projeto e entre na pasta.
- No Dockerfile, troque o endereço da API pelo IP público da instância.
- No Compose, publique o servidor na porta 80.
- Suba tudo com `docker-compose up -d`.
- Entre no container do servidor e rode `npx sequelize db:migrate`.
- Abra o IP público no navegador e cadastre uma tarefa de teste.

Se a sua aplicação em container roda na máquina do dev e você quer levá-la para a AWS sem surpresa, vale uma conversa para olhar o seu cenário.