Israel Ludolf

Você já ouviu falar de contêineres e de como eles são úteis para ambientes de desenvolvimento, mas ainda não deu o primeiro passo.

Não se preocupe, vou te ajudar. Contêineres podem revolucionar a forma como você programa, oferecendo ambientes isolados e descartáveis, prontos para codar logo de cara. Neste guia definitivo, vou te mostrar tudo o que você precisa para começar com Dev Containers.

Ao final, você estará criando contêineres personalizados para seus projetos e se perguntará como conseguiu viver sem isso.

Vamos mergulhar e ver como Dev Containers podem simplificar seu fluxo de trabalho e tornar você um(a) desenvolvedor(a) mais feliz e produtivo(a).

TL;DR

Dev Containers são ambientes isolados e leves que fornecem um ambiente de desenvolvimento pré‑configurado dentro do seu editor ou IDE. Eles economizam tempo ao eliminar a necessidade de configuração manual e garantem um ambiente limpo sempre. Benefícios incluem: ambientes de build pré‑configurados, isolamento, builds reprodutíveis, menos tempo de setup e flexibilidade para escolher imagens base.

O que são Dev Containers?

Dev Containers são ambientes isolados e leves que permitem trabalhar dentro de uma versão containerizada do ambiente de build. Basicamente, eles oferecem um ambiente de desenvolvimento pré‑configurado diretamente no seu editor ou IDE.

Os dev Containers podem economizar um bom tempo de configuração e garantir um ambiente limpo toda vez que você começar a trabalhar.

Exemplo de configuração de Dev Container no VS Code

Principais benefícios

Ambientes de build pré‑configurados. Vêm com uma imagem base contendo software, ferramentas e dependências já instaladas para você começar a programar imediatamente.
Ambientes isolados. Cada Dev Container tem seu próprio filesystem, rede, memória e CPU, evitando conflitos com outros projetos ou softwares da sua máquina.
Builds reprodutíveis. Fornecem o mesmo ambiente toda vez que são iniciados, garantindo resultados consistentes. Chega de “funciona na minha máquina!”.
Menos tempo de setup. Em um novo projeto, você pula o setup demorado. Abra o projeto no contêiner e pronto.
Flexibilidade. Você pode escolher uma imagem base com as ferramentas que precisa ou criar sua própria imagem base.

Resumo: Dev Containers revolucionam a experiência de desenvolvimento ao fornecer ambientes pré‑configurados e isolados que turbinam sua produtividade. Se você ainda não testou, vale muito a pena. Eles podem mudar sua forma de trabalhar. O futuro é containerizado!

Começando com Dev Containers

Para começar, você vai precisar de:

Um editor que suporte Dev Containers
Atualmente funcionam com Visual Studio Code e IDEs da JetBrains (como WebStorm). Neste guia, focaremos no VS Code.
Docker Desktop instalado
Dev Containers usam o Docker para construir e rodar contêineres. Instale e deixe o Docker Desktop rodando no seu sistema operacional.
Um arquivo devcontainer.json
Esse arquivo define o ambiente do contêiner e especifica, por exemplo:
- A imagem Docker (ex.: node:18-alpine)
- Pastas a montar no contêiner
- Variáveis de ambiente
- Scripts pós‑criação (postCreateCommand)

O VS Code tem snippets para te ajudar a gerar um devcontainer.json para stacks populares.

Exemplo passo a passo

Crie uma nova pasta de projeto:

mkdir my-dev-container-project
cd my-dev-container-project

Abra no VS Code:

code .

Adicione a pasta .devcontainer com um devcontainer.json:

mkdir .devcontainer
touch .devcontainer/devcontainer.json

Edite o devcontainer.json:

{
    "name": "Node.js Sample",
    "dockerFile": "Dockerfile",
    "settings": {
        "terminal.integrated.shell.linux": "/bin/bash"
    },
    "extensions": ["dbaeumer.vscode-eslint"],
    "postCreateCommand": "npm install",
    "remoteUser": "node"
}

Adicione um Dockerfile dentro de .devcontainer:

FROM node:18-alpine

Construa e rode o contêiner:
Pressione F1 e selecione “Remote‑Containers: Reopen in Container” para construir a imagem e reabrir a pasta dentro do contêiner. O VS Code vai construir a imagem, instalar dependências e iniciar o contêiner. A janela recarrega e você passa a trabalhar diretamente no contêiner, com tudo pronto!

Se precisar recriar do zero, use “Remote‑Containers: Rebuild and Reopen in Container”.

