---
title: 'Hat ile Tümleştirme'
source: 'https://academia.sh/tr/kurslar/kod-olarak-altyapi/hat-ile-tumlestirme'
course: 'Kod Olarak Altyapı'
language: tr
updated: '2026-08-17T18:09:07+00:00'
license: 'CC BY-SA 4.0'
---

# Hat ile Tümleştirme

Altyapı değişikliği bir hattan geçirilir: plan aşaması ile uygulama aşaması ayrılır, arada onay durur. Onaycının okumadan onayladığı plan, plan ile uygulama arasında bayatlayan gerçek, hattın uygulama yetkisinin genişliği ve elle yapılan bir değişikliğin hattın sonraki koşumunda sessizce geri alınması, çakışması ya da hiç görülmemesi sayılır.

Önceki ders imajı pişirdi, ondan önceki ders ayarı uyguladı. İkisi de bir şeyi sormadı: bunları
kim tetikliyor ve kim onaylıyor. Bu kursun bütün ölçümleri elle çalıştırıldı ve elle çalıştırılan
bir akışta plan ile uygulama arasında bir insan durup ikisini art arda görür. Hat ikisini ayırır:
plan bir aşamada üretilir, saklanır, onaya sunulur; uygulama başka bir anda koşar. M22/K04 kapının
ne yakalayıp ne kaçırdığını ölçmüştü; o ölçü tekrarlanmaz, uygulanır.

**AD37.** Hat, bölgesel ölçüm ağının — su sayaçlarından okuma toplayan kurgu yazılımın — altyapı
kaydını iki aşamada koşturur, 30 günde 18 değişiklik geçirir. **AD38.** Planda bir kalem 3 satır
tutar, dakikada 12 satır okunur, 40 satırı geçen planı onaycı okumaz. **AD39.** Tohumlar
`20260901`–`20260903` görünürdür ve sayılar büyüklük mertebesidir.
**AD40.** Sağlayıcı 9 kaynak tipi ve 4 işlem sunar, ortamda 84 kurgu kaynak vardır, dar yetki son
12 koşumdan türetilir. **AD41.** 30 günde 26 elle değişiklik olur; dokunulan kalemin kayıt
kapsamında olma oranı 0,62, kapsamdakinin korumalı olma oranı 0,24, acil düzeltme oranı 0,35'tir.
**AD42.** Tazelik kapısı uygulama anında planı yeniden üretip onaylananla karşılaştırır ve
değişiklik başına 0,5 dakika ekler.

## Plan, Onay, Uygulama

Onay bir imzadır; ölçülebilir olan, arkasında ne kadar okuma olduğu ve imza ile uygulama arasında
ne kadar süre geçtiğidir — plan bir anın fotoğrafıdır ve bayatlar.

