# Finch da AWS: alternativa ao Docker Desktop, testada num projeto

> Troquei docker por finch em um projeto Node com React e Postgres: build, run, compose e migrate. Só os comandos mudam. Veja o que testei e o que não.

- Autor: Henrylle Maia, consultor AWS
- Publicado em: 2026-10-15
- Assuntos: Containers
- URL: https://pages.formacaoaws.com.br/blog/finch-da-aws-alternativa-ao-docker-desktop/
- Aula de origem: "Docker acabou? Conheça o Finch da AWS (grátis e rápido!)" (https://www.youtube.com/watch?v=PQQXd_S2M3c)

Parei o Docker da minha máquina e rodei um projeto real (Node, React e Postgres) só com o Finch, o cliente de containers de código aberto mantido pela AWS. O Dockerfile e o compose.yml ficaram como estavam; só a primeira palavra do comando mudou. Abaixo estão os comandos, os erros que cometi e o que o teste não cobre.

## Por que olhar para uma alternativa ao Docker

O Docker deixou de ser gratuito para empresas grandes. Pelo que citei, desde 2021, com avaliação a partir de janeiro de 2022: a cobrança vale para empresas a partir de 250 usuários (ou 10 milhões de dólares de faturamento). Confira os números atuais na página oficial do Docker, porque eles podem mudar.

Eu não estou dizendo que o Docker vai morrer. Pode ser que ele continue sendo o padrão do mercado. Mas se o critério de licenciamento mudar, por exemplo para empresas a partir de 50 usuários, uma fatia bem maior de empresas passa a ser afetada. Por isso, no seu lugar, eu também começaria a fazer testes.

## O que é o Finch

O Finch é código aberto, funciona só por linha de comando e foi criado e é mantido pela AWS. Ele foi lançado em 2022. O repositório oficial está em [github.com/runfinch/finch](https://github.com/runfinch/finch), a documentação em [runfinch.com/docs](https://runfinch.com/docs/) e o anúncio de lançamento no [blog de código aberto da AWS](https://aws.amazon.com/blogs/opensource/introducing-finch-an-open-source-client-for-container-development/).

O Docker, para você operar, pede o Docker Desktop, que é mais pesado. O Finch dispensa esse programa. Os dois usam por baixo o containerd, o ambiente de execução de containers padrão do setor, focado em simplicidade e robustez. Por isso a sua aplicação, muito provavelmente, não precisa do Docker: precisa de um runtime de containers.

![Docker e Finch lado a lado: o Docker é pago para grandes empresas e pede o Docker Desktop; o Finch é open source, de linha de comando e criado e mantido pela AWS; os dois usam containerd](https://pages.formacaoaws.com.br/blog/assets/posts/finch-da-aws-alternativa-ao-docker-desktop/finch-desenho.svg)

Ele é compatível com Mac, Windows e Linux, incluindo Ubuntu e instâncias Amazon Linux. A documentação oficial traz a instalação para cada um dos três sistemas.

## Passo 1: conferir que o Finch está rodando

Eu não cobri a instalação. O post de lançamento da AWS que mostrei traz o passo a passo: depois de instalar, a máquina virtual do Finch é inicializada com `finch vm init` e, depois de um reinício, sobe de novo com `finch vm start`. Eu só rodei o teste.

Primeiro parei o Docker e rodei `docker run hello-world`: parou de responder. Depois, a imagem de teste do Finch:

```bash
finch run --rm public.ecr.aws/finch/hello-finch
```

Ela imprime "Hello from Finch!": o Finch funciona e o Docker está parado.

## Passo 2: build e run, trocando só a primeira palavra

O projeto de teste é o BIA, aplicação em Node com React que uso com os alunos da Formação AWS. Ele já tem `Dockerfile` e `compose.yml`, e eu não mexi em nenhum dos dois. Com o Docker seria `docker build -t bia-finch .`. Com o Finch:

```bash
finch build -t bia-finch .
```

O comando procura o `Dockerfile` no diretório atual. Na primeira tentativa errei o diretório e veio "no such file or directory"; entrei na pasta do projeto e rodou. O build correu como no Docker, com o Docker parado.

Para subir o container, as opções vêm antes do nome da imagem:

```bash
finch run -p 3001:8080 --rm bia-finch
```

O `-p 3001:8080` mapeia a porta 3001 da máquina para a 8080 do container, e o `--rm` remove o container quando ele parar. Na primeira vez escrevi o nome da imagem antes da porta e deu erro: a imagem vai por último. Abri `localhost:3001` e a aplicação estava de pé. Com Ctrl+C o container para.

## Passo 3: subir com compose, banco incluso

A aplicação precisa do banco, então uso compose. O `compose.yml` do projeto faz o build do servidor, publica a porta e depende do serviço do banco (Postgres 17.1).

![O compose.yml do projeto, sem alteração: build do servidor, container bia, porta 3001:8080 e depends_on do serviço database](https://pages.formacaoaws.com.br/blog/assets/posts/finch-da-aws-alternativa-ao-docker-desktop/finch-compose.webp)

Com o Docker eu rodaria `docker compose up -d`. Com o Finch:

```bash
finch compose up -d
```

Saíram alguns avisos e informações do próprio Finch, mas o projeto subiu. Conferi com `finch ps`: os dois containers estavam de pé, criados com 8 e 7 segundos de diferença, primeiro o banco e depois o servidor. **Fluxo:** Dockerfile e compose.yml (os mesmos do Docker) → finch build (imagem local) → finch compose up -d (banco e servidor) → finch compose exec (migrate do banco) → localhost:3001 (a aplicação salvando dados)

## Passo 4: rodar a migration e testar a persistência

Na primeira tentativa, a tarefa não foi salva. O motivo não é o Finch: o projeto tem migrations, e a tabela de tarefas ainda não existia. O README do projeto traz o comando para o Docker; basta trocar a primeira palavra:

```bash
finch compose exec server bash -c 'npx sequelize db:migrate'
```

Ele entra no serviço `server` e roda o Sequelize para criar a estrutura relacional. A saída mostrou as migrations rodando.

Depois disso, cadastrei a tarefa "tirando docker e colocando o finch" e ela foi salva.

![A aplicação BIA em localhost:3001, rodando no Finch, com a tarefa "tirando docker e colocando o finch" cadastrada para HOJE](https://pages.formacaoaws.com.br/blog/assets/posts/finch-da-aws-alternativa-ao-docker-desktop/finch-app.webp)

Para ver o banco trabalhando, abri os logs:

```bash
finch logs -f
```

Dá para ver os INSERT, SELECT e UPDATE a cada tarefa. Tudo se comportou como se eu estivesse com o Docker.

## O que eu concluo (e o que não)

Eu não concluí que o Docker acabou. Concluí que existem alternativas e que vale começar a testar antes de precisar. O Finch rodou o meu projeto com build, run, compose e migrate sem eu mexer no Dockerfile nem no compose.yml. Citei também o Podman e outras opções do mercado.

Se a sua empresa é pequena, talvez você não precise fazer nada. Se ela está em uma situação que pode ficar em risco pela quantidade de funcionários, por que não mudar? Ainda tem o ganho de não depender do Docker Desktop: o Finch se instala por linha de comando e a máquina virtual é bem leve.

O que o teste não cobre: foi um projeto só, na minha máquina. Estou testando o Finch de forma exaustiva e confio nele por ser mantido pela AWS, mas faça os seus testes no seu projeto antes de trocar qualquer coisa.

## Checklist

- [ ] Finch instalado e a máquina virtual iniciada (`finch vm init`, `finch vm start`)
- [ ] `finch run --rm public.ecr.aws/finch/hello-finch` imprime "Hello from Finch!"
- [ ] `finch build -t <nome> .` roda no diretório do `Dockerfile`
- [ ] `finch run -p 3001:8080 --rm <nome>` abre a aplicação em `localhost:3001`, com as opções antes da imagem
- [ ] `finch compose up -d` sobe o servidor e o banco, e `finch ps` lista os dois containers
- [ ] A migration rodou com `finch compose exec` e a aplicação salva dados
- [ ] Você conferiu a licença atual do Docker na página oficial

Se você quer aprender containers e AWS fazendo projeto de verdade, como este, é esse o trabalho da Formação AWS.