---
title: 'Dağıtım Damgaları ve Coğrafi Kopyalar'
source: 'https://academia.sh/tr/kurslar/dayaniklilik-kaliplari/dagitim-damgalari-ve-cografi-kopyalar'
course: 'Dayanıklılık ve Güvenilirlik'
language: tr
updated: '2026-08-17T18:11:00+00:00'
license: 'CC BY-SA 4.0'
---

# Dağıtım Damgaları ve Coğrafi Kopyalar

Hizmetin kendi kendine yeten yinelenebilir birimlere bölünmesi: damga sınırını geçen bağların sayılması, her bileşenin bulaşma kapsamının üç yerleşimde karşılaştırılması, damgalar arasında paylaşılan tek kaynağın kapsamının damga sayısından bağımsız kalması ve damga başına düşen yükün K01 sayılarına çevrilmesi.

Önceki ders kopyaları alanlara ve bölgelere dağıttı, ama dağıtılan şey hep aynı bütündü: tek bir
hizmet, tek bir veri kümesi. Bir birimin kaybında ayakta kalan kapasitenin yüzde 66,7 ya da yüzde
50 çıkması, kaybedilen birimin hizmetin bir **kesirini** taşıdığını varsayıyordu. Çoğu düzende bu
varsayım tutmaz: birimlerin ortak bir noktası kalır ve o noktanın kaybı hepsini birden alır.

**Dağıtım damgası** (deployment stamp), hizmetin kendi kendine yeten ve yinelenebilir bir
kopyasıdır: uygulama, deposu, önbelleği ve kuyruğu bir arada. Aynı yapı bir ölçekleme birimi olarak
kullanıldığında **ölçek birimi** adını alır — kapasite artırmak yeni bir damga açmaktır. Terim,
Uygulama Katmanı ve Servis Etkileşimi kursundaki `sürüm damgası` ile karışmaz; o, bir kaydın hangi
sürümde yazıldığını gösteren bir işarettir, bu ise bir dağıtım birimidir.

## Damga Sınırı Nedir

Bir damga ancak sınırını geçen bağ yoksa kendi kendine yeter. Sınırı geçen her bağ, damganın
dışındaki bir şeyin ayakta olmasını gerektirir ve o şey düştüğünde damganın bağımsızlığı biter.
Bu yüzden bu dersin birinci ölçüsü **damgayı geçen bağ sayısıdır**.

Aşağıdaki düzenek bir **modeldir**: dokuz bileşen, üç akış ve üç yerleşim. Bileşenler damga içi ya
da damgalar arası paylaşılan olarak etiketlenir; akış, sırayla dokunduğu bileşenlerin listesidir.
Gerçek küme, bölge ya da kapsayıcı kurulmaz.

