---
title: 'Değişmez Altyapı'
source: 'https://academia.sh/tr/kurslar/kod-olarak-altyapi/degismez-altyapi'
course: 'Kod Olarak Altyapı'
language: tr
updated: '2026-08-17T18:09:06+00:00'
license: 'CC BY-SA 4.0'
---

# Değişmez Altyapı

On iki makinelik bir filo sekiz dönem boyunca iki yolla güncellenir: yerinde yama ve imajdan yeniden oluşturma. Aynı olay dizisi iki yolda oynatılır; birbirinden ayrışan sunucu sayısı, güncelleme süresi, geri alma turu, yeniden oluşturmanın taşıyamadığı yerel durum ile bağlantı, ve yeniden oluşturmanın hiçbir şey kazandırmadığı durum sayılır.

Önceki iki ders altyapıyı yerinde değiştirdi: kuyruğun bölüm sayısı arttı, makine sayısı arttı, var
olan kaynaklara dokunulmadı. Bir makinenin üzerindeki paket sürümü de aynı yolla ilerler — makine
aynı makine kalır, üzerindeki yazılım değişir. Bu **yerinde yama**dır ve her uygulaması makinenin
geçmişine bir katman ekler.

İkinci yol makineye hiç dokunmaz: yeni bir imaj hazırlanır, eski makine kapatılır, yerine imajdan
yeni bir makine doğar. **Değişmez altyapı** budur — koşan bir kaynak değiştirilmez, yerine yenisi
konur. Bu ders aynı güncellemeyi sekiz dönem boyunca iki yolla koşturur ve dört şey sayar:
birbirinden **ayrışan sunucu** sayısı, güncelleme süresi, geri alma turu, ve yeniden oluşturmanın
**taşıyamadığı** şey. Sonunda yeniden oluşturmanın hiçbir şey kazandırmadığı durum da aynı ölçüyle
gösterilir.

Filo **bölgesel ölçüm ağı**nın toplayıcı makineleridir: sayaç okumalarını sahadan alıp kuyruğa
yazan **kurgu** yazılım. Makineler gerçekten kurulmaz; filo, olaylar ve süreler `node` ile
modellenir ve üreteç kendi yazılıdır.

**AT13.** Filo on iki makinedir ve sekiz dönem güncellenir. Bir makinenin **parmak izi** sürümü ile
taşıdığı izlerden oluşur; iki makine aynı parmak izini taşıyorsa ayrışmamıştır.
**AT14.** Olaylar bir kez üretilir (tohum 8140723, üreteç kendi yazılıdır) ve iki yolda **aynı
sırayla** oynatılır; aradaki fark yoldan gelir, olaydan değil.
**AT15.** Bir dönemde makine başına yamanın düşme olasılığı 0,10; bir acil düzeltme uygulanma
olasılığı 0,10'dur.
**AT16.** Yeniden oluşturma yolunda makine her dönem geçerli imajdan doğar. Dönem içinde uygulanan
acil düzeltme çift dönemlerde imaja işlenir, tek dönemlerde **kaybolur**.
**AT17.** Süreler: yerinde yama 40 saniye, yeniden oluşturma 360 saniye artı 90 saniye boşaltma;
dalga dört makinedir. Düşen yama iki kez daha denenir, düşen sağlık kontrolü bir tur daha.
**AT18.** Geri alma 3. ve 6. dönemde yapılır. Ters yama iz taşıyan makinede düşer ve her turda
kalanın yarısı düzelir.

## Filo ve Sekiz Dönem

