31 Aralık 2025 Çarşamba

Next.js 15’te Server Actions ile Form İşleme: API Route Yazmadan Güvenli ve Hızlı Akış

Giriş: Neden Server Actions?

Next.js’in son sürümleriyle birlikte uygulama mimarisi “daha az kablo, daha çok iş” anlayışına yaklaştı. Bunların başında da Server Actions geliyor. Klasik yaklaşımda bir form gönderimini işlemek için API route yazmak, doğrulama yapmak, CSRF önlemleri düşünmek, sonra istemci tarafında fetch ile bağlanmak gerekiyordu. Server Actions, özellikle App Router kullanan projelerde, bu akışı sadeleştirerek form verisini doğrudan sunucu tarafında çalışan bir fonksiyona teslim etmenizi sağlıyor.

Bu yazıda, Next.js 15 (App Router) üzerinde Server Actions ile API yazmadan form işleme akışını kuracağız. Örnek senaryomuz basit bir “Bültene kayıt” formu olacak: e-posta doğrulama, rate limit mantığına uygun küçük bir kontrol ve sonuç mesajını kullanıcıya gösterme. Kod örnekleri TypeScript odaklıdır, fakat aynı mantık JavaScript ile de birebir uygulanır.

Ön Koşullar

Devam etmeden önce projede App Router kullanıyor olmanız ve Node.js sürümünüzün güncel olması gerekir. Ayrıca örnekte veri saklama katmanını basit tutacağız; dilerseniz Prisma, Drizzle veya doğrudan PostgreSQL ile genişletebilirsiniz. Ama amaç, Server Actions’ın form + doğrulama + sunucu tarafı işlem üçlüsünde neleri kolaylaştırdığını net görmek.

1) Server Action Fonksiyonunu Tanımlama

Server Actions’ın temel fikri, bir fonksiyonun sunucuda çalışacağını açıkça belirtmektir. Bu sayede fonksiyonunuz istemci paketine taşınmaz ve güvenli tarafta kalır. Genellikle app altında bir dosyada, örneğin app/actions/newsletter.ts gibi konumlandırılır.

app/actions/newsletter.ts:

Not: Aşağıdaki kod bloğunu Blogger HTML’inde göstermek için düz metin olarak paylaşıyorum.

Kod:

"use server";

type ActionState = { ok: boolean; message: string };

function isValidEmail(email: string) {

  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);

}

export async function subscribeNewsletter(prevState: ActionState, formData: FormData): Promise<ActionState> {

  const email = String(formData.get("email") ?? "").trim().toLowerCase();

  if (!email) return { ok: false, message: "E-posta alanı boş olamaz." };

  if (!isValidEmail(email)) return { ok: false, message: "Geçerli bir e-posta girin." };

  // Basit bir “oran sınırlama” fikri: aynı e-postayı kısa sürede tekrar alma

  // Gerçek projede Upstash/Redis veya benzeri bir katman önerilir.

  await new Promise((r) => setTimeout(r, 300)); // örnek gecikme

  // Burada DB’ye yazma veya üçüncü parti servise iletme yapılır

  return { ok: true, message: "Kaydınız alındı. Teşekkürler!" };

}

2) Formu Server Action’a Bağlama

Şimdi bu action’ı bir formun action özelliğine bağlayacağız. Next.js tarafında bu, “form submit” ile birlikte verinin otomatik olarak sunucu fonksiyonuna gitmesi demek. Eğer kullanıcıya durum mesajı göstermek istiyorsanız useActionState (veya proje yapılandırmanıza göre benzer state kancaları) oldukça pratik.

app/newsletter/page.tsx örneği:

Kod:

"use client";

import { useActionState } from "react";

import { subscribeNewsletter } from "../actions/newsletter";

const initialState = { ok: false, message: "" };

export default function NewsletterPage() {

  const [state, formAction, pending] = useActionState(subscribeNewsletter, initialState);

  return (

    <div>

      <h2>Bültene Katıl</h2>

      <form action={formAction}>

        <label>E-posta</label>

        <input name="email" type="email" placeholder="[email protected]" required />

        <button type="submit" disabled={pending}>

          {pending ? "Gönderiliyor..." : "Kaydol"}

        </button>

      </form>

      {state.message ? (

        <p><b>{state.ok ? "Başarılı:" : "Hata:"}</b> {state.message}</p>

      ) : null}

    </div>

  );

}

3) Güvenlik ve Üretim İpuçları

Server Actions API route ihtiyacını azaltır, ama güvenlik sorumluluğunu ortadan kaldırmaz. Öncelikle, sunucu tarafında çalışan fonksiyonlarınızda her zaman doğrulama yapın; istemci tarafındaki required gibi kontroller sadece kullanıcı deneyimidir, güvenlik değildir. İkinci olarak, bülten gibi uç noktalarda bot trafiği yoğun olur; bu yüzden gerçek projede rate limit’i Redis/Upstash gibi bir katmanla uygulamak mantıklıdır. Üçüncü olarak, e-posta kaydını bir veritabanına yazıyorsanız tekrarlı kayıtları engellemek için benzersiz indeks kullanın.

Performans tarafında da avantajlar var: fetch katmanı, ayrı endpoint, ekstra JSON serileştirme gibi adımlar azaldığı için akış sadeleşir. Ayrıca action’ın sunucu tarafında kalması, anahtar ve gizli bilgilerin istemciye sızma riskini ciddi biçimde düşürür. Buna rağmen üçüncü parti servis çağrıları yapıyorsanız (Mailchimp, Brevo, vb.), hata yönetimini iyi kurgulayın ve kullanıcıya ham hata mesajı döndürmeyin.

4) Sık Yapılan Hatalar

En sık görülen hata, action dosyasına "use server" eklemeyi unutmak veya action’ı istemci bileşeninde yanlış şekilde çağırmaktır. İkinci hata, form alan adlarının (örneğin name="email") action içinde okunan anahtarlarla uyuşmaması. Üçüncü hata ise, action içinde doğrulama yokken yalnızca istemci doğrulamasına güvenmek. Bu üç noktayı kontrol ettiğinizde, Server Actions akışı genellikle sorunsuz çalışır.

Sonuç

Next.js 15’te Server Actions, özellikle form temelli işlemlerde “API route yaz, fetch bağla, JSON dön” rutinini büyük ölçüde azaltıyor. Bu yaklaşım, hem kod tabanını sadeleştiriyor hem de hassas işlemleri doğal şekilde sunucu tarafında tutuyor. Buradaki bülten örneği küçük görünse de aynı mimariyi parola sıfırlama, ödeme sonrası kayıt, yönetim paneli formları ve veri güncelleme ekranları gibi daha kritik alanlara ölçekleyebilirsiniz.

30 Aralık 2025 Salı

Android Telefonda Private DNS ile Reklâm ve Takip Engelleme (AdGuard DNS/NextDNS) – Adım Adım Kurulum ve İnce Ayar

Private DNS Nedir ve Neden İşe Yarar?

Android 9 ve üzeri sürümlerde yer alan Private DNS (Özel DNS) özelliği, telefonunuzun DNS sorgularını şifreli şekilde (DoT – DNS over TLS) belirlediğiniz bir DNS sağlayıcısına yönlendirmenizi sağlar. Pratikte bu, hem ağ düzeyinde daha tutarlı bir gizlilik sunar hem de doğru bir DNS servisi seçtiğinizde reklâm, takip alanı ve zararlı alan adı filtreleme gibi avantajlar getirebilir. Üstelik uygulama yüklemeden çalıştığı için pil tüketimi ve performans açısından çoğu “VPN tabanlı reklâm engelleyici”ye göre daha hafiftir.

Bu yazıda, Android’de Private DNS’i kullanarak reklâm ve takip engelleme yaklaşımını, iki popüler seçenek olan AdGuard DNS ve NextDNS üzerinden anlatacağım. Ayrıca bazı uygulamaların (özellikle oyunlar ve reklam SDK’ları) engellemeye takılınca neler olabileceği ve nasıl ince ayar yapılacağına da değineceğim.

Yöntemin Artıları ve Sınırları

Artılar: Kurulumu birkaç dakikadır, root gerektirmez, ekstra uygulama çalıştırmadığı için genellikle daha stabil ve hızlıdır, her uygulamayı kapsar (tarayıcı eklentisi gibi sınırlı değildir). Sınırlar: DNS tabanlı engelleme, “alan adı” seviyesinde çalışır; yani bir uygulama reklâmları aynı alan adından servis ediyorsa engelleme etkisi sınırlı olabilir. Ayrıca bazı servisler DNS üzerinden izleme/telemetri göndermese bile uygulama içi ölçümleme devam edebilir. Yine de mobilde “en az eforla en çok etki” sağlayan yöntemlerden biridir.

Hangi DNS Servisini Seçmeli?

AdGuard DNS genellikle “kur ve unut” yaklaşımına uygundur. Varsayılan filtre setiyle reklâm ve takip alanlarının önemli bir kısmını engeller. Öte yandan NextDNS daha “ileri seviye” bir deneyim sunar: panel üzerinden filtre listelerini seçebilir, istatistikleri görebilir, beyaz liste (allowlist) ve kara liste (denylist) ile çok ince ayar yapabilirsiniz. Eğer uğraşmayı seviyorsanız NextDNS, kontrol hissini ciddi biçimde artırır.

Adım Adım: Android’de Private DNS Kurulumu

1) Ayarlar menüsünü açın: Telefonunuzda Ayarlar > Ağ ve internet (bazı arayüzlerde “Bağlantılar”) bölümüne girin.

2) Özel DNS’i bulun: Özel DNS veya Private DNS

3) “Özel DNS sağlayıcı ana bilgisayar adı” seçin: Seçenekler genelde “Kapalı”, “Otomatik” ve “Özel DNS sağlayıcı ana bilgisayar adı” şeklindedir. Üçüncüyü seçin.

4) Sağlayıcı alan adını girin: Aşağıdaki seçeneklerden birini yazıp kaydedin:

AdGuard DNS (genel): dns.adguard.com

AdGuard DNS (aile koruması): dns-family.adguard.com (uygun içerik filtreleri içerir)

NextDNS: NextDNS kullanacaksanız size özel bir alan adı verilir. Örnek format genelde xxxxxx.dns.nextdns.io şeklindedir (buradaki x’ler size özel kimliktir). Kendi panelinizde “Setup” bölümünde Android/Private DNS için verilen hostname’i kopyalayın.

Kurulumun Çalıştığını Nasıl Anlarsınız?

En basit kontrol, sık reklâm çıkan bir uygulama veya web sitesini açıp farkı gözlemlemektir; ancak bu her zaman güvenilir bir test değildir. Daha teknik bir doğrulama için tarayıcıdan DNS test sayfalarını kullanabilirsiniz. Ayrıca NextDNS kullanıyorsanız panelde Logs (günlükler) bölümünde cihazınızın yaptığı sorguları anlık görerek Private DNS’in aktif olduğundan emin olabilirsiniz.

İleri Seviye İnce Ayar: NextDNS ile Beyaz Liste/Kara Liste

NextDNS’in asıl gücü, “bir şey bozulduğunda” hızlıca düzeltmenize izin vermesidir. Örneğin bir bankacılık uygulaması ya da bir oyunun giriş ekranı takılı kalıyorsa sebep çoğunlukla bir alan adının engellenmesidir. Böyle bir durumda NextDNS panelinde sorgu kayıtlarına bakıp engellenen alan adını tespit edebilir, ilgili alan adını Allowlist (izin verilenler) tarafına ekleyerek sorunu çözebilirsiniz.

Benim önerim, önce “agresif” liste sayısını abartmadan başlamak. Özellikle “tracking” listeleri ile “reklâm” listelerini dengeli tutmak, hem reklâmı azaltır hem de uygulama uyumluluğunu artırır. Engelleme arttıkça bazı içeriklerin (örneğin uygulama içi haber akışları veya video önerileri) eksik yüklenmesi gibi yan etkiler görülebilir.

Olası Sorunlar ve Çözümleri

1) Wi‑Fi’a bağlanıyor ama internet yok: Bazı kurumsal ağlar veya oteller şifreli DNS’e izin vermeyebilir. Bu durumda geçici olarak Özel DNS’i “Otomatik”e alıp deneyin.

2) Bir uygulama çalışmıyor veya doğrulama ekranı gelmiyor: NextDNS kullanıyorsanız loglardan engellenen alan adını bulup Allowlist’e ekleyin. AdGuard DNS kullanıyorsanız geçici olarak Private DNS’i kapatıp test edin; sorun düzelirse DNS engellemesine takılan bir alan adı vardır.

3) YouTube reklamları hâlâ var mı? DNS tabanlı engelleme, YouTube gibi aynı alan adı üzerinden farklı içerik servis eden platformlarda sınırlı kalabilir. Private DNS’i “her şeyi çözen tek yöntem” gibi değil, genel reklâm ve takip azaltma katmanı olarak düşünmek daha gerçekçi olur.

Sonuç: Uygulamasız, Hafif ve Etkili Bir Katman