```js
// damga/model.mjs — dagitim damgasi MODELIDIR: bilesenler damga ici ya da damgalar arasi
// paylasilan olarak etiketlenir, akislar bilesen dizisidir. Gercek kume kurulmaz.
export const DAMGA = 4;
export const AKIS = {                          // her akisin sirayla dokundugu bilesenler
  takip: ["yonlendirme", "uc", "takip-servisi", "onbellek", "durum-deposu"],
  olay: ["yonlendirme", "uc", "olay-kuyrugu", "durum-deposu", "numara-dagitici"],
  ucret: ["ucret-isi", "durum-deposu", "tarife-deposu"],
};
export const YUK = { takip: 8, olay: 2, ucret: 1 };   // tur basina istek, K01 oranina yakin

const HEPSI = [...new Set(Object.values(AKIS).flat())];
export const YERLESIM = {                      // paylasilan olarak isaretlenmemis her sey damga ici
  "tek-parca": HEPSI,
  "paylasilan-damga": ["yonlendirme", "onbellek", "numara-dagitici", "tarife-deposu"],
  "kendine-yeten": ["yonlendirme"],
};
export const BILESENLER = HEPSI;

export const kapsam = (yerlesim, b) => (YERLESIM[yerlesim].includes(b) ? "paylasilan" : "damga");

export function damgaSayisi(yerlesim) {        // tek parca duzeninde damga kavrami yoktur
  return yerlesim === "tek-parca" ? 1 : DAMGA;
}

export function gecenBag(yerlesim) {           // damga siniri kac kez asiliyor
  let n = 0;
  for (const yol of Object.values(AKIS))
    for (let i = 0; i + 1 < yol.length; i += 1)
      if (kapsam(yerlesim, yol[i]) !== kapsam(yerlesim, yol[i + 1])) n += 1;
  return n;
}

export function bulasma(yerlesim, dusen) {     // bir bilesen dusunce etkilenen istek ve damga
  const d = damgaSayisi(yerlesim);
  const toplam = Object.values(YUK).reduce((a, b) => a + b, 0) * d;
  let etkilenen = 0;
  for (const [ad, yol] of Object.entries(AKIS)) {
    if (!yol.includes(dusen)) continue;
    etkilenen += kapsam(yerlesim, dusen) === "paylasilan" ? YUK[ad] * d : YUK[ad];
  }
  const damga = kapsam(yerlesim, dusen) === "paylasilan" ? d : 1;
  return { etkilenen, toplam, oran: etkilenen / toplam, damga, d };
}
```

```js
// damga/olc.mjs — uc yerlesimde damgayi gecen bag sayisi ve her bilesenin bulasma kapsami
import { AKIS, YERLESIM, BILESENLER, gecenBag, bulasma, damgaSayisi, kapsam } from "./model.mjs";

const s = (x, n) => String(x).padStart(n);
console.log(`${BILESENLER.length} bilesen, ${Object.keys(AKIS).length} akis, ` +
  `damga basina 8 takip + 2 olay + 1 ucret istegi.`);
console.log();
console.log("yerlesim          | damga | paylasilan bilesen | damga ici | damgayi gecen bag");
console.log("------------------|-------|--------------------|-----------|------------------");
for (const y of Object.keys(YERLESIM)) {
  const p = BILESENLER.filter((b) => kapsam(y, b) === "paylasilan").length;
  console.log(`${y.padEnd(17)} | ${s(damgaSayisi(y), 5)} | ${s(p, 18)} | ` +
    `${s(BILESENLER.length - p, 9)} | ${s(gecenBag(y), 17)}`);
}

console.log();
console.log("dusen bilesen    |       tek-parca | paylasilan-damga |   kendine-yeten");
console.log("-----------------|-----------------|------------------|----------------");
for (const b of BILESENLER) {
  const hucre = Object.keys(YERLESIM).map((y) => {
    const r = bulasma(y, b);
    return `%${(100 * r.oran).toFixed(1)} (${r.damga}/${r.d})`;
  });
  console.log(`${b.padEnd(16)} | ${s(hucre[0], 15)} | ${s(hucre[1], 16)} | ${s(hucre[2], 14)}`);
}
```

```
9 bilesen, 3 akis, damga basina 8 takip + 2 olay + 1 ucret istegi.

yerlesim          | damga | paylasilan bilesen | damga ici | damgayi gecen bag
------------------|-------|--------------------|-----------|------------------
tek-parca         |     1 |                  9 |         0 |                 0
paylasilan-damga  |     4 |                  4 |         5 |                 6
kendine-yeten     |     4 |                  1 |         8 |                 2

dusen bilesen    |       tek-parca | paylasilan-damga |   kendine-yeten
-----------------|-----------------|------------------|----------------
yonlendirme      |     %90.9 (1/1) |      %90.9 (4/4) |    %90.9 (4/4)
uc               |     %90.9 (1/1) |      %22.7 (1/4) |    %22.7 (1/4)
takip-servisi    |     %72.7 (1/1) |      %18.2 (1/4) |    %18.2 (1/4)
onbellek         |     %72.7 (1/1) |      %72.7 (4/4) |    %18.2 (1/4)
durum-deposu     |    %100.0 (1/1) |      %25.0 (1/4) |    %25.0 (1/4)
olay-kuyrugu     |     %18.2 (1/1) |       %4.5 (1/4) |     %4.5 (1/4)
numara-dagitici  |     %18.2 (1/1) |      %18.2 (4/4) |     %4.5 (1/4)
ucret-isi        |      %9.1 (1/1) |       %2.3 (1/4) |     %2.3 (1/4)
tarife-deposu    |      %9.1 (1/1) |       %9.1 (4/4) |     %2.3 (1/4)
```

