Mikroservisler mi Monolit mi: Doğru Seçimi Yapmak
Mikroservisleri ne zaman kullanmalı, monolitik yapıyı ne zaman sürdürmeli. Gerçek deneyimlere dayalı pratik rehberlik.

Bir kurucu bana, henüz hiç kullanıcısı olmayan bir ürün için on bir servisten oluşan bir mimari diyagramı göstermişti. Ekip dört kişiden oluşuyordu. Her kutunun kendi deposu, kendi pipeline'ı ve kendi veritabanı vardı ve ilk sprint servis keşfine ayrılacaktı. Hangi sınırdan en çok emin olduklarını sordum. Uzun bir duraksamadan sonra cevap şuydu: "Hiçbirinden, ama büyük şirketler böyle yapıyor."
Bu cevap, tüm tartışmayı tek bir cümlede özetliyor. Mikroservisler, henüz sahip olmayabileceğiniz organizasyonel ve ölçekleme sorunlarına bir yanıttır ve ilk günden itibaren sabit bir maliyet taşırlar. Bu yazı, benim kullandığım karar rehberidir: nasıl seçim yapılır, kolayca bölünebilen bir monolit nasıl inşa edilir ve ilk servisinizi yeniden yazmadan nasıl ayırırsınız.
Hızlı çıkarımlar
- Yeni ürünler için varsayılan olarak monolitik bir yapı tercih edin. Doğru servis sınırlarını, alan bir süre üretimde kalana kadar bilemezsiniz.
- Her modül için tek bir genel giriş noktası olan ve araçlarla uygulanan sınırlara sahip modüler bir monolit, daha sonra bölme seçeneğini korur.
- Bir servisi, somut bir baskı (bağımsız ölçekleme, ekip sahipliği, farklı çalışma zamanı ihtiyaçları) nedeniyle ayırın, moda olduğu için değil.
- İlk ayırma, monolitik yapının zaten kullandığı aynı arayüzün arkasına taşınan, en az bağımlı modül olmalıdır.
- Her servis kendi verisine sahiptir. Paylaşılan bir veritabanı, ek ağ atlamaları olan bir monolit demektir.
Monolit mi yoksa mikroservislerle mi başlamalıyım?
Küçük bir ekip ve belirsiz bir ürün için monolitik bir yapıyla başlayın. Tek bir kod tabanı, tek bir dağıtım, gerçek bir yığın izi ile basit hata ayıklama ve IDE'nizin bir dakikada yapabileceği yeniden düzenleme anlamına gelir. Bileşenler arasında ağ olmadığı için gecikme, kısmi hata ve sürdürülecek bir serileştirme formatı yoktur. Tasarruf ettiğiniz çabayı ürüne harcarsınız.
Mikroservisleri, baskı gerçek olduğunda seçin: tek bir kod tabanında sürekli birbirinin ayağına basan büyük bir ekip, sistemin çok farklı oranlarda ölçeklenmesi veya dağıtılması gereken kısımları ya da bir CRUD API'sinin yanında GPU'ya bağımlı bir model sunucusu gibi farklı çalışma zamanı gereksinimleri olan bileşenler. Kullandığım kabaca bir eşik, kararlı, iyi anlaşılmış alan sınırlarına sahip yaklaşık on veya daha fazla kişiden oluşan bir ekiptir. Bunun altında, tasarruf ettiğiniz koordinasyon, eklediğiniz operasyonel yükü nadiren karşılar.
Mikroservisler size aslında neye mal olur?
Faydaları gerçektir: her şeyi yerine tek bir yoğun servisi ölçeklendirin, ekiplerin bağımsız dağıtım yapmasına izin verin ve bir servisteki hatanın diğerlerini çökertmesini engelleyin. Maliyetler anında ortaya çıkar ve asla durmaz. Dağıtılmış izlemeye ihtiyacınız var, çünkü bir istek artık süreçler arası geçiş yapıyor. Servislerin nasıl konuşacağına karar vermeniz gerekiyor ki bu, REST vs gRPC vs kuyruklar: protokolü nasıl seçerim başlıklı yazıda ayrı bir konudur. Servisler arası işlemleri kaybedersiniz ve nihai tutarlılık için tasarım yapmanız gerekir. Yerel geliştirme, test etme ve nöbetçi olma hepsi zorlaşır. Ekipte daha önce dağıtılmış bir sistem işletmiş kimse yoksa, bu öğrenme eğrisi için açıkça bütçe ayırın.
Daha sonra bölünebilecek modüler bir monolit nasıl inşa ederim?
Modüler bir monolit, katı iç sınırlara sahip, tek bir dağıtılabilir birimdir. Amaç, bir modülü kendi servisine taşımanın bir arkeoloji projesi yerine mekanik bir değişiklik haline gelmesidir. Kural basittir: modüller birbirleriyle yalnızca küçük bir genel arayüz aracılığıyla konuşur, asla birbirlerinin iç yapıları üzerinden değil.
src/
modules/
billing/
index.ts <- diğer modüllerin içe aktarabileceği tek dosya
internal/ <- tablolar, sorgular, yardımcılar: özel
catalog/
orders/
shared/ <- yalnızca loglama, yapılandırma, küçük yardımcı programlar
Her modülün sözleşmesini bir arayüz olarak tanımlayın ve bağımlılık olarak geçirin:
// src/modules/billing/index.ts
export interface BillingApi {
chargeOrder(orderId: string, amountCents: number): Promise<{ paymentId: string }>;
}
export { createBilling } from "./internal/create-billing";
// src/modules/orders/place-order.ts
import type { BillingApi } from "../billing";
export async function placeOrder(billing: BillingApi, orderId: string, totalCents: number) {
const { paymentId } = await billing.chargeOrder(orderId, totalCents);
return { orderId, paymentId };
}
Kurallar zorlama olmadan aşınır, bu yüzden bir aracın derlemeyi başarısız etmesine izin verin. With dependency-cruiser, tek bir kural, başka bir modülden index.ts dışındaki herhangi bir şeyi içe aktarmayı yasaklar:
// .dependency-cruiser.cjs
module.exports = {
forbidden: [
{
name: "no-deep-imports-across-modules",
severity: "error",
from: { path: "^src/modules/([^/]+)/" },
to: {
path: "^src/modules/[^/]+/(?!index\\.ts$)",
pathNot: "^src/modules/$1/",
},
},
],
};
Ayrıca her modüle kendi veritabanı tablolarını verin ve modül sınırları arasında birleştirmelerden (join) kaçının. Bu tek alışkanlık, daha sonra ayırmanın bir hafta mı yoksa bir çeyrek mi süreceğini belirler. Bu iki uç nokta arasındaki daha geniş seçenek haritasını istiyorsanız, monolit ve mikroservisler arasındaki adım katmanlı, olay odaklı ve hegzagonal stilleri karşılaştırır.
Bir servisi ayırma zamanının geldiğini gösteren sinyaller nelerdir?
Fikirlere değil, kanıtlara bakın:
- Bir modül, diğer her şeyin on katı örneğe ihtiyaç duyuyor ve bunun için tüm monoliti ölçeklemek pahalı.
- İki ekip, aynı dağıtımı paylaştıkları için sürekli olarak birbirlerinin yayınlarını engelliyor.
- Bir bileşen farklı bir dil veya çalışma zamanı ya da farklı bir güvenlik sınırı (örneğin ödemeler) gerektiriyor.
- Bir kısmın yayın döngüsü, geri kalanından çok farklı.
Bunlardan hiçbiri doğru değilse, ayırma faydasız bir maliyettir. Adayın gerçekten ayrılabilir bir birim olup olmadığını kontrol etmek için veriler etrafında çizilmiş alan sınırlarını, isimler etrafında değil kullanın.
İlk servisi güvenli bir şekilde nasıl ayırırım?
En az bağımlı modülü seçin ve aynı arayüzü koruyun. BillingApi ayrımının arkasında, süreç içi uygulamayı bir HTTP istemcisiyle değiştirin. Çağıran kod değişmez:
export function createBillingHttpClient(baseUrl: string): BillingApi {
return {
async chargeOrder(orderId, amountCents) {
const res = await fetch(`${baseUrl}/charges`, {
method: "POST",
headers: { "content-type": "application/json", "idempotency-key": orderId },
body: JSON.stringify({ orderId, amountCents }),
signal: AbortSignal.timeout(3000),
});
if (!res.ok) throw new Error(`billing responded ${res.status}`);
return (await res.json()) as { paymentId: string };
},
};
}
Nelerin değiştiğine dikkat edin: bir zaman aşımı, bir idempotency anahtarı ve süreç içinde var olmayan bir hata yolu. Bunlar artık sizin sorumlu olduğunuz yeni hata modlarıdır. Ardından, strangler (boğucu) desenini kullanarak harici trafiği kademeli olarak yönlendirin. Bir ters proxy, bir yolu aynı anda taşımanıza ve tek bir satırı düzenleyerek geri almanıza olanak tanır:
upstream monolith { server app:3000; }
upstream billing_service { server billing:4000; }
server {
listen 80;
location /api/billing/ { proxy_pass http://billing_service; }
location / { proxy_pass http://monolith; }
}
Mümkünse her iki uygulamayı bir süre paralel çalıştırın, sonuçları karşılaştırın ve ancak ondan sonra eski kod yolunu silin.
Ekipler en sık hangi hataları yapar?
- Mikroservislerle başlamak. Sınırları yanlış tahmin edersiniz ve kodun servisler arasında taşınması, modüller arasında taşınmasından çok daha pahalıdır.
- Yanlış servis sınırları. Teknik katmana veya isme göre kesmek, çok konuşkan servislere yol açar. İş yeteneğine ve veri sahipliğine göre kesin.
- Paylaşılan bir veritabanı. İki servis aynı tabloları okuyup yazıyorsa, onları en önemli şekilde birbirine bağlamışsınız demektir.
- Operasyonları göz ardı etmek. İzleme, izleme (tracing), uyarı ve nöbetçi olma, ikinci servis yayına girmeden önce var olmalıdır, ilk kesintiden sonra değil.
Bu hafta ne yapmalıyım?
En büyük kod tabanınızı alın ve modüllerini kağıt üzerine çizin. Her çift için, genel bir arayüzü atlayan içe aktarmaları sayın. En karmaşık tek çifti seçin, aralarına bir arayüz ekleyin ve yukarıdaki dependency-cruiser kuralını uyarı modunda ekleyin. Bir sonraki sprintte, uyarıları hatalara dönüştürün. Ya hiç mikroservislere ihtiyacınız olmadığını keşfedeceksiniz ya da ilk ayırmayı sıkıcı hale getiren ön çalışmayı yapmış olacaksınız.
Uğur Kaval
Modern teknolojilerle yenilikçi çözümler geliştirmede uzmanlaşmış AI/ML Mühendisi & Full Stack Geliştirici. Otomasyon, makine öğrenmesi ve web geliştirme tutkunu.


