# Docker e Node no Windows com Vagrant e VS Code remoto

> Suba uma VM Linux com Vagrant e VirtualBox, conecte pelo VS Code por SSH e rode Docker e Node sem instalá-los no Windows.

- Autor: Henrylle Maia, consultor AWS
- Publicado em: 2026-10-15
- Assuntos: Containers
- URL: https://pages.formacaoaws.com.br/blog/vagrant-virtualbox-docker-no-windows/
- Aula de origem: "Setup alternativo ninja para trabalhar com Docker e Node no Windows" (https://www.youtube.com/watch?v=GOyWFkyoGOE)

Se o Docker não funciona no seu Windows, ou você prefere não instalar Node e Docker nele, trabalhe dentro de uma máquina virtual Linux. Com Vagrant e VirtualBox ela sobe com um comando, você edita o código pelo VS Code como se fosse local e, quando quiser, joga a VM fora.

Esta aula é de fevereiro de 2022. Versões, imagens e passos dos programas mudam: confira a [instalação do Vagrant](https://developer.hashicorp.com/vagrant/install) e o [Remote SSH do VS Code](https://code.visualstudio.com/docs/remote/ssh) na documentação oficial. Se o Docker já roda bem no seu Windows, o caminho direto está em [Docker no Windows: instalar e rodar o primeiro container](https://pages.formacaoaws.com.br/blog/docker-no-windows/).

## Por que um ambiente alternativo

Fiz este ambiente depois de um evento meu de janeiro de 2022 sobre AWS com Docker. Para acompanhar, a pessoa precisava de Node, NPM, Docker e Docker Compose na máquina, e quase todos os problemas que recebi tinham a ver com o Windows.

A ideia é encurtar o caminho: deixar o ambiente pronto para você começar a rodar e containerizar o projeto. Depois, se quiser, migra para WSL2 ou Linux de verdade, que é o ideal para Docker.

O que cada peça faz:

- **VirtualBox** roda a máquina virtual, mas você não mexe nele diretamente.
- **Vagrant** automatiza a criação da VM a partir de um arquivo, o `Vagrantfile`, que funciona como um Dockerfile da máquina: diz o sistema operacional e o que fazer ao subir.
- **VS Code** com a extensão Remote SSH conecta na VM. Seu Windows só roda o editor.
- **Git Bash** (ou outro Git) clona o projeto de exemplo.

## Passo 1: instalar as ferramentas

Instale, nesta ordem, o VirtualBox (versão para Windows), o Vagrant (64 bits), o Git e o VS Code, cada um no next, next, next. O instalador pode pedir para reiniciar a máquina: reinicie. Na instalação do VirtualBox, deixei desmarcada a opção de abrir o programa ao terminar.

Depois do reboot, abra o terminal do VS Code e confirme que o Vagrant responde:

```bash
vagrant -h
```

Se ele listar os comandos, está instalado.

## Passo 2: clonar o projeto e subir a VM

Clone o projeto de exemplo, o [bia_vagrant](https://github.com/henrylle/bia_vagrant), numa pasta sua e abra essa pasta no VS Code. Na raiz está o `Vagrantfile`. Suba a VM:

```bash
vagrant up
```

O Vagrant lê o `Vagrantfile`, procura a box `ubuntu/focal64` (o Ubuntu 20.04) e, se não a tiver, baixa. Estimo que a box tenha uns 2 GB, então leva um tempo. Depois ele importa a VM e roda os scripts de preparo.

![Vagrantfile com três linhas forwarded_port: 3001, 8080 e 5433 da VM para o host](https://pages.formacaoaws.com.br/blog/assets/posts/vagrant-virtualbox-docker-no-windows/vagrantfile-portas.webp)

O arquivo faz três coisas que importam:

1. Escolhe a box `ubuntu/focal64`.
2. Encaminha as portas 3001 (a aplicação em container), 8080 (a aplicação web, se você quiser rodá-la) e 5433 (o PostgreSQL em container).
3. Clona o projeto dentro da VM e dá permissão de execução ao script `prepara_linux_vagrant.sh`.

Eu poderia ter colocado toda a instalação no `Vagrantfile`. Deixei para rodar o script dentro da VM de propósito: assim você sabe o que foi instalado e pode acrescentar o que quiser.

No fim do `vagrant up`, o Vagrant troca a chave SSH insegura padrão por uma chave gerada para a sua VM. Espere ele terminar antes do próximo passo.

## Passo 3: conectar o VS Code por SSH

Peça ao Vagrant os dados de conexão:

```bash
vagrant ssh-config
```

![Saída do vagrant ssh-config com HostName 127.0.0.1, User vagrant, Port 2222 e o IdentityFile da chave privada](https://pages.formacaoaws.com.br/blog/assets/posts/vagrant-virtualbox-docker-no-windows/vagrant-ssh-config.webp)

No VS Code, instale a extensão Remote SSH, clique no ícone dela, escolha **Open SSH Configuration File** e cole esses dados no arquivo. Troque o nome do host para `default`. Depois conecte ao host `default`.

Na primeira conexão o VS Code instala o VS Code Server dentro da VM. Quando terminar, a barra mostra `SSH: default`. Use **Open Folder** na pasta `/home/vagrant` e confie no diretório. O terminal que você abrir daí em diante é o da VM: um `ls` lista os arquivos dela.

## Passo 4: instalar Docker, Node e AWS CLI

Entre na pasta `bia_vagrant` dentro da VM, dê permissão de execução ao script e rode. Na minha aula o `chmod` do Vagrantfile não pegou, então dei a permissão à mão, com `sudo`:

```bash
sudo chmod +x prepara_linux_vagrant.sh
./prepara_linux_vagrant.sh
```

Ele atualiza os pacotes, instala o Docker, habilita o serviço para subir sozinho depois de um reboot, instala o Docker Compose, o Node, o NPM e o AWS CLI, e ajusta as permissões do Docker. Se preferir, rode os comandos do script um a um para ver cada etapa.

O download foi muito lento na minha máquina, principalmente na atualização de pacotes, parecia baixar a 2 KB/s. Espere: acontece uma vez só, e a VM fica pronta para reutilizar.

Confirme:

```bash
docker --version
docker-compose --version
```

## Passo 5: rodar a aplicação de exemplo

Saia da pasta do `bia_vagrant` e, na raiz, clone o projeto da aplicação, a BIA, que é Node com React e PostgreSQL ([henrylle/bia](https://github.com/henrylle/bia)). Entre na pasta dela e suba os containers:

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

O Docker baixa a imagem do PostgreSQL (cerca de 300 a 400 MB) e a do Node, e gera a imagem da aplicação pelo Dockerfile do projeto. A lentidão da rede ficou só na atualização dos pacotes: aqui tudo baixou rápido.

Quando a aplicação sobe, o VS Code avisa que ela está rodando na porta 3001 e faz o encaminhamento sozinho: na aba Ports aparece a 3001, com origem Auto Forwarded. Abra `localhost:3001` no navegador do Windows. A aplicação roda na VM, mas você acessa como se fosse local.

![Aplicação BIA 2022 aberta em localhost:3001 no navegador, com a mensagem Nenhuma tarefa por aqui](https://pages.formacaoaws.com.br/blog/assets/posts/vagrant-virtualbox-docker-no-windows/bia-rodando-na-vm.webp)

A API ainda dá erro, porque o banco não tem as tabelas. No terminal da VM, dentro da pasta do projeto, instale as dependências e rode a migration:

```bash
npm install
npx sequelize db:migrate
```

Com a estrutura do banco criada, atualize a página e adicione uma tarefa na tela: ela é salva e permanece.

**Fluxo:** Vagrantfile (define a VM Ubuntu) → vagrant up (cria a VM no VirtualBox) → VS Code Remote SSH (conecta na VM) → Script de preparo (Docker, Node, AWS CLI) → docker-compose (aplicação na porta 3001)

## Passo 6: destruir o ambiente

Quando terminar, no terminal do Windows, na pasta do projeto:

```bash
vagrant destroy
```

O Vagrant pergunta se você tem certeza. Confirmando, ele desliga e remove a VM, e `localhost:3001` deixa de responder. É por isso que serve para montar laboratórios do zero, isolados, sem comprometer nada na sua máquina.

## Checklist

- Instale VirtualBox, Vagrant, Git e VS Code, e reinicie se pedirem.
- Rode `vagrant -h` para confirmar o Vagrant.
- Clone o bia_vagrant e rode `vagrant up` na pasta com o `Vagrantfile`.
- Rode `vagrant ssh-config` e cole os dados no arquivo de configuração do Remote SSH.
- Conecte ao host `default` e abra a pasta `/home/vagrant`.
- Rode o `prepara_linux_vagrant.sh` e confira `docker --version`.
- Clone a BIA, rode `docker-compose up -d` e abra `localhost:3001`.
- Rode `npm install` e `npx sequelize db:migrate`, e salve uma tarefa.
- Quando acabar, rode `vagrant destroy`.

Com a VM no ar você trabalha com Docker e Node sem instalá-los no Windows, e pode jogar o ambiente fora quando terminar.