Gerador de Dockerfile

O que é Gerador de Dockerfile?

Crie um Dockerfile que segue as boas práticas atuais para Node.js, Python, Go, Java (Maven), .NET (ASP.NET Core), Rust ou um site estático servido pelo Nginx. As opções incluem builds multiestágio para imagens menores, execução com usuário não root, versão do runtime, porta e comando de inicialização, e a ferramenta também gera um .dockerignore correspondente.

Como usar Gerador de Dockerfile

1. Escolha a Linguagem / stack.
2. Defina a Versão do runtime (tag da imagem), a Porta e o nome do arquivo inicial, módulo, JAR ou binário.
3. Mantenha marcados Build multiestágio e Executar com usuário não root, a menos que tenha um motivo para não fazer isso.
4. Baixe o Dockerfile e o .dockerignore para a raiz do projeto e execute docker build -t myapp ..

Exemplo

Node.js 22, port 3000, start file dist/index.js, multi-stage, non-root, npm run build

# syntax=docker/dockerfile:1

# ---- dependencies (production only) ----
FROM node:22-alpine AS deps
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci --omit=dev

# ---- build ----
FROM node:22-alpine AS build
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci
COPY . .
RUN npm run build

# ---- runtime ----
FROM node:22-alpine
ENV NODE_ENV=production
WORKDIR /app
COPY --from=deps --chown=node:node /app/node_modules ./node_modules
COPY --from=build --chown=node:node /app/dist ./dist
COPY --chown=node:node package.json ./
# The official Node images ship an unprivileged "node" user
USER node
EXPOSE 3000
CMD ["node", "dist/index.js"]

Quando usar Gerador de Dockerfile

Use-o para colocar em contêiner rapidamente um serviço web ou API típico, com padrões sensatos. Revise o arquivo gerado para o seu projeto: comandos de build, pastas de saída e pontos de entrada variam, e dependências nativas podem exigir pacotes de sistema extras. Fixe versões exatas ou digests das imagens para builds de produção reproduzíveis.

Como funciona Gerador de Dockerfile

Cada stack tem um modelo escrito para as suas imagens oficiais. Os builds multiestágio instalam e compilam em uma imagem SDK completa e copiam só o resultado para um runtime enxuto: o Node instala as dependências de produção com npm ci --omit=dev em um estágio separado; o Python monta um virtualenv e o copia para python:<ver>-slim; o Go compila um binário estático (CGO_ENABLED=0, -trimpath -ldflags="-s -w") em distroless/static:nonroot; o Java copia o JAR para uma imagem Temurin só com JRE; o .NET publica na imagem de runtime aspnet e usa o usuário embutido $APP_UID; o Rust copia o binário de release para debian:bookworm-slim. O modo não root usa o usuário sem privilégios da própria imagem (node, nonroot, app) ou cria um com UID 10001. Os manifestos de dependências são copiados antes do código-fonte para que o cache de camadas do Docker pule a reinstalação quando só o código muda.

Casos de Uso Comuns

• ✓ Colocar em contêiner uma API Node.js ou Python para implantação
• ✓ Reduzir a imagem de um serviço Go com um runtime distroless
• ✓ Servir um build React/Vue/Astro com Nginx sem root
• ✓ Ensinar ou revisar boas práticas de Dockerfile

Perguntas Frequentes

Explore mais categorias