Pular para o conteúdo principal

Tutorial: Docker no Windows com Nginx + Visual Studio Code

Este tutorial ensina a instalar e utilizar o Docker Desktop no Windows, usando o Visual Studio Code como IDE e o Prompt de Comando (CMD) para executar os comandos.

Você aprenderá a:

  • Instalar o Docker Desktop via winget
  • Verificar se o sistema está pronto
  • Configurar o VS Code com um perfil dedicado docker
  • Criar e construir um Dockerfile
  • Trabalhar com Volumes
  • Usar Variáveis de Ambiente
  • Executar scripts shell dentro do container
  • Usar Docker Compose
  • Executar comandos dentro de containers

Pré-requisitos do sistema​

Antes de instalar o Docker Desktop, confirme os requisitos:

RequisitoDetalhe
Sistema operacionalWindows 10 64-bit (21H2 ou superior) ou Windows 11
Arquiteturax64 ou ARM64
Memória RAMMínimo 4 GB (recomendado 8 GB ou mais)
VirtualizaçãoHardware virtualization (Intel VT-x / AMD-V) habilitada na BIOS
WSL 2Recomendado (backend padrão)
Espaço em discoPelo menos 6 GB livres
IDEVisual Studio Code instalado

Verificar virtualização​

  1. Abra o Gerenciador de Tarefas (Ctrl + Shift + Esc)
  2. Vá na aba Desempenho → CPU
  3. Confirme que Virtualização está Habilitada

Habilitar WSL 2 (recomendado)​

Abra o Prompt de Comando como Administrador e execute:

wsl --install

Reinicie o computador se solicitado. Depois atualize:

wsl --update
wsl --set-default-version 2

Verifique a versão:

wsl --version

Instalação do Docker Desktop via winget​

O winget é o gerenciador de pacotes oficial da Microsoft.

1. Verificar se o winget está disponível​

Abra o CMD e execute:

winget --version

2. Instalar o Docker Desktop​

winget install -e --id Docker.DockerDesktop

Aceite os termos se solicitado (Y).

3. Iniciar o Docker Desktop​

Após a instalação:

  1. Abra o Docker Desktop pelo menu Iniciar
  2. Aceite os termos de serviço
  3. Aguarde até o status ficar Running (ícone da baleia na bandeja do sistema)

Verificação da instalação​

Abra um novo CMD e execute:

docker --version
docker compose version
docker info

Teste rápido com a imagem oficial do Nginx:

docker run --rm -d -p 8080:80 --name teste-nginx nginx

Acesse no navegador: http://localhost:8080

Você deve ver a página padrão do Nginx.

Pare o container:

docker stop teste-nginx

Configurando o Visual Studio Code​

1. Criar um perfil dedicado chamado docker​

Os Profiles do VS Code permitem isolar extensões, configurações e layout para diferentes contextos de trabalho.

Opção A – Pela interface (recomendada)​

  1. Abra o VS Code
  2. Pressione Ctrl + Shift + P
  3. Digite e selecione: Profiles: Create Profile
  4. Escolha Empty Profile (perfil vazio)
  5. Digite o nome: docker
  6. Confirme

Opção B – Pelo CMD (cria o perfil automaticamente se não existir)​

code --profile docker
dica

Para sempre abrir o projeto com esse perfil:

code . --profile docker

2. Instalar as extensões no perfil docker​

As extensões do VS Code não são instaladas via winget. O método oficial é o CLI do próprio VS Code.

Abra o CMD e execute:

code --profile docker --install-extension ms-azuretools.vscode-containers --install-extension docker.docker
ExtensãoIDFunção principal
Container Toolsms-azuretools.vscode-containersExplorer visual de containers, imagens, volumes, redes
Docker DXdocker.dockerLinting avançado de Dockerfile e Compose

Verifique as extensões instaladas:

code --profile docker --list-extensions

3. Definir o CMD como terminal padrão no perfil​

  1. Com o perfil docker ativo, pressione Ctrl + Shift + P
  2. Digite: Terminal: Select Default Profile
  3. Escolha Command Prompt

Abrindo o projeto no VS Code com o perfil docker​

cd C:\caminho\para\meu-nginx
code . --profile docker

Projeto prático: Nginx com conteúdo personalizado​

Estrutura de pastas​

meu-nginx/
├── Dockerfile
├── docker-compose.yml
├── .env
├── .dockerignore
├── html/
│   └── index.html
└── scripts/
    └── ola.sh

Conteúdo do index.html​

<!DOCTYPE html>
<html lang="pt-BR">
  <head>
    <meta charset="UTF-8" />
    <title>Meu Site com Nginx + Docker</title>
    <style>
      body {
        font-family: system-ui, sans-serif;
        background: #0f172a;
        color: #e2e8f0;
        display: flex;
        justify-content: center;
        align-items: center;
        height: 100vh;
        margin: 0;
      }
      h1 {
        font-size: 2.5rem;
      }
    </style>
  </head>
  <body>
    <h1>🚀 Site rodando com Nginx no Docker!</h1>
  </body>