```js
// filo.mjs — on iki makinelik toplayici filosunun sekiz donemi. Model; uretec kendi yazilidir.
export const TOHUM = 8140723, MAKINE = 12, DONEM = 8;
const uretec = (t) => () => (t = (t * 1103515245 + 12345) % 2147483648) / 2147483648;

// Olaylar bir kez uretilir ve iki yolda ayni sirayla oynatilir; boylece fark yoldan gelir.
const r = uretec(TOHUM);
export const olay = [];
for (let d = 1; d <= DONEM; d++)
  for (let m = 0; m < MAKINE; m++)
    olay.push({ d, m, yamaDuser: r() < 0.10, acil: r() < 0.10 });
const donemin = (d) => olay.filter((o) => o.d === d);
const imza = (x) => `${x.surum}|${[...x.iz].sort().join(",")}`;
export const ayrisan = (s) => new Set(s.map(imza)).size;
const bosFilo = () => Array.from({ length: MAKINE }, () => ({ surum: "1.0.0", iz: new Set() }));

export const yolYerinde = () => {                        // yerinde yama: iz birikir, silinmez
  const s = bosFilo(), dizi = [];
  let dusen = 0, acil = 0;
  for (let d = 1; d <= DONEM; d++) {
    for (const o of donemin(d)) {
      if (o.yamaDuser) { s[o.m].iz.add(`yarim-yama-${o.d}`); dusen++; }
      else s[o.m].surum = `1.${d}.0`;
      if (o.acil) { s[o.m].iz.add(`acil-${d}`); acil++; }
    }
    dizi.push(ayrisan(s));
  }
  return { s, dizi, dusen, acil, kaybolan: 0 };
};

export const yolYeniden = () => {                        // yeniden olusturma: her donem imajdan
  const s = bosFilo(), dizi = [], imajIz = new Set();
  let dusen = 0, acil = 0, kaybolan = 0;
  for (let d = 1; d <= DONEM; d++) {
    for (let m = 0; m < MAKINE; m++) s[m] = { surum: `1.${d}.0`, iz: new Set(imajIz) };
    const islenecek = [];
    for (const o of donemin(d)) {
      if (o.yamaDuser) dusen++;                          // saglik kontrolu duser: bir tur daha
      if (o.acil) { acil++; s[o.m].iz.add(`acil-${d}`);  // donem icinde tek makineye uygulanir
        if (d % 2 === 0) islenecek.push(`acil-${d}`); else kaybolan++; }
    }
    dizi.push(ayrisan(s));
    for (const x of islenecek) imajIz.add(x);            // cift donemde duzeltme imaja islenir
  }
  return { s, dizi, dusen, acil, kaybolan };
};
```

## Ölçüm