## Bulaşma Kapsamı Neyin Sonucudur

Birinci tablo damgalamanın kâğıt üzerindeki ölçüsünü veriyor. Tek parça düzende damga sınırı yok,
dolayısıyla geçen bağ da yok — ama bağımsız birim de yok. Dört damga açıldığında paylaşılan bileşen
sayısı dörde inip geçen bağ 6 oluyor; paylaşılanlar damgaya taşındığında geçen bağ 2'ye iniyor.
**Damga sayısı bağımsızlığı vermez; paylaşılan bileşen sayısı verir.**

İkinci tablo bunun karşılığını her bileşen için ayrı ayrı sayıyor. Damga içi bileşenlerde kapsam
dörde bölünüyor: uç bileşeninin kaybı yüzde 90,9'dan yüzde 22,7'ye, durum deposunun kaybı yüzde
100'den yüzde 25'e iniyor ve etkilenen damga 4'ten 1'e düşüyor. Kalıbın vaadi bu sütundur.

Paylaşılan bileşenlerde ise damgalama hiçbir şey yapmıyor. Önbellek ortada kaldığında kaybı
tek parça düzenle aynı: yüzde 72,7 ve 4/4 damga. Damgaya taşındığında yüzde 18,2 ve 1/4 oluyor.
Aynı desen numara dağıtıcı (yüzde 18,2 → yüzde 4,5) ve tarife deposu (yüzde 9,1 → yüzde 2,3) için
de geçerli. **Bir bileşen damga dışında kaldığı sürece damga sayısını artırmak onun bulaşma
kapsamını değiştirmez.**

Yönlendirme eşlemesi satırı üç sütunda da aynı: yüzde 90,9 ve 4/4. Bu, hangi gönderinin hangi
damgada olduğunu bilen tek kaynaktır ve damgaya taşınamaz — taşınırsa isteğin hangi damgaya
gideceği bilinemez. Kalıbın sınırı budur: **damgalama bulaşma kapsamını sıfırlamaz, onu paylaşılan
kalan tek noktaya indirger.** O noktanın hizmet erişilebilirliği bütün sistemin üst sınırıdır ve
K01'in en zayıf halka kuralı burada birebir geçerlidir.

## Damga Sayısı Neyi Değiştirir

```js
// damga/yuk.mjs — damga sayisinin K01 yuklerine ve arizasiz gunun bedeline cevrilmesi
const TEPE_UC = 513.89;       // K01: tepe uctaki istek/s
const TEPE_YAZMA = 97.22;     // K01: tepe yazma istek/s
const DEPO = 138.89;          // K01: depoya ulasan istek/s
const GONDERI = 400_000;      // K01: gunluk gonderi
const DAMGA_ICI = 8;          // modelden: kendine-yeten yerlesimde damga ici bilesen sayisi
const b = (x, n = 2) => x.toFixed(n);

console.log(`${"damga".padStart(6)}${"damga basina uc".padStart(17)}${"damga basina depo".padStart(19)}` +
  `${"damga basina yazma".padStart(20)}${"bulasma kapsami".padStart(17)}${"gunluk gonderi".padStart(16)}`);
for (const n of [1, 2, 4, 8, 16]) {
  console.log(`${String(n).padStart(6)}${b(TEPE_UC / n).padStart(17)}${b(DEPO / n).padStart(19)}` +
    `${b(TEPE_YAZMA / n).padStart(20)}${("%" + b(100 / n)).padStart(17)}` +
    `${(GONDERI / n).toLocaleString("tr-TR").padStart(16)}`);
}

console.log(`\n${"damga".padStart(6)}${"toplam bilesen".padStart(16)}${"cografi kopyayla".padStart(18)}` +
  `${"ucret isinin dokundugu damga".padStart(30)}`);
for (const n of [1, 2, 4, 8, 16]) {
  const bilesen = DAMGA_ICI * n + 1;        // +1: paylasilan yonlendirme eslemesi
  console.log(`${String(n).padStart(6)}${String(bilesen).padStart(16)}` +
    `${String(DAMGA_ICI * n * 2 + 1).padStart(18)}${String(n).padStart(30)}`);
}
console.log(`paylasilan tek kaynagin bulasma kapsami damga sayisindan bagimsizdir: her zaman %90,9`);
```

