0Pricing
React Academy · Aula

Colocando um aplicativo React/Next.js em contêineres

Escreva um Dockerfile em várias etapas para um aplicativo Next.js e execute-o localmente com Docker Compose.

Colocando um aplicativo React/Next.js em contêineres é uma aula grátis de React Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de React Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de React Academy inclui 4 aulas no total.

Por que usar o Docker?

Os contêineres Docker empacotam seu aplicativo e suas dependências juntos, garantindo um comportamento consistente nos ambientes de desenvolvimento, preparação e produção. A mesma imagem é executada em todos os lugares.

Dockerfile para uma SPA React simples

Uma compilação em duas etapas: Node.js para compilar e Nginx para servir a saída estática.

# Stage 1: Build
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Stage 2: Serve with Nginx
FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html
COPY nginx.conf /etc/nginx/conf.d/default.conf
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Configuração do Nginx para roteamento de SPA

Configure o Nginx para servir index.html em todas as rotas (suporte ao roteamento no cliente).

# nginx.conf
server {
  listen 80;
  root /usr/share/nginx/html;
  index index.html;

  location / {
    try_files $uri $uri/ /index.html; # SPA routing
  }

  location ~* \.(js|css|png|jpg|woff2)$ {
    expires 1y;
    add_header Cache-Control "public, immutable";
  }
}

Dockerfile do modo independente do Next.js

O Next.js 12+ oferece suporte a output: 'standalone', que copia apenas os arquivos necessários para uma imagem de produção mínima.

// next.config.js
module.exports = { output: 'standalone' };

# Dockerfile (Next.js standalone)
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:20-alpine AS runner
WORKDIR /app
ENV NODE_ENV=production
COPY --from=builder /app/.next/standalone ./
COPY --from=builder /app/.next/static ./.next/static
COPY --from=builder /app/public ./public
EXPOSE 3000
CMD ["node", "server.js"]

.dockerignore

Exclua arquivos desnecessários do contexto de compilação do Docker para acelerar as compilações e reduzir o tamanho da imagem.

node_modules
.next
dist
.env*
.git
README.md
*.test.ts

Compilação e execução

Compile a imagem e execute-a localmente.

# Build:
docker build -t my-next-app .

# Run:
docker run -p 3000:3000 -e DATABASE_URL=postgres://... my-next-app

# Check size:
docker images my-next-app

Docker Compose para desenvolvimento local

Use o Docker Compose para executar o aplicativo com suas dependências (banco de dados, Redis) usando um único comando.

# docker-compose.yml
services:
  web:
    build: .
    ports: ['3000:3000']
    environment:
      DATABASE_URL: postgresql://postgres:password@db:5432/myapp
    depends_on: [db]
  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_PASSWORD: password
      POSTGRES_DB: myapp
    volumes:
      - pgdata:/var/lib/postgresql/data
volumes:
  pgdata:

Verificações de integridade

Adicione uma verificação de integridade ao Dockerfile para que os orquestradores saibam quando o contêiner está pronto.

HEALTHCHECK --interval=30s --timeout=3s \
  CMD curl -f http://localhost:3000/api/health || exit 1

Variáveis de ambiente em tempo de execução

Passe as variáveis de ambiente no momento de executar docker run ou por meio de --env-file. Nunca inclua segredos na imagem.

docker run -p 3000:3000 \
  --env-file .env.production \
  my-next-app

Compilações multiplataforma

Compile imagens para várias arquiteturas de CPU (ARM64 para Macs M1 e máquinas virtuais na nuvem, AMD64 para a maioria dos servidores) com o Docker Buildx.

docker buildx build \
  --platform linux/amd64,linux/arm64 \
  -t myregistry/my-next-app:latest \
  --push .

Verificação rápida

Qual é o benefício de usar compilações Docker em várias etapas para um aplicativo React/Next.js?

Recapitulação

Use Dockerfiles em várias etapas: Node.js para compilar e Nginx ou node:alpine para servir. Adicione output: 'standalone' à configuração do Next.js para obter imagens mínimas. Use o Docker Compose no desenvolvimento local, passe os segredos em tempo de execução por meio de variáveis de ambiente e compile imagens multiplataforma com o Buildx para garantir compatibilidade com ARM e AMD64.

Perguntas Frequentes

A aula “Colocando um aplicativo React/Next.js em contêineres” é grátis?

Sim — o texto completo de “Colocando um aplicativo React/Next.js em contêineres” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de React Academy, atualize para CoddyKit PRO. O curso de React Academy inclui 4 aulas no total.

O que vou aprender em “Colocando um aplicativo React/Next.js em contêineres”?

Escreva um Dockerfile em várias etapas para um aplicativo Next.js e execute-o localmente com Docker Compose. Você pratica React Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar React Academy?

Nenhuma experiência prévia é necessária. React Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Colocando um aplicativo React/Next.js em contêineres”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de React Academy?

Sim. Cada aula de React Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Implantando na Vercel: configuração zero e URLs de pré-visualização
  2. Hospedando uma SPA React no AWS S3 e CloudFront
  3. Colocando um aplicativo React/Next.js em contêineres
  4. CI/CD do GitHub Actions para React
← Voltar para React Academy