</html>

Explorando o Dockerfile​

Crie o arquivo Dockerfile:

FROM nginx:alpine

# Variáveis de ambiente padrão
ENV AMBIENTE=desenvolvimento
ENV APP_VERSION=1.0.0
ENV MENSAGEM="Valor padrao do Dockerfile"

# Remove a página padrão do Nginx
RUN rm -rf /usr/share/nginx/html/*

# Copia os arquivos estáticos
COPY html/ /usr/share/nginx/html/

# Copia o script e dá permissão de execução
COPY scripts/ola.sh /usr/local/bin/ola.sh
RUN chmod +x /usr/local/bin/ola.sh

EXPOSE 80

CMD ["nginx", "-g", "daemon off;"]

Principais instruções explicadas​

InstruçãoFunção
FROMDefine a imagem base
ENVDefine variáveis de ambiente padrão
RUNExecuta comandos durante o build da imagem
COPYCopia arquivos/pastas do host para a imagem
EXPOSEDocumenta a porta que o container usa
CMDComando executado quando o container inicia
dica

Use COPY em vez de ADD na maioria dos casos (mais previsível).

Build da imagem​

No terminal do VS Code (CMD), dentro da pasta do projeto, execute:

docker build -t meu-nginx:1.0 .

Verifique as imagens:

docker images

Rodar o container a partir da imagem​

docker run -d -p 8080:80 --name site-nginx meu-nginx:1.0

Acesse: http://localhost:8080

Comandos úteis:

docker ps
docker logs site-nginx
docker stop site-nginx
docker rm site-nginx

Docker Compose – comandos básicos​

Crie o arquivo docker-compose.yml:

services:
  web:
    build: .
    image: meu-nginx:1.0
    container_name: site-nginx
    ports:
      - "8080:80"
    env_file:
      - .env
    volumes:
      - ./html:/usr/share/nginx/html:ro
      - ./scripts:/scripts:ro
    restart: unless-stopped

Comandos principais do Compose​

ComandoDescrição
docker compose up -dSobe os serviços em background
docker compose up --build -dFaz build e sobe
docker compose downPara e remove containers, redes e volumes
docker compose psLista os serviços
docker compose logs -fMostra logs em tempo real
docker compose buildApenas constrói as imagens
docker compose restartReinicia os serviços

Exemplo completo:

docker compose up --build -d
docker compose ps
docker compose logs -f web
docker compose down

Volumes no Docker​

Volumes permitem persistir dados e compartilhar arquivos entre o host (Windows) e o container.

TipoDescriçãoUso comum
Bind MountLiga uma pasta do Windows a uma pasta do containerDesenvolvimento (código vivo)
Named VolumeVolume gerenciado pelo DockerDados persistentes (bancos, logs)

1. Bind Mount (pasta do Windows → container)​

Ideal para desenvolvimento: qualquer alteração no arquivo local aparece imediatamente no container.

Exemplo com docker run​

docker run -d -p 8080:80 --name site-nginx ^
  -v %cd%\html:/usr/share/nginx/html:ro ^
  meu-nginx:1.0

Exemplo com Docker Compose​

Já está configurado no docker-compose.yml acima:

volumes:
  - ./html:/usr/share/nginx/html:ro
  - ./scripts:/scripts:ro
dica

O modificador :ro significa read-only (somente leitura). Use sempre que possível para arquivos estáticos.

2. Named Volume (volume gerenciado pelo Docker)​

docker volume create nginx-data

docker run -d -p 8080:80 --name site-nginx ^
  -v nginx-data:/usr/share/nginx/html ^
  meu-nginx:1.0

Com Compose:

services:
  web:
    image: nginx:alpine
    ports:
      - "8080:80"
    volumes:
      - nginx-data:/usr/share/nginx/html

volumes:
  nginx-data:

Comandos úteis de volumes​

docker volume ls
docker volume inspect nginx-data
docker volume rm nginx-data
docker volume prune
informação

Com a extensão Container Tools você consegue ver e gerenciar volumes visualmente no painel lateral do VS Code.

Variáveis de Ambiente no Docker​

Variáveis de ambiente são uma forma limpa de passar configurações para o container sem alterar o código ou a imagem.

1. Definindo variáveis com docker run​

docker run -d -p 8080:80 --name site-nginx ^
  -e AMBIENTE=producao ^
  -e APP_VERSION=1.0.0 ^
  -e MENSAGEM="Ola do container" ^
  meu-nginx:1.0

Carregar de um arquivo .env:

docker run -d -p 8080:80 --name site-nginx --env-file .env meu-nginx:1.0

2. Criando o arquivo .env​

AMBIENTE=desenvolvimento
APP_VERSION=1.2.3
MENSAGEM=Site rodando com Docker + Nginx
NGINX_HOST=localhost
aviso

Adicione o arquivo .env no .gitignore para não versionar dados sensíveis (senhas, tokens, etc.).

3. Usando variáveis no Docker Compose​

A forma mais limpa é com env_file (já configurado no exemplo anterior):

env_file:
  - .env

Ou definir diretamente:

environment:
  - AMBIENTE=producao
  - APP_VERSION=1.0.0
  - MENSAGEM=Ola do Compose

4. Definindo variáveis no Dockerfile (ENV)​

Valores padrão já estão definidos no Dockerfile mostrado anteriormente.

dica

Variáveis passadas com -e ou no Compose sobrescrevem as definidas no Dockerfile.

5. Lendo as variáveis dentro do container​

docker exec site-nginx printenv
docker exec site-nginx printenv AMBIENTE
docker exec site-nginx sh -c "echo %MENSAGEM%"

Executando um script shell (.sh) dentro do container​

1. Criar o script​

Crie o arquivo scripts\ola.sh:

#!/bin/sh

echo "========================================"
echo "  Script com Variáveis de Ambiente"
echo "========================================"
echo "Ambiente........: $AMBIENTE"
echo "Versão..........: $APP_VERSION"
echo "Mensagem........: $MENSAGEM"
echo "Data e hora.....: $(date)"
echo "Hostname........: $(hostname)"
echo "Arquivos em /usr/share/nginx/html:"
ls -la /usr/share/nginx/html
echo "========================================"

2. Executar o script​

Com a imagem que já contém o script​

docker exec site-nginx /usr/local/bin/ola.sh

Com Docker Compose​

docker compose exec web /usr/local/bin/ola.sh

Alternativa rápida (sem rebuild) usando volume​

docker exec site-nginx sh /scripts/ola.sh

Exemplo de saída esperada​

========================================
  Script com Variáveis de Ambiente
========================================
Ambiente........: desenvolvimento
Versão..........: 1.2.3
Mensagem........: Site rodando com Docker + Nginx
Data e hora.....: Wed Sep 16 16:55:12 UTC 2026
Hostname........: a1b2c3d4e5f6
Arquivos em /usr/share/nginx/html:
total 8
...
========================================
dica

Sempre use #!/bin/sh (ou #!/bin/bash) no início do script e dê permissão de execução com chmod +x.

Executar comandos dentro do container​

1. Executar um comando pontual (docker exec)​

docker exec -it site-nginx sh

Dentro do container:

ls /usr/share/nginx/html
cat /usr/share/nginx/html/index.html
nginx -t
exit

Outros exemplos:

docker exec site-nginx ls -la /usr/share/nginx/html
docker exec site-nginx ps aux

2. Usando Docker Compose​

docker compose exec web sh

3. Pela extensão Container Tools​

  1. Abra o painel Containers
  2. Clique com o botão direito no container
  3. Escolha Attach Shell

Boas práticas e dicas finais​

  1. Use tags específicas (nginx:1.27-alpine em vez de nginx:latest).
  2. Multi-stage builds são úteis em projetos maiores.
  3. .dockerignore – crie um arquivo para ignorar arquivos desnecessários no build:
.git
.env
*.md
node_modules
  1. Volumes – para desenvolvimento, prefira bind mounts.
  2. Variáveis sensíveis – nunca coloque senhas no Dockerfile.
  3. Limpe recursos não utilizados:
docker system prune -a
perigo

O comando docker system prune -a remove todas as imagens não utilizadas. Use com cuidado.

Resumo dos comandos mais usados (CMD)​

REM Instalação
winget install -e --id Docker.DockerDesktop

REM Build
docker build -t nome:tag .

REM Run com volume e variáveis
docker run -d -p 8080:80 --name container ^
  -v %cd%\html:/usr/share/nginx/html:ro ^
  --env-file .env ^
  imagem

REM Compose
docker compose up --build -d
docker compose down

REM Executar comandos e scripts
docker exec -it container sh
docker exec container /usr/local/bin/ola.sh
docker compose exec servico sh

Conclusão​

Você agora sabe:

  • Instalar o Docker Desktop no Windows via winget
  • Verificar o ambiente (WSL 2 + virtualização)
  • Configurar o VS Code com um perfil docker e as extensões Container Tools + Docker DX
  • Criar um Dockerfile baseado em Nginx
  • Trabalhar com Volumes (bind mount e named volume)
  • Usar Variáveis de Ambiente (Dockerfile, .env, Compose e CLI)
  • Executar scripts shell dentro do container
  • Usar Docker Compose
  • Executar comandos dentro de containers (via CLI e pela extensão)

Este é o fundamento para qualquer aplicação containerizada. A partir daqui você pode evoluir para aplicações Node.js, Python, bancos de dados e orquestração com Kubernetes.

Bom aprendizado e bons containers! 🐳

Última atualização em por Adriano Ruseler