---
title: 'Alan Adı Sistemi Tasarımı'
source: 'https://academia.sh/tr/kurslar/trafik-katmani/alan-adi-sistemi-tasarimi'
course: 'Trafik Katmanı'
language: tr
updated: '2026-08-17T18:11:02+00:00'
license: 'CC BY-SA 4.0'
---

# Alan Adı Sistemi Tasarımı

Ad çözümlemesinin bir yönlendirme kararı olarak tasarlanması: coğrafi, gecikmeye göre ve ağırlıklı politikaların aynı istek akışında ölçülmesi, ağırlıklı politikanın hedef payı neden tutamadığının çözümleyici payları üzerinden gösterilmesi ve yaşam süresinin devralma penceresini belirlemesiyle düşen isteğin giriş kursunun kesinti bütçesine çevrilmesi.

Sistem Tasarımına Giriş kursu bütün nitelikleri tanımladı, eşikleri koydu ve devralma kalıplarını
seçti. Bir şey eksik kaldı: istek daha sisteme **girmedi**. Takip sorgusu bir alan adının
çözülmesiyle başlar, bir kenar önbelleğinden geçebilir, bir yük dengeleyiciye düşer ve bir ağ
geçidinden uygulamaya ulaşır. O kursta önbellek yalnız hesapta bir çarpandı, yönlendirme ise
modelde tek satırlık bir seçimdi.

Bu kurs o yolu ele alır ve ilk durak ad çözümlemesidir. Alan adı sisteminin kendisi Bilgisayar
Ağları müfredatının İnternet Nasıl Çalışır kursunda kuruldu: hiyerarşi, çözümleme zinciri, kayıt
türleri ve yaşam süresi orada anlatıldı ve burada yeniden anlatılmaz. Buradaki soru başkadır: bir
adın altında birden çok bölge varken **hangi adresin döndürüleceği bir tasarım kararıdır** ve o
kararın ölçülebilir sonuçları vardır.

## Ad Katmanı Bir Karar Noktasıdır

Yetkili sunucu her sorguya aynı yanıtı vermek zorunda değildir. Sorunun nereden geldiğine ve
bölgelerin durumuna bakarak farklı adres döndürebilir. Bu seçime **yönlendirme politikası** denir
ve üç biçimi ayrılır.

**Coğrafi politika**, soranın bulunduğu bölgeye göre kaba bir tablodan yanıt verir: bu istemci
kümesi şu bölgeye gider. Tablo elle yazılır ve yanlış olabilir. **Gecikmeye göre politika**,
soranın hangi bölgeye daha yakın olduğunu ölçüme dayanarak seçer; coğrafi yakınlıkla ağ yakınlığı
aynı şey olmadığı için iki politika farklı yanıtlar üretir. **Ağırlıklı politika** bölgelere hedef
bir pay verir ve yanıtları o paya göre dağıtır; amacı yakınlık değil kapasite denetimidir.

Bir dördüncü kullanım politika değil arıza yanıtıdır: bir bölge erişilemez olduğunda yetkili
sunucu o bölgenin adresini yanıtlardan çıkarır. Bu **devralma**nın ad katmanındaki biçimidir ve
dersin ikinci yarısı onun bedelini ölçer.

## Düzenek

Ölçüm bir süreç içi modelle yapılır. Model bir yetkili sunucu, kırk çözümleyici ve üç bölge
tutar; bölgeler Erişilebilirlik Kalıpları dersinin `b34` ve `b35` bölgelerine `b06` eklenerek
kurulur. İstek hızı giriş kursundan gelir: uçta tepe 513,89 istek/s, yukarı yuvarlanarak 514.
Model dört yeni varsayım alır ve bunlar giriş kursunun V1–V13 tablosuna **eklenmez**; bu kursun
kendi varsayımlarıdır.