Android’de Private DNS ile reklâm ve takip engelleme, birkaç ayarla cihaz genelinde hissedilir bir temizlik sağlar. Özellikle mobil veri tüketimini azaltması, sayfa yüklemelerini hafifletmesi ve bazı takip alanlarını kesmesi günlük kullanımda fark yaratır. Basitlik istiyorsanız AdGuard DNS, kontrol ve ince ayar istiyorsanız NextDNS iyi birer seçenek. Kurulumu yaptıktan sonra bir-iki gün gözlemleyin; sorun yaşarsanız “Allowlist” yaklaşımıyla sistemi kendi kullanımınıza göre rafine edebilirsiniz.

29 Aralık 2025 Pazartesi

Windows 11’de WSL 2 ile Docker’ı Kurmak ve Performanslı Bir Geliştirme Ortamı Hazırlamak

WSL 2 + Docker neden bu kadar popüler oldu?

Windows üzerinde Linux tabanlı bir geliştirme ortamı kurmanın en pratik yollarından biri WSL 2 (Windows Subsystem for Linux). Üzerine bir de Docker eklediğinizde, hem Linux ekosistemindeki araçları kullanabilir hem de container tabanlı projeleri Windows’ta zahmetsizce çalıştırabilirsiniz. Bu yazıda, Windows 11’de WSL 2 kurulumundan Docker entegrasyonuna, performans ayarlarından sık yapılan hatalara kadar uçtan uca bir “how-to” rehberi bulacaksınız.

Ön koşullar ve kısa kontrol listesi

Başlamadan önce sisteminizin sanallaştırma desteğinin açık olduğundan emin olun. Görev Yöneticisi > Performans > CPU bölümünde “Sanallaştırma: Etkin” görmelisiniz. Değilse BIOS/UEFI üzerinden Intel VT-x ya da AMD-V etkinleştirilmelidir. Ayrıca Windows 11’in güncel sürümünü kullanmanız (özellikle WSL tarafında) daha az sürpriz çıkarır.

1) WSL 2’yi kurma ve varsayılanı WSL 2 yapma

En hızlı yöntem, PowerShell’i yönetici olarak açıp aşağıdaki komutu çalıştırmaktır. Bu komut WSL bileşenlerini kurar, çekirdeği indirir ve bir Linux dağıtımı yüklemenize yardımcı olur:

Komut: wsl --install

Kurulumdan sonra sistemi yeniden başlatın. Ardından WSL sürümünüzü ve dağıtımlarınızı kontrol edin:

Komut: wsl -l -v

Varsayılan sürümü WSL 2 yapmak için:

Komut: wsl --set-default-version 2

2) Dağıtım seçimi: Ubuntu ile başlamak

Yeni başlayanlar ve geniş topluluk desteği nedeniyle çoğu geliştirici WSL üzerinde Ubuntu tercih ediyor. Microsoft Store üzerinden “Ubuntu” kurabilir ya da komutla listeleyip yükleyebilirsiniz:

Komut: wsl --list --online

Komut: wsl --install -d Ubuntu

İlk açılışta Linux kullanıcı adı ve şifre belirleyeceksiniz. Burada seçtiğiniz kullanıcı, geliştirme süreçlerinde sürekli kullanılacağı için basit ama anlamlı bir isim seçmek işinizi kolaylaştırır.

3) Docker Desktop kurulumu ve WSL entegrasyonu

Windows 11 üzerinde en sorunsuz yol genellikle Docker Desktop kurmaktır. Kurulum sırasında “Use WSL 2 instead of Hyper-V” benzeri bir seçenek görürseniz WSL 2’yi tercih edin. Kurulum tamamlandıktan sonra Docker Desktop’ı açın ve şu ayarları kontrol edin:

Settings > General: WSL 2 tabanlı motor etkin olmalı.

Settings > Resources > WSL Integration: Kurduğunuz Ubuntu dağıtımı için entegrasyonu aktif edin.

Bu noktadan sonra Ubuntu terminalinde docker version ve docker ps komutlarını çalıştırarak her şeyin düzgün bağlandığını doğrulayabilirsiniz.

4) Performans için kritik öneri: Projeyi Linux dosya sisteminde tutun

WSL 2 ile en sık yapılan performans hatası, projeyi Windows dosya sisteminde (ör. C:\) tutup WSL içinden işlemektir. Bu, özellikle Node.js, PHP Composer veya büyük Git depolarında dramatik yavaşlamaya neden olur. Bunun yerine projenizi Ubuntu tarafında, örneğin /home/kullaniciadi/proje altında konumlandırın. Windows’tan erişmek isterseniz Dosya Gezgini’ne \\wsl$ yazarak WSL dosya sistemine girebilirsiniz.

5) Kaynak yönetimi: .wslconfig ile RAM/CPU sınırı koyma

Docker container’ları ve WSL 2 birlikte çalışırken bazen sistem RAM’ini gereğinden fazla tüketebilir. Bu durumda Windows kullanıcı profiliniz altına .wslconfig dosyası oluşturup kaynak sınırı koyabilirsiniz. Dosya yolu genellikle C:\Users\KullaniciAdiniz\.wslconfig şeklindedir. İçeriği örnek olarak şu mantıkta olabilir: RAM limit, CPU çekirdeği, swap boyutu. Değişiklik sonrası WSL’yi kapatıp açmanız gerekir:

Komut: wsl --shutdown

Bu ayar, özellikle aynı anda IDE, tarayıcı ve container’lar açıkken sistemin nefes almasını sağlar.

6) Port yönlendirme ve yerel geliştirme

Docker ile ayağa kaldırdığınız servisleri (ör. 3000, 8080, 5432) Windows üzerinden de kullanmak isteyeceksiniz. Genel senaryoda container portlarını -p ile publish ettiğinizde Windows tarafında localhost üzerinden erişebilirsiniz. Yine de bazı ağ senaryolarında güvenlik yazılımları veya kurumsal politikalar trafiği engelleyebilir. Sorun yaşarsanız ilk kontrol noktası Windows Güvenlik Duvarı ve Docker Desktop’ın network ayarları olmalıdır.

7) Sık karşılaşılan sorunlar ve hızlı çözümler

Docker çalışmıyor / daemon’a bağlanamıyor: Docker Desktop’ın açık olduğundan ve ilgili dağıtımda WSL entegrasyonunun aktif edildiğinden emin olun. Ardından Ubuntu terminalinde yeniden deneyin.

Disk şişmesi: Uzun süre kullanılan Docker ortamlarında image ve volume birikir. Düzenli aralıklarla gereksiz kaynakları temizlemek için docker system prune (dikkatli kullanın) faydalı olabilir.

Git performansı düşük: Proje konumu çoğu zaman sebep olur. Repo’yu Windows yerine Linux dosya sistemine taşıyın.

Sonuç: Windows’ta Linux konforu, Docker ile taşınabilirlik

WSL 2 + Docker ikilisi, Windows 11 üzerinde modern geliştirme akışlarının neredeyse tamamını kapsayan güçlü bir kombinasyon sunuyor. Doğru kurulum ve birkaç performans ayarıyla; container tabanlı projeleri daha hızlı çalıştırabilir, bağımlılık karmaşasını azaltabilir ve ekip içinde tutarlı bir ortam sağlayabilirsiniz. Özellikle projelerinizi WSL dosya sisteminde tutmak ve kaynak yönetimini doğru yapmak, bu kurulumdan alacağınız verimi belirgin biçimde artırır.

28 Aralık 2025 Pazar

Windows 11’de WSL2 ile Docker Desktop’sız Geliştirici Ortamı Kurulumu (Adım Adım)

Docker Desktop olmadan neden Docker?

Windows 11’de Docker kullanmanın en popüler yolu Docker Desktop. Ancak özellikle kurumsal cihazlarda lisans politikaları, performans beklentisi veya daha “hafif” bir kurulum isteği nedeniyle alternatif arayan çok kişi var. Bu yazıda, WSL2 (Windows Subsystem for Linux) üzerinde Docker Engine kurarak, Docker Desktop’a ihtiyaç duymadan konteyner tabanlı bir geliştirme ortamını nasıl oluşturabileceğinizi adım adım anlatacağım. Hedefimiz: Windows’ta terminalden yönetilen, güncel ve performanslı bir Docker deneyimi.

Ön koşullar: Neler gerekli?

Bu rehber için Windows 11 kullanmanız önerilir (Windows 10’da da çalışır). Yönetici yetkisine sahip olmanız, PowerShell’i açabilmeniz ve Microsoft Store’dan bir Linux dağıtımı kurabilmeniz yeterli. Ayrıca BIOS/UEFI’de sanallaştırmanın açık olması gerekir. Kurulum sırasında komutları kopyalayıp yapıştırmanız işleri hızlandırır.

1) WSL2’yi etkinleştirme ve Ubuntu kurma

Önce WSL2’yi açalım. PowerShell’i Yönetici olarak çalıştırın ve şu komutu girin:

wsl --install

Bu komut genellikle WSL bileşenlerini etkinleştirir ve varsayılan dağıtım olarak Ubuntu’yu kurar. Eğer sisteminizde WSL zaten kuruluysa, sürümü kontrol etmek için:

wsl -l -v

Listede dağıtımınızın sürümü 2 görünmelidir. Değilse şu komutla yükseltebilirsiniz:

wsl --set-version Ubuntu 2

2) Ubuntu içinde temel güncellemeler

Başlat menüsünden Ubuntu’yu açın ve paket listesini güncelleyin:

sudo apt update && sudo apt upgrade -y

Bu adım, Docker kurulumu sırasında bağımlılık sorunlarını azaltır. Ardından gerekli yardımcı paketleri yükleyelim:

sudo apt install -y ca-certificates curl gnupg lsb-release

3) Docker Engine kurulumu (Ubuntu/WSL2)

WSL2 üzerinde en sağlıklı yöntem, Docker’ı Docker’ın resmi deposundan kurmaktır. Önce anahtar ve depo ekleyelim:

sudo install -m 0755 -d /etc/apt/keyrings

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

sudo chmod a+r /etc/apt/keyrings/docker.gpg

echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo $VERSION_CODENAME) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Şimdi Docker paketlerini kuralım:

sudo apt update

sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

4) Docker’ı root’suz (daha rahat) kullanma

Varsayılan olarak Docker komutları root yetkisi ister. Sürekli sudo yazmamak için kullanıcıyı docker grubuna ekleyin:

sudo usermod -aG docker $USER

Ardından Ubuntu oturumunu kapatıp tekrar açın (WSL penceresini kapatmak yeterli). Not: Bazı sistemlerde değişikliğin etkinleşmesi için Windows tarafında şu komutla WSL’yi yeniden başlatmak gerekebilir:

wsl --shutdown

5) Docker servisinin WSL2’de başlatılması

WSL dağıtımlarında systemd her zaman varsayılan olmayabilir. Windows 11’de güncel WSL sürümleri systemd desteği sunuyor. Eğer kullanmak isterseniz Ubuntu içinde /etc/wsl.conf dosyasını oluşturup şu satırları ekleyin:

[boot]
systemd=true

Sonra Windows’ta wsl --shutdown çalıştırıp Ubuntu’yu yeniden açın. Ardından Docker servis durumunu kontrol edin:

systemctl status docker

Aktif değilse başlatın:

sudo systemctl enable --now docker

6) Kurulum testi: İlk konteynerinizi çalıştırın

Şimdi her şeyin çalıştığını doğrulamak için klasik testi yapalım:

docker run --rm hello-world

Çıktıda Docker’ın başarıyla çalıştığını belirten bir mesaj görmelisiniz. Ardından Compose eklentisini test etmek için sürüme bakabilirsiniz:

docker compose version

7) Windows ile dosya performansı: Küçük ama kritik bir ipucu

WSL2 ile Docker kullanırken en çok performans kaybı, proje dosyalarını /mnt/c altında (Windows dosya sistemi) tutunca yaşanır. Özellikle Node.js, PHP veya Python gibi çok sayıda küçük dosya okuyan projelerde fark dramatiktir. En iyi pratik: projeyi Ubuntu dosya sisteminde (ör. /home/kullanici/proje) tutmak ve editörü (VS Code gibi) WSL eklentisiyle oradan açmak. Böylece I/O gecikmeleri düşer, konteyner build süreleri kısalır.

Sonuç: Hafif, hızlı ve kontrol sizde

Bu yöntemle Docker Desktop kullanmadan, WSL2 üzerinde güncel bir Docker Engine kurmuş oldunuz. Avantajları net: daha az arka plan servisi, daha yalın bir kurulum ve Linux’a daha yakın bir çalışma ortamı. Dezavantaj olarak ise bazı GUI odaklı Desktop özellikleri (tek tıkla Kubernetes, bazı entegrasyonlar) sizden ek kurulum isteyebilir. Yine de terminal seven geliştiriciler için bu kurulum, Windows 11 üzerinde konteyner tabanlı geliştirme yapmanın en pratik yollarından biri.

27 Aralık 2025 Cumartesi

Windows 11’de WSL 2 ile Docker Desktop Kullanmadan Docker Kurulumu ve İnce Ayar Rehberi

Docker’ı Windows’ta “hafif” çalıştırmak neden önemli?

