---
title: 'Hassas Değerler'
source: 'https://academia.sh/tr/kurslar/kod-olarak-altyapi/hassas-degerler'
course: 'Kod Olarak Altyapı'
language: tr
updated: '2026-08-17T18:09:07+00:00'
license: 'CC BY-SA 4.0'
---

# Hassas Değerler

Kurgu bir parola tanımdan geçirilir ve yedi iz noktasında kaç kopya bıraktığı bir iz tarayıcısıyla sayılır; sonra alanlara hassas işareti konur ve tarama yeniden koşturulur. İşaretlemenin kapattığı ve kapatamadığı yerler, döndürme sonrası kalıntı ve maruziyet ayrı ayrı ölçülür.

Bir önceki ders modül kaydından çekilen metnin girdilerini saydı ve hepsi zararsızdı: bir ağ bloğu,
bir kapı numarası, bir kuyruk adı. Bu derste girdilerden biri bir veri deposu parolasıdır. Değer
değişmedi, yol değişmedi, ölçülen şey değişti — artık sorulan soru "kaç satır" değil, **"kaç yerde
görünüyor"**.

**Sır**, saklanması gereken değerin kendisidir. **Hassas değer** ise o değerin kayıt boyunca taşıdığı
işarettir; bir alanın "bunu gösterme" diye damgalanmasıdır. Aradaki fark bu dersin ölçtüğü şeydir:
işaret değere değil, **alana** konur, ve değer bir alandan başka bir alana kopyalandığı anda işaret
onunla birlikte gitmez.

Sır sızıntısı bu modülün önceki kurslarında iki kez ölçüldü: biri depo genelinde bir sızıntı taraması
koşturdu ve şifreli sır kaydını ele aldı, öteki hat kayıtlarında görünen değerleri saydı. Burada o
taramalar tekrarlanmaz. Ölçülen şey daha dar: **tek bir değerin, tek bir uygulamada bıraktığı iz.**

Ölçüm yine **bölgesel ölçüm ağı** üzerindedir ve ağ **kurgudur**. Değerin kendisi de kurgudur; gerçek
bir sır, anahtar ya da kimlik bilgisi yazılmaz. Gerçek bir sağlayıcıya bağlanılmaz; iz noktaları
`node` ile üretilmiş bir **modeldir**.

**DM37.** Hassas değer kurgu bir dizedir: `KURGU-parola-7f31`.
**DM38.** Değer depodaki bir değişken dosyasından girer, modüle girdi olur ve iki kaynak alanına
yazılır: doğrudan `parola` alanına, bir de değerin içine gömüldüğü bir bağlantı dizesine.
**DM39.** Yedi iz noktası vardır: değişken dosyası, plan çıktısı, uygulama günlüğü, durum dosyası,
modül çıktısı, sağlayıcı hata mesajı ve hat kaydı. Hat kaydı ötekilerin kopyasını taşır.
**DM40.** İşaretleme alana yapılır; işaretli alan plan, günlük ve modül çıktısında maskelenir.
**DM41.** Durum dosyası şifresizdir ve işaretlemeden etkilenmez; sağlayıcı hata mesajı maskeleme
kuralını bilmez.
**DM42.** Üç tur koşulur: işaretsiz, yalnız `parola` işaretli, `parola` ve `baglanti` işaretli.
Sonra değer döndürülür ve eski değerin kaç yerde kaldığı sayılır.
**DM43.** Maruziyet **model bir sayıdır**: kopya × okuyabilen kişi × saklama günü. Yer, gün ve kişi
sayıları ders içinde yazılıdır.

## Değerin Yolu ve İz Tarayıcısı