```js
// olcum-agi/hat.mjs — plan asamasi, onay, uygulama asamasi (model; urun degil tur)
export const uretec = (tohum) => () =>
  (tohum = (tohum * 1103515245 + 12345) % 2147483648) / 2147483648;

// kalem basina plan satiri; dakikada okunan satir; onaycinin okumayi biraktigi satir;
// tazelik kapisinin degisiklik basina ekledigi dakika.
const SATIR = 3, HIZ = 12, ESIK = 40, YENIDEN = 0.5;

// 30 gunde hattan gecen 18 altyapi degisikligi; nicelikler ureteçten gelir.
export const degisiklikler = (tohum = 20260901) => {
  const r = uretec(tohum);
  return Array.from({ length: 18 }, () => {
    const kalem = 1 + Math.floor(r() * 14);
    return { kalem, satir: kalem * SATIR + 6, bekleme: Math.round(r() * 470) / 10,
      degisti: r() < 0.3, sapan: 1 + Math.floor(r() * 3) };
  });
};

// kapi=true: uygulama aninda plan yeniden uretilip onaylananla karsilastiriliyor.
export const kosum = (liste, kapi) => {
  const okunmayan = liste.filter((d) => d.satir > ESIK);
  const bayat = liste.filter((d) => d.degisti);
  const sapan = bayat.reduce((t, d) => t + d.sapan, 0);
  return {
    korsan: okunmayan.length, korsanKalem: okunmayan.reduce((t, d) => t + d.kalem, 0),
    dakika: liste.reduce((t, d) =>
      t + (d.satir <= ESIK ? d.satir / HIZ : 0.5) + (kapi ? YENIDEN : 0), 0),
    bayat: bayat.length, korumasiz: kapi ? 0 : sapan, sapan,
    duran: kapi ? bayat.length : 0, uygulanan: 18 - (kapi ? bayat.length : 0),
  };
};

if (import.meta.url === `file://${process.argv[1]}`) {
  const liste = degisiklikler(), top = (a) => liste.reduce((t, d) => t + a(d), 0);
  console.log(`18 degisiklik, ${top((d) => d.kalem)} kalem, ${top((d) => d.satir)} plan satiri; ` +
    `plan ile uygulama arasi ortalama ${(top((d) => d.bekleme) / 18).toFixed(1)} saat\n`);
  console.log("tazelik kapisi".padEnd(16) + "onaylanan".padEnd(11) + "okunmadan".padEnd(11) +
    "okunmayan kalem".padEnd(17) + "gozden gecirme".padEnd(16) + "bayat plan".padEnd(12) +
    "korumasiz kalem".padEnd(17) + "uygulanan");
  for (const kapi of [false, true]) {
    const s = kosum(liste, kapi);
    console.log((kapi ? "var" : "yok").padEnd(16) + "18/18".padEnd(11) +
      `${s.korsan}/18`.padEnd(11) + `${s.korsanKalem}/${top((d) => d.kalem)}`.padEnd(17) +
      `${s.dakika.toFixed(1)} dk`.padEnd(16) + `${s.bayat}/18`.padEnd(12) +
      `${s.korumasiz}/${s.sapan}`.padEnd(17) + `${s.uygulanan}/18`);
  }
  const es = kosum(liste, false);
  console.log(`\nplan ${ESIK} satiri gectiginde onayci okumuyor: ${es.korsan} degisiklik, ` +
    `${es.korsanKalem} kalem denetimsiz onaylandi`);
}
```

```
18 degisiklik, 129 kalem, 495 plan satiri; plan ile uygulama arasi ortalama 28.6 saat

tazelik kapisi  onaylanan  okunmadan  okunmayan kalem  gozden gecirme  bayat plan  korumasiz kalem  uygulanan
yok             18/18      4/18       49/129           29.0 dk         3/18        5/5              18/18
var             18/18      4/18       49/129           38.0 dk         3/18        0/5              15/18

plan 40 satiri gectiginde onayci okumuyor: 4 degisiklik, 49 kalem denetimsiz onaylandi
```

On sekiz değişikliğin on sekizi onaydan geçti; onay oranı hiçbir şey söylemez. Söyleyen sayı
ikinci sütundadır: **4 plan okunmadan onaylandı** ve o dört plan 129 kalemin 49'unu taşıyordu —
kalemlerin yüzde otuz sekizi bakılmadan uygulandı. Bu bir dikkat sorunu değil ölçek sorunudur;
gözden geçirme yükü `bildirimsel-saglama/07`'de sayıldığı gibi doğrusal artar.

İkinci ölçü plan ile uygulama arasındaki süredir: ortalama **28,6 saat** ve bu sürede gerçek
durmaz. On sekiz planın **3'ü uygulandığında bayattı**, onaylanan planda yazmayan 5 kalem
uygulamaya girdi; onaylanan belge ile uygulanan iş aynı değildi.

**Bu kursun kapılarından biri yalnız burada işe yarar.** Biçim denetimi, politika taraması,
altyapı testi ve maliyet tahmini hattın dışında da koşabilir; tazelik kapısı koşamaz. Uygulama
anında planı yeniden üretip **onaylanan planla** karşılaştırmak, onaylanan planın saklanmış bir
belge olmasını gerektirir; elle koşan akışta arada saklanacak bir şey yoktur. Kapı 9 dakika ekliyor,
3 uygulamayı durduruyor ve 5 kalemi kurtarıyor.

## Hattın Yetkisi

Hat artık uygulamayı kendisi koşuyor ve bunun için altyapı üzerinde bir kimliği var. Yetki genişse
hat her şeyi yapar; o kimlik düşerse her şey yapılabilir hâle gelir.

```js
// olcum-agi/yetki.mjs — hattin altyapi uzerindeki uygulama yetkisi (model)
import { uretec, degisiklikler } from "./hat.mjs";