Windows 11 üzerinde konteyner geliştirme yapanların büyük kısmı Docker Desktop ile başlıyor. Ancak zamanla kaynak tüketimi, otomatik güncellemeler, kurumsal lisans gereksinimleri veya arka planda çalışan servislerin fazlalığı gibi sebeplerle daha “temiz” bir kurulum arayışı doğuyor. Bu yazıda, WSL 2 (Windows Subsystem for Linux) kullanarak Docker’ı Docker Desktop’a ihtiyaç duymadan kurmayı, performans ve ağ ayarlarını ince ayarlamayı ve günlük kullanımda dikkat edilmesi gereken noktaları adım adım ele alacağım.

1) Ön koşullar: WSL 2 ve Linux dağıtımı

Öncelikle Windows 11’de WSL 2’nin aktif olması gerekiyor. Microsoft Store üzerinden Ubuntu 22.04/24.04 gibi güncel bir dağıtım kurmanız önerilir. WSL tarafında çalışacağımız için, komutların büyük kısmı Ubuntu terminalinde çalıştırılacak. Kurulumdan sonra Ubuntu’yu açıp güncellemeleri almak iyi bir başlangıçtır:

sudo apt update && sudo apt upgrade -y

WSL sürümünüzün 2 olduğundan emin olmak için Windows Terminal (PowerShell) tarafında şu komutu kullanabilirsiniz: wsl -l -v. Dağıtımınız “Version 2” görünmüyorsa WSL 2’ye çevirmek gerekir.

2) Docker Engine kurulumu (Docker Desktop olmadan)

Docker’ı WSL içindeki Ubuntu’ya kurduğumuzda aslında Docker Engine (dockerd) Linux içinde çalışır. Bu yaklaşımın avantajı, Windows tarafında ekstra arayüz ve servis yükü olmadan konteyner çalıştırabilmenizdir.

Ubuntu üzerinde önerilen yöntem, Docker’ın resmi deposunu eklemektir. Sırasıyla şu komutları çalıştırın:

sudo apt-get update

sudo apt-get install -y ca-certificates curl gnupg

sudo install -m 0755 -d /etc/apt/keyrings

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

sudo chmod a+r /etc/apt/keyrings/docker.gpg

echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo $VERSION_CODENAME) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt-get update

Ardından Docker bileşenlerini kurun:

sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

3) WSL’de systemd ve Docker servisinin yönetimi

Güncel WSL sürümlerinde systemd desteği mevcut. Docker servisinin otomatik ve sorunsuz başlaması için systemd’yi etkinleştirmek işleri kolaylaştırır. Ubuntu içinde /etc/wsl.conf dosyasını açıp aşağıdakini ekleyin:

[boot]
systemd=true

Sonra Windows tarafında WSL’i kapatıp yeniden başlatın: wsl --shutdown. Ubuntu’yu tekrar açtıktan sonra Docker’ı başlatıp durumunu kontrol edebilirsiniz:

sudo systemctl enable --now docker

systemctl status docker

4) “sudo” derdini bitirmek: docker grubuna kullanıcı ekleme

Her docker komutunda sudo yazmak istemiyorsanız, kullanıcıyı docker grubuna alın:

sudo usermod -aG docker $USER

Değişikliğin uygulanması için terminal oturumunu kapatıp açın. Ardından test:

docker run --rm hello-world

5) Docker Compose ve modern kullanım

Yeni yaklaşımda “docker-compose” ayrı bir ikili yerine çoğunlukla docker compose alt komutu olarak gelir. Kurulumla birlikte “Compose plugin” geldiği için şu şekilde kullanabilirsiniz:

docker compose version

Örneğin basit bir servis ayağa kaldırmak için bir klasörde compose.yaml oluşturup docker compose up -d komutuyla çalıştırabilirsiniz. Bu yöntem, yerel geliştirmede Nginx, Postgres, Redis gibi servisleri hızlıca yönetmek için oldukça pratik.

6) Performans ve dosya sistemi: projeyi nereye koymalı?

WSL 2’de performansı belirleyen en kritik detaylardan biri dosyaların konumudur. Projeyi Windows dosya sisteminde (örn. /mnt/c/...) tutmak mümkündür ama yoğun I/O yapan Node.js veya Python projelerinde yavaşlama görebilirsiniz. En iyi performans için projeyi WSL dosya sisteminde, örneğin ~/projects altında tutmak genellikle daha iyi sonuç verir.

7) Port yönlendirme ve erişim mantığı

Docker konteynerleri WSL içinde çalıştığı için portlar WSL ağı üzerinden yayınlanır. Windows 11’de çoğu senaryoda localhost erişimi otomatik çalışır; örneğin -p 8080:80 ile Nginx çalıştırdığınızda tarayıcıdan http://localhost:8080 ile erişebilirsiniz. Yine de bazı ağ senaryolarında WSL’in IP’sini öğrenmek gerekebilir: ip addr veya hostname -I iş görür.

8) Bu yaklaşımın artıları ve eksileri (kısa inceleme)

Artılar: Daha az arka plan bileşeni, daha düşük kaynak tüketimi, daha “Linux’a yakın” çalışma biçimi, lisans ve GUI bağımlılığının azalması.

Eksiler: Docker Desktop’taki bazı kolaylıklar (tek tıkla Kubernetes, görsel arayüz, otomatik entegrasyonlar) yoktur. Ayrıca WSL ve Linux ağ/dosya sistemi mantığına biraz daha hâkim olmanız gerekir.

Sonuç

Eğer amacınız Windows 11 üzerinde modern bir geliştirme ortamı kurarken Docker’ı daha kontrollü, daha hafif ve daha “geliştirici dostu” biçimde kullanmaksa, WSL 2 + Docker Engine yaklaşımı güçlü bir alternatiftir. Kurulumu tamamladıktan sonra en kritik iki noktayı aklınızda tutun: projeleri mümkünse WSL dosya sisteminde tutmak ve systemd ile Docker servisinin yönetimini düzgün yapmak. Bu sayede Docker Desktop’sız da günlük iş akışınızı sorunsuz şekilde sürdürebilirsiniz.

26 Aralık 2025 Cuma

Windows 11’de WSL2 ile Docker Desktop Kurulumu: Yerel Kubernetes ve Hızlı Geliştirme Ortamı

WSL2 + Docker ile neden uğraşalım?

Windows 11 kullanırken Linux tabanlı geliştirme araçlarını “gerçek” bir Linux deneyimine yakın şekilde çalıştırmanın en pratik yolu WSL2’dir. WSL2 üzerine Docker kurduğunuzda, hem container’larınızı yerel olarak hızlıca ayağa kaldırabilir hem de isterseniz Docker Desktop’ın sağladığı entegre Kubernetes’i kullanarak mikro servis denemeleri yapabilirsiniz. Bu yazıda hedefimiz; Windows 11’de WSL2’yi etkinleştirmek, uygun bir Linux dağıtımı kurmak, Docker Desktop’ı WSL2 altyapısıyla çalıştırmak ve yaygın hatalara karşı kontrol listesi oluşturmak.

Ön koşullar

Gerekenler: Windows 11 (güncel), yönetici yetkisi, BIOS/UEFI’de sanallaştırmanın açık olması (Intel VT-x/AMD-V), en az 8 GB RAM (Kubernetes açacaksanız 16 GB daha rahat). Ayrıca kurulum sırasında internet bağlantısı şart.

1) WSL2’yi etkinleştirin

Önce Windows özellikleri tarafında WSL2 altyapısını açacağız. En hızlı yöntem PowerShell’i yönetici olarak çalıştırıp aşağıdaki komutu kullanmaktır:

PowerShell (Yönetici): wsl --install

Bu komut gerekli bileşenleri kurar ve varsayılan bir Linux dağıtımı yükler. Kurulum bitince bilgisayarı yeniden başlatmanız istenebilir. Halihazırda WSL yüklüyse sürümü doğrulamak için şu komutu çalıştırın:

PowerShell: wsl -l -v

Çıktıda dağıtımınızın VERSION sütununda 2 görünmesi gerekir. Eğer 1 ise, WSL2’ye çevirmek için:

PowerShell: wsl --set-version Ubuntu 2

2) Ubuntu’yu güncelleyin ve temel araçları kurun

Ubuntu terminalini açın (Başlat menüsünden “Ubuntu”). İlk iş paketleri güncellemek iyi bir alışkanlıktır:

Ubuntu: sudo apt update && sudo apt -y upgrade

Git ve bazı yardımcı paketler de işinizi kolaylaştırır:

Ubuntu: sudo apt -y install git ca-certificates curl

3) Docker Desktop’ı kurun ve WSL2 entegrasyonunu açın

Docker’ı Windows tarafında Docker Desktop ile yönetmek, ağ, proxy, GUI ayarları ve Kubernetes gibi özellikleri tek yerden kontrol etmenizi sağlar. Resmi kurulum dosyasını Docker’ın web sitesinden indirip standart şekilde kurabilirsiniz. Kurulum sırasında veya sonrasında Docker Desktop içinde şu ayarları kontrol edin:

Ayarlar > General: “Use the WSL 2 based engine” seçeneği açık olmalı.

Ayarlar > Resources > WSL Integration: “Enable integration with my default WSL distro” açık olmalı ve Ubuntu dağıtımınız seçili olmalı.

Bu noktadan sonra Ubuntu terminalinde Docker komutlarının çalıştığını test edin:

Ubuntu: docker version

Eğer sürüm bilgisi geliyorsa bağlantı tamamdır. Basit bir test container’ı çalıştırabilirsiniz:

Ubuntu: docker run --rm hello-world

4) Yerel Kubernetes’i etkinleştirme (isteğe bağlı)

Mikro servis mimarisiyle uğraşıyorsanız, yerel Kubernetes büyük kolaylık. Docker Desktop içinde:

Ayarlar > Kubernetes: “Enable Kubernetes” seçeneğini açın ve kurulumu bekleyin. İlk kurulum birkaç dakika sürebilir.

Kurulum tamamlanınca kubectl komutunu doğrulayın. Docker Desktop genellikle kubectl’i beraberinde getirir. Ubuntu içinde:

Ubuntu: kubectl version --client

Ardından cluster durumuna bakın:

Ubuntu: kubectl get nodes

Tek node “Ready” görünüyorsa, yerel Kubernetes ortamınız hazırdır.

5) Performans için kritik ipuçları

WSL2 üzerinde Docker kullanırken en sık yapılan hata, proje dosyalarını Windows dosya sistemi altında (ör. /mnt/c/...) tutmaktır. Bu, özellikle Node.js, Python veya büyük bağımlılık ağaçlarında ciddi yavaşlamaya neden olur. En iyi pratik, projeleri Linux dosya sistemi içinde (ör. ~/projects) saklamaktır.

Ayrıca Docker Desktop’ta Resources bölümünden CPU/RAM sınırlarını iş yükünüze göre ayarlayın. Kubernetes açıkken RAM tüketimi artar; 8 GB sistemlerde aynı anda çok container çalıştırmak zorlaşabilir.

6) Yaygın sorunlar ve hızlı çözüm listesi

“WSL 2 installation is incomplete”: Windows Update’i çalıştırın, ardından “wsl --update” komutunu deneyin.

Docker çalışıyor ama Ubuntu’da “Cannot connect to the Docker daemon”: Docker Desktop’ta WSL Integration açık mı kontrol edin. Ubuntu’yu kapatıp yeniden açın; gerekirse “wsl --shutdown” ile WSL’yi yeniden başlatın.

Kubernetes pod’ları sürekli Pending: Sistem kaynakları yetersiz olabilir. Docker Desktop kaynak limitlerini yükseltin veya Kubernetes’i kapatın.

Disk şişmesi: Kullanılmayan imaj ve volume’ları düzenli temizleyin: “docker system prune” (dikkatli kullanın) ve büyük volume’ları gözden geçirin.

Sonuç

Windows 11’de WSL2 ile Docker Desktop kurduğunuzda, hem Linux uyumlu geliştirme akışını yakalarsınız hem de container tabanlı projeleri hızlıca test edebilirsiniz. Üstelik tek tıkla Kubernetes açıp kapatabilmek, yerel ortamda prod’a benzer senaryoları denemenin en pratik yollarından biridir. Dosyaları Linux tarafında tutmak ve kaynak ayarlarını doğru yapmak, bu kurulumdan maksimum verimi almanızı sağlar.

25 Aralık 2025 Perşembe

WebAssembly ile Tarayıcıda Rust Çalıştırma: Performans Odaklı Kurulum ve Gerçekçi Kullanım Senaryoları

WebAssembly (Wasm) Nedir ve Neden Rust?

Tarayıcıda “native’e yakın” hız hedefleyen herkesin yolu bir noktada WebAssembly (Wasm) ile kesişiyor. Wasm; JavaScript’in yerine geçmekten çok, onu tamamlamak için tasarlanmış taşınabilir bir düşük seviye bytecode formatı. Performansın kritik olduğu yerlerde (görüntü işleme, kriptografi, veri sıkıştırma, oyun motoru parçaları, büyük veri dönüşümleri vb.) JavaScript tarafında zorlanan işlemleri Wasm’a taşıyabiliyorsunuz.