| Kod | Varsayım | Değer | Gerekçe |
|---|---|---|---|
| T1 | yaşam süresi (taban) | 300 sn | ad sahibinin seçtiği süre; ölçümde oynatılır |
| T2 | bölge sayısı | 3 | iki bölgeli devralmaya bir yedek bölge eklenmiştir |
| T3 | hedef pay | 0,50 / 0,30 / 0,20 | eski bölge ağır, yeni bölge hafif yüklenir |
| T4 | çözümleyici sayısı ve payı | 40, pay ~ 1/(j+1) | sorguların çoğu az sayıda büyük çözümleyiciden gelir |
| T5 | ölü bölgenin işaretlenme süresi | 10 sn | sağlık denetimi bir bölgeyi bu gecikmeyle ölü sayar |

Mesafe matrisi soyut birim cinsindendir ve **ölçülmüş gecikme değildir**; giriş kursunun tur
soyutlamasıyla aynı türdendir. Çözümleyicilerin önbellek fazları eşit aralıklarla dağıtılmıştır,
çünkü hepsinin aynı anda süre sonuna gelmesi ayrı bir sorundur ve Eşzamansız İşleme kursunda
sürü etkisi olarak ölçüldü.

```js
// ad/model.mjs — ad katmani modeli. Mesafe soyut birimdir, olculmus gecikme degildir;
// yasam suresi, algilama suresi ve ariza baslangici model parametresidir.
export const BOLGE = ["b34", "b35", "b06"];
export const GRUP = ["g1", "g2", "g3", "g4"];
export const MESAFE = {                       // birim; olculmus gecikme degil
  g1: { b34: 1, b35: 3, b06: 2 }, g2: { b34: 3, b35: 1, b06: 2 },
  g3: { b34: 2, b35: 4, b06: 1 }, g4: { b34: 2, b35: 3, b06: 4 },
};
export const COGRAFI = { g1: "b34", g2: "b35", g3: "b34", g4: "b06" };  // kaba bolge tablosu
export const YEDEK = { b34: "b06", b35: "b34", b06: "b35" };            // tablonun yedegi
export const DESEN = ["b34", "b35", "b06", "b34", "b35", "b34", "b35", "b06", "b34", "b34"];
export const AGIRLIK = { b34: 0.5, b35: 0.3, b06: 0.2 };  // T3: hedef pay, DESEN bunu verir
export const COZUMLEYICI = 40;    // T4
export const ALGILAMA = 10;       // T5: saglik denetiminin olu bolgeyi isaretlemesi (sn)
export const ISTEK_SANIYE = 514;  // K01 "tepe ucta 513,89 istek/s", yukari yuvarlanmis

// T4: cozumleyici paylari esit degil, pay ~ 1/(j+1); saniyedeki istek en buyuk kalanla bolunur.
const ham = Array.from({ length: COZUMLEYICI }, (_, j) => 1 / (j + 1));
const t0 = ham.reduce((a, b) => a + b, 0);
export const ISTEK = ham.map((p) => Math.floor((p / t0) * ISTEK_SANIYE));
for (const [, j] of ham.map((p, j) => [(p / t0) * ISTEK_SANIYE % 1, j]).sort((a, b) => b[0] - a[0])
  .slice(0, ISTEK_SANIYE - ISTEK.reduce((a, b) => a + b, 0))) ISTEK[j] += 1;

export function kosum({ politika, ttl, arizaBaslangic = null, sure = 3600, istek = ISTEK }) {
  const s = { kabul: 0, dusen: 0, yukariSorgu: 0, mesafe: 0, pencere: 0 };
  const bolgeIstek = Object.fromEntries(BOLGE.map((b) => [b, 0]));
  const bagli = new Array(COZUMLEYICI).fill(null);
  // isinma: onbellek fazlari esit araliklarla dagitilir, sayim t >= 1'de baslar
  const sonaErer = Array.from({ length: COZUMLEYICI }, (_, j) => 1 - ttl + ((j * 13) % ttl));
  let desenSira = 0;
  const olu = (b, t) => arizaBaslangic !== null && b === "b34" && t >= arizaBaslangic;
  const bilinen = (b, t) => olu(b, t) && t >= arizaBaslangic + ALGILAMA;

  const yetkili = (grup, t) => {
    if (politika === "cografi") {
      const b = COGRAFI[grup];
      return bilinen(b, t) ? YEDEK[b] : b;
    }
    if (politika === "gecikmeye-gore") {
      return BOLGE.filter((b) => !bilinen(b, t))
        .reduce((a, b) => (MESAFE[grup][b] < MESAFE[grup][a] ? b : a));
    }
    for (let k = 0; k < DESEN.length; k++) {         // agirlikli: desende siradaki canli bolge
      const b = DESEN[(desenSira + k) % DESEN.length];
      if (!bilinen(b, t)) { desenSira = (desenSira + k + 1) % DESEN.length; return b; }
    }
  };

  for (let t = 1 - ttl; t <= sure; t++) {
    for (let j = 0; j < COZUMLEYICI; j++) {
      if (t >= sonaErer[j]) {                       // yasam suresi doldu: yetkiliye sorulur
        bagli[j] = yetkili(GRUP[j % GRUP.length], t);
        sonaErer[j] = t + ttl;
        if (t >= 1) s.yukariSorgu += 1;
      }
      if (t < 1) continue;
      const n = istek[j], hedef = bagli[j];
      if (olu(hedef, t)) { s.dusen += n; s.pencere = t - arizaBaslangic + 1; continue; }
      s.kabul += n;
      s.mesafe += n * MESAFE[GRUP[j % GRUP.length]][hedef];
      bolgeIstek[hedef] += n;
    }
  }
  const pay = Object.fromEntries(BOLGE.map((b) => [b, bolgeIstek[b] / s.kabul]));
  const sapma = BOLGE.reduce((a, b) => a + Math.abs(pay[b] - AGIRLIK[b]), 0) / 2;
  return { ...s, pay, sapma, birimMesafe: s.mesafe / s.kabul };
}
```