```
 damga  damga basina uc  damga basina depo  damga basina yazma  bulasma kapsami  gunluk gonderi
     1           513.89             138.89               97.22          %100.00         400.000
     2           256.94              69.44               48.61           %50.00         200.000
     4           128.47              34.72               24.30           %25.00         100.000
     8            64.24              17.36               12.15           %12.50          50.000
    16            32.12               8.68                6.08            %6.25          25.000

 damga  toplam bilesen  cografi kopyayla  ucret isinin dokundugu damga
     1               9                17                             1
     2              17                33                             2
     4              33                65                             4
     8              65               129                             8
    16             129               257                            16
paylasilan tek kaynagin bulasma kapsami damga sayisindan bagimsizdir: her zaman %90,9
```

Birinci tablo damgalamanın ölçekleme yüzüdür: dört damgada damga başına uç yükü 128,47 istek/s,
depoya ulaşan 34,72 istek/s ve günlük 100.000 gönderi. K01'in bütün hesapları damga başına yeniden
okunabilir hâle geliyor ve bir damganın kapasitesi bilindiğinde kaç damga gerektiği bölmeyle
bulunuyor. Bulaşma kapsamı sütunu aynı bölmenin dayanıklılık yüzüdür ve ikisi aynı sayıdır — ölçek
birimi ile arıza yalıtım birimi burada çakışır.

İkinci tablo **arızasız günün bedelini** veriyor. Toplam bileşen sayısı damga sayısıyla doğrusal
büyüyor: bir damgada 9, on altı damgada 129. Her damganın ikinci bir bölgede **coğrafi kopyası**
tutulursa sayı ikiye katlanıyor: 257. Coğrafi kopya, damganın bütününün başka bir bölgede
çoğaltılmasıdır; çoğaltmanın mekaniği Veri Katmanı Ölçekleme kursunda kuruldu ve burada
tekrarlanmaz, buradaki yenilik çoğaltılan şeyin bir kayıt değil bir **dağıtım birimi** olmasıdır.

Son sütun damgalamanın en görünmeyen bedelidir. Gün sonu ücretlendirmesi bütün gönderilere
dokunmak zorundadır ve gönderiler damgalara bölünmüştür; iş on altı damgada on altı yere gitmek ve
sonuçlarını birleştirmek zorunda kalır. Damga başına düşen istek azalırken, damgayı **geçmek
zorunda olan** iş için dağılım bir maliyettir. Bu iş K01'in dört saatlik penceresine bağlıdır ve
pencere değişmiyor; değişen, işin kaç parçadan toplandığıdır.

## İki Günün Sayısı

**Arızasız günün bedeli** üç kalemdir. Bileşen sayısı 9'dan 33'e (dört damga), coğrafi kopyayla
65'e çıkıyor — her biri ayrı kurulan, ayrı yükseltilen ve ayrı izlenen birer birim. Gün sonu
ücretlendirmesi tek yerine dört yere gidiyor. Ve iki damgayı birden ilgilendiren bir sorgu, damga
sınırını geçtiği için tasarımda yeri olmayan bir işlem hâline geliyor; kendine yeten yerleşimde
sınırı geçen yalnız 2 bağ kalmıştı ve o iki bağ da yönlendirme eşlemesine gidiyordu.