```js
// iz.mjs — kurgu bir hassas deger tanimdan gecirilir, iz noktalari uretilir, bir iz tarayicisi kosar.
const DEGER = "KURGU-parola-7f31";                     // kurgu dize; gercek bir sir degildir
const YENI = "KURGU-parola-b204";                      // dondurmeden sonraki kurgu deger

const uret = (d, im) => {                              // im: isaretli alanlar; gosterimde maskelenir
  const alan = { parola: d, baglanti: `olcum:${d}@depo.olcum-agi:5432` };
  const g = (a) => (im.has(a) ? "(hassas deger)" : alan[a]);
  const plan = `+ veri-deposu olcum-deposu\n    parola = ${g("parola")}\n` +
    `+ baglanti olcum-baglanti\n    dize = ${g("baglanti")}`;
  const gunluk = `uygulandi veri-deposu olcum-deposu parola=${g("parola")}\n` +
    `uygulandi baglanti olcum-baglanti dize=${g("baglanti")}`;
  const durum = JSON.stringify({ "veri-deposu": { parola: alan.parola },   // durum sifresizdir
    baglanti: { dize: alan.baglanti } });                                  // isaretleme onu etkilemez
  const cikti = `cikti baglanti-dizesi = ${g("baglanti")}`;
  const hata = `saglayici hatasi 400: gecersiz istek, govde {"parola":"${alan.parola}"}`;
  return { degerler: `parola = ${alan.parola}`, plan, gunluk, durum, cikti, hata,
    hat: [plan, gunluk, cikti].join("\n") };           // hat kaydi otekilerin kopyasini tasir
};
const tara = (iz, d) => Object.entries(iz).map(([a, m]) => [a, m.split(d).length - 1]);

const AD = ["degerler", "plan", "gunluk", "durum", "cikti", "hata", "hat"];
const TUR = [["isaretsiz", new Set()], ["parola isaretli", new Set(["parola"])],
  ["parola+baglanti", new Set(["parola", "baglanti"])]];
console.log("tur                " + AD.map((a) => a.padStart(9)).join("") + "   nokta  kopya");
const sonuc = {};
for (const [ad, im] of TUR) {
  const s = tara(uret(DEGER, im), DEGER);
  sonuc[ad] = s;
  console.log(ad.padEnd(19) + s.map(([, n]) => String(n).padStart(9)).join("") +
    `   ${s.filter(([, n]) => n).length}/${AD.length}` +
    `${String(s.reduce((a, [, n]) => a + n, 0)).padStart(7)}`);
}
const ilk = sonuc["isaretsiz"], son = sonuc["parola+baglanti"];
const kapanan = ilk.filter(([a, n], i) => n && !son[i][1]).map(([a]) => a);
const acik = son.filter(([, n]) => n).map(([a]) => a);
console.log(`iki isaretlemeden sonra kapanan ${kapanan.length}/${AD.length} (${kapanan})` +
  ` | acik kalan ${acik.length}/${AD.length} (${acik})`);

const KALINTI = { "durum surumu -1": uret(DEGER, new Set(["parola", "baglanti"])).durum,
  "arsiv hat kaydi": uret(DEGER, new Set()).hat, "depo gecmisi": uret(DEGER, new Set()).degerler };
const yeniKosum = tara(uret(YENI, new Set(["parola", "baglanti"])), DEGER);
const k = tara(KALINTI, DEGER);
console.log(`deger dondurulduktan sonra yeni kosumda eski deger ${yeniKosum.reduce((a, [, n]) => a + n, 0)} kopya` +
  ` | kalintida ${k.filter(([, n]) => n).length} yer, ${k.reduce((a, [, n]) => a + n, 0)} kopya: ` +
  k.map(([a, n]) => `${a} ${n}`).join(", "));
console.log(`durum dosyasi her turda ${ilk[3][1]} kopya tasidi; isaretleme onu hicbir turda azaltmadi`);

const YER = {                                          // iz noktasi: [nerede durur, saklama gunu, okuyabilen]
  degerler: ["depo", 3650, 24], plan: ["hat kaydi", 90, 31], gunluk: ["hat kaydi", 90, 31],
  durum: ["uzak durum deposu", 3650, 6], cikti: ["baska tanimlar", 3650, 12],
  hata: ["destek kaydi", 365, 40], hat: ["hat arsivi", 90, 31] };
const mar = (s) => s.reduce((a, [ad, n]) => a + n * YER[ad][1] * YER[ad][2], 0);
console.log("nokta     nerede              gun  okuyan  kopya(ilk/son)  maruziyet(ilk/son)");
for (const [i, [ad, n]] of ilk.entries()) {
  const [y, g, o] = YER[ad];
  console.log(`${ad.padEnd(10)}${y.padEnd(20)}${String(g).padStart(4)}${String(o).padStart(8)}` +
    `${`${n}/${son[i][1]}`.padStart(16)}${`${n * g * o}/${son[i][1] * g * o}`.padStart(20)}`);
}
const kp = (s) => s.reduce((a, [, n]) => a + n, 0);
console.log(`kopya ${kp(ilk)} -> ${kp(son)} (%${Math.round((1 - kp(son) / kp(ilk)) * 100)} dustu)` +
  ` | maruziyet ${mar(ilk)} -> ${mar(son)} (%${Math.round((1 - mar(son) / mar(ilk)) * 100)} dustu)`);

const TUKETEN = ["saha-hizmeti", "raporlama", "dogrulayici"];    // modul ciktisini giren tanimlar
const asagi = Object.fromEntries(TUKETEN.map((t) =>              // her biri kendi durumuna yazar
  [`durum:${t}`, JSON.stringify({ [t]: { baglanti: `olcum:${DEGER}@depo.olcum-agi:5432` } })]));
const a = tara(asagi, DEGER), aMar = kp(a) * YER.durum[1] * YER.durum[2];
console.log(`ciktiyi tuketen tanim ${TUKETEN.length}, her biri ayri durum dosyasi | ` +
  a.map(([ad, n]) => `${ad} ${n}`).join(" ") + ` | bolunmus durumla acik nokta ` +
  `${acik.length}+${a.filter(([, n]) => n).length}=${acik.length + a.length}` +
  ` | kopya ${kp(son)}+${kp(a)}=${kp(son) + kp(a)}` +
  ` | maruziyet ${mar(son)}+${aMar}=${mar(son) + aMar} (isaretsiz tura gore %` +
  `${Math.round((1 - (mar(son) + aMar) / mar(ilk)) * 100)} dustu)`);
```