## Üç Politika Aynı Akışta

```js
// ad/politika.mjs — uc yonlendirme politikasi ayni istek akisinda: bolge payi, hedef paydan
// sapma, istek basina mesafe birimi ve cozumleyicilerin yetkiliye sordugu ad sayisi
import { kosum, ISTEK, ISTEK_SANIYE, AGIRLIK, BOLGE } from "./model.mjs";

const TTL = 300, SURE = 3600;
console.log(`${SURE} sn, ${ISTEK_SANIYE} istek/s, yasam suresi ${TTL} sn, ` +
  `en buyuk cozumleyicinin payi %${((ISTEK[0] / ISTEK_SANIYE) * 100).toFixed(2)}`);
console.log(`hedef pay: ${BOLGE.map((b) => `${b}=%${AGIRLIK[b] * 100}`).join(" ")}`);
console.log();
console.log("politika        |   b34   b35   b06 | sapma | birim mesafe | yukari sorgu");
console.log("----------------|-------------------|-------|--------------|-------------");
for (const politika of ["cografi", "gecikmeye-gore", "agirlikli"]) {
  const r = kosum({ politika, ttl: TTL, sure: SURE });
  console.log(`${politika.padEnd(15)} |` +
    `${BOLGE.map((b) => `%${(r.pay[b] * 100).toFixed(1)}`.padStart(6)).join("")} | ` +
    `${r.sapma.toFixed(3).padStart(5)} | ${r.birimMesafe.toFixed(3).padStart(12)} | ` +
    `${String(r.yukariSorgu).padStart(12)}`);
}
console.log();
for (const ttl of [30, 60, 300, 900]) {
  const r = kosum({ politika: "agirlikli", ttl, sure: SURE });
  console.log(`agirlikli, ttl ${String(ttl).padStart(3)} sn -> sapma ${r.sapma.toFixed(3)}, ` +
    `yukari sorgu ${String(r.yukariSorgu).padStart(4)}`);
}

// T4'un duyarliligi: cozumleyici paylari esit olsa ayni politika ne kadar sapardi
const ESIT = Array.from({ length: 40 }, (_, j) => (j < 34 ? 13 : 12));   // toplam 514
const e = kosum({ politika: "agirlikli", ttl: TTL, sure: SURE, istek: ESIT });
console.log(`\nT4 duyarliligi: paylar esit olsa (ttl ${TTL}) sapma ${e.sapma.toFixed(3)}`);
```