const TIP = ["makine", "disk", "ag", "alt ag", "guvenlik kurali", "kuyruk", "veri deposu",
  "nesne deposu", "kimlik"];
const ISLEM = ["yarat", "oku", "guncelle", "sil"];
const KAYNAK = [14, 22, 3, 6, 19, 2, 4, 3, 11];   // tip basina kurgu kaynak; toplam 84
const PENCERE = 12;   // yetkinin turetildigi gecmis kosum

// Her degisiklik birkac (tip, islem) ciftine dokunur; cift kumesi ureteçten gelir.
const dokunus = (tohum = 20260902) => {
  const r = uretec(tohum);
  return degisiklikler().map(() => {
    const c = new Set(), n = 1 + Math.floor(r() * 3);
    for (let i = 0; i < n; i++)
      c.add(`${TIP[Math.floor(r() * 9)]}/${ISLEM[Math.floor(r() * 4)]}`);
    return [...c];
  });
};

const d = dokunus();
const hepsi = TIP.flatMap((t) => ISLEM.map((i) => `${t}/${i}`));
const dar = [...new Set(d.slice(0, PENCERE).flat())];
const silmesiz = dar.filter((c) => !c.endsWith("/sil"));
const silinebilir = (y) => TIP.reduce((t, x, i) => t + (y.includes(`${x}/sil`) ? KAYNAK[i] : 0), 0);

console.log(`${TIP.length} kaynak tipi x ${ISLEM.length} islem = ${hepsi.length} islem; ` +
  `${KAYNAK.reduce((a, b) => a + b)} kurgu kaynak\n`);
console.log("yetki".padEnd(22) + "islem".padEnd(9) + "hattan gecen".padEnd(14) +
  "elde kalan".padEnd(12) + "silinebilir kaynak");
for (const [ad, y] of [["genis (hepsi)", hepsi], [`dar (${PENCERE} kosumdan)`, dar],
  ["dar, silmesiz", silmesiz]]) {
  const gecen = d.filter((c) => c.every((x) => y.includes(x))).length;
  console.log(ad.padEnd(22) + `${y.length}/36`.padEnd(9) + `${gecen}/18`.padEnd(14) +
    `${18 - gecen}/18`.padEnd(12) + `${silinebilir(y)}/84`);
}
const yeni = [...new Set(d.slice(PENCERE).flat())].filter((c) => !dar.includes(c));
console.log(`\ndar yetki gecmise bakarak turetildi; sonraki 6 kosumda ${yeni.length} yeni ` +
  `islem cifti cikti: ${yeni.join(", ")}`);
```

```
9 kaynak tipi x 4 islem = 36 islem; 84 kurgu kaynak

yetki                 islem    hattan gecen  elde kalan  silinebilir kaynak
genis (hepsi)         36/36    18/18         0/18        84/84
dar (12 kosumdan)     19/36    14/18         4/18        14/84
dar, silmesiz         18/36    13/18         5/18        0/84