```
tur                 degerler     plan   gunluk    durum    cikti     hata      hat   nokta  kopya
isaretsiz                  1        2        2        2        1        1        5   7/7     14
parola isaretli            1        1        1        2        1        1        3   7/7     10
parola+baglanti            1        0        0        2        0        1        0   3/7      4
iki isaretlemeden sonra kapanan 4/7 (plan,gunluk,cikti,hat) | acik kalan 3/7 (degerler,durum,hata)
deger dondurulduktan sonra yeni kosumda eski deger 0 kopya | kalintida 3 yer, 8 kopya: durum surumu -1 2, arsiv hat kaydi 5, depo gecmisi 1
durum dosyasi her turda 2 kopya tasidi; isaretleme onu hicbir turda azaltmadi
nokta     nerede              gun  okuyan  kopya(ilk/son)  maruziyet(ilk/son)
degerler  depo                3650      24             1/1         87600/87600
plan      hat kaydi             90      31             2/0              5580/0
gunluk    hat kaydi             90      31             2/0              5580/0
durum     uzak durum deposu   3650       6             2/2         43800/43800
cikti     baska tanimlar      3650      12             1/0             43800/0
hata      destek kaydi         365      40             1/1         14600/14600
hat       hat arsivi            90      31             5/0             13950/0
kopya 14 -> 4 (%71 dustu) | maruziyet 214910 -> 146000 (%32 dustu)
ciktiyi tuketen tanim 3, her biri ayri durum dosyasi | durum:saha-hizmeti 1 durum:raporlama 1 durum:dogrulayici 1 | bolunmus durumla acik nokta 3+3=6 | kopya 4+3=7 | maruziyet 146000+65700=211700 (isaretsiz tura gore %1 dustu)
```

## Üç Tur

İşaretsiz turda değer **yedi iz noktasının yedisinde** görünüyor ve toplam on dört kopya bırakıyor.
Tek bir uygulamanın tek bir girdisi için on dört kopya. Sayının büyük kısmı çoğaltmadan geliyor: hat
kaydı planı, günlüğü ve çıktıyı olduğu gibi topladığı için tek başına beş kopya taşıyor. Bu beş
kopyanın hiçbiri yeni bir karardan doğmadı; kimse "parolayı hat kaydına yaz" demedi. Kayıt okundu,
çıktısı bir yere yazıldı, o yer de saklandı. **Kopyaların çoğu bir karar değil, bir yan üründür** ve
bu yüzden hiçbiri bir gözden geçirmede görünmez.

İkinci tur işaretlemenin ne kadar dar bir şey olduğunu gösterir. `parola` alanı işaretlendi; plan ve
günlük o alanı maskeledi, kopya sayısı on dörtten ona indi — ama **görünen nokta sayısı yine yedi**.
Nedeni ilk bölümde yazılıydı: değer bir alandan başka bir alana kopyalanmıştı. `baglanti` dizesi
parolayı içine gömdüğü için ayrı bir alandır ve işaretlenmemiştir. Maskeleme alanı tanır, değeri
tanımaz. İşaretlemenin gözden kaçırdığı şey bir kural değil, bir **kopya**dır.

