TL;DR
Docker konteneryzuje aplikacje, zapewniając spójne środowiska od development do produkcji. Ułatwia deployment, skalowanie i zarządzanie infrastrukturą. Oto jak używać Docker w 2026.
Dla kogo to jest
- Deweloperów chcących ustandaryzować środowiska
- DevOps engineerów zarządzających infrastrukturą
- Firm planujących skalowanie aplikacji
Fraza (SEO)
docker, konteneryzacja, docker compose, kubernetes, container deployment
Czym jest Docker?
Docker to platforma do konteneryzacji:
- Izolowane środowiska (containers)
- Spójność między środowiskami
- Lekkie (vs virtual machines)
- Szybkie uruchamianie
Kontener vs VM:
- VM: pełny OS, wolniejsze, więcej zasobów
- Kontener: współdzielony OS, szybsze, mniej zasobów
Korzyści:
- "Działa na moim komputerze" → rozwiązane
- Szybsze deploymenty
- Łatwiejsze skalowanie
- Lepsze wykorzystanie zasobów
Podstawy Docker
Dockerfile
Podstawowy przykład:
# Base image
FROM node:18-alpine
# Working directory
WORKDIR /app
# Copy package files
COPY package*.json ./
# Install dependencies
RUN npm ci --only=production
# Copy application code
COPY . .
# Expose port
EXPOSE 3000
# Start application
CMD ["npm", "start"]
Build i run
Build image:
docker build -t my-app:latest .
Run container:
docker run -p 3000:3000 my-app:latest
Run w tle:
docker run -d -p 3000:3000 --name my-app my-app:latest
Best Practices Dockerfile
1. Multi-stage builds
Zmniejsz rozmiar image:
# Stage 1: Build
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build
# Stage 2: Production
FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY --from=builder /app/dist ./dist
EXPOSE 3000
CMD ["node", "dist/index.js"]
2. Layer caching
Optymalna kolejność:
# 1. Zależności (rzadko się zmieniają)
COPY package*.json ./
RUN npm ci
# 2. Kod aplikacji (często się zmienia)
COPY . .
3. Używaj .dockerignore
.dockerignore:
node_modules
npm-debug.log
.git
.env
dist
*.md
4. Minimalne base images
Alpine Linux:
FROM node:18-alpine # ~5MB vs ~150MB dla node:18
Distroless (jeszcze mniejsze):
FROM gcr.io/distroless/nodejs18-debian11
5. Non-root user
Bezpieczeństwo:
RUN addgroup -g 1001 -S nodejs
RUN adduser -S nextjs -u 1001
USER nextjs
Docker Compose
Podstawowa konfiguracja
docker-compose.yml:
version: '3.8'
services:
app:
build: .
ports:
- "3000:3000"
environment:
- NODE_ENV=production
- DATABASE_URL=postgresql://user:pass@db:5432/mydb
depends_on:
- db
- redis
db:
image: postgres:15-alpine
environment:
- POSTGRES_USER=user
- POSTGRES_PASSWORD=pass
- POSTGRES_DB=mydb
volumes:
- postgres_data:/var/lib/postgresql/data
redis:
image: redis:7-alpine
ports:
- "6379:6379"
volumes:
postgres_data:
Uruchamianie
Start wszystkich serwisów:
docker-compose up -d
Logi:
docker-compose logs -f app
Stop:
docker-compose down
Kubernetes
Podstawowe koncepty
Pod:
- Najmniejsza jednostka
- Jeden lub więcej kontenerów
- Wspólne zasoby (network, storage)
Deployment:
- Zarządza replikami Pod
- Rolling updates
- Rollback
Service:
- Expose Pods jako sieć
- Load balancing
- Service discovery
Podstawowy Deployment
deployment.yaml:
apiVersion: apps/v1
kind: Deployment
metadata:
name: my-app
spec:
replicas: 3
selector:
matchLabels:
app: my-app
template:
metadata:
labels:
app: my-app
spec:
containers:
- name: app
image: my-app:latest
ports:
- containerPort: 3000
env:
- name: NODE_ENV
value: "production"
resources:
requests:
memory: "256Mi"
cpu: "250m"
limits:
memory: "512Mi"
cpu: "500m"
Service:
apiVersion: v1
kind: Service
metadata:
name: my-app-service
spec:
selector:
app: my-app
ports:
- protocol: TCP
port: 80
targetPort: 3000
type: LoadBalancer
Apply:
kubectl apply -f deployment.yaml
kubectl apply -f service.yaml
Skalowanie
Horizontal Pod Autoscaler (HPA)
Automatyczne skalowanie:
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
name: my-app-hpa
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: my-app
minReplicas: 2
maxReplicas: 10
metrics:
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 70
Manual scaling
kubectl scale deployment my-app --replicas=5
Monitoring i logging
Health checks
W Dockerfile:
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
CMD curl -f http://localhost:3000/health || exit 1
W Kubernetes:
livenessProbe:
httpGet:
path: /health
port: 3000
initialDelaySeconds: 30
periodSeconds: 10
readinessProbe:
httpGet:
path: /ready
port: 3000
initialDelaySeconds: 5
periodSeconds: 5
Logging
Docker logs:
docker logs my-app
docker logs -f my-app # Follow
Kubernetes logs:
kubectl logs deployment/my-app
kubectl logs -f deployment/my-app
Security best practices
1. Scan images
docker scan my-app:latest
2. Minimalne uprawnienia
USER nonroot
3. Secrets management
Nie w Dockerfile:
# ❌ Złe
ENV API_KEY=secret123
Używaj secrets:
# Kubernetes
apiVersion: v1
kind: Secret
metadata:
name: api-secret
data:
api-key: <base64-encoded>
4. Regular updates
Aktualizuj base images:
FROM node:18-alpine # Używaj najnowszej wersji
CI/CD z Docker
GitHub Actions przykład:
- name: Build Docker image
run: docker build -t my-app:${{ github.sha }} .
- name: Push to registry
run: |
docker tag my-app:${{ github.sha }} my-registry/my-app:latest
docker push my-registry/my-app:latest
- name: Deploy to Kubernetes
run: |
kubectl set image deployment/my-app app=my-registry/my-app:latest
FAQ
Czy Docker jest potrzebny dla małych projektów?
Nie zawsze, ale warto. Ułatwia deployment, zapewnia spójność środowisk i przygotowuje do skalowania.
Docker vs Kubernetes?
Docker: konteneryzacja aplikacji. Kubernetes: orkiestracja kontenerów (dla większych systemów).
Jak często aktualizować base images?
Regularnie (co miesiąc). Używaj narzędzi jak Dependabot do automatycznych aktualizacji.