```
3600 sn, 514 istek/s, yasam suresi 300 sn, en buyuk cozumleyicinin payi %23.35
hedef pay: b34=%50 b35=%30 b06=%20

politika        |   b34   b35   b06 | sapma | birim mesafe | yukari sorgu
----------------|-------------------|-------|--------------|-------------
cografi         | %57.6 %25.3 %17.1 | 0.076 |        1.710 |          480
gecikmeye-gore  | %55.1 %25.3 %19.6 | 0.051 |        1.171 |          480
agirlikli       | %50.6 %27.8 %21.6 | 0.022 |        2.144 |          480

agirlikli, ttl  30 sn -> sapma 0.082, yukari sorgu 4800
agirlikli, ttl  60 sn -> sapma 0.195, yukari sorgu 2400
agirlikli, ttl 300 sn -> sapma 0.022, yukari sorgu  480
agirlikli, ttl 900 sn -> sapma 0.037, yukari sorgu  160

T4 duyarliligi: paylar esit olsa (ttl 300) sapma 0.000
```

Sayılar **ölçüm** sınıfındadır: bu makinede koşan modelden çıkmıştır. Mesafe birimi model
parametresine bağlıdır, istek sayıları ise değildir.

Birinci tablo iki ölçütün ters yönde çalıştığını gösteriyor. Gecikmeye göre politika istek başına
1,171 mesafe birimiyle en yakın yerleşimi buluyor; coğrafi politika 1,710, ağırlıklı politika
2,144. Ağırlıklı politika en yakını arayan politikanın 1,83 katı mesafe üretiyor — bu oran birim
seçiminden bağımsızdır, çünkü iki koşum aynı matrisi kullanır. Karşılığında hedef paya en yakın
dağılımı o veriyor: sapma 0,022, coğrafi politikada 0,076. **Yakınlık ile pay denetimi aynı
politikada birlikte elde edilmiyor.**

Coğrafi politikanın 1,710'u tablonun elle yazılmasından geliyor. Dört istemci kümesinden ikisinde
tablo en yakın bölgeyi göstermiyor: `g3` kümesi için tablo `b34` diyor, matriste en yakın bölge
`b06`; `g4` için tablo `b06` diyor, en yakın `b34`. Coğrafi yakınlık ile ağ yakınlığı ayrıştığında
politika sessizce yanlış bölgeye gönderiyor ve bu ancak ölçülerek görülüyor.

İkinci tablo ağırlıklı politikanın asıl sorununu açıyor. Yaşam süresi kısaldıkça sapma
düzelmiyor: 0,082, 0,195, 0,022, 0,037 sırasıyla — düzensiz salınıyor. Buna karşılık yukarı sorgu
sayısı 160'tan 4800'e, otuz kata çıkıyor. Yani kısa yaşam süresi ödenen bedeli otuza katlıyor ve
karşılığında hedef paya yaklaşmayı sağlamıyor.

Son satır nedeni veriyor. Çözümleyici payları eşitlendiğinde aynı politikanın sapması 0,000'a
iniyor. Sapma yaşam süresinden değil, **denetim biriminin yanlış olmasından** geliyor: politika
payı *çözümleme* başına dağıtıyor, oysa yük *istek* başına geliyor. En büyük çözümleyici tek
başına isteklerin yüzde 23,35'ini taşıyor; bu, `b06` bölgesinin yüzde 20'lik hedef payının
tamamından büyüktür. O çözümleyici hangi bölgeye bağlanırsa o bölge hedefini aşar. Ad katmanı
istek düzeyinde bir denetim aracı değildir.

## Devralma Penceresi

Bir bölge erişilemez olduğunda yetkili sunucu onu yanıtlardan çıkarır, ama çıkarma anında
önbellekte duran yanıtlar geçerli kalır. Devralma penceresi bu yüzden iki parçadır: bölgenin ölü
işaretlenmesi (T5) ve önbellekteki yanıtın süresinin dolması (T1).

