Docker Compose 2026: Çok Konteynerli Uygulamalar, Ağ Yapılandırması ve DevOps Mülakat Soruları

Docker Compose, 2026 yılında çok konteynerli Docker uygulamalarını tanımlamak ve çalıştırmak için vazgeçilmez araç olmaya devam ediyor. İster yerel geliştirme ortamı kurulumu, ister DevOps mülakatına hazırlık olsun, Compose ağ yapılandırması, servis bağımlılıkları ve production kalıplarını anlamak deneyimli mühendisleri ayırt eden önemli bir beceridir.

Docker Compose Mimarisi

Docker Compose basit bir prensiple çalışır: uygulamanın servisleri compose.yaml dosyasında tanımlanır (eski docker-compose.yml yerine modern adlandırma kuralı) ve Compose konteyner oluşturma, ağ yapılandırma ve yaşam döngüsü yönetimini üstlenir.

Docker Compose spesifikasyonu üç temel kavramı tanımlar:

• Servisler: Image, build context, ortam değişkenleri ve kaynak limitleri içeren konteyner yapılandırmaları
• Ağlar: Servisler arasında izole iletişim kanalları
• Volume'lar: Konteyner yeniden başlatmalarında hayatta kalan kalıcı veri depolama

# compose.yaml
services:
  api:
    build: ./api
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=postgres://db:5432/app
    depends_on:
      db:
        condition: service_healthy
    networks:
      - backend

  db:
    image: postgres:16
    volumes:
      - postgres_data:/var/lib/postgresql/data
    environment:
      - POSTGRES_DB=app
      - POSTGRES_PASSWORD_FILE=/run/secrets/db_password
    secrets:
      - db_password
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 5s
      retries: 5
    networks:
      - backend

networks:
  backend:
    driver: bridge

volumes:
  postgres_data:

secrets:
  db_password:
    file: ./secrets/db_password.txt

Bu yapılandırma birkaç production-ready kalıbı göstermektedir: bağımlılık sıralaması için health check'ler, hassas veriler için Docker secret'ları, kalıcılık için adlandırılmış volume'lar ve açık ağ tanımlamaları.

Docker Compose Ağ Yapılandırması Detaylı İnceleme

Varsayılan olarak Compose, uygulama için tek bir ağ oluşturur. Tüm servisler bu ağa katılır ve servis adını hostname olarak kullanarak birbirleriyle iletişim kurabilir. Bu ağ modelini anlamak, ileride Kubernetes geçişi için temel oluşturur.

# compose.yaml
services:
  frontend:
    build: ./frontend
    ports:
      - "80:80"
    networks:
      - frontend-net
      - backend-net

  api:
    build: ./api
    networks:
      - backend-net

  cache:
    image: redis:7-alpine
    networks:
      - backend-net

  db:
    image: postgres:16
    networks:
      - backend-net

networks:
  frontend-net:
    driver: bridge
  backend-net:
    driver: bridge
    internal: true

internal: true bayrağı, backend ağının harici internete erişimini engeller. Frontend servisi her iki ağı köprüleyerek tek giriş noktası olarak işlev görür. Bu ağ segmentasyonu, production güvenlik uygulamalarını yansıtır.

Compose ile Multi-Stage Build'ler

Production image'ları minimal olmalıdır. Multi-stage build'ler ve Compose profilleri birlikte kullanıldığında, geliştirme ve production için farklı yapılandırmalar mümkün olur.

# api/Dockerfile
# Aşama 1: Build
FROM node:22-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Aşama 2: Production
FROM node:22-alpine AS production
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
COPY package*.json ./
USER node
EXPOSE 3000
CMD ["node", "dist/index.js"]

# Aşama 3: Geliştirme
FROM node:22-alpine AS development
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
USER node
CMD ["npm", "run", "dev"]

# compose.yaml
services:
  api:
    build:
      context: ./api
      target: ${BUILD_TARGET:-production}
    volumes:
      - ${API_VOLUMES:-./api/dist:/app/dist:ro}
    profiles:
      - ${COMPOSE_PROFILES:-prod}