Bu noktada Rust pratik bir tercih: bellek güvenliği yaklaşımı, güçlü derleyici optimizasyonları ve Wasm ekosisteminin olgunlaşması sayesinde tarayıcı hedefleri için oldukça düzgün bir geliştirme deneyimi sunuyor. Bu yazıda, Blogger’da yayınlanabilir şekilde, sıfırdan Rust + Wasm projesi hazırlayıp tarayıcıda çalıştırmayı ve gerçek hayatta işinize yarayacak püf noktalarını adım adım ele alıyorum.

Ön Koşullar

Kuruluma başlamadan önce sisteminizde Rust ve Node.js bulunmalı. Rust için resmi kurulum aracı rustup yeterli. Node.js tarafında LTS sürüm tercih edin. Ayrıca yerel geliştirme için basit bir web sunucusu kullanacağız (Vite veya benzeri). Örnekleri macOS, Linux ve Windows’ta uygulayabilirsiniz; komutlar büyük ölçüde aynı.

1) Rust’ı Wasm Hedefiyle Hazırlama

İlk adım olarak Rust’ın WebAssembly hedefini ekleyin. Terminalde şu komutu çalıştırın:

rustup target add wasm32-unknown-unknown

Bu hedef, Rust kodunu Wasm bytecode’una derlemenizi sağlar. Ancak tarayıcıyla daha rahat entegrasyon için çoğu projede bir adım daha ileri gidip wasm-bindgen ve wasm-pack kullanılır. wasm-pack, proje iskeletini yönetir, derler ve JavaScript bağlayıcılarını üretir.

2) wasm-pack Kurulumu ve Proje Oluşturma

wasm-pack’i Rust’ın paket yöneticisi Cargo ile kurun:

cargo install wasm-pack

Ardından yeni bir kütüphane projesi oluşturun:

cargo new --lib hizli-wasm

Klasöre girip Cargo.toml dosyanıza wasm-bindgen bağımlılığını ekleyin. Dosyanın ilgili kısmı kabaca şöyle olmalı:

[dependencies]
wasm-bindgen = "0.2"

3) Rust Kodunu Tarayıcıya Açma (wasm-bindgen)

src/lib.rs içine basit ama ölçülebilir bir örnek koyun. Örneğin bir dizi içindeki sayıları filtreleyip toplamak gibi CPU’ya yük bindiren işleri Wasm’a taşımak yaygın bir yaklaşım. Örnek mantık: dışarıdan bir sayı listesi al, tek sayıları süz, kalanları topla. wasm-bindgen ile fonksiyonu dışa açabilirsiniz:

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub fn ciftleri_topla(nums: Vec<u32>) -> u32 {
  nums.into_iter().filter(|n| n % 2 == 0).sum()
}

Buradaki önemli nokta: Tarayıcıya “güvenli” ve “anlaşılır” bir arayüz vermek. Karmaşık veri tipleri mümkündür ama başlangıçta sayılar ve basit diziler üzerinden ilerlemek, performans ve hata ayıklama açısından daha stabildir.

4) Derleme: Wasm Paketini Üretme

Proje klasöründe şu komutu çalıştırın:

wasm-pack build --target web

Komut tamamlandığında pkg adlı bir klasör oluşur. İçinde .wasm dosyası, JavaScript sarmalayıcısı ve package.json benzeri çıktılar yer alır. Bu klasör, web projenizde “modül” gibi kullanılabilir.

5) Vite ile Basit Bir Web Arayüzü

Wasm çıktısını hızlıca test etmek için Vite iyi bir seçenek. Ayrı bir klasörde Vite projesi oluşturun:

npm create vite@latest web-arayuz -- --template vanilla

Klasöre girip bağımlılıkları kurun:

cd web-arayuz
npm install

Ardından Rust projenizdeki pkg klasörünü web-arayuz içine kopyalayın (örneğin web-arayuz/src/pkg). Sonra src/main.js içinde Wasm modülünü içe aktarın:

import init, { ciftleri_topla } from "./pkg/hizli_wasm.js";

async function run() {
  await init();
  const nums = Array.from({ length: 100000 }, (_, i) => i);
  const sonuc = ciftleri_topla(nums);
  console.log("Sonuç:", sonuc);
}

run();

Son olarak geliştirme sunucusunu başlatın:

npm run dev

Tarayıcı konsolunda sonucu görüyorsanız temel entegrasyon tamamdır. Buradan sonra UI ekleyebilir, girdileri form üzerinden alabilir ya da daha gerçekçi veri işleme senaryolarına geçebilirsiniz.

Performans ve Gerçek Hayat İpuçları

Wasm her zaman otomatik olarak “daha hızlı” demek değildir. Kazanç, işin türüne göre değişir. Sık çağrılan küçük fonksiyonlarda JavaScript ↔ Wasm sınırı (FFI) maliyeti baskın hale gelebilir. Bu yüzden çok küçük işleri binlerce kez çağırmak yerine, mümkünse işi Wasm tarafında daha “toplu” yapacak şekilde tasarlayın.

Ayrıca tarayıcı tarafında bellek kopyaları önemli bir maliyet kalemidir. Büyük dizileri sürekli Rust’a geçirip geri almak yerine, veri akışını minimize edin. Daha ileri senaryolarda TypedArray ile bellek paylaşımı ve wasm-bindgen’in sunduğu yardımcılar gündeme gelir; fakat temel kurulum oturduktan sonra bu optimizasyonlara geçmek daha sağlıklı olur.

Hata Ayıklama ve Yaygın Sorunlar

En sık görülen problem, yanlış hedefle derleme veya modülün doğru yüklenmemesidir. Vite gibi bundler’lar ESM modüllerle iyi çalışır; bu yüzden wasm-pack build --target web seçimi önemlidir. Eğer “Failed to load module script” gibi hatalar alıyorsanız, dosya yollarını ve modül import biçimini kontrol edin.

Bir diğer konu da sürüm uyumsuzluklarıdır. wasm-bindgen sürümü yükseldiğinde, eski çıktılarla karışıklık yaşayabilirsiniz. Böyle durumlarda pkg klasörünü temizleyip yeniden derlemek genellikle sorunu çözer.

Sonuç

Rust ile WebAssembly kullanarak tarayıcıya performans odaklı bir modül eklemek, doğru kurulum yapıldığında şaşırtıcı derecede pratik. Bu rehberde Rust hedefini ekledik, wasm-pack ile derleme çıktısı ürettik ve Vite üzerinden tarayıcıda çalıştırdık. Buradan sonra gerçek bir uygulamada kriptografi, görüntü dönüştürme, sıkıştırma veya büyük veri filtreleme gibi alanlarda Wasm’ın avantajını daha net görmeye başlayacaksınız.

24 Aralık 2025 Çarşamba

Web Push Bildirimleri Kurulumu: Firebase Cloud Messaging ile PWA’nıza Bildirim Ekleyin (Adım Adım)

Web Push nedir ve neden hâlâ önemli?

Web Push bildirimleri, kullanıcı tarayıcıyı kapatsa bile (izin verdiği sürece) tarayıcı üzerinden bildirim göndermenizi sağlar. Özellikle PWA (Progressive Web App) kullanan projelerde kullanıcıyı geri çağırmak, kampanya duyurmak veya kritik olayları bildirmek için hâlâ en etkili yöntemlerden biridir. Bu yazıda güncel ve pratik bir yaklaşım olarak Firebase Cloud Messaging (FCM) ile web push bildirimlerini nasıl kuracağınızı anlatacağım.

Ön koşullar ve dikkat edilmesi gerekenler

Kuruluma başlamadan önce şu maddeleri kontrol edin: (1) Siteniz HTTPS üzerinden yayınlanmalı. (2) Kullanıcı izni olmadan bildirim gönderemezsiniz; izin isteme akışını doğru tasarlayın. (3) Push, tarayıcı ve platforma göre değişir: Android’de Chrome oldukça sorunsuzken, iOS tarafında Web Push desteği sürüm ve kurulum tipine göre farklı davranabilir. (4) Bu öğretici, istemci tarafta JavaScript ve Service Worker, sunucu tarafta ise token yönetimi mantığını esas alır.

1) Firebase projesi oluşturma ve Web uygulaması ekleme

Firebase Console’a girip yeni bir proje oluşturun. Proje hazır olunca “Project settings” üzerinden “Your apps” bölümünde bir Web App ekleyin. Firebase size bir yapılandırma nesnesi (apiKey, authDomain, projectId vb.) verecek. Bu bilgileri istemci tarafta kullanacağız. Ardından “Cloud Messaging” sekmesinden bir VAPID key (Web Push certificates) üretin. Bu anahtar, tarayıcıların push aboneliğini doğrulamak için kullanılır ve istemci tarafında gerekecek.

2) Projeye Firebase SDK ekleme (modüler yaklaşım)

Blogger’da veya klasik bir web projesinde modüler Firebase SDK kullanımında iki seçenek var: (a) Paket yöneticisi (npm) ile derlenmiş proje, (b) CDN üzerinden modül import. Basit senaryoda CDN işinizi görür. Örneğin bir “app.js” dosyasında Firebase App ve Messaging modüllerini içeri alıp yapılandırmayı başlatırsınız. Önemli nokta: Bildirim için messaging modülünü doğru import etmek ve tarayıcı desteğini kontrol etmektir.

3) Service Worker dosyasını hazırlama (firebase-messaging-sw.js)

Web Push’un kalbi Service Worker’dır. Kök dizinde firebase-messaging-sw.js gibi bir dosya oluşturun. Bu dosya arka planda gelen mesajları yakalar. Arka plan bildirimi göstermek için “onBackgroundMessage” benzeri bir dinleyici kullanılır. Burada bildirimin başlığı, gövdesi ve tıklama davranışı gibi alanları tanımlayabilirsiniz. Service Worker dosyanızın mutlaka sitenin köküne veya kapsamı doğru ayarlanmış bir dizine konumlandığından emin olun; aksi halde tarayıcı bildirimleri doğru scope’ta yakalayamaz.

4) Tarayıcıdan izin isteme ve FCM token alma

İstemci tarafta kullanıcıdan bildirim izni istemeniz gerekir. Burada yapılan en büyük hata, sayfa açılır açılmaz izin istemektir. Bunun yerine kullanıcıya bir değer önerin: “Sipariş güncellemeleri için bildirimleri aç” gibi. Kullanıcı izin verince FCM üzerinden bir registration token alırsınız. Bu token’ı sunucunuza gönderip kullanıcı hesabı, cihaz veya abonelik tercihleriyle ilişkilendirmeniz gerekir. Token yönetimini doğru yapmazsanız, aynı kullanıcıda birden fazla token birikir ve gereksiz bildirim gönderimleri oluşur.

5) Sunucu tarafında bildirim gönderme mantığı

FCM ile push göndermenin iki yolu öne çıkar: (1) Firebase Console’dan test amaçlı gönderim, (2) Sunucudan FCM HTTP v1 API ile programatik gönderim. Üretim senaryosunda ikinci yöntem şarttır. Bunun için bir servis hesabı (service account) ile OAuth 2.0 üzerinden erişim token’ı alıp FCM endpoint’ine istek atarsınız. Mesaj gövdesinde hedef olarak token (tek cihaz), topic (kanal) veya condition (mantıksal filtre) kullanabilirsiniz. Ayrıca web tarafında bildirim göstermek için payload içinde notification ve/veya data alanlarını doğru kurgulamak önemlidir.

6) İleri seviye ipuçları: Topic, segmentasyon ve ölçüm

Web push’u “herkese aynı bildirim” seviyesinde bırakırsanız kullanıcılar hızlıca izinleri kapatır. Daha iyi bir yaklaşım, kullanıcının tercihine göre topic aboneliği yaptırmaktır: örneğin “indirimler”, “blog”, “stok” gibi kanallar. Böylece sadece ilgili kitleye bildirim gider. Bir diğer ileri seviye konu da ölçümdür: Bildirimin tıklanma oranı (CTR) ve dönüşümünü takip etmek için linklere UTM parametreleri ekleyin ve Analytics tarafında kampanyaları ayrı raporlayın. Ayrıca Service Worker’da “notificationclick” event’ini yakalayıp kullanıcıyı doğru sayfaya yönlendirmek, deneyimi ciddi şekilde iyileştirir.

7) Sık karşılaşılan sorunlar ve hızlı çözümler

Token alınamıyor: VAPID anahtarını doğru kullandığınızdan ve Notification izninin “granted” olduğundan emin olun. Service Worker çalışmıyor: Dosya yolu/scope hatalarını kontrol edin; tarayıcı “Application” sekmesinden kayıt durumuna bakın. Bildirim geliyor ama tıklayınca açılmıyor: Service Worker’daki “notificationclick” içinde doğru URL ve focus mantığı kurun. Çoklu cihaz kirliliği: Token’ları kullanıcı bazında güncelleyin; geçersiz token’ları (NotRegistered) yanıtlarına göre temizleyin.

Sonuç