dar yetki gecmise bakarak turetildi; sonraki 6 kosumda 5 yeni islem cifti cikti: alt ag/sil, kuyruk/guncelle, guvenlik kurali/sil, alt ag/yarat, disk/yarat
```

Geniş yetki tabloyu tek satırda bitirir: 36 işlemin 36'sı, 18 değişikliğin 18'i, elde kalan sıfır.
Son sütun karşılığıdır — hattın kimliği ele geçerse **84 kaynağın 84'ü** silinebilir; hat, bu
kursta yazılan hiçbir kaydın vermediği kadar geniş bir erişimdir.

Yetki geçmiş on iki koşuma bakılarak daraltıldığında işlem sayısı **19'a**, silinebilir kaynak
**14'e** iner; bedeli 18 değişikliğin **4'ünün elde kalmasıdır**. Silme yetkisi de alınınca
silinebilir kaynak sıfırlanır, elde kalan 5'e çıkar. Alt satır daraltmanın neden kalıcı olmadığını
yazar: sonraki altı koşumda hiç görülmemiş **5 yeni işlem çifti** çıktı. Geçmişten türetilen yetki
geleceğin işini elde bırakır ve elde kalanda ilk derste sayılan elle yol aynen sürer.

## Elle Değişiklik Hatta Çarpınca

Hat kurulduktan sonra da makinelere elle dokunulur; soru, o dokunuşa hattın sonraki koşumunda ne
olduğudur.

```js
// olcum-agi/carpisma.mjs — elle degisiklik hattin bir sonraki kosumunda ne oluyor (model)
import { uretec } from "./hat.mjs";

const KOSUM = [1.4, 3.1, 4.0, 6.8, 8.2, 9.9, 12.5, 14.1, 15.0, 17.7,
  19.2, 21.4, 22.8, 24.3, 25.1, 27.6, 28.9, 29.5];   // 18 hat kosumunun gunu (kurgu)
const KAPSAM = 0.62;    // elle dokunulan kalemin kayit kapsaminda olma orani
const KORUMA = 0.24;    // kapsamdaki kalemin korumali/yeniden olusturan olma orani

// 30 gunde elle yapilan 26 degisiklik; her biri tek bir kaleme dokunuyor.
const elle = (tohum = 20260903) => {
  const r = uretec(tohum);
  return Array.from({ length: 26 }, () => {
    const gun = Math.round(r() * 300) / 10;
    const kapsamda = r() < KAPSAM;
    return { gun, kapsamda, korumali: kapsamda && r() < KORUMA, acil: r() < 0.35 };
  });
};

const SONUC = { "sessizce geri alinan": [], "catisan (hat duruyor)": [], "fark edilmeyen": [] };
for (const o of elle()) {
  const sonraki = KOSUM.find((g) => g > o.gun);
  const ad = !o.kapsamda ? "fark edilmeyen"
    : o.korumali ? "catisan (hat duruyor)" : "sessizce geri alinan";
  // Kayit disi kalem hicbir kosumda gorulmez; gecikmesi de yoktur.
  const gecikme = !o.kapsamda || sonraki === undefined ? null : sonraki - o.gun;
  SONUC[ad].push({ ...o, gecikme });
}

console.log("26 elle degisiklik, 30 gun, 18 hat kosumu\n");
console.log("sonuc".padEnd(24) + "adet".padEnd(9) + "acil".padEnd(8) + "gecikme");
for (const [ad, liste] of Object.entries(SONUC)) {
  const g = liste.map((o) => o.gecikme).filter((v) => v !== null);
  console.log(ad.padEnd(24) + `${liste.length}/26`.padEnd(9) +
    String(liste.filter((o) => o.acil).length).padEnd(8) +
    (g.length ? `${(g.reduce((a, b) => a + b, 0) / g.length).toFixed(1)} gun` : "-"));
}
const geri = SONUC["sessizce geri alinan"];
console.log(`\ngeri alinan ${geri.length} degisiklik hata uretmedi, hepsi planda birer satirdi; ` +
  `${geri.filter((o) => o.acil).length}'i acil duzeltmeydi`);
```

```
26 elle degisiklik, 30 gun, 18 hat kosumu

