--- title: 'Bilgi Teknolojileri ve Sistem Temelleri' source: 'https://academia.sh/tr/kurslar/bt-temelleri' language: tr updated: '2026-08-17T04:39:56+00:00' license: 'CC BY-SA 4.0' lessons: 11 outcomes: - 'Donanım ve işletim sistemi bileşenlerini taşıdıkları güvenlik sınırıyla birlikte tanır' - 'Sanallaştırma katmanlarının yalıtım gücünü sınırı geçmek için gereken kalem sayısıyla karşılaştırır' - 'Sistem sorunlarını hipotez başına elenen olasılık sayısıyla yöntemli biçimde giderir' --- # Bilgi Teknolojileri ve Sistem Temelleri Korunan şeyin altındaki katmanın güvenlik gözüyle okunması: işlemci, bellek, depolama ve arayüzlerin hangi sınırı taşıdığı, işletim sistemi ailelerinin güvenlik modeli farkı, temiz kurulum ve başlangıç sertleştirmesinin kapattığı kalem, platformlar arası izin ve sahiplik modellerinin aynı istekte farklı sonuç vermesi, grafik arayüz ile komut satırının bıraktığı iz farkı, belirti, hipotez ve doğrulama döngüsünün eleme gücü, hipervizör türleri, konuk ile konak arasındaki yalıtım sınırı ve kaçış riski, anlık görüntü ve klonlamanın kurtardığı ve kurtaramadığı kalem, konteynerle yalıtım gücü karşılaştırması, yedek türleri ve kurtarma testi. ## Donanım ve İşletim Sistemleri Tek bir makinenin çizdiği sınırların kalem kalem sayılması: donanım bileşenlerinin taşıdığı sınır ve açılış zinciri, işletim sistemi ailelerinin güvenlik modeli farkı, temiz kurulumun kapattığı ve kapatamadığı kalem, iki izin modelinin aynı erişim isteğinde ayrıştığı nokta, iki yönetim biçiminin bıraktığı iz farkı ve sorun giderme sırasının eleme gücü. ### Bilgisayar Donanım Bileşenleri Source: https://academia.sh/tr/kurslar/bt-temelleri/bilgisayar-donanim-bilesenleri Donanımın sınır listesi olarak okunması: 43 kalemlik envanterde sekiz bileşenin çizdiği sınır, sınırı geçmek için aynı anda yanlış olması gereken kalem sayısının uzaktan 1 ile 3, fiziksel erişimde 0 ile 3 arasında değişmesi, iki bileşenin tek başına envanterin tamamını açması ve dört sertleştirme ayarından üçü açıldıktan sonra bile açılan kalemin 43'te kalması. Önceki kurs bir varlığa ulaşmanın kaç ayrı yolu olduğunu saydı ve her savunma ilkesini kapattığı yol cinsinden ölçtü. Bütün o yolların ortak bir noktası vardı: hepsi bir makinenin üzerinden geçiyordu. Makinenin kendisi hiç açılmadı. Bu ders donanımı katalog olarak ele almaz. İşlemcinin kaç çekirdeği olduğu ya da belleğin ne kadar hızlı olduğu buradaki soru değildir. Soru şudur: bir bileşen hangi sınırı çiziyor, o sınırın iki yanında kaç kalem duruyor ve sınır bir kez geçildiğinde neye erişiliyor. #### Sınır Listesi Olarak Donanım Bir bileşenin güvenlik değeri üç sayıyla yazılır. **Sınırın adı ve tarafı.** Bileşen bir ayrımı zorlar: bir kalem kümesi içeride, kalanı dışarıdadır. "İşlemci güvenlidir" bir karar taşımaz; "işlemci ayrıcalık kipi sınırını çizer ve o sınırın içinde şu kadar kalem vardır" taşır. **Sınırı geçmek için gereken kalem.** Bir yandan öbürüne geçmek kaç ayrı koşulun **aynı anda** yanlış olmasını ister. Bu sayı yalıtım gücüdür. Bir ise sınır yoktur: tek bir hata bütün geçişi verir. Sıfır ise sınır hiç kurulmamıştır. **Sınır düştüğünde erişilen kalem.** Sınırın bir kez geçildiği varsayılır ve kaç kaleme erişildiği sayılır. Dar bir sınır düşse de az kalem verir; geniş bir sınır düştüğünde envanterin tamamı açılır. #### Sekiz Bileşenin Sınırı Örnek, kursun kurgu **bölgesel ölçüm ağı**ndaki bir şube sunucusudur: sayaç okumalarını toplayan uçlardan gelen veriyi saklar, saha ekiplerinin dizüstü bilgisayarlarına dağıtır. Sunucu da envanteri de kurgudur; aşağıdaki tablo bir **modeldir**, gerçek bir makine, satıcı ya da yapılandırma yoktur. **DI1:** korunan varlık envanteri 43 kalemdir ve yedi katmana bölünür. **DI2:** her bileşen bir sınır çizer; sınır düştüğünde erişilen katmanlar kalem kalem yazılır. **DI3:** eşik, sınırı geçmek için aynı anda yanlış olması gereken kalem sayısıdır ve uzaktan erişimle fiziksel erişimde ayrı ayrı verilir. **DI4:** dört sertleştirme ayarı vardır; her biri ilgili bileşenin fiziksel eşiğine iki kalem ekler. **DI5:** en düşük eşikli sınır seçilir; erişilen kalem, eşiği bir ve altında olan sınırların açtığı katmanların **birleşimidir**. **DI6:** çevre birim arayüzü uzaktan geçilemez, fiziksel takma ister. ```js // bt/bilesen.mjs — kurgu bolgesel olcum agi sube sunucusunun bilesen ve sinir envanteri // (model): gercek bir makine, satici ya da yapilandirma yok. Rastgelelik yok. // Varlik envanteri: yedi katman, katman basina kalem sayisi. export const KATMAN = { "cekirdek-bellek": 5, "surec-bellegi": 9, "disk-veri": 11, "yapilandirma": 6, "anahtar-malzemesi": 3, "ag-ucu": 4, "gunluk": 5 }; export const TOPLAM = Object.values(KATMAN).reduce((a, b) => a + b, 0); const HEPSI = Object.keys(KATMAN); // Her bilesen bir sinir cizer. u/f: sinirin uzaktan ve fiziksel erisimde gecilmesi icin ayni // anda yanlis olmasi gereken kalem sayisi (Infinity: o yoldan gecilemez). ayar: sinira kalem // ekleyen sertlestirme; ek: ayar acikken f'ye eklenen kalem. acar: sinir dustugunde erisilen // katmanlar. export const SINIR = [ { ad: "islemci", sinir: "ayricalik-kipi", u: 2, f: 2, ayar: null, ek: 0, acar: ["cekirdek-bellek", "surec-bellegi", "yapilandirma", "gunluk"] }, { ad: "bellek-yonetim-birimi", sinir: "surec-adres-alani", u: 2, f: 2, ayar: null, ek: 0, acar: ["surec-bellegi"] }, { ad: "kalici-depolama", sinir: "dosya-sistemi-izni", u: 2, f: 0, ayar: "disk-sifrelemesi", ek: 2, acar: ["disk-veri", "yapilandirma", "gunluk"] }, { ad: "bellenim", sinir: "acilis-zinciri", u: 3, f: 1, ayar: "imzali-acilis", ek: 2, acar: HEPSI }, { ad: "guvenilir-platform-birimi", sinir: "anahtar-saklama", u: 3, f: 3, ayar: null, ek: 0, acar: ["anahtar-malzemesi"] }, { ad: "ag-arayuzu", sinir: "dinlenen-uc", u: 1, f: 1, ayar: null, ek: 0, acar: ["ag-ucu"] }, { ad: "cevre-birim-arayuzu", sinir: "aygit-bellek-erisimi", u: Infinity, f: 1, ayar: "aygit-adres-yalitimi", ek: 2, acar: ["cekirdek-bellek", "surec-bellegi"] }, { ad: "bant-disi-yonetim-arayuzu", sinir: "yonetim-agi", u: 2, f: 1, ayar: "yonetim-agi-bolutlemesi", ek: 2, acar: HEPSI }, ]; export const AYAR = ["imzali-acilis", "disk-sifrelemesi", "aygit-adres-yalitimi", "yonetim-agi-bolutlemesi"]; export const kalem = (katmanlar) => katmanlar.reduce((a, k) => a + KATMAN[k], 0); // Esik: acik ayarlar kumesine gore bir sinirin gecilmesi icin gereken kalem sayisi. export const esik = (s, yol, acik) => (yol === "u" ? s.u : s.f + (acik.has(s.ayar) ? s.ek : 0)); // En zayif halka: en dusuk esik, o esikteki sinirlar ve esigi <=1 olan sinirlarin birlesimi. export function zayif(yol, acik = new Set()) { const e = SINIR.map((s) => esik(s, yol, acik)); const min = Math.min(...e); const gevsek = SINIR.filter((s, i) => e[i] <= 1); const birlesim = new Set(gevsek.flatMap((s) => s.acar)); return { min, minAd: SINIR.filter((s, i) => e[i] === min).map((s) => s.ad).join(" "), gevsek: gevsek.length, acilan: kalem([...birlesim]) }; } ``` ```js // bt/olc.mjs — her bilesenin sinirini, esigini ve sinir dustugunde acilan kalemi sayar. import { KATMAN, TOPLAM, SINIR, AYAR, kalem, esik, zayif } from "./bilesen.mjs"; const yaz = (g, ...s) => console.log(s.map((v, i) => (g[i] < 0 ? String(v).padEnd(-g[i]) : String(v).padStart(g[i]))).join("")); const say = (n) => (n === Infinity ? "-" : n); console.log(`varlik envanteri: ${TOPLAM} kalem / ${Object.keys(KATMAN).length} katman — ` + Object.entries(KATMAN).map(([k, v]) => `${k} ${v}`).join(", ")); const A = [-27, -22, 9, 10, 7, 10]; console.log("\n1. bilesen basina sinir (icerde: sinir dustugunde erisilen kalem)"); yaz(A, "bilesen", "sinir", "icerde", "disarida", "uzak", "fiziksel"); for (const s of SINIR) { const i = kalem([...new Set(s.acar)]); yaz(A, s.ad, s.sinir, i, TOPLAM - i, say(s.u), say(s.f)); } const B = [-12, -28, 9, 9, 9]; console.log("\n2. en zayif halka (hicbir sertlestirme ayari acik degilken)"); yaz(B, "yol", "en zayif bilesen", "en dusuk", "esik<=1", "acilan"); for (const [ad, yol] of [["uzaktan", "u"], ["fiziksel", "f"]]) { const z = zayif(yol); yaz(B, ad, z.minAd, z.min, z.gevsek, z.acilan); } const C = [-26, 9, 9, 9]; console.log("\n3. ayarlar sirayla acildikca (fiziksel erisim)"); yaz(C, "acik ayar", "en dusuk", "esik<=1", "acilan"); const acik = new Set(); yaz(C, "(hicbiri)", zayif("f").min, zayif("f").gevsek, zayif("f").acilan); for (const a of AYAR) { acik.add(a); const z = zayif("f", acik); yaz(C, `+ ${a}`, z.min, z.gevsek, z.acilan); } const D = [-34, 9]; console.log("\n4. esik dagilimi (tum ayarlar acik, fiziksel erisim)"); const hepsi = new Set(AYAR); const dag = {}; for (const s of SINIR) dag[esik(s, "f", hepsi)] = (dag[esik(s, "f", hepsi)] || 0) + 1; yaz(D, "esik (kalem)", "bilesen"); for (const k of Object.keys(dag).sort()) yaz(D, k, dag[k]); yaz(D, "envanterin tamamini acan bilesen", SINIR.filter((s) => kalem([...new Set(s.acar)]) === TOPLAM).length); ``` ``` varlik envanteri: 43 kalem / 7 katman — cekirdek-bellek 5, surec-bellegi 9, disk-veri 11, yapilandirma 6, anahtar-malzemesi 3, ag-ucu 4, gunluk 5 1. bilesen basina sinir (icerde: sinir dustugunde erisilen kalem) bilesen sinir icerde disarida uzak fiziksel islemci ayricalik-kipi 25 18 2 2 bellek-yonetim-birimi surec-adres-alani 9 34 2 2 kalici-depolama dosya-sistemi-izni 22 21 2 0 bellenim acilis-zinciri 43 0 3 1 guvenilir-platform-birimi anahtar-saklama 3 40 3 3 ag-arayuzu dinlenen-uc 4 39 1 1 cevre-birim-arayuzu aygit-bellek-erisimi 14 29 - 1 bant-disi-yonetim-arayuzu yonetim-agi 43 0 2 1 2. en zayif halka (hicbir sertlestirme ayari acik degilken) yol en zayif bilesen en dusuk esik<=1 acilan uzaktan ag-arayuzu 1 1 4 fiziksel kalici-depolama 0 5 43 3. ayarlar sirayla acildikca (fiziksel erisim) acik ayar en dusuk esik<=1 acilan (hicbiri) 0 5 43 + imzali-acilis 0 4 43 + disk-sifrelemesi 1 3 43 + aygit-adres-yalitimi 1 2 43 + yonetim-agi-bolutlemesi 1 1 4 4. esik dagilimi (tum ayarlar acik, fiziksel erisim) esik (kalem) bilesen 1 1 2 3 3 4 envanterin tamamini acan bilesen 2 ``` Sayılar **ölçüm** sınıfındadır; girdileri DI1–DI6'dır. #### Alttaki Sınır Üsttekini Kurar Birinci tablonun `icerde` sütunu bileşenleri iki gruba ayırır. **Bellenim** ile **bant dışı yönetim arayüzü** düştüğünde 43 kalemin tamamı açılır; `disarida` sütunları sıfırdır. Bellek yönetim birimi düştüğünde 9, güvenilir platform birimi düştüğünde 3 kalem açılır. Fark, bileşenin önemli olup olmamasından gelmez; **sırasından** gelir. **Bellenim (firmware)**, makine açıldığında ilk çalışan koddur ve kendisinden sonra çalışacak her katmanı o yükler. Bu zincire **açılış zinciri (boot chain)** denir: bellenim çekirdek yükleyiciyi, yükleyici işletim sistemi çekirdeğini, çekirdek de kullanıcı süreçlerini başlatır. Ayrıcalık kipi sınırını uygulayan kod da, dosya sistemi izinlerine bakan kod da bu zincirin üst halkalarındadır. Zincirin ilk halkası değiştirilirse üstteki hiçbir sınır kurulmaz — çünkü sınırı kuran şeyin kendisi değiştirilmiştir. **İmzalı açılış (secure boot)** tam olarak bu yüzden vardır: her halka, bir sonrakini yüklemeden önce imzasını doğrular. Modeldeki `imzali-acilis` ayarı bellenimin fiziksel eşiğini 1'den 3'e çıkarır; imzayı atlatmak için imza denetiminin kapatılması, güvenilen anahtar kümesinin değiştirilmesi ve değişikliğin kalıcı olması gerekir. **Güvenilir platform birimi (trusted platform module)** ters yöndedir. Sınırı dardır — yalnız 3 kalem, anahtar malzemesi. Ama eşiği hem uzaktan hem fiziksel erişimde 3'tür, çünkü anahtar birimden hiç çıkmaz; birim anahtarı kullanır, vermez. **Dar ve derin bir sınır, geniş ve sığ bir sınırdan farklı bir işe yarar:** birincisi az kalemi neredeyse kesin korur, ikincisi çok kalemi zayıf korur. İki sayı ayrı yazılmazsa bu fark görünmez. #### Eşik İki İse Ne Değişir İşlemcinin ayrıcalık kipi sınırı ile bellek yönetim biriminin süreç adres alanı sınırı modelde aynı eşiği taşır: 2. Sayı, iki ayrı koşulun **aynı anda** yanlış olması gerektiğini söyler. Ayrıcalık kipi için bunlar çekirdek kodunda geçilebilir bir hatanın bulunması ile o hataya ulaşan bir çağrı yolunun açık olmasıdır; ikisinden biri yoksa geçiş olmaz. Süreç adres alanı için bunlar bir sürecin kendi sınırının dışına yazabilmesi ile yazdığı yerin başka bir sürecin haritasında bulunmasıdır. Eşiğin ikiye çıkması geçişi zorlaştırır — ama yalnız iki kalem **bağımsızsa**. Aynı yapılandırma kalemi ikisini birden kapatıyorsa, ya da aynı ayrıcalıklı hesap ikisini birden değiştirebiliyorsa, iki kalem tek kalem gibi davranır ve gerçek eşik 1'dir. Model bu bağımlılığı görmez: `esik` işlevi kalemleri sayar, aralarındaki bağı sormaz. **Sınırın yetmediği ilk yer burasıdır.** Eşik tablosu bir üst sınır verir, alt sınır vermez; bir sınırın "iki kalemlik" olduğu yazıldığında bu, iki kalemin ayrı ayrı yanlış olması gerektiğini değil, en fazla iki kalemin gerektiğini söyler. Sayı bu yüzden yalnız başına kullanılmaz; yanına iki soru yazılır. Sayılan kalemler ayrı ayrı mı yönetiliyor? Tek bir yetki ikisini birden değiştirebiliyor mu? İkinci sorunun yanıtı evet ise sayı bire indirilir ve sınır, sınır sayılmaz. Aynı sınırlama üçüncü sütun için de geçerlidir. Katman modeli `surec-bellegi` ile `anahtar-malzemesi` kalemlerini ayrı sayar, ama bir anahtar kullanılırken süreç belleğinde bulunur; o an bellek yönetim biriminin sınırı düşerse açılan kalem 9 değil, 9 artı o anda bellekte duran anahtardır. Envanteri katmana bölmek sayımı yapılabilir kılar, **zamanı** ise gizler. #### Fiziksel Erişim Eşiği Sıfıra İndirir İkinci tablo aynı envanteri iki yoldan okur. Uzaktan en zayıf sınır ağ arayüzüdür: eşik 1, açılan kalem 4. Fiziksel erişimde en zayıf sınır kalıcı depolamadır ve **eşik 0'dır**. Sıfırın anlamı kesindir: hiçbir koşulun yanlış olması gerekmez. Şifrelenmemiş bir depolama birimi sökülüp başka bir makineye takıldığında dosya sistemi izinleri hiç sorulmaz, çünkü izinleri uygulayan şey diskin kendisi değil, o diski takan işletim sistemidir. İzin bitleri diskte **veri** olarak durur; onlara uyan bir çekirdek yoksa hiçbir şey uygulanmaz. Disk şifrelemesi bu eşiği 2'ye çıkarır: hem anahtar hem de anahtarı açan sır gerekir. Çevre birim arayüzünün `uzak` sütunundaki tire de aynı ayrımın öteki yüzüdür. Aygıtın belleğe doğrudan erişimi uzaktan kullanılamaz; ama makineye fiziksel olarak bir aygıt takılabiliyorsa eşik 1'dir ve çekirdek belleğiyle süreç belleği, yani 14 kalem açılır. Aygıt adres yalıtımı açıldığında aygıtın gördüğü adres alanı sınırlanır ve eşik 3'e çıkar. #### En Zayıf Halka Sayılır Üçüncü tablo bu dersin karar taşıyan sayısını verir. Dört sertleştirme ayarı sırayla açılır ve her satırda **açılan kalem** okunur: 43, 43, 43, 43, 4. Üç ayar açıldıktan sonra bile fiziksel erişimde envanterin tamamı açılmaktadır. Nedeni son sütundadır: `esik<=1` sayısı 5'ten 4, 3, 2'ye iner ama **sıfır olmaz** ve kalan gevşek sınırlardan biri her seferinde 43 kalem açan bant dışı yönetim arayüzüdür. İmzalı açılışı ve disk şifrelemesini açmak o bileşene hiç dokunmaz. Erişilen kalem ancak dördüncü ayar — yönetim ağının bölütlenmesi — açıldığında 4'e iner. **Bu, katman eklemenin kendiliğinden yol kapatmadığının sayısal karşılığıdır.** Üç ayar üç ayrı sınırı güçlendirdi, üçü de gerçek iş yaptı, ama ölçülen sonuç değişmedi; çünkü ölçülen şey sınırların ortalaması değil, **en zayıfının açtığı kalemdir**. Sertleştirme sırası, en çok kalem açan gevşek sınırdan başlamalıdır — modeldeki sıra bunun tersiydi ve bedeli üç adım boyunca hiç kazanç elde edilememesi oldu. Dördüncü tablo kalan tabloyu verir. Tüm ayarlar açıkken eşik dağılımı 1, 3 ve 4 bileşendir: bir bileşenin eşiği hâlâ 1'dir. O bileşen ağ arayüzüdür ve açtığı kalem 4'tür — dar bir sınır. Ayrıca sekiz bileşenden **ikisi** tek başına envanterin tamamını açar; bu iki bileşen, ölçüm ağındaki her makinede önce sayılması gereken kalemdir. #### Özet - Bir bileşenin güvenlik değeri üç sayıdır: sınırın adı ve tarafı, sınırı geçmek için aynı anda yanlış olması gereken kalem sayısı, sınır düştüğünde erişilen kalem sayısı. - 43 kalemlik envanterde sekiz bileşenin açtığı kalem 3 ile 43 arasında değişir; bellenim ve bant dışı yönetim arayüzü tek başına envanterin tamamını açar, çünkü ikisi de açılış zincirinin ya da yönetim yolunun altında durur. - Uzaktan en düşük eşik 1'dir ve 4 kalem açar; fiziksel erişimde en düşük eşik 0'dır ve 43 kalem açar. Şifrelenmemiş depolamada dosya sistemi izni bir sınır değil, diskte duran veridir. - Dar ve derin sınır (güvenilir platform birimi: 3 kalem, eşik 3) ile geniş ve sığ sınır (kalıcı depolama: 22 kalem, eşik 0) aynı tabloda ancak iki sayı ayrı yazılırsa ayırt edilir. - Eşik sayısı kalemlerin bağımsız olduğunu varsayar. Aynı yetki ya da aynı yapılandırma kalemi ikisini birden değiştirebiliyorsa iki kalemlik sınır gerçekte tek kalemliktir; tablo bir üst sınır verir, alt sınır vermez. - Dört ayardan üçü açıldıktan sonra bile açılan kalem 43'te kalır; sayı ancak en çok kalem açan gevşek sınır kapatıldığında 4'e iner. Ölçülen şey sınırların ortalaması değil, en zayıfıdır. #### Sonraki Adım Donanımın çizdiği sınırlar sayıldı ve ikisinin envanterin tamamını açtığı görüldü. Ancak birinci tablodaki sınırların çoğunu donanım yalnız **mümkün kılar**; hangi isteğin geçeceğine karar veren kod donanımda değildir. Ayrıcalık kipini işlemci sunar, o kipte hangi sürecin koşacağını işletim sistemi seçer; dosya sistemi iznini disk saklar, o izne uyacak olan yine işletim sistemidir. Sonraki ders bu karar katmanına iner ve tek bir soru sorar: aynı donanım üzerinde çalışan farklı işletim sistemi aileleri, aynı erişim isteğine kaç kalemde farklı yanıt verir. ### İşletim Sistemi Aileleri Source: https://academia.sh/tr/kurslar/bt-temelleri/isletim-sistemi-aileleri İşletim sistemi ailelerinin ürün adıyla değil güvenlik modeliyle ayrılması: 14 sistem isteğinin üç ailede 4, 11 ve 12 kalemde farklı sonuç vermesi, yönetici sınırını geçmenin 1, 2 ve 3 kaleme mal olması, sınır düştüğünde erişilen isteğin 13, 9 ve 5 olması ve yönetici olunsa da erişilemeyen isteğin 1, 1 ve 9'a çıkması. Önceki ders donanımın çizdiği sınırları saydı ve bir ayrım bıraktı: donanım sınırı yalnız **mümkün kılar**. İşlemci ayrıcalık kipini sunar, o kipte hangi kodun koşacağına karar vermez; kalıcı depolama izin bitlerini saklar, onlara uyup uymamak diski takan yazılımın işidir. Kararı veren katman işletim sistemidir. Bu katman anıldığında genellikle ürün adları sıralanır. Ürün adı bir karar taşımaz: adlar değişir, sürümler birbirinin özelliğini alır ve aynı ad altındaki iki kurulum bambaşka davranabilir. Karar taşıyan şey ailenin **güvenlik modelidir** — aynı isteğe hangi yanıtı verdiği, o yanıtı değiştirmenin kaç kaleme mal olduğu. #### Üç Aile, Üç Model Bu derste aileler modelleriyle anılır. **Ayrık kullanıcı ve grup izni taşıyan aile.** Her nesnenin bir sahibi ve bir grubu vardır; erişim, sahip–grup–diğerleri sınıflarına verilen bitlerle belirlenir. Ayrıcalık tek bir üstün kimlikte toplanır: o kimliğe geçen her şeyi yapar. **Erişim denetim listesi (access control list) taşıyan aile.** Nesne başına, özne başına giriş tutulur; ayrıca sistem ayrıcalıkları **bölünmüştür** — saati değiştirme, tüm diski okuyan yedek alma, günlüğe dokunma ayrı ayrı verilebilen kalemlerdir. Yönetici olmak bunların hepsini kendiliğinden vermez. **İmzalı uygulama deposuna dayanan aile.** Çalıştırılabilir kod yalnız imzalı bir kaynaktan gelir ve her uygulama kendi yalıtılmış alanında koşar. Bazı istekler, kullanıcı yönetici olsa da, modelde **hiçbir yolla** verilmez. Üç tanımın ortak noktası, hepsinin aynı donanım üzerinde koşabilmesidir. Önceki dersteki sekiz sınır bu üç ailede de aynı yerdedir; değişen şey, o sınırların üstünde hangi isteğin hangi koşulla geçtiğidir. Bu yüzden aileler ancak **aynı istek kümesi** üzerinde karşılaştırılabilir: farklı istek listeleriyle yapılan karşılaştırma, ailelerin değil listelerin farkını ölçer. #### Aynı İstek Kümesi Üç Ailede Örnek, kurgu **bölgesel ölçüm ağı**ndaki saha ekiplerinin dizüstü bilgisayarıdır. Ekip ve istek kümesi kurgudur; aşağıdaki matris bir **modeldir**, gerçek bir dağıtım, ürün ya da satıcı yoktur. **DI7:** istek kümesi 14 kalemdir ve üç ailede aynı biçimde sorulur. **DI8:** sonuç dört değerlidir — `izin` doğrudan verilir, `onay` yönetici sınırı aşılarak verilir, `ayri` kendi ayrıcalık kalemiyle tam yönetici olunmadan verilir, `ret` o ailede hiçbir yolla verilmez. **DI9:** yönetici sınırını geçmek ayrık izin ailesinde 1, erişim denetim listesi ailesinde 2, imzalı depo ailesinde 3 kalem ister. **DI10:** `ayri` sonuçlu her istek kendi kalemini ayrıca ister. **DI11:** senaryo iki aşamalıdır — önce standart bir hesap ele geçer, sonra yönetici sınırı düşer. ```js // bt/aile.mjs — ayni sistem istegi kumesinin uc isletim sistemi ailesindeki sonucu (model): // gercek bir dagitim, urun ya da satici yok. Rastgelelik yok. // Aileler guvenlik modeliyle anilir. gec: yonetici sinirini gecmek icin gereken kalem; // ekKalem: "ayri" sonuclu her istek icin ayrica gereken kalem. export const AILE = [ { kod: "ayrik-izin", gec: 1, ekKalem: 0 }, // ayrik kullanici ve grup izni tasiyan aile { kod: "erisim-listesi", gec: 2, ekKalem: 1 }, // erisim denetim listesi tasiyan aile { kod: "imzali-depo", gec: 3, ekKalem: 1 }, // imzali uygulama deposuna dayanan aile ]; // Sonuc: izin (dogrudan), onay (yonetici sinirinin asilmasiyla), ayri (kendi ayricalik // kalemiyle, tam yonetici gerekmeden), ret (bu ailede hicbir yolla verilmez). export const ISTEK = ` kendi-belgesini-okuma izin izin izin baska-kullanici-belgesi ret ret ret sistem-dizinine-yazma onay onay ret depodan-yazilim-kurma onay onay izin imzasiz-yazilim-calistirma izin izin ret surucu-yukleme onay onay ret baslangic-ogesi-ekleme izin izin onay ayricalikli-uc-acma onay onay ret baska-surecin-bellegini-okuma onay onay ret sistem-saatini-degistirme onay ayri ret gunluk-silme onay ayri ret disk-birimi-takma onay ayri onay kamera-ve-mikrofon izin izin onay tum-diski-okuyan-yedek onay ayri ret` .trim().split("\n").map((r) => { const [ad, ...s] = r.trim().split(/\s+/); return { ad, s: Object.fromEntries(AILE.map((a, i) => [a.kod, s[i]])) }; }); export const SONUC = ["izin", "onay", "ayri", "ret"]; export const say = (a, c) => ISTEK.filter((i) => i.s[a.kod] === c).length; // Iki asamali senaryo: once standart hesap ele gecer, sonra yonetici siniri duser. export function asama(a) { const izin = say(a, "izin"); const onay = say(a, "onay"); const ayri = say(a, "ayri"); return { izin, sinirDuser: izin + onay, hepsi: izin + onay + ayri, gec: a.gec, kalem: a.gec + ayri * a.ekKalem, ret: say(a, "ret") }; } ``` ```js // bt/aileolc.mjs — ayni istek kumesi uc ailede kac kalemde ayrisiyor, sinir dusunce ne aciliyor. import { AILE, ISTEK, SONUC, say, asama } from "./aile.mjs"; const yaz = (g, ...s) => console.log(s.map((v, i) => (g[i] < 0 ? String(v).padEnd(-g[i]) : String(v).padStart(g[i]))).join("")); const K = AILE.map((a) => a.kod); console.log(`${ISTEK.length} sistem istegi x ${AILE.length} aile; sonuc: ` + "izin dogrudan, onay yonetici sinirini asarak, ayri kendi ayricalik kalemiyle, ret hicbir yolla"); const A = [-32, 15, 16, 13]; console.log("\n1. ayni istek kumesi uc ailede"); yaz(A, "istek", ...K); for (const i of ISTEK) yaz(A, i.ad, ...K.map((k) => i.s[k])); const B = [-32, 15, 16, 13]; console.log("\n2. aile basina sayim"); yaz(B, "olcu", ...K); for (const c of SONUC) yaz(B, `${c} sonuclu istek`, ...AILE.map((a) => say(a, c))); const R = AILE.map(asama); for (const [ad, f] of [["yonetici sinirini gecmek: kalem", (r) => r.gec], ["tumune erismek icin: kalem", (r) => r.kalem], ["standart hesapta erisilen istek", (r) => r.izin], ["sinir dusunce erisilen istek", (r) => r.sinirDuser], ["her kalem alinsa erisilen istek", (r) => r.hepsi], ["yonetici olsa da erisilemeyen", (r) => r.ret]]) yaz(B, ad, ...R.map(f)); const C = [-32, 15]; console.log("\n3. ikili karsilastirma (kac istekte sonuc farkli)"); yaz(C, "cift", "farkli istek"); for (let x = 0; x < K.length; x++) for (let y = x + 1; y < K.length; y++) yaz(C, `${K[x]} - ${K[y]}`, ISTEK.filter((i) => i.s[K[x]] !== i.s[K[y]]).length); yaz(C, "uc ailede de ayni", ISTEK.filter((i) => new Set(K.map((k) => i.s[k])).size === 1).length); yaz(C, "uc ailede de farkli", ISTEK.filter((i) => new Set(K.map((k) => i.s[k])).size === 3).length); ``` ``` 14 sistem istegi x 3 aile; sonuc: izin dogrudan, onay yonetici sinirini asarak, ayri kendi ayricalik kalemiyle, ret hicbir yolla 1. ayni istek kumesi uc ailede istek ayrik-izin erisim-listesi imzali-depo kendi-belgesini-okuma izin izin izin baska-kullanici-belgesi ret ret ret sistem-dizinine-yazma onay onay ret depodan-yazilim-kurma onay onay izin imzasiz-yazilim-calistirma izin izin ret surucu-yukleme onay onay ret baslangic-ogesi-ekleme izin izin onay ayricalikli-uc-acma onay onay ret baska-surecin-bellegini-okuma onay onay ret sistem-saatini-degistirme onay ayri ret gunluk-silme onay ayri ret disk-birimi-takma onay ayri onay kamera-ve-mikrofon izin izin onay tum-diski-okuyan-yedek onay ayri ret 2. aile basina sayim olcu ayrik-izin erisim-listesi imzali-depo izin sonuclu istek 4 4 2 onay sonuclu istek 9 5 3 ayri sonuclu istek 0 4 0 ret sonuclu istek 1 1 9 yonetici sinirini gecmek: kalem 1 2 3 tumune erismek icin: kalem 1 6 3 standart hesapta erisilen istek 4 4 2 sinir dusunce erisilen istek 13 9 5 her kalem alinsa erisilen istek 13 13 5 yonetici olsa da erisilemeyen 1 1 9 3. ikili karsilastirma (kac istekte sonuc farkli) cift farkli istek ayrik-izin - erisim-listesi 4 ayrik-izin - imzali-depo 11 erisim-listesi - imzali-depo 12 uc ailede de ayni 2 uc ailede de farkli 3 ``` Sayılar **ölçüm** sınıfındadır; girdileri DI7–DI11'dir. #### Yönetici Sınırı Kaç Kalem İkinci tablonun beşinci ve altıncı satırları bu dersin ölçüsünü verir. Yönetici sınırını geçmek ayrık izin ailesinde **1**, erişim denetim listesi ailesinde **2**, imzalı depo ailesinde **3** kalemdir. Ama alt satır farklıdır: **her isteğe** erişmek için gereken kalem 1, **6** ve 3'tür. Aradaki fark ayrıcalığın bölünmesinden gelir. Ayrık izin ailesinde üstün kimliğe geçmek bir kalemdir ve o kalem her şeyi verir; sınırı geçme maliyeti ile tümüne erişme maliyeti aynı sayıdır. Erişim denetim listesi ailesinde yönetici olmak dört isteği daha vermez; her biri kendi ayrıcalık kalemini ister ve toplam 6'ya çıkar. **Bölünmüş ayrıcalık, sınırın yüksekliğini değil, sınırdan sonraki mesafeyi uzatır.** Bu ayrımı görmek için iki sayının ayrı yazılması gerekir. Tek bir "yönetici olmak zor mu" sorusu 1, 2, 3 dizisini verir ve üç aileyi neredeyse eşit gösterir; ikinci sayı eklendiğinde dizi 1, 6, 3 olur ve sıralama değişir. #### Sınır Düştüğünde Ne Açılır Üçüncü sütun grubu senaryonun ikinci aşamasını okur. Standart bir hesap ele geçtiğinde doğrudan erişilen istek üç ailede 4, 4 ve 2'dir — neredeyse aynı. Yönetici sınırı düştüğünde sayılar ayrışır: **13, 9 ve 5**. Ayrık izin ailesinde 14 isteğin 13'ü açılır. Tek kalem, envanterin tamamına yakınını verir; bu, önceki derste bellenim satırında görülen örüntünün yazılım tarafındaki karşılığıdır. Erişim denetim listesi ailesinde aynı anda açılan istek 9'dur ve kalan 4 istek için dört ayrı kalem daha gerekir. İmzalı depo ailesinde sınır düşse bile açılan istek 5'te kalır, çünkü kalan 9 istek modelde hiçbir kalem alınarak açılmaz. Son satır bunu doğrudan yazar: yönetici olunsa da erişilemeyen istek sayısı **1, 1 ve 9**'dur. Bu, üç ailenin en keskin farkıdır ve tek bir tasarım kararından çıkar — ayrıcalığın en üst noktasının her şeyi verip vermemesi. Senaryonun ikinci aşaması, bir hesabın taşıdığı yetkinin sistemin izin verdiğinden fazlasına çevrilmesidir; bu adıma **yetki yükseltme (privilege escalation)** denir. Burada ölçülen şey yükseltmenin nasıl yapıldığı değil, **yapıldığı varsayıldığında açılan istek sayısıdır**; adımın kendisi bir modeldir ve bu derste hiçbir çalışan örneği yoktur. Bir sistemde yükseltme denemesi, yazılı yetki ve tanımlı kapsam olmadan yapıldığında hem yasadışı hem de meslek dışıdır. #### Modelin Görmediği Kalem Tablodaki `ret` değeri modelde mutlaktır: o istek hiçbir kalem alınarak açılmaz. Gerçek bir kurulumda mutlak değildir. İmzalı depo ailesinde imzalayan anahtarın kendisi, kuruma özel kayıt profilleri, geliştirme kipi ve depo dışı kurulum izni birer kalemdir; bunlardan biri açıksa `ret` sonuçlarının bir bölümü `onay`a döner ve son satırdaki 9 düşer. Bu, modelin kusuru değil sınırıdır ve nasıl kullanılacağını belirler. **Tablo bir aileyi değil, bir ailenin varsayılan yapılandırmasını ölçer.** Sayıyı bir makineye uygularken önce iki soru sorulur: `ret` sonuçlarını `onay`a çeviren kaç kalem bu makinede açık ve o kalemleri kim değiştirebiliyor. İkinci sorunun yanıtı "yönetici" ise, imzalı depo ailesinin 9'u gerçekte 9 değildir. Aynı sınırlama ters yönde de işler. Ayrık izin ailesinde 1 olarak yazılan "yönetici olunsa da erişilemeyen istek" sayısı, zorunlu erişim denetimi katmanı eklenmiş bir kurulumda yükselir; o katman ayrıcalığı bölmenin başka bir yoludur. **Aile adı bir üst sınır verir, kurulum ise gerçek sayıyı.** Bu yüzden bir sonraki ders ailenin değil kurulumun kendisini ölçer. #### Aynı Aile, İki Kurulum Ölçüm ağındaki saha dizüstü bilgisayarlarının hepsi aynı ailedendir, ama ikisi aynı sayıyı vermez. Birinde standart kullanıcı hesabı, ötekinde günlük iş yönetici hesabıyla yapılıyorsa senaryonun ilk aşaması ikincisinde doğrudan ikinci aşamadan başlar: ele geçen hesap zaten sınırın öte yanındadır ve yönetici sınırını geçmek için gereken kalem 1 değil **0**'dır. Bu, önceki dersteki sıfır eşiğin yazılım tarafındaki karşılığıdır. Sıfır, sınırın zayıf olduğunu değil, kurulmadığını söyler. Aile seçimi bu durumda hiçbir şey değiştirmez: en sıkı modelde bile günlük işin yönetici hesabıyla yapılması, tablodaki `onay` sütununu `izin` sütununa taşır ve üç ailenin arasındaki 4, 11, 12 farkı büyük ölçüde silinir. #### Bedel: Yapılamayan Meşru İş Aynı satır, ters yönden okunduğunda savunmanın bedelini verir. İmzalı depo ailesinde erişilemeyen 9 isteğin içinde sürücü yükleme, tüm diski okuyan yedek alma ve başka bir sürecin belleğini okuma vardır. Bu üç iş de meşru bir yönetim işidir: ölçüm ağında bir sayaç okuyucu aygıtın sürücüsü yüklenmek zorundadır, saha dizüstü bilgisayarının tam yedeği alınmak zorundadır, bir çökme incelenirken sürecin belleği okunmak zorundadır. Model bu işleri "yapılamaz" saymaz, **başka yerde yapılır** sayar: sürücü imzalanıp depoya girer, yedek uygulama başına verilen bir izinle alınır, çökme kaydı işletim sisteminin kendi düzeneğiyle toplanır. Bedel, işin ortadan kalkması değil, **her birinin ayrı bir onaylı yola bağlanmasıdır** — ve o yolların sayısı 9'dur. Ayrık izin ailesinde bu bedel 1'dir; buna karşılık sınır düştüğünde açılan istek 13'tür. Üçüncü tablo bu ödünleşimin nerede yoğunlaştığını gösterir. İlk iki aile birbirinden yalnız **4** istekte ayrılır ve bu dördü de ayrıcalığın bölünmesiyle ilgilidir. İmzalı depo ailesi ötekilerden **11** ve **12** istekte ayrılır. Üç ailede de aynı sonucu veren istek yalnızca **2**'dir: kendi belgesini okuma ve başka kullanıcının belgesini okuma. Ortak taban, bir kullanıcının kendi verisiyle başkasının verisi arasındaki ayrımdan ibarettir; onun ötesindeki her şey aileye bağlıdır. Ödünleşim tek yönlü okunmaz. Ölçüm ağında saha dizüstü bilgisayarı ile şube sunucusu aynı tabloya farklı yerlerden bakar. Dizüstü bilgisayarda çalıştırılan kod büyük ölçüde dışarıdan gelir ve kullanıcı sistemin bakımını yapmaz; orada `ret` sayısının yüksek olması bedel değil kazançtır. Şube sunucusunda ise sürücü yükleme, tam yedek ve bellek incelemesi işin kendisidir; aynı 9 sayısı orada dokuz ayrı istisna yolu demektir ve her istisna yolu kendi başına bir kalemdir. **Aynı sayı bir makinede kapanan yol, ötekinde yeni açılan yapılandırma kalemidir.** Aile seçimi bu yüzden makine sınıfı başına yapılır, kurum başına değil. #### Özet - İşletim sistemi ailesi ürün adıyla değil güvenlik modeliyle ayrılır: aynı isteğe verdiği yanıt ve o yanıtı değiştirmenin kaç kaleme mal olduğu. - 14 istek üç ailede 4, 11 ve 12 kalemde farklı sonuç verir; üçünde de aynı sonucu veren istek yalnızca 2'dir. - Yönetici sınırını geçmek 1, 2 ve 3 kalemdir; her isteğe erişmek 1, 6 ve 3 kalemdir. Bölünmüş ayrıcalık sınırın yüksekliğini değil, sınırdan sonraki mesafeyi uzatır. - Sınır düştüğünde erişilen istek 13, 9 ve 5'tir. Ayrıcalığın en üst noktası her şeyi veriyorsa tek kalem 14 isteğin 13'ünü açar. - Bedel, yönetici olunsa da erişilemeyen istek sayısıdır: 1, 1 ve 9. İmzalı depo ailesinde kapatılan dokuz isteğin çoğu meşru yönetim işidir ve her biri ayrı bir onaylı yola bağlanır. - Tablo bir aileyi değil, ailenin varsayılan yapılandırmasını ölçer. Günlük iş yönetici hesabıyla yapılıyorsa yönetici sınırını geçmek için gereken kalem 0'a iner ve aileler arasındaki fark silinir. #### Sonraki Adım Üç aile de kendi modelini bir kurulumla getirir; tablodaki sonuçlar o kurulumun varsayılan değerleridir. Ama varsayılan değer bir seçim değildir: kurulumu yapan kişi hiçbir şey seçmediğinde kalan durumdur. Sonraki ders bu ana bakar. Temiz bir kurulum bittiğinde kaç kalem açık kalıyor, ilk sertleştirmede kaçı kapanıyor ve kaçı ancak makine yeniden kurulursa kapatılabiliyor. ### Kurulum ve Yapılandırma Source: https://academia.sh/tr/kurslar/bt-temelleri/kurulum-ve-yapilandirma Temiz kurulumun kendisinin ölçülmesi: 20 yapılandırma kaleminin 17'sinin varsayılanda riskli kalması, başlangıç sertleştirmesinin 8'ini kapatması, 4'ünün yalnız yeniden kurulumla kapanması ve 1'inin hiç kapanmaması; ağa bağlanmadan önce sertleştirme yapıldığında penceredeki açık kalemin 17'den 9'a, sürekli kalemler de kapatıldığında 5'e inmesi. Önceki ders üç işletim sistemi ailesini aynı istek kümesi üzerinde karşılaştırdı ve son bölümde bir uyarı bıraktı: tablodaki sonuçlar ailenin **varsayılan yapılandırmasına** aittir. Varsayılan bir seçim değildir; kurulumu yapan kişi hiçbir şey seçmediğinde geriye kalan durumdur. Bu ders o durumu ölçer. Temiz bir kurulum bittiğinde kaç kalem riskli kalıyor, bunların kaçı hemen kapatılabiliyor, kaçı ancak makine yeniden kurulursa kapanıyor ve kaçı hiç kapanmıyor. #### Kurulum Bir An Değil, Bir Karar Kümesi Kurulum genellikle tek bir olay gibi anılır: makine kuruldu. Ölçüm açısından bakıldığında kurulum bir **karar kümesidir** ve kararların hepsi aynı anda geri alınabilir değildir. Bazı kalemler yalnız kurulum sırasında belirlenir. Bir birimi sonradan şifrelemek verinin taşınması demektir; bölüm düzenini sonradan değiştirmek dosya sistemini yeniden kurmak demektir; makine kimliğini üreten anahtar ilk açılışta üretilir ve o an zayıf bir kaynak kullanıldıysa sonradan düzeltmek kimliğin değişmesi demektir. Bu kalemler için "sonradan yaparız" bir seçenek değil, **yeniden kurulum** demektir. Bazı kalemler kurulumdan hemen sonraki **başlangıç sertleştirmesinde (baseline hardening)** kapatılır: varsayılan hesaplar, varsayılan parolalar, açık bırakılmış hizmetler. Bazıları makine kullanımdayken de kapatılabilir. Bir tanesi hiç kapanmaz. Bu dört zamanın ayrı ayrı sayılması, "kurulum sertleştirildi" cümlesini bir sayıya çevirir. #### Yirmi Kalem, Dört Zaman Örnek, kurgu **bölgesel ölçüm ağı**nda yeni kurulan bir şube sunucusudur. Sunucu da kalem listesi de kurgudur; aşağıdaki tablo bir **modeldir**, gerçek bir dağıtım, kurulum aracı ya da satıcı yoktur. **DI12:** yapılandırma kalemi kümesi 20'dir ve her kalem bir kapatma zamanı taşır. **DI13:** kapatma zamanı dört değerlidir — `kurulum` yalnız kurulum anında, `ilk` başlangıç sertleştirmesinde, `sonra` makine kullanımdayken, `hic` hiçbir zaman. **DI14:** temiz kurulumun bıraktığı durum riskli ya da güvenlidir. **DI15:** `acar`, kalem açık kaldığında erişilen kalem sayısıdır; kalemler aynı varlıklara dokunabildiği için toplanmaz, **en yükseği** yazılır. **DI16:** pencere, makine ağa bağlıyken henüz kapatılmamış riskli kalemlerin kümesidir. ```js // bt/kurulum.mjs — temiz kurulumun biraktigi yapilandirma kalemleri (model): gercek bir // dagitim, kurulum araci ya da satici yok. Rastgelelik yok. // zaman: kalemin ne zaman kapatilabilecegi — kurulum (yalnizca kurulum anında; sonradan // degistirmek yeniden kurulum ister), ilk (kurulumdan hemen sonraki baslangic // sertlestirmesinde), sonra (istenen zaman), hic (kapatilamaz, yalnizca yonetilir). // vars: temiz kurulumun biraktigi durum riskli mi. acar: kalem acik kalirsa erisilen kalem. export const KALEM = ` disk-sifrelemesi kurulum riskli 11 ayrik-veri-bolumu kurulum riskli 6 acilis-imza-kaydi kurulum riskli 9 makine-anahtari-uretimi kurulum riskli 3 kurulum-kaynagi-dogrulamasi kurulum guvenli 14 bellenim-yonetici-parolasi ilk riskli 12 varsayilan-yonetici-hesabi ilk riskli 8 varsayilan-parola ilk riskli 8 uzak-yonetim-hizmeti ilk riskli 7 gereksiz-hizmet-kumesi ilk riskli 5 guvenlik-duvari-varsayilani ilk riskli 6 otomatik-oturum-acma ilk riskli 4 konuk-hesabi ilk guvenli 3 gunluk-toplama ilk riskli 4 saat-esitleme ilk guvenli 2 ekran-kilidi-suresi sonra riskli 2 yazilim-kaynagi-kisitlamasi sonra riskli 5 yedek-programi sonra riskli 9 surucu-imza-zorunlulugu sonra riskli 6 donanim-hata-kanali hic riskli 1` .trim().split("\n").map((r) => { const [ad, zaman, vars, acar] = r.trim().split(/\s+/); return { ad, zaman, riskli: vars === "riskli", acar: Number(acar) }; }); export const ZAMAN = ["kurulum", "ilk", "sonra", "hic"]; export const riskli = KALEM.filter((k) => k.riskli); export const sayZaman = (z, hepsi = KALEM) => hepsi.filter((k) => k.zaman === z).length; // Bir sirada, pencerede acik kalan riskli kalemler: kapatilmis asamalar disarida kalir. export function pencere(kapanan) { const acik = riskli.filter((k) => !kapanan.includes(k.zaman)); return { adet: acik.length, enKotu: Math.max(...acik.map((k) => k.acar)), kotuAd: acik.reduce((a, b) => (b.acar > a.acar ? b : a)).ad }; } ``` ```js // bt/kurulumolc.mjs — temiz kurulumda kac kalem acik, kaci ne zaman kapaniyor, sira ne degistiriyor. import { KALEM, ZAMAN, riskli, sayZaman, pencere } from "./kurulum.mjs"; const yaz = (g, ...s) => console.log(s.map((v, i) => (g[i] < 0 ? String(v).padEnd(-g[i]) : String(v).padStart(g[i]))).join("")); console.log(`${KALEM.length} yapilandirma kalemi; temiz kurulumun biraktigi riskli kalem: ` + `${riskli.length}; kapatma zamani: ${ZAMAN.join(", ")}`); const A = [-30, 11, 12, 8]; console.log("\n1. kalem basina kapatma zamani (acar: kalem acik kalirsa erisilen kalem)"); yaz(A, "kalem", "zaman", "varsayilan", "acar"); for (const k of KALEM) yaz(A, k.ad, k.zaman, k.riskli ? "riskli" : "guvenli", k.acar); const B = [-30, 11, 12, 8]; console.log("\n2. kapatma zamanina gore dagilim"); yaz(B, "zaman", "kalem", "riskli", "en kotu"); for (const z of ZAMAN) { const r = riskli.filter((k) => k.zaman === z); yaz(B, z, sayZaman(z), r.length, r.length ? Math.max(...r.map((k) => k.acar)) : 0); } yaz(B, "toplam", KALEM.length, riskli.length, Math.max(...riskli.map((k) => k.acar))); const C = [-33, -29, 12, 9]; console.log("\n3. iki kurulum sirasi (pencere: aga bagliyken acik kalan riskli kalem)"); yaz(C, "sira", "penceredeki en kotu kalem", "acik kalem", "acar"); for (const [ad, kapanan] of [["kur -> aga bagla -> sertlestir", []], ["kur -> sertlestir -> aga bagla", ["ilk"]], [" + surekli kalemler de kapali", ["ilk", "sonra"]]]) { const s = pencere(kapanan); yaz(C, ad, s.kotuAd, s.adet, s.enKotu); } const D = [-36, 12]; console.log("\n4. sertlestirme bittikten sonra ne kaliyor"); yaz(D, "olcu", "kalem"); yaz(D, "ilk sertlestirmede kapanan", riskli.filter((k) => k.zaman === "ilk").length); yaz(D, "sonradan kapatilabilen", riskli.filter((k) => k.zaman === "sonra").length); yaz(D, "yalniz yeniden kurulumla kapanan", riskli.filter((k) => k.zaman === "kurulum").length); yaz(D, "hic kapanmayan", riskli.filter((k) => k.zaman === "hic").length); yaz(D, "kurulum kalemlerinin actigi en kotu", Math.max(...riskli.filter((k) => k.zaman === "kurulum").map((k) => k.acar))); ``` ``` 20 yapilandirma kalemi; temiz kurulumun biraktigi riskli kalem: 17; kapatma zamani: kurulum, ilk, sonra, hic 1. kalem basina kapatma zamani (acar: kalem acik kalirsa erisilen kalem) kalem zaman varsayilan acar disk-sifrelemesi kurulum riskli 11 ayrik-veri-bolumu kurulum riskli 6 acilis-imza-kaydi kurulum riskli 9 makine-anahtari-uretimi kurulum riskli 3 kurulum-kaynagi-dogrulamasi kurulum guvenli 14 bellenim-yonetici-parolasi ilk riskli 12 varsayilan-yonetici-hesabi ilk riskli 8 varsayilan-parola ilk riskli 8 uzak-yonetim-hizmeti ilk riskli 7 gereksiz-hizmet-kumesi ilk riskli 5 guvenlik-duvari-varsayilani ilk riskli 6 otomatik-oturum-acma ilk riskli 4 konuk-hesabi ilk guvenli 3 gunluk-toplama ilk riskli 4 saat-esitleme ilk guvenli 2 ekran-kilidi-suresi sonra riskli 2 yazilim-kaynagi-kisitlamasi sonra riskli 5 yedek-programi sonra riskli 9 surucu-imza-zorunlulugu sonra riskli 6 donanim-hata-kanali hic riskli 1 2. kapatma zamanina gore dagilim zaman kalem riskli en kotu kurulum 5 4 11 ilk 10 8 12 sonra 4 4 9 hic 1 1 1 toplam 20 17 12 3. iki kurulum sirasi (pencere: aga bagliyken acik kalan riskli kalem) sira penceredeki en kotu kalem acik kalem acar kur -> aga bagla -> sertlestir bellenim-yonetici-parolasi 17 12 kur -> sertlestir -> aga bagla disk-sifrelemesi 9 11 + surekli kalemler de kapali disk-sifrelemesi 5 11 4. sertlestirme bittikten sonra ne kaliyor olcu kalem ilk sertlestirmede kapanan 8 sonradan kapatilabilen 4 yalniz yeniden kurulumla kapanan 4 hic kapanmayan 1 kurulum kalemlerinin actigi en kotu 11 ``` Sayılar **ölçüm** sınıfındadır; girdileri DI12–DI16'dır. #### Temiz Kurulum Ne Bırakıyor Başlık satırı ilk sayıyı verir: 20 kalemin **17'si** temiz kurulumdan riskli durumda çıkar. Üçü güvenlidir — kurulum kaynağının doğrulanması, konuk hesabının kapalı olması ve saat eşitlemesinin açık olması. Bu oran, sertleştirmenin neden ayrı bir iş olduğunu açıklar. Kurulum aracı bir güvenlik kararı vermez; çalışan bir sistem bırakır. Çalışan bir sistemin varsayılanları, kurulumun **başarılı sayılmasını** kolaylaştıracak yönde seçilir: hizmetler açık, hesaplar hazır, uzaktan erişim kullanılabilir. Bu tercihlerin her biri kendi başına savunulabilir; toplamı 17 kalemdir. Güvenli çıkan üç kalem de rastgele değildir. Kurulum kaynağının doğrulanması kurulum aracının kendi işidir ve doğrulanmazsa kurulan sistemin tamamı sorgulanır — bu yüzden açtığı sayı 14 ile listenin en yükseğidir ve aynı nedenle varsayılan olarak açıktır. Saat eşitlemesi kayıtların karşılaştırılabilir olması için gerekir. Konuk hesabının kapalı gelmesi ise eski bir varsayılanın tersine dönmüş hâlidir: bir kalemin varsayılanı, o kalemin geçmişte ne kadar sorun çıkardığına göre değişir. İkinci tablo dağılımı verir. On kalem başlangıç sertleştirmesinde kapatılabilir ve bunların 8'i risklidir. Beş kalem yalnız kurulum anında belirlenir ve dördü risklidir. Dört kalem makine kullanımdayken kapanır. Bir kalem hiç kapanmaz. Satırların `en kotu` sütunu ayrıca bir sıralama verir. Başlangıç sertleştirmesindeki en kötü kalem 12 varlık açar ve bu, listedeki en yüksek riskli değerdir; kurulum anındaki en kötü kalem 11, sürekli kalemlerdeki en kötü 9'dur. Yani en çok varlık açan riskli kalem, en ucuz kapatılan sınıftadır. Bu sıralama sertleştirme sırasını belirler: önce en yüksek `acar` değerine sahip kalemler kapatılır, çünkü onları kapatmanın maliyeti ile kazancı arasındaki fark en büyüktür. #### Kurulum Anında Kaçırılan Kalem Dördüncü tablonun üçüncü satırı bu dersin en pahalı sayısını verir: **4 kalem yalnız yeniden kurulumla kapanır** ve bunların açtığı en kötü kalem sayısı 11'dir. Bu dört kalemin ortak yanı, sisteme sonradan eklenemeyecek bir yapıya karşılık gelmeleridir. Disk şifrelemesi bir ayar değil, birimin nasıl yazıldığıdır. Ayrık veri bölümü bir tercih değil, dosya sisteminin nerede başlayıp bittiğidir. Açılış imza kaydı, önceki derste sayılan açılış zincirinin güvenilen anahtar kümesidir ve zincir bir kez o kayıtsız kurulduğunda üstteki hiçbir katman geriye dönüp onu ekleyemez. Makine kimliğini üreten anahtar ilk açılışta üretilir. Sayının pratik karşılığı şudur: bu dört kalem için **denetim listesi kurulumdan sonra çalıştırılamaz**. Kurulumdan sonra yapılan bir denetim, kalan 13 riskli kalemi bulur ve dördünü "eksik" olarak yazar — ama o dördünü kapatmanın maliyeti bir ayar değişikliği değil, makinenin yeniden kurulmasıdır. Ölçüm ağındaki kırk şube sunucusu düşünüldüğünde bu, dört ayarın değil kırk makinenin yeniden kurulmasıdır. #### Pencere: Sertleştirmeden Önce Ağa Bağlanmak Üçüncü tablo sıranın bedelini ölçer. Makine kurulup **önce ağa bağlanır**, sonra sertleştirilirse pencerede 17 riskli kalem açıktır ve en kötü kalem 12 varlık açar. Sertleştirme ağa bağlanmadan önce yapılırsa açık kalem 9'a iner ve en kötü kalem 11'e düşer. Sürekli kapatılabilen kalemler de bağlantıdan önce kapatılırsa açık kalem **5**'e iner. Aradaki fark tek bir yeni denetim eklemeden elde edilir. Kapatılan kalemler her üç sırada da aynıdır; değişen yalnızca **ne zaman** kapatıldıklarıdır. Bu, önceki derslerdeki eşik ölçümünden farklı bir kazanç türüdür: sınır güçlendirilmemiş, sınırın kurulmadığı süre kısaltılmıştır. Pencere hiçbir sırada sıfıra inmez. En iyi sırada bile 5 riskli kalem açıktır ve en kötüsü 11 varlık açar; bunlar kurulum anında belirlenen ve hiç kapanmayan kalemlerdir. Pencereyi kapatmanın tek yolu kalemleri **kurulum sırasında** kapatmaktır — yani sertleştirmeyi kurulumdan sonraki bir adım olmaktan çıkarıp kurulumun kendisine taşımak. #### Kurulum Profili ile Denetim Listesi Ayrımı Üçüncü tablonun okunmasının doğrudan bir karşılığı vardır. Riskli kalemlerin **12'si** — kurulum anına ait 4 ile başlangıç sertleştirmesine ait 8 — makine ilk kez açılmadan önce belirlenebilir. Bunlar bir denetim listesi maddesi olarak değil, kurulumun kendisinin bir parçası olarak yazıldığında pencere hiç açılmaz. Ayrım şudur. **Denetim listesi**, kurulmuş bir makinede kalemleri tek tek sorar ve eksikleri raporlar; her sorgu bir zaman noktasında yapılır ve o noktaya kadar geçen süre penceredir. **Kurulum profili**, aynı kalemleri kurulum sırasında uygulanacak kararlar olarak taşır; makine kurulduğunda kalemler zaten kapalıdır ve pencere sıfırdır. İki yaklaşımın kapsamı da farklıdır. Denetim listesi 20 kalemin hepsini sorabilir ama yalnız 12'sini düzeltebilir — başlangıç sertleştirmesinde kapatılabilenler artı sürekli kalemler, yani 8 artı 4. Kurulum profili 12 kalemi kapatır ve geriye sürekli kalemlerle kapatılamayan kalemi bırakır. **İkisi birbirinin yerine geçmez:** profil pencereyi kapatır, liste zamanla açılan kalemleri yakalar. Bir kurulumda yalnız biri varsa ölçülen sayı eksiktir. Bu ayrımın maliyeti de sayılabilir. Kurulum profilini yazmak, 12 kalemin her biri için kurulum aracının o kalemi hangi seçenekle ayarladığını bulmayı ister; bu bir kereye özgü bir iştir ve makine sınıfı başına yapılır. Denetim listesi ise her koşumda çalışır ve her yeni makinede aynı eksikleri yeniden bulur — bulmak ile kapatmak arasındaki farkı ölçen sayı, kırk makinede kırk kere tekrar edilen düzeltme sayısıdır. #### Aynı Kalem, İki Makine Sınıfı Tablodaki `riskli` işareti makine sınıfından bağımsız değildir. Ölçüm ağında iki sınıf vardır ve aynı kalem ikisinde farklı yere düşer. Şube sunucusunda `uzak-yonetim-hizmeti` bir gerekliliktir; kapatılamaz, yalnız daraltılır — bu durumda kalem `ilk` sınıfından çıkar ve sürekli yönetilen bir kaleme dönüşür. Saha dizüstü bilgisayarında ise hizmet hiç gerekmez ve gerçekten kapatılır. Tersine, `disk-sifrelemesi` dizüstü bilgisayarda kurulumun en önemli kalemidir çünkü cihaz fiziksel olarak kaybedilebilir; kilitli bir şube odasındaki sunucuda aynı kalemin açtığı 11 varlık başka bir sınırın da arkasındadır. Bu yüzden ölçüm makine sınıfı başına yapılır ve iki sayı ayrı tutulur: kalemin **kendi** açtığı varlık ve o varlıkların **başka hangi sınırların** arkasında olduğu. Tek bir kurumsal liste iki sınıfa birden uygulandığında, bir sınıfta gereksiz iş, ötekinde eksik kapatma üretir. #### Hiç Kapanmayan Kalem Dördüncü tablonun son satırı bir kalemi ayrı tutar: `donanim-hata-kanali`. Bu kalem kapatılamaz, yalnız yönetilir. Donanımda bulunan bir kusur bir yapılandırma seçeneği değildir; karşılığı bellenim ve işletim sistemi güncellemeleriyle gelen azaltmalardır. Güncellemelerin nasıl programlanacağı ayrı bir konudur ve bu kursta ölçülmez; burada sayılan şey yalnızca **kapatılamaz kalemin var olduğudur**. Bir kalemin bu sınıfa düşmesi ölçümü değiştirir. Denetim listesinde "kapalı" işareti bekleyen bir satır olarak durursa her denetimde eksik görünür ve sonunda görmezden gelinir. Ayrı bir sınıf olarak yazıldığında ise doğru soruyu sorar: bu kalem kapanmadığına göre, açtığı 1 varlık başka hangi sınırın arkasında duruyor. Sayının küçük olması burada anlamlıdır — kapatılamayan kalem küçük bir yüzey açıyorsa katmanlı savunma iş görür; büyük bir yüzey açıyorsa makinenin görevi değişmelidir. #### Özet - Temiz kurulum bir güvenlik kararı vermez: 20 yapılandırma kaleminin 17'si varsayılanda riskli durumda kalır, yalnız 3'ü güvenlidir. - Kalemler kapatma zamanına göre dörde ayrılır: 8 riskli kalem başlangıç sertleştirmesinde, 4'ü makine kullanımdayken kapanır, 4'ü yalnız yeniden kurulumla kapanır, 1'i hiç kapanmaz. - Kurulum anında belirlenen dört kalem sonradan bir ayar değişikliğiyle düzelmez; denetimin bulduğu eksik, ilgili makinelerin yeniden kurulması demektir. - Sıra tek başına ölçülebilir bir kazanç verir: ağa bağlanmadan önce sertleştirme yapıldığında penceredeki açık kalem 17'den 9'a, sürekli kalemler de kapatıldığında 5'e iner. - Pencere hiçbir sırada sıfırlanmaz; kalan 5 kalem kurulum anına ait olanlardır. Pencereyi kapatmanın tek yolu sertleştirmeyi kurulumun kendisine taşımaktır. - Kapatılamayan kalem ayrı bir sınıf olarak yazılır; denetim listesinde sürekli eksik görünen bir satır olarak tutulursa görmezden gelinir. #### Sonraki Adım Kurulum bittiğinde makinede bir izin düzeni kurulmuş olur: hesaplar, gruplar ve nesnelerin kimin neyine açık olduğu. Bu düzen, önceki derste aileler arasındaki farkın kaynağıydı ve bu derste sayılan 17 kalemin birkaçı doğrudan onu ayarlıyordu. Sonraki ders o düzenin içine iner ve konunun en ayrıntılı ölçümünü yapar: aynı erişim isteği kümesi iki ayrı izin modelinde koşturulur, kaç istekte farklı sonuç çıktığı sayılır ve her modelin hangi isteği **ifade edemediği** yazılır. ### Dosya İzinleri ve Sahiplik Source: https://academia.sh/tr/kurslar/bt-temelleri/dosya-izinleri-ve-sahiplik Aynı 70 erişim isteğinin iki izin modelinde koşturulması: izin bitleri modelinin gevşek ifadesinin 6 fazla izin, sıkı ifadesinin 6 fazla ret üretmesi, iki ifadenin birbirinden 12 istekte ayrılması, erişim denetim listesinin politikayı tam ifade etmesi ama girdi sırası değiştiğinde 6 isteğin sonucunun dönmesi ve sahipliğin iki modelin de dışında kalması. Önceki ders temiz kurulumun bıraktığı 17 riskli kalemi saydı ve birkaçının doğrudan izin düzenini ayarladığını belirtti. Kurulum bittiğinde makinede bir izin düzeni vardır: hesaplar, gruplar ve nesnelerin kimin neyine açık olduğu. Bu ders o düzenin içine iner. İzin bitlerinin mekaniği — üç sınıf, üç erişim türü, sekizlik gösterim, sınıf seçiminin dışlayıcılığı — Linux'a Giriş kursunda kurulmuştu ve burada tekrarlanmaz. Buradaki soru başkadır: **aynı politika iki ayrı izin modelinde ifade edildiğinde kaç istekte farklı sonuç çıkar ve hangi model hangi isteği hiç ifade edemez.** #### Ölçülen Şey Mekanik Değil, İfade Gücü Bir izin modeli iki işi birden yapar. Birincisi bir erişim isteğine yanıt vermektir; bu, mekaniktir ve öğrenilir. İkincisi, kurumun aklındaki politikayı **taşıyabilmektir**; bu, modelin ifade gücüdür ve sınırlıdır. İki iş karıştırıldığında ölçüm kaybolur. "İzinler doğru ayarlandı" cümlesi mekanik iştir. Karar taşıyan cümle şudur: bu politika bu modelde **tam olarak** ifade edilebiliyor mu, edilemiyorsa en yakın ifadenin bedeli kaç istektir ve bu bedel hangi yöne düşer — fazladan verilen izne mi, fazladan yapılan reddin engellediği meşru işe mi. #### Politika, İki Model ve 70 İstek Örnek, kurgu **bölgesel ölçüm ağı**nın şube sunucusundaki beş dosyasıdır. Özneler, dosyalar ve politika kurgudur; aşağıdaki değerlendirme bir **modeldir**, gerçek bir sistem ya da ürün yoktur. **DI17:** yedi özne, beş nesne ve iki işlem 70 istek üretir; `niyet`, politikanın istediği sonuçtur. **DI18:** izin bitleri modeli üç sınıf taşır ve sınıf seçimi dışlayıcıdır. **DI19:** her nesne için grup, **sapması en az olan** grup seçilir; modele en iyi şans verilir. **DI20:** iki ifade stratejisi denenir — `gevsek`, diğerleri sınıfına dışarıdaki ihtiyaçların birleşimini verir; `siki`, diğerleri sınıfını boş bırakır. **DI21:** erişim denetim listesi modelinde ilk eşleşen girdi karar verir; liste yazıldığı sırayla ve ters sırayla değerlendirilir. **DI22:** sapma iki yönlü sayılır — fazla izin ve fazla ret ayrı sütunlardır. ```js // bt/izin.mjs — ayni erisim istegi kumesinin iki izin modelindeki sonucu (model): kurgu olcum // aginin dosyalari, gercek bir sistem ya da urun yok. Rastgelelik yok. export const OZNE = { "saha-teknisyeni": "saha", "sube-yoneticisi": "sube", "toplayici-servis": "servis", "faturalama-servisi": "servis", "veri-analisti": "analiz", "denetci": "denetim", "misafir-cihaz": "misafir" }; export const GRUP = [...new Set(Object.values(OZNE))]; export const ISLEM = ["r", "w"]; // niyet: politikanin istedigi erisim. acl: yoneticinin yazdigi liste (ret girdileri once). export const NESNE = [ { ad: "okuma-ham", sahip: "toplayici-servis", niyet: { "toplayici-servis": "rw", "saha-teknisyeni": "r", "sube-yoneticisi": "r", "veri-analisti": "r", "denetci": "r" }, acl: [["ret", "faturalama-servisi", "rw"], ["izin", "servis", "rw"], ["izin", "saha", "r"], ["izin", "sube", "r"], ["izin", "analiz", "r"], ["izin", "denetim", "r"]] }, { ad: "okuma-dogrulanmis", sahip: "veri-analisti", niyet: { "veri-analisti": "rw", "faturalama-servisi": "r", "sube-yoneticisi": "r", "denetci": "r" }, acl: [["ret", "toplayici-servis", "rw"], ["izin", "servis", "r"], ["izin", "analiz", "rw"], ["izin", "sube", "r"], ["izin", "denetim", "r"]] }, { ad: "fatura-taslak", sahip: "faturalama-servisi", niyet: { "faturalama-servisi": "rw", "sube-yoneticisi": "r", "denetci": "r" }, acl: [["ret", "toplayici-servis", "rw"], ["izin", "servis", "rw"], ["izin", "sube", "r"], ["izin", "denetim", "r"]] }, { ad: "anahtar-dosyasi", sahip: "toplayici-servis", niyet: { "toplayici-servis": "r" }, acl: [["ret", "faturalama-servisi", "rw"], ["izin", "servis", "r"]] }, { ad: "denetim-gunlugu", sahip: "denetci", niyet: { "denetci": "r", "toplayici-servis": "w", "faturalama-servisi": "w" }, acl: [["izin", "servis", "w"], ["izin", "denetim", "r"]] }, ]; export const ISTEK = Object.keys(OZNE).flatMap((o) => NESNE.flatMap((n) => ISLEM.map((i) => ({ o, n, i })))); export const niyet = (n, o, i) => (n.niyet[o] || "").includes(i); // Izin bitleri modeli: uc sinif, sinif secimi dislayicidir (M03/K01'de kurulmustur). const birlestir = (n, kim) => kim.filter((o) => o !== n.sahip) .map((o) => n.niyet[o] || "").join(""); export function bitler(n, grup, gevsek) { const uye = Object.keys(OZNE).filter((o) => OZNE[o] === grup); const dis = Object.keys(OZNE).filter((o) => OZNE[o] !== grup && o !== n.sahip); return { grup, sahip: n.niyet[n.sahip] || "", g: birlestir(n, uye), d: gevsek ? birlestir(n, dis) : "" }; } export const bitSonuc = (b, n, o, i) => (o === n.sahip ? b.sahip : OZNE[o] === b.grup ? b.g : b.d).includes(i); // En iyi grup secimi: sapmasi en az olan grup. Sapma = fazla izin + fazla ret. export function enIyi(n, gevsek) { return GRUP.map((g) => bitler(n, g, gevsek)) .map((b) => ({ b, ...sapma((o, i) => bitSonuc(b, n, o, i), [n]) })) .reduce((a, x) => (x.fazlaIzin + x.fazlaRet < a.fazlaIzin + a.fazlaRet ? x : a)); } // Erisim denetim listesi modeli: ilk eslesen girdi karar verir. export const aclSonuc = (n, o, i, tersSira) => { const l = tersSira ? [...n.acl].reverse() : n.acl; const g = l.find(([, kim, ops]) => (kim === o || kim === OZNE[o]) && ops.includes(i)); return g ? g[0] === "izin" : false; }; export function sapma(f, nesneler = NESNE) { const k = ISTEK.filter((x) => nesneler.includes(x.n)); return { fazlaIzin: k.filter((x) => f(x.o, x.i, x.n) && !niyet(x.n, x.o, x.i)).length, fazlaRet: k.filter((x) => !f(x.o, x.i, x.n) && niyet(x.n, x.o, x.i)).length }; } ``` ```js // bt/izinolc.mjs — ayni istek kumesi iki izin modelinde: kac istekte fark, kac istek ifade edilemiyor. import { OZNE, NESNE, ISTEK, niyet, bitSonuc, enIyi, aclSonuc, sapma } from "./izin.mjs"; const yaz = (g, ...s) => console.log(s.map((v, i) => (g[i] < 0 ? String(v).padEnd(-g[i]) : String(v).padStart(g[i]))).join("")); const B = { gevsek: {}, siki: {} }; for (const n of NESNE) for (const s of ["gevsek", "siki"]) B[s][n.ad] = enIyi(n, s === "gevsek").b; const bitF = (s) => (o, i, n) => bitSonuc(B[s][n.ad], n, o, i); const MODEL = [["izin-bitleri (gevsek)", bitF("gevsek")], ["izin-bitleri (siki)", bitF("siki")], ["erisim-listesi (ret once)", (o, i, n) => aclSonuc(n, o, i, false)], ["erisim-listesi (izin once)", (o, i, n) => aclSonuc(n, o, i, true)]]; const izinli = ISTEK.filter((x) => niyet(x.n, x.o, x.i)).length; console.log(`${Object.keys(OZNE).length} ozne x ${NESNE.length} nesne x 2 islem = ` + `${ISTEK.length} istek; niyette izinli olan ${izinli}, reddedilen ${ISTEK.length - izinli}`); const A = [-28, 12, 11, 14]; console.log("\n1. her model niyetten ne kadar sapiyor"); yaz(A, "model", "fazla izin", "fazla ret", "niyetle ayni"); for (const [ad, f] of MODEL) { const s = sapma(f); yaz(A, ad, s.fazlaIzin, s.fazlaRet, ISTEK.length - s.fazlaIzin - s.fazlaRet); } const C = [-20, -14, -12, 12, 11]; console.log("\n2. izin bitleri modelinde nesne basina artik (en iyi grup secimiyle)"); yaz(C, "nesne", "gevsek grup", "siki grup", "fazla izin", "fazla ret"); for (const n of NESNE) { const g = enIyi(n, true); const s = enIyi(n, false); yaz(C, n.ad, g.b.grup, s.b.grup, g.fazlaIzin, s.fazlaRet); } const D = [-56, 10]; console.log("\n3. modeller arasi fark (kac istekte sonuc farkli)"); yaz(D, "cift", "farkli"); for (let x = 0; x < MODEL.length; x++) for (let y = x + 1; y < MODEL.length; y++) yaz(D, `${MODEL[x][0]} / ${MODEL[y][0]}`, ISTEK.filter((r) => MODEL[x][1](r.o, r.i, r.n) !== MODEL[y][1](r.o, r.i, r.n)).length); const E = [-24, 14, 14]; console.log("\n4. fazladan erisim kime gidiyor"); yaz(E, "ozne", "gevsek bitler", "izin once acl"); for (const o of Object.keys(OZNE)) { const f = (g) => ISTEK.filter((x) => x.o === o && g(x.o, x.i, x.n) && !niyet(x.n, x.o, x.i)).length; const a = f(bitF("gevsek")); const b = f((oz, i, n) => aclSonuc(n, oz, i, true)); if (a || b) yaz(E, o, a, b); } ``` ``` 7 ozne x 5 nesne x 2 islem = 70 istek; niyette izinli olan 19, reddedilen 51 1. her model niyetten ne kadar sapiyor model fazla izin fazla ret niyetle ayni izin-bitleri (gevsek) 6 0 64 izin-bitleri (siki) 0 6 64 erisim-listesi (ret once) 0 0 70 erisim-listesi (izin once) 6 0 64 2. izin bitleri modelinde nesne basina artik (en iyi grup secimiyle) nesne gevsek grup siki grup fazla izin fazla ret okuma-ham servis saha 1 3 okuma-dogrulanmis saha sube 2 2 fatura-taslak saha sube 3 1 anahtar-dosyasi saha saha 0 0 denetim-gunlugu servis servis 0 0 3. modeller arasi fark (kac istekte sonuc farkli) cift farkli izin-bitleri (gevsek) / izin-bitleri (siki) 12 izin-bitleri (gevsek) / erisim-listesi (ret once) 6 izin-bitleri (gevsek) / erisim-listesi (izin once) 8 izin-bitleri (siki) / erisim-listesi (ret once) 6 izin-bitleri (siki) / erisim-listesi (izin once) 12 erisim-listesi (ret once) / erisim-listesi (izin once) 6 4. fazladan erisim kime gidiyor ozne gevsek bitler izin once acl toplayici-servis 2 3 faturalama-servisi 0 3 veri-analisti 1 0 misafir-cihaz 3 0 ``` Sayılar **ölçüm** sınıfındadır; girdileri DI17–DI22'dir. #### İzin Bitleri Neyi İfade Edemiyor Birinci tablonun ilk iki satırı bu dersin ana bulgusudur. İzin bitleri modeli 70 isteğin 64'ünü niyetle aynı sonuçlandırır; kalan 6 istek her iki stratejide de yanlıştır. Yön farklıdır: gevşek ifade **6 fazla izin**, sıkı ifade **6 fazla ret** üretir. Sıfır olmaması bir ayar hatası değildir. Kod her nesne için beş grubu da dener ve sapması en az olanı seçer; modele en iyi şans verilmiştir. Kalan artık, modelin **yapısından** gelir: üç sınıf vardır ve bir özneye ancak bu üç sınıftan biri üzerinden ulaşılabilir. Politikanın istediği ayrım üç sınıfa sığmıyorsa — dört ayrı grupta okuyucu varsa ve bir özne dışarıda tutulacaksa — geriye yalnızca yaklaşık ifade kalır. İkinci tablo artığın nerede biriktiğini gösterir. `anahtar-dosyasi` ve `denetim-gunlugu` iki stratejide de sıfır artık verir; ikisinde de erişim kümesi tek bir sahip ile tek bir grubun içine düşer. `fatura-taslak` gevşek ifadede 3 fazla izin üretir, çünkü iki farklı gruptaki iki okuyucuyu kapsamanın tek yolu diğerleri sınıfını açmaktır ve o sınıfta üç özne daha vardır. Dördüncü tablo bedelin kime gittiğini yazar. Gevşek ifadede fazladan erişim alan öznelerden biri `misafir-cihaz`'dır ve **3 istek** kazanır. Bu özne politikada hiçbir nesneye erişmez; modelde onu dışarıda tutacak bir yer yoktur, çünkü "diğerleri" sınıfı herkesi kapsar. **İzin bitleri modelinin ifade edemediği şey bir izin değil, bir istisnadır.** #### Yaklaşımın Yönü Seçilir, Varlığı Seçilmez Üçüncü tablonun ilk satırı iki stratejiyi karşılaştırır: gevşek ve sıkı ifadeler birbirinden **12 istekte** ayrılır. Toplam sapma her ikisinde de 6 olduğu hâlde ayrıştıkları istek sayısı iki katıdır, çünkü sapmalar farklı isteklerdedir ve zıt yönlüdür. Bu, yaklaşık ifadenin yönetilebilir kısmıdır. Model tam ifade edemiyorsa yönetici bir yön seçer. Gevşek yön işleri durdurmaz ama 6 istekte politika dışı erişim açar. Sıkı yön hiçbir fazladan erişim vermez ama 6 meşru isteği reddeder; ölçüm ağında bu, denetçinin fatura taslağını okuyamaması ve şube yöneticisinin ham okumaya erişememesi demektir. Seçilemeyecek olan şey **sapmanın kendisidir**. Toplam sapma iki yönde de 6'dır; hangi stratejinin seçildiği yalnızca bedelin nereye yazılacağını belirler. Bir izin modeli seçilirken sorulacak soru "hangisi daha güvenli" değil, "politikam bu modelde kaç istekte ifade edilemiyor ve o isteklerin bedelini hangi yöne yazabilirim" sorusudur. #### Erişim Denetim Listesi Ne Getiriyor, Ne Getirmiyor Birinci tablonun üçüncü satırı sıfırdır: erişim denetim listesi modeli, ret girdileri önce değerlendirildiğinde 70 isteğin 70'ini niyetle aynı sonuçlandırır. Özne başına girdi yazılabildiği için üç sınıf sınırı ortadan kalkar ve `misafir-cihaz` sorunu doğmaz. Dördüncü satır ise bedeli gösterir. Aynı liste, girdiler ters sırada değerlendirildiğinde **6 fazla izin** üretir. Üçüncü tablonun son satırı bunu doğrudan yazar: iki sıralama birbirinden 6 istekte ayrılır. Bu 6 istek, grup düzeyinde verilen bir iznin öznesi olan ama bireysel bir ret girdisiyle dışarıda tutulması gereken öznelere aittir — `toplayici-servis` ve `faturalama-servisi`, dördüncü tabloda 3'er istek kazanırlar. Buradaki fark bir yazım hatası değil, modelin ikinci ekseninin **sıra** olmasıdır. İzin bitleri modelinde bir nesnenin izin durumu tek bir değerdir ve okunduğunda sonucu belirler; erişim denetim listesinde aynı politika farklı sıralarla yazılabilir ve iki liste aynı girdileri taşıdığı hâlde farklı sonuç verir. **İfade gücü arttıkça sonucun okunması zorlaşır:** bir listenin doğruluğu girdilerine bakılarak değil, ancak istek kümesi üzerinde koşturularak anlaşılır. Sınırın yetmediği ikinci yer budur. Sıfır sapma, listenin doğru yazıldığı **ve** doğru sırada değerlendirildiği varsayımına dayanır; bu iki koşuldan biri kaybolduğunda model, izin bitleri modelinin gevşek ifadesiyle aynı sayıya — 6 fazla izne — düşer. #### İkisinin de Dışında: Sahiplik Her iki modelde de ölçülmeyen bir kalem vardır. Nesnenin **sahipliği**, izin kararlarının içinde değil, üstündedir: sahip, bitleri de listeyi de değiştirebilir. Modelde `denetim-gunlugu` dosyasının sahibi `denetci`'dir ve politika denetçiye yalnız okuma verir — ama sahip olduğu için kendine yazma verebilir. Bu, kursun ölçüsüyle yazıldığında nettir. Bir nesnenin izin sınırını geçmek için gereken kalem, o nesnede politika ne derse desin, **1'dir**: sahipliğin ele geçmesi. Sınır düştüğünde erişilen kalem ise o nesnenin bütün izin kararlarıdır. Bu yüzden sahiplik bir izin satırı gibi denetlenmez; ayrı sayılır. Ölçüm ağının beş dosyasında sahiplik dört ayrı özneye dağıtılmıştır ve bu dağılım, tek bir öznenin ele geçmesinin kaç dosyanın izin düzenini açtığını belirler. Sahipliğin ayrı sayılması ölçümün üçüncü sütununu da düzeltir. İlk iki sütun — sapma sayısı ve sapmanın yönü — modelin ifade gücünü ölçer; üçüncü sütun, o ifadenin ne kadar süreyle geçerli kaldığını ölçer. Sahipliği bir öznede toplanan bir dosya kümesinde politika, o özne ele geçtiği anda geçersizdir ve sapma sayısı anlamını yitirir. #### Özet - İzin bitleri modeli 70 isteğin 6'sını ifade edemez; gevşek ifade 6 fazla izin, sıkı ifade 6 fazla ret üretir. Artık, grup seçiminden değil, üç sınıflı yapıdan gelir. - Modelin ifade edemediği şey bir izin değil bir istisnadır: politikada hiçbir erişimi olmayan `misafir-cihaz`, gevşek ifadede 3 istek kazanır çünkü "diğerleri" sınıfı herkesi kapsar. - İki strateji birbirinden 12 istekte ayrılır. Sapmanın varlığı seçilemez, yalnız yönü seçilir: fazladan açılan erişim ile durdurulan meşru iş arasında. - Erişim denetim listesi modeli aynı politikayı 70 istekte tam ifade eder, ama ikinci bir eksen getirir: girdiler ters sırada değerlendirildiğinde 6 istek fazla izne döner. - İfade gücü arttıkça doğruluk okunamaz hâle gelir; bir listenin doğruluğu girdilerine bakılarak değil, istek kümesi üzerinde koşturularak anlaşılır. - Sahiplik iki modelin de dışındadır: izin sınırını geçmek için gereken kalem, politika ne derse desin 1'dir ve sınır düştüğünde o nesnenin bütün izin kararları açılır. #### Sonraki Adım İzin düzeni artık ölçülü: hangi modelin neyi ifade edebildiği ve edemediği sayıyla yazılı. Ancak bütün bu ölçüm, izinlerin **kim tarafından ve nasıl** değiştirildiğini hiç sormadı. Bir izin satırının değişmesi bir olaydır ve o olayın geriye bıraktığı iz, izin satırının kendisi kadar önemlidir. Sonraki ders aynı işi iki yönetim biçiminde yapar — grafik arayüzle ve komut satırıyla — ve her birinin bıraktığı iz kalemini sayar: kaç kayıt düşüyor, kaçı yeniden üretilebiliyor, kaçı denetim izinde hiç görünmüyor. ### Grafik Arayüz ve Komut Satırı Source: https://academia.sh/tr/kurslar/bt-temelleri/grafik-arayuz-ve-komut-satiri Aynı on yönetim işinin iki yönetim biçiminde bıraktığı izin sayılması: grafik arayüz ile komut satırının denetim izinde görünen kalem sayısının 11'de eşitlenmesi, üç işin her iki biçimde de hiç iz bırakmaması, yeniden üretilebilen iş sayısının 0'dan 10'a çıkması için betik ve deponun gerekmesi ve kırk makinede elle yapılan işlemin 400'den 10'a inmesi. Önceki ders izin modellerinin ifade gücünü ölçtü ve bir soruyu açıkta bıraktı: bir izin satırının **değişmesi** de bir olaydır. Sahiplik ele geçtiğinde ya da bir yönetici bir kuralı değiştirdiğinde politika değişir; o değişikliğin geriye ne bıraktığı, izin satırının kendisi kadar ölçülebilir bir şeydir. Bu ders aynı yönetim işlerini iki biçimde yapar — grafik arayüzle ve komut satırıyla — ve her birinin bıraktığı iz kalemini sayar. #### İz Bir Sayıdır Bir yönetim işi bittiğinde geride kalan şeyler üç ayrı ölçüyle yazılır. **Kaç kayıt düşüyor.** İşin sonunda kaç ayrı yerde bir iz oluşuyor: alt sistemin kendi kaydı, arayüzün kendi kaydı, kabuk geçmişi, betik dosyası, bir depo işlemesi, bir değişiklik bileti. **Kaçı denetim izinde görünüyor.** Kayıtların hepsi eşit değildir. Bir kayıt, işi yapan kişi tarafından silinebiliyorsa denetim izi sayılmaz. Kabuk geçmişi kullanıcının kendi dosyasıdır; arayüzün yerel kaydı döner ve saklanmaz. **Kalıcı olmayan kayıt bir iz değil, bir hatırlatmadır.** **Kaçı yeniden üretilebiliyor.** Bir kayıt, değişikliğin ne olduğunu tam olarak taşıyorsa aynı değişiklik başka bir makinede birebir tekrarlanabilir ya da geri alınabilir. Bir kaydın "kullanıcı eklendi" demesi ile eklemenin tanımını taşıması aynı şey değildir. #### On İş, Üç Biçim Örnek, kurgu **bölgesel ölçüm ağı**nın şube sunucularında yapılan on yönetim işidir. İşler de kayıt düzeni de kurgudur; aşağıdaki tablo bir **modeldir**, gerçek bir arayüz, kabuk ya da ürün yoktur. **DI23:** yönetim işi kümesi 10'dur ve her iş üç biçimde yapılabilir. **DI24:** kayıt türü 6'dır; `kalici` alanı kaydın işi yapan tarafından silinemediğini ve denetim izinde göründüğünü, `uretir` alanı kaydın değişikliği yeniden üretmeye yettiğini söyler. **DI25:** sistem kaydı ve değişiklik bileti **biçimden bağımsızdır** — işi yapan alt sistem kendi kaydını tutuyorsa üç biçimde de tutar. **DI26:** biçim yalnız kendi ek kayıtlarını ekler. **DI27:** aynı iş kırk makinede tekrarlanır; betik ve depo biçiminde tanım bir kez yazılıp kırk kez koşturulur. ```js // bt/iz.mjs — ayni yonetim isinin iki bicimde biraktigi iz (model): kurgu olcum agi, gercek bir // arayuz, kabuk ya da urun yok. Rastgelelik yok. // Kayit turleri. kalici: kullanici tarafindan silinemez, denetim izinde gorunur. // uretir: kaydin kendisi degisikligi yeniden uretmeye yeter. export const TUR = { "sistem-kaydi": { kalici: true, uretir: false }, "degisiklik-bileti": { kalici: true, uretir: false }, "arayuz-kaydi": { kalici: false, uretir: false }, "kabuk-gecmisi": { kalici: false, uretir: false }, "betik-dosyasi": { kalici: false, uretir: true }, "depo-islemesi": { kalici: true, uretir: true }, }; // Bicimin her ise ekledigi kayitlar. Sistem kaydi ve bilet bicimden bagimsizdir. export const BICIM = { grafik: ["arayuz-kaydi"], komut: ["kabuk-gecmisi"], "betik-depo": ["kabuk-gecmisi", "betik-dosyasi", "depo-islemesi"] }; // sis: isi yapan alt sistem kendi kaydini tutuyor mu. bil: is degisiklik biletine bagli mi. export const IS = ` kullanici-ekleme var var izin-degistirme yok var hizmet-kapatma var var guvenlik-duvari-kurali var var disk-birimi-takma yok yok yazilim-kurma var var saat-ayari var yok sertifika-kurma yok yok yedek-alma var yok gunluk-inceleme yok yok` .trim().split("\n").map((r) => { const [ad, sis, bil] = r.trim().split(/\s+/); return { ad, sis: sis === "var", bil: bil === "var" }; }); export const kayitlar = (is, bicim) => [...(is.sis ? ["sistem-kaydi"] : []), ...(is.bil ? ["degisiklik-bileti"] : []), ...BICIM[bicim]]; export function olc(bicim) { const k = IS.map((is) => kayitlar(is, bicim)); const kalici = k.map((x) => x.filter((t) => TUR[t].kalici).length); return { kayit: k.reduce((a, x) => a + x.length, 0), denetimde: kalici.reduce((a, x) => a + x, 0), gorunmeyen: k.reduce((a, x) => a + x.filter((t) => !TUR[t].kalici).length, 0), izsiz: kalici.filter((x) => x === 0).length, uretilebilir: k.filter((x) => x.some((t) => TUR[t].uretir && TUR[t].kalici)).length }; } ``` ```js // bt/izolc.mjs — kac kayit dusuyor, kaci denetim izinde gorunuyor, kaci yeniden uretilebiliyor. import { TUR, BICIM, IS, kayitlar, olc } from "./iz.mjs"; const yaz = (g, ...s) => console.log(s.map((v, i) => (g[i] < 0 ? String(v).padEnd(-g[i]) : String(v).padStart(g[i]))).join("")); const B = Object.keys(BICIM); const MAKINE = 40; console.log(`${IS.length} yonetim isi x ${B.length} bicim; kayit turu ${Object.keys(TUR).length}: ` + Object.entries(TUR).map(([t, v]) => `${t}${v.kalici ? " (kalici)" : ""}`).join(", ")); const A = [-24, -8, -8, 10, 10, 12]; console.log("\n1. is basina dusen kayit kalemi (parantez: denetim izinde gorunen)"); yaz(A, "is", "sistem", "bilet", ...B); for (const is of IS) { const h = (b) => { const k = kayitlar(is, b); return `${k.length} (${k.filter((t) => TUR[t].kalici).length})`; }; yaz(A, is.ad, is.sis ? "var" : "yok", is.bil ? "var" : "yok", ...B.map(h)); } const C = [-40, 10, 10, 12]; console.log("\n2. bicim basina toplam"); yaz(C, "olcu", ...B); const R = Object.fromEntries(B.map((b) => [b, olc(b)])); for (const [ad, f] of [["dusen kayit kalemi", (r) => r.kayit], ["denetim izinde gorunen kalem", (r) => r.denetimde], ["denetim izinde gorunmeyen kalem", (r) => r.gorunmeyen], ["hic denetim izi birakmayan is", (r) => `${r.izsiz}/${IS.length}`], ["yeniden uretilebilen is", (r) => `${r.uretilebilir}/${IS.length}`]]) yaz(C, ad, ...B.map((b) => f(R[b]))); const D = [-40, 10, 10, 12]; console.log(`\n3. ayni is ${MAKINE} makinede tekrarlandiginda`); yaz(D, "olcu", ...B); for (const [ad, f] of [["elle yapilan islem", (b) => (b === "betik-depo" ? IS.length : IS.length * MAKINE)], ["degisiklik tanimini saklayan yer", (b) => (b === "betik-depo" ? 1 : 0)], ["denetim izinde gorunen kalem", (b) => R[b].denetimde * MAKINE]]) yaz(D, ad, ...B.map(f)); ``` ``` 10 yonetim isi x 3 bicim; kayit turu 6: sistem-kaydi (kalici), degisiklik-bileti (kalici), arayuz-kaydi, kabuk-gecmisi, betik-dosyasi, depo-islemesi (kalici) 1. is basina dusen kayit kalemi (parantez: denetim izinde gorunen) is sistem bilet grafik komut betik-depo kullanici-ekleme var var 3 (2) 3 (2) 5 (3) izin-degistirme yok var 2 (1) 2 (1) 4 (2) hizmet-kapatma var var 3 (2) 3 (2) 5 (3) guvenlik-duvari-kurali var var 3 (2) 3 (2) 5 (3) disk-birimi-takma yok yok 1 (0) 1 (0) 3 (1) yazilim-kurma var var 3 (2) 3 (2) 5 (3) saat-ayari var yok 2 (1) 2 (1) 4 (2) sertifika-kurma yok yok 1 (0) 1 (0) 3 (1) yedek-alma var yok 2 (1) 2 (1) 4 (2) gunluk-inceleme yok yok 1 (0) 1 (0) 3 (1) 2. bicim basina toplam olcu grafik komut betik-depo dusen kayit kalemi 21 21 41 denetim izinde gorunen kalem 11 11 21 denetim izinde gorunmeyen kalem 10 10 20 hic denetim izi birakmayan is 3/10 3/10 0/10 yeniden uretilebilen is 0/10 0/10 10/10 3. ayni is 40 makinede tekrarlandiginda olcu grafik komut betik-depo elle yapilan islem 400 400 10 degisiklik tanimini saklayan yer 0 0 1 denetim izinde gorunen kalem 440 440 840 ``` Sayılar **ölçüm** sınıfındadır; girdileri DI23–DI27'dir. #### İki Biçim Aynı İzi Bırakıyor İkinci tablonun ilk üç satırı beklenmedik bir eşitlik verir. Grafik arayüz ve komut satırı aynı on işte **aynı sayıları** üretir: 21 kayıt kalemi, bunların **11'i** denetim izinde görünür, 10'u görünmez. Dördüncü satır da aynıdır: her iki biçimde de **3 iş** hiçbir denetim izi bırakmaz. Nedeni birinci tablodadır. Denetim izinde görünen kalemler yalnız iki türden gelir: işi yapan alt sistemin kendi kaydı ve değişiklik bileti. İkisi de **biçimden bağımsızdır**. Bir işi grafik arayüzden yapmak, alt sistemin kayıt tutmadığı bir işi kayıtlı hâle getirmez; aynı işi komuttan yapmak da getirmez. Her iki biçimin eklediği kalem — arayüzün yerel kaydı ve kabuk geçmişi — kalıcı değildir. İkisi de işi yapan tarafından silinebilir ve ikisi de değişikliğin tanımını taşımaz. Bu yüzden ikisi de denetim izi sayılmaz; sütunlarda 10 olarak görünürler ve o 10, ölçüye hiçbir katkı yapmaz. **"Komut satırından yapıldı, kaydı vardır" cümlesi bir varsayımdır ve modelde yanlıştır.** Kabuk geçmişi kullanıcının ev dizinindeki bir dosyadır: kapatılabilir, silinebilir, düzenlenebilir. Bir denetim izi, izi bırakan kişinin denetiminde olmayan bir yerde durur. #### Fark Yeniden Üretilebilirlikte Beşinci satır iki biçimi ilk kez ayırır — ama ayırdığı şey grafik ile komut değil, **betiklenmiş ile betiklenmemiş** olandır. Yeniden üretilebilen iş sayısı grafik arayüzde 0/10, elle yazılan komutta da 0/10, betik ve depo biçiminde 10/10'dur. Elle yazılan bir komutun betikten farkı, tanımın hiçbir yerde durmamasıdır. Komut çalışır, sonucunu bırakır ve kendisi kaybolur. Kabuk geçmişi komut satırlarını tutar, ama geçmiş bir tanım değildir: sırası, bağlamı, hangi makinede koştuğu ve hangi denemenin başarısız olduğu orada yazmaz. Betik ve depo biçiminde iki kalem eklenir ve ikisi birlikte iş görür. Betik dosyası değişikliği yeniden üretir ama kendisi kalıcı değildir — diskte durur, değiştirilebilir. Depo işlemesi hem kalıcıdır hem de tanımı taşır. Ölçüm bu yüzden `uretir` ve `kalici` alanlarını birlikte arar: **yeniden üretilebilirlik, tanımın var olmasına değil, tanımın değiştirilemeyen bir yerde durmasına bağlıdır.** Aynı satır bir bedeli de gizler. Betik ve depo biçiminde düşen kayıt 41'e, görünmeyen kalem 20'ye çıkar. Görünmeyen kalemin iki katına çıkması bir kayıp değildir — eklenen kalemlerin karşılığı zaten depo işlemesindedir — ama bakılacak yer sayısını artırır. Bir olayda üç ayrı kayıt kümesi karşılaştırılır ve bu karşılaştırmanın kendisi bir iştir. #### Üç İş Hiçbir İz Bırakmıyor Dördüncü satırdaki **3/10** iki biçimde de aynıdır ve ölçümün en doğrudan çıktısıdır. Disk birimi takma, sertifika kurma ve günlük inceleme işlerinin arkasında ne alt sistem kaydı ne de değişiklik bileti vardır; bu üç iş yapıldığında geriye yalnız silinebilir bir kalem kalır. Bu üç işin ortak yanı, ikisinin bir yapılandırma değişikliği gibi görünmemesidir. Günlük incelemek bir değişiklik değildir — ama hangi kayıtların kim tarafından okunduğu, bir olay incelemesinde sorulan sorulardan biridir. Sertifika kurmak bir dosya kopyalamaya benzer, oysa makinenin kime güveneceğini değiştirir. Betik ve depo biçiminde bu sayı 0/10'a iner, çünkü depo işlemesi biçime değil işe bağlıdır: alt sistem kayıt tutmasa da değişiklik bir yerde yazılıdır. **İz bırakmayan işin çözümü arayüzü değiştirmek değil, işi tanımlı bir değişiklik hâline getirmektir.** #### Kırk Makine Üçüncü tablo ölçeği ekler. On iş kırk şube sunucusunda tekrarlandığında elle yapılan işlem sayısı grafik ve komut biçimlerinde **400**, betik ve depo biçiminde **10**'dur; tanım bir kez yazılır, kırk kez koşturulur. Değişiklik tanımını saklayan yer sayısı 0, 0 ve 1'dir. Sıfırın anlamı, kırk makinenin birbirinden sapıp sapmadığının **karşılaştırılabilecek bir tanım olmamasıdır**; sapma ancak makineler tek tek okunarak bulunur. Bir tanım varsa sapma, tanım ile makine arasındaki fark olarak sorulur. Denetim izinde görünen kalem 440, 440 ve 840'a çıkar. Bu sayı büyüdükçe iyileşmez; okunması gereken kalem sayısıdır. Ölçünün üçüncü sütunu bu yüzden ham kayıt sayısı değil, **kayıt başına yanıtlanan soru sayısıdır**: 440 kalem "kim, ne zaman" sorusunu yanıtlar; 840 kalemin 400'ü ayrıca "tam olarak ne" sorusunu da yanıtlar. #### Kaydın Okunabilirliği Ayrı Bir Kalem Denetim izinde görünen kalem sayısı, o kalemlerin bir arada okunabildiğini varsayar. Kırk makinenin 440 kaydı ancak iki koşulda tek bir anlatıya dönüşür: kayıtların ortak bir zaman ekseni olması ve aynı işin farklı makinelerde aynı adla anılması. Birinci koşul önceki dersteki `saat-esitleme` kalemine bağlıdır. O kalem kapalıysa iki makinenin kaydı sıralanamaz ve "önce hangisi oldu" sorusu yanıtsız kalır; denetim izinde görünen kalem sayısı 440 olarak yazılmaya devam eder ama yanıtladığı soru sayısı düşer. İkinci koşul adlandırmayla ilgilidir: aynı iş bir makinede bir adla, ötekinde başka bir adla kaydedilmişse kalemler toplanamaz. Bu yüzden iz ölçümü iki sayıyla değil üçle yazılır: kaç kalem düşüyor, kaçı kalıcı ve kalıcı olanların kaçı **karşılaştırılabilir**. İlk iki sayı biçime ve alt sisteme, üçüncüsü kurulum kalemlerine bağlıdır. Üçüncü sayı ölçülmediğinde denetim izi bir kayıt yığınıdır. #### Biçim Seçimi İşin Tekrarına Bağlı Tablo, tek bir biçimi öteki üzerine koymaz. Sayılar üç durumu ayırır. **Bir kez yapılacak, tanımı henüz olmayan iş.** Bir sorunun nedeni aranırken hangi ayarın değiştirileceği önceden bilinmez; burada grafik arayüzün eksik izi bir bedel değildir, çünkü ortada tekrarlanacak bir tanım yoktur. Bu tür iş kırk makinede tekrarlanmaz. **Kırk makinede tekrarlanacak iş.** Üçüncü tablo bu durumda tek bir yön gösterir: 400 elle işlem ile 10 arasındaki fark, işlem sayısından çok **sapmanın ölçülebilirliğidir**. Tanımı olmayan kırk makinede sapma bulunamaz. **Denetime konu olan iş.** Burada belirleyici olan biçim değil, işin arkasında bir alt sistem kaydının bulunup bulunmadığıdır. Alt sistem kayıt tutmuyorsa hiçbir biçim bunu düzeltmez; işi tanımlı bir değişikliğe dönüştürmek gerekir. Üç durumun ortak dersi şudur: **biçim seçimi bir alışkanlık değil, işin tekrar sayısı ve denetim gereksinimiyle belirlenen bir karardır.** Ölçüm ağının on işinden kaçının hangi sınıfa düştüğü yazıldığında, hangi işin betiklenmesi gerektiği tartışma konusu olmaktan çıkar. #### Özet - Bir yönetim işinin izi üç sayıyla yazılır: düşen kayıt kalemi, bunların kaçının denetim izinde göründüğü ve kaç işin yeniden üretilebildiği. - Grafik arayüz ile komut satırı on işte aynı sayıları verir: 21 kayıt, 11 denetim izi kalemi, 3 iş hiç iz bırakmaz. Denetim izi biçimden değil, alt sistemin kayıt tutmasından ve değişiklik biletinden gelir. - Her iki biçimin kendi eklediği kalem kalıcı değildir; kabuk geçmişi işi yapanın silebildiği bir dosyadır ve bir denetim izi, izi bırakanın denetiminde olmayan yerde durur. - Yeniden üretilebilen iş sayısı 0/10, 0/10 ve 10/10'dur. Ayrım grafik ile komut arasında değil, betiklenmiş ile betiklenmemiş iş arasındadır; tanımın değiştirilemeyen bir yerde durması gerekir. - Kırk makinede elle yapılan işlem 400'den 10'a iner ve değişiklik tanımını saklayan yer 0'dan 1'e çıkar; sapma ancak karşılaştırılacak bir tanım varsa sorulabilir. - Denetim izinde görünen kalem sayısı, kalemlerin ortak bir zaman ekseninde ve ortak adlarla durduğunu varsayar; bu koşullar yoksa kalem sayısı değişmez ama yanıtladığı soru sayısı düşer. #### Sonraki Adım Bu konu boyunca ölçülen her şey bir düzenin nasıl kurulduğuyla ilgiliydi: hangi sınır nerede duruyor, hangi kalem ne zaman kapanıyor, hangi politika ifade edilebiliyor, hangi iş iz bırakıyor. Hepsi, makine beklendiği gibi çalışırken geçerlidir. Makine beklendiği gibi çalışmadığında ise elde yalnız belirtiler kalır ve bu derste sayılan kayıtlar o belirtilerin okunacağı yerdir. Sonraki ders bu duruma bakar ve yöntemi bir sayıya bağlar: bir belirti kümesinde hipotez başına kaç olasılık eleniyor, hangi sıra kaç adımda bitiriyor ve en kötü sıra kaç adım sürüyor. ### Sorun Giderme Yöntemi Source: https://academia.sh/tr/kurslar/bt-temelleri/sorun-giderme-yontemi Sorun gidermenin eleme sayısıyla ölçülmesi: 16 olasılık ve 8 test üzerinde bilgi öncelikli sıranın ortalama 3,50 adımda, liste sırasının 5,81 adımda bitirmesi, en kötü adımın 6'ya karşı 8 olması, hiçbir olasılığı elemeyen adımın 0'a karşı 22 çıkması ve iki nedenin hiçbir testle ayrılamaması. Önceki ders yönetim işlerinin bıraktığı izi saydı ve makine beklendiği gibi çalışırken geçerli olan bir düzenin ölçüsünü verdi. Makine beklendiği gibi çalışmadığında elde yalnız belirtiler kalır: bir servis veri alamıyor, bir istek yanıtsız dönüyor, bir iş gecikiyor. Belirtiden nedene giden yol bir yöntemdir ve yöntem ölçülebilir. Bu ders onu tek bir sayıya bağlar: bir hipotez sınandığında kaç olasılık eleniyor. #### Yöntem Bir Eleme Sayısıdır Sorun giderme, tahmin ile deneme arasında bir yerde anlatılır. Ölçülebilir hâle getirmek için üç şey yazılır. **Olasılık kümesi.** Belirti görüldüğünde hangi nedenler hâlâ mümkündür. Bu küme yazılmadığında "neden arıyorum" cümlesi bir sayı taşımaz. **Test kümesi.** Her test bir hipotezi sınar ve bir sonuç verir. Bir testin gücü, sonucun kaç olasılığı elediğidir — ve bu sayı **kötü durumda** okunur, çünkü hangi sonucun çıkacağı önceden bilinmez. **Sıra.** Testler bir sırayla koşturulur. Aynı test kümesi farklı sıralarla farklı sayıda adımda bitirir; sıra, ek bir araç almadan kazanılan tek şeydir. #### On Altı Olasılık, Sekiz Test Örnek, kurgu **bölgesel ölçüm ağı**nda bir belirtidir: şube sunucusundan faturalama servisine veri gitmiyor. Belirti de neden listesi de kurgudur; aşağıdaki değerlendirme bir **modeldir**, gerçek bir olay kaydı yoktur. **DI28:** belirti görüldüğünde 16 neden mümkündür. **DI29:** 8 test vardır; her test her neden için tek bir sonuç verir ve **aynı sonucu veren nedenler o testle birbirinden ayrılmaz**. **DI30:** bir test koşturulduğunda aday kümesi, doğru nedenle aynı sonucu veren nedenlere daralır. **DI31:** üç sıra denenir — `bilgi` kötü durumda en çok eleyen testi seçer, `liste` testleri yazıldıkları sırayla koşturur, `zayif` kötü durumda en az eleyen testi öne alır. **DI32:** koşum, aday kümesi tek nedene indiğinde ya da hiçbir test kümeyi daha fazla ayıramadığında durur. ```js // bt/tani.mjs — bir belirti kumesinde hipotez basina elenen olasilik (model): kurgu olcum agi, // gercek bir olay kaydi yok. Rastgelelik yok. // Belirti: sube sunucusundan faturalama servisine veri gitmiyor. Baslangicta 16 olasilik. export const NEDEN = ["ag-kablosu", "anahtar-uc-durumu", "adres-catismasi", "ad-cozumleme", "guvenlik-duvari-kurali", "yonlendirme-tablosu", "hizmet-durmus", "hizmet-yanlis-ucta", "sertifika-suresi", "kimlik-bilgisi", "izin-degisikligi", "disk-dolu", "bellek-tukendi", "saat-kaymasi", "surum-uyumsuzlugu", "yapilandirma-hatasi"]; // Her test bir hipotezi sinar. Dizideki her karakter, o nedenin testte verecegi sonuctur; // ayni karakteri veren nedenler o testle birbirinden ayrilamaz. export const TEST = [ ["ag-baglantisi", "hheeeeeeeeeeeeee"], ["adres-ve-yonlendirme", "eeceeyeeeeeeeeee"], ["ad-cozumleme", "eeeheeeeeeeeeeee"], ["uc-erisimi", "eeeehekkeeeeeeee"], ["hizmet-durumu", "eeeeeedyeeeeeeee"], ["kimlik-ve-sertifika", "eeeeeeeeskieeeee"], ["kaynak-durumu", "eeeeeeeeeeedbeee"], ["saat-surum-yapilandirma", "eeeeeeeeeeeeetsy"], ].map(([ad, s]) => ({ ad, s })); // Bir testin verilen aday kumesinde birakacagi en buyuk grup: kotu durumda kalan olasilik. export const enBuyuk = (t, aday) => Math.max(...[...new Set(aday.map((c) => t.s[c]))] .map((v) => aday.filter((c) => t.s[c] === v).length)); export const SIRA = { // bilgi-oncelikli: kotu durumda en cok eleyen test. Hicbiri elemiyorsa dur. bilgi: (aday, kul) => { const k = TEST.map((t, i) => i).filter((i) => !kul.has(i)); if (!k.length) return null; const e = k.reduce((a, i) => (enBuyuk(TEST[i], aday) < enBuyuk(TEST[a], aday) ? i : a)); return enBuyuk(TEST[e], aday) === aday.length ? null : e; }, // liste: testler yazildigi sirayla. liste: (aday, kul) => TEST.map((t, i) => i).find((i) => !kul.has(i)) ?? null, // zayif: kotu durumda en az eleyen testi one alan sira. zayif: (aday, kul) => { const k = TEST.map((t, i) => i).filter((i) => !kul.has(i)); if (!k.length) return null; return k.reduce((a, i) => (enBuyuk(TEST[i], aday) > enBuyuk(TEST[a], aday) ? i : a)); }, }; export function kos(dogru, sira) { let aday = NEDEN.map((n, i) => i); const kul = new Set(); let adim = 0, bos = 0; while (aday.length > 1) { const i = SIRA[sira](aday, kul); if (i === null) break; kul.add(i); const once = aday.length; aday = aday.filter((c) => TEST[i].s[c] === TEST[i].s[dogru]); adim++; if (aday.length === once) bos++; } return { adim, bos, kalan: aday.length }; } ``` ```js // bt/taniolc.mjs — hipotez basina kac olasilik eleniyor, hangi sira kac adimda bitiriyor. import { NEDEN, TEST, enBuyuk, SIRA, kos } from "./tani.mjs"; const yaz = (g, ...s) => console.log(s.map((v, i) => (g[i] < 0 ? String(v).padEnd(-g[i]) : String(v).padStart(g[i]))).join("")); const HEPSI = NEDEN.map((n, i) => i); const S = Object.keys(SIRA); if (TEST.some((t) => t.s.length !== NEDEN.length)) throw new Error("test uzunlugu uyusmuyor"); console.log(`belirti: sube sunucusundan veri gitmiyor; ${NEDEN.length} olasilik, ` + `${TEST.length} test`); const A = [-26, 13, 15, 16]; console.log("\n1. tek basina her testin gucu (16 olasilik uzerinde)"); yaz(A, "test", "sonuc turu", "kotu durumda", "en az elenen"); for (const t of TEST) { const b = enBuyuk(t, HEPSI); yaz(A, t.ad, new Set(t.s).size, b, NEDEN.length - b); } const B = [-38, 10, 10, 10]; console.log("\n2. uc sira, 16 nedenin her biri dogru neden olarak denendiginde"); const R = Object.fromEntries(S.map((s) => [s, HEPSI.map((c) => kos(c, s))])); yaz(B, "olcu", ...S); for (const [ad, f] of [["ortalama adim", (r) => (r.reduce((a, x) => a + x.adim, 0) / r.length).toFixed(2)], ["en kotu adim", (r) => Math.max(...r.map((x) => x.adim))], ["hicbir olasiligi elemeyen adim", (r) => r.reduce((a, x) => a + x.bos, 0)], ["tek nedene inen senaryo (16 uzerinden)", (r) => r.filter((x) => x.kalan === 1).length]]) yaz(B, ad, ...S.map((s) => f(R[s]))); const C = [-38, 10, 10, 10]; console.log("\n3. dort neden icin adim sayisi"); yaz(C, "dogru neden", ...S); for (const c of [0, 7, 10, 15]) yaz(C, NEDEN[c], ...S.map((s) => kos(c, s).adim)); const D = [-38, 10]; console.log("\n4. yontemin tabani"); const ayrilamaz = HEPSI.filter((c) => HEPSI .some((d) => d !== c && TEST.every((t) => t.s[c] === t.s[d]))); yaz(D, "olcu", "deger"); yaz(D, "hicbir testin ayiramadigi neden", ayrilamaz.length); yaz(D, "bilgi sirasinda ulasilan en kucuk kume", Math.min(...HEPSI.map((c) => kos(c, "bilgi").kalan))); yaz(D, "bilgi sirasinda kalan en buyuk kume", Math.max(...HEPSI.map((c) => kos(c, "bilgi").kalan))); console.log(`ayrilamayan nedenler: ${ayrilamaz.map((c) => NEDEN[c]).join(", ")}`); ``` ``` belirti: sube sunucusundan veri gitmiyor; 16 olasilik, 8 test 1. tek basina her testin gucu (16 olasilik uzerinde) test sonuc turu kotu durumda en az elenen ag-baglantisi 2 14 2 adres-ve-yonlendirme 3 14 2 ad-cozumleme 2 15 1 uc-erisimi 3 13 3 hizmet-durumu 3 14 2 kimlik-ve-sertifika 4 13 3 kaynak-durumu 3 14 2 saat-surum-yapilandirma 4 13 3 2. uc sira, 16 nedenin her biri dogru neden olarak denendiginde olcu bilgi liste zayif ortalama adim 3.50 5.81 5.81 en kotu adim 6 8 8 hicbir olasiligi elemeyen adim 0 22 12 tek nedene inen senaryo (16 uzerinden) 14 14 14 3. dort neden icin adim sayisi dogru neden bilgi liste zayif ag-kablosu 4 8 8 hizmet-yanlis-ucta 2 5 4 izin-degisikligi 2 6 7 yapilandirma-hatasi 3 8 8 4. yontemin tabani olcu deger hicbir testin ayiramadigi neden 2 bilgi sirasinda ulasilan en kucuk kume 1 bilgi sirasinda kalan en buyuk kume 2 ayrilamayan nedenler: ag-kablosu, anahtar-uc-durumu ``` Sayılar **ölçüm** sınıfındadır; girdileri DI28–DI32'dir. #### Testler Dengesiz, Bölme Yarı Yarıya Değil Birinci tablo bir beklentiyi yıkar. Sekiz testin hiçbiri olasılık kümesini ortadan bölmez: kötü durumda kalan olasılık 13 ile 15 arasındadır, yani en güçlü test bile 16'dan yalnız **3** olasılık eler. `ad-cozumleme` testinin kötü durumda elediği olasılık **1**'dir. Nedeni, testlerin sonuç türü sayısındadır. Bir test iki sonuç veriyorsa olasılıkları en fazla ikiye böler; dört sonuç veriyorsa dörde. Ama bölmenin **eşit** olması gerekmez ve bu modelde eşit değildir: her test birkaç nedeni ayırır, kalan on üç, on dört ya da on beşi aynı sonuçta bırakır. Bir sistemde testler doğal olarak dengesizdir, çünkü her test belirli bir katmanı sınar ve o katmanın dışındaki nedenler testin gözünde birbirinin aynıdır. Bunun pratik sonucu şudur: **kötü durumda en çok eleyen testi seçmek, ikiye bölmeyi bulmak değil, en az kötü bölmeyi bulmaktır.** 16 olasılığı ikili aramayla dört adımda bitirme beklentisi bu test kümesinde karşılanmaz. #### Sıra Ne Değiştiriyor İkinci tablo üç sırayı on altı nedenin her biri doğru neden alınarak koşturur. Bilgi öncelikli sıra ortalama **3,50** adımda bitirir; liste sırası ve zayıf sıra **5,81** adımda. En kötü adım bilgi öncelikli sırada **6**, ötekilerde **8**'dir — sekiz, test sayısının tamamıdır, yani bu iki sıra kötü durumda bütün testleri koşturur. Fark yaklaşık **kırk beş dakikalık bir olayda kırk beş dakikalık bir fark** demek değildir; adım başına maliyet testten teste değişir. Ama sayı yön verir: aynı test kümesi, aynı bilgi ve aynı araçlarla, yalnız sıra değiştirilerek ortalama adımın üçte birinden fazlası kazanılır. Üçüncü tablo bunun her nedende geçerli olmadığını gösterir. `hizmet-yanlis-ucta` nedeninde bilgi öncelikli sıra 2, zayıf sıra 4, liste sırası 5 adımdır. `izin-degisikligi` nedeninde ise zayıf sıra 7, liste sırası 6 adımdır — zayıf sıra liste sırasından **daha kötüdür**. `ag-kablosu` nedeninde liste ve zayıf sıraların ikisi de 8 adım koşar, bilgi öncelikli sıra 4. #### Sabit Sıra, Uyarlanan Kötü Sıradan Daha Çok Boş Adım Üretir İkinci tablonun üçüncü satırı dersin en beklenmedik sayısını verir. Hiçbir olasılığı elemeyen adım sayısı bilgi öncelikli sırada **0**, liste sırasında **22**, zayıf sırada **12**'dir. Zayıf sıra, kötü durumda en az eleyen testi bile bile öne alır; yine de liste sırasının yarısı kadar boş adım üretir. Nedeni, ikisi arasındaki gerçek farkın "iyi seçim / kötü seçim" değil, **uyarlanan / uyarlanmayan** olmasıdır. Zayıf sıra her adımda o anki aday kümesine bakar ve kümeyi hiç bölmeyen bir test kalmadıysa onu seçmez; liste sırası aday kümesine hiç bakmaz ve sırasıyla, zaten elenmiş bir katmanı sınayan testleri de koşturur. Boş adım, sorun gidermenin görünmeyen maliyetidir. Koşulur, zaman alır, bir sonuç üretir ve o sonuç aday kümesini değiştirmez — ama sonucun kendisi bir bilgi gibi görünür, çünkü "şu da normalmiş" cümlesi bir ilerleme duygusu verir. **Sayılması gereken şey koşulan test sayısı değil, elenen olasılık sayısıdır.** Liste sırasının 22 boş adımı, koşan ama hiçbir şey elemeyen 22 sınamadır. #### Eleme Sayısı Tek Ölçü Değil Model her nedeni eşit olası sayar ve testleri yalnız eleme güçlerine göre sıralar. Bir olayda iki şey daha vardır ve ikisi de bu tabloda yoktur. Birincisi **nedenlerin olasılığıdır**. On altı nedenin hepsi aynı sıklıkta görülmez; bir yapılandırma değişikliğinden hemen sonra ortaya çıkan bir belirtinin arkasında `yapilandirma-hatasi` bulunma olasılığı ötekilerden yüksektir. Eleme sayısı bunu görmez: en çok eleyen testi seçer, en olası nedeni sınayan testi değil. İkisi çakışmıyorsa seçim, beklenen adım sayısı ile en kötü adım sayısı arasında bir tercihtir. Belirtiyi hızla kapatmak beklenen sayıyı, kötü durumu sınırlamak en kötü sayıyı önemser. İkincisi **testin maliyetidir**. Modelde her adımın maliyeti eşittir; gerçekte bir test bir komutla saniyeler içinde, bir başkası saha ekibinin şubeye gitmesiyle saatler içinde biter. Üç olasılık eleyen pahalı bir test ile iki olasılık eleyen ucuz bir test arasındaki seçim, eleme sayısına bakılarak yapılamaz. `ag-kablosu` ile `anahtar-uc-durumu` ayrımının yeni bir gözlem istemesi tam olarak böyle bir kalemdir: ayrımın bedeli bir ziyarettir. Bu iki ekseni eklemek modeli değiştirmez, **okunmasını** değiştirir. Tablodaki 3,50 sayısı, adımların eşit maliyetli ve nedenlerin eşit olası olduğu durumda geçerlidir; bu iki varsayım yazılmadan sayı bir hedefe dönüştürülemez. Ölçümün değeri, hangi varsayımla üretildiği yazıldığında ortaya çıkar. #### Yöntemin Tabanı Dördüncü tablo yöntemin nerede durduğunu yazar. On altı nedenin **ikisi** hiçbir testle ayrılamaz: `ag-kablosu` ile `anahtar-uc-durumu`. İkisi de aynı testte aynı sonucu verir, çünkü sunucudan bakıldığında ikisinin belirtisi aynıdır. Bu yüzden üç sıranın da tek nedene indirdiği senaryo sayısı **14/16**'dır. Kalan iki senaryoda yöntem iki olasılıkla durur ve bu bir eksiklik değil, **test kümesinin çözünürlüğüdür**. Ayrımı yapmak yeni bir sıra değil, yeni bir test ister — bu modelde sunucunun dışından, bağlantının öteki ucundan yapılacak bir gözlem. Bunun bir karar karşılığı vardır. Bir sorun giderme yordamı yazılırken önce test kümesinin ayıramadığı neden çiftleri çıkarılır; o çiftler için ya yeni bir gözlem eklenir ya da ayrım yapılmadan uygulanabilecek tek bir düzeltme tanımlanır. Ölçüm ağında `ag-kablosu` ile `anahtar-uc-durumu` ayrımı yapılmadan da ilerlenebilir: iki neden de saha ekibinin aynı ziyaretinde görülür. **Ayırt edilemeyen iki neden, düzeltmeleri aynıysa bir sorun değildir.** #### Özet - Sorun giderme, hipotez başına elenen olasılık sayısıyla ölçülür; bu sayı kötü durumda okunur, çünkü hangi sonucun çıkacağı önceden bilinmez. - Testler dengesizdir: sekiz testin en güçlüsü 16 olasılıktan kötü durumda yalnız 3'ünü eler, en zayıfı 1'ini. İkiye bölme beklentisi gerçek test kümelerinde karşılanmaz. - Bilgi öncelikli sıra ortalama 3,50 adımda, liste ve zayıf sıra 5,81 adımda bitirir; en kötü adım 6'ya karşı 8'dir. Sıra, yeni bir araç almadan kazanılan tek şeydir. - Hiçbir olasılığı elemeyen adım sayısı 0, 22 ve 12'dir. Sabit liste sırası, bile bile zayıf seçim yapan uyarlanan sıradan iki kat fazla boş adım üretir; belirleyici olan seçimin iyiliği değil, aday kümesine bakılıp bakılmamasıdır. - Eleme sayısı tek ölçü değildir: nedenlerin olasılığı ve testlerin maliyeti tabloda yoktur. 3,50 sayısı, adımların eşit maliyetli ve nedenlerin eşit olası sayıldığı varsayımıyla geçerlidir. - İki neden hiçbir testle ayrılamaz; üç sıra da 16 senaryonun 14'ünü tek nedene indirir. Kalan ayrım yeni bir sıra değil yeni bir gözlem ister ve düzeltmeleri aynıysa ayrım gerekmeyebilir. #### Sonraki Adım Bu konu tek bir makinenin sınırlarını kalem kalem saydı. Donanımın çizdiği sekiz sınır ve ikisinin envanterin tamamını açması; işletim sistemi ailelerinin aynı istekte 4, 11 ve 12 kalemde ayrışması; temiz kurulumun bıraktığı 17 riskli kalem ve kapanmayan 5'i; iki izin modelinin 6 istekte ifade sınırına çarpması; iki yönetim biçiminin aynı 11 denetim izi kalemini bırakması; ve şimdi belirtiden nedene giden yolun 3,50 adıma inmesi. Makinenin sınırı artık bir sıfat değil, bir sayıdır. Bütün bu ölçümlerin sessiz bir varsayımı vardı: sayılan makine **kendi donanımının üzerinde koşuyor**. Bugün bu makinelerin çoğu için doğru değildir. Şube sunucusunun altında bir katman daha vardır ve o katmanın sınırı hiç ölçülmedi: hangi kalem konukla konak arasında paylaşılıyor, o sınırı geçmek kaç kalem istiyor ve sınır düştüğünde kaç kaleme erişiliyor. Sonraki konu **Sanallaştırma ve Yedeklilik** bu soruyla başlar. ## Sanallaştırma ve Yedeklilik Donanımın altına konan katmanın sınır olarak ölçülmesi: çıplak donanım ve barındırılan hipervizörün güvenilir taban büyüklüğü, konuk ile konağın paylaştığı kalem sayısı ve her paylaşılan kalemin açtığı yol, anlık görüntü zinciri ile klonun taşıdığı sır ve geri dönüşün yeniden açtığı açık, aynı yalıtım sorusunun konuk sistem ile konteynerde sınırı geçmek için gereken kalem cinsinden karşılaştırılması, anlık görüntü ile yedeğin aynı kayıp senaryosunda kurtardığı ve kurtaramadığı kalem. ### Hipervizör Türleri Source: https://academia.sh/tr/kurslar/bt-temelleri/hipervizor-turleri Hipervizörün çizdiği sınırın iki tasarımda sayılması: konuk ile donanım arasındaki katman sayısı, her katmanın güvenilir tabana eklediği kalem, bir katman düştüğünde erişilen kalem oranı ve aynı hedef kümesinde sınırı geçmek için gereken kalem ile o kalemin seçilebileceği aday sayısı. Önceki ders sorun gidermeyi hipotez başına elenen olasılık sayısına bağladı ve konuyu bir boşlukla kapattı: ölçülen bütün sınırlar **tek bir makinenin** sınırlarıydı. O makinenin donanımı kendisine aitti, çekirdeği doğrudan o donanımla konuşuyordu, kullanıcı ile çekirdek arasındaki sınır tek sınırdı. Bölgesel ölçüm ağının şube sunucularında bu artık doğru değil: bir şube sunucusunda dört ayrı konuk sistem koşuyor, dördü de aynı işlemciyi, aynı belleği ve aynı diski kullanıyor. İşletim sisteminin çizdiği sınırın **altında** ikinci bir sınır var ve onu çizen katmanın adı hipervizördür. Bu ders hipervizörü bir sıfatla değil, iki sayıyla ayırır. Birinci sayı konuk ile donanım arasında kaç katman durduğudur. İkinci sayı her katmanın **güvenilir tabana** kaç kalem eklediğidir — yani konuk sınırının ayakta kalması için doğru davranması gereken kalem sayısı. Bu iki sayı bir tasarımı öbürüne göre değil, kendi kalem kümesine göre konumlandırır. **SA1 — Ölçüm nesnesi kurgu bölgesel ölçüm ağının bir şube sunucusudur**; üzerinde dört konuk sistem koşar. Kalem sayıları modeldir, koşum ve aritmetik gerçektir. **SA2 — Hipervizör yalnız iki tür adıyla anılır: çıplak donanım hipervizörü ve barındırılan hipervizör.** **SA3 — Güvenilir taban, konuk sınırının ayakta kalması için doğru davranması gereken kalemlerin kümesidir.** **SA4 — Bir katmanın düşmesi, o katmandaki kalemlerden yalnız birinin yanlış davranmasıdır.** **SA5 — Sınırı geçmek için gereken kalem sayısı, aynı anda yanlış olması gereken katman sayısıdır**; her katmanda bir kalem yeter. **SA6 — Aday kalem, o katmanlarda yanlış olabilecek kalemlerin toplamıdır.** #### Katmanlar ve Güvenilir Taban Çıplak donanım hipervizörü donanımın üstüne doğrudan kurulur; altında genel amaçlı bir işletim sistemi yoktur. Barındırılan hipervizör bir işletim sisteminin üzerinde bir süreç olarak koşar ve konuk sistemler o sürecin içinde çalışır. Fark bir kurulum ayrıntısı değil, konuğun altındaki katman listesinin uzunluğudur. ```js // katman.mjs — konuk ile donanim arasindaki katmanlar ve guvenilir taban (MODEL). // Kurgu sube sunucusu: uzerinde dort konuk sistem kosuyor. Urun adi degil, tur adi kullanilir. // Sistemdeki kalem kumeleri: kisa anahtar -> [ad, kalem sayisi] export const KUME = { kd: ['konuk disk imaji', 4], kb: ['konuk bellek icerigi', 4], ka: ['konuk ag arayuzu', 4], hy: ['hipervizor ayar kalemi', 3], ku: ['konak kullanici alani dosyasi', 7], ba: ['bellenim ayari', 4], }; // [katman, guvenilir taban kalemi, konuk-donanim yolunda mi, dustugunde erisilen kumeler] export const TASARIM = { 'ciplak donanim hipervizoru': [ ['yonetim arayuzu', 3, false, ['kd', 'ka', 'hy']], ['hipervizor cekirdegi', 6, true, ['kd', 'kb', 'ka', 'hy']], ['bellenim ve acilis zinciri', 4, true, ['kd', 'kb', 'ka', 'hy', 'ba']], ], 'barindirilan hipervizor': [ ['konak kullanici alani', 7, false, ['kd', 'ka', 'hy', 'ku']], ['hipervizor sureci', 5, true, ['kd', 'kb', 'ka', 'hy', 'ku']], ['konak cekirdegi', 9, true, ['kd', 'kb', 'ka', 'hy', 'ku', 'ba']], ['bellenim ve acilis zinciri', 4, true, ['kd', 'kb', 'ka', 'hy', 'ku', 'ba']], ], }; export const say = (anahtarlar) => anahtarlar.reduce((t, a) => t + KUME[a][1], 0); // Tasarimin kapsadigi kalem evreni: katmanlarin erisebildigi butun kumeler export const evren = (ad) => say([...new Set(TASARIM[ad].flatMap(([, , , e]) => e))]); if (import.meta.url === `file://${process.argv[1]}`) { const s = (x, n) => String(x).padStart(n); for (const [ad, katmanlar] of Object.entries(TASARIM)) { const taban = katmanlar.reduce((t, [, k]) => t + k, 0); const yolda = katmanlar.filter(([, , y]) => y).length; const tum = evren(ad); console.log(`\n${ad}: guvenilir taban ${taban} kalem, yolda ${yolda} katman, evren ${tum} kalem`); console.log(`${'katman'.padEnd(28)}${s('kalem', 6)}${s('yolda', 7)}${s('duserse erisilen', 18)}`); for (const [k, n, y, e] of katmanlar) console.log(`${k.padEnd(28)}${s(n, 6)}${s(y ? 'evet' : 'hayir', 7)}${s(`${say(e)}/${tum}`, 18)}`); } } ``` ``` ciplak donanim hipervizoru: guvenilir taban 13 kalem, yolda 2 katman, evren 19 kalem katman kalem yolda duserse erisilen yonetim arayuzu 3 hayir 11/19 hipervizor cekirdegi 6 evet 15/19 bellenim ve acilis zinciri 4 evet 19/19 barindirilan hipervizor: guvenilir taban 25 kalem, yolda 3 katman, evren 26 kalem katman kalem yolda duserse erisilen konak kullanici alani 7 hayir 18/26 hipervizor sureci 5 evet 22/26 konak cekirdegi 9 evet 26/26 bellenim ve acilis zinciri 4 evet 26/26 ``` İki tasarımın katman sayısı beklendiği yönde ayrılıyor: çıplak tasarımda konuk ile donanım arasında **iki** katman var, barındırılan tasarımda **üç**. Bu sayıya bakıp barındırılan tasarımın daha derin korunduğu söylenebilir; ikinci sütun bunu bozuyor. Aynı üç katmanı taşımanın bedeli güvenilir tabanın on üç kalemden **yirmi beş** kaleme çıkmasıdır. Eklenen kalemlerin çoğu konuk için değil, konağın kendi işi için oradadır: yedi kalemlik konak kullanıcı alanı, oturum yöneticisinden paket yöneticisine kadar konuğun hiç ihtiyaç duymadığı bileşenlerdir. Konuk sınırı yine de onlara bağlıdır, çünkü hipervizör süreci o kullanıcının dosyalarıyla aynı yerde durur. Üçüncü sütun asıl bulguyu veriyor. Çıplak tasarımda düşebilecek en zararsız katman yönetim arayüzüdür: düştüğünde on dokuz kalemin **on biri** erişilir hâle gelir; konuk bellek içeriği dışarıda kalır, çünkü yönetim arayüzü konuğu oluşturur ve siler ama çalışan konuğun belleğini okumaz. Barındırılan tasarımda en zararsız düşüş konak kullanıcı alanıdır ve orada yirmi altı kalemin **on sekizi** erişilir. Oran olarak yüzde elli sekize karşı yüzde altmış dokuz. Katman eklemek yolu uzattı, ama **ilk düşüşün açtığı yüzeyi daraltmadı.** En keskin satır barındırılan tasarımın ikinci satırıdır. Hipervizör süreci düştüğünde erişilen kalem sayısı yirmi ikidir ve bu, konak çekirdeği düştüğünde erişilen sayıdan yalnız dört eksiktir. Sebebi yapısaldır: konuk disk imajları konağın dosya sisteminde, hipervizör sürecini çalıştıran kimliğin dosyaları olarak durur. Sürece erişen, dört konuğun diskine dosya olarak erişir. **Konuğun altındaki üçüncü katman donanımı korur, konuğun diskini korumaz.** #### Sınırı Geçmek İçin Gereken Kalem Katman sayısı tek başına yalıtım gücü değildir. Ölçü, belirli bir hedefe ulaşmak için **aynı anda** kaç kalemin yanlış olması gerektiğidir. Aşağıdaki koşum aynı dört hedefi iki tasarımda ayrı ayrı ölçüyor ve her hedef için iki sayı yazıyor: gereken kalem ve o kalemin seçilebileceği aday sayısı. ```js // sinir.mjs — ayni hedef kumesi iki tasarimda: siniri gecmek icin gereken kalem ve aday kalem. // "Gereken" = ayni anda yanlis olmasi gereken katman sayisi. "Aday" = o katmanlarin kalem toplami. import { TASARIM, say, evren } from './katman.mjs'; const HEDEF = [ // [hedef, erisilmesi gereken kalem kumeleri] ['komsu konugun diski', ['kd']], ['komsu konugun bellegi', ['kb']], ['bellenim ayarini degistirme', ['ba']], ['donanima dogrudan erisim', null], ]; const olc = (ad, gerek) => { const katman = TASARIM[ad]; if (gerek === null) { // donanim: yoldaki her katmanda bir kalem yanlis olmali const yol = katman.filter(([, , y]) => y); return [yol.length, yol.reduce((t, [, n]) => t + n, 0)]; } const yeten = katman.filter(([, , , e]) => gerek.every((g) => e.includes(g))); return [1, yeten.reduce((t, [, n]) => t + n, 0)]; }; const ADLAR = Object.keys(TASARIM); const s = (x, n) => String(x).padStart(n); console.log(`${''.padEnd(29)}${'ciplak donanim'.padStart(16)}${'barindirilan'.padStart(18)}`); console.log(`${'hedef'.padEnd(29)}${s('gereken', 8)}${s('aday', 8)}${s('gereken', 10)}${s('aday', 8)}`); for (const [h, g] of HEDEF) { const [a1, b1] = olc(ADLAR[0], g), [a2, b2] = olc(ADLAR[1], g); console.log(`${h.padEnd(29)}${s(a1, 8)}${s(b1, 8)}${s(a2, 10)}${s(b2, 8)}`); } const bir = HEDEF.filter(([, g]) => g !== null).length; console.log(`\n${bir} hedefte gereken kalem iki tasarimda da 1; fark aday sayisindadir`); for (const ad of ADLAR) { const k = TASARIM[ad]; const enaz = Math.min(...k.map(([, , , e]) => say(e))); console.log(`${ad.padEnd(27)} taban ${s(k.reduce((t, [, n]) => t + n, 0), 2)} kalem,` + ` tek katman dustugunde en az ${enaz}/${evren(ad)} kaleme erisiliyor`); } ``` ``` ciplak donanim barindirilan hedef gereken aday gereken aday komsu konugun diski 1 13 1 25 komsu konugun bellegi 1 10 1 18 bellenim ayarini degistirme 1 4 1 13 donanima dogrudan erisim 2 10 3 18 3 hedefte gereken kalem iki tasarimda da 1; fark aday sayisindadir ciplak donanim hipervizoru taban 13 kalem, tek katman dustugunde en az 11/19 kaleme erisiliyor barindirilan hipervizor taban 25 kalem, tek katman dustugunde en az 18/26 kaleme erisiliyor ``` Dört hedefin üçünde gereken kalem sayısı iki tasarımda da **birdir**. Komşu konuğun diskine ulaşmak için tek bir katmanın tek bir kalemi yeter; komşunun belleği için de öyle. Katman sayısındaki fark bu üç satırın hiçbirinde görünmüyor, çünkü katmanlar konuk ile donanım arasında **art arda** durur, konuk ile komşu konuk arasında değil. Yan yana duran iki konuğu ayıran şey aynı hipervizördür ve o hipervizör tek bir kalem kümesidir. Fark aday sütununda. Komşunun diski için çıplak tasarımda on üç, barındırılan tasarımda yirmi beş aday kalem var — yaklaşık iki kat. Bellenim ayarı satırı oranı daha da açıyor: çıplak tasarımda bellenim ayarına yalnız açılış zincirinin dört kalemi üzerinden ulaşılabilirken, barındırılan tasarımda konak çekirdeği de bellenimi yazabildiği için aday sayısı dörtten on üçe çıkıyor. **Yalıtım gücü gereken kalem sayısıdır; o sayı ikisinde de bir olduğuna göre, iki tasarımı ayıran şey sınırın gücü değil, o tek kalemin kaç aday arasından çıkabileceğidir.** Yalnız son satırda gereken sayı birden büyük: donanıma doğrudan erişmek çıplak tasarımda iki, barındırılan tasarımda üç kalemin aynı anda yanlış olmasını ister. Barındırılan tasarımın kazandığı tek yer burasıdır ve kazandığı şey donanımdır — konuk verisi değil. #### Zincirin Kökü İki tasarımın ortak katmanı bellenim ve açılış zinciridir ve iki tabloda da düştüğünde her şeye erişilen katman odur: çıplak tasarımda 19/19, barındırılan tasarımda 26/26. O dört kalemi ayrı ayrı saymak yetmez, çünkü aralarında bir sıra vardır: her halka bir sonrakini yükler. **İmzalı açılış** bu sıraya bir doğrulama koyar — her halka bir öncekince imzalanmış olduğu için doğrulanır ve zincirin kökü donanımdaki **güvenilir platform birimidir**. ```js // acilis.mjs — imzali acilisin acilis zincirindeki gereken ve aday kalemi nasil degistirdigi (MODEL). // Zincirin koku donanimdaki guvenilir platform birimidir; her halka bir oncekince dogrulanir. const ZINCIR = ['acilis bellenimi', 'acilis yukleyicisi', 'cekirdek imaji', 'hipervizor modulu']; // imzasiz: dogrulanmayan ilk halkanin sirasi (null ise butun zincir dogrulanir) const olc = (imzali, imzasiz = null) => { if (!imzali) return [1, ZINCIR.length, 0]; // her halka tek basina degistirilebilir const kes = imzasiz === null ? ZINCIR.length : ZINCIR.indexOf(imzasiz); // kesilen halkadan sonrasi dogrulanmiyor: tek kalem yeter, aday o kalan halkalardir if (kes < ZINCIR.length) return [1, ZINCIR.length - kes, ZINCIR.length - 1]; return [ZINCIR.length, 1, ZINCIR.length]; // kok anahtar tek aday, halkalar yeniden imzalanir }; const s = (x, n) => String(x).padStart(n); console.log(`acilis zinciri ${ZINCIR.length} halka: ${ZINCIR.join(' -> ')}`); console.log(`${'duzen'.padEnd(34)}${s('gereken', 8)}${s('aday', 6)}${s('yeniden imzalanan', 19)}`); for (const [ad, imzali, imzasiz] of [['imzasiz acilis', false, null], ['imzali acilis', true, null], ['imzali acilis, son halka imzasiz', true, 'hipervizor modulu'], ['imzali acilis, cekirdek imzasiz', true, 'cekirdek imaji']]) { const [g, a, y] = olc(imzali, imzasiz); console.log(`${ad.padEnd(34)}${s(g, 8)}${s(a, 6)}${s(y, 19)}`); } ``` ``` acilis zinciri 4 halka: acilis bellenimi -> acilis yukleyicisi -> cekirdek imaji -> hipervizor modulu duzen gereken aday yeniden imzalanan imzasiz acilis 1 4 0 imzali acilis 4 1 4 imzali acilis, son halka imzasiz 1 1 3 imzali acilis, cekirdek imzasiz 1 2 3 ``` İmzasız düzende dört halkanın herhangi biri tek başına değiştirilebilir: gereken kalem bir, aday dört. İmzalı düzende son halkayı değiştirmek için ondan köke kadar bütün zinciri değiştirmek gerekir; gereken kalem dörde çıkar, aday ise donanımdaki tek kök anahtara iner. Bu, dersteki tek sayısal iyileşmedir — hem gereken sayı büyür hem aday sayısı küçülür. Son iki satır bedeli ve kırılganlığı birlikte gösteriyor. İmzalı zincirin her güncellemesi üç ya da dört halkanın yeniden imzalanmasını ister; bu, yama sürecine eklenen sabit bir iştir. Kırılganlık daha keskin: zincirde **tek bir imzasız halka** varsa gereken kalem dörtten bire düşer. Son halka imzasız bırakıldığında gereken kalem bir, aday da birdir — yani doğrulanmamış tek bir hipervizör modülü, dört halkalık zincirin bütün kazancını siler. Çekirdek imzasız bırakıldığında aday ikiye çıkar. **Zincir en zayıf halkasının değil, doğrulanmayan ilk halkasının gücündedir.** #### Bedelin Yazıldığı Yer Çıplak tasarımın on üç kalemlik tabanı bedavaya gelmiyor. O tasarımda makine yalnız konuk sistem çalıştırır: konak üzerinde tarayıcı, yerel araç, dosya paylaşımı ya da saha ekibinin günlük işi yoktur. Barındırılan tasarımdaki yedi kalemlik konak kullanıcı alanı bir israf değil, o makinenin **meşru işidir**. Saha ekiplerinin dizüstü bilgisayarlarında bu iş vazgeçilebilir değildir; şube sunucusunda vazgeçilebilir olduğu için çıplak tasarım anlamlıdır. Bedelin ikinci kalemi yönetimdir. Çıplak tasarımda yönetim arayüzü ayrı bir katman olarak sayıldı ve düştüğünde on bir kaleme erişildi. Barındırılan tasarımda ayrı bir yönetim katmanı yok, çünkü yönetim konağın kendi oturumundan yapılır; o oturum zaten yirmi altı kalemin on sekizine erişiyor. Yönetimi ayrı bir katmana çıkarmak bir kalem eklemek pahasına erişilen kalemi daraltır — bu kursta ölçülen ilk takas budur ve üç kalem karşılığında yedi kalemlik bir daralma verir. Bu ölçümlerin hiçbiri iki tür arasında bir sıralama vermez. Şube sunucusunda konağın kendi işi yoksa çıplak tasarım on iki kalemlik daha küçük bir taban ve bir katman daha kısa bir yol karşılığında yönetimi ayrı bir arayüze taşımayı ister. Saha dizüstü bilgisayarında o iş vazgeçilemez olduğu için barındırılan tasarımın yirmi beş kalemlik tabanı bir seçim değil, o makinenin tanımıdır. Ölçünün söylediği tek şey, seçilen tasarımın hangi sayıyla gelmiş olduğudur. #### Özet - Çıplak donanım hipervizöründe konuk ile donanım arasında iki katman, barındırılan hipervizörde üç katman vardır; güvenilir taban sırasıyla 13 ve 25 kalemdir. - Tek bir katman düştüğünde erişilen en küçük kalem oranı çıplak tasarımda 11/19, barındırılan tasarımda 18/26'dır: katman eklemek ilk düşüşün açtığı yüzeyi daraltmamıştır. - Barındırılan tasarımda hipervizör süreci düştüğünde 22/26 kaleme erişilir, çünkü dört konuğun disk imajı konağın dosya sisteminde o sürecin kimliğine ait dosyalardır. - Dört hedefin üçünde sınırı geçmek için gereken kalem sayısı iki tasarımda da birdir; fark aday sayısındadır (13'e karşı 25, 10'a karşı 18, 4'e karşı 13). - Yalnız donanıma doğrudan erişimde sayı ikiye ve üçe çıkar; barındırılan tasarımın fazladan katmanı donanımı korur, konuk diskini korumaz. - Dört halkalık açılış zincirinde imzalı açılış gereken kalemi 1'den 4'e çıkarır ve aday kalemi 4'ten 1'e indirir; doğrulanmayan tek bir halka gereken kalemi yeniden 1'e düşürür. #### Sonraki Adım Bu dersin bütün ölçümü katmanları **üst üste** saydı: konuk, hipervizör, konak, donanım. Ama konuk ile konak arasında yalnız bir yığın yok; ikisi çalışırken bir dizi kalemi **aynı anda** kullanıyor. Aynı zamanlayıcı ikisinin iş parçacıklarını sıraya diziyor, aynı fiziksel bellek sayfaları paylaştırılıyor, konuğun gördüğü disk ve ağ kartı konakta koşan bir öykünme kodudur, üstüne bir de paylaşılan dizin ve pano gibi rahatlık için açılmış kalemler var. Sonraki ders kaçış riskini bu paylaşılan kalemler üzerinden sayar: konuk ile konak kaç kalemi paylaşıyor, paylaşılan her kalem kaç yol açıyor ve o kalemler kapatıldığında geriye kaç yol kalıyor. ### Konuk ve Konak Sistem Source: https://academia.sh/tr/kurslar/bt-temelleri/konuk-ve-konak-sistem Kaçış riskinin paylaşılan kalem sayısıyla ölçülmesi: konuk ile konağın paylaştığı on bir kalem, her kalemin açtığı yol ve yolun geçiş, veri ya da bilgi etkisiyle sınıflanması, seçime bağlı paylaşımların kapatılmasıyla kapanan yol ile bunun iş adımı ve konak belleği cinsinden bedeli, konuk koştuğu sürece kapatılamayan altı yol. Önceki ders katmanları üst üste saydı: konuk, hipervizör, konak, donanım. O sıralamada her katman bir öncekini taşıyordu. Ama konuk ile konak arasında yalnız bir yığın yok; ikisi çalışırken bir dizi kalemi **aynı anda** kullanıyor. Aynı zamanlayıcı iki tarafın iş parçacıklarını sıraya diziyor, aynı fiziksel bellek sayfaları paylaştırılıyor, konuğun gördüğü disk ve ağ kartı konakta koşan bir öykünme kodudur, üstüne bir de rahatlık için açılmış paylaşılan dizin, pano ve ajan kanalı var. Kaçış, konuk sınırının bir kez geçilip konak tarafında bir şeye ulaşılmasıdır. Bu ders kaçışı bir olasılık olarak değil, **paylaşılan kalem sayısı** olarak ölçer: konuk ile konak kaç kalemi paylaşıyor, paylaşılan her kalem kaç yol açıyor ve o yolların kaçı kapatılabiliyor. Kaçış adımının kendisi yazılmaz; yolun adı, etkisi ve karşılığı yazılır. Bir kaçış yolunun gerçek bir sistemde denenmesi, yazılı yetki ve tanımlı kapsam olmadan hem yasadışı hem de meslek dışıdır. **SA7 — Paylaşılan kalem, konuk çalışırken konakla ortak kullanılan bir bileşendir**; kurgu şube sunucusundaki liste modeldir, sayım gerçektir. **SA8 — Bir yol, tek bir paylaşılan kalem üzerinden konak tarafında ulaşılan sonuçtur.** **SA9 — Yolun etkisi üç sınıftan biridir: geçiş** (konak sürecinde kod çalıştırma), **veri** (konak verisine dokunma), **bilgi** (yalnız çıkarım). **SA10 — Zorunlu kalem, konuk koştuğu sürece kapatılamayan kalemdir.** **SA11 — Bedel iki birimde yazılır: değişen meşru iş adımı ve konakta ek bellek.** **SA12 — Şube sunucusunda dört konuk vardır ve iki güven düzeyine ayrılır.** #### Paylaşılan Kalemler Paylaşılan kalemler iki türdür. Bir bölümü konuk çalıştığı sürece vardır: konuk bir işlemci zamanı almak, bir disk görmek ve bir ağ kartına yazmak zorundadır, o disk ve ağ kartı da konakta koşan bir öykünme kodudur. Öteki bölüm rahatlık için açılır ve bir yapılandırma kalemiyle kapatılabilir. ```js // paylasim.mjs — konuk ile konagin paylastigi kalemler ve her kalemin actigi yol (MODEL). // Yollar savunma ekseninde adlandirilir; istismar kodu degil, yol adi ve etkisi yazilir. // etki: gecis = konak surecine gecme, veri = konak verisine dokunma, bilgi = bilgi cikarimi. // [kalem, zorunlu mu, [[yol, etki], ...], [degisen mesru is adimi, konakta ek bellek MiB]] export const PAYLASIM = [ ['zamanlayici', true, [['komsu konugun etkinlik zamanlamasi', 'bilgi']], [0, 0]], ['islemci onbellegi', true, [['paylasilan satirdan erisim deseni', 'bilgi']], [0, 0]], ['saat kaynagi', true, [['konak bakim penceresinin cikarimi', 'bilgi']], [0, 0]], ['disk denetleyicisi oykunmesi', true, [['oykunme kusuruyla konak surecine gecis', 'gecis']], [0, 0]], ['ag arayuzu oykunmesi', true, [['oykunme kusuruyla konak surecine gecis', 'gecis'], ['konak ag yiginina konuk paketi', 'veri']], [0, 0]], ['bellek sayfasi birlestirme', false, [['ayni sayfanin varligini olcme', 'bilgi'], ['yazma gecikmesinden sayfa paylasimi', 'bilgi']], [0, 1856]], ['ekran denetleyicisi oykunmesi', false, [['oykunme kusuruyla konak surecine gecis', 'gecis']], [2, 0]], ['paylasilan dizin', false, [['konak dosya sistemine yazma', 'veri'], ['konaktan gelen dosyanin konukta calismasi', 'veri']], [2, 0]], ['pano', false, [['konak panosunu okuma', 'veri'], ['konuga konaktan veri gecirme', 'veri']], [1, 0]], ['konuk ajani kanali', false, [['konaktan konukta komut calistirma', 'veri'], ['konuk dosya sistemini konaktan okuma', 'bilgi']], [4, 0]], ['usb gecirme', false, [['takilan aygitin konak surucusune ulasmasi', 'gecis']], [1, 0]], ]; export const ETKI = ['gecis', 'veri', 'bilgi']; export const yol = (liste) => liste.reduce((t, [, , y]) => t + y.length, 0); export const etkiSay = (liste, e) => liste.reduce((t, [, , y]) => t + y.filter(([, k]) => k === e).length, 0); if (import.meta.url === `file://${process.argv[1]}`) { const s = (x, n) => String(x).padStart(n); const T = yol(PAYLASIM); console.log(`${PAYLASIM.length} paylasilan kalem, ${T} yol; kalem basina ortalama ` + `${(T / PAYLASIM.length).toFixed(2)} yol`); console.log(`\n${'kalem'.padEnd(30)}${'tur'.padEnd(14)}${s('yol', 4)}${s('gecis', 7)}${s('veri', 6)}` + `${s('bilgi', 7)}${s('ek adim', 9)}${s('ek bellek', 11)}`); for (const k of PAYLASIM) { const [ad, zorunlu, y, [adim, mib]] = k; console.log(`${ad.padEnd(30)}${(zorunlu ? 'zorunlu' : 'secime bagli').padEnd(14)}${s(y.length, 4)}` + ETKI.map((e) => s(etkiSay([k], e), e === 'veri' ? 6 : 7)).join('') + `${s(zorunlu ? '-' : adim, 9)}${s(zorunlu ? '-' : mib, 11)}`); } for (const [ad, f] of [['zorunlu toplam', true], ['secime bagli toplam', false]]) { const g = PAYLASIM.filter(([, z]) => z === f); const [adim, mib] = g.reduce(([a, m], [, , , [x, y]]) => [a + x, m + y], [0, 0]); console.log(`${ad.padEnd(44)}${s(yol(g), 4)}` + ETKI.map((e) => s(etkiSay(g, e), e === 'veri' ? 6 : 7)).join('') + `${s(f ? '-' : adim, 9)}${s(f ? '-' : mib, 11)}`); } } ``` ``` 11 paylasilan kalem, 16 yol; kalem basina ortalama 1.45 yol kalem tur yol gecis veri bilgi ek adim ek bellek zamanlayici zorunlu 1 0 0 1 - - islemci onbellegi zorunlu 1 0 0 1 - - saat kaynagi zorunlu 1 0 0 1 - - disk denetleyicisi oykunmesi zorunlu 1 1 0 0 - - ag arayuzu oykunmesi zorunlu 2 1 1 0 - - bellek sayfasi birlestirme secime bagli 2 0 0 2 0 1856 ekran denetleyicisi oykunmesi secime bagli 1 1 0 0 2 0 paylasilan dizin secime bagli 2 0 2 0 2 0 pano secime bagli 2 0 2 0 1 0 konuk ajani kanali secime bagli 2 0 1 1 4 0 usb gecirme secime bagli 1 1 0 0 1 0 zorunlu toplam 6 2 1 3 - - secime bagli toplam 10 2 5 3 10 1856 ``` On bir kalem on altı yol açıyor; kalem başına ortalama 1,45. Bu ortalama tek başına bir uyarıdır: paylaşılan bir kalemi kapatmak her zaman tek bir yolu kapatmaz — on bir kalemin beşi **iki** yol taşır ve açık bırakmak da öyle. Etki sütunları listeyi ikiye ayırıyor. Zorunlu beş kalem altı yol açıyor ve bunların üçü yalnız bilgi çıkarımıdır: komşunun ne zaman çalıştığı, hangi bellek sayfasının ortak olduğu, konağın bakım penceresi. İki tanesi geçiştir ve ikisi de bir öykünme kodundan gelir. Konuk bir disk ve bir ağ kartı görmek zorunda olduğuna göre o iki öykünme kodu her koşumda konakta çalışır; bu iki geçiş yolu **kapatılabilir bir kalem değildir.** Seçime bağlı altı kalem on yol açıyor ve dağılım tersine dönüyor: altı **veri** yolunun beşi bu grupta. Pano, paylaşılan dizin ve ajan kanalı — üçü de bir kişinin işini kolaylaştırmak için açılmış kalemlerdir — konak verisine dokunan altı yolun beşini taşıyor. Sağ iki sütun bunun karşılığını yazıyor: on iş adımı ve 1.856 MiB konak belleği. #### Kapatmanın Kapattığı ve Bıraktığı Aşağıdaki koşum seçime bağlı kalemleri tek tek kapatıyor — önce çok yol açanı, eşitlikte ucuz olanı — ve her adımda kapanan yolu bedelle birlikte yazıyor. ```js // kapatma.mjs — secime bagli paylasimlar tek tek kapatilir; kapanan yol ve bedel birlikte sayilir. import { PAYLASIM, ETKI, yol, etkiSay } from './paylasim.mjs'; const T = yol(PAYLASIM); const secmeli = PAYLASIM.filter(([, z]) => !z) .sort((a, b) => b[2].length - a[2].length || a[3][0] - b[3][0]); // once cok yol, sonra ucuz const s = (x, n) => String(x).padStart(n); console.log(`${'kapatilan kalem'.padEnd(30)}${s('kapanan', 8)}${s('toplam', 7)}${s('kalan', 6)}` + `${s('ek adim', 9)}${s('ek bellek', 11)}`); let kapanan = 0, adim = 0, mib = 0; for (const [ad, , y, [a, m]] of secmeli) { kapanan += y.length; adim += a; mib += m; console.log(`${ad.padEnd(30)}${s(y.length, 8)}${s(kapanan, 7)}${s(T - kapanan, 6)}${s(adim, 9)}${s(mib, 11)}`); } const kalan = PAYLASIM.filter(([, z]) => z); console.log(`\nkapatilabilen ${secmeli.length}/${PAYLASIM.length} kalem, kapanan ${kapanan}/${T} yol ` + `(%${((100 * kapanan) / T).toFixed(1)}); bedel ${adim} is adimi ve ${mib} MiB konak bellegi`); console.log(`${'etki'.padEnd(10)}${s('bastaki yol', 12)}${s('kalan yol', 11)}`); for (const e of ETKI) console.log(`${e.padEnd(10)}${s(etkiSay(PAYLASIM, e), 12)}${s(etkiSay(kalan, e), 11)}`); console.log(`konuk kostugu surece kapatilamayan ${kalan.length} kalem ${yol(kalan)} yol birakiyor`); // Yerlesim: ayni konaktaki dort kurgu konuk, iki guven duzeyi. const KONUK = [['toplayici', 'yuksek'], ['dogrulayici', 'yuksek'], ['saha portali', 'dusuk'], ['sinama', 'dusuk']]; const cift = KONUK.flatMap((a, i) => KONUK.slice(i + 1).map((b) => [a[1], b[1]])); const karisik = cift.filter(([a, b]) => a !== b).length; console.log(`\ntek konak: ${KONUK.length} konuk, ${cift.length} komsu cifti, farkli duzeyden ${karisik} cift`); console.log(`duzey basina ayri konak: ${cift.length - karisik} cift, farkli duzeyden 0; ` + `kalan yol yine ${yol(kalan)}, bedel 1 makine daha`); ``` ``` kapatilan kalem kapanan toplam kalan ek adim ek bellek bellek sayfasi birlestirme 2 2 14 0 1856 pano 2 4 12 1 1856 paylasilan dizin 2 6 10 3 1856 konuk ajani kanali 2 8 8 7 1856 usb gecirme 1 9 7 8 1856 ekran denetleyicisi oykunmesi 1 10 6 10 1856 kapatilabilen 6/11 kalem, kapanan 10/16 yol (%62.5); bedel 10 is adimi ve 1856 MiB konak bellegi etki bastaki yol kalan yol gecis 4 2 veri 6 1 bilgi 6 3 konuk kostugu surece kapatilamayan 5 kalem 6 yol birakiyor tek konak: 4 konuk, 6 komsu cifti, farkli duzeyden 4 cift duzey basina ayri konak: 2 cift, farkli duzeyden 0; kalan yol yine 6, bedel 1 makine daha ``` Altı kalem kapatıldığında on altı yolun onu kapanıyor, altısı kalıyor. Birinci satır ilk bakışta bedava görünüyor: bellek sayfası birleştirme iki bilgi yolunu kapatıyor ve değişen iş adımı sıfır. Bedel iş akışında değil, bellektedir — 1.856 MiB konak belleği, çünkü birleştirilmiş sayfalar artık ayrı ayrı tutulur. **Bedeli sıfır görünen kalemin bedeli genelde başka bir sütundadır.** Etki tablosu asıl kazancı gösteriyor. Veri yolları altıdan **bire** iniyor; kalan tek veri yolu ağ öykünmesinin taşıdığı yoldur. Yani konak verisine dokunan yolların altıda beşi, kapatılabilir rahatlık kalemlerinin içindeydi. Geçiş yolları dörtten ikiye, bilgi yolları altıdan üçe iniyor. Toplam bedel on iş adımıdır: dosya aktarımı ağ üzerinden yapılır, kapatma ve açılış yordamları elle yürütülür, saha cihazı okuması şube istemcisine taşınır. Kalan altı yol bu dersin sınırıdır. Konuk koştuğu sürece bir zamanlayıcı, bir işlemci önbelleği, bir saat kaynağı, bir disk ve bir ağ arayüzü paylaşılır. Bunlar kapatılamaz, çünkü kapatıldıklarında konuk da çalışmaz. Geriye o altı yolun **ne kadar kolay** işlediğini sormak kalıyor. #### Yol Başına Gereken Kalem Buraya kadar her yol tek bir paylaşılan kalemle eşleştirildi. Bu, yolun tek koşulu paylaşımın varlığıymış gibi okunur; çoğu yolda böyle değildir. Aşağıdaki koşum her yola paylaşımın **üstüne** gereken ek koşulları veriyor ve sınırı geçmek için aynı anda doğru olması gereken kalem sayısını çıkarıyor. ```js // kosul.mjs — her yol icin ayni anda dogru olmasi gereken kalem sayisi (MODEL). // Paylasilan kalemin varligi bir kalemdir; asagidaki liste ona EK kosullari verir. import { PAYLASIM } from './paylasim.mjs'; const EK = { 'komsu konugun etkinlik zamanlamasi': [], 'paylasilan satirdan erisim deseni': ['komsuyla ayni cekirdege yerlesme'], 'konak bakim penceresinin cikarimi': [], 'oykunme kusuruyla konak surecine gecis': ['yamalanmamis oykunme kusuru'], 'konak ag yiginina konuk paketi': ['konak arayuzunun konuk agina bagli olmasi'], 'ayni sayfanin varligini olcme': ['komsuda ayni sayfa icerigi'], 'yazma gecikmesinden sayfa paylasimi': ['komsuda ayni sayfa icerigi'], 'konak dosya sistemine yazma': ['takmanin yazilabilir olmasi'], 'konaktan gelen dosyanin konukta calismasi': ['konukta calistirma izni', 'dosyanin acilmasi'], 'konak panosunu okuma': [], 'konuga konaktan veri gecirme': [], 'konaktan konukta komut calistirma': ['konak tarafinda ajan yetkisi'], 'konuk dosya sistemini konaktan okuma': ['konak tarafinda ajan yetkisi'], 'takilan aygitin konak surucusune ulasmasi': ['fiziksel erisim', 'yamalanmamis surucu kusuru'], }; // [gereken kalem, yol adi, zorunlu kalemden mi] const YOL = PAYLASIM.flatMap(([, z, y]) => y.map(([ad]) => [1 + EK[ad].length, ad, z])); const s = (x, n) => String(x).padStart(n); console.log(`${'gereken kalem'.padEnd(15)}${s('yol', 4)} ornek`); for (const g of [...new Set(YOL.map(([n]) => n))].sort()) { const k = YOL.filter(([n]) => n === g); console.log(`${String(g).padEnd(15)}${s(k.length, 4)} ${k[0][1]}`); } const zorunlu = YOL.filter(([, , z]) => z); console.log(`\nkapatilamayan ${zorunlu.length} yolda gereken kalem: ` + [...new Set(zorunlu.map(([n]) => n))].sort() .map((g) => `${g} -> ${zorunlu.filter(([n]) => n === g).length} yol`).join(', ')); const ikinci = YOL.flatMap(([, ad]) => EK[ad]); const sayim = [...new Set(ikinci)].map((k) => [k, ikinci.filter((x) => x === k).length]) .sort((a, b) => b[1] - a[1]); console.log(`en sik ek kosul: ${sayim[0][0]} (${sayim[0][1]} yol); toplam ${ikinci.length} ek kosul, ` + `${sayim.length} ayri kalem`); ``` ``` gereken kalem yol ornek 1 4 komsu konugun etkinlik zamanlamasi 2 10 paylasilan satirdan erisim deseni 3 2 konaktan gelen dosyanin konukta calismasi kapatilamayan 6 yolda gereken kalem: 1 -> 2 yol, 2 -> 4 yol en sik ek kosul: yamalanmamis oykunme kusuru (3 yol); toplam 14 ek kosul, 10 ayri kalem ``` On altı yolun **dördü** tek kalemle işliyor: paylaşım açıksa yol açıktır, başka hiçbir koşul gerekmiyor. Bu dördü zamanlayıcı, saat kaynağı ve panonun iki yönüdür; üçü de bir kusura ya da bir yerleşime bağlı değil, paylaşımın tanımı gereği vardır. On yol iki kalem, iki yol üç kalem istiyor. Kapatılamayan altı yolun ikisi tek kalemle işliyor ve ikisi de bilgi yoludur. Kalan dördü ikinci bir kalem ister ve en sık istenen ikinci kalem **yamalanmamış öykünme kusurudur** — üç yolda aynı koşul. Bu, sınırı geçmenin ölçüsünü yamaya bağlıyor: öykünme kodunun yamalı olduğu bir konakta o üç yol iki kalem ister ve ikincisi yerinde değildir. Yama programının kendisi bu kursun konusu değil, ama buradaki sayı onun neyi değiştirdiğini yazıyor: **üç geçiş yolunun ikinci kalemini o kapatıyor.** #### Kapatılamayan Altı Yol Kapatılamayan bir yol için yapılabilecek şey, o yolun **ulaştığı yeri** değiştirmektir. Son iki satır bunu ölçüyor. Dört konuk aynı konakta koşarken altı komşu çifti oluşuyor ve bunların dördü farklı güven düzeyinden geliyor: sayaç okumasını toplayan konuk ile sınama konuğu, doğrulayıcı ile saha portalı. Kalan altı yol bu dört çiftin arasında işliyor. Konukları güven düzeyine göre iki ayrı konağa dağıtmak yolların hiçbirini kapatmıyor — her konakta yine altı yol var — ama farklı düzeyden çiftin sayısını dörtten **sıfıra** indiriyor. Kalan iki çiftte komşular zaten aynı veriye erişen sistemlerdir; bir komşunun ötekinden çıkardığı bilgi, kendi sınırları içinde zaten sahip olduğu bilgidir. Bedeli bir makinedir. Bu ölçüm bir tercih değil, bir sıralama veriyor. Önce seçime bağlı altı kalem kapatılır: on yol gider, bedeli on iş adımı ve 1.856 MiB. Sonra yerleşim düzeltilir: hiçbir yol gitmez, ama kalan altı yolun uçları aynı güven düzeyine bağlanır ve bedeli bir makinedir. Üçüncü bir adım yoktur; konuk koştuğu sürece o altı yol açıktır ve savunmanın oradaki karşılığı kapatmak değil, **görmektir** — hangi öykünme kodunun beklenmedik bir hata döndürdüğü, hangi konuğun komşusunun bakım penceresinde etkinlik gösterdiği. #### Özet - Konuk ile konak on bir kalem paylaşıyor ve bu kalemler on altı yol açıyor; kalem başına ortalama 1,45 yol düşüyor. - Zorunlu beş kalem altı yol açar: iki geçiş, bir veri, üç bilgi. İki geçiş yolu disk ve ağ öykünmesinden gelir ve konuk koştuğu sürece kapatılamaz. - Seçime bağlı altı kalem on yol açar ve altı veri yolunun beşini taşır; kapatılınca veri yolu altıdan bire, geçiş dörtten ikiye, bilgi altıdan üçe iner. - Bedel iki sütunda yazılır: on değişen iş adımı ve 1.856 MiB konak belleği. Bellek sayfası birleştirmenin iş adımı bedeli sıfırdır, bedeli bellektedir. - On altı yolun dördü tek kalemle işler; kalan altı yolun ikisi tek, dördü iki kalem ister ve en sık istenen ikinci kalem yamalanmamış öykünme kusurudur. - Yerleşimi güven düzeyine ayırmak yol sayısını değiştirmez, farklı düzeyden komşu çiftini dörtten sıfıra indirir; bedeli bir makinedir. #### Sonraki Adım Bu iki dersin ölçümü hep **koşan** bir konuk üzerineydi: hangi katman altında duruyor, hangi kalemi konakla paylaşıyor. Ama sanal makinenin asıl ayırt edici özelliği koşarken değil, **durdurulup kopyalanırken** ortaya çıkıyor. Bir konuk anlık görüntüsü alınıp saklanabiliyor, bir imaj otuz kez klonlanıp otuz makineye dağıtılabiliyor, bir hafta önceki duruma birkaç saniyede dönülebiliyor. Sonraki ders bu üç işlemi sınır kalemi cinsinden ölçer: klon kaç sır kalemini kaç kopyaya taşıyor, anlık görüntü zinciri uzadıkça geri dönüş için kaç sağlam halka gerekiyor ve bir hafta önceye dönmek kaç kapalı açığı yeniden açıyor. ### Sanal Makine Yönetimi Source: https://academia.sh/tr/kurslar/bt-temelleri/sanal-makine-yonetimi Klonlama ve anlık görüntünün sınır kalemi cinsinden ölçülmesi: altın imajdaki yedi sır kaleminin kaçının ilk açılışta yenilendiği ve kaçının bütün klonlarda aynı kaldığı, benzersizleştirmenin adım bedeli, yedi noktalı anlık görüntü zincirinde her noktaya dönmek için gereken sağlam halka sayısı, geri dönüşün yeniden açtığı açık ve sildiği denetim kaydı. Önceki iki ders koşan bir konuğu ölçtü: altında kaç katman var, konakla kaç kalem paylaşıyor. Sanal makineyi fiziksel makineden ayıran asıl özellik ise koşarken değil, **durdurulup kopyalanırken** görünüyor. Bir konuk dosyadan ibarettir: anlık görüntüsü alınıp saklanabilir, imajı yirmi dört kez klonlanıp yirmi dört makineye dağıtılabilir, bir hafta önceki durumuna birkaç saniyede dönülebilir. Bu üç işlem yönetimi hafifletir ve hepsi bir sınır kalemi taşır. Ölçülen şey işlemlerin kolaylığı değil, taşıdıkları kalemdir. Klonda soru şudur: bir imajdan üretilen makineler kaç kalemi ortak taşıyor ve o kalemlerden biri düşerse kaç makineye erişiliyor. Anlık görüntüde soru zincirin uzunluğudur: bir noktaya dönmek kaç halkanın sağlam olmasını istiyor. Geri dönüşte soru kayıptır: dönülen nokta ile bugün arasında kapatılmış olan kaç açık yeniden açılıyor. **SA13 — Kurgu şube parkında tek bir altın imajdan 24 konuk klonlanır**; kalem listesi modeldir, sayım gerçektir. **SA14 — Sır kalemi, kopyalandığında iki makinede aynı olan gizli değerdir.** **SA15 — Benzersizleştirme, klonun ilk açılışında bir kalemi yeniden üreten adımdır**; bedeli adım ve servis yeniden başlatma sayısıyla yazılır. **SA16 — Anlık görüntü zinciri artımlıdır**: her halka bir öncekinin üstüne yazılır, bir noktayı açmak taban ile o noktaya kadarki bütün halkaları ister. **SA17 — Doğrulayıcı konuğunun çizelgesi 42 gündür**; altı anlık görüntü ve altı yama olayı içerir, yama olayları toplam 17 açık kapatır. **SA18 — Konuk günde 240 denetim kaydı üretir.** **SA19 — Konuk üzerinde dört bileşen koşar** ve her biri ancak belirli bir hazırlık düzeyinde tutarlı olur; hazırlık düzeyinin bedeli konuğa verilen kesinti saniyesidir. #### Klonun Taşıdığı Sır Bir altın imaj bir kez kurulur, sertleştirilir ve şubelere dağıtılır. İçindeki dosyaların bir bölümü o kuruluma özgü gizli değerlerdir ve klonlama onları da kopyalar. ```js // klon.mjs — altin imajdan uretilen klonlarin tasidigi sir kalemi (MODEL). // Kurgu sube parki: tek bir altin imajdan 24 konuk klonlaniyor. const KLON = 24; // [kalem, ilk acilista yenileniyor mu, yenilemenin istedigi ek adim, servis yeniden baslatma] const SIR = [ ['konak anahtari', true, 1, 1], ['makine kimligi', true, 1, 0], ['yonetim ajani belirteci', false, 1, 1], ['gunluk gonderim anahtari', false, 1, 1], ['yonetici oturum belirteci onbellegi', false, 1, 0], ['yerel yonetici parola ozeti', false, 1, 0], ['sertifika ozel anahtari', false, 2, 1], ]; const s = (x, n) => String(x).padStart(n); console.log(`altin imaj ${SIR.length} sir kalemi tasiyor; ${KLON} klon uretiliyor`); console.log(`${'kalem'.padEnd(36)}${s('yenileniyor', 12)}${s('ayni kalan makine', 19)}`); for (const [ad, y] of SIR) console.log(`${ad.padEnd(36)}${s(y ? 'evet' : 'hayir', 12)}${s(y ? 1 : KLON, 19)}`); const ortak = SIR.filter(([, y]) => !y); console.log(`\nyenilenen ${SIR.length - ortak.length}, ortak ${ortak.length}; ` + `ortak kalem-makine cifti ${ortak.length * KLON}`); console.log(`tek ortak sir kalemi icin gereken kalem 1, erisilen makine ${KLON}`); const [adim, servis] = ortak.reduce(([a, r], [, , x, y]) => [a + x, r + y], [0, 0]); console.log(`bes ortak kalemi de yenilemenin bedeli: ${adim} ilk acilis adimi, ` + `${servis} servis yeniden baslatma, klon basina`); console.log(`park genelinde ${adim * KLON} adim; yenilenmeyen tek kalem kalirsa erisilen makine ` + `yine ${KLON}`); ``` ``` altin imaj 7 sir kalemi tasiyor; 24 klon uretiliyor kalem yenileniyor ayni kalan makine konak anahtari evet 1 makine kimligi evet 1 yonetim ajani belirteci hayir 24 gunluk gonderim anahtari hayir 24 yonetici oturum belirteci onbellegi hayir 24 yerel yonetici parola ozeti hayir 24 sertifika ozel anahtari hayir 24 yenilenen 2, ortak 5; ortak kalem-makine cifti 120 tek ortak sir kalemi icin gereken kalem 1, erisilen makine 24 bes ortak kalemi de yenilemenin bedeli: 6 ilk acilis adimi, 3 servis yeniden baslatma, klon basina park genelinde 144 adim; yenilenmeyen tek kalem kalirsa erisilen makine yine 24 ``` Yedi kalemin ikisi yenileniyor. Bu ikisi yenileniyor çünkü yenilenmediklerinde sistem görünür biçimde bozulur: iki makinenin makine kimliği aynıysa ağ yönetimi ikisini ayırt edemez, konak anahtarı aynıysa bağlantı istemcileri uyarı verir. Kalan beşi yenilenmiyor çünkü yenilenmediklerinde **hiçbir şey bozulmuyor**. Yirmi dört makine aynı yönetim ajanı belirtecini, aynı günlük gönderim anahtarını ve aynı sertifika özel anahtarını taşıyor ve park sorunsuz çalışıyor. Ortak kalem-makine çifti yüz yirmi. Bu sayı hasar değil, yüzeydir. Asıl sayı onun altındadır: bir sır kalemi için sınırı geçmek üzere gereken kalem **birdir** ve o bir kalem düştüğünde erişilen makine **yirmi dörttür**. Bir makinenin diskinden okunan tek bir özel anahtar, yirmi dört şubede aynı anahtardır. Klonlama bir yol açmaz; **var olan yolun ucundaki makine sayısını yirmi dörde çıkarır.** Bedel sütunu bu kez küçük. Beş kalemi de benzersizleştirmek klon başına altı ilk açılış adımı ve üç servis yeniden başlatma, park genelinde yüz kırk dört adım ister — bir kereye mahsus ve betiklenebilir bir iş. Son satır ise ölçümün en sert yeridir: **yenilenmeyen tek bir kalem kalırsa erişilen makine yine yirmi dörttür.** Benzersizleştirme kısmi yapılamaz; dördü yenilenip biri unutulduğunda kazanılan sayı sıfırdır. #### Anlık Görüntü Zinciri Anlık görüntü bir kopya değil, bir farktır: her halka bir öncekinin üstüne yazılan değişikliği tutar. Bu, alma işlemini ucuzlatır ve okuma işlemini zincirin uzunluğuna bağlar. ```js // zincir.mjs — anlik goruntu zinciri ve geri donusun geri getirdigi acik (MODEL). // Kurgu dogrulayici konugunun 42 gunluk cizelgesi: alti anlik goruntu, alti yama olayi. const BUGUN = 42, GUNLUK = 240; // gunde 240 denetim kaydi const NOKTA = [['taban', 0], ['ag-1', 3], ['ag-2', 10], ['ag-3', 17], ['ag-4', 24], ['ag-5', 31], ['ag-6', 38]]; const YAMA = [[5, 3], [12, 1], [19, 4], [26, 2], [33, 5], [40, 2]]; // [gun, kapatilan acik] const TABAN_GIB = 40, HALKA_GIB = 1.9; const acik = (gun) => YAMA.filter(([g]) => g > gun).reduce((t, [, n]) => t + n, 0); const s = (x, n) => String(x).padStart(n); console.log(`bugun gun ${BUGUN}; ${NOKTA.length - 1} anlik goruntu, ${YAMA.length} yama olayi, ` + `kapatilan acik ${acik(0)}`); console.log(`\n${'donulen nokta'.padEnd(15)}${s('gun', 4)}${s('gereken halka', 15)}` + `${s('yeniden acilan acik', 21)}${s('kaybolan gunluk kaydi', 23)}`); NOKTA.forEach(([ad, gun], i) => { console.log(`${ad.padEnd(15)}${s(gun, 4)}${s(i + 1, 15)}${s(acik(gun), 21)}` + `${s((BUGUN - gun) * GUNLUK, 23)}`); }); const halka = NOKTA.length - 1; console.log(`\nzincir: taban ${TABAN_GIB} GiB + ${halka} halka x ${HALKA_GIB} GiB = ` + `${(TABAN_GIB + halka * HALKA_GIB).toFixed(1)} GiB; en yeni noktayi acmak ${NOKTA.length} halka okur`); const BOZUK = 3; // ag-3'un deltasi bozuldu const [ad, gun] = NOKTA[BOZUK - 1]; console.log(`halka ${BOZUK} bozuk -> donulebilen en yeni nokta ${ad} (gun ${gun}), ` + `yeniden acilan acik ${acik(gun)}, kaybolan kayit ${(BUGUN - gun) * GUNLUK}`); console.log(`bozuk halkadan sonraki ${NOKTA.length - BOZUK} nokta acilamaz; ` + `zincirde gereken saglam halka ${NOKTA.length}`); ``` ``` bugun gun 42; 6 anlik goruntu, 6 yama olayi, kapatilan acik 17 donulen nokta gun gereken halka yeniden acilan acik kaybolan gunluk kaydi taban 0 1 17 10080 ag-1 3 2 17 9360 ag-2 10 3 14 7680 ag-3 17 4 13 6000 ag-4 24 5 9 4320 ag-5 31 6 7 2640 ag-6 38 7 2 960 zincir: taban 40 GiB + 6 halka x 1.9 GiB = 51.4 GiB; en yeni noktayi acmak 7 halka okur halka 3 bozuk -> donulebilen en yeni nokta ag-2 (gun 10), yeniden acilan acik 14, kaybolan kayit 7680 bozuk halkadan sonraki 4 nokta acilamaz; zincirde gereken saglam halka 7 ``` Üçüncü sütun zincirin fiyatını yazıyor: en yeni noktaya dönmek yedi halkanın yedisinin de sağlam olmasını istiyor. Bu sayı yalıtımda iyi, dayanıklılıkta kötüdür — bir sınırı geçmek için gereken kalemin çok olması istenir, bir kurtarma noktasını açmak için gereken halkanın çok olması istenmez. **Anlık görüntü zinciri uzadıkça geri dönüş kolaylaşmaz, tek bir noktaya daha çok bağlanır.** Dördüncü sütun geri dönüşün asıl bedelidir. Kırk iki günde altı yama olayı on yedi açık kapattı. Tabana dönmek bu on yedisini de yeniden açar; gün 38'deki noktaya dönmek yalnız ikisini. Aradaki fark bir tercih değil, bir çizelge sorunudur: yama gün 40'ta yapıldı, en yakın anlık görüntü gün 38'de alındı. **Geri dönüşün maliyeti dönülen noktanın yaşı değil, o nokta ile bugün arasında kaç yama olayı kaldığıdır.** Beşinci sütun daha sessiz bir kalem sayıyor. Geri dönüş yalnız açığı geri getirmez, dönülen nokta ile bugün arasında üretilmiş denetim kayıtlarını da siler. Tabana dönmek 10.080 kaydı, gün 38'e dönmek 960 kaydı götürür. Bir olayın ardından temiz bir duruma dönmek, o olayın izini taşıyan kayıtları da silmek anlamına gelir — bu yüzden geri dönüşten önce kayıtların konuk dışına kopyalanması ayrı bir adımdır. Son iki satır zincirin kırılganlığını gösteriyor. Üçüncü halka bozulduğunda ondan sonraki dört noktanın dördü de açılamaz hâle geliyor. Dönülebilen en yeni nokta otuz iki gün geriye, gün 10'a düşüyor; yeniden açılan açık ikiden on dörde çıkıyor, kaybolan kayıt 960'tan 7.680'e. Yedi kurtarma noktası vardı, tek bir bozuk halka bunların dördünü aynı anda götürdü. **Zincirdeki nokta sayısı bağımsız kurtarma noktası sayısı değildir.** #### Anlık Görüntünün Tutarlı Olduğu An Zincir tablosu her noktayı bir "durum" gibi saydı. Bu, sorulmamış bir soruyu içeriyor: anlık görüntü alındığı anda konuk **koşuyordu** ve konak diskin o anki hâlini aldı. Diskte olan ile bileşenlerin bellekte tuttuğu hâl aynı an değildir. ```js // tutarlilik.mjs — anlik goruntunun tutarli oldugu an ile bilesenlerin tutarli oldugu an (MODEL). // Konak duzeyinde alinan anlik goruntu diskin o anki halini alir; bellekte bekleyen yazma diskte yok. // [bilesen, tutarli olmasi icin gereken hazirlik duzeyi, geri yuklemede elle kurtarma adimi] const BILESEN = [['dosya sistemi ust verisi', 1, 1], ['dosya kuyrugu', 1, 1], ['veritabani sayfalari', 2, 3], ['bellekteki uygulama durumu', 3, 2]]; // [hazirlik duzeyi, ad, konuga verdigi kesinti (saniye)] const DUZEY = [[0, 'hicbir hazirlik', 0], [1, 'konuk icinde yazma bosaltma', 0.4], [2, 'uygulama duraklatma', 3.2], [3, 'konuk durdurma', 95]]; const s = (x, n) => String(x).padStart(n); console.log(`${'hazirlik'.padEnd(30)}${s('tutarli', 8)}${s('yarim', 7)}${s('kesinti sn', 12)}` + `${s('elle kurtarma adimi', 21)}`); for (const [d, ad, sn] of DUZEY) { const yarim = BILESEN.filter(([, g]) => g > d); console.log(`${ad.padEnd(30)}${s(`${BILESEN.length - yarim.length}/${BILESEN.length}`, 8)}` + `${s(yarim.length, 7)}${s(sn.toFixed(1), 12)}${s(yarim.reduce((t, [, , a]) => t + a, 0), 21)}`); } const tam = DUZEY.find(([d]) => BILESEN.every(([, g]) => g <= d)); console.log(`\ndort bilesenin dordu ancak "${tam[1]}" ile tutarli; kesinti ${tam[2]} saniye`); console.log(`hazirliksiz anlik goruntu ${BILESEN.filter(([, g]) => g > 0).length} kalemi yarim birakir; ` + `alma islemi yine de basarili doner`); ``` ``` hazirlik tutarli yarim kesinti sn elle kurtarma adimi hicbir hazirlik 0/4 4 0.0 7 konuk icinde yazma bosaltma 2/4 2 0.4 5 uygulama duraklatma 3/4 1 3.2 2 konuk durdurma 4/4 0 95.0 0 dort bilesenin dordu ancak "konuk durdurma" ile tutarli; kesinti 95 saniye hazirliksiz anlik goruntu 4 kalemi yarim birakir; alma islemi yine de basarili doner ``` Birinci satır dersin en yanıltıcı satırıdır: kesinti sıfır, alma işlemi başarılı döner ve dört bileşenin dördü de yarımdır. Konak, konuğun içinde ne olup bittiğini görmez; diskin o anki hâlini kopyalar ve işlemi tamamlanmış sayar. Konuk düzeyinde yazma boşaltma iki bileşeni tutarlı hâle getiriyor ve bunun bedeli 0,4 saniye. Veritabanı sayfaları ancak uygulamanın duraklatılmasıyla, bellekteki uygulama durumu ancak konuğun durdurulmasıyla tutarlı oluyor — doksan beş saniyelik bir kesinti karşılığında. Sağ sütun farkı geri yükleme tarafında yazıyor: hazırlıksız alınan bir anlık görüntüden dönüldüğünde yedi elle kurtarma adımı gerekir, uygulama duraklatılarak alınandan dönüldüğünde iki. **Anlık görüntünün tutarlı olduğu an konak için diskin dondurulduğu andır; veri katmanı için ise ancak bekleyen yazmaların diske indiği andır ve bu ikisi hazırlık yapılmadıkça aynı an değildir.** #### Sınırın Üç Sütunu Bu dersin sınırı yönetim işlemlerinin çizdiği sınırdır ve üç sütunu şöyle doldurur. Sınırın adı **klon ve anlık görüntü sınırıdır**. Sınırı geçmek için gereken kalem sayısı **birdir**: yirmi dört makinede ortak duran beş sır kaleminden herhangi biri. Sınır düştüğünde erişilen kalem sayısı **yirmi dört makinedir** — klonlama, tek kalemin arkasındaki makine sayısını çarpan işlemdir. Anlık görüntü bu tabloya ikinci bir satır ekliyor ve o satırda sayı ters yönde çalışıyor. Bir noktayı açmak için gereken sağlam halka yedidir; bu bir yalıtım kazancı değil, bir dayanıklılık borcudur. Geri dönüş ise sınırın geçilmesini değil, **daha önce kapatılmış sınırların yeniden açılmasını** sağlar: on yedi açığa kadar geriye gidilebilir ve bu, hiçbir kaçış yolu kullanılmadan yapılır. Üç ölçümün ortak yanı, hepsinin **yönetimi kolaylaştıran** işlemler olmasıdır. Klonlama yirmi dört makineyi bir imajdan kurar, anlık görüntü bir haftalık işi bir dosyaya sığdırır, geri dönüş bozulan bir sistemi saniyeler içinde çalışır hâle getirir. Üçünün de sınır kalemi aynı yerden gelir: bir makinenin durumunun **kopyalanabilir bir nesne** hâline gelmesi. O nesne kopyalandığında içindeki sır da kopyalanır, saklandığında o andaki yama düzeyi de saklanır, geri yüklendiğinde o düzeye dönülür. #### Özet - Altın imajdaki yedi sır kaleminin ikisi ilk açılışta yenilenir, beşi yirmi dört klonda aynı kalır; ortak kalem-makine çifti 120'dir. - Bir ortak sır kalemi için sınırı geçmek üzere gereken kalem birdir ve erişilen makine yirmi dörttür; yenilenmeyen tek kalem kalırsa bu sayı yine yirmi dörttür. - Beş kalemi de benzersizleştirmenin bedeli klon başına altı ilk açılış adımı ve üç servis yeniden başlatma, park genelinde 144 adımdır. - Yedi noktalı artımlı zincirde en yeni noktayı açmak yedi halkanın sağlam olmasını ister; üçüncü halka bozulduğunda dört nokta birden açılamaz hâle gelir. - Geri dönüş dönülen nokta ile bugün arasındaki yamaları geri alır: tabana dönmek 17 açığı yeniden açar ve 10.080 denetim kaydını siler, gün 38'e dönmek 2 açığı açar ve 960 kaydı siler. - Hazırlıksız alınan anlık görüntüde dört bileşenin dördü yarımdır ve geri yükleme yedi elle adım ister; dördünün de tutarlı olması konuğun durdurulmasını ve 95 saniyelik kesintiyi ister. #### Sonraki Adım Buraya kadarki üç ders aynı soruyu tek bir teknolojide sordu: konuk sistemin sınırı nerede, kaç kalemle geçiliyor, geçilirse neye erişiliyor. Aynı iş için ikinci bir yol daha var ve o yolda konuk sistem hiç yok: aynı çekirdeğin üzerinde birbirinden ayrılmış süreçler koşuyor. İki yol aynı işi yapıyorsa aynı ölçüyle karşılaştırılabilir. Sonraki ders bunu yapar: aynı sekiz hedef için sınırı geçmek üzere gereken kalem sayısı konuk sistemde kaç, aynı çekirdeği paylaşan bölmede kaç; paylaşılan çekirdek kaç kalem paylaşımı demek ve iki sayının farkı nereden geliyor. ### Konteyner ile Karşılaştırma Source: https://academia.sh/tr/kurslar/bt-temelleri/konteyner-ile-karsilastirma Aynı yalıtım sorusunun iki teknolojide sınırı geçmek için gereken kalem cinsinden ölçülmesi: konuk sistemin beş, aynı çekirdeği paylaşan bölmenin on iki zorunlu paylaşılan kalemi, sekiz hedefin her birinde aynı anda yanlış olması gereken kalem sayısı, tek kalemle geçilen hedef sayısı ve gereken kalemlerin tek bir kalemde yoğunlaşması. Önceki üç ders aynı soruyu tek bir teknolojide sordu: konuk sistemin sınırı nerede, kaç kalemle geçiliyor, geçilirse neye erişiliyor. Aynı iş için ikinci bir yol daha var ve o yolda konuk sistem hiç yok: aynı çekirdeğin üzerinde birbirinden ayrılmış bölmeler koşuyor. Bölgesel ölçüm ağının şube sunucularında iki düzen de kullanılıyor — doğrulayıcı bir konuk sistemde, okuma toplayıcının üç kopyası aynı çekirdeği paylaşan bölmelerde. Bu ders iki teknolojiyi hız, boyut ya da işletme kolaylığı üzerinden karşılaştırmaz; o ölçümler Konteynerler kursunda yapıldı ve tekrarlanmaz. Buradaki tek soru yalıtım gücüdür ve o güç bu kursun ölçü birimiyle yazılır: **sınırı geçmek için aynı anda yanlış olması gereken kalem sayısı.** İki teknoloji aynı hedef kümesinde bu sayıyla karşılaştırılır. **SA20 — Karşılaştırma aynı işi yapan iki düzen arasındadır**: bir konuk sistem ve aynı çekirdeği paylaşan bir bölme. **SA21 — Konuk sistemin zorunlu beş paylaşılan kalemi önceki dersten girdidir**; bölmenin listesi aynı ölçüyle sayılır. **SA22 — Bir ad alanı görünümü ayırır, kaynağı ayırmaz**; bu ayrım kalem sayımında ayrı sütun olarak tutulur. **SA23 — Hedef kümesi sekiz kalemdir** ve her hedef için gereken kalemler adıyla yazılır; kalem adları modeldir, sayım gerçektir. **SA24 — Yoğunlaşma, aynı kalemin kaç hedefte geçtiğidir.** **SA25 — Erişim evreni 52 kalemdir**: dört iş yükünün dokuzar kalemi, konağın on üç kalemi ve üç ayar kalemi. #### Paylaşılan Kalem Sayısı İki düzen aynı konak üzerinde koşarken farklı sayıda kalem paylaşır. Konuk sistemde paylaşım hipervizörün açtığı kadardır; bölmede paylaşım çekirdeğin kendisidir. ```js // bolme.mjs — konuk sistem ile ayni cekirdegi paylasan bolmenin konakla paylastigi kalem (MODEL). // Konuk sistemin zorunlu bes kalemi onceki dersten girdidir; bolme ayni olcuyle sayilir. export const KONUK = [['zamanlayici', false], ['islemci onbellegi', false], ['saat kaynagi', false], ['disk denetleyicisi oykunmesi', false], ['ag arayuzu oykunmesi', false]]; // [kalem, gorunumu bir ad alani ayiriyor mu] — kaynak her satirda ortaktir export const BOLME = [['zamanlayici', false], ['islemci onbellegi', false], ['saat kaynagi', false], ['sistem cagrisi yuzeyi', false], ['cekirdek veri yapilari', false], ['sayfa onbellegi', false], ['cekirdek gunluk arabellegi', false], ['cekirdek modul kumesi', false], ['surec numarasi uzayi', true], ['kullanici kimligi uzayi', true], ['ag yigini', true], ['dosya sistemi gorunumu', true]]; if (import.meta.url === `file://${process.argv[1]}`) { const s = (x, n) => String(x).padStart(n); console.log(`${'teknoloji'.padEnd(34)}${s('paylasilan kalem', 18)}${s('gorunumu ayrilan', 18)}` + `${s('kaynagi ortak', 15)}`); for (const [ad, liste] of [['konuk sistem', KONUK], ['ayni cekirdegi paylasan bolme', BOLME]]) console.log(`${ad.padEnd(34)}${s(liste.length, 18)}` + `${s(liste.filter(([, a]) => a).length, 18)}${s(liste.length, 15)}`); const ayrilmayan = BOLME.filter(([, a]) => !a).map(([k]) => k); console.log(`\nbolmede gorunumu ayrilmayan ${ayrilmayan.length} kalem:`); for (let i = 0; i < ayrilmayan.length; i += 4) console.log(` ${ayrilmayan.slice(i, i + 4).join(', ')}`); console.log(`oran: bolme / konuk = ${(BOLME.length / KONUK.length).toFixed(1)} kat paylasilan kalem`); } ``` ``` teknoloji paylasilan kalem gorunumu ayrilan kaynagi ortak konuk sistem 5 0 5 ayni cekirdegi paylasan bolme 12 4 12 bolmede gorunumu ayrilmayan 8 kalem: zamanlayici, islemci onbellegi, saat kaynagi, sistem cagrisi yuzeyi cekirdek veri yapilari, sayfa onbellegi, cekirdek gunluk arabellegi, cekirdek modul kumesi oran: bolme / konuk = 2.4 kat paylasilan kalem ``` Bölme 2,4 kat kalem paylaşıyor. Bu oran tek başına bir sonuç değil, bir tabandır: paylaşılan her kalem bir yol adayıdır ve aday sayısı beşten on ikiye çıkmıştır. Konuk sistemin beş kaleminin ikisi bir öykünme kodudur — yani konak tarafında koşan, sınırlı ve tek amaçlı bir yazılım parçası. Bölmenin on iki kalemi ise doğrudan çekirdeğin kendisidir; araya konan bir öykünme katmanı yoktur. İkinci sütun daha ilginç. On iki kalemin yalnız dördünde bir ad alanı görünümü ayırıyor: süreç numarası, kullanıcı kimliği, ağ yığını, dosya sistemi görünümü. Kalan sekizde ayrı bir görünüm bile yok — zamanlayıcı, işlemci önbelleği, saat, sistem çağrısı yüzeyi, çekirdek veri yapıları, sayfa önbelleği, çekirdek günlük arabelleği ve çekirdek modül kümesi bölme için de konak için de aynı nesnedir. Üçüncü sütun ise ayrımı bitiriyor: on iki kalemin on ikisinde **kaynak ortaktır**. Ad alanı olan dört kalemde bile ayrılan şey görünümdür; altta duran sayı uzayı ve veri yapısı tektir. #### Sekiz Hedef, İki Sayı Paylaşılan kalem sayısı yalıtım gücü değildir; yalıtım gücü belirli bir hedefe ulaşmak için aynı anda yanlış olması gereken kalem sayısıdır. Aşağıdaki koşum aynı sekiz hedefi iki düzende yazıyor. ```js // hedef.mjs — ayni sekiz hedef iki teknolojide: siniri gecmek icin ayni anda yanlis olmasi // gereken kalemler. Kalem adlari model, sayim gercektir. const HEDEF = [ ['komsunun dosyalarini okuma', ['hipervizor kusuru', 'komsu imajina erisim'], ['cekirdek kusuru']], ['komsunun bellegini okuma', ['hipervizor kusuru', 'bellek yalitimi hatasi'], ['cekirdek kusuru', 'surec izleme yetkisi']], ['konak dosya sistemine yazma', ['hipervizor kusuru', 'konak yazma yetkisi'], ['yazilabilir takma']], ['konak cekirdeginde kod calistirma', ['hipervizor kusuru', 'konak cekirdek kusuru'], ['cekirdek kusuru']], ['konak saatini degistirme', ['hipervizor kusuru', 'konak saat yetkisi'], ['saat degistirme yetkisi']], ['komsuyu kaynak tuketerek durdurma', ['acik kalan kaynak siniri'], ['acik kalan kaynak siniri']], ['konagin sirlarini okuma', ['hipervizor kusuru', 'konak dosya erisimi'], ['sir dosyasinin takilmasi', 'okuma izni']], ['konak agindaki bir uca ulasma', ['acik ag yolu'], ['acik ag yolu']], ]; const AD = ['konuk sistem', 'bolme']; const s = (x, n) => String(x).padStart(n); console.log(`${'hedef'.padEnd(36)}${s(AD[0], 14)}${s(AD[1], 8)}`); for (const [h, a, b] of HEDEF) console.log(`${h.padEnd(36)}${s(a.length, 14)}${s(b.length, 8)}`); const gereken = (i) => HEDEF.reduce((t, h) => t + h[i + 1].length, 0); const tek = (i) => HEDEF.filter((h) => h[i + 1].length === 1).length; console.log(`${'toplam gereken kalem'.padEnd(36)}${s(gereken(0), 14)}${s(gereken(1), 8)}`); console.log(`${'tek kalemle gecilen hedef'.padEnd(36)}${s(tek(0), 14)}${s(tek(1), 8)}`); for (let i = 0; i < 2; i++) { // yogunlasma: en sik gecen kalem const hepsi = HEDEF.flatMap((h) => h[i + 1]); const [kalem, n] = [...new Set(hepsi)].map((k) => [k, hepsi.filter((x) => x === k).length]) .sort((a, b) => b[1] - a[1])[0]; const sonra = HEDEF.filter((h) => h[i + 1].filter((k) => k !== kalem).length <= 1).length; console.log(`\n${AD[i]}: en sik kalem "${kalem}" ${n}/${HEDEF.length} hedefte`); console.log(`o kalem yerindeyse tek kalemle gecilen hedef ${tek(i)} -> ${sonra}`); } ``` ``` hedef konuk sistem bolme komsunun dosyalarini okuma 2 1 komsunun bellegini okuma 2 2 konak dosya sistemine yazma 2 1 konak cekirdeginde kod calistirma 2 1 konak saatini degistirme 2 1 komsuyu kaynak tuketerek durdurma 1 1 konagin sirlarini okuma 2 2 konak agindaki bir uca ulasma 1 1 toplam gereken kalem 14 10 tek kalemle gecilen hedef 2 6 konuk sistem: en sik kalem "hipervizor kusuru" 6/8 hedefte o kalem yerindeyse tek kalemle gecilen hedef 2 -> 8 bolme: en sik kalem "cekirdek kusuru" 3/8 hedefte o kalem yerindeyse tek kalemle gecilen hedef 6 -> 7 ``` Beklenen fark tabloda var: sekiz hedefin altısı bölmede tek kalemle geçiliyor, konuk sistemde ikisi. Toplam gereken kalem on dörde karşı on. Bir hedefe ulaşmak için ortalama olarak konuk sistemde 1,75, bölmede 1,25 kalemin aynı anda yanlış olması gerekiyor. Eşit çıkan iki satır bu farkın nereden **gelmediğini** gösteriyor. Kaynak tüketerek komşuyu durdurmak ve konak ağındaki bir uca ulaşmak iki düzende de tek kalem istiyor, çünkü bu iki hedef yalıtım sınırına değil bir yapılandırma kalemine bağlıdır: kaynak sınırı açık bırakılmışsa ve ağ yolu açıksa sınırın türü sonucu değiştirmiyor. **Yalıtım teknolojisi seçmek, yapılandırma kaleminin açık kalmasını telafi etmiyor.** Son iki bölüm ise tablonun kendisini düzeltiyor. Konuk sistemdeki altı "iki kalem" bağımsız değil: altısı da aynı ikinci kaleme, **hipervizör kusuruna** bağlı. O kalem yerindeyse tek kalemle geçilen hedef sayısı ikiden **sekize** çıkıyor — yani konuk sistemin yalıtımı sekiz hedefte birden tek bir kalemin doğruluğuna dayanıyor. Bölmede aynı yoğunlaşma yok: en sık kalem üç hedefte geçiyor ve o kalem yerindeyken tek kalemle geçilen hedef altıdan yediye çıkıyor, sekize değil. İki teknolojinin ayrıldığı yer budur. **Konuk sistem daha yüksek ama daha yoğunlaşmış bir sayı verir: sekiz hedefin altısı tek bir kaleme bağlıdır. Bölme daha düşük ama daha dağınık bir sayı verir: altı ayrı hedef beş ayrı kaleme bağlıdır.** Birincisinde savunmanın gideceği yer bellidir ve tektir; ikincisinde beş ayrı kalem ayrı ayrı doğru tutulmalıdır. #### Sınır Düştüğünde Erişilen Kalem Gereken kalem sayısı üç sütunun ikincisidir; üçüncüsü sınır bir kez geçildiğinde kaç kaleme erişildiğidir. Bu sayı yerleşimden gelir ve iki teknoloji arasında değil, üç düzen arasında ayrılır. ```js // dusus.mjs — sinir dustugunde erisilen kalem, uc yerlesim duzeninde (MODEL). // Kurgu sube sunucusu: dort is yuku, her biri 6 dosya ve 3 bellek kalemi tasiyor. const IS = 4, DOSYA = 6, BELLEK = 3, KONAK_FS = 9, KONAK_SIR = 4, AYAR = 3; const TOPLAM = IS * (DOSYA + BELLEK) + KONAK_FS + KONAK_SIR + AYAR; // [duzen, siniri gecmek icin gereken kalem, ilk dususte erisilen kalem, bakimda yama kalemi] const DUZEN = [ ['tek konuk sistemde 4 is yuku', 2, IS * (DOSYA + BELLEK) + AYAR, 2], ['tek konakta 4 bolme', 1, TOPLAM, 1], ['is yuku basina konuk sistem + bolme', 1, DOSYA + BELLEK, 5], [' ayni duzende konak duzeyine', 3, IS * (DOSYA + BELLEK) + AYAR, 5], ]; const s = (x, n) => String(x).padStart(n); console.log(`evren ${TOPLAM} kalem: ${IS} is yuku x ${DOSYA + BELLEK}, konak ${KONAK_FS + KONAK_SIR}, ayar ${AYAR}`); console.log(`\n${'duzen'.padEnd(38)}${s('gereken', 8)}${s('erisilen', 10)}${s('yama kalemi', 13)}`); for (const [ad, g, e, y] of DUZEN) console.log(`${ad.padEnd(38)}${s(g, 8)}${s(`${e}/${TOPLAM}`, 10)}${s(y, 13)}`); const [, , enaz] = DUZEN.reduce((a, b) => (b[2] < a[2] ? b : a)); console.log(`\nen dar ilk dusus ${enaz}/${TOPLAM} (%${((100 * enaz) / TOPLAM).toFixed(1)}), ` + `bedeli ${DUZEN[2][3] - DUZEN[1][3]} ek yama kalemi`); ``` ``` evren 52 kalem: 4 is yuku x 9, konak 13, ayar 3 duzen gereken erisilen yama kalemi tek konuk sistemde 4 is yuku 2 39/52 2 tek konakta 4 bolme 1 52/52 1 is yuku basina konuk sistem + bolme 1 9/52 5 ayni duzende konak duzeyine 3 39/52 5 en dar ilk dusus 9/52 (%17.3), bedeli 4 ek yama kalemi ``` İlk iki satır önceki tablonun sonucunu erişim tarafında tekrarlıyor: dört bölme tek konakta koştuğunda sınır bir kalemle geçilir ve elli iki kalemin elli ikisine erişilir; dört iş yükü bir konuk sistemde koştuğunda sınır iki kalem ister ve otuz dokuz kaleme erişilir. Bölmede erişilen kalemin evrenin tamamı olmasının nedeni yapısaldır: sınırı çizen katman çekirdektir ve o çekirdek konağın kendisidir; onu geçen, konağın dosya sistemine ve sırlarına da geçmiş olur. Üçüncü satır iki teknolojinin karşıt değil, **üst üste** konabildiğini gösteriyor. Her iş yükü kendi konuk sisteminde bir bölme içinde koştuğunda ilk düşüşte erişilen kalem elli ikinin dokuzu — yüzde 17,3 — çünkü o bölmeden çıkan yalnız kendi konuk sisteminin içine çıkar. Konak düzeyine ulaşmak için gereken kalem üçe çıkıyor: bölme sınırının bir kalemi ile konuk sisteminin iki kalemi toplanıyor. **Katmanlar üst üste konduğunda gereken kalem toplanır; bu, kursta gereken kalemin üçe çıktığı tek düzendir.** Sağ sütun bedeli yazıyor. Tek konakta dört bölme bir yama kalemi ister — tek çekirdek. Üç numaralı düzen beş yama kalemi ister: bir hipervizör ve dört ayrı konuk çekirdeği. Dört ek yama kalemi, sürekli ve tekrar eden bir iştir; erişilen kalemi 52'den 9'a indirmenin karşılığı budur. #### Sayının Okunma Biçimi Bu ölçüm bir teknolojiyi öbürüne yeğlemeyi söylemiyor, iki farklı savunma programı tarif ediyor. Konuk sistemde program tek kalemlidir ve o kalem hipervizördür: yamalı tutulması, yönetim arayüzünün ayrılması, üzerinde başka iş çalıştırılmaması. Bu programın tamamı bir bileşene bakar ve o bileşen düştüğünde sekiz hedefin sekizi tek kalemle geçilir. Yoğunlaşmanın hem gücü hem zayıflığı budur. Bölmede program altı kalemlidir: çekirdeğin yamalı olması, takmanın salt okunur bırakılması, saat yetkisinin verilmemesi, süreç izleme yetkisinin kapatılması, kaynak sınırının konması, ağ yolunun kapatılması. Altısı ayrı ayrı doğru tutulduğunda tek kalemle geçilen hedef sayısı düşer; biri unutulduğunda o hedef tek kalemle geçilir ve ötekiler bunu telafi etmez. Kalan iki satır ikisinde de aynı: kaynak sınırı ve ağ yolu. Bu iki kalem yalıtım teknolojisinin dışındadır ve iki düzende de tek başına yeterlidir. Üçüncü tablo bu iki programın birbirini dışlamadığını gösteriyor. İş yükünü kendi konuk sistemi içindeki bir bölmede koşturmak iki programı da yürütmeyi gerektirir — hipervizör de çekirdek de yamalı tutulacaktır, beş yama kalemi — ama karşılığında ilk düşüşte erişilen kalemi elli ikinin dokuzuna indirir ve konak düzeyine ulaşmak için gereken kalemi üçe çıkarır. **Bu kursta gereken kalemin üçe çıktığı tek satır budur ve bir teknoloji seçiminden değil, iki teknolojinin üst üste konmasından gelir.** Bir sonraki dersin ölçüsü aynı kalem evreninden başlayacak: sınır düştüğünde geriye ne kaldığı sorusu, sınırın türünden bağımsızdır. #### Özet - Konuk sistem konakla beş zorunlu kalem paylaşır, aynı çekirdeği paylaşan bölme on iki; oran 2,4 kattır. - Bölmedeki on iki kalemin yalnız dördünde bir ad alanı görünümü ayırır ve on ikisinde de kaynak ortaktır; kalan sekizde ayrı bir görünüm bile yoktur. - Sekiz hedefte toplam gereken kalem konuk sistemde 14, bölmede 10'dur; tek kalemle geçilen hedef sayısı 2'ye karşı 6'dır. - İki hedef — kaynak tüketerek durdurma ve konak ağındaki uca ulaşma — iki düzende de tek kalem ister, çünkü yalıtım sınırına değil bir yapılandırma kalemine bağlıdır. - Konuk sistemdeki altı "iki kalem" bağımsız değildir: altısı da hipervizör kusuruna bağlıdır ve o kalem yerindeyse tek kalemle geçilen hedef 2'den 8'e çıkar. Bölmede en sık kalem 3 hedefte geçer ve sayı 6'dan 7'ye çıkar. - İlk düşüşte erişilen kalem üç düzende 39/52, 52/52 ve 9/52'dir; iş yükü başına konuk sistem içinde bölme düzeninde konak düzeyine ulaşmak üç kalem ister ve bedeli dört ek yama kalemidir. #### Sonraki Adım Dört ders boyunca sınır hep aynı yönden ölçüldü: birinin sınırı geçmesi durumunda ne olacağı. Sınırın düşmesinin tek yolu bu değil. Bir disk arızalanır, bir dosya yanlışlıkla silinir, bir konak açılmaz hâle gelir — ve bu durumlarda sınırı geçen kimse yoktur, yine de konuk kaybolur. Sanallaştırmanın bu soruya iki ayrı karşılığı var: anlık görüntü ve yedek. İkisi de "geri getirir" diye anılıyor ve ikisi aynı şeyi getirmiyor. Son ders ikisini aynı kayıp senaryosunda koşturup kurtarılan ve kurtarılamayan kalemi ayrı ayrı sayar, tam, artımlı ve ayrımsal yedeğin zincir bozulduğunda dönülebilen noktasını hesaplar ve kursu on bir dersin sınır tablosuyla kapatır. ### Yedekleme ve Dayanıklılık Source: https://academia.sh/tr/kurslar/bt-temelleri/yedekleme-ve-dayaniklilik Anlık görüntü ile yedeğin aynı yedi kayıp senaryosunda koşturulması: anlık görüntünün üç senaryoda 8/8, yedeğin yedi senaryoda 6/8 kalem getirmesi, ikisinin birlikte 56 kalemin 48'ini kurtarması, tam, artımlı ve ayrımsal yedekte bir dosya bozulduğunda kaybolan nokta sayısının 1, 18 ve 1 olması ve depolamanın 1.120, 91,3 ve 758,2 GiB'a ayrılması. Dört ders boyunca sınır hep aynı yönden ölçüldü: birinin sınırı geçmesi durumunda ne olacağı. Sınırın düşmesinin tek yolu bu değil. Bir depolama birimi arızalanır, bir konuk yanlışlıkla silinir, bir konak açılmaz hâle gelir — sınırı geçen kimse yoktur, yine de konuk kaybolur. Sanallaştırmanın bu soruya iki karşılığı var ve ikisi de "geri getirir" diye anılıyor: **anlık görüntü** ve **yedek**. İkisi aynı şeyi getirmiyor. Anlık görüntü konakta, konuk imajının durduğu depolama biriminin üzerinde durur ve saklaması kısadır; yedek konak dışında durur, saklaması uzundur ve kapsamı bir listeyle sınırlıdır. Bu ders ikisini aynı yedi senaryoda koşturup **kurtarılan ve kurtarılamayan kalemi ayrı ayrı** sayar. **SA26 — Kurgu doğrulayıcı konuğu sekiz kalem taşır.** **SA27 — Anlık görüntü konakta, konuk imajının depolama biriminde durur**; saklama 7 gün, alım aralığı 1 saattir. **SA28 — Yedek konak dışında durur**; saklama 90 gün, alım aralığı 24 saattir. **SA29 — Yedeğin kapsamı dışında iki kalem vardır**: yerel sırlar ve bellekteki oturum durumu; bu kapsam boşluğu Sunucu Yönetimi ve Sertleştirme kursunda ölçülmüştü, burada girdidir. **SA30 — Bir yöntem, o senaryoda çalışıyorsa kapsamındaki bütün kalemleri getirir.** **SA31 — Yedek zinciri 28 günlük bir penceredir**; boyutlar kurgudur. #### Aynı Kayıp Senaryosunda İki Yöntem ```js // kayip.mjs — ayni kayip senaryolarinda anlik goruntu ile yedek: kurtarilan ve kurtarilamayan kalem. // Kurgu dogrulayici konugu 8 kalem tasir. Kapsam bosluklari onceki kurstan girdidir. const KALEM = ['isletim sistemi kok dosyalari', 'uygulama ikilileri', 'yapilandirma', 'veritabani sayfalari', 'is emri kuyrugu', 'denetim gunlugu', 'yerel sirlar', 'bellekteki oturum durumu']; const DISI = ['yerel sirlar', 'bellekteki oturum durumu']; // yedegin kapsami disinda const ANLIK = { kapsam: KALEM.length, saklama: 7, pencere: 1 }; // konakta, ayni depolama biriminde const YEDEK = { kapsam: KALEM.length - DISI.length, saklama: 90, pencere: 24 }; // [senaryo, kaybin yasi (gun), depolama birimi kayboldu, konak kayboldu, konuk nesnesi silindi] const SENARYO = [ ['konuk dosya sisteminin bozulmasi', 0, false, false, false], ['yanlis yapilandirma (2 saat once)', 0, false, false, false], ['konuk icindeki dosyalarin sifrelenmesi', 0, false, false, false], ['30 gun once silinen kayit', 30, false, false, false], ['depolama biriminin kaybi', 0, true, false, false], ['konak makinenin kaybi', 0, false, true, false], ['yonetim arayuzunden silinen konuk', 0, false, false, true], ]; const anlikOk = ([, yas, b, k, s]) => !b && !k && !s && yas <= ANLIK.saklama; const yedekOk = ([, yas]) => yas <= YEDEK.saklama; const s = (x, n) => String(x).padStart(n); console.log(`${KALEM.length} kalem; anlik goruntu kapsami ${ANLIK.kapsam}, saklama ${ANLIK.saklama} gun; ` + `yedek kapsami ${YEDEK.kapsam}, saklama ${YEDEK.saklama} gun`); console.log(`\n${'senaryo'.padEnd(40)}${s('anlik goruntu', 15)}${s('yedek', 8)}${s('en iyisi', 10)}`); let a = 0, y = 0, en = 0; for (const sen of SENARYO) { const ka = anlikOk(sen) ? ANLIK.kapsam : 0, ky = yedekOk(sen) ? YEDEK.kapsam : 0; a += ka; y += ky; en += Math.max(ka, ky); console.log(`${sen[0].padEnd(40)}${s(`${ka}/${KALEM.length}`, 15)}${s(`${ky}/${KALEM.length}`, 8)}` + `${s(`${Math.max(ka, ky)}/${KALEM.length}`, 10)}`); } const T = SENARYO.length * KALEM.length; console.log(`${'toplam'.padEnd(40)}${s(`${a}/${T}`, 15)}${s(`${y}/${T}`, 8)}${s(`${en}/${T}`, 10)}`); console.log(`\nanlik goruntu ${SENARYO.filter(anlikOk).length}/${SENARYO.length} senaryoda calisir, ` + `calistiginda ${ANLIK.kapsam}/${KALEM.length} kalem getirir`); console.log(`yedek ${SENARYO.filter(yedekOk).length}/${SENARYO.length} senaryoda calisir, ` + `her seferinde ${DISI.length} kalem kapsam disi: ${DISI.join(', ')}`); console.log(`ikisi birlikte ${en}/${T}; kurtarilamayan ${T - en} kalem`); console.log(`veri kaybi penceresi: anlik goruntu ${ANLIK.pencere} saat, yedek ${YEDEK.pencere} saat`); ``` ``` 8 kalem; anlik goruntu kapsami 8, saklama 7 gun; yedek kapsami 6, saklama 90 gun senaryo anlik goruntu yedek en iyisi konuk dosya sisteminin bozulmasi 8/8 6/8 8/8 yanlis yapilandirma (2 saat once) 8/8 6/8 8/8 konuk icindeki dosyalarin sifrelenmesi 8/8 6/8 8/8 30 gun once silinen kayit 0/8 6/8 6/8 depolama biriminin kaybi 0/8 6/8 6/8 konak makinenin kaybi 0/8 6/8 6/8 yonetim arayuzunden silinen konuk 0/8 6/8 6/8 toplam 24/56 42/56 48/56 anlik goruntu 3/7 senaryoda calisir, calistiginda 8/8 kalem getirir yedek 7/7 senaryoda calisir, her seferinde 2 kalem kapsam disi: yerel sirlar, bellekteki oturum durumu ikisi birlikte 48/56; kurtarilamayan 8 kalem veri kaybi penceresi: anlik goruntu 1 saat, yedek 24 saat ``` İki sütun iki farklı biçimde eksik. Anlık görüntü **çalıştığı yerde tam**, çalışmadığı yerde sıfırdır: üç senaryoda sekiz kalemin sekizini getirir, dört senaryoda hiçbirini. Sıfırların üçü aynı sebepten gelir — anlık görüntü kaybolan şeyin **yanında** durur: depolama birimi, konak ya da konuk nesnesi gittiğinde anlık görüntüler de gider. Dördüncüsünün sebebi başkadır; otuz gün önceki kayıt yedi günlük saklamanın dışındadır. Yedek **her yerde eksik**: yedisinde de çalışır ve her seferinde altı kalem getirir. Kaçırdığı iki kalem adıyla yazılıdır — yerel sırlar ve bellekteki oturum durumu — ve senaryodan bağımsız olarak kapsam dışıdır. **Anlık görüntünün eksiği koşula bağlıdır, yedeğinki kapsama.** Alt satırlar toplamı veriyor: anlık görüntü 24/56, yedek 42/56, her senaryoda iyisi seçildiğinde 48/56. İki yöntem birbirinin yerine geçmiyor, birbirinin boşluğunu dolduruyor — ama kalan sekiz kalem hiçbir düzende gelmiyor ve hepsi anlık görüntünün çalışmadığı dört senaryodaki kapsam dışı kalemlerdir. Bunun üstüne veri kaybı penceresi eklenir: anlık görüntü bir, yedek yirmi dört saat. #### Zincir Bozulduğunda Dönülebilen Nokta Yedek de tek bir dosya değildir. Her gün tam kopya almak en pahalı düzendir; artımlı ve ayrımsal düzenler maliyeti düşürür ve karşılığında noktaları birbirine bağlar. ```js // yedekzincir.mjs — tam, artimli ve ayrimsal yedekte zincir bozuldugunda donulebilen nokta (MODEL). // 28 gunluk pencere; gun 0'da tam yedek, sonraki her gun bir nokta. Boyutlar kurgudur. const GUN = 28, TAM_GIB = 40, DELTA_GIB = 1.9, BOZUK = 10; // nokta d'yi acmak icin gereken dosyalar (gun numaralari) const GEREKEN = { tam: (d) => [d], artimli: (d) => Array.from({ length: d + 1 }, (_, i) => i), ayrimsal: (d) => (d === 0 ? [0] : [0, d]), }; const BOYUT = { tam: () => GUN * TAM_GIB, artimli: () => TAM_GIB + (GUN - 1) * DELTA_GIB, ayrimsal: () => TAM_GIB + DELTA_GIB * ((GUN - 1) * GUN) / 2, }; const kayip = (tur, bozuk) => Array.from({ length: GUN }, (_, d) => d) .filter((d) => GEREKEN[tur](d).includes(bozuk)); const s = (x, n) => String(x).padStart(n); console.log(`${GUN} gun, gun 0'da tam yedek; tam ${TAM_GIB} GiB, gunluk delta ${DELTA_GIB} GiB`); console.log(`\n${'tur'.padEnd(11)}${s('dosya', 6)}${s('nokta basina dosya', 20)}` + `${s(`gun ${BOZUK} bozuk: kayip`, 22)}${s('donulebilen en yeni', 21)}${s('depolama GiB', 14)}`); for (const tur of Object.keys(GEREKEN)) { const n = Array.from({ length: GUN }, (_, d) => GEREKEN[tur](d).length); const k = kayip(tur, BOZUK); const saglam = Array.from({ length: GUN }, (_, d) => d).filter((d) => !k.includes(d)); console.log(`${tur.padEnd(11)}${s(GUN, 6)}${s(n[0] === n[GUN - 1] ? n[0] : `${Math.min(...n)}-${Math.max(...n)}`, 20)}` + `${s(`${k.length} nokta`, 22)}${s(`gun ${Math.max(...saglam)}`, 21)}${s(BOYUT[tur]().toFixed(1), 14)}`); } console.log(`\ntam yedek (gun 0) bozulursa kaybolan nokta: ` + Object.keys(GEREKEN).map((t) => `${t} ${kayip(t, 0).length}`).join(', ')); console.log(`ayrimsal, artimliya gore ${(BOYUT.ayrimsal() / BOYUT.artimli()).toFixed(1)} kat depolama ister` + ` ve gun ${BOZUK} bozuldugunda ${kayip('artimli', BOZUK).length - kayip('ayrimsal', BOZUK).length}` + ' nokta daha kurtarir'); ``` ``` 28 gun, gun 0'da tam yedek; tam 40 GiB, gunluk delta 1.9 GiB tur dosya nokta basina dosya gun 10 bozuk: kayip donulebilen en yeni depolama GiB tam 28 1 1 nokta gun 27 1120.0 artimli 28 1-28 18 nokta gun 9 91.3 ayrimsal 28 1-2 1 nokta gun 27 758.2 tam yedek (gun 0) bozulursa kaybolan nokta: tam 1, artimli 28, ayrimsal 28 ayrimsal, artimliya gore 8.3 kat depolama ister ve gun 10 bozuldugunda 17 nokta daha kurtarir ``` Üç türün nokta sayısı aynı: yirmi sekiz. Fark noktaların birbirine ne kadar bağlı olduğudur. Tam düzende her nokta bir dosyadır ve bir dosyanın bozulması yalnız o noktayı götürür. Artımlı düzende gün 27'yi açmak yirmi sekiz dosyanın yirmi sekizini ister; gün 10'daki tek dosya bozulduğunda on sekiz nokta birden gider ve dönülebilen en yeni nokta gün 9'a düşer. Ayrımsal düzende her nokta iki dosyadır ve gün 10'un bozulması yalnız gün 10'u götürür. Depolama sütunu takası yazıyor: 1.120, 91,3 ve 758,2 GiB. Artımlı düzen en ucuzu ve en kırılganıdır; ayrımsal düzen 8,3 kat depolama karşılığında aynı bozulmada on yedi nokta daha kurtarır. **Yedek türü bir depolama kararı gibi görünür; ölçüldüğünde bir bağımlılık kararı olduğu çıkar.** Üçünün ortak zayıflığı son satırdadır: tam yedeğin kendisi bozulursa artımlı ve ayrımsal düzenlerde yirmi sekiz noktanın yirmi sekizi birden gider. #### Kopyanın Nerede Durduğu Zincir bağımlılığı ölçüldü; kopyanın **nerede** durduğu ayrı bir sayıdır. Aynı senaryolar bu kez kopya kümesi üzerinde koşuyor. ```js // kopya.mjs — kopya dagilimi: hangi senaryoda kac kopya hayatta kaliyor (MODEL). // [ad, konum, cevrimici mi, ayni yonetim kimligiyle silinebilir mi, kurtarma dakikasi] const KOPYA = [ ['konak anlik goruntusu', 'konak', true, true, 8], ['sube sunucusunda yedek', 'sube', true, true, 45], ['merkez nesne deposunda yedek', 'merkez', true, true, 210], ['merkezde cevrimdisi kopya', 'merkez', false, false, 720], ]; const SENARYO = [ ['konak makinenin kaybi', (k) => k[1] === 'konak'], ['sube tesisinin kaybi', (k) => k[1] === 'konak' || k[1] === 'sube'], ['merkez nesne deposunun kaybi', (k) => k[1] === 'merkez' && k[2]], ['yonetim kimliginin ele gecirilmesi', (k) => k[3]], ['konuk icindeki dosyalarin sifrelenmesi', () => false], ]; const kalan = (liste, yiten) => liste.filter((k) => !yiten(k)); const s = (x, n) => String(x).padStart(n); console.log(`${'senaryo'.padEnd(40)}${s('kalan', 7)} en hizli kurtarma`); let enkotu = KOPYA.length; for (const [ad, yiten] of SENARYO) { const k = kalan(KOPYA, yiten); const hizli = k.length ? k.reduce((a, b) => (b[4] < a[4] ? b : a)) : null; enkotu = Math.min(enkotu, k.length); console.log(`${ad.padEnd(40)}${s(`${k.length}/${KOPYA.length}`, 7)} ` + (hizli ? `${hizli[0]} (${hizli[4]} dk)` : 'yok')); } const konum = new Set(KOPYA.map((k) => k[1])).size; console.log(`\n${KOPYA.length} kopya, ${konum} konum; en kotu senaryoda kalan ${enkotu}`); const cevrimici = KOPYA.filter((k) => k[2]); const sonra = Math.min(...SENARYO.map(([, y]) => kalan(cevrimici, y).length)); console.log(`cevrimdisi kopya cikarilinca kopya ${KOPYA.length} -> ${cevrimici.length}, ` + `en kotu senaryoda kalan ${enkotu} -> ${sonra}`); ``` ``` senaryo kalan en hizli kurtarma konak makinenin kaybi 3/4 sube sunucusunda yedek (45 dk) sube tesisinin kaybi 2/4 merkez nesne deposunda yedek (210 dk) merkez nesne deposunun kaybi 3/4 konak anlik goruntusu (8 dk) yonetim kimliginin ele gecirilmesi 1/4 merkezde cevrimdisi kopya (720 dk) konuk icindeki dosyalarin sifrelenmesi 4/4 konak anlik goruntusu (8 dk) 4 kopya, 3 konum; en kotu senaryoda kalan 1 cevrimdisi kopya cikarilinca kopya 4 -> 3, en kotu senaryoda kalan 1 -> 0 ``` Üç fiziksel senaryoda en az iki kopya ayakta kalıyor. Dördüncü satır ötekilerden farklıdır: yönetim kimliğinin ele geçirilmesi hiçbir donanımı yok etmez, yine de dört kopyanın üçünü birden götürür — o üçü aynı kimliğin silebildiği çevrimiçi kopyalardır ve konum çeşitliliği burada bir şey ifade etmez. Son satır ölçünün özetidir: çevrimdışı kopya çıkarıldığında kopya sayısı dörtten üçe iner, ama en kötü senaryoda kalan kopya **birden sıfıra** düşer. **Dayanıklılık kopya sayısı değil, kopyaları aynı anda yok edebilen kalem sayısıdır.** #### Kurtarma Testi Bütün bu sayılar bir varsayıma dayanıyor: yedek dosyası okunabilir. Bu varsayımın sınanmasına **kurtarma testi** denir; Sunucu Yönetimi ve Sertleştirme kursundaki geri yükleme tatbikatının aynısıdır ve orada ölçülmüştü. Bu kursun ölçüsüyle söylenecek tek şey şudur: kurtarma testi yapılmadığında kurtarma sınırını geçmek için gereken kalem **birdir** — bir bozuk dosya, bir kapsam dışı kalem ya da bir okunamayan anahtar — ve o kalem yerindeyse erişilebilen kurtarma noktası sıfırdır. #### Özet - Yedi kayıp senaryosunda anlık görüntü 3'ünde çalışır ve çalıştığında 8/8 kalem getirir; yedek 7'sinde çalışır ve her seferinde 6/8 getirir. - Anlık görüntünün eksiği koşula bağlıdır — kaybolan şeyin yanında durur; yedeğinki kapsama bağlıdır ve iki kalem senaryodan bağımsız olarak dışarıda kalır. - İki yöntem toplamda 56 kalemin 48'ini kurtarır; kalan 8 kalem hiçbir düzende gelmez. Veri kaybı penceresi anlık görüntüde 1, yedekte 24 saattir. - Yirmi sekiz noktalı zincirde bir dosyanın bozulması tam düzende 1, artımlı düzende 18, ayrımsal düzende 1 nokta götürür; depolama sırasıyla 1.120, 91,3 ve 758,2 GiB'dir. Tam yedeğin kendisi bozulursa artımlı ve ayrımsal düzenlerde 28 noktanın 28'i birden gider. - Dört kopyalı düzende en kötü senaryo yönetim kimliğinin ele geçirilmesidir ve 3 kopyayı birden götürür; çevrimdışı kopya çıkarıldığında en kötü senaryoda kalan kopya 1'den 0'a iner. - Kurtarma testi yapılmadığında kurtarma sınırını geçmek için gereken kalem birdir ve o kalem yerindeyse erişilebilen kurtarma noktası sıfırdır. #### Kurs Kapanışı | Ders | Sınırın adı | Geçmek için gereken kalem | Düşerse erişilen kalem | |---|---|---|---| | Bilgisayar Donanım Bileşenleri | 8 bileşen, 43 kalem | uzaktan 1–3, fiziksel 0 | 3–43; bellenim tek başına 43 | | İşletim Sistemi Aileleri | yönetici sınırı, 14 istek | ailelere göre 1, 2, 3 | 13, 9, 5 istek | | Kurulum ve Yapılandırma | varsayılan sınırı, 20 kalem | 1 riskli kalem | 17 kalem; sertleştirmeden sonra 5 | | Dosya İzinleri ve Sahiplik | izin sınırı, 70 istek | sahiplikte 1 | nesnenin tüm izin kararları; 6 sapma | | Grafik Arayüz ve Komut Satırı | denetim izi sınırı, 21 kayıt | silinebilen 1 kalem | 10 kayıt görünmez; 3 iş izsiz | | Sorun Giderme Yöntemi | belirti–neden sınırı, 16 olasılık | 3,50 adım; kötü sırada 5,81 | 14 senaryo tek nedene; 2 ayrılamaz | | Hipervizör Türleri | hipervizör sınırı, 19 ve 26 kalem | komşuya 1; donanıma 2 ve 3 | 15/19 ve 22/26 | | Konuk ve Konak Sistem | paylaşım sınırı, 11 kalem | 4 yolda 1, 10 yolda 2, 2 yolda 3 | 16 yolun 6'sı kapatılamaz | | Sanal Makine Yönetimi | klon ve anlık görüntü sınırı, 7 sır | ortak sırda 1 | 24 makine; geri dönüşte 17 açık | | Konteyner ile Karşılaştırma | yalıtım sınırı, 52 kalem | konuk 2, bölme 1, iç içe 3 | 39/52, 52/52, iç içe 9/52 | | Yedekleme ve Dayanıklılık | kurtarma sınırı, 56 kalem | bozuk dosyada 1 | 8 kalem kurtarılamaz; 18 nokta | Üçüncü sütun kursun kuralını on bir satırda aynı biçimde okutuyor: **yalıtım bir sıfat değil, sınırı geçmek için aynı anda yanlış olması gereken kalem sayısıdır; o sayı bir ise sınır yoktur.** On bir satırın on birinde en az bir "1" var. Bir riskli varsayılan kalemi, bir sahiplik kaydı, silinebilen bir denetim kaydı, bir ortak sır, bir bozuk yedek dosyası — hepsi tek başına yeterlidir ve hiçbiri bir kaçış yolu kullanmaz. Sayının birden büyük olduğu yerler üç kaynaktan geliyor: **katman üstüne katman** (donanıma iki ve üç kalem, iç içe düzende üç), **doğrulama zinciri** (imzalı açılış gereken kalemi bire karşı dörde çıkarır) ve **bölünmüş ayrıcalık** (yönetici sınırı bir ailede bir, ötekinde üç kalem). Üçünün de bedeli yazılıdır — dört ek yama kalemi, her güncellemede yeniden imzalanan üç halka, yönetici olunsa da erişilemeyen dokuz istek. **Bedeli yazılmayan bir sınır ölçülmemiştir.** Dördüncü sütun sınırın yetmediği yeri gösteriyor: kapatılamayan altı paylaşım yolu, kurtarılamayan sekiz kalem, ayrılamayan iki neden ve hiç kapanmayan bir kurulum kalemi. Hiçbiri daha iyi bir yapılandırmayla kapanmıyor. Bütün bu sayılar tek bir makinede ve üzerindeki konuk sistemlerde ölçüldü. Ama şube sunucusu yalnız başına durmuyor: sayaç uç noktaları ve saha ekiplerinin dizüstü bilgisayarları ona, kendisi de merkeze bağlanıyor. Bu bağlantıların her biri işletim sisteminin çizdiği sınırın **dışından** geçen bir yoldur; ne izin bitleri ne hipervizör ne de bölme onu görür. **M24/K03 Ağ Güvenliği** bu soruyla başlar: iki makine arasındaki her bağlantı kaç yol açıyor ve o yolları kim sayıyor.