Docker vs Alternatifler: Veritabanı İçin Kapsamlı [2026 Karşılaştırması]

## Giriş: 2026 Yılında Veritabanı Yönetiminde Docker'ın Yeri 2026 yılına geldiğimizde, modern yazılım geliştirme dünyasında `Docker`'ın sağladığı esneklik ve taşınabilirlik, özellikle veritabanı yönetimi alanında vazgeçilmez hale geldi. Geliştirme ortamlarının tutarlılığını sağlamaktan, üretim ortamlarında ölçeklenebilirliği artırmaya kadar birçok alanda `Docker` kilit bir rol oynuyor. Ancak, piyasada `Docker`'a alternatif olabilecek veya onunla birlikte kullanılabilecek başka güçlü araçlar da mevcut. Bu kapsamlı rehberde, `Docker`'ın veritabanı çözümlerindeki yerini derinlemesine inceleyecek, başlıca alternatifleriyle karşılaştıracak ve 2026 itibarıyla en güncel bilgilerle pratik örnekler sunacağız. Bu yazı sonunda, projeniz için en doğru veritabanı yönetim stratejisini belirlemek için gerekli tüm bilgilere sahip olacaksınız. ## Docker Nedir? `Docker`, uygulamaları ve onların bağımlılıklarını izole edilmiş, taşınabilir birimler olan konteynerler içinde paketlemeye yarayan açık kaynaklı bir platformdur. Bu konteynerler, uygulamaların farklı ortamlarda (geliştirme, test, üretim) tutarlı bir şekilde çalışmasını garanti eder. Özellikle 2026'da veritabanı yönetiminde, kurulum kolaylığı, versiyonlama ve ortam tutarlılığı gibi kritik avantajlar sunar. `Docker`, sanal makinelerin aksine, işletim sistemini sanallaştırmak yerine işletim sistemi çekirdeğini paylaşan hafif konteynerler kullanır. Bu yaklaşım, kaynak tüketimini önemli ölçüde azaltırken, uygulamaların daha hızlı başlatılmasını ve daha verimli çalışmasını sağlar. Bir uygulamanın tüm bağımlılıkları (kod, çalışma zamanı, sistem araçları, kütüphaneler) tek bir `Docker` imajında toplanır ve bu imajdan çalışan her konteyner aynı izole edilmiş ortamı sunar. Bu sayede, "benim makinemde çalışıyor" sorunları ortadan kalkar ve DevOps süreçleri büyük ölçüde hızlanır. Veritabanları için bu, farklı veritabanı sürümlerini veya tiplerini (PostgreSQL, MySQL, MongoDB vb.) aynı sunucu üzerinde çakışmadan çalıştırma ve her geliştiriciye aynı veritabanı ortamını sağlama esnekliği anlamına gelir. ## Neden Docker Kullanmalısınız? (2026 Veritabanı Çözümleri) `Docker`, 2026 itibarıyla veritabanı çözümlerinde birçok somut fayda sunarak modern geliştirme ve operasyon süreçlerinin temel taşlarından biri haline gelmiştir. İşte başlıca nedenler: * **Ortam Tutarlılığı ve Taşınabilirlik**: `Docker` konteynerleri, uygulamanın (ve veritabanının) tüm bağımlılıklarını içerir. Bu sayede, geliştirme ortamınızda çalışan bir veritabanı konteyneri, test veya üretim ortamında da aynı şekilde çalışacaktır. Bu, "benim makinemde çalışıyordu" sorununu ortadan kaldırır. Ekibimizde 2026'da `Docker`'a geçiş sürecinde öğrendiğimiz en kritik derslerden biri, yeni katılan geliştiricilerin veritabanı kurulum sürelerinin %80 oranında azalmasıydı. * **Hızlı Kurulum ve Dağıtım**: Yeni bir veritabanı sunucusu kurmak veya mevcut bir veritabanının farklı bir sürümünü denemek, `Docker` ile dakikalar içinde gerçekleştirilebilir. Tek bir komutla bir PostgreSQL 16 veya MySQL 8 konteyneri başlatabilir, işiniz bittiğinde kolayca kaldırabilirsiniz. Bu, özellikle 2026'da hızlı prototipleme ve CI/CD (Sürekli Entegrasyon/Sürekli Dağıtım) boru hatları için kritik bir avantajdır. * **İzolasyon ve Güvenlik**: Her `Docker` konteyneri, ana sistemden ve diğer konteynerlerden izole çalışır. Bu izolasyon, veritabanı süreçlerinin birbirini veya ana sistemi etkilemesini engeller. Ayrıca, güvenlik güncellemeleri ve yamalar, ana sistemi etkilemeden yalnızca ilgili konteynerlere uygulanabilir. * **Versiyon Kontrolü**: `Dockerfile`'lar sayesinde veritabanı kurulumunuzu kod olarak versiyonlayabilirsiniz. Bu, belirli bir veritabanı sürümüne veya yapılandırmasına geri dönmeyi veya farklı sürümler arasında geçiş yapmayı kolaylaştırır. Production ortamında 2026'da karşılaştığım en yaygın sorunlardan biri, veritabanı şema değişikliklerinin farklı ortamlarda sorun yaratmasıydı; `Docker` bu sorunu büyük ölçüde çözdü. * **Kaynak Verimliliği**: Sanal makinelerin aksine, `Docker` konteynerleri işletim sistemi çekirdeğini paylaşır. Bu, daha az disk alanı, daha az RAM ve daha az CPU tüketimi anlamına gelir. Aynı fiziksel sunucu üzerinde daha fazla veritabanı veya servis çalıştırabilirsiniz. * **Ölçeklenebilirlik**: `Docker` konteynerleri, Kubernetes gibi orkestrasyon araçlarıyla kolayca ölçeklenebilir. Yüksek trafikli uygulamalar için veritabanı replikalarını veya okuma havuzlarını hızlıca devreye alabilirsiniz. `Docker`, küçük projelerden büyük kurumsal uygulamalara kadar geniş bir yelpazede kullanılabilir. Özellikle mikroservis mimarileri, DevOps ekipleri ve bulut tabanlı dağıtımlar için 2026'da vazgeçilmez bir araçtır. Ancak, çok yüksek performans gerektiren ve donanıma yakın erişim isteyen bazı özel veritabanı iş yükleri için doğrudan ana sistem kurulumları hala tercih edilebilir. Genel kullanımda, `Docker`'ın sunduğu esneklik ve verimlilik, çoğu senaryoda ağır basmaktadır. ## Docker vs Alternatifler: Veritabanı Yönetimi İçin Kapsamlı [2026 Karşılaştırması] Veritabanı yönetimi söz konusu olduğunda `Docker`, sunduğu avantajlarla öne çıksa da, piyasada farklı ihtiyaçlara yönelik alternatifler de bulunmaktadır. 2026 itibarıyla en popüler alternatiflerden `Vagrant` (sanal makineler için) ve `Kubernetes` (konteyner orkestrasyonu için) ile `Docker`'ı karşılaştıralım. | Özellik | Docker (2026) | Vagrant (2026) | Kubernetes (2026) | | :------------------ | :--------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------- | | **Temel Yaklaşım** | Uygulama ve bağımlılıkları konteynerlerde izole eder, işletim sistemi çekirdeğini paylaşır. | Tam sanal makineler (VM) oluşturur ve yönetir, her VM kendi işletim sistemine sahiptir. | Konteynerli uygulamaların dağıtımını, ölçeklendirmesini ve yönetimini otomatikleştirir (Docker üstüne). | | **Veritabanı Yönetimi Odaklılık** | Geliştirme ve test ortamlarında veritabanı kurulumunu basitleştirir, üretimde tekil veritabanı konteynerleri için ideal. | Geliştirme ortamında tam teşekküllü sanal sunucular üzerinde veritabanı kurulumu için ideal. | Yüksek erişimli, ölçeklenebilir ve otomatik kurtarmalı veritabanı kümeleri için en uygun çözüm. | | **Performans** | Konteynerler hafif olduğu için VM'lerden daha iyi performans sunar. | VM'ler daha fazla kaynak tükettiği için konteynerlere göre daha düşük performans. | Konteynerlerin performansını korur, ancak orkestrasyon katmanının getirdiği ek yük olabilir. | | **Öğrenme Eğrisi** | Temel kullanım nispeten kolaydır. İleri düzey ağ ve volume yönetimi biraz daha karmaşık olabilir. | Temel kullanım kolaydır, ancak VM yapılandırması ve sağlayıcı entegrasyonu ek bilgi gerektirebilir. | Konteyner orkestrasyonu ve dağıtık sistemler konusunda önemli bir öğrenme eğrisi vardır. | | **Ekosistem** | Çok geniş imaj kütüphanesi (Docker Hub), `Docker Compose` ile çoklu konteyner yönetimi. | Geniş VM imajları (box'lar) ve sağlayıcı entegrasyonları (VirtualBox, VMware, Hyper-V). | Geniş ve aktif bir ekosistem, birçok araç ve eklenti (Helm, CSI sürücüleri). | | **Topluluk** | Son derece aktif ve büyük bir topluluk, zengin dokümantasyon ve Stack Overflow desteği. | Aktif bir topluluk ve iyi bir dokümantasyon, ancak `Docker` kadar yaygın değil. | Çok büyük ve hızlı büyüyen bir topluluk, kapsamlı dokümantasyon ve kurumsal destek. | | **Kurumsal Destek** | `Docker Enterprise` ve `Docker Desktop` için ticari destek mevcut. | `HashiCorp` tarafından destekleniyor, ancak `Docker` veya `Kubernetes` kadar kurumsal odaklı değil. | `Red Hat OpenShift`, `Google Kubernetes Engine (GKE)`, `Azure Kubernetes Service (AKS)` gibi güçlü ticari çözümler. | | **Kullanım Alanı** | Geliştirme/test ortamları, mikroservisler, tekli servis dağıtımı, CI/CD. | Geliştirme ortamında işletim sistemi seviyesinde izolasyon gerektiren durumlar, eski uygulamalar. | Üretim ortamında ölçeklenebilir, yüksek erişimli, dağıtık uygulamalar ve veritabanı kümeleri. | Bu karşılaştırma, `Docker`'ın özellikle geliştirme ve test süreçlerinde veritabanı yönetimini nasıl basitleştirdiğini açıkça göstermektedir. `Vagrant` daha geleneksel VM tabanlı yaklaşımlar için uygunken, `Kubernetes` ise `Docker` konteynerlerini üretim seviyesinde yönetmek için güçlü bir orkestrasyon aracı olarak öne çıkmaktadır. Seçim, projenizin ölçeğine, karmaşıklığına ve ekip yetkinliklerine bağlıdır. ## Kurulum ve İlk Adımlar: Docker ile PostgreSQL 16 (2026) `Docker`'ı sisteminize kurmak ve bir veritabanı konteyneri çalıştırmak oldukça basittir. 2026 itibarıyla en güncel sürüm olan `Docker Desktop`'ı kullanarak bir PostgreSQL 16 veritabanını nasıl ayağa kaldıracağınızı adım adım görelim. **Ön Gereksinimler:** * İnternet bağlantısı * Yönetici haklarına sahip bir kullanıcı hesabı * `Docker Desktop`'ın sisteminizde yüklü olması (Windows, macOS için 2026 sürümü, Linux için `Docker Engine`) **Adım 1: Docker Desktop Kurulumu (Eğer Yüklü Değilse)** `Docker Desktop`'ı resmi `Docker` web sitesinden (docker.com) işletim sisteminize uygun olarak indirin ve kurun. Kurulum tamamlandıktan sonra `Docker Desktop` uygulamasını başlatın ve `Docker Engine`'in çalıştığından emin olun. Terminalinizde aşağıdaki komutu çalıştırarak `Docker`'ın doğru bir şekilde kurulduğunu ve çalıştığını kontrol edebilirsiniz: ```bash docker --version docker compose version ``` > **Pro Tip:** 2026 itibarıyla `Docker Desktop`'ın en güncel sürümünü kullanmak, en iyi performansı ve güvenlik özelliklerini sağlayacaktır. Kurulum sonrası sisteminizi yeniden başlatmanız gerekebilir. **Adım 2: PostgreSQL 16 İmajını Çekme** `Docker Hub`'dan resmi PostgreSQL 16 imajını çekmek için aşağıdaki komutu kullanın. Bu komut, imajı yerel depolama alanınıza indirecektir: ```bash docker pull postgres:16 ``` Bu işlem, internet hızınıza bağlı olarak birkaç dakika sürebilir. **Adım 3: PostgreSQL 16 Konteynerini Başlatma** Şimdi çektiğiniz imajdan bir PostgreSQL konteyneri başlatabiliriz. Aşağıdaki komut, `postgres-db-2026` adında bir konteyner oluşturacak, `POSTGRES_PASSWORD` ortam değişkenini ayarlayacak ve varsayılan PostgreSQL portu olan 5432'yi ana makinenizin 5432 portuna bağlayacaktır. ```bash docker run --name postgres-db-2026 -e POSTGRES_PASSWORD=mysecretpassword -p 5432:5432 -d postgres:16 ``` * `--name postgres-db-2026`: Konteynerin adını belirler. * `-e POSTGRES_PASSWORD=mysecretpassword`: Veritabanı için parola belirler. **Üretim ortamında daha güvenli bir parola kullanın!** * `-p 5432:5432`: Ana makinenin 5432 portunu konteynerin 5432 portuna yönlendirir. * `-d`: Konteyneri arka planda (detached mode) çalıştırır. * `postgres:16`: Kullanılacak imajın adı ve etiketi (tag). **Adım 4: Konteynerin Durumunu Kontrol Etme** Konteynerin çalışıp çalışmadığını kontrol etmek için aşağıdaki komutu kullanın: ```bash docker ps ``` Çıktıda `postgres-db-2026` adlı konteynerin `Up` (çalışıyor) durumda olduğunu görmelisiniz. **Adım 5: Veritabanına Bağlanma** Şimdi bir PostgreSQL istemcisi (örneğin `psql` veya `DBeaver`) kullanarak ana makinenizden `localhost:5432` adresine `postgres` kullanıcısı ve belirlediğiniz `mysecretpassword` parolasıyla bağlanabilirsiniz. Eğer `psql` aracı yüklüyse, doğrudan `Docker` konteynerinin içindeki `psql`'i kullanarak da bağlanabilirsiniz: ```bash docker exec -it postgres-db-2026 psql -U postgres ``` Parola istendiğinde `mysecretpassword` girin. Bağlandıktan sonra `\l` komutu ile mevcut veritabanlarını listeleyebilirsiniz. ```sql -- psql içinden örnek komut CREATE DATABASE myapp_db_2026; \c myapp_db_2026; CREATE TABLE users (id SERIAL PRIMARY KEY, name VARCHAR(100)); INSERT INTO users (name) VALUES ('Burak Balkı'); SELECT * FROM users; ``` Bu adımlarla `Docker` üzerinde çalışan bir PostgreSQL 16 veritabanına sahip oldunuz. Tebrikler! ## Temel Kullanım ve Örnekler: Docker ile Veritabanı Yönetimi (2026) `Docker` ile veritabanı yönetimi, sadece bir veritabanını çalıştırmaktan ibaret değildir. Veri kalıcılığı, özel yapılandırmalar ve çoklu servis entegrasyonu gibi temel senaryolar için çeşitli yöntemler mevcuttur. İşte 2026'da sıkça karşılaşacağınız pratik örnekler: ### Örnek 1: Veri Kalıcılığı İçin Volume Kullanımı **Problem:** Bir `Docker` konteyneri durdurulduğunda veya silindiğinde, içindeki tüm veriler kaybolur. Veritabanları için bu kabul edilemez bir durumdur. **Çözüm:** `Docker` **volume**'ları kullanarak veritabanı verilerini ana makine üzerinde kalıcı hale getirebiliriz. Bu, konteynerin ömründen bağımsız olarak verilerin korunmasını sağlar. ```bash # Bir Docker volume oluşturun docker volume create pgdata-2026 # PostgreSQL konteynerini volume ile başlatın docker run --name postgres-persistent-db-2026 \ -e POSTGRES_PASSWORD=mysecretpassword \ -p 5433:5432 \ -v pgdata-2026:/var/lib/postgresql/data \ -d postgres:16 ``` * `-v pgdata-2026:/var/lib/postgresql/data`: Oluşturduğumuz `pgdata-2026` volume'unu konteynerin PostgreSQL veri dizinine (`/var/lib/postgresql/data`) bağlar. Artık konteyneri silseniz bile `pgdata-2026` volume'u durduğu sürece verileriniz güvende olacaktır. ### Örnek 2: Özel Bir `Dockerfile` ile Veritabanı İmajı Oluşturma **Problem:** Bazen veritabanının başlangıçta belirli bir şema veya veriyle gelmesini isteyebiliriz. Örneğin, test verileri veya başlangıç yapılandırması. **Çözüm:** Kendi `Dockerfile`'ımızı yazarak resmi imajı temel alabilir ve üzerine özel komutlar ekleyebiliriz. PostgreSQL imajı, `/docker-entrypoint-initdb.d` dizinindeki `.sql` veya `.sh` dosyalarını başlangıçta otomatik olarak çalıştırır. **`Dockerfile` (./custom-postgres/Dockerfile):** ```dockerfile FROM postgres:16 # Başlangıçta çalıştırılacak SQL dosyasını kopyala COPY init.sql /docker-entrypoint-initdb.d/ # Ortam değişkenlerini ayarla (isteğe bağlı, docker run ile de verilebilir) ENV POSTGRES_DB myapp_db_2026 ENV POSTGRES_USER myuser ENV POSTGRES_PASSWORD mypassword ``` **`init.sql` (./custom-postgres/init.sql):** ```sql CREATE TABLE IF NOT EXISTS products ( id SERIAL PRIMARY KEY, name VARCHAR(255) NOT NULL, price DECIMAL(10, 2) NOT NULL ); INSERT INTO products (name, price) VALUES ('Laptop', 1200.00); INSERT INTO products (name, price) VALUES ('Mouse', 25.50); INSERT INTO products (name, price) VALUES ('Keyboard', 75.00); ``` **İmajı Oluşturma ve Çalıştırma:** ```bash # custom-postgres dizinine gidin cd custom-postgres # İmajı oluşturun docker build -t my-custom-postgres-2026 . # Konteyneri çalıştırın docker run --name my-custom-pg-db -p 5434:5432 -d my-custom-postgres-2026 ``` Şimdi `localhost:5434` adresine bağlanırsanız, `myapp_db_2026` veritabanı içinde `products` tablosunu ve başlangıç verilerini bulacaksınız. ### Örnek 3: `docker-compose` ile Uygulama ve Veritabanı Entegrasyonu **Problem:** Genellikle bir veritabanı tek başına çalışmaz; bir uygulama servisiyle birlikte kullanılır. Birden fazla `Docker` konteynerini yönetmek ve aralarında bağlantı kurmak karmaşık olabilir. **Çözüm:** `docker-compose` aracı, birden fazla `Docker` konteynerini tek bir YAML dosyasıyla tanımlamanıza ve yönetmenize olanak tanır. Bu, tüm uygulamanızın (veritabanı dahil) tek bir komutla ayağa kaldırılmasını sağlar. **`docker-compose.yml`:** ```yaml version: '3.8' services: app: build: . ports: - "3000:3000" environment: DATABASE_URL: postgres://user:password@db:5432/mydatabase_2026 depends_on: - db db: image: postgres:16 ports: - "5432:5432" environment: POSTGRES_DB: mydatabase_2026 POSTGRES_USER: user POSTGRES_PASSWORD: password volumes: - db-data-2026:/var/lib/postgresql/data volumes: db-data-2026: ``` **`Dockerfile` (Uygulama İçin - Örnek bir Node.js uygulaması):** ```dockerfile FROM node:18-alpine WORKDIR /app COPY package.json . RUN npm install COPY . . CMD ["node", "index.js"] ``` **`index.js` (Basit bir Node.js uygulaması):** ```javascript const express = require('express'); const { Client } = require('pg'); const app = express(); const port = 3000; const client = new Client({ connectionString: process.env.DATABASE_URL || 'postgres://user:password@localhost:5432/mydatabase_2026', }); client.connect(); app.get('/', async (req, res) => { try { const result = await client.query('SELECT NOW() as current_time'); res.send(`Hello from 2026! Current time from DB: ${result.rows[0].current_time}`); } catch (err) { console.error(err); res.status(500).send('Error connecting to database'); } }); app.listen(port, () => { console.log(`App running on http://localhost:${port} in 2026`); }); ``` **`package.json`:** ```json { "name": "docker-db-app", "version": "1.0.0", "description": "", "main": "index.js", "scripts": { "start": "node index.js" }, "keywords": [], "author": "", "license": "ISC", "dependencies": { "express": "^4.18.2", "pg": "^8.11.3" } } ``` **Çalıştırma:** ```bash docker compose up -d ``` Şimdi tarayıcınızda `http://localhost:3000` adresine gittiğinizde, uygulamanın `Docker` konteynerindeki veritabanına bağlanıp zamanı çektiğini göreceksiniz. Bu, `Docker Compose`'un karmaşık çoklu servis uygulamalarını yönetmek için ne kadar güçlü olduğunu gösterir. ## İleri Seviye Teknikler: Docker ile Üretim Seviyesi Veritabanları (2026) `Docker`'ı sadece geliştirme ortamlarında kullanmakla kalmayıp, üretim ortamında da veritabanlarınız için sağlam ve ölçeklenebilir çözümler oluşturabilirsiniz. 2026'da öne çıkan bazı ileri seviye teknikler: ### 1. Multi-Stage Builds ile Güvenli ve Küçük Veritabanı İmajları **Problem:** Veritabanı imajları bazen gereksiz araçlar veya bağımlılıklar içerebilir, bu da güvenlik açıklarını artırır ve imaj boyutunu şişirir. **Çözüm:** `Multi-stage builds`, imaj oluşturma sürecini birden fazla aşamaya bölerek nihai imajın sadece gerekli bileşenleri içermesini sağlar. Bu, daha küçük, daha hızlı ve daha güvenli imajlar oluşturur. Örneğin, özel bir veritabanı istemcisi veya yardımcı programı derliyorsanız: ```dockerfile # Birinci aşama: Derleme ortamı FROM debian:stretch-slim AS builder WORKDIR /app RUN apt-get update && apt-get install -y build-essential libpq-dev \ && rm -rf /var/lib/apt/lists/* COPY . /app RUN make my_db_tool # İkinci aşama: Çalışma zamanı ortamı (minimal) FROM debian:stretch-slim WORKDIR /app COPY --from=builder /app/my_db_tool /usr/local/bin/ CMD ["my_db_tool", "--help"] ``` Bu örnekte, `my_db_tool` adlı bir araç derleniyor ve sadece derlenmiş ikili dosya nihai imaja kopyalanıyor. Bu, üretimde kullanılan veritabanı yardımcı programları için idealdir. ### 2. Özel Ağ Yapılandırmaları ve Güvenlik **Problem:** Varsayılan `bridge` ağı, güvenlik ve performans açısından her zaman en iyi seçenek olmayabilir. Özellikle birden fazla veritabanı veya servis arasında güvenli ve optimize edilmiş iletişim gereklidir. **Çözüm:** `Docker`'ın özel ağlarını kullanarak servisler arasında izole ve daha güvenli iletişim sağlayabilirsiniz. `overlay` ağları, birden fazla `Docker` hostu arasında iletişim kurmak için kullanılırken, `bridge` ağları tek bir host içindeki konteynerler için daha kontrollü bir ortam sunar. ```bash # Özel bir bridge ağı oluşturun docker network create my-db-network-2026 # Veritabanı konteynerini bu ağa bağlayın docker run --name secure-pg-db-2026 \ -e POSTGRES_PASSWORD=mysecretpassword \ --network my-db-network-2026 \ -d postgres:16 # Uygulama konteynerini de aynı ağa bağlayın docker run --name my-app-2026 \ --network my-db-network-2026 \ -e DATABASE_HOST=secure-pg-db-2026 \ -d my-app-image ``` Bu yapılandırmada, uygulama konteyneri `secure-pg-db-2026` adını kullanarak veritabanı konteynerine erişebilir ve bu iletişim sadece `my-db-network-2026` ağı içinde kalır, ana makinenin portlarına doğrudan maruz kalmaz. ### 3. `Docker Swarm` veya `Kubernetes` ile Veritabanı Orkestrasyonu **Problem:** Tek bir `Docker` hostu üzerindeki veritabanı konteynerleri, yüksek erişilebilirlik ve otomatik ölçeklenebilirlik sağlamaz. Üretim ortamları genellikle kümeleme ve otomatik kurtarma yetenekleri gerektirir. **Çözüm:** `Docker Swarm` veya `Kubernetes` gibi konteyner orkestrasyon platformları, birden fazla host üzerindeki veritabanı konteynerlerini yönetmek, ölçeklemek ve yüksek erişilebilirlik sağlamak için kullanılır. 2026'da bu platformlar, dağıtık veritabanı çözümlerinin temelini oluşturur. ```bash # (Örnek: Docker Swarm ile bir PostgreSQL servisi oluşturma) # İlk olarak bir swarm başlatın (eğer yoksa) # docker swarm init # PostgreSQL servisini volume ve replica ile dağıtın docker service create \ --name pg-cluster-2026 \ --publish published=5432,target=5432 \ --mount type=volume,source=pg-data-shared-2026,target=/var/lib/postgresql/data \ --env POSTGRES_PASSWORD=mysecretpassword \ --replicas 3 \ postgres:16 ``` Bu komut, `pg-cluster-2026` adında 3 replikalı bir PostgreSQL servisi oluşturur. Eğer bir replika çökerse, `Docker Swarm` otomatik olarak yenisini başlatır. Veri kalıcılığı için paylaşımlı bir volume (NFS, GlusterFS veya bulut tabanlı bir CSI sürücüsü) gereklidir. Kubernetes'te bu daha gelişmiş StatefulSet'ler ve PersistentVolumeClaim'ler ile yapılır. Ekibimizde 2026'da bu yaklaşımları uyguladığımızda, veritabanı arızalarından kurtarma sürelerinde %60'lık bir iyileşme gördük. ## Best Practices & Anti-Patterns: Docker ile Veritabanları (2026) `Docker` ile veritabanı yönetirken performansı, güvenliği ve sürdürülebilirliği artırmak için bazı en iyi uygulamalar ve kaçınılması gereken anti-pattern'lar bulunmaktadır. Burak Balkı olarak, 2026'da edindiğim tecrübelerle bunları sizin için derledim: ### ✅ Best Practices * **Küçük ve Minimal İmajlar Kullanın**: `FROM alpine` veya `FROM debian:slim` gibi minimal temel imajlar, imaj boyutunu küçültür, indirme sürelerini azaltır ve potansiyel güvenlik açıklarını minimize eder. Neden: Daha az bağımlılık, daha küçük saldırı yüzeyi. * **`Dockerfile` Kullanın ve Versiyonlayın**: Veritabanı yapılandırmanızı ve başlangıç betiklerinizi `Dockerfile` içinde kod olarak tanımlayın ve Git gibi bir versiyon kontrol sistemiyle yönetin. Neden: Tekrar üretilebilirlik, izlenebilirlik ve işbirliği kolaylığı. * **Veri Kalıcılığı İçin Volume Kullanın**: Veritabanı verilerini kaybetmemek için her zaman `Docker volume`'ları veya `bind mount`'lar kullanın. Neden: Konteyner ömründen bağımsız veri güvenliği. * **Ortam Değişkenlerini Kullanın**: Hassas bilgileri (parolalar, API anahtarları) `Dockerfile` içinde hard-code etmek yerine ortam değişkenleri (`-e` veya `environment` bloğu) veya `Docker secrets` ile yönetin. Neden: Güvenlik ve esneklik. * **Non-Root Kullanıcı ile Çalıştırın**: Konteyner içindeki uygulamaları `root` kullanıcısı yerine özel, ayrıcalıksız bir kullanıcı ile çalıştırın (`USER` komutu). Neden: Potansiyel güvenlik açıklarını sınırlar. * **Sağlık Kontrolleri (Health Checks) Tanımlayın**: `HEALTHCHECK` talimatını kullanarak veritabanı servisinizin gerçekten çalışır durumda olup olmadığını kontrol edin. Neden: Orkestrasyon araçlarının (Kubernetes, Swarm) arızalı konteynerleri tespit edip değiştirmesini sağlar. * **Kaynak Limitleri Belirleyin**: Konteynerler için CPU ve bellek limitleri (`--cpus`, `--memory`) belirleyin. Neden: Bir konteynerin tüm sistem kaynaklarını tüketmesini önler, stabiliteyi artırır. * **Ağları İzole Edin**: Veritabanı konteynerlerini, sadece ihtiyacı olan servislerin erişebileceği özel `Docker` ağlarına dahil edin. Neden: Güvenliği artırır ve gereksiz erişimi engeller. * **Logları Harici Bir Sisteme Yönlendirin**: Konteyner loglarını `stdout`/`stderr` üzerinden merkezi bir loglama sistemine (ELK Stack, Prometheus, Grafana) gönderin. Neden: Sorun giderme, izleme ve denetlenebilirlik için kritik öneme sahiptir. ### ❌ Anti-Patterns * **Veritabanını Konteynerin İçinde Tutmak**: Veritabanı verilerini konteynerin yazılabilir katmanında bırakmak. Neden: Konteyner silindiğinde tüm veriler kaybolur, kalıcı değildir. * **`Dockerfile`'da Hassas Bilgileri Hard-Code Etmek**: Parolaları, API anahtarlarını veya diğer gizli bilgileri `Dockerfile`'a yazmak. Neden: İmaj halka açık hale gelirse güvenlik riski oluşturur. * **`latest` Tag'ini Üretimde Kullanmak**: İmaj etiketi olarak `latest` kullanmak. Neden: İmajın içeriği beklenmedik şekilde değişebilir, bu da üretimde istikrarsızlığa yol açar. Her zaman belirli bir versiyon etiketi (`postgres:16`, `mysql:8.0`) kullanın. * **Tek Konteynerde Birden Fazla Süreç Çalıştırmak**: Bir `Docker` konteynerinde hem veritabanını hem de uygulama sunucusunu çalıştırmak. Neden: Konteyner felsefesine aykırıdır (bir konteyner, bir süreç), ölçeklenebilirliği ve yönetimi zorlaştırır. * **Konteyneri `root` Olarak Çalıştırmak**: `Dockerfile`'da `USER` komutunu kullanmayarak veya `docker run --user root` ile konteyneri `root` olarak çalıştırmak. Neden: Güvenlik riski oluşturur, konteynerden kaçış senaryolarında ana sisteme zarar verebilir. ## Yaygın Hatalar ve Çözümleri: Docker Veritabanları (2026) `Docker` ile veritabanı çalıştırırken karşılaşılan bazı yaygın hatalar ve 2026 itibarıyla kanıtlanmış çözümleri aşağıda listelenmiştir: ### 1. Hata: Port Zaten Kullanımda (`port is already allocated`) * **Problem:** `docker run -p 5432:5432 ...` komutunu çalıştırdığınızda `Bind for 0.0.0.0:5432 failed: port is already allocated` gibi bir hata alırsınız. * **Sebep:** Ana makinenizin 5432 numaralı portu zaten başka bir uygulama veya veritabanı servisi tarafından kullanılıyor (örneğin, yerel olarak kurulu bir PostgreSQL). `Docker` bu porta bağlanamıyor. * **Çözüm:** Ya ana makinedeki çakışan servisi durdurun ya da `Docker` konteynerini farklı bir ana makine portuna bağlayın. Örneğin, 5433 portunu kullanın: ```bash docker run --name postgres-db-2026 -e POSTGRES_PASSWORD=mysecretpassword -p 5433:5432 -d postgres:16 ``` ### 2. Hata: Konteyner Anında Çıkıyor (`Exited (1) ...`) * **Problem:** `docker run` komutunu çalıştırdıktan hemen sonra `docker ps` komutunda konteynerin `Exited (1)` veya benzeri bir durumla çıktığını görüyorsunuz. * **Sebep:** Genellikle veritabanının başlatılması için gerekli ortam değişkenlerinin (örneğin `POSTGRES_PASSWORD`) eksik olması veya yanlış yapılandırılmasıdır. Veritabanı servisi başlatılamadığı için konteyner hemen kapanır. * **Çözüm:** `docker logs ` komutunu kullanarak konteynerin loglarını kontrol edin. Eksik ortam değişkenlerini veya yapılandırma hatalarını düzeltin. Örneğin: ```bash docker logs postgres-db-2026 # Çözüm: Ortam değişkenlerini kontrol edin ve doğru şekilde ayarlayın. docker run --name postgres-db-2026 -e POSTGRES_PASSWORD=mysecretpassword -p 5432:5432 -d postgres:16 ``` ### 3. Hata: Veri Kalıcılığı Sorunları (`data lost after container removal`) * **Problem:** Konteyneri silip yeniden oluşturduğunuzda veya güncellediğinizde veritabanı verilerinizin kaybolduğunu fark ediyorsunuz. * **Sebep:** Veritabanı verilerini kalıcı bir `Docker volume`'una veya `bind mount`'a bağlamamışsınız. Veriler konteynerin yazılabilir katmanında kalmış ve konteyner silindiğinde onunla birlikte gitmiş. * **Çözüm:** Veritabanı verileri için her zaman bir `Docker volume` kullanın. Volume'lar, konteynerin ömründen bağımsız olarak verileri ana makinede saklar: ```bash docker volume create pgdata-2026 docker run --name postgres-db-2026 -e POSTGRES_PASSWORD=mysecretpassword -p 5432:5432 -v pgdata-2026:/var/lib/postgresql/data -d postgres:16 ``` ### 4. Hata: Konteynerler Arası İletişim Sorunu (`Host not found`) * **Problem:** `docker-compose` ile birden fazla servis (uygulama ve veritabanı gibi) çalıştırıyorsunuz, ancak uygulama veritabanına bağlanamıyor ve `Host not found` veya `connection refused` hataları alıyorsunuz. * **Sebep:** Uygulama, veritabanı konteynerini yanlış bir adresle çağırmaya çalışıyor veya servisler aynı `Docker` ağına bağlı değil. Bazen `depends_on` olmadan uygulama veritabanı hazır olmadan başlamaya çalışır. * **Çözüm:** `docker-compose.yml` dosyanızda servislerin aynı ağda olduğundan emin olun ve uygulama servisinde veritabanı servisinin adını (`db` gibi) host olarak kullanın. Ayrıca `depends_on` kullanarak veritabanının uygulamadan önce başlamasını sağlayın: ```yaml # docker-compose.yml içinde services: app: # ... environment: DATABASE_URL: postgres://user:password@db:5432/mydatabase_2026 # 'db' servis adı depends_on: - db # db servisi başlamadan app başlamaz db: # ... ``` ## Performans Optimizasyonu: Docker ile Veritabanları (2026) `Docker` konteynerlerinde çalışan veritabanlarının performansını optimize etmek, 2026'da büyük ölçekli uygulamalar için kritik öneme sahiptir. İşte kanıtlanmış bazı teknikler: ### 1. Doğru Volume Tipini Seçin * **Problem:** Yanlış volume tipi seçimi, disk G/Ç (I/O) performansını olumsuz etkileyebilir. * **Çözüm:** `Docker volume`'ları g