0Pricing
React Academy · Lekcja

Konteneryzacja aplikacji React/Next.js

Pisanie wieloetapowego Dockerfile dla aplikacji Next.js i uruchamianie jej lokalnie za pomocą Docker Compose.

Konteneryzacja aplikacji React/Next.js to bezpłatna lekcja React Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej React Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs React Academy zawiera 4 lekcji w sumie.

Dlaczego Docker?

Kontenery Docker pakują aplikację wraz z jej zależnościami, zapewniając spójne działanie w środowiskach deweloperskim, stagingowym i produkcyjnym. Ten sam obraz działa wszędzie.

Dockerfile dla prostej aplikacji React SPA

Wieloetapowe budowanie: Node.js służy do budowania, a Nginx do serwowania statycznych plików wynikowych.

# 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;"]

Konfiguracja Nginx dla routingu SPA

Należy skonfigurować Nginx tak, aby serwował index.html dla wszystkich ścieżek (obsługa routingu po stronie klienta).

# 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 dla trybu standalone Next.js

Next.js 12+ obsługuje output: 'standalone', które kopiuje tylko wymagane pliki, tworząc minimalny obraz produkcyjny.

// 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

Należy wykluczyć niepotrzebne pliki z kontekstu budowania Dockera, aby przyspieszyć budowanie i zmniejszyć rozmiar obrazu.

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

Budowanie i uruchamianie

Należy zbudować obraz i uruchomić go lokalnie.

# 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 podczas lokalnego developmentu

Należy użyć Docker Compose, aby uruchomić aplikację wraz z jej zależnościami (bazą danych i Redisem) za pomocą jednego polecenia.

# 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:

Sprawdzanie stanu

Należy dodać sprawdzanie stanu do Dockerfile, aby narzędzia orkiestrujące wiedziały, kiedy kontener jest gotowy.

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

Zmienne środowiskowe w czasie działania

Zmienne środowiskowe należy przekazywać podczas wykonywania docker run lub za pomocą --env-file. Sekretów nigdy nie należy umieszczać w obrazie.

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

Budowanie dla wielu platform

Za pomocą Docker Buildx należy budować obrazy dla wielu architektur procesora (ARM64 dla komputerów Mac z układem M1 i maszyn wirtualnych w chmurze oraz AMD64 dla większości serwerów).

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

Szybkie sprawdzenie

Jaka jest korzyść ze stosowania wieloetapowego budowania obrazów Dockera w aplikacji React/Next.js?

Podsumowanie

Należy używać wieloetapowych plików Dockerfile: Node.js do budowania, a Nginx lub node:alpine do serwowania. W konfiguracji Next.js należy dodać output: 'standalone', aby tworzyć minimalne obrazy. Do lokalnego developmentu należy używać Docker Compose, przekazywać sekrety w czasie działania za pomocą zmiennych środowiskowych oraz budować obrazy dla wielu platform za pomocą Buildx, aby zapewnić zgodność z ARM i AMD64.

Często zadawane pytania

Czy lekcja „Konteneryzacja aplikacji React/Next.js” jest bezpłatna?

Tak — pełny tekst „Konteneryzacja aplikacji React/Next.js” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu React Academy, przejdź na CoddyKit PRO. Kurs React Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Konteneryzacja aplikacji React/Next.js”?

Pisanie wieloetapowego Dockerfile dla aplikacji Next.js i uruchamianie jej lokalnie za pomocą Docker Compose. Ćwiczysz React Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć React Academy?

Nie wymagamy żadnego doświadczenia. React Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Konteneryzacja aplikacji React/Next.js”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji React Academy?

Tak. Każda lekcja React Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Wdrażanie na Vercel: zero konfiguracji i adresy podglądu
  2. Hosting React SPA w AWS S3 i CloudFront
  3. Konteneryzacja aplikacji React/Next.js
  4. CI/CD React z GitHub Actions
← Powrót do React Academy