Firebase Cloud Messaging ile web push bildirimleri, doğru kurgulandığında PWA veya klasik web sitenizde kullanıcı etkileşimini ciddi ölçüde artırabilir. Bu rehberde proje oluşturma, VAPID anahtarı, Service Worker mantığı, token yönetimi ve üretim senaryosunda gönderim yaklaşımını ele aldık. Bir sonraki adım olarak topic tabanlı abonelik ve ölçümleme ekleyerek bildirimi “spam” olmaktan çıkarıp gerçek bir ürüne dönüştürebilirsiniz.

23 Aralık 2025 Salı

Docker Compose ile PostgreSQL + pgAdmin Kurulumu: Geliştirme Ortamını 10 Dakikada Ayağa Kaldırma

Hedef: Tek Komutla Veritabanı Ortamı

Yerel geliştirme ortamında PostgreSQL kurmak çoğu zaman “kuruldu mu, servis başladı mı, port çakıştı mı, kullanıcı yetkileri doğru mu?” gibi küçük ama zaman yiyen sorularla uzar. Üstelik ekip çalışmasında herkesin makinesinde aynı sürüm ve aynı ayarlarla çalışmak daha da zorlaşır. Bu yazıda, Docker Compose ile PostgreSQL’i ve yönetim aracı olarak pgAdmin’i birlikte çalıştıran, tekrar üretilebilir (reproducible) bir kurulum hazırlayacağız. Amaç: projeyi klonlayan herkesin tek komutla aynı veritabanına erişebilmesi.

Konu “ileri seviye” tarafına şu noktada yaklaşıyor: sadece konteyneri çalıştırmakla kalmayacağız; kalıcı veri (volume), başlangıç SQL dosyaları, servis bağımlılıkları ve güvenli sayılabilecek temel ayarlarla pratik bir şablon oluşturacağız. Bu yapı; Node.js, Python, Java, .NET gibi farklı backend’lerle rahatça kullanılabilir.

Ön Koşullar

Bilgisayarınızda Docker ve Docker Compose yüklü olmalı. Güncel Docker Desktop sürümlerinde Compose genellikle hazır gelir. Terminalde docker --version ve docker compose version komutlarıyla kontrol edebilirsiniz.

Proje Yapısını Hazırlama

Proje klasörünüzde aşağıdaki gibi bir yapı işinizi kolaylaştırır. Özellikle init dosyalarını ayrı klasörde tutmak, veritabanını ilk kurulumda otomatik hazırlamak için idealdir.

Önerilen dizinler:
- docker-compose.yml
- db/init/01-schema.sql
- db/init/02-seed.sql

docker-compose.yml Dosyası

Aşağıdaki Compose tanımı PostgreSQL (db) ve pgAdmin (pgadmin) servislerini ayağa kaldırır. PostgreSQL verisi named volume ile kalıcı hale gelir; pgAdmin ayarları da ayrı volume’da tutulur. Ayrıca PostgreSQL’e ilk kurulumda SQL çalıştırmak için ./db/init klasörünü otomatik mount ediyoruz.

docker-compose.yml içeriği:

version satırı artık zorunlu olmasa da okunabilirlik için ekleyebilirsiniz. Örnek YAML:

Not: Aşağıdaki blokları dosyanıza aynen yazın (girintiler YAML için kritiktir).

docker-compose.yml
services:
  db:
    image: postgres:16
    container_name: local_postgres
    restart: unless-stopped
    environment:
      POSTGRES_USER: appuser
      POSTGRES_PASSWORD: apppass
      POSTGRES_DB: appdb
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./db/init:/docker-entrypoint-initdb.d:ro
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U appuser -d appdb"]
      interval: 5s
      timeout: 3s
      retries: 20

  pgadmin:
    image: dpage/pgadmin4:latest
    container_name: local_pgadmin
    restart: unless-stopped
    environment:
      PGADMIN_DEFAULT_EMAIL: [email protected]
      PGADMIN_DEFAULT_PASSWORD: adminpass
    ports:
      - "5050:80"
    volumes:
      - pgadmin_data:/var/lib/pgadmin
    depends_on:
      db:
        condition: service_healthy

volumes:
  postgres_data:
  pgadmin_data:

Başlangıç SQL Dosyaları (Opsiyonel ama Çok Faydalı)

PostgreSQL’in resmi imajı, ilk kez boş bir data dizini oluştururken /docker-entrypoint-initdb.d altındaki .sql dosyalarını otomatik çalıştırır. Bu sayede tablo şemasını ve örnek veriyi sürüm kontrolüne alabilirsiniz. Örnek iki dosya hazırlayalım:

db/init/01-schema.sql

CREATE TABLE IF NOT EXISTS users (
  id SERIAL PRIMARY KEY,
  email TEXT UNIQUE NOT NULL,
  created_at TIMESTAMP NOT NULL DEFAULT NOW()
);

db/init/02-seed.sql

INSERT INTO users (email) VALUES ('[email protected]')
ON CONFLICT DO NOTHING;

Buradaki önemli detay: init dosyaları sadece veritabanı ilk kez oluşturulurken devreye girer. Eğer volume zaten doluysa ve siz SQL’i değiştirdiyseniz, değişikliğin uygulanması için ya manuel migration çalıştırmanız ya da geliştirme ortamında ilgili volume’u temizleyip yeniden başlatmanız gerekir.

Servisleri Başlatma

Aynı klasörde terminal açın ve şu komutu çalıştırın:

docker compose up -d

Ardından konteynerlerin durumunu görmek için:

docker compose ps

pgAdmin ile Bağlantı Kurma

Tarayıcıdan http://localhost:5050 adresine gidin. Giriş için Compose dosyasındaki PGADMIN_DEFAULT_EMAIL ve PGADMIN_DEFAULT_PASSWORD değerlerini kullanın. Yeni bir server kaydı eklerken:

Host name/address: db
Port: 5432
Maintenance database: appdb
Username: appuser
Password: apppass

Burada “host” olarak db yazmamızın sebebi, Compose ağında servis isimlerinin DNS gibi çalışmasıdır. Yani pgAdmin konteyneri, PostgreSQL’e db:5432 üzerinden erişir.

Sık Karşılaşılan Sorunlar ve İpuçları

Port çakışması: Makinenizde 5432 zaten kullanılıyorsa, “5432:5432” satırını örneğin “5433:5432” yapın. Uygulamanızdan bağlanırken host portunu (5433) kullanırsınız.

Şifreleri dosyaya yazmak: Bu örnek geliştirme içindir. Ekip içinde daha güvenli kullanım için ortam değişkenlerini .env dosyasına taşıyıp Compose’dan çağırabilirsiniz.

Veriyi sıfırlama: Tamamen temiz kurulum için servisleri durdurup volume’ları silin: docker compose down -v. Sonra tekrar docker compose up -d dediğinizde init SQL dosyaları yeniden çalışır.

Sonuç

Docker Compose ile PostgreSQL + pgAdmin kurulumu, hem tek kişilik projelerde hem de ekip çalışmalarında standart bir geliştirme zemini sağlar. En büyük kazanım; “benim makinemde çalışıyor” problemini azaltmanız, versiyon uyumunu korumanız ve veritabanını birkaç komutla yönetebilmenizdir. Bu şablonu temel alıp Redis, MinIO, Kafka gibi servisleri de aynı Compose dosyasına ekleyerek daha kapsamlı bir yerel ortam kurabilirsiniz.

22 Aralık 2025 Pazartesi

Windows 11’de WSL2 ile Docker Kurulumu ve Performans Ayarları (Adım Adım)

WSL2 ile Docker: Neden Hâlâ En Pratik Seçenek?

Windows 11 kullanıyorsanız ve geliştirme ortamınızı “Linux hissiyatı” ile kurmak istiyorsanız, WSL2 (Windows Subsystem for Linux) + Docker ikilisi bugün hâlâ en pratik çözümlerden biri. WSL2, Windows üzerinde gerçek bir Linux çekirdeğiyle çalıştığı için klasik sanal makine kurulumlarına göre daha hızlı başlatma, daha iyi entegrasyon ve daha az uğraş sunuyor. Bu yazıda, WSL2 üzerinde Docker’ı kurup sorunsuz çalıştırmanın yanında, performans ve disk yönetimi gibi can sıkıcı noktaları da ileri seviye ayarlarla toparlayacağız.

Ön Koşullar: Sürüm ve Özellik Kontrolü

Başlamadan önce Windows 11’in güncel olduğundan emin olun. Windows Özellikleri tarafında iki bileşenin etkin olması gerekiyor: Windows Subsystem for Linux ve Virtual Machine Platform. Bunları elle açabilirsiniz; ancak en temiz yöntem, Microsoft’un komutlarıyla ilerlemek.

1) WSL2 Kurulumu ve Varsayılan Sürümü Ayarlama

PowerShell’i Yönetici olarak açın ve şu komutu çalıştırın:

wsl --install

Bu komut çoğu sistemde gerekli bileşenleri açar ve varsayılan bir dağıtım (genellikle Ubuntu) kurar. Kurulum sonrası yeniden başlatma istenirse sistemi yeniden başlatın. Ardından WSL sürümünü 2 yapın:

wsl --set-default-version 2

Kurulu dağıtımların WSL2’de olup olmadığını görmek için:

wsl -l -v

Eğer dağıtımınız WSL1 görünüyorsa şu şekilde WSL2’ye yükseltebilirsiniz:

wsl --set-version Ubuntu 2

2) Docker Desktop Kurulumu ve WSL Entegrasyonu

Windows tarafında Docker kullanmanın en sorunsuz yolu, Docker Desktop kurmaktır. Kurulum sırasında “Use WSL 2 instead of Hyper-V” benzeri bir seçenek görürseniz WSL2’yi tercih edin. Kurulum bittikten sonra Docker Desktop’ı açın ve ayarlardan Resources > WSL Integration bölümüne gidin.

Burada, Docker’ın hangi Linux dağıtımıyla entegre çalışacağını seçebilirsiniz. Örneğin Ubuntu kullanıyorsanız ilgili dağıtımı etkinleştirin. Bu adım, “Docker komutlarını Ubuntu içinde çalıştırayım” senaryosunun anahtarıdır.

3) Ubuntu İçinde Docker’ın Çalıştığını Doğrulama

Ubuntu terminalinizi (WSL) açın ve şu komutlarla kontrol edin:

docker version

docker run --rm hello-world

İkinci komut, küçük bir imaj indirip çalıştırır ve kurulumun doğru yapıldığını net şekilde gösterir. Eğer “Cannot connect to the Docker daemon” hatası alırsanız, Docker Desktop’ın açık olduğundan ve WSL Integration’ın seçili dağıtım için etkinleştirildiğinden emin olun.

4) Performans: Dosyaları Nereye Koymalısınız?

WSL2 + Docker’da performansı belirleyen en kritik noktalardan biri dosya sistemidir. Projenizi /home/kullaniciadi/proje gibi WSL’in Linux dosya sistemi içinde tutmak genellikle çok daha hızlıdır. Projeyi /mnt/c altında (Windows diskine bağlı konumda) çalıştırmak, özellikle Node.js, PHP Composer veya yoğun küçük dosya erişimi yapan işler için belirgin yavaşlık yaratabilir.

Özet kural: Kod ve bağımlılıklar Linux tarafında, Windows tarafıyla paylaşım gerekiyorsa bunu kontrollü yapın.

5) İleri Ayar: WSL Kaynak (CPU/RAM) Sınırı ve Disk Yönetimi

WSL2 varsayılan olarak sistem kaynaklarını dinamik kullanır. Ancak Docker ile birlikte yoğun işlerde RAM tüketimi artabilir. Bunu kontrol etmek için Windows kullanıcı klasörünüzde .wslconfig adında bir dosya oluşturup şu örnek ayarları ekleyebilirsiniz:

[wsl2]
memory=6GB
processors=4
swap=2GB

Değişikliklerin uygulanması için WSL’i kapatın:

wsl --shutdown

Bir diğer yaygın sorun, Docker imajları ve katmanları arttıkça disk tüketiminin şişmesidir. WSL2 sanal diski zamanla büyür ve her zaman otomatik küçülmez. Gereksiz imajları temizlemek için periyodik olarak şu komutlar işinize yarar:

docker system prune -a

Bu komut kullanılmayan imajları da sileceği için üretim benzeri ortamlarda dikkatli olun. Düzenli temizlik, WSL2 disk şişmesi ve gereksiz alan kullanımını azaltır.

6) Sık Karşılaşılan Hatalar ve Hızlı Çözümler

Docker daemon’a bağlanamıyorum: Docker Desktop açık mı, WSL Integration doğru dağıtımda etkin mi kontrol edin. Gerekirse wsl --shutdown sonrası Docker’ı yeniden başlatın.

İmaj indirme çok yavaş: Kurumsal ağ veya proxy varsa Docker Desktop proxy ayarlarını kontrol edin. DNS problemlerinde WSL içinde resolv.conf ayarları bazen etkili olur.

Dosya erişimi yavaş: Projeyi /mnt/c yerine Linux dosya sistemine taşıyın. Özellikle bağımlılık klasörleri (node_modules gibi) için fark dramatiktir.

Sonuç: Stabil Bir Geliştirme Ortamı İçin Kısa Reçete