```js
// ad/devralma.mjs — b34 100. saniyede erisilemez oluyor. Yasam suresi devralma penceresini ve
// o pencerede dusen istegi belirliyor; butce sayilari K01 hesaplarindan alinmistir.
import { kosum, ALGILAMA, ISTEK_SANIYE } from "./model.mjs";

const ARIZA = 100, SURE = 1200;
const AYLIK_BUTCE_SN = (1 - 99.9 / 100) * 30 * 24 * 3600;  // K01: %99,9 -> aylik 43,2 dk
const K01_PASIF_DUSEN = 1541.67;                           // K01: etkin-pasif, 3 sn penceresi

console.log(`b34 ${ARIZA}. saniyede dusuyor, saglik denetimi ${ALGILAMA} sn sonra isaretliyor.`);
console.log(`aylik kesinti butcesi = ${(AYLIK_BUTCE_SN / 60).toFixed(1)} dk (%99,9)`);
console.log();
console.log("ttl | pencere | dusen istek | esdeger kesinti | butce payi | yukari sorgu");
console.log("----|---------|-------------|-----------------|------------|-------------");
for (const ttl of [30, 60, 300, 900]) {
  const r = kosum({ politika: "cografi", ttl, arizaBaslangic: ARIZA, sure: SURE });
  const esdeger = r.dusen / ISTEK_SANIYE;
  console.log(`${String(ttl).padStart(3)} | ${String(r.pencere).padStart(4)} sn | ` +
    `${String(r.dusen).padStart(11)} | ${esdeger.toFixed(2).padStart(12)} sn | ` +
    `${`%${((esdeger / AYLIK_BUTCE_SN) * 100).toFixed(2)}`.padStart(10)} | ` +
    `${String(r.yukariSorgu).padStart(12)}`);
}
const r = kosum({ politika: "cografi", ttl: 300, arizaBaslangic: ARIZA, sure: SURE });
console.log();
console.log(`ttl 300: pencere ${r.pencere} sn, esdeger kesinti ` +
  `${(r.dusen / ISTEK_SANIYE).toFixed(2)} sn -> pencerede trafigin ` +
  `%${((r.dusen / (r.pencere * ISTEK_SANIYE)) * 100).toFixed(1)}'i dustu`);
console.log(`K01 etkin-pasif devralmasi 3 sn'de ${K01_PASIF_DUSEN} istek dusurmustu; ` +
  `bu devralma onun ${(r.dusen / K01_PASIF_DUSEN).toFixed(1)} kati`);
```

```
b34 100. saniyede dusuyor, saglik denetimi 10 sn sonra isaretliyor.
aylik kesinti butcesi = 43.2 dk (%99,9)

ttl | pencere | dusen istek | esdeger kesinti | butce payi | yukari sorgu
----|---------|-------------|-----------------|------------|-------------
 30 |   39 sn |        6666 |        12.97 sn |      %0.50 |         1600
 60 |   69 sn |        9486 |        18.46 sn |      %0.71 |          800
300 |  305 sn |       57906 |       112.66 sn |      %4.35 |          160
900 |  905 sn |      190206 |       370.05 sn |     %14.28 |           64