**Arızalı günün kazancı** ikinci tablonun damga içi satırlarındadır. Aynı arıza — durum deposunun
kaybı — tek parça düzende isteklerin yüzde 100'ünü, dört damgalı düzende yüzde 25'ini, on altı
damgalı düzende yüzde 6,25'ini etkiliyor. Uç bileşeninin kaybı yüzde 90,9'dan yüzde 22,7'ye
iniyor. Bir arızanın süresi değişmiyor; değişen, o süre boyunca kaç kullanıcının etkilendiğidir ve
K01'in istek tabanlı erişilebilirlik ölçümü tam olarak bunu sayar.

İki günün karşılaştırması bir sınır da veriyor. Damga sayısını artırmak bulaşma kapsamını $1/n$ ile
küçültürken bileşen sayısını $n$ ile büyütüyor. Paylaşılan tek kaynağın kapsamı ise yüzde 90,9'da
duruyor ve hiç küçülmüyor; kalıbın kazancı bu tabanın üstünde kalan payla sınırlıdır.

## Özet

- Dağıtım damgası hizmetin kendi kendine yeten ve yinelenebilir bir kopyasıdır; ölçekleme birimi
  olarak kullanıldığında ölçek birimi adını alır ve sürüm damgasından ayrı bir kavramdır.
- Bağımsızlığın ölçüsü damga sayısı değil, damgayı geçen bağ sayısıdır: dört damgalı düzende
  paylaşılan bileşenlerle 6, paylaşılanlar damgaya taşındığında 2.
- Damga içi bileşenlerde bulaşma kapsamı dörde bölünüyor (durum deposu yüzde 100'den yüzde 25'e),
  paylaşılan bileşenlerde hiç değişmiyor (önbellek yüzde 72,7'de, 4/4 damgada kalıyor).
- Yönlendirme eşlemesi damgaya taşınamaz ve kapsamı üç yerleşimde de yüzde 90,9'dur: damgalama
  bulaşma kapsamını sıfırlamaz, paylaşılan kalan tek noktaya indirger.
- Damga sayısı K01 yüklerini doğrudan böler: dört damgada damga başına 128,47 istek/s uç, 34,72
  istek/s depo ve 100.000 günlük gönderi; bulaşma kapsamı aynı bölmedir.
- Arızasız günün bedeli bileşen sayısıdır: 9'dan dört damgada 33'e, coğrafi kopyayla 65'e; ayrıca
  gün sonu ücretlendirmesi damga sayısı kadar yere gitmek zorunda kalır.

## Sonraki Adım

Bu konu beş derste bir kurtarma düzeni kurdu: devralma eşiği ve geri dönüş politikası, sağlık
ucunun içeriği ve aralığı, kurtarma süresi ile veri kaybı hedefleri, alan ve bölge yerleşimi,
damgalar ve coğrafi kopyalar. Hepsinin sayıları bir modelden ya da aritmetikten çıktı ve hepsi bir
şeyi varsaydı: **plan yazıldığı gibi çalışacak.** Devralma eşiği doğru tetikleyecek, yedek kopya
gerçekten güncel olacak, ikinci bölge yükü kaldıracak, damgadaki her bileşen gerçekten damganın
içinde olacak. Bu varsayımların hiçbiri sınanmadı. Sonraki ders planı denetimli bir arıza
denemesiyle sınar: tatbikatın kendisi kesinti bütçesinden ne kadar yer tutuyor, hedeflenen kurtarma
süresi ile tatbikatta ölçülen arasındaki fark nedir ve tatbikatsız bir düzende ilk gerçek arıza
hangi varsayımları birden kırar.