Üçüncü tur ikinci alanı da işaretler ve o zaman gerçek düşüş gelir: kopya dörde, görünen nokta üçe
iner. Kapanan dört nokta plan, günlük, modül çıktısı ve hat kaydıdır. Açık kalan üç nokta ise
değişken dosyası, durum dosyası ve sağlayıcı hata mesajıdır — ve üçünün açık kalması üç ayrı
nedenledir.

Değişken dosyası açıktır çünkü işaretleme bir **gösterim** kuralıdır; değerin nerede yazılı olduğuna
karışmaz. Damga, kaydın okunduğu yerde ne yazacağını söyler, kaydın kendisinde ne yazdığını değil.
Sağlayıcı hata mesajı açıktır çünkü maskeleme kuralı kaydı yazan tarafın kuralıdır ve hatayı üreten
taraf onu bilmez; hata, gönderilen isteğin gövdesini olduğu gibi geri yazar. Bu ikisinin ortak yanı,
ikisinin de **kaydın denetimi dışında** olmasıdır: biri kayıttan önce gelir, öteki kayıttan sonra.
Durum dosyası ise ikisine de benzemez; kaydın tam ortasındadır ve bu yüzden en önemlisidir.

## Durum, Kalıntı ve Maruziyet

Durum dosyası üç turun üçünde de iki kopya taşıdı ve işaretleme onu hiçbir turda azaltmadı. Bunun
nedeni durumun ne olduğudur: durum, uygulanmış kaynakların gerçek değerlerinin kaydıdır. Bir alanı
"gösterme" diye damgalamak o alanın **değerini** ortadan kaldırmaz; sonraki planın kayıt ile gerçeği
karşılaştırabilmesi için değerin bir yerde durması gerekir. Bu kursun kuralı burada da geçerlidir:
altyapı ancak kaydı kadar yönetilebilir, ve kayıt değeri tutmak zorundadır.

Döndürme bunu bir kez daha gösterir. Değer yenisiyle değiştirildikten sonra yeni koşumda eski değer
**sıfır kopya** bırakıyor — yani ileriye doğru temiz. Geriye doğru değil: kalıntıda üç yer ve sekiz
kopya duruyor. Eski durum sürümü iki, arşivlenmiş hat kaydı beş, deponun geçmişi bir. Sekiz kopyanın
beşi, işaretleme hiç yokken alınmış tek bir arşivden geliyor; bugün konan damga dünkü kaydı
düzeltmez. Döndürme değeri geçersiz kılar ama **kayıttan silmez**; silinmesi gereken şey artık
değer değil, kaydın kendisidir.

Son tablo işaretlemenin değerini bir de ağırlıklı olarak ölçer. Maruziyet kopya sayısını bulunduğu
yerin saklama süresi ve o yeri okuyabilen kişi sayısıyla çarpar; **model bir sayıdır**, gerçek bir
ölçüm değil. Sonuç şudur: iki işaretleme **kopyaların yüzde yetmiş birini** sildi ama **maruziyetin
yalnız yüzde otuz ikisini**. Aradaki fark, kapanan noktaların hepsinin kısa ömürlü olmasından gelir
— plan, günlük ve hat kaydı doksan gün saklanır, açık kalan üç noktanın ikisi kalıcıdır.

Kalan maruziyetin dağılımı da beklenenden farklıdır. En büyük pay durum dosyasında değil, depodaki
değişken dosyasındadır: yüz kırk altı binin seksen yedi bin altı yüzü, yani yüzde altmışı. Değer
depoda yazılı olduğu sürece onu okuyabilen yirmi dört kişi, uzak durum deposunu okuyabilen altı
kişiden fazladır. İşaretleme bu payı hiç azaltmaz; azaltacak olan şey başka bir karardır — değeri
kayıttan çıkarıp uygulama anında dışarıdan almak.

## Bölünmüş Durumda Çoğalma

Buraya kadarki sayım tek bir tanımın tek bir durumunu ölçtü. Bu konuda durum daha önce bölünmüştü:
her ekip kendi tanımını, kendi durumunu ve kendi uygulama takvimini aldı. Bölünmüş durum hassas
değerde başka türlü davranır.