BUILD_TARGET=development COMPOSE_PROFILES=dev docker compose up komutu, hot reload özellikli geliştirme yapılandırmasını başlatır.

Servis Bağımlılıkları ve Health Check'ler

depends_on direktifi başlatma sırasını kontrol eder, ancak konteynerlerin başlaması servislerin hazır olduğu anlamına gelmez. Health check'ler bu zamanlama sorununu çözer — bu kalıp DevOps mülakatlarında sıkça sorulan bir konudur.

# compose.yaml
services:
  api:
    build: ./api
    depends_on:
      db:
        condition: service_healthy
      cache:
        condition: service_started
      migrations:
        condition: service_completed_successfully

  migrations:
    build: ./api
    command: npm run migrate
    depends_on:
      db:
        condition: service_healthy

  db:
    image: postgres:16
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 3s
      retries: 5
      start_period: 10s

  cache:
    image: redis:7-alpine
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s
      timeout: 3s
      retries: 3

Üç bağımlılık koşulu mevcuttur:

• service_started: Varsayılan, konteyner başlatıldı
• service_healthy: Health check başarılı
• service_completed_successfully: Konteyner 0 kodu ile çıkış yaptı (init konteynerleri için)

Yerel Geliştirme için Docker Compose

Geliştirme ortamları bind mount'lar, ortam değişkeni override'ları ve hata ayıklama araçlarından yararlanır. compose.override.yaml dosyası otomatik olarak compose.yaml ile birleştirilir.

# compose.yaml (temel yapılandırma)
services:
  api:
    build: ./api
    environment:
      - NODE_ENV=production

  db:
    image: postgres:16

# compose.override.yaml (geliştirme override'ları)
services:
  api:
    build:
      target: development
    volumes:
      - ./api:/app
      - /app/node_modules
    environment:
      - NODE_ENV=development
      - DEBUG=app:*
    ports:
      - "9229:9229"

  db:
    ports:
      - "5432:5432"

Anonim volume /app/node_modules, host'un node_modules klasörünün konteynerin yüklü bağımlılıklarını geçersiz kılmasını önler.

Production Dağıtım Kalıpları

Docker Compose tek host production dağıtımları için uygundur. Çoklu host orkestrasyon için Kubernetes ve Helm daha iyi ölçekleme sağlar, ancak Compose daha küçük uygulamalar için uygun kalır.

# compose.prod.yaml
services:
  api:
    image: registry.example.com/api:${VERSION:-latest}
    deploy:
      replicas: 3
      resources:
        limits:
          cpus: "0.5"
          memory: 512M
        reservations:
          cpus: "0.25"
          memory: 256M
      restart_policy:
        condition: on-failure
        delay: 5s
        max_attempts: 3
    logging:
      driver: json-file
      options:
        max-size: "10m"
        max-file: "3"

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
      - ./certs:/etc/nginx/certs:ro
    depends_on:
      - api

deploy anahtarı kaynak limitleri, replika sayıları ve yeniden başlatma politikalarını yapılandırır. docker compose -f compose.prod.yaml up -d komutu production yığınını arka planda başlatır.

Ortam Değişkenleri ve Secret Yönetimi

Hassas yapılandırma uygun işlem gerektirir. Docker Compose, .env dosyalarından Docker secret'larına kadar birden fazla yaklaşımı destekler.

# .env
POSTGRES_PASSWORD=dev_password_only
API_SECRET_KEY=local_dev_key

# compose.yaml
services:
  api:
    environment:
      - API_SECRET_KEY  # Shell veya .env'den miras alır
      - DATABASE_URL=postgres://user:${POSTGRES_PASSWORD}@db:5432/app
    env_file:
      - ./config/api.env

Production için Docker secret'ları, hassas verileri ortam değişkenleri yerine dosya olarak bağlayarak daha iyi güvenlik sağlar:

# compose.prod.yaml
services:
  api:
    secrets:
      - api_key
      - db_password
    environment:
      - API_KEY_FILE=/run/secrets/api_key

secrets:
  api_key:
    external: true
  db_password:
    file: ./secrets/db_password.txt

Docker Compose Hakkında Yaygın DevOps Mülakat Soruları