Windows 11’de WSL2 ile Docker kurmak artık birkaç adımda tamamlanıyor; asıl farkı yaratan kısım doğru entegrasyon ve performans ayarları. Projeyi Linux tarafında tutmak, WSL kaynaklarını mantıklı sınırlandırmak ve Docker temizliğini düzenli yapmak; hem hız hem stabilite açısından günlük geliştirme akışını ciddi şekilde iyileştirir. Bu kurulumla, Windows konforunu bozmadan Linux tabanlı bir geliştirme düzenine geçebilirsiniz.

21 Aralık 2025 Pazar

Windows 11’de WSL2 ile Docker Kurulumu ve Geliştirici Ortamını Hızlandırma Rehberi

WSL2 + Docker Neden Bu Kadar Popüler?

Windows 11 üzerinde yazılım geliştirenlerin önemli bir kısmı, Linux araçlarını yerel hızda çalıştırmak ve aynı anda Windows uygulamalarından da vazgeçmemek istiyor. WSL2 (Windows Subsystem for Linux 2), Linux çekirdeğini sanal makine benzeri bir mimaride çalıştırırken, kullanıcıya terminal ve dosya erişimi açısından çok pratik bir deneyim sunuyor. İşin içine Docker da girince; mikroservisler, test ortamları, veritabanları ve CI/CD’ye yakın bir yerel geliştirme düzeni kurmak oldukça kolaylaşıyor.

Bu rehberde, Windows 11’de WSL2’yi etkinleştirip bir Linux dağıtımı kuracak, Docker’ı WSL2 tabanlı şekilde çalıştıracak ve performans/uyumluluk için birkaç kritik ayarı yapacağız. Anlatım sade; ancak adımlar güncel ve geliştirici kullanımına uygun olacak.

1) Ön Koşullar ve Kontroller

Başlamadan önce sisteminizde sanallaştırmanın açık olduğundan emin olun. Görev Yöneticisi > Performans sekmesinde Sanallaştırma: Etkin görmelisiniz. Değilse BIOS/UEFI üzerinden Intel VT-x veya AMD-V özelliğini açmanız gerekir.

Windows 11’in güncel olması da önemli. Bazı WSL2 ve ağ bileşenleri güncellemelerle iyileşiyor. Ayarlar > Windows Update bölümünden güncelleme kontrolü yapın.

2) WSL2 Kurulumu ve Varsayılan Sürümü Ayarlama

Windows Terminal veya PowerShell’i Yönetici olarak açın ve aşağıdaki komutu çalıştırın:

wsl --install

Bu komut çoğu sistemde gerekli bileşenleri kurar ve varsayılan olarak bir dağıtım (genellikle Ubuntu) önerir. Kurulumdan sonra yeniden başlatmanız istenebilir. Ardından WSL sürümünü 2 olarak sabitlemek için:

wsl --set-default-version 2

Kurulu dağıtımları görmek için:

wsl -l -v

Eğer dağıtımınız WSL 1 görünüyorsa, örnek olarak Ubuntu’yu WSL2’ye çevirebilirsiniz:

wsl --set-version Ubuntu 2

3) Ubuntu İçinde Temel Güncelleme ve Kullanışlı Paketler

Ubuntu terminalini açın ve paketleri güncelleyin:

sudo apt update && sudo apt upgrade -y

Geliştirme süreçlerinde sık kullanılan araçlar için:

sudo apt install -y build-essential git curl ca-certificates

4) Docker’ı WSL2 Üzerinde Çalıştırma (Docker Desktop ile)

Windows tarafında en sorunsuz yöntem, Docker Desktop kullanmaktır. Docker Desktop’ı kurduktan sonra Ayarlar (Settings) içinde Use the WSL 2 based engine seçeneğini etkinleştirin. Ardından Resources > WSL Integration bölümünde Ubuntu dağıtımınızı seçip entegrasyonu açın.

Bu aşamadan sonra Ubuntu terminalinde Docker komutlarını çalıştırabilmelisiniz. Kontrol için:

docker version

docker run --rm hello-world

Komutlar çalışıyor ama izin hatası alıyorsanız, genellikle Docker Desktop entegrasyonu eksik veya dağıtım seçimi kapalıdır. Ayarlara geri dönüp WSL Integration’ı doğrulayın.

5) Performans İçin Kritik İpucu: Dosyaları Nerede Tutmalı?

WSL2 + Docker kullanımında en sık yaşanan performans farkı, proje dosyalarının konumundan kaynaklanır. Eğer kaynak kodunuz Windows dosya sisteminde (ör. C:\) duruyor ve siz WSL içinden bu klasöre /mnt/c üzerinden erişiyorsanız, yoğun dosya okuma/yazma yapan projelerde yavaşlık hissedebilirsiniz.

Daha iyi performans için projelerinizi WSL dosya sisteminde tutun. Örneğin:

mkdir -p ~/projeler

Bu klasör altında çalışıp editör olarak VS Code’un Remote - WSL eklentisini kullanırsanız hem Windows arayüzüyle düzenleme yapar hem de Linux tarafında hızlı I/O avantajını korursunuz.

6) Docker Compose ile Örnek Bir Geliştirme Ortamı

Hızlı bir test ortamı için bir klasör oluşturup içine docker-compose.yml ekleyebilirsiniz. Örneğin PostgreSQL başlatmak, çoğu projede büyük kolaylık sağlar. Dosyanızın mantığı basit: bir veritabanı servisi, port yönlendirme ve kalıcı veri dizini. Compose çalıştırmak için genelde şu komut yeterlidir:

docker compose up -d

Sonrasında konteynerleri kontrol edin:

docker ps

İşiniz bitince ortamı kaldırmak için:

docker compose down

7) Sık Karşılaşılan Sorunlar ve Hızlı Çözümler

WSL dağıtımı açılmıyor veya güncellenmiyor: PowerShell’de wsl --update komutunu deneyin ve Windows Update’i kontrol edin.

Docker komutları bulunamıyor: Docker Desktop’ın açık olduğundan ve WSL Integration’ın ilgili dağıtım için etkin olduğundan emin olun.

Port çakışması: 5432, 3306 gibi yaygın portlar başka servisler tarafından kullanılıyor olabilir. Compose dosyasında portları değiştirin veya çakışan servisi kapatın.

Sonuç

Windows 11’de WSL2 ile Docker kullanmak, tek bilgisayarda hem Windows uygulamalarını hem de Linux tabanlı geliştirme araçlarını verimli şekilde bir araya getirir. Doğru entegrasyon yapıldığında, konteyner tabanlı projeler daha taşınabilir olur; test ve geliştirme ortamları birkaç komutla ayağa kalkar. En büyük kazanım ise şudur: “Makinemde çalışıyor” cümlesini ekibin geri kalanından daha az duyarsınız.

20 Aralık 2025 Cumartesi

Windows 11’de WSL2 ile Docker Kurulumu ve Performans İyileştirme Rehberi (2025)

WSL2 + Docker Neden Hâlâ En Mantıklı Kombinasyon?

Windows 11 üzerinde yazılım geliştirenlerin büyük bölümü iki farklı dünyayı aynı anda yönetiyor: Windows uygulamaları ve Linux tabanlı geliştirme araçları. WSL2 (Windows Subsystem for Linux 2), Linux çekirdeğini sanallaştırma katmanıyla çalıştırdığı için klasik WSL1’e göre çok daha hızlı dosya sistemi ve ağ performansı sunuyor. Docker ise mikro servis, test otomasyonu ve yerel geliştirme ortamlarını standartlaştırma konusunda artık neredeyse “varsayılan” araç. Bu rehberde Windows 11’de WSL2 ile Docker kurulumunu adım adım yapacak, ardından sık görülen darboğazları performans odaklı ayarlarla gidereceğiz.

Ön Koşullar: Sürüm ve Özellik Kontrolü

Kuruluma başlamadan önce Windows 11’in güncel olduğundan emin olun. WSL2 için sanallaştırma desteği (BIOS/UEFI üzerinden VT-x/AMD-V) açık olmalı. Kurumsal cihazlarda bu ayar kilitli olabilir; böyle bir durumda BT birimiyle görüşmek gerekir. Ayrıca Hyper-V ve Virtual Machine Platform özellikleri WSL2 için önemlidir.

Windows özelliklerini hızlıca etkinleştirmek için PowerShell’i yönetici olarak açıp şu komutları kullanabilirsiniz:

1) wsl --install

Bu komut WSL’yi kurar, varsayılan olarak bir Linux dağıtımı (genelde Ubuntu) yükler ve gerekli bileşenleri etkinleştirmeye çalışır. Kurulum sonrası yeniden başlatma istenirse ertelemeyin.

WSL2 Dağıtımını Kurma ve Güncelleme

Yeniden başladıktan sonra Ubuntu (veya seçtiğiniz dağıtım) ilk açılışta kullanıcı adı ve parola oluşturmanızı ister. Ardından Linux paketlerini güncellemek iyi bir alışkanlıktır:

sudo apt update && sudo apt upgrade -y

WSL sürümünü kontrol etmek için Windows tarafında şu komutu çalıştırabilirsiniz:

wsl -l -v

Dağıtımınızın “VERSION” sütununda 2 yazdığını görmelisiniz. Eğer 1 ise:

wsl --set-version Ubuntu 2

Docker Desktop Kurulumu ve WSL2 Entegrasyonu

Docker’ı Windows 11’de en sorunsuz yöntemle kullanmak için güncel Docker Desktop tercih ediliyor. Kurulum sırasında “Use WSL 2 instead of Hyper-V” benzeri seçenekler görürseniz WSL2’yi seçin. Kurulumdan sonra Docker Desktop’ı açın ve şu ayarları kontrol edin:

Settings > General: WSL2 tabanlı motor etkin olmalı.

Settings > Resources > WSL Integration: Ubuntu dağıtımınız için entegrasyonu açın.

Bu aşamadan sonra Ubuntu terminalinde Docker komutlarının çalıştığını doğrulayın:

docker version

Test amaçlı basit bir container çalıştırabilirsiniz:

docker run --rm hello-world

Performans İyileştirme: En Kritik 3 Nokta

1) Proje dosyalarını doğru yerde tutun (çok önemli). WSL2 ile çalışırken kaynak kodunuzu Windows dosya sisteminde (ör. C:\Users\...) tutup WSL üzerinden erişmek I/O gecikmesini artırabilir. Docker build süreleri ve testler gereksiz uzar. En iyi pratik, projeyi Linux dosya sisteminde tutmaktır: /home/kullanici/proje. VS Code kullanıyorsanız “Remote - WSL” eklentisiyle projeyi doğrudan WSL içinde açarak hem hızlı hem stabil bir akış elde edersiniz.

2) WSL kaynak limitlerini ayarlayın. Varsayılan durumda WSL2, sistem kaynaklarını dinamik yönetir; bu bazen RAM’in gereksiz şişmesine ya da CPU’nun dengesiz kullanımına yol açabilir. Windows kullanıcı dizininizde bir .wslconfig dosyası oluşturarak limit koyabilirsiniz:

[wsl2]
memory=8GB
processors=4
swap=2GB

Değerleri sisteminize göre uyarlayın. Ardından WSL’yi kapatıp açın: wsl --shutdown. Bu ayar, Docker build ve compose senaryolarında daha öngörülebilir performans sağlar.

3) Docker Desktop kaynaklarını gereksiz şişirmeyin. Docker Desktop tarafında da CPU/RAM limitleri bulunur. Eğer WSL2 motorunu kullanıyorsanız çoğu yük WSL2 üzerinde koşar; yine de ağır compose projelerinde denge önemlidir. Gereğinden fazla CPU vermek her zaman hızlandırmaz; özellikle aynı anda IDE, tarayıcı ve test araçları çalışıyorsa sistem geneli yavaşlayabilir.

Sık Karşılaşılan Sorunlar ve Hızlı Çözümler

Docker komutu bulunamıyor: WSL Integration açık mı kontrol edin. Docker Desktop çalışıyor olmalı. Ubuntu içinde docker komutu hâlâ yoksa dağıtım entegrasyonu kapalı olabilir.

Port çakışması (ör. 3000/5432): Aynı portu kullanan başka bir servis Windows tarafında çalışıyor olabilir. docker ps ile container portlarını kontrol edin ve gerekirse docker compose yapılandırmanızda portları değiştirin.

Dosya izleme (hot reload) yavaş: Proje Windows dizinindeyse WSL içine taşıyın. Ayrıca Node.js gibi araçlarda dosya izleme ayarlarını WSL için optimize eden parametreler gerekebilir, ancak çoğu durumda dosya konumu değişikliği sorunu kökten çözer.

Sonuç: Daha Hızlı Build, Daha Stabil Geliştirme

Windows 11’de WSL2 ile Docker kullanmak, doğru kurulum ve birkaç kritik ayarla hem hızlı hem de üretken bir geliştirme ortamı sunuyor. En büyük kazanım genellikle “dosyaları doğru yerde tutmak” ile geliyor: kaynak kodu WSL dosya sistemine taşıdığınızda build süreleri kısalır, container içi I/O performansı hissedilir biçimde artar. Üstüne .wslconfig ile kaynakları dengelediğinizde sistem stabilitesi belirgin şekilde iyileşir. Eğer yerel geliştirme ortamınızı modernleştirmek istiyorsanız, bu kombinasyon 2025’te de en pratik seçeneklerden biri olmaya devam ediyor.