Escolhendo a imagem base

A imagem base contém o sistema operacional Linux e ferramentas iniciais sobre as quais seu contêiner será construído.

Imagens específicas por linguagem

Se o foco é uma linguagem (Python, JavaScript, Go etc.), comece por uma imagem voltada a ela:

python — inclui Python, Pip e básicos.
node — para projetos Node.js, com Node e NPM (ou PNPM/Yarn conforme a imagem).
golang — inclui compilador Go, ferramentas de build e libs comuns.

Imagens de uso geral

Se quer flexibilidade, use:

Ubuntu — popular, footprint reduzido, fácil instalar qualquer coisa.
Debian — estável e confiável.
Alpine — minúscula (~5 MB), ótima para contêineres enxutos.

Dicas para escolher:

Tenha o mínimo necessário para começar.
Prefira imagens leves para builds e carregamentos rápidos.
Verifique manutenção ativa (segurança/updates).

Adicionando ferramentas e runtimes

Há várias formas de incluir ferramentas/runtimes:

1) Instalar no build da imagem

Bom quando você já sabe tudo que precisa.

# Dockerfile
FROM node:20

# Ex.: instala Python
RUN apt-get update && apt-get install -y python3 python3-pip

2) Instalar na inicialização do contêiner

Útil para instalar em runtime ou variar conforme o projeto.

{
    "name": "Node.js Sample",
    "image": "mcr.microsoft.com/vscode/devcontainers/javascript-node:0-20",
    "postCreateCommand": "npm install && pip install requests"
}

3) Usar build args no `devcontainer.json`

Construa uma vez e inicie com variações via argumentos.

# Dockerfile
ARG PYTHON_VERSION=3.11
FROM python:${PYTHON_VERSION}

RUN apt-get update && apt-get install -y curl

{
    "name": "Python Sample",
    "build": {
        "dockerfile": "Dockerfile",
        "args": {
            "PYTHON_VERSION": "3.12"
        }
    }
}

4) Múltiplos builds para stacks diferentes

Defina várias opções no devcontainer.json e escolha ao iniciar.

5) Base comum no Dockerfile + extras no `postCreateCommand`

Base comum + ferramentas específicas por projeto.

6) Docker Compose para “sidecars”

Suba serviços auxiliares (DB, cache) junto com seu Dev Container.

version: '3'
services:
    dev:
        build: .
        volumes:
            - .:/workspace
        command: npm start
    db:
        image: postgres
        environment:
            POSTGRES_PASSWORD: example

Montando o código‑fonte

Para desenvolver no contêiner editando no host, monte seu código como volume.

Bind mounts (simples)

Espelham uma pasta do host no contêiner.

docker run -v /caminho/no/host:/caminho/no/container ...
# Exemplo
docker run -v /home/user/code:/app ...

Drivers de volume (avançado)

Ajudam com permissões/performance:

local (padrão)
CIFS (shares do Windows)
NFS (shares *nix)
OverlayFS (melhor performance)

Formato geral:

docker run -v <driver>:/caminho/host:/caminho/container ...

Definindo entrypoints

Entrypoints especificam o que rodar ao iniciar o contêiner: instalar deps, preparar código, subir servidores etc.

Opções:

ENTRYPOINT no Dockerfile — simples; menos flexível para sobrescrever.
entrypoint no docker-compose.yml — flexível para trocar em runtime.
Shell script — ótimo para lógica condicional; aceite argumentos.
Rebuild com outro ENTRYPOINT — funciona, mas exige reconstrução.

Um bom entrypoint deve:

Instalar dependências (ex.: npm install, apt-get install).
Preparar o código (migrações, build de assets).
Iniciar servidores necessários (ex.: npm start).
Rodar em foreground e encaminhar sinais (Ctrl+C para parar).

Casos de uso

Ambientes locais de desenvolvimento (ex.: Python)

{
    "name": "Python Dev Container",
    "dockerFile": "Dockerfile",
    "settings": {
        "python.pythonPath": "/usr/local/bin/python3"
    },
    "extensions": ["ms-python.python"],
    "postCreateCommand": "pip install -r requirements.txt"
}

FROM python:3.8-slim

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

Onboarding de novos membros (Node.js)

{
    "name": "Node.js Dev Container",
    "image": "mcr.microsoft.com/vscode/devcontainers/javascript-node:0-20",
    "postCreateCommand": "npm install"
}

Ambientes isolados para testar versões (Node)

FROM node:20
RUN npm install -g some-library@beta

