Docker ileri seviye kullanımı modern DevOps pratikleri ile CI/CD pipeline entegrasyonunu gerektirir. GitLab CI/CD ve GitHub Actions ile Docker ileri seviye deployment’ları gerçekleştirebilirsiniz.
Docker ileri seviye kullanımı için güvenlik en önemli konulardan biridir. Production ortamlarında Docker security best practice’lerini uygulamak şarttır.
Enterprise Docker deployment için kendi private registry’nizi kurmak büyük avantajlar sağlar. Docker Hub gibi public registry’ler yerine, güvenlik ve kontrol açısından private registry tercih edilmelidir.
Docker İleri Seviye Kullanımı: Production ve Enterprise Rehberi
Docker ileri seviye kullanımı öğrenmek isteyen geliştiriciler için bu rehber tam size göre! Docker temel kullanımı makalesinden sonra, artık daha karmaşık senaryolar ve advanced özellikler ile karşılaşma zamanı geldi. Bu kapsamlı rehberde Docker Swarm, container orchestration, production optimizasyonları ve enterprise-level deployment stratejilerini detaylı olarak ele alacağız.
Docker Swarm ile Advanced Container Orchestration
Docker Swarm, advanced container orchestration için en önemli araçlardan biridir. Docker’ın kendi container orchestration çözümü olan Swarm, Kubernetes‘e alternatif olarak, özellikle küçük ve orta ölçekli projeler için daha basit ve anlaşılır bir yaklaşım sunar.
Swarm Cluster Kurulum Rehberi
Advanced Docker kullanımı için Swarm cluster’ı başlatmak öncelikle bir manager node oluşturmalıyız. Manager node, cluster’ın beynini oluşturur ve tüm orchestration işlemlerini yönetir.
# Manager node'u başlat
docker swarm init --advertise-addr <MANAGER-IP>
# Worker node'ları cluster'a ekle (manager node çıktısından alınan token ile)
docker swarm join --token <TOKEN> <MANAGER-IP>:2377
# Cluster durumunu kontrol et
docker node ls
docker swarm ca --cert # Swarm sertifikasını görüntüle
Professional Service Yönetimi
Professional Docker deployment bağlamında, Swarm mode’da uygulamalar “service” olarak çalıştırılır. Service’ler, container’ların desired state’ini tanımlar ve cluster genelinde yönetimini sağlar. Bu Docker service yaklaşımı production ortamları için kritik öneme sahiptir.
# Service oluştur ve replika sayısını belirle
docker service create --name web-service --replicas 3 -p 8080:80 nginx:alpine
# Service'leri listele
docker service ls
# Service detaylarını görüntüle
docker service inspect web-service
# Service'i ölçeklendir (scale up/down)
docker service scale web-service=5
# Service'i güncelle (rolling update)
docker service update --image nginx:latest web-service
# Service'i sil
docker service rm web-service
Stack ile Multi-Service Deployment
Stack’ler, Docker Compose formatında tanımlanan multi-service uygulamaları Swarm cluster’ında çalıştırmamızı sağlar. Bu, karmaşık uygulamaları tek komutla deploy etmek için idealdir.
version: '3.8'
services:
web:
image: nginx:alpine
ports:
- "8080:80"
deploy:
replicas: 3
placement:
constraints:
- node.role == worker
resources:
limits:
memory: 128M
reservations:
memory: 64M
restart_policy:
condition: on-failure
delay: 5s
max_attempts: 3
networks:
- frontend
api:
image: node:18-alpine
deploy:
replicas: 2
placement:
constraints:
- node.labels.type == api-server
environment:
- NODE_ENV=production
- DATABASE_URL=postgresql://user:pass@db:5432/myapp
networks:
- frontend
- backend
database:
image: postgres:15-alpine
deploy:
replicas: 1
placement:
constraints:
- node.role == manager
environment:
POSTGRES_DB: myapp
POSTGRES_USER: user
POSTGRES_PASSWORD_FILE: /run/secrets/db_password
secrets:
- db_password
volumes:
- db_data:/var/lib/postgresql/data
networks:
- backend
networks:
frontend:
driver: overlay
backend:
driver: overlay
volumes:
db_data:
driver: local
secrets:
db_password:
external: true
Bu stack dosyasını deploy etmek için:
# Secret oluştur
echo "supersecretpassword" | docker secret create db_password -
# Stack'i deploy et
docker stack deploy -c docker-stack.yml myapp
# Stack durumunu kontrol et
docker stack ls
docker stack services myapp
docker stack ps myapp
# Stack'i kaldır
docker stack rm myapp
Advanced Secrets ve Config Yönetimi
Professional Docker deployment için production ortamlarında hassas bilgilerin güvenli yönetimi kritik önem taşır. Bu durumda Docker secrets ve configs mekanizmalarını etkin kullanmak gerekir.
Secret Yönetimi
# Dosyadan secret oluştur
docker secret create ssl_certificate ./ssl/cert.pem
# Stdin'den secret oluştur
echo "db_password_here" | docker secret create database_password -
# Secret'ları listele
docker secret ls
# Secret detaylarını görüntüle (değer görünmez)
docker secret inspect database_password
# Service'de secret kullan
docker service create \
--name web-app \
--secret database_password \
--env DATABASE_PASSWORD_FILE=/run/secrets/database_password \
my-web-app:latest
Config Yönetimi
# Config dosyası oluştur
docker config create nginx_config ./nginx.conf
# Config'leri listele
docker config ls
# Service'de config kullan
docker service create \
--name web-server \
--config source=nginx_config,target=/etc/nginx/nginx.conf \
nginx:alpine
Professional Multi-Stage Build Optimizasyonları
Advanced Docker deployment kapsamında, Multi-stage build’ler Docker imajlarını optimize etmek için en güçlü yöntemlerden biridir. Bu teknik sayesinde production-ready, minimal boyutlu imajlar elde edebilirsiniz. Temel Docker rehberimizde basit multi-stage build gördük, şimdi daha karmaşık bir örneği inceleyelim:
# Build stage
FROM node:18-alpine AS dependencies
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production && npm cache clean --force
# Development dependencies stage
FROM node:18-alpine AS dev-dependencies
WORKDIR /app
COPY package*.json ./
RUN npm ci
# Build stage
FROM dev-dependencies AS build
COPY . .
RUN npm run build && npm run test
# Security scanning stage
FROM build AS security-scan
RUN npm audit --audit-level high
# Production stage
FROM node:18-alpine AS production
RUN addgroup -g 1001 -S nodejs && adduser -S nextjs -u 1001
WORKDIR /app
# Copy production dependencies
COPY --from=dependencies /app/node_modules ./node_modules
COPY --from=build /app/dist ./dist
COPY --from=build /app/public ./public
USER nextjs
EXPOSE 3000
CMD ["node", "dist/server.js"]
Build Cache Optimizasyonu
Docker build cache’ini etkili kullanmak, build sürelerini dramatik olarak azaltabilir:
# BuildKit ile paralel build
DOCKER_BUILDKIT=1 docker build -t my-app .
# Build cache mount kullanımı
FROM node:18-alpine AS build
WORKDIR /app
COPY package*.json ./
RUN --mount=type=cache,target=/root/.npm \
npm ci --only=production
# Multi-platform build
docker buildx build --platform linux/amd64,linux/arm64 -t my-app:latest .
Professional Container Registry ve Image Yönetimi
Private Registry Kurulumu
# Private registry başlat
docker run -d \
-p 5000:5000 \
--restart=always \
--name registry \
-v /opt/registry:/var/lib/registry \
registry:2
# SSL ile güvenli registry
docker run -d \
-p 5000:5000 \
--restart=always \
--name secure-registry \
-v /opt/registry:/var/lib/registry \
-v /opt/certs:/certs \
-e REGISTRY_HTTP_TLS_CERTIFICATE=/certs/domain.crt \
-e REGISTRY_HTTP_TLS_KEY=/certs/domain.key \
registry:2
Image Tagging Stratejileri
# Semantic versioning
docker tag my-app:latest my-app:1.2.3
docker tag my-app:latest my-app:1.2
docker tag my-app:latest my-app:1
# Environment-based tagging
docker tag my-app:latest my-app:staging
docker tag my-app:latest my-app:production
# Git commit hash tagging
GIT_HASH=$(git rev-parse --short HEAD)
docker tag my-app:latest my-app:$GIT_HASH
Docker İleri Seviye Production Monitoring ve Logging
Centralized Logging
Docker ileri seviye kullanımı kapsamında production ortamında log yönetimi kritik önem taşır. Elastic Stack (ELK Stack: Elasticsearch, Logstash, Kibana) ile centralized logging kurulumu Docker ileri seviye kullanımı için şarttır:
version: '3.8'
services:
elasticsearch:
image: docker.elastic.co/elasticsearch/elasticsearch:8.8.0
environment:
- discovery.type=single-node
- "ES_JAVA_OPTS=-Xms512m -Xmx512m"
- xpack.security.enabled=false
volumes:
- elasticsearch_data:/usr/share/elasticsearch/data
deploy:
resources:
limits:
memory: 1GB
logstash:
image: docker.elastic.co/logstash/logstash:8.8.0
volumes:
- ./logstash/pipeline:/usr/share/logstash/pipeline:ro
depends_on:
- elasticsearch
kibana:
image: docker.elastic.co/kibana/kibana:8.8.0
ports:
- "5601:5601"
environment:
ELASTICSEARCH_HOSTS: http://elasticsearch:9200
depends_on:
- elasticsearch
app:
image: my-application:latest
logging:
driver: "json-file"
options:
max-size: "10m"
max-file: "3"
depends_on:
- logstash
volumes:
elasticsearch_data:
Health Checks ve Monitoring
# Advanced health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
CMD curl -f http://localhost:8080/api/health \
|| curl -f http://localhost:8080/api/ping \
|| exit 1
# Prometheus metrics endpoint için health check
HEALTHCHECK --interval=15s --timeout=3s --start-period=10s --retries=3 \
CMD wget --no-verbose --tries=1 --spider http://localhost:9090/metrics \
|| exit 1
Docker İleri Seviye Container Security Best Practices
Non-Root User Implementation
FROM node:18-alpine
# Güvenlik için non-root user oluştur
RUN addgroup -g 1001 -S nodejs
RUN adduser -S nextjs -u 1001
# Gerekli dizinleri oluştur ve sahipliğini ayarla
WORKDIR /app
RUN chown -R nextjs:nodejs /app
USER nextjs
# Uygulama dosyalarını kopyala
COPY --chown=nextjs:nodejs . .
# Port expose et (1024 üstü portlar non-root kullanıcılar için güvenli)
EXPOSE 3000
CMD ["node", "server.js"]
Image Vulnerability Scanning
# Docker Scout ile güvenlik tarama
docker scout cves my-app:latest
# Trivy ile detaylı güvenlik analizi
trivy image my-app:latest
# Snyk ile dependency scanning
snyk container test my-app:latest
Runtime Security
# Read-only root filesystem
docker run --read-only --tmpfs /tmp my-app:latest
# Capability drop
docker run --cap-drop=ALL --cap-add=NET_BIND_SERVICE my-app:latest
# No new privileges
docker run --security-opt=no-new-privileges my-app:latest
# AppArmor/SELinux profili
docker run --security-opt apparmor:my-profile my-app:latest
Docker İleri Seviye CI/CD Pipeline Entegrasyonu
GitLab CI/CD Pipeline
stages:
- build
- test
- security
- deploy
variables:
DOCKER_IMAGE: $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
DOCKER_LATEST: $CI_REGISTRY_IMAGE:latest
build:
stage: build
script:
- docker build -t $DOCKER_IMAGE .
- docker tag $DOCKER_IMAGE $DOCKER_LATEST
- docker push $DOCKER_IMAGE
- docker push $DOCKER_LATEST
only:
- main
- develop
test:
stage: test
script:
- docker run --rm $DOCKER_IMAGE npm test
- docker run --rm $DOCKER_IMAGE npm run lint
needs: ["build"]
security_scan:
stage: security
script:
- docker scout cves $DOCKER_IMAGE
- trivy image --exit-code 1 --severity HIGH,CRITICAL $DOCKER_IMAGE
needs: ["build"]
allow_failure: false
deploy_staging:
stage: deploy
script:
- docker stack deploy -c docker-stack.yml myapp-staging
environment:
name: staging
url: https://staging.myapp.com
only:
- develop
deploy_production:
stage: deploy
script:
- docker stack deploy -c docker-stack.yml myapp-production
environment:
name: production
url: https://myapp.com
when: manual
only:
- main
GitHub Actions Workflow
name: Docker Build and Deploy
on:
push:
branches: [ main, develop ]
pull_request:
branches: [ main ]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v2
- name: Login to Container Registry
uses: docker/login-action@v2
with:
registry: ghcr.io
username: ${{ github.actor }}
password: ${{ secrets.GITHUB_TOKEN }}
- name: Build and push Docker image
uses: docker/build-push-action@v4
with:
context: .
push: true
tags: |
ghcr.io/${{ github.repository }}:latest
ghcr.io/${{ github.repository }}:${{ github.sha }}
cache-from: type=gha
cache-to: type=gha,mode=max
- name: Run security scan
run: |
docker scout cves ghcr.io/${{ github.repository }}:latest
- name: Deploy to staging
if: github.ref == 'refs/heads/develop'
run: |
echo "Deploying to staging environment"
# Staging deployment commands
- name: Deploy to production
if: github.ref == 'refs/heads/main'
run: |
echo "Deploying to production environment"
# Production deployment commands
Performance Optimization Strategies
Resource Management
# CPU ve Memory limits ile service oluştur
docker service create \
--name optimized-app \
--replicas 3 \
--reserve-memory 512MB \
--limit-memory 1GB \
--reserve-cpu 0.25 \
--limit-cpu 0.5 \
my-app:latest
# OOM killer koruması
docker run -d \
--name protected-app \
--memory=512m \
--oom-kill-disable \
my-app:latest
Networking Optimization
# Custom network ile performans optimizasyonu
docker network create \
--driver overlay \
--subnet=10.10.0.0/16 \
--gateway=10.10.0.1 \
--opt encrypted=true \
production-network
# Load balancing algoritması belirle
docker service create \
--name load-balanced-app \
--network production-network \
--endpoint-mode dnsrr \
nginx:alpine
Backup ve Disaster Recovery
Volume Backup Stratejileri
# Volume backup scripti
#!/bin/bash
BACKUP_DIR="/backup/$(date +%Y%m%d_%H%M%S)"
mkdir -p $BACKUP_DIR
# Database volume backup
docker run --rm \
-v postgres_data:/source:ro \
-v $BACKUP_DIR:/backup \
alpine tar czf /backup/postgres_data.tar.gz -C /source .
# Application data backup
docker run --rm \
-v app_uploads:/source:ro \
-v $BACKUP_DIR:/backup \
alpine tar czf /backup/app_uploads.tar.gz -C /source .
echo "Backup completed at $BACKUP_DIR"
Automated Backup with Cron
# Backup container ile otomatik yedekleme
version: '3.8'
services:
backup:
image: alpine:latest
volumes:
- postgres_data:/data/postgres:ro
- app_data:/data/app:ro
- /backup:/backup
command: |
sh -c "
apk add --no-cache dcron
echo '0 2 * * * tar czf /backup/backup_\$$(date +%Y%m%d_%H%M%S).tar.gz -C /data .' > /tmp/crontab
crontab /tmp/crontab
crond -f
"
restart: unless-stopped
volumes:
postgres_data:
app_data:
Troubleshooting ve Debugging
Advanced Debugging Techniques
# Container filesystem analizi
docker diff container_name
# Process monitoring inside container
docker exec container_name top
docker exec container_name ps aux
# Network debugging
docker exec container_name netstat -tlnp
docker exec container_name ss -tlnp
# Resource usage real-time monitoring
docker stats --format "table {{.Container}}\t{{.CPUPerc}}\t{{.MemUsage}}\t{{.NetIO}}\t{{.BlockIO}}"
# Event monitoring
docker events --filter container=my-container
docker system events --filter type=container
Performance Profiling
# Container performance profiling
docker run -it --rm \
--pid container:target-container \
--cap-add SYS_PTRACE \
nicolaka/netshoot
# Memory leak detection
docker exec container_name cat /proc/meminfo
docker exec container_name free -h
# I/O performance monitoring
docker exec container_name iostat -x 1
Migration Strategies
Legacy Application Containerization
Mevcut uygulamaları containerize etmek için aşamalı bir yaklaşım önerilir:
# Aşama 1: Lift and Shift
FROM ubuntu:20.04
COPY legacy-app /opt/legacy-app
RUN apt-get update && apt-get install -y legacy-dependencies
CMD ["/opt/legacy-app/start.sh"]
# Aşama 2: Optimization
FROM ubuntu:20.04 AS base
RUN apt-get update && apt-get install -y --no-install-recommends \
required-packages && \
rm -rf /var/lib/apt/lists/*
FROM base AS runtime
COPY --from=builder /opt/legacy-app /opt/legacy-app
USER nonroot
CMD ["/opt/legacy-app/start.sh"]
Blue-Green Deployment
# Blue-Green deployment script
#!/bin/bash
CURRENT_COLOR=$(docker service inspect --format='{{.Spec.Labels.color}}' myapp 2>/dev/null || echo "blue")
NEW_COLOR=$([ "$CURRENT_COLOR" = "blue" ] && echo "green" || echo "blue")
echo "Current environment: $CURRENT_COLOR"
echo "Deploying to: $NEW_COLOR"
# Deploy new version
docker service create \
--name myapp-$NEW_COLOR \
--label color=$NEW_COLOR \
--replicas 3 \
myapp:latest
# Health check
sleep 30
if curl -f http://myapp-$NEW_COLOR:8080/health; then
echo "Health check passed, switching traffic"
# Switch traffic (update load balancer config)
docker service update --label-add color=$NEW_COLOR myapp-router
# Remove old version
docker service rm myapp-$CURRENT_COLOR
echo "Deployment completed successfully"
else
echo "Health check failed, rolling back"
docker service rm myapp-$NEW_COLOR
exit 1
fi
Kubernetes Migration Hazırlığı
Docker Swarm’dan Kubernetes’e geçiş planlayanlar için kompose aracı kullanarak Docker Compose dosyalarını Kubernetes manifesto’larına dönüştürebilirsiniz:
# Kompose kurulumu
curl -L https://github.com/kubernetes/kompose/releases/latest/download/kompose-linux-amd64 -o kompose
chmod +x kompose && sudo mv kompose /usr/local/bin/
# Docker Compose'u Kubernetes manifesto'larına çevir
kompose convert -f docker-compose.yml
# Helm chart oluştur
kompose convert -f docker-compose.yml -c
Sonuç ve Gelecek Adımlar
Bu Docker ileri seviye kullanımı rehberi ile enterprise-grade container deployment’ları gerçekleştirebilir, production ortamlarında güvenli ve performanslı uygulamalar çalıştırabilirsiniz. Docker ileri seviye özellikleri sayesinde modern DevOps pratiklerini hayata geçirmek artık çok daha kolay.
Docker ileri seviye kullanımı konusunda container orchestration dünyasında Docker Swarm’dan sonraki adım genellikle Kubernetes olmaktadır. Kubernetes, daha karmaşık ve büyük ölçekli dağıtımlar için additional özellikler sunar. Ancak burada öğrendiğiniz Docker ileri seviye temelleri, Kubernetes öğrenme sürecinizde size büyük avantaj sağlayacaktır.
DevOps journey’nizde başarılar dilerim ve Docker ileri seviye kullanımı teknolojilerinin gücünü projelerinizde en iyi şekilde kullanmanızı umuyorum! Docker temel kullanımı makalemizi de mutlaka inceleyin.