19 Aralık 2025 Cuma

Güncel Rehber: Docker’da Rootless Mod ile Güvenli Konteyner Çalıştırma (Adım Adım)

Rootless Docker nedir ve neden önemli?

Docker’ı klasik kurulumla kullandığınızda, arka plandaki dockerd servisi genellikle root yetkileriyle çalışır. Bu, konteyner izolasyonu güçlü olsa bile “daemon” katmanında yetki seviyesinin yüksek olduğu anlamına gelir. Rootless Docker ise Docker daemon’ını ve konteynerleri root olmayan bir kullanıcıyla çalıştırarak olası bir kaçış senaryosunda zararın etkisini düşürür. Özellikle paylaşımlı sunucular, geliştirici makineleri ve CI ortamlarında “en az ayrıcalık” yaklaşımını uygulamak için güncel ve pratik bir yöntemdir.

Bu yazıda Rootless Docker’ın ne işe yaradığını, hangi sınırlamalara sahip olduğunu ve Linux üzerinde nasıl kurup günlük kullanımda problemsiz çalıştırabileceğinizi adım adım göreceksiniz. Odak noktası, güvenliği artırırken geliştirici deneyimini mümkün olduğunca bozmadan ilerlemek.

Ön koşullar ve desteklenen sistemler

Rootless mod en sorunsuz şekilde modern Linux dağıtımlarında çalışır. Ubuntu 22.04/24.04, Debian 12, Fedora gibi sistemler uygun adaylardır. Çekirdek tarafında kullanıcı isim alanları (user namespaces) ve cgroup desteği gibi bileşenler önemlidir. Ayrıca Rootless Docker, ağ tarafında çoğunlukla slirp4netns ile kullanıcı alanı NAT kullanır; performans ve port yönlendirme mantığı root’lu kurulumdan farklı olabilir.

Bu rehberde komutlar Debian/Ubuntu çizgisinde düşünülmüştür. Fedora veya Arch kullanıyorsanız paket isimleri değişebilir, mantık aynı kalır.

1) Gerekli paketler ve Docker kurulumu

Öncelikle Docker Engine’in kurulu olması gerekir. Resmî depodan kurulum önerilir. Kurulumdan sonra Rootless için gerekli yardımcı araçlar gerekebilir. Ubuntu/Debian’da çoğu zaman aşağıdakiler işinizi görür:

Komut örneği:
sudo apt update
sudo apt install -y uidmap slirp4netns fuse-overlayfs

Burada uidmap paketi rootless çalışmada kullanıcı kimliği eşlemeleri için kritik olan newuidmap/newgidmap araçlarını sağlar. fuse-overlayfs ise overlay dosya sistemi rootless senaryolarda daha iyi performans/uyumluluk sunabilir.

2) Rootless kurulumu başlatma

Docker kurulumunuzda genellikle dockerd-rootless-setuptool.sh adlı bir kurulum aracı bulunur. Bu araç, kullanıcı düzeyinde systemd servislerini ve gerekli dizinleri oluşturur.

Komut örneği:
dockerd-rootless-setuptool.sh install

Kurulum bittiğinde size DOCKER_HOST gibi ortam değişkenlerini ayarlamanızı öneren bir çıktı gösterebilir. Rootless Docker’da daemon, kullanıcıya ait bir UNIX soketi üzerinden çalışır. Bu da varsayılan /var/run/docker.sock yerine genellikle şu tarz bir yola işaret eder:

Örnek: unix:///run/user/1000/docker.sock

3) Ortam değişkeni ve kalıcı ayar

Mevcut terminal oturumunda Rootless Docker’ı kullanmak için aşağıdaki değişkeni tanımlayabilirsiniz:

Komut örneği:
export DOCKER_HOST=unix:///run/user/$(id -u)/docker.sock

Kalıcı yapmak için bunu ~/.bashrc veya kullandığınız shell’in profil dosyasına ekleyebilirsiniz. Ardından Docker istemcisinin doğru daemon’a bağlandığını doğrulayın:

Komut örneği:
docker info

Çıktıda “rootless” ile ilgili bir ibare görmeniz veya daemon’ın user socket üzerinden çalıştığını doğrulamanız gerekir. Eğer hâlâ root’lu servise bağlanıyorsa DOCKER_HOST ayarını ve terminal oturumunuzu kontrol edin.

4) Systemd ile otomatik başlatma

Rootless kurulum çoğunlukla kullanıcı seviyesinde systemd servisi oluşturur. Servisi yönetmek için:

Komut örneği:
systemctl --user status docker
systemctl --user enable --now docker

Uzak oturumlarda veya yeniden başlatmalarda kullanıcı servisi çalışsın istiyorsanız “linger” açmak gerekebilir:

Komut örneği:
sudo loginctl enable-linger $(whoami)

5) Port yönlendirme ve ağ davranışı

Rootless modda 1024 altındaki portlara (80, 443 gibi) bağlanmak bazı dağıtımlarda doğrudan mümkün olmayabilir. Geliştirme ortamında alternatif olarak 8080/8443 gibi portlar kullanabilir ya da ters vekil (reverse proxy) yaklaşımına gidebilirsiniz. Örneğin Nginx’i root yetkisiyle host’ta dinleyip trafiği rootless konteyner portuna aktarabilirsiniz.

Basit bir test için bir web sunucusu çalıştırın:

Komut örneği:
docker run --rm -p 8080:80 nginx

Ardından tarayıcıdan http://localhost:8080 ile doğrulayın. Rootless ağ katmanı kullanıcı alanında çalıştığı için bazı senaryolarda performans root’lu kurulumdan düşük olabilir; ancak güvenlik hedefiniz yüksekse bu takas kabul edilebilir.

6) Sık karşılaşılan sorunlar ve çözüm ipuçları

“newuidmap: write to uid_map failed” gibi hatalar genellikle uidmap paketinin eksikliğine veya /etc/subuid ve /etc/subgid eşlemelerinin yetersizliğine işaret eder. Çoğu sistemde kurulum aracı bunları ayarlar, ancak sorun yaşıyorsanız kullanıcıya yeterli aralık tanımlandığından emin olun.

Disk sürücüsü ve overlay problemi yaşayanlar için fuse-overlayfs önemli bir çözümdür. Ayrıca Docker’ın storage driver seçimi rootless modda farklı davranabilir. Günlükleri kontrol etmek için:

Komut örneği:
journalctl --user -u docker --no-pager -n 200

Kaynak tüketimi ve limitler konusunda da cgroup v2 uyumluluğu önemlidir. Modern dağıtımlar cgroup v2 ile daha sorunsuzdur. “docker info” çıktısında cgroup sürümünü kontrol ederek ilerleyin.

Sonuç: Rootless Docker kimler için ideal?

Rootless Docker, tek başına tüm güvenlik sorunlarını sihirli şekilde çözmez; yine de konteyner çalıştırma katmanında root yetkisini ortadan kaldırarak saldırı yüzeyini ciddi biçimde azaltır. Kişisel geliştirme makineleri, eğitim ortamları, çok kullanıcılı sistemler ve güvenlik hassasiyeti yüksek ekipler için güncel ve uygulanabilir bir yaklaşımdır. Eğer amacınız “konteyner çalıştırıyorum, ama host üzerinde root daemon istemiyorum” ise Rootless mod, bugün tercih edilebilecek en pratik çözümlerden biridir.

18 Aralık 2025 Perşembe

Web Sitelerinde Core Web Vitals İyileştirme Rehberi: INP, LCP ve CLS’yi Gerçekten Düşürmek

Core Web Vitals neden hâlâ önemli?

Google’ın Core Web Vitals metrikleri (LCP, CLS ve güncel olarak FID yerine geçen INP) sadece “SEO puanı” için değil, ziyaretçinin sayfayı akıcı kullanabilmesi için de kritik. Özellikle mobil trafikte, birkaç yüz milisaniyelik gecikme bile etkileşimi düşürüyor. Bu rehberde, geliştirici araçlarıyla sorunu bulup, kod seviyesinde uygulanabilir optimizasyonları adım adım ele alacağım.

1) Ölçmeden iyileştirme olmaz: Doğru metrik kaynağını seçin

İlk hata, yalnızca laboratuvar testlerine bakıp (Lighthouse gibi) gerçek kullanıcı verisini (field data) göz ardı etmek. Başlangıç için şu kaynakları birlikte kullanın: PageSpeed Insights (CrUX saha verisi + lab), Chrome DevTools Performance (iz sürme), WebPageTest (farklı cihaz/ağ senaryoları) ve mümkünse RUM (Real User Monitoring) ile gerçek ziyaretçiden telemetri toplama. Hedefiniz net olmalı: LCP < 2,5 sn, CLS < 0,1 ve INP < 200 ms.

2) LCP (Largest Contentful Paint): “En büyük” içeriği hızlandırın

LCP çoğu sitede “hero” görseli, başlık alanı veya üstteki büyük bir kart bileşeni olur. LCP’yi iyileştirmenin ana fikri şudur: kritik içeriğe giden yolu kısaltın. Önce DevTools’ta Performance kaydı alın, “Timings” ve “LCP” işaretini bulun; ardından LCP öğesinin ne olduğunu tespit edin.

Uygulanabilir adımlar: 1) Sunucu yanıt süresini düşürün (TTFB). CDN kullanın, HTML’i önbelleğe alın, dinamik sorguları azaltın. 2) Kritik CSS’i öne alın; sayfanın üst kısmını boyamak için gereken CSS’i geciktirmeyin. 3) Render-blocking kaynakları azaltın: büyük JS paketlerini başlangıçta yüklemek LCP’yi uzatır. 4) Web fontları için doğru stratejiyi seçin: font-display: swap gibi ayarlar, metnin beklemesini azaltır.

3) CLS (Cumulative Layout Shift): Kaymaların kaynağını kapatın

CLS çoğu zaman “reklam alanı sonradan geldi”, “görsel boyutu belirtilmedi”, “font geç yüklendi ve satırlar oynadı” gibi sebeplerle yükselir. Sorunun güzelliği şu: Genellikle birkaç net düzeltmeyle ciddi düşer.

Uygulanabilir adımlar: 1) Görseller ve iframe’ler için genişlik/yükseklik belirtin ya da CSS ile en-boy oranını sabitleyin. 2) Üst kısma dinamik banner ekliyorsanız yer tutucu alan ayırın. 3) Geç yüklenen fontlarda satır kaymasını azaltmak için benzer metriklere sahip font fallback’leri seçin. 4) “Yukarıdan açılan” çerez bildirimi gibi bileşenleri sayfa içeriğini itmek yerine, sabit konumda (overlay) tasarlamayı değerlendirin.

4) INP (Interaction to Next Paint): Etkileşim gecikmesini azaltmanın kısa yolu

INP, kullanıcının tıklama/dokunma/klavye gibi etkileşiminden sonra arayüzün bir sonraki çizimine kadar geçen süreyi ölçer. Kısaca: JS ana iş parçacığını (main thread) tıkamayın. Büyük framework projelerinde bile INP’yi düşüren en etkili hamle, “gereksiz iş”i doğru zamana yaymaktır.

Uygulanabilir adımlar: 1) Uzun süren görevleri bölün: 200–300 ms’yi aşan işlemleri küçük parçalara ayırın. 2) Olay dinleyicilerini sadeleştirin; her tıklamada ağır DOM işlemleri yapmayın. 3) “Passive event listener” kullanın (özellikle scroll/touch). 4) Üçüncü taraf script’leri (chat, analytics, tag manager) denetleyin; INP’yi en çok bunlar bozabilir. Mümkünse gecikmeli yükleyin veya daha hafif alternatiflere geçin.

5) Pratik bir kontrol listesi: Hızlı kazanımlar

Kontrol listesi: (1) Ana sayfa ve en çok trafik alan 3 şablonda ölçüm alın. (2) LCP öğesini belirleyip kritik yolu kısaltın. (3) CLS için boyut belirtmeyen medya alanlarını tespit edin. (4) INP için Performance kaydında “Long Task” avına çıkın. (5) Üçüncü taraf script’leri tek tek devre dışı bırakıp etkisini ölçün. (6) Değişiklik sonrası PageSpeed Insights + gerçek kullanıcı verisiyle doğrulayın.

6) Sık yapılan hatalar ve doğru yaklaşım

Sadece Lighthouse skorunu yükseltmeye odaklanmak çoğu zaman yanıltıcıdır; çünkü kullanıcılar farklı cihaz ve ağlarda geziyor. Diğer hata, her şeyi aynı anda optimize etmeye çalışmak. En iyi yöntem: önce en çok etkileyen metriği seçin (örneğin LCP), en büyük darboğazı giderin, sonra diğerine geçin. Küçük ama doğrulanmış iyileştirmeler, bir “büyük refactor”dan daha güvenli sonuç verir.

Sonuç