ttl 300: pencere 305 sn, esdeger kesinti 112.66 sn -> pencerede trafigin %36.9'i dustu
K01 etkin-pasif devralmasi 3 sn'de 1541.67 istek dusurmustu; bu devralma onun 37.6 kati
```

Pencere yaşam süresini neredeyse birebir izliyor: 39, 69, 305 ve 905 saniye. Bu, yaşam süresinin
bir önbellek ayarı olmaktan çıkıp **devralma süresinin kendisi** olduğu anlamına gelir. Ad
sahibinin sorgu yükünü azaltmak için seçtiği sayı, aynı zamanda bir bölge düştüğünde trafiğin ne
kadar süre ölü adrese gitmeye devam edeceğini belirliyor.

Düşen istek ile eşdeğer kesinti arasındaki fark giriş kursunun bir ayrımını doğruluyor. Yaşam
süresi 300 saniyede pencere 305 saniye, ama düşen isteğin eşdeğeri yalnız 112,66 saniyedir:
pencerede trafiğin yüzde 36,9'u düşmüştür, tamamı değil. Erişilebilirliğin Sayısal İfadesi dersi
zaman tabanlı ile istek tabanlı ölçümün ayrıştığını söylemişti; bölgesel bir devralma tam olarak
o ayrımın düştüğü yerdir. Zaman tabanlı bakan biri 305 saniyelik kesinti sayar, istek tabanlı
bakan 112,66 saniyelik kesinti sayar ve ikisi de aynı olayı anlatır.

Bütçe payı sütunu kararı veriyor. Aylık bütçe yüzde 99,9 hedefinde 43,2 dakikadır. Yaşam süresi
900 saniyeyken tek bir bölge devralması bu bütçenin yüzde 14,28'ini harcıyor; 300 saniyede yüzde
4,35, 30 saniyede yüzde 0,50. Aynı olayın maliyeti yirmi sekiz kat değişiyor ve tek değişen ad
kaydındaki bir sayıdır.

Karşılaştırma son satırda tamamlanıyor. Erişilebilirlik Kalıpları dersindeki etkin–pasif devralma
üç saniyelik bir pencerede 1.541,67 istek düşürüyordu. Ad katmanındaki devralma, taban yaşam
süresiyle, onun 37,6 katını düşürüyor. **Ad katmanı elde bulunan en yavaş devralma aracıdır**;
kopya düzeyinde saniyelerle ölçülen bir geçiş, ad düzeyinde dakikalarla ölçülür. Bunun tasarım
sonucu, ad katmanının bölge seçimi için kullanılıp arıza yanıtı için tek başına
bırakılmamasıdır — pencereyi kapatan durak sonraki derslerin konusudur.

## Özet

- Ad çözümlemesi bir yönlendirme kararıdır: coğrafi politika kaba bir tablo, gecikmeye göre
  politika ölçülen yakınlık, ağırlıklı politika hedef pay üzerinden yanıt verir.
- Aynı akışta gecikmeye göre politika istek başına 1,171 mesafe birimi, coğrafi 1,710, ağırlıklı
  2,144 üretti; hedef paya en yakın dağılımı ise ağırlıklı politika verdi (sapma 0,022).
- Coğrafi tablonun elle yazılması ölçülebilir bir kusurdur: dört istemci kümesinden ikisinde
  tablo en yakın bölgeyi göstermiyordu.
- Ağırlıklı politikanın sapması yaşam süresi kısaldıkça düzelmedi (0,082–0,195 bandında salındı)
  ama yukarı sorgu otuz kata çıktı; paylar eşitlendiğinde sapma 0,000 oldu. Denetim birimi
  çözümlemedir, oysa yük istek başına gelir.
- Devralma penceresi yaşam süresini izliyor (39, 69, 305, 905 sn) ve tek bir bölge devralması
  aylık kesinti bütçesinin yüzde 0,50'sinden yüzde 14,28'ine kadar yer tutuyor.
- Yaşam süresi 300 saniyede pencere 305 saniye ama eşdeğer kesinti 112,66 saniyedir; ad
  katmanındaki devralma kopya düzeyindekinin 37,6 katı istek düşürür.

## Sonraki Adım

Ad katmanı isteğin **hangi bölgeye** gideceğini seçti ve bu seçimin bedelini iki yerde ödedi:
mesafe biriminde ve devralma penceresinde. Ama seçtiği şey bir adresti; istek o adrese vardığında
hâlâ uygulamaya ulaşmamıştır. Aradaki boşlukta isteği uygulamaya hiç ulaştırmadan yanıtlayabilecek
bir durak vardır. Önbellekleme Eşzamansız İşleme kursunda kurulmuştu, ama orada önbellek
uygulamanın yanındaydı; giriş kursunun hesabında da öyle varsayılmıştı ve yüzde 90 isabet oranı
`onbellek arkasi okuma/s` sayısını 41,67'ye indiriyordu. Sonraki ders aynı önbelleği bir yer
değiştirmeyle ele alır: aynı içerik uygulamanın yanında değil kullanıcının yanında tutulursa
uygulamaya ulaşan istek sayısına, sınırdan geçen bayta ve giriş kursunun hangi hesabına ne olur.