```js
// olc.mjs — ayrisma, guncelleme suresi, geri alma turu ve yeniden olusturmanin tasiyamadigi.
import { TOHUM, MAKINE, DONEM, olay, ayrisan, yolYerinde, yolYeniden } from "./filo.mjs";

const A = yolYerinde(), B = yolYeniden();
console.log(`tohum ${TOHUM}   makine ${MAKINE}   donem ${DONEM}   olay ${olay.length}`);
console.log(`donem donem ayrisan sunucu (tekil parmak izi)`);
console.log(`  yerinde yama       ${A.dizi.join("  ")}   -> son ${ayrisan(A.s)}/${MAKINE}`);
console.log(`  yeniden olusturma  ${B.dizi.join("  ")}   -> son ${ayrisan(B.s)}/${MAKINE}`);
console.log(`  dusen yama/saglik ${A.dusen}   acil duzeltme ${A.acil}` +
  `   imaja islenmeyip kaybolan ${B.kaybolan}\n`);

// Sureler saniyedir; dalga 4 makinedir. Yerinde yama 40 sn, yeniden olusturma 360 sn + 90 sn bosaltma.
const DALGA = Math.ceil(MAKINE / 4), YAMA = 40, KUR = 360, BOSALT = 90;
const donemDusen = (d) => olay.filter((o) => o.d === d && o.yamaDuser).length;
let sA = 0, sB = 0;
for (let d = 1; d <= DONEM; d++) {
  sA += DALGA * YAMA + donemDusen(d) * 2 * YAMA;          // dusen yama iki kez daha denenir
  sB += DALGA * (BOSALT + KUR) + donemDusen(d) * KUR;     // dusen saglik kontrolu bir tur daha
}
console.log(`guncelleme suresi (${DONEM} donem toplami, saniye)`);
console.log(`  yerinde yama       ${sA}   donem ortalamasi ${(sA / DONEM).toFixed(0)}`);
console.log(`  yeniden olusturma  ${sB}   donem ortalamasi ${(sB / DONEM).toFixed(0)}` +
  `   oran ${(sB / sA).toFixed(1)} kat\n`);

// Geri alma: 3. ve 6. donemin guncellemesi geri alinir. Ters yama, iz tasiyan makinede duser.
const geriAl = (s) => {
  const izli = s.filter((x) => x.iz.size).length;
  let tur = 1, kalan = izli;
  while (kalan > 0 && tur < 3) { kalan = Math.floor(kalan / 2); tur++; }
  return { tur: kalan > 0 ? tur + 1 : tur, izli, elle: kalan };
};
const g = geriAl(A.s);
console.log(`geri alma (3. ve 6. donem, iki kez)`);
console.log(`  yerinde yama       tur ${g.tur} x 2 = ${g.tur * 2}   ters yamanin dustugu makine` +
  ` ${g.izli}   elle onarim kalan ${g.elle}`);
console.log(`  yeniden olusturma  tur 1 x 2 = 2   onceki imaj etiketi secilir, filo ayni` +
  ` ${DALGA * (BOSALT + KUR)} saniyede doner\n`);

// Yeniden olusturmanin tasiyamadigi: yerel durum, acik baglanti, sicak onbellek.
const TAMPON = 1800, ISLEM = 20, BAGLANTI = 40, ISINMA = 720, OKUMA = 15, KAT = 3.4;
console.log(`yeniden olusturmanin tasiyamadigi (donem basina, ${MAKINE} makine)`);
console.log(`  kuyruk tamponu     bosaltma yoksa dusen okuma ${MAKINE * TAMPON}` +
  `   bosaltma varsa ek sure ${DALGA * BOSALT} sn (tampon ${TAMPON / ISLEM} sn'de biter)`);
console.log(`  acik baglanti      kopan ${MAKINE * BAGLANTI}   yerinde yamada 0`);
console.log(`  sicak onbellek     isinma ${ISINMA} sn, veri deposu okumasi ${KAT} kat` +
  `   ek okuma ${MAKINE * ISINMA * OKUMA * (KAT - 1)}\n`);

// Yeniden olusturmanin kazandirmadigi durum: tek makineli, durum tasiyan veri deposu.
const VERI_GB = 400, HIZ_MBS = 180;
const tasima = Math.round(VERI_GB * 1024 / HIZ_MBS);
console.log(`durum tasiyan tek makine (olcum deposu, ${VERI_GB} GB yerel veri)`);
console.log(`  yerinde yama ${YAMA} sn   yeniden olusturma ${tasima} sn` +
  ` (${(tasima / 60).toFixed(1)} dk, veri kopyalama ${HIZ_MBS} MB/sn)`);
console.log(`  ayrisan sunucu 1/1 -> 1/1   kazanc 0   bedel ${(tasima / YAMA).toFixed(0)} kat sure`);
```

```
tohum 8140723   makine 12   donem 8   olay 96
donem donem ayrisan sunucu (tekil parmak izi)
  yerinde yama       3  6  6  6  7  7  8  10   -> son 10/12
  yeniden olusturma  2  2  1  1  1  2  2  2   -> son 2/12
  dusen yama/saglik 7   acil duzeltme 9   imaja islenmeyip kaybolan 3

guncelleme suresi (8 donem toplami, saniye)
  yerinde yama       1520   donem ortalamasi 190
  yeniden olusturma  13320   donem ortalamasi 1665   oran 8.8 kat

geri alma (3. ve 6. donem, iki kez)
  yerinde yama       tur 4 x 2 = 8   ters yamanin dustugu makine 10   elle onarim kalan 2
  yeniden olusturma  tur 1 x 2 = 2   onceki imaj etiketi secilir, filo ayni 1350 saniyede doner

yeniden olusturmanin tasiyamadigi (donem basina, 12 makine)
  kuyruk tamponu     bosaltma yoksa dusen okuma 21600   bosaltma varsa ek sure 270 sn (tampon 90 sn'de biter)
  acik baglanti      kopan 480   yerinde yamada 0
  sicak onbellek     isinma 720 sn, veri deposu okumasi 3.4 kat   ek okuma 311040

durum tasiyan tek makine (olcum deposu, 400 GB yerel veri)
  yerinde yama 40 sn   yeniden olusturma 2276 sn (37.9 dk, veri kopyalama 180 MB/sn)
  ayrisan sunucu 1/1 -> 1/1   kazanc 0   bedel 57 kat sure
```

## Ayrışan Sunucu ve Geri Alma

Aynı doksan altı olay iki yolda oynatıldı ve sekiz dönem sonunda yerinde yama yolunda on iki
makineden **onu tekil** hâle geldi: on farklı parmak izi, yani ortalama 1,2 makinelik gruplar. Dizi
birikimi gösteriyor — üçten ona, hiç geri dönmeden. Yeniden oluşturma yolunda dizi bir ile iki
arasında salınıyor ve hiç birikmiyor. Aradaki fark bir dikkat farkı değil: iki yolda da yedi yama
düştü, dokuz acil düzeltme uygulandı. Yerinde yamada bunların izi makinede **kalır**; yeniden
oluşturmada bir sonraki dönem makine sıfırdan doğduğu için iz **silinir**.

Silinmenin bir bedeli var ve o da sayılı: dokuz acil düzeltmenin üçü imaja geri işlenmedi ve
kayboldu. Yeniden oluşturma, düzeltmenin imaja geri yazılmasını **zorunlu** kılar; yazılmazsa
düzeltme bir sonraki dönemde yok olur ve giderdiği sorun geri gelir. Yerinde yamada böyle bir
zorunluluk yoktur — düzeltme kalır. Ayrışmayı üreten şey tam olarak budur: kalıcılık.

Ayrışmanın maliyeti dizinin kendisinde görünmez; sonraki bir işlemde görünür. On tekil parmak izi
demek, bir sonraki değişikliğin on ayrı başlangıç durumunda denenmesi demektir. Bir yamanın bir
makinede çalışıp ötekinde çalışmaması artık bir olasılık değil, sekiz dönemin biriktirdiği
sonuçtur. Yeniden oluşturma yolunda aynı değişiklik en çok iki başlangıç durumunda denenir ve
ikisinden biri dönem içinde uygulanmış tek bir acil düzeltmedir — dönem kapandığında o da yok olur.

Süre tablosu ters yönde çalışıyor. Yeniden oluşturma sekiz dönemde 13.320 saniye, yerinde yama
1.520 saniye — **8,8 kat**. Dönem başına 190 saniye ile 1.665 saniye arasındaki fark, bir bakım
penceresinin boyutunu belirleyecek büyüklükte. Geri almada işaret değişiyor: yerinde yama iki geri
almada toplam sekiz tur harcadı, çünkü ters yama iz taşıyan on makinede düştü ve iki makine sonunda
elle onarıldı. Yeniden oluşturma iki turda bitti — önceki imaj etiketi seçilir, filo 1.350 saniyede
o etikete döner. Geri almanın **tur sayısı** ile **süresi** burada birbirinden ayrılıyor: yeniden
oluşturmanın turu tektir ve öngörülebilir, yerinde yamanınki ortamın biriktirdiği ize bağlıdır ve
önceden bilinemez.

## Yeniden Oluşturmanın Taşıyamadığı

Üçüncü tablo yeniden oluşturmanın bedelinin süreden ibaret olmadığını gösteriyor. Makine
kapatıldığında üzerinde taşıdığı üç şey vardır ve hiçbiri imajın parçası değildir. Kuyruk tamponunda
bekleyen okumalar: boşaltma yapılmazsa dönem başına 21.600 okuma düşer; boşaltma yapılırsa hiç
düşmez ama her dalgaya doksan saniye eklenir. Açık bağlantılar: sahadan gelen dört yüz seksen uzun
ömürlü bağlantı her dönemde kopar ve yeniden kurulur; yerinde yamada bu sayı sıfırdır. Sıcak
önbellek: yeni doğan makinenin önbelleği boştur, on iki dakikalık ısınma boyunca veri deposu
okuması 3,4 katına çıkar ve dönem başına 311.040 ek okuma doğar.

Üçünün de bir azaltma yolu var ve üçü de bedelini başka bir yere yazıyor. Boşaltma tamponu kurtarır
ve süreyi uzatır. Bağlantıların kopması, sahadaki birimin yeniden bağlanmayı beklemesi ve okumayı
yerelde tutmasıyla kayıpsız hâle gelir — ama bu, saha birimine bir tampon eklemek demektir.
Önbelleğin ısınması, makinenin trafiğe alınmadan önce ısıtılmasıyla gizlenir; o da dalga başına
ek süredir. Ölçü değişmiyor, yalnızca sütun değiştiriyor.

Bu üç kalemin ortak yanı, hiçbirinin **kayıtta yazılı olmaması**dır. İmaj sürümü, paket listesi ve
ayarlar kayda girer; tamponun doluluğu, bağlantı sayısı ve önbelleğin sıcaklığı girmez. Yeniden
oluşturma kayıtta yazılı olanı bire bir yeniden üretir ve kayıtta yazılı olmayanı **her seferinde
sıfırlar**. Ayrışmayı önleyen mekanizma ile yerel durumu yok eden mekanizma aynı mekanizmadır;
biri ötekinden ayrılamaz.

## Kazanç Sağlamadığı Durum

Son tablo yeniden oluşturmanın işe yaramadığı yeri gösteriyor. Ölçüm deposu tek makinedir ve
üzerinde dört yüz gigabayt yerel veri taşır. Tek makine olduğu için ayrışacak bir şey yoktur:
parmak izi sayısı yeniden oluşturmadan önce de sonra da birdir. Kazanç sıfırdır. Bedel ise
kopyalama süresidir — 2.276 saniye, yerinde yamanın **elli yedi katı** — ve bu sürenin tamamı veri
taşımaya gider, yazılım güncellemeye değil.

Aynı hesap ölçüm ağının öteki bileşenlerinde başka sonuç verir. Doğrulayıcı makineler durum
taşımaz ve dört tanedir; orada yeniden oluşturma toplayıcılardakine yakın bir kazanç üretir. Kuyruk
ile nesne deposu zaten sağlayıcının işlettiği kaynaklardır ve üzerlerinde yama uygulanacak bir
işletim ortamı yoktur; bu iki bileşende sorunun kendisi sorulmaz. Karar, filoyu tek parça
görmekten değil, **rol rol** ayırmaktan çıkıyor.

Buradan çıkan ölçüt tek cümledir: yeniden oluşturmanın kazancı, aynı rolü paylaşan makine sayısıyla
ve o makinelerde biriken izle orantılıdır. On iki toplayıcıda kazanç ondan bire iner; tek bir
durum taşıyan makinede kazanç yoktur. Değişmez altyapı bir ilke olarak değil, **rol rol** karar
verilir ve kararın girdisi bu iki sayıdır.

## Özet

- Aynı 96 olay iki yolda oynatıldığında yerinde yama 8 dönem sonunda 12 makinenin 10'unu tekil
  hâle getirdi (dizi 3'ten 10'a); yeniden oluşturmada dizi 1 ile 2 arasında kaldı.
- İki yolda da 7 yama düştü ve 9 acil düzeltme uygulandı; farkı üreten şey izin kalıcılığıydı.
- Yeniden oluşturma 9 acil düzeltmenin 3'ünü kaybetti; düzeltmenin imaja geri işlenmesi zorunluluk
  hâline geliyor.
- Güncelleme süresi yeniden oluşturmada 8,8 kat uzun (dönem başına 1.665'e karşı 190 saniye), ama
  geri alma 8 tur yerine 2 turda bitti ve turun sayısı önceden biliniyor.
- Yeniden oluşturmanın taşıyamadığı üç kalem dönem başına 21.600 düşen okuma, 480 kopan bağlantı ve
  311.040 ek veri deposu okumasıdır; durum taşıyan tek makinede kazanç 0, bedel 57 kat süredir.

## Sonraki Adım

Bu derste iki iş birbirine karıştı. İmajın hangi paketleri taşıdığı, makinenin üzerindeki ayarların
ne olduğu bir iştir; makinenin kaç tane olduğu, hangi ağa bağlandığı, hangi diski taşıdığı başka bir
iştir. Yerinde yama birincisine, yeniden oluşturma ikincisine dokunur — ve acil düzeltmenin
kaybolması tam olarak bu iki işin sınırında oldu.

Sonraki ders bu sınırı çizer. Bir ortamın kalemleri iki katmana bölünür — kaynağı yaratan katman ve
kaynağın içini ayarlayan katman — ve sınırın nereye çizildiği sayılır: kaç kalem her iki katmanda da
tanımlı, kaç kalem hiçbirinde, sınır kaydığında kaç kalem iki kez uygulanıyor ve iki katman aynı
kaleme yazdığında hangisi kazanıyor.