sonuc                   adet     acil    gecikme
sessizce geri alinan    15/26    4       1.2 gun
catisan (hat duruyor)   3/26     1       0.7 gun
fark edilmeyen          8/26     2       -

geri alinan 15 degisiklik hata uretmedi, hepsi planda birer satirdi; 4'i acil duzeltmeydi
```

Üç satır üç ayrı olaydır ve yalnız ortadaki görünür. **3 çatışmada** hat durur ve bir insan karar
verir; bunlar hattın çalıştığının kanıtı sayılır. **15 değişiklik sessizce geri alınır** ve
ortalama 1,2 gün sonra kaybolur; hiçbiri hata üretmez, çünkü hat bunu yapmak için kuruldu. O on
beşin **4'ü acil düzeltmeydi** — kayıtları güncellenmediği için kaydın istediği eski değere
döndüler. `iac-temelleri/05` geri almanın canlı düzeltmeyi bozmasını saymıştı; hat bu geri almayı
hızlandırır ve sessizleştirir.

Her geri alma planda birer satırdı; planların dördü okunmadan onaylandığına göre sessizliğin
kaynağı hat değil, okunmayan plan satırıdır.

Üçüncü satır kursun kuralını son kez yazar: **8 kalem hattın hiç görmediği kalemlerdir.** Kayıt
dışı oldukları için ne geri alınırlar ne çatışırlar; hat kusursuz koşarken orada dururlar.

## Özet

- On sekiz değişikliğin on sekizi onaydan geçti, ama 4 plan okunmadan onaylandı ve o dört plan
  129 kalemin 49'unu (yüzde 38) taşıyordu; onay oranı bir ölçü değildir.
- Plan ile uygulama arasında ortalama 28,6 saat geçti, 18 planın 3'ü bayattı ve onayda görünmeyen
  5 kalem uygulamaya girdi.
- Tazelik kapısı yalnız hatta anlamlıdır, çünkü onaylanan planın saklanmasını gerektirir; 9 dakika
  ekler, 3 uygulamayı durdurur, 5 kalemi kurtarır.
- Geniş yetkide kimlik düşerse 84 kaynağın 84'ü silinebilir; yetki 19 işleme inince silinebilir
  kaynak 14'e, elde kalan iş 4 değişikliğe gelir, sonraki altı koşumda 5 yeni işlem çifti çıkar.
- 26 elle değişikliğin 15'i sessizce geri alındı (4'ü acil düzeltme), 3'ü çatıştı, 8'i kayıt dışı
  olduğu için hiç görülmedi.

## Kurs Kapanışı

| Ders | Kayda giren | Kayıt ile gerçek arasındaki fark | Kaydın bedeli ya da sınırı |
|---|---|---|---|
| `iac-temelleri/01` | 8 satır tarif | 9 kalem ayrı | kapsam dışı 5 kalem |
| `iac-temelleri/02` | 9 kalemlik hedef | 6/9'a karşı 2/9 | 5 koruma satırı |
| `iac-temelleri/03` | imaj, 96 olay | 10/12 makine tekil | 3 düzeltme kayboldu |
| `iac-temelleri/04` | 34 kalem, 35 tanım | 6 kalem çakışıyor | 5 kalem hiçbir kayıtta yok |
| `iac-temelleri/05` | 26 kalem | 12 sapma, 6'sı kapanır | kapsam dışı 12 kalem |
| `bildirimsel-saglama/01` | 3 blok, 14 atama | 8 kusur uygulamada | tipin görmediği 9 alan |
| `bildirimsel-saglama/02` | 20 alan | hedefte 36 alan | 16 alan kayıtta yok |
| `bildirimsel-saglama/03` | 8 kaynak, 5 veri kaynağı | tarama 8/13 kalem | 2 dış alan görünmez |
| `bildirimsel-saglama/04` | 14 değişken, 24 değer | 4 yanlış girdi geçti | 6 ortamda 48 elle değer |
| `bildirimsel-saglama/05` | 14 kaynak, 23 kenar | gereklilik 27, görülen 23 | 4 gereklilik kayıtta yok |
| `bildirimsel-saglama/06` | 3 biçim, 10 kaynak | 1'e karşı 6 kalem | 525 makine-saniye kesinti |
| `bildirimsel-saglama/07` | plan 11 kalem | 13 adresin 8'i tutuyor | 30 bölgede 39,6 dakika |
| `bildirimsel-saglama/08` | 24 alanın 20'si | ilk plan 4 kalem | 4 alan kayıt dışı |
| `durum-ve-moduller/01` | 56 alan, durumda 80 | 33 kalemin 4'ü kayıt dışı | kayıpta 3 kalem dönmez |
| `durum-ve-moduller/02` | iki eşzamanlı uygulama | kilitsiz 12 kalem kayboldu | 12 kaynak kayıt dışı |
| `durum-ve-moduller/03` | 620 kalem, 673 kenar | 66 kenar sınır aşıyor | 3 kalem kayıt dışı |
| `durum-ve-moduller/04` | 17 ya da 51 satır | 23'e karşı 4 yanlış ortam | 2 ortam 9'ar alan geride |
| `durum-ve-moduller/05` | modül 20 satır | 4 kalemin 0'ı görüldü | 1 kaynak kayıt dışı |
| `durum-ve-moduller/06` | 9 tanım, 12 sürüm | 9/9 koşan söylenmiyor | 25 sürüm geride |
| `durum-ve-moduller/07` | 7 iz noktası | 14 kopya, işaretle 4 | 3 nokta kapanmıyor |
| `iac-dogrulama/01` | 11 kaynak, 59 satır | üç denetim 16/16 | görülmeyen 4 red |
| `iac-dogrulama/02` | 62 satır, 7 politika | 3 kaçan, 2 yanlış alarm | 3 hesaplanan değer görünmez |
| `iac-dogrulama/03` | 15 kusur | üç seviye 12/15 | 11 artık, kayıtta 0 |
| `iac-dogrulama/04` | 24 kalem, 12 değişiklik | 9'unda 0,51x–1,45x | 11 kalem tahmin edilemez |
| `iac-dogrulama/05` | 1700 kayıt satırı | 1598'e karşı 1530 tutuyor | kapsam dışı 27/61 ayar |
| `iac-dogrulama/06` | içerik kaydı 32 girdi | imajlarda 52 girdi | 20 girdi kayıt dışı |
| `iac-dogrulama/07` | 18 değişiklik, 495 satır | 3 bayat plan, 5 kalem | 8 kalem görülmüyor |

Kursun kuralı budur: **altyapı ancak kaydı kadar yönetilebilir; kaydın kapsamadığı her kalem
sapmanın kaynağıdır.** Son sütunda üç sınır tekrar eder.
**On dokuz satırda sınır kaydın kapsamadığı kalemdir** — kayıt dışı kaynak, sağlayıcı varsayılanı,
görülmeyen gereklilik, hesaplanan değer, dolaylı bileşen. **Beş satırda** sınır kaydın kendi
işletme yüküdür: koruma satırı, gözden geçirme dakikası, geride kalan sürüm, geciken uygulama.
**Üç satırda** sınır geri alınamayan kayıptır: silinen düzeltme, hizmet dışı makine, dönmeyen
kalem. Kaydı büyütmek birinci grubu küçültür, ikincisini büyütür; bu takas hiçbir derste
sıfırlanmadı.

Altyapı artık kayda bağlı: yazılıyor, planlanıyor, denetleniyor, fiyatlanıyor, onaydan geçiyor ve
bir hattın uyguladığı iş oluyor. Ama bu kursun bütün ölçümleri **değişiklik anına** aitti.
Altyapının koşarken ne yaptığını hâlâ kimse görmüyor: hangi makine ne kadar yük taşıyor, hangi
kuyruk birikiyor. **M22/K06 Gözlemlenebilirlik ve İşletim** bu soruyla başlıyor — neyin
ölçüleceğine kim karar veriyor?