Mülakatçılar, Compose kavramlarını pratik senaryolar üzerinden test eder. Bu sorular DevOps ve platform mühendisliği mülakatlarında sıkça karşılaşılır.

S: Bir Compose ağındaki konteynerler nasıl iletişim kurar?

Docker, her Compose projesi için özel bir bridge ağı oluşturur. Servisler, hostname olarak servis adlarını kullanarak iletişim kurar. Gömülü DNS sunucusu bu adları konteyner IP adreslerine çözümler. Harici trafik, servislere yalnızca açıkça yayınlanan portlar üzerinden ulaşır.

S: Mevcut konteynerlerle docker compose up çalıştırıldığında ne olur?

Compose, mevcut yapılandırmayı çalışan konteynerlerle karşılaştırır. Değişmeyen servisler çalışmaya devam eder. Değiştirilen servisler yeni ayarlarla yeniden oluşturulur. Yeni servisler sıfırdan başlatılır. Kaldırılan servisler durdurulur ve silinir.

S: Compose'da veritabanı migrasyonları nasıl yönetilir?

İki kalıp mevcuttur. İlki, service_completed_successfully bağımlılığı olan bir init konteyneri kullanır:

services:
  migrate:
    image: api:latest
    command: npm run migrate
    depends_on:
      db:
        condition: service_healthy

  api:
    depends_on:
      migrate:
        condition: service_completed_successfully

İkincisi, migrasyon mantığını uygulama başlatma betiğine dahil ederek, trafik kabul etmeden önce bekleyen migrasyonları kontrol edip uygular.

S: Volume'lar ve bind mount'lar arasındaki fark nedir?

Adlandırılmış volume'lar Docker tarafından yönetilir, /var/lib/docker/volumes içinde depolanır ve hostlar arasında taşınabilir. Bind mount'lar host dizinlerini doğrudan konteynerlere eşler, geliştirme için kullanışlıdır ancak ortama bağımlıdır. Volume'lar, NFS veya bulut block storage gibi uzak depolama için sürücüleri destekler.

S: docker-compose ve docker compose arasındaki fark nedir?

Tire ile yazılan docker-compose, artık kullanımdan kaldırılmış Python tabanlı bağımsız V1 aracıydı. Boşluk ile yazılan docker compose, Docker CLI'ye entegre edilmiş Go tabanlı V2 uygulamasıdır. V2 daha hızlıdır, Compose Spesifikasyonunu tam olarak destekler ve aktif olarak geliştirilmektedir.

Compose Uygulamalarında Hata Ayıklama

Konteynerize uygulamalarda sorun giderme belirli teknikler gerektirir. Bu komutlar Compose yığınınızın içinde neler olduğunu ortaya çıkarır:

# Tüm servislerden logları görüntüle
docker compose logs -f

# Belirli bir servisin loglarını zaman damgalarıyla
docker compose logs -f --timestamps api

# Çalışan konteynerde komut çalıştır
docker compose exec api sh

# Tek seferlik komut çalıştır (yeni konteyner başlatır)
docker compose run --rm api npm test

# Kaynak kullanımını görüntüle
docker compose top
docker stats

# Ağ yapılandırmasını incele
docker network inspect project_backend

# Compose dosyasını doğrula
docker compose config

docker compose config komutu tüm compose dosyalarını birleştirir ve son yapılandırmayı gösterir — değişken interpolasyon sorunlarını ayıklamak için çok değerlidir.

Sonuç

• Docker Compose, çok konteynerli uygulamaları servisler, ağlar ve volume'lar ile tek bir YAML dosyasında tanımlar
• Servisler, varsayılan bridge ağında hostname olarak servis adlarını kullanarak DNS üzerinden iletişim kurar
• service_healthy koşullu health check'ler uygun başlatma sıralamasını sağlar
• compose.override.yaml bind mount'lar ve debug portları gibi geliştirme ayarları için kullanılır
• Production dağıtımları kaynak limitleri, yeniden başlatma politikaları ve hassas veriler için Docker secret'larından yararlanır
• docker compose CLI (V2), daha iyi performans ve özelliklerle kullanımdan kaldırılan docker-compose (V1) yerini alır