Modül `baglanti-dizesi` diye bir çıktı veriyor ve bu çıktıyı üç aşağı tanım girdi olarak alıyor.
Çıktı gösterimde maskelendi — üçüncü turda `cikti` noktası sıfır kopya gösteriyordu. Ama maskeleme
gösterimdir; tüketen tarafa giden şey değerin kendisidir. Üç tanımın üçü değeri kendi kaynağına
yazar, kaynak da kendi durum dosyasına düşer. Son satır bunu sayar: **üç yeni durum dosyası, üç yeni
kopya.**

Toplam böylece tersine döner. İşaretlemeden sonra üç noktada dört kopya kalmıştı; bölünmüş durum
sayılınca altı noktada yedi kopya oluyor. Maruziyet daha da serttir: yüz kırk altı bin, altmış beş
bin yedi yüz artarak iki yüz on bir bin yedi yüze çıkıyor. İşaretsiz turdaki iki yüz on dört bin
dokuz yüz onla karşılaştırıldığında düşüş **yüzde bir**. İki alan işaretlendi, dört iz noktası
kapandı, ve toplam maruziyet neredeyse hiç değişmedi.

Bunun nedeni durum bölmenin kendisi değil, işaretlemenin sınırıdır. İşaret bir tanımın gösterimine
konur; tanım sınırını geçen değer işareti geride bırakır. Modül çıktısı bir sınırdır, bir tanımın
başka bir tanıma verdiği değer başka bir sınırdır, ve her sınırda aynı şey olur — değer geçer,
damga geçmez. Durumu bölmek kayıt yönetimini kolaylaştırdı, ama hassas değer bakımından yaptığı şey
**kopya sayısını bölünme sayısı kadar artırmak** oldu.

## Özet

- Kurgu bir parola tek bir uygulamada 7 iz noktasının 7'sinde görünüyor ve 14 kopya bırakıyor; hat
  kaydı tek başına 5 kopya taşıyor çünkü plan, günlük ve çıktıyı kopyalıyor.
- Yalnız `parola` işaretlendiğinde kopya 14'ten 10'a indi ama görünen nokta 7'de kaldı — değer bir
  bağlantı dizesine kopyalanmıştı; iki alan da işaretlenince kopya 4'e, nokta 3'e indi ve plan,
  günlük, modül çıktısı ile hat kaydı kapandı.
- Açık kalan 3 nokta değişken dosyası, durum dosyası ve sağlayıcı hata mesajıdır; durum dosyası üç
  turda da 2 kopya taşıdı, çünkü kayıt karşılaştırma yapabilmek için değeri tutmak zorundadır.
- Döndürme sonrası yeni koşumda eski değer 0 kopya bırakıyor, kalıntıda 3 yerde 8 kopya duruyor:
  eski durum sürümü, arşiv hat kaydı ve depo geçmişi.
- İşaretleme kopyaların yüzde 71'ini sildi ama maruziyetin yalnız yüzde 32'sini; kalan maruziyetin
  yüzde 60'ı depodaki değişken dosyasındadır.
- Modül çıktısını tüketen 3 tanım değeri kendi durum dosyalarına yazınca açık nokta 3'ten 6'ya,
  kopya 4'ten 7'ye çıktı ve maruziyetin düşüşü yüzde 32'den yüzde 1'e indi: değer tanım sınırını
  geçerken damgası geçmiyor.

## Sonraki Adım

Bu konu boyunca kayıt dört kez ele alındı. Önce durum dosyası ve kilit kuruldu, sonra durum
bölündü, sonra tekrar eden tanım bir modüle çıkarıldı ve paylaşılan bir kayıttan sürümlenerek
çekildi, en sonunda da içinden geçen hassas değerler işaretlendi. Her adımda kaydın kapsamı,
bedeli ve kendi riski sayıldı.

Bir şey hiç yapılmadı: kayıt **uygulanmadan önce doğru olup olmadığı hiç sınanmadı**. Bu konuda
yazılan her kayıt, sınanma yerine uygulanarak denendi — plan bakıldı, uygulandı, sonuç görüldü.
Yanlış yazılmış bir alan, bir politikayı çiğneyen bir kaynak ya da beklenenden pahalı bir değişiklik
ancak uygulama sırasında ya da sonrasında ortaya çıktı. Bir sonraki konu bu boşluğu ele alır: altyapı
tanımı üzerinde uygulamadan önce koşan denetimler yazılır ve şu sayılır — bir tanımın kaç kusuru
metne bakarak yakalanabilir, kaçı ancak uygulanınca görünür, ve yakalayan denetimin kaç yanlış alarm
ürettiği.