Core Web Vitals optimizasyonu, “tek seferlik” değil, ölçüm-iyileştirme döngüsüdür. LCP’de kritik içeriği hızlandırın, CLS’de düzen kaymalarını kökten engelleyin, INP’de ana iş parçacığını rahatlatın. Bu üçlüde doğru teşhis ve küçük ama hedefli dokunuşlarla hem kullanıcı deneyimini hem de organik görünürlüğü aynı anda güçlendirebilirsiniz.

Docker Compose ile Yerel Geliştirme Ortamı Kurma: PostgreSQL + Redis + Uygulama Servisi (İleri Seviye How-To)

Docker Compose neden hâlâ en pratik seçenek?

Yerel geliştirme ortamı kurarken en çok vakit yediren şey, bağımlılıkların (veritabanı, cache, mesaj kuyruğu, reverse proxy vb.) makineden makineye farklı davranmasıdır. Docker Compose, birden fazla servisi tek bir dosyada tanımlayıp ayağa kaldırarak “bende çalıştı” problemini ciddi ölçüde azaltır. Bu yazıda PostgreSQL ve Redis’i, bir uygulama servisiyle birlikte aynı ağda koşturacak; kalıcı veri, healthcheck, profil ve ortam değişkeni yönetimi gibi ileri seviye pratiklere değineceğiz.

1) Proje yapısı: düzenli başlamak önemli

Örnek bir dizin yapısı oluşturalım. Terminalde bir klasör açıp içerisine aşağıdaki gibi dosyalar koymanız yeterli: docker-compose.yml, .env ve isterseniz uygulamanız için bir Dockerfile. Uygulama diliniz önemli değil; Compose tarafında servislerin birbirini görmesi ve konfigürasyonun taşınabilir olması hedef.

2) .env ile gizli bilgileri yönetmek

Compose dosyasına gömmek yerine şifreleri ve sık değişen değerleri .env içine almak daha temizdir. Proje köküne bir .env dosyası oluşturun ve örnek olarak şunları ekleyin: POSTGRES_DB=appdb, POSTGRES_USER=appuser, POSTGRES_PASSWORD=gucluSifre123, REDIS_PASSWORD=redisSifre123. Bu dosyayı versiyon kontrolüne koymamayı unutmayın; gerekirse örnek bir .env.example

3) docker-compose.yml: PostgreSQL + Redis + app

Aşağıdaki Compose tanımı, üç servisi aynı network üzerinde çalıştırır. PostgreSQL için kalıcı volume, Redis için parola ve iki servis için healthcheck ekledik. Uygulama servisini ise örnek bir “app” konteyneri olarak tanımlıyoruz; burada kendi Dockerfile’ınızı kullanabilir ya da hazır bir imajla test edebilirsiniz.

docker-compose.yml içeriği:

version: "3.9"
services:
  db:
    image: postgres:16-alpine
    container_name: local-postgres
    restart: unless-stopped
    environment:
      POSTGRES_DB: ${POSTGRES_DB}
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    ports:
      - "5432:5432"
    volumes:
      - pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
      interval: 5s
      timeout: 3s
      retries: 20

  redis:
    image: redis:7-alpine
    container_name: local-redis
    restart: unless-stopped
    command: ["sh", "-c", "redis-server --requirepass ${REDIS_PASSWORD}"]
    ports:
      - "6379:6379"
    healthcheck:
      test: ["CMD-SHELL", "redis-cli -a ${REDIS_PASSWORD} ping | grep PONG"]
      interval: 5s
      timeout: 3s
      retries: 20

  app:
    build: .
    container_name: local-app
    restart: unless-stopped
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_healthy
    environment:
      DATABASE_URL: postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@db:5432/${POSTGRES_DB}
      REDIS_URL: redis://:${REDIS_PASSWORD}@redis:6379/0
    ports:
      - "8080:8080"

volumes:
  pgdata:

4) Uygulama servisi için minimal Dockerfile fikri

“app” servisi için örnek bir Dockerfile ihtiyacınız olacak. Kendi stack’inize göre değişir; ancak temel prensip aynıdır: bağımlılıkları kur, kaynak kodu kopyala, uygulamayı çalıştır. Örneğin Node.js kullanıyorsanız node:20-alpine ile başlayabilir; Python’da python:3.12-slim tercih edebilirsiniz. Önemli nokta, Compose içindeki bağlantı adreslerinin db ve redis servis adları üzerinden verilmesidir; çünkü konteynerlar aynı Compose ağı içinde DNS ile birbirini bu isimlerle bulur.

5) Çalıştırma, log takibi ve durdurma

Kurulumdan sonra proje kökünde şu komut yeterlidir: docker compose up -d. İlk çalıştırmada imajlar indirileceği için birkaç dakika sürebilir. Servislerin durumunu görmek için docker compose ps, logları takip etmek için docker compose logs -f kullanın. Her şeyi kapatmak için docker compose down işinizi görür; veriyi de silmek istiyorsanız (PostgreSQL volume) docker compose down -v uygulayabilirsiniz.

6) Sık yapılan hatalar ve pratik ipuçları

En yaygın hata, uygulama içinde veritabanına localhost ile bağlanmaya çalışmaktır. Konteyner içinden “localhost”, o konteynerın kendisini ifade eder; bu yüzden bağlantı adresi db:5432 olmalı. İkinci hata, servisler hazır olmadan uygulamanın ayağa kalkmasıdır; burada kullandığımız healthcheck ve depends_on condition: service_healthy yaklaşımı bu sorunu büyük ölçüde azaltır. Son olarak, geliştirme sürecinde dosya değişikliklerini anında görmek istiyorsanız volumes ile proje klasörünü konteynere mount edebilir, fakat bu ayarı işletim sisteminize ve kullandığınız dile göre dikkatle yapmalısınız.

Sonuç: taşınabilir, tekrarlanabilir bir yerel ortam

Bu yapı sayesinde PostgreSQL ve Redis’i tek komutla ayağa kaldırıp uygulamanızla aynı ağda konuşturabilirsiniz. Üstelik ekipteki herkes aynı Compose dosyasını kullandığı için ortam farklılıkları azalır, hata ayıklama hızlanır. İsterseniz bir sonraki adım olarak profil ekleyip (ör. test/prod), ya da ters proxy (Nginx/Traefik) ile TLS ve routing katmanı ekleyerek daha da gerçekçi bir geliştirme ortamı kurabilirsiniz.

17 Aralık 2025 Çarşamba

Kubernetes’te Argo Rollouts ile Canary Dağıtımı: Adım Adım Kurulum ve Ölçüme Dayalı Otomasyon

Özet

Canary dağıtımı, üretimde yeni sürümü küçük bir trafik yüzdesiyle deneyerek hataları erken yakalamayı hedefleyen, modern ve güvenli bir yayınlama tekniğidir. Bu yazıda, Kubernetes üzerinde Argo Rollouts kullanarak canary dağıtımı nasıl kurulur, NGINX Ingress ile trafik nasıl paylaştırılır ve Prometheus ile ölçüme dayalı otomatik promosyon/geri alma (rollback) nasıl yapılır adım adım anlatıyorum.

Neden Argo Rollouts?

Argo Rollouts, Kubernetes’in Deployment nesnesine gelişmiş progressive delivery yetenekleri ekleyen bir CRD (Custom Resource Definition) çözümüdür. Canary, Blue/Green, A/B testleri, metric tabanlı onaylar, otomatik rollback ve NGINX/ALB/Istio gibi çoklu trafik yöneticileri desteği sunar. Tek komutla izleme ve görselleştirme sağlayan kubectl argo rollouts eklentisi ile süreç oldukça şeffaftır.

Gereksinimler

- Kubernetes 1.21+ bir küme (yerelde kind/minikube veya bulutta managed).
- kubectl ve yönettiğiniz namespace üzerinde yetki.
- NGINX Ingress Controller (canary anotasyonlarını destekleyen sürüm).
- Prometheus (temel HTTP başarı oranı ölçümü için).

Kurulum

1) Argo Rollouts CRD ve kontrol düzlemini kurun:
kubectl apply -f https://github.com/argoproj/argo-rollouts/releases/latest/download/install.yaml

2) Komut satırı eklentisini yükleyin (macOS örneği):
brew install argoproj/tap/kubectl-argo-rollouts
Linux/Windows için ikili dosyayı Argo Rollouts sürüm sayfasından indirip PATH’e ekleyebilirsiniz.

3) NGINX Ingress Controller kurulu değilse resmi manifest ya da Helm chart ile kurun. Trafik yönlendirme için Rollout nesnesinde trafficRouting: nginx kullanacağız.

Manifest Tasarımı

Canary stratejisinde iki Service kullanılır: stable ve canary. Ingress, Argo Rollouts tarafından ağırlıklandırılmış şekilde bu Service’lere trafik dağıtır. Aşağıdaki örnekler özlü tutulmuştur; isimleri ve etiketleri kendi uygulamanıza göre uyarlayın.

Stable ve Canary Service (aynı selector’ı paylaşır, Rollouts yönetir):
apiVersion: v1
kind: Service
metadata:
  name: myapp-stable
spec:
  selector:
   app: myapp
  ports:
  - port: 80
    targetPort: 8080

apiVersion: v1
kind: Service
metadata:
  name: myapp-canary
spec:
  selector:
   app: myapp
  ports:
  - port: 80
    targetPort: 8080

Ingress (Argo Rollouts, bu Ingress’i kullanarak NGINX canary anotasyonlarıyla ağırlık verir):
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: myapp-ingress
spec:
  rules:
 - host: myapp.example.com
   http:
    paths:
    - path: /
     pathType: Prefix
     backend:
      service:
       name: myapp-stable
       port:
        number: 80

AnalysisTemplate (Prometheus ile başarı oranı ölçümü):
apiVersion: argoproj.io/v1alpha1
kind: AnalysisTemplate
metadata:
  name: success-rate
spec:
  args:
  - name: service
  metrics:
  - name: http-success-rate
   interval: 30s
   count: 3
   successCondition: result[0] >= 0.99
   failureLimit: 1
   provider:
    prometheus:
     address: http://prometheus-server.monitoring.svc.cluster.local:9090
     query: sum(rate(http_requests_total{service="{{args.service}}",code=~"2.."}[1m])) / sum(rate(http_requests_total{service="{{args.service}}"}[1m]))

Rollout (canary adımları, NGINX trafik yönlendirme ve metrik analizi ile):
apiVersion: argoproj.io/v1alpha1
kind: Rollout
metadata:
  name: myapp
spec:
  replicas: 4
  selector:
   matchLabels:
    app: myapp
  template:
   metadata:
    labels:
     app: myapp
   spec:
    containers:
    - name: web
     image: ghcr.io/org/myapp:1.1.0
     ports:
     - containerPort: 8080
  strategy:
   canary:
    canaryService: myapp-canary
    stableService: myapp-stable
    trafficRouting:
     nginx:
      stableIngress: myapp-ingress
    steps:
    - setWeight: 20
    - pause: { duration: 120 }
    - analysis:
      templates:
      - templateName: success-rate
       args:
       - name: service
        value: myapp
    - setWeight: 50
    - pause: { duration: 120 }

Dağıtımı Başlatma ve İzleme

Manifestleri uygulayın: kubectl apply -f . Ardından rollout durumunu canlı izleyin: kubectl argo rollouts get rollout myapp -w. Eklenti, hangi adımda olunduğunu, mevcut ağırlığı ve analiz sonuçlarını gösterir. Metrikler eşik altında kalırsa Argo Rollouts otomatik rollback yapar; eşik üstünde ise bir sonraki adıma geçer ve sonunda sürüm terfi eder.

İpuçları ve En Sık Yapılan Hatalar

- Prometheus sorgunuzun doğru label’ları kullandığından emin olun. Bazı exporter’larda HTTP durum etiketi code yerine status olabilir.
- NGINX Ingress sürümünüzün canary anotasyonlarını desteklediğini doğrulayın; aksi halde ağırlıklandırma çalışmaz.
- Düşük trafik ortamlarında oran metrikleri dalgalıdır. interval ve count değerlerini artırmak yalancı negatifleri azaltır.
- Rollout öncesi readinessProbe ve livenessProbe ayarlarını düzgün yapılandırın; aksi halde analiz başlamadan pod’lar çakılabilir.

Performans ve Maliyet Değerlendirmesi

Canary adımları önemlidir çünkü ağ ve uygulama gecikmelerindeki küçük oynamaları yakalar. Ancak her adımda fazladan pod ve ölçüm maliyeti oluşur. Kritik servisler için 20%→50%→100% gibi 2-3 adıma bölmek çoğu senaryoda yeterli olur. Trafik çok yüksekse daha fazla adım ve daha uzun duraklatmalarla güvenlik marjı artırılabilir.

Sonuç

Argo Rollouts, Kubernetes üzerinde canary dağıtımını pratik ve güvenli hale getiriyor. NGINX Ingress ile trafik ağırlıklandırma ve Prometheus ile metrik bazlı doğrulama birleştiğinde, üretimde hataları kullanıcıların küçük bir yüzdesiyle sınırlayıp otomatik geri alma yapabilirsiniz. Küçükten başlayın, metriklerinizi doğrulayın ve ihtiyaçlarınıza göre adım sayısı ile eşikleri düzenleyerek olgun bir progressive delivery akışı elde edin.