Setups reprodutíveis para times e CI

{
    "name": "Consistent Dev Environment",
    "dockerFile": "Dockerfile",
    "settings": { "editor.formatOnSave": true },
    "extensions": ["dbaeumer.vscode-eslint", "esbenp.prettier-vscode"],
    "postCreateCommand": "npm install"
}

FROM node:20-alpine
RUN npm install -g eslint prettier

Experimentos de tooling (Go)

{
    "name": "Go Dev Container",
    "image": "golang:latest",
    "postCreateCommand": "go mod tidy"
}

CI/CD com ambiente idêntico ao local

# .github/workflows/ci.yml
name: CI

on: [push, pull_request]

jobs:
    build:
        runs-on: ubuntu-latest
        container:
            image: ghcr.io/owner/repo:devcontainer
        steps:
            - uses: actions/checkout@v2
            - name: Set up Node.js
              uses: actions/setup-node@v2
              with:
                  node-version: '20'
            - run: npm install
            - run: npm test

FAQs — Perguntas frequentes

Preciso ter Docker instalado?
Sim. Dev Containers usam tecnologia de contêineres do Docker. Instale o Docker CE (ou superior).

Dev Containers substituem meu ambiente local?
Não. Eles rodam dentro do seu ambiente local e das suas ferramentas. Apenas encapsulam runtimes e dependências do projeto.

Posso dar commit/push dentro do Dev Container?
Sim. O código é montado do host para o contêiner. Você pode usar Git normalmente.

Preciso de internet para usar Dev Containers?
Na primeira build, sim (para baixar dependências). Depois, não necessariamente — a menos que seu projeto precise instalar pacotes online.

São multiplataforma?
Sim. Funcionam em Windows, macOS e Linux. A experiência varia um pouco, mas o resultado final é o mesmo.

Posso usar qualquer editor/IDE?
Funciona com editores que suportam Remote – Containers (ex.: VS Code). JetBrains também oferece suporte em IDEs como WebStorm.

Como criar um devcontainer.json?
Manual ou com snippets do VS Code. Nele você define imagem Docker, mounts, envs e scripts pós‑criação.

Como escolher imagem base?
Combine com sua stack (ex.: node, python) ou use Ubuntu/Debian/Alpine para flexibilidade.

Como adicionar ferramentas/runtimes?

Via Dockerfile (RUN ...)
Via postCreateCommand no devcontainer.json
Via build args
Com múltiplos Dockerfiles configuráveis
Com Docker Compose para sidecars

Como montar o código no contêiner?
Use bind mounts (-v host:container) ou defina mounts no devcontainer.json.

Como depurar dentro do contêiner?
Configure no devcontainer.json (seção customizations) e use o painel de debug do editor.

Como compartilhar setup com o time?
Comite devcontainer.json e Dockerfile no repositório, publique uma imagem em registry ou use Docker Compose para setups multi‑serviço.

Meu contêiner não inicia. E agora?
Veja os logs com docker logs <container-id>, confira configs e dependências.

Performance lenta?
Garanta CPU/Mem suficientes, reduza I/O de disco e avalie armazenamento mais rápido.

Problemas de rede?
Cheque conflitos de porta e, se necessário, configure DNS customizado (--dns) no docker run.

Conflitos de dependência?
Garanta versões compatíveis e especifique versões exatas no gerenciador de pacotes.

Boas práticas

Mantenha leve. Menos coisas = imagens menores e startups mais rápidos. Instale só o necessário.
Use multi‑stage builds. Separe ambiente de dev do artefato final.
Cache de dependências. Aproveite o cache do Docker para acelerar builds (ex.: diretórios de cache de pacotes).
Trate contêineres como efêmeros. Nada crítico deve ficar dentro do contêiner. Commit no host/volume.
Use Docker Compose. Suba todo o stack (DB, cache, app) com um comando.
Bind na rede do host quando fizer sentido, para acessar serviços locais com facilidade.
Mantenha imagens atualizadas. Rebuild periódico puxa updates de segurança/bugfixes.

Conclusão

Pronto: tudo o que você precisa saber sobre Dev Containers para facilitar sua vida como dev. Com o poder do Docker e do VS Code, você tem um ambiente de desenvolvimento portável e isolado, capaz de reproduzir sua produção localmente. Nada de “funciona na minha máquina”.

Você vai programar com mais confiança e entregar software melhor, mais rápido.
O que está esperando? Suba um Dev Container, instale suas dependências e mãos à obra. Seu eu do futuro agradece.

Bom código!