--- title: 'Bulutta Hesaplama ve Ağ' source: 'https://academia.sh/tr/kurslar/bulut-hesaplama-ve-ag' language: tr updated: '2026-08-17T04:39:00+00:00' license: 'CC BY-SA 4.0' lessons: 15 outcomes: - 'Örnek ailesi ve boyutlandırma kararını kaynak eşleşmesiyle verir' - 'Adres alanı, alt ağ ve yönlendirme tasarımını kalem kalem kurar' - 'Filtreleme ve erişim kararlarını açık yüzey cinsinden ölçer' --- # Bulutta Hesaplama ve Ağ Kiralanan en somut şeyin ölçülmesi: sanal makine örnek ailelerinin ve boyutlandırmanın kaynak eşleşmesi, makine imajı ile başlangıç betiğinin açılış süresine etkisi, kalıcı ile kesintili kapasitenin maliyet ve kesinti dengesi, tekrarlanabilir örnek tanımı için başlatma şablonları, ölçekleme politikaları ve sağlık denetimi, yönetilen konteyner servisleri, adres alanı planlaması, genel ve özel alt ağ ayrımı, yönlendirme tabloları, dışarı ve içeri erişim geçitleri, durum bilgili ve bilgisiz filtreleme, yük dengeleyici katman seçimi, adres kararlılığı, içerik dağıtım ağı ve ağlar arası özel erişim. ## Hesaplama Makinenin kiralanması: örnek ailelerinin kaynak oranıyla iş yüküne eşleşmesi ve boyutlandırma, makine imajı ile başlangıç betiğinin açılış süresi ve tazelik dengesi, kalıcı ile kesintili kapasitenin maliyet ve kesinti riski, tekrarlanabilir örnek tanımı için başlatma şablonları, ölçekleme politikaları ile sağlık denetiminin birlikte davranışı ve küme ile görev tabanlı yönetilen konteyner servisleri. ### Sanal Makine Örnekleri Source: https://academia.sh/tr/kurslar/bulut-hesaplama-ve-ag/sanal-makine-ornekleri Dört iş yükü profili üç örnek ailesine eşlenir ve her eşleşmede atıl işlemci, atıl bellek ile darboğazın hangi boyutta doğduğu sayılır; aynı talep altı ayrı örnek boyutuna bölünür ve sabit yük ile arıza etkisinin ters yönde değiştiği ölçülür; bir örnekte hangi kararın elde kaldığı, hangisinin geri alınamadığı ve düzeltmenin filoya kaç saat tuttuğu çıkarılır. Önceki kurs kiralama kararını verdi ve coğrafyasını seçti: hangi katmanın devredildiği, hangi bölgenin seçildiği, çıkışın ne tuttuğu sayıldı. Ama kiralanan şeylerin en somutu — üzerinde sürecin koştuğu makine — hiç ele alınmadı. Bölge seçildiğinde henüz tek bir işlemci çekirdeği bile ayrılmış değildir. Bu ders o makineyi kiralar. Sanal makine örneği, sağlayıcının fiziksel bir sunucudan ayırdığı ve tür olarak sunduğu hesaplama birimidir; **örnek ailesi** işlemci ile belleğin hangi oranda geldiğini, **boyut** ise o oranın kaç katının alındığını söyler. Devredilen karar buraya kadar gelir: fiziksel makinenin hangisi olduğu, işlemcinin hangi nesil olduğu, komşunun ne yaptığı sağlayıcıda kalır. Elde kalan karar aile ve boyuttur — ve bu iki kalem, iş yükünün şekline uymadığında bedeli her saat ödenen bir seçimdir. **BH1.** Filo, bölgesel ölçüm ağının — su sayaçlarından okuma toplayan kurgu yazılımın — dört iş yükünden oluşur; tepe talepleri kurgudur. **BH2.** Üç örnek ailesi vardır ve vCPU başına 2, 4, 8 GB bellek verir; fiyatlar **kurgu birimdir**, gerçek bir para birimi değildir. **BH3.** Boyut basamakları 2'nin katlarıdır ve aile içinde oran sabittir. **BH4.** Her örnekte işletim sistemi ile ölçüm aracısı 0,6 vCPU sabit yük tutar. **BH5.** Toplayıcı katmanının etkin talebi 84 vCPU'dur ve tarama boyunca sabit kabul edilir. **BH6.** Karar defterindeki dakikalar kurgudur; değişim aynı anda iki örnekle yürür. #### İş Yükünün Şekli ile Ailenin Şekli Bir iş yükünün iki boyutu vardır: ne kadar işlemci, ne kadar bellek. Örnek ailesi bu ikisini ayrı ayrı satmaz; sabit bir oranda paketleyip satar. Eşleşme oranı tutmadığında ihtiyaç duyulmayan boyut da alınır ve **atıl kaynak** olarak durur. Aşağıdaki model dört profili üç aileye eşler. ```js // olcum-agi/eslesme.mjs — is yuku profillerini ornek ailelerine esler (model; urun degil tur) // Aile: vCPU basina bellek (GB) ve vCPU-saat basina kurgu birim. export const AILE = { "hesaplama agirlikli": { gb: 2, birim: 1.0 }, "dengeli": { gb: 4, birim: 1.3 }, "bellek agirlikli": { gb: 8, birim: 1.9 }, }; export const BOYUT = [2, 4, 8, 16, 32, 64]; // aile ici vCPU basamaklari // Is yuku: [ad, tepe vCPU, tepe GB, gunde acik saat, ornek sayisi]. export const IS = [ ["okuma toplayici", 12, 10, 24, 7], ["sayac dizini", 5, 46, 24, 3], ["api ucu", 7, 26, 24, 5], ["gece raporu", 26, 38, 2, 2], ]; export const yerlestir = ([ad, cpu, gb, saat, adet], aileAd) => { const a = AILE[aileAd]; const i = BOYUT.findIndex((b) => b >= cpu && b * a.gb >= gb); const boyut = BOYUT[i], bellek = boyut * a.gb, alt = BOYUT[i - 1] ?? 0; return { ad, aileAd, boyut, bellek, adet, saat, atilCpu: boyut - cpu, atilGb: bellek - gb, darbogaz: alt < cpu ? (alt * a.gb < gb ? "ikisi" : "islemci") : "bellek", gunluk: boyut * a.birim * saat * adet }; }; if (import.meta.url === `file://${process.argv[1]}`) { console.log("is yuku / aile".padEnd(24) + "ornek".padEnd(15) + "atil vCPU".padEnd(12) + "atil GB".padEnd(12) + "darbogaz".padEnd(10) + "gunluk birim"); const enUcuz = {}; for (const is of IS) { console.log(`${is[0]} (${is[1]} vCPU, ${is[2]} GB, ${is[4]} ornek, gunde ${is[3]} sa)`); let ucuz = null; for (const ad of Object.keys(AILE)) { const y = yerlestir(is, ad); if (!ucuz || y.gunluk < ucuz.gunluk) ucuz = y; console.log(" " + ad.padEnd(22) + `${y.boyut}/${y.bellek} GB`.padEnd(15) + `${y.atilCpu} (%${Math.round(100 * y.atilCpu / y.boyut)})`.padEnd(12) + `${y.atilGb} (%${Math.round(100 * y.atilGb / y.bellek)})`.padEnd(12) + y.darbogaz.padEnd(10) + y.gunluk.toFixed(1)); } enUcuz[is[0]] = ucuz; } console.log("\nfilo gunluk bedeli — tek aileye standartlasmak ile is yuku basina secmek:"); console.log("politika".padEnd(28) + "gunluk birim".padEnd(15) + "fark".padEnd(10) + "atil vCPU".padEnd(12) + "atil GB"); const karma = Object.values(enUcuz); const topla = (l) => [l.reduce((t, y) => t + y.gunluk, 0), l.reduce((t, y) => t + y.atilCpu * y.adet, 0), l.reduce((t, y) => t + y.atilGb * y.adet, 0)]; const [kb] = topla(karma); for (const ad of Object.keys(AILE)) { const [b, c, g] = topla(IS.map((is) => yerlestir(is, ad))); console.log(`yalniz ${ad}`.padEnd(28) + b.toFixed(1).padEnd(15) + `+%${Math.round(100 * (b - kb) / kb)}`.padEnd(10) + String(c).padEnd(12) + String(g)); } const [b, c, g] = topla(karma); console.log("is yuku basina secim".padEnd(28) + b.toFixed(1).padEnd(15) + "—".padEnd(10) + String(c).padEnd(12) + String(g)); } ``` ``` is yuku / aile ornek atil vCPU atil GB darbogaz gunluk birim okuma toplayici (12 vCPU, 10 GB, 7 ornek, gunde 24 sa) hesaplama agirlikli 16/32 GB 4 (%25) 22 (%69) islemci 2688.0 dengeli 16/64 GB 4 (%25) 54 (%84) islemci 3494.4 bellek agirlikli 16/128 GB 4 (%25) 118 (%92) islemci 5107.2 sayac dizini (5 vCPU, 46 GB, 3 ornek, gunde 24 sa) hesaplama agirlikli 32/64 GB 27 (%84) 18 (%28) bellek 2304.0 dengeli 16/64 GB 11 (%69) 18 (%28) bellek 1497.6 bellek agirlikli 8/64 GB 3 (%38) 18 (%28) ikisi 1094.4 api ucu (7 vCPU, 26 GB, 5 ornek, gunde 24 sa) hesaplama agirlikli 16/32 GB 9 (%56) 6 (%19) bellek 1920.0 dengeli 8/32 GB 1 (%13) 6 (%19) ikisi 1248.0 bellek agirlikli 8/64 GB 1 (%13) 38 (%59) islemci 1824.0 gece raporu (26 vCPU, 38 GB, 2 ornek, gunde 2 sa) hesaplama agirlikli 32/64 GB 6 (%19) 26 (%41) ikisi 128.0 dengeli 32/128 GB 6 (%19) 90 (%70) islemci 166.4 bellek agirlikli 32/256 GB 6 (%19) 218 (%85) islemci 243.2 filo gunluk bedeli — tek aileye standartlasmak ile is yuku basina secmek: politika gunluk birim fark atil vCPU atil GB yalniz hesaplama agirlikli 7040.0 +%36 166 290 yalniz dengeli 6406.4 +%24 78 642 yalniz bellek agirlikli 8268.8 +%60 54 1506 is yuku basina secim 5158.4 — 54 290 ``` Darboğaz sütunu ailenin yanlış seçildiğini söyleyen tek sütundur. `sayac dizini` bellek ağırlıklı bir iştir: hesaplama ağırlıklı ailede 46 GB'ı almak için 32 vCPU alınır ve **27 vCPU, yani işlemcinin yüzde 84'ü boşta durur**. Aynı iş bellek ağırlıklı ailede 8 vCPU'luk bir örneğe sığar; atıl işlemci 27'den 3'e, günlük bedel 2304'ten 1094'e iner. Ters yönde de aynısı geçerlidir: `okuma toplayici` işlemci ağırlıklıdır ve bellek ağırlıklı aileye konursa 118 GB bellek — belleğin yüzde 92'si — boşta kalır. Atıl kaynak bir bedeldir ama tek bedel değildir. `api ucu` satırında darboğaz sütunu "ikisi" yazar: bir alt boyut hem işlemcide hem bellekte yetmiyor. Bu, o eşleşmenin ailesinin doğru olduğunun işaretidir; iki boyut da aynı anda sınırdaysa alınan paketin şekli işin şekline uyuyor demektir. Tek boyutun "ikisi" yazması yerine "islemci" ya da "bellek" yazması, o örneğin bir boyutunun gereğinden büyük alındığını gösterir. Alt tablo kararı bir politikaya çevirir. Filoyu tek aileye standartlaştırmak yönetimi sadeleştirir; bedeli üç sayıda görünür. En yakın tek aile bile günde **yüzde 24 fazla** tutar ve atıl belleği 290 GB'dan 642 GB'a çıkarır. En kötü tek aile yüzde 60 fazla tutar. Dört iş yükü için karar dört kez ayrı verildiğinde günlük 5158,4 kurgu birim, tek aileye indirildiğinde 6406,4 birim ödenir; aradaki 1248 birim, standartlaşmanın günlük fiyatıdır. #### Aynı Talebi Kaç Parçaya Bölmek Aile seçildikten sonra ikinci karar gelir: aynı toplam kapasite az sayıda büyük örnekten mi, çok sayıda küçükten mi alınacak. Bu karar boyut satırında görünmez, çünkü her iki uçta da toplam vCPU yaklaşık aynıdır. Fark iki başka yerde doğar: her örneğin kendi sabit yükünde ve bir örnek düştüğünde kaybedilen orandaki. ```js // olcum-agi/boyutlandirma.mjs — ayni talebi farkli ornek boyutlarina bolme taramasi (model) import { AILE, BOYUT } from "./eslesme.mjs"; const TALEP = 84; // toplayici katmaninin etkin vCPU talebi (kurgu) const SABIT = 0.6; // her ornekte isletim sistemi + olcum aracisi (vCPU) const SAAT = 24, AD = "dengeli"; export const tara = (boyut) => { const etkin = boyut - SABIT, adet = Math.ceil(TALEP / etkin); const saglanan = adet * boyut, sabit = adet * SABIT; const gunluk = saglanan * AILE[AD].birim * SAAT; return { boyut, adet, saglanan, sabit, yuvarlama: saglanan - TALEP - sabit, atil: saglanan - TALEP, eksik: Math.max(0, TALEP - (adet - 1) * etkin), gunluk, yedek: boyut * AILE[AD].birim * SAAT }; }; if (import.meta.url === `file://${process.argv[1]}`) { console.log(`talep ${TALEP} etkin vCPU, ornek basina ${SABIT} vCPU sabit yuk, ${AD} ailesi\n`); console.log("boyut".padEnd(9) + "ornek".padEnd(8) + "saglanan".padEnd(11) + "sabit yuk".padEnd(11) + "yuvarlama".padEnd(11) + "atil".padEnd(9) + "bir ariza".padEnd(11) + "N+1 bedeli"); for (const b of BOYUT) { const t = tara(b); console.log(`${b} vCPU`.padEnd(9) + String(t.adet).padEnd(8) + `${t.saglanan}`.padEnd(11) + t.sabit.toFixed(1).padEnd(11) + t.yuvarlama.toFixed(1).padEnd(11) + `%${Math.round(100 * t.atil / t.saglanan)}`.padEnd(9) + `%${(100 * t.eksik / TALEP).toFixed(1)}`.padEnd(11) + `+%${(100 * t.yedek / t.gunluk).toFixed(1)}`); } const en = BOYUT.map(tara).reduce((a, b) => (b.atil < a.atil ? b : a)); console.log(`\nen dusuk atil: ${en.boyut} vCPU (${en.atil.toFixed(1)} vCPU bosta, ` + `${en.adet} ornek); orada bir ariza talebin %${(100 * en.eksik / TALEP).toFixed(1)}'ini acikta birakiyor`); } ``` ``` talep 84 etkin vCPU, ornek basina 0.6 vCPU sabit yuk, dengeli ailesi boyut ornek saglanan sabit yuk yuvarlama atil bir ariza N+1 bedeli 2 vCPU 61 122 36.6 1.4 %31 %0.0 +%1.6 4 vCPU 25 100 15.0 1.0 %16 %2.9 +%4.0 8 vCPU 12 96 7.2 4.8 %13 %3.1 +%8.3 16 vCPU 6 96 3.6 8.4 %13 %8.3 +%16.7 32 vCPU 3 96 1.8 10.2 %13 %25.2 +%33.3 64 vCPU 2 128 1.2 42.8 %34 %24.5 +%50.0 en dusuk atil: 8 vCPU (12.0 vCPU bosta, 12 ornek); orada bir ariza talebin %3.1'ini acikta birakiyor ``` İki israf kalemi ters yönde hareket eder. Sabit yük — her örneğin işletim sistemi ve ölçüm aracısı — 2 vCPU'luk örnekte 36,6 vCPU tutar, 64 vCPU'luk örnekte 1,2 vCPU'ya iner; küçük örnekte kiralanan kapasitenin neredeyse üçte biri işi yapmadan harcanır. Yuvarlama israfı tersine gider: talep örnek boyutuna tam bölünmediği için büyük örnekte 42,8 vCPU fazladan alınır. Toplam atıl bu yüzden düz bir eğri değildir; **8 ile 32 vCPU arasında en düşük noktasına iner** ve iki uçta yükselir. Arıza sütunu ise tek yönlüdür ve karara asıl yönü o verir. 61 örneklik dizilimde bir örnek düşünce talebin yüzde 0'ı açıkta kalır; 32 vCPU'luk üç örnekli dizilimde aynı arıza talebin **yüzde 25'ini** açıkta bırakır. Son sütun bunun düzeltme fiyatıdır: bir yedek örnek eklemek 61 örneklik dizilimde günlük bedeli yüzde 1,6 artırır, üç örneklik dizilimde yüzde 33,3 artırır. Atıl kaynağı en aza indiren nokta ile arıza etkisini en aza indiren nokta aynı yerde değildir; boyutlandırma bu iki sayının arasında bir yer seçmektir, tek bir doğru boyut aramak değil. #### Örnekte Hangi Karar Kimde İki karar da verildikten sonra üçüncü soru gelir: bu kararlar yanlış çıkarsa geri alınır mı. Örnek üzerindeki kalemlerin bir bölümü çalışırken değişir, bir bölümü örneği durdurmayı ister, bir bölümü ise başlatma anında verilir ve **bir daha değişmez**. ```js // olcum-agi/karar-defteri.mjs — bir ornekte hangi karar kimde, hangisi geri alinamaz (model) import { IS } from "./eslesme.mjs"; const FILO = IS.reduce((t, is) => t + is[4], 0); // 17 ornek const PENCERE = 2, TUR = Math.ceil(FILO / PENCERE); // ayni anda disari alinan ornek // Elde kalan kalem: [ad, geri alinabilirlik, degisim yolu, ornek basina dakika] const ELDE = [ ["ornek ailesi", "evet", "durdur-degistir-baslat", 4], ["ornek boyutu", "evet", "durdur-degistir-baslat", 4], ["kok disk boyutu", "tek yonlu", "buyutulur, kucultulmez", 2], ["islemci mimarisi", "hayir", "imaj yeniden uretimi + yeniden yaratma", 35], ["yerlestigi alt ag", "hayir", "yeniden yaratma", 35], ["kok diskin sifrelenmesi", "hayir", "yeniden yaratma", 35], ]; const SAGLAYICIDA = ["fiziksel makine", "islemci nesli", "asiri abonelik orani", "komsu is yuku", "bakim penceresi ani"]; if (import.meta.url === `file://${process.argv[1]}`) { console.log(`${FILO} ornekli filo; degisim ayni anda ${PENCERE} ornekle, ${TUR} turda yuruyor\n`); console.log("elde kalan kalem".padEnd(26) + "geri alinabilir".padEnd(17) + "degisim yolu".padEnd(40) + "filo duvar saati"); for (const [ad, geri, yol, dk] of ELDE) console.log(ad.padEnd(26) + geri.padEnd(17) + yol.padEnd(40) + `${((TUR * dk) / 60).toFixed(1)} sa`); const geriYok = ELDE.filter((x) => x[1] === "hayir"); console.log(`\nsaglayicida kalan ${SAGLAYICIDA.length} kalem: ${SAGLAYICIDA.join(", ")}`); console.log(`geri alinamayan kalem: ${geriYok.length}; ucu birlikte degisirse filo ` + `${(TUR * Math.max(...geriYok.map((x) => x[3])) / 60).toFixed(1)} saatte yenilenir, ` + `yanlis aile secimi ${(TUR * 4 / 60).toFixed(1)} saatte duzelir`); } ``` ``` 17 ornekli filo; degisim ayni anda 2 ornekle, 9 turda yuruyor elde kalan kalem geri alinabilir degisim yolu filo duvar saati ornek ailesi evet durdur-degistir-baslat 0.6 sa ornek boyutu evet durdur-degistir-baslat 0.6 sa kok disk boyutu tek yonlu buyutulur, kucultulmez 0.3 sa islemci mimarisi hayir imaj yeniden uretimi + yeniden yaratma 5.3 sa yerlestigi alt ag hayir yeniden yaratma 5.3 sa kok diskin sifrelenmesi hayir yeniden yaratma 5.3 sa saglayicida kalan 5 kalem: fiziksel makine, islemci nesli, asiri abonelik orani, komsu is yuku, bakim penceresi ani geri alinamayan kalem: 3; ucu birlikte degisirse filo 5.3 saatte yenilenir, yanlis aile secimi 0.6 saatte duzelir ``` On bir kalemin **altısı elde, beşi sağlayıcıdadır**. Sağlayıcıda kalanlar üzerinde tek yapılabilecek şey ölçmektir: aynı boyuttaki iki örneğin farklı hızda koşması komşu iş yükünün ya da işlemci neslinin farkıdır, bir karar değil bir gözlemdir. Elde kalan altı kalem geri alınabilirliğe göre üçe ayrılır. Aile ve boyut **geri alınabilir** kalemlerdir: yanlış aile seçimi 17 örneklik filoda 0,6 saatte düzelir, atıl kaynak sayıldıkça her ay yeniden bakılabilir. Kök disk boyutu **tek yönlüdür** — büyütülür, küçültülmez; gereğinden büyük alınan disk örneğin ömrü boyunca ödenir. Geri alınamayan üç kalem — işlemci mimarisi, örneğin yerleştiği alt ağ ve kök diskin şifrelenip şifrelenmediği — başlatma anında verilir ve değiştirilmek istendiğinde örnek değişmez, **yeniden yaratılır**: filo 5,3 saatte, yani aile değişiminin dokuz katı sürede yenilenir. Bu üçü ilk gün seçilir ve filo büyüdükçe düzeltilmesi pahalılaşır; 17 örnekte 5,3 saat olan iş, 170 örnekte iki günden uzun sürer. #### Özet - Aile eşleşmesi tutmadığında bedel her saat ödenir: `sayac dizini` hesaplama ağırlıklı ailede 27 vCPU'yu (işlemcinin yüzde 84'ünü) boşta tutar, doğru ailede aynı iş 3 vCPU atılla koşar ve günlük bedel 2304'ten 1094 kurgu birime iner. - Tek aileye standartlaşmak en iyi durumda günde yüzde 24, en kötü durumda yüzde 60 fazla tutar; dört iş yükü için ayrı seçim 5158,4 birim, en yakın tek aile 6406,4 birimdir. - Boyutlandırmada iki israf ters yönde gider: sabit yük 2 vCPU'luk örnekte 36,6 vCPU, 64 vCPU'luk örnekte 1,2 vCPU; yuvarlama israfı 1,4'ten 42,8 vCPU'ya çıkar ve toplam atıl 8–32 vCPU aralığında en düşüktür. - Arıza etkisi tek yönlüdür: bir örneğin düşmesi 61 örneklik dizilimde talebin yüzde 0'ını, üç örneklik dizilimde yüzde 25'ini açıkta bırakır; yedek örneğin bedeli yüzde 1,6'dan yüzde 33,3'e çıkar. - On bir kalemin altısı elde, beşi sağlayıcıdadır; geri alınamayan üç kalem işlemci mimarisi, yerleştiği alt ağ ve kök diskin şifrelenmesidir — üçünün değişimi filoyu 5,3 saatte yeniler, aile değişimi 0,6 saatte. #### Sonraki Adım Bu dersin bütün sayıları örnek açıldıktan sonrasını ölçtü: kaç vCPU boşta durduğunu, bir arızanın ne kadarını götürdüğünü, bir kalemin değişmesinin kaç saat tuttuğunu. Açılışın kendisi tek bir satırda geçti — "yeniden yaratma 35 dakika" — ve o 35 dakikanın içinde ne olduğu sorulmadı. Örnek boş bir diskle açılmaz; bir **makine imajından** açılır ve o imajın içinde ne kadar hazır iş varsa açılış o kadar kısa sürer. Sonraki ders imaja gömülen kalem ile açılışta yapılan kalem arasındaki dengeyi tarar ve sorar: bir kalem imaja gömüldükçe açılış kaç saniye kısalıyor, imajın tazeliği kaç gün düşüyor ve açılışta kalan iş kaç dış bağımlılığa kaç çağrı yapıyor? ### Makine İmajları Source: https://academia.sh/tr/kurslar/bulut-hesaplama-ve-ag/makine-imajlari Açılışta yapılan sekiz kalem tek tek imaja gömülür ve her kalemin kazandırdığı saniye ile ödettiği bayatlık yan yana sayılır; gömme düzeyi sıfırdan sekize taranarak açılış süresi, dış çağrı sayısı, bağımlılık türü, aylık pişirme yükü ve bayat kalem-günü çıkarılır; açılışta kalan işin hangi bağımlılığa bağlı olduğu ve o bağımlılık düştüğünde açılışın durup durmadığı ölçülür. Önceki ders bir kalemi tek satırda geçti: yeniden yaratma 35 dakika. O sürenin içindeki asıl iş, boş bir diskin çalışan bir makineye dönüşmesidir ve bu dönüşüm bir **makine imajından** başlar. İmaj, örneğin kök diskine kopyalanan hazır dosya sistemidir; içinde ne varsa açılışta yapılmaz, içinde ne yoksa açılışta yapılır. M22/K05 bu imajın nasıl üretildiğini — pişirme akışını, sürümlenmesini ve yayılma penceresini — ölçtü; o ölçüm burada tekrarlanmaz. Bu dersin ölçüsü tek bir eksendir: **açılış süresi**. Her kalem için aynı soru sorulur — bu kalem imaja gömülürse açılış kaç saniye kısalır, karşılığında imaj kaç gün daha bayat kalır ve ayda kaç kez yeniden pişirmek gerekir. Cevap kalemden kaleme değişir ve değişimin büyüklüğü, "her şeyi imaja gömmek" ile "hiçbir şeyi gömmemek" arasındaki tercihi bir zevk meselesi olmaktan çıkarır. **BH7.** Bölgesel ölçüm ağının — su sayaçlarından okuma toplayan kurgu yazılımın — açılışında on kalem yapılır; sekizi imaja gömülebilir, ikisi gömülemez. Süreler, boyutlar ve değişim aralıkları kurgudur. **BH8.** Taban imaj 900 MB'dır, çekme hızı 60 MB/sn'dir, çekirdek açılışı her yolda 11 saniyedir. **BH9.** Pişirme haftada bir toplu yapılır; bir değişikliğin imaja girmek için beklediği süre ortalama 3,5 gündür. **BH10.** Bir pişirme, sınamasıyla birlikte 18 dakika tutar. **BH11.** Gömme sırası açgözlüdür: pişirme başına en çok saniye kazandıran kalem önce gömülür. **BH12.** Bir kalemin "kritik" olması, o kalem eksikken servisin başlamaması demektir; ayrım kurgudur. #### Bir Kalemin İki Yüzü Açılışta yapılan her iş bağımsız bir kalemdir ve her kalemin imaja gömülmesi ayrı bir karardır. Kalem gömülünce açılıştaki saniyesi kalkar ama imajın boyutu büyür — ve büyüyen imajın çekilmesi açılışa saniye ekler. Net kazanç bu ikisinin farkıdır. Bedel ise başka bir birimdedir: kalem ne kadar sık değişiyorsa, imaja gömülmesi o kadar sık yeniden pişirme ister. ```js // olcum-agi/imaj-kalemleri.mjs — bir kalemi imaja gommenin acilis kazanci ve tazelik bedeli (model) export const HIZ = 60, TABAN_MB = 900, CEKIRDEK = 11; // MB/sn, taban imaj, cekirdek acilisi (sn) export const PISIRME_BEKLEME = 3.5, PISIRME_DK = 18; // haftalik toplu pisirmede ortalama bekleme // [ad, acilista sn, imaja ekledigi MB, kac gunde bir degisir, bagimlilik, cagri, kritik mi] export const KALEM = [ ["cekirdek paketleri", 46, 320, 45, "paket deposu", 6, true], ["calisma zamani", 38, 210, 30, "paket deposu", 3, true], ["olcum aracisi", 14, 60, 14, "paket deposu", 2, false], ["gunluk yonlendirme", 8, 20, 21, "paket deposu", 1, false], ["sertifika demeti", 9, 12, 7, "yapilandirma sunucusu", 1, true], ["uygulama ikilisi", 22, 90, 2, "yapim deposu", 1, true], ["ag ayarlari", 6, 2, 3, "yapilandirma sunucusu", 1, true], ["ortam degiskenleri", 3, 1, 1, "yapilandirma sunucusu", 1, false], ]; // Gomulemez kalemler: acilista her zaman yapilir. export const GOMULEMEZ = [["dugum sirri", 7, "sir deposu", 1, true], ["saat esitleme", 4, "zaman sunucusu", 1, false]]; export const olc = ([ad, sn, mb, gun, , cagri]) => ({ ad, kazanc: sn - mb / HIZ, pisirme: 30 / gun, cagri, bayat: (30 / gun) * PISIRME_BEKLEME, }); // Acgozlu sira: pisirme basina en cok saniye kazandiran kalem once gomulur. export const SIRA = [...KALEM].sort((a, b) => olc(b).kazanc / olc(b).pisirme - olc(a).kazanc / olc(a).pisirme); if (import.meta.url === `file://${process.argv[1]}`) { console.log("kalem".padEnd(22) + "acilista".padEnd(10) + "imaja".padEnd(9) + "cekme".padEnd(9) + "net kazanc".padEnd(12) + "ayda pisirme".padEnd(14) + "bayat kalem-gun".padEnd(17) + "oran"); for (const k of SIRA) { const o = olc(k); console.log(o.ad.padEnd(22) + `${k[1]} sn`.padEnd(10) + `${k[2]} MB`.padEnd(9) + `${(k[2] / HIZ).toFixed(1)} sn`.padEnd(9) + `${o.kazanc.toFixed(1)} sn`.padEnd(12) + o.pisirme.toFixed(2).padEnd(14) + o.bayat.toFixed(1).padEnd(17) + (o.kazanc / o.pisirme).toFixed(1)); } const g = GOMULEMEZ.reduce((t, x) => t + x[1], 0); console.log(`\ngomulemez kalemler: ${GOMULEMEZ.map((x) => x[0]).join(", ")} — ` + `${g} sn ve ${GOMULEMEZ.length} cagri her acilista kalir`); } ``` ``` kalem acilista imaja cekme net kazanc ayda pisirme bayat kalem-gun oran cekirdek paketleri 46 sn 320 MB 5.3 sn 40.7 sn 0.67 2.3 61.0 calisma zamani 38 sn 210 MB 3.5 sn 34.5 sn 1.00 3.5 34.5 olcum aracisi 14 sn 60 MB 1.0 sn 13.0 sn 2.14 7.5 6.1 gunluk yonlendirme 8 sn 20 MB 0.3 sn 7.7 sn 1.43 5.0 5.4 sertifika demeti 9 sn 12 MB 0.2 sn 8.8 sn 4.29 15.0 2.1 uygulama ikilisi 22 sn 90 MB 1.5 sn 20.5 sn 15.00 52.5 1.4 ag ayarlari 6 sn 2 MB 0.0 sn 6.0 sn 10.00 35.0 0.6 ortam degiskenleri 3 sn 1 MB 0.0 sn 3.0 sn 30.00 105.0 0.1 gomulemez kalemler: dugum sirri, saat esitleme — 11 sn ve 2 cagri her acilista kalir ``` Son sütun kalemleri iki kümeye ayırır. `cekirdek paketleri` 40,7 saniye kazandırır ve ayda 0,67 kez pişirme ister; oran 61'dir. `ortam degiskenleri` 3 saniye kazandırır ve ayda 30 kez pişirme ister; oran 0,1'dir. İki kalem arasında **altı yüz kat** fark vardır ve fark boyuttan değil, **değişim sıklığından** gelir. İmaja gömülmeye en uygun kalem, açılışta en uzun süren kalem değildir; uzun sürüp seyrek değişen kalemdir. `uygulama ikilisi` satırı bu ayrımın en görünür yeridir. Açılışta 22 saniye tutar — listenin en uzun üçüncü kalemi — ama iki günde bir değişir. Gömülürse ayda 15 pişirme tetikler ve 52,5 bayat kalem-günü biriktirir. Aynı 20,5 saniyeyi `calisma zamani` yalnız 3,5 bayat kalem-güne satar. Sezgi "en büyük kalemi göm" der; oran sütunu "en durağan kalemi göm" der. Gömülemez iki kalem ölçünün alt sınırını çizer. Düğüm sırrı imaja yazılamaz, çünkü imajı okuyabilen herkes sırrı da okur; saat eşitlemesi imajdan gelemez, çünkü ölçülen şey açılış anıdır. Bu iki kalem 11 saniye ve 2 çağrıdır ve hiçbir pişirme kararı bunları kaldıramaz. #### Gömme Düzeyi Taraması Tek tek kalemler karşılaştırıldı; sıradaki soru kaç tanesinin gömüleceğidir. Aşağıdaki tarama oran sütununa göre sıralanmış listeyi baştan alır ve sıfırdan sekize kadar her düzeyde açılışı yeniden hesaplar. ```js // olcum-agi/gomme-taramasi.mjs — kac kalem imaja gomulurse acilis ne oluyor (model) import { HIZ, TABAN_MB, CEKIRDEK, PISIRME_DK, KALEM, GOMULEMEZ, SIRA, olc } from "./imaj-kalemleri.mjs"; export const duzey = (k) => { const gomulu = SIRA.slice(0, k), acik = SIRA.slice(k); const mb = TABAN_MB + gomulu.reduce((t, x) => t + x[2], 0); const sure = CEKIRDEK + mb / HIZ + acik.reduce((t, x) => t + x[1], 0) + GOMULEMEZ.reduce((t, x) => t + x[1], 0); const cagri = acik.reduce((t, x) => t + x[5], 0) + GOMULEMEZ.reduce((t, x) => t + x[3], 0); const tur = new Set([...acik.map((x) => x[4]), ...GOMULEMEZ.map((x) => x[2])]).size; return { k, mb, sure, cagri, tur, pisirme: gomulu.reduce((t, x) => t + olc(x).pisirme, 0), bayat: gomulu.reduce((t, x) => t + olc(x).bayat, 0), son: k ? SIRA[k - 1][0] : "—" }; }; if (import.meta.url === `file://${process.argv[1]}`) { console.log("gomulu".padEnd(9) + "son gomulen".padEnd(22) + "imaj".padEnd(10) + "acilis".padEnd(10) + "dis cagri".padEnd(11) + "bagimlilik".padEnd(12) + "ayda pisirme".padEnd(14) + "pisirici dk".padEnd(13) + "bayat kalem-gun"); for (let k = 0; k <= KALEM.length; k++) { const d = duzey(k); console.log(`${k}/${KALEM.length}`.padEnd(9) + d.son.padEnd(22) + `${d.mb} MB`.padEnd(10) + `${d.sure.toFixed(1)} sn`.padEnd(10) + String(d.cagri).padEnd(11) + `${d.tur} tur`.padEnd(12) + d.pisirme.toFixed(2).padEnd(14) + Math.round(d.pisirme * PISIRME_DK).toString().padEnd(13) + d.bayat.toFixed(1)); } const s = duzey(0), t = duzey(4), h = duzey(KALEM.length); console.log(`\nilk dort kalem: acilis ${(s.sure - t.sure).toFixed(1)} sn kisaliyor, ` + `${t.bayat.toFixed(1)} bayat kalem-gunune mal oluyor`); console.log(`son dort kalem: acilis ${(t.sure - h.sure).toFixed(1)} sn kisaliyor, ` + `${(h.bayat - t.bayat).toFixed(1)} bayat kalem-gunune mal oluyor`); console.log(`saniye basina bayatlik: ilk dortte ${(t.bayat / (s.sure - t.sure)).toFixed(2)}, ` + `son dortte ${((h.bayat - t.bayat) / (t.sure - h.sure)).toFixed(2)} kalem-gun/sn`); } ``` ``` gomulu son gomulen imaj acilis dis cagri bagimlilik ayda pisirme pisirici dk bayat kalem-gun 0/8 — 900 MB 183.0 sn 18 5 tur 0.00 0 0.0 1/8 cekirdek paketleri 1220 MB 142.3 sn 12 5 tur 0.67 12 2.3 2/8 calisma zamani 1430 MB 107.8 sn 9 5 tur 1.67 30 5.8 3/8 olcum aracisi 1490 MB 94.8 sn 7 5 tur 3.81 69 13.3 4/8 gunluk yonlendirme 1510 MB 87.2 sn 6 4 tur 5.24 94 18.3 5/8 sertifika demeti 1522 MB 78.4 sn 5 4 tur 9.52 171 33.3 6/8 uygulama ikilisi 1612 MB 57.9 sn 4 3 tur 24.52 441 85.8 7/8 ag ayarlari 1614 MB 51.9 sn 3 3 tur 34.52 621 120.8 8/8 ortam degiskenleri 1615 MB 48.9 sn 2 2 tur 64.52 1161 225.8 ilk dort kalem: acilis 95.8 sn kisaliyor, 18.3 bayat kalem-gunune mal oluyor son dort kalem: acilis 38.3 sn kisaliyor, 207.5 bayat kalem-gunune mal oluyor saniye basina bayatlik: ilk dortte 0.19, son dortte 5.42 kalem-gun/sn ``` Tarama tek bir eğri değil, **iki farklı eğridir**. Açılış süresi 183 saniyeden 48,9 saniyeye düşerken azalan getiri verir: ilk dört kalem 95,8 saniye kazandırır, son dört kalem 38,3 saniye. Bayatlık ise ters yönde ve hızlanarak artar: ilk dört kalem 18,3 bayat kalem-günü, son dört kalem 207,5 bayat kalem-günü ödetir. Son satır iki eğriyi tek sayıya çevirir — kazanılan saniyenin fiyatı ilk dörtte 0,19 kalem-gün, son dörtte 5,42 kalem-gündür. **Yirmi sekiz kat.** Pişirici dakika sütunu aynı şeyi işgücü tarafından yazar. Dört kalem gömülüyken imaj üretici ayda 94 dakika çalışır; sekiz kalem gömülüyken 1161 dakika — yaklaşık on dokuz saat. Bu, kimsenin plana yazmadığı ama her ay ödenen bir bedeldir ve pişirme hattının kendisinin izlenmesi gereken bir altyapı parçası olmasının nedenidir. Bağımlılık sütunu ise düz düşmez, **basamak basamak** düşer: 5 türden 4'e dördüncü kalemde, 3'e altıncıda, 2'ye sekizincide iner. Neden ilk dört kalemin dördünün de aynı bağımlılığı — paket deposunu — kullanmasıdır. Bir bağımlılık türü ancak ona bağlı **son** kalem de gömüldüğünde kalkar; ilk üç kalemi gömmek çağrıyı 18'den 7'ye indirir ama tür sayısını hiç değiştirmez. #### Açılışta Kalanın Yüzeyi Çağrı sayısı bir yüzey ölçüsüdür: her çağrı, açılış anında ayakta olması gereken ayrı bir şeydir. Ama bütün çağrılar aynı ağırlıkta değildir. Kimi kalem eksikse servis hiç başlamaz, kimi kalem eksikse makine açılır ve eksik çalışır. ```js // olcum-agi/acilis-yuzeyi.mjs — acilista kalan isin dis yuzeyi ve karar defteri (model) import { KALEM, GOMULEMEZ, SIRA } from "./imaj-kalemleri.mjs"; import { duzey } from "./gomme-taramasi.mjs"; const DUZEY = [0, 4, 8]; const acik = (k) => [...SIRA.slice(k).map(([ad, sn, , , b, c, kr]) => ({ ad, sn, b, c, kr })), ...GOMULEMEZ.map(([ad, sn, b, c, kr]) => ({ ad, sn, b, c, kr }))]; const etki = (k, bag) => { const l = acik(k).filter((x) => x.b === bag); if (!l.length) return "etkisiz"; if (l.some((x) => x.kr)) return "acilis basarisiz"; return `-${l.reduce((t, x) => t + x.sn, 0)} sn, ${l.length} kalem eksik`; }; // [kalem, kimde, geri alinabilir mi] const KARAR = [["imaja hangi kalem girer", "sende", "evet — yeni imaj"], ["taban isletim sistemi surumu", "sende", "evet — yeni imaj"], ["pisirme sikligi", "sende", "evet"], ["yayimlanmis imajin icerigi", "sende", "hayir — ayni kimlikle degismez"], ["imaja giren sir", "sende", "hayir — kopyalandiysa silmek yetmez"], ["ornege verilen baslangic betigi", "sende", "hayir — yaratildiktan sonra degismez"], ["imaj deposunun dayanikliligi", "saglayicida", "—"], ["imajin kopyalanma hizi", "saglayicida", "—"], ["taban imajin altindaki sanallastirma", "saglayicida", "—"]]; if (import.meta.url === `file://${process.argv[1]}`) { const BAG = [...new Set([...KALEM.map((x) => x[4]), ...GOMULEMEZ.map((x) => x[2])])]; console.log("dusen bagimlilik".padEnd(24) + DUZEY.map((k) => `${k}/8 gomulu`.padEnd(22)).join("").trimEnd()); for (const b of BAG) console.log((b.padEnd(24) + DUZEY.map((k) => etki(k, b).padEnd(22)).join("")).trimEnd()); console.log(""); console.log("duzey".padEnd(9) + "acilis".padEnd(10) + "acik kalem".padEnd(13) + "kritik acik kalem".padEnd(20) + "acilisi durduran bagimlilik"); for (const k of DUZEY) { const a = acik(k); console.log(`${k}/8`.padEnd(9) + `${duzey(k).sure.toFixed(1)} sn`.padEnd(10) + String(a.length).padEnd(13) + String(a.filter((x) => x.kr).length).padEnd(20) + String(new Set(a.filter((x) => x.kr).map((x) => x.b)).size)); } const say = (v) => KARAR.filter((x) => x[1] === v).length; console.log(`\nkarar defteri: ${say("sende")} kalem elde, ${say("saglayicida")} kalem saglayicida`); for (const [ad, , geri] of KARAR.filter((x) => x[2].startsWith("hayir"))) console.log(` geri alinamaz — ${ad.padEnd(32)} ${geri.slice(8)}`); } ``` ``` dusen bagimlilik 0/8 gomulu 4/8 gomulu 8/8 gomulu paket deposu acilis basarisiz etkisiz etkisiz yapilandirma sunucusu acilis basarisiz acilis basarisiz etkisiz yapim deposu acilis basarisiz acilis basarisiz etkisiz sir deposu acilis basarisiz acilis basarisiz acilis basarisiz zaman sunucusu -4 sn, 1 kalem eksik -4 sn, 1 kalem eksik -4 sn, 1 kalem eksik duzey acilis acik kalem kritik acik kalem acilisi durduran bagimlilik 0/8 183.0 sn 10 6 4 4/8 87.2 sn 6 4 3 8/8 48.9 sn 2 1 1 karar defteri: 6 kalem elde, 3 kalem saglayicida geri alinamaz — yayimlanmis imajin icerigi ayni kimlikle degismez geri alinamaz — imaja giren sir kopyalandiysa silmek yetmez geri alinamaz — ornege verilen baslangic betigi yaratildiktan sonra degismez ``` Açılışı durduran bağımlılık sayısı 4'ten 1'e iner ve bu, saniyeden bağımsız bir kazançtır. Hiçbir kalem gömülmemişken dört ayrı sistemin aynı anda ayakta olması gerekir; sekizi gömülmüşken tek bir sistem — sır deposu — kalır. Sır deposu satırı üç sütunda da aynıdır ve gömme kararıyla değiştirilemez. Zaman sunucusu satırı ise tek "yumuşak" satırdır: düşerse açılış tamamlanır, makine 4 saniye erken ve saati eşitlenmemiş olarak iş almaya başlar. Bu satır sessiz bir tuzağın yeridir. Ölçüm ağının okumaları zaman damgalıdır; saati eşitlenmemiş bir makinenin ürettiği kayıtlar başarısız açılıştan daha zor fark edilir, çünkü makine sağlıklı görünür. Kritik olmayan kalemin eksik açılması bir hata değil, bir karardır. Karar defteri dokuz kalemin **altısını elde bırakır**: imaja ne gireceği, taban sürümün ne olacağı, ne sıklıkta pişirileceği ve üç geri alınamayan kalem. Sağlayıcıda kalan üçü — imaj deposunun dayanıklılığı, kopyalanma hızı, altındaki sanallaştırma — çekme saniyesini belirler ama seçilemez. Geri alınamayan üç kalem birbirinden farklı biçimde geri alınamaz. Yayımlanmış imajın içeriği aynı kimlikle değişmez; düzeltmek yeni bir imaj demektir ve o imaj eskisini silmez. İmaja giren sır, imaj bir kez kopyalandıysa silinerek geri alınamaz; bu yüzden sır deposu çağrısı bir eksiklik değil, bir tercihtir. Örneğe verilen başlangıç betiği ise örnek yaratılırken verilir ve o örnek yaşadığı sürece değişmez — betiği düzeltmek çalışan makineyi düzeltmez, yalnız **bundan sonra yaratılacak** makineleri düzeltir. #### Özet - Bir kalemin gömülmeye uygunluğunu boyutu değil değişim sıklığı belirler: `cekirdek paketleri` pişirme başına 61 saniye kazandırır, `ortam degiskenleri` 0,1 saniye — altı yüz kat fark. - `uygulama ikilisi` açılışta 22 saniye tutar ama iki günde bir değişir; gömülürse ayda 15 pişirme ve 52,5 bayat kalem-günü ödetir, aynı saniyeyi `calisma zamani` 3,5 kalem-güne satar. - Gömme düzeyi taramasında açılış 183 saniyeden 48,9 saniyeye iner; kazanılan saniyenin fiyatı ilk dört kalemde 0,19, son dört kalemde 5,42 bayat kalem-günüdür. - Dış çağrı 18'den 2'ye düşer ama bağımlılık türü basamak basamak iner: bir tür ancak ona bağlı son kalem de gömüldüğünde kalkar; pişirici yükü 94 dakikadan 1161 dakikaya çıkar. - Açılışı durduran bağımlılık 4'ten 1'e iner, sıfıra inmez; zaman sunucusu düşerse makine açılır ve saati eşitlenmemiş olarak iş alır — başarısız açılıştan daha zor görülen bir durumdur. - Dokuz kalemin altısı elde, üçü sağlayıcıdadır; geri alınamayan üç kalem yayımlanmış imajın içeriği, imaja giren sır ve örneğe verilen başlangıç betiğidir. #### Sonraki Adım Bu ders açılışın ne kadar sürdüğünü ve neye bağlı olduğunu saydı, ama makinenin **ne kadar yaşayacağını** hiç sormadı. Bütün hesap örneğin istendiği sürece ayakta kalacağı varsayımı üzerine kuruldu: 183 saniye de 48,9 saniye de bir kez ödenir, sonra makine iş yapmaya devam eder. Kiralamanın bir de kesintili biçimi vardır — kapasite ucuza verilir, karşılığında sağlayıcı onu kısa bir bildirimle geri alabilir. Önceki kurs bu biçimin fiyat farkını ölçtü; burada fiyat girdi olur ve soru iş türüne kayar. Sonraki ders dört iş türünü kesintili kapasitede koşturur ve sorar: bildirim süresi kısaldıkça hangi iş ne kadar iş kaybediyor, yeniden başlamak ne tutuyor ve hangi iş kesintiye hiç dayanmıyor? ### Kalıcı ve Kesintili Kapasite Source: https://academia.sh/tr/kurslar/bulut-hesaplama-ve-ag/kalici-ve-kesintili-kapasite Dört iş türü kesintili kapasitede koşturulur ve kesinti bildirimi sıfırdan üç yüz saniyeye taranarak her türde kaybedilen iş sayılır; otuz günlük bir dönemde kesinti sayısı, kaybedilen iş-saati, yeniden başlama yükü ve tamamlanma oranı çıkarılır; kesintiye hiç dayanmayan iş türü adıyla yazılır ve kalıcı ile kesintilinin karışımı taranır. Önceki iki ders makineyi kiraladı ve açtı; ikisi de aynı varsayımın üzerinde durdu — örnek istendiği sürece ayakta kalır. Kiralamanın bir de bu varsayımı kaldıran biçimi vardır: **kesintili kapasite**, sağlayıcının başka bir yere gerektiğinde kısa bir bildirimle geri alabildiği kapasitedir ve karşılığında belirgin biçimde ucuza verilir. M23/K01 bu iki biçimin fiyat farkını ölçtü; o karşılaştırma burada tekrarlanmaz, **girdi olarak alınır**. Bu dersin sorusu fiyat değil, **iş türüdür**: aynı indirim dört farklı işe verildiğinde dördü de aynı şeyi kazanmaz, çünkü kesinti geldiğinde dördü aynı şeyi kaybetmez. Ölçü, kesintinin kendisi değil, kesintinin **ne götürdüğüdür**. **BH13.** Dört iş türü bölgesel ölçüm ağının — su sayaçlarından okuma toplayan kurgu yazılımın — işleridir; süreleri ve örnek sayıları kurgudur. **BH14.** Kesinti oranı 0,06 kesinti/örnek-saattir; üreteç kendi yazılmıştır ve tohum 20260901 görünürdür. **BH15.** Bildirim süresi 0 ile 300 saniye arasında taranır; her iş türünün kurtarma süresi kurgudur. **BH16.** Kalıcı kapasite 1,00, kesintili kapasite 0,32 **kurgu birimdir**; oran M23/K01'den girdi olarak gelir, gerçek bir para birimi değildir. **BH17.** Uzun koşum ara kayıt tutmaz; kesildiğinde baştan başlar. **BH18.** Dönem 30 gündür. #### Hangi İş Ne Kaybeder Kesinti bildirimi bir haber değil, bir penceredir: kapasite geri alınmadan önce elde kalan süredir. O pencerede yapılabilecek tek şey işi kurtarmaktır ve her iş türünün kurtarma işlemi farklı sürer. Pencere kurtarma süresinden kısaysa bildirim hiçbir işe yaramaz. ```js // olcum-agi/is-turleri.mjs — dort is turunun kesintide kaybettigi is (model; urun degil tur) export const uretec = (tohum) => () => (tohum = (tohum * 1103515245 + 12345) % 2147483648) / 2147483648; export const BILDIRIM = [0, 30, 60, 120, 300]; // taranan kesinti bildirimi (sn) // kurtar: bildirim penceresinde isi kurtarmak icin gereken saniye (yetmezse kayip olusur). // kayip: kurtarilamazsa bir kesintide kaybedilen is (dakika). yeniden: yeniden baslama (dakika). export const IS = [ { ad: "gecelik toplu is", ornek: 12, saat: 6, kurtar: 45, kayip: 15, yeniden: 4, birim: "ara kayittan beri gecen 15 dk" }, { ad: "kuyruk iscisi", ornek: 20, saat: 24, kurtar: 90, kayip: 0.75, yeniden: 3, birim: "yarim gorev, kuyruga doner" }, { ad: "uzun suren tek kosum", ornek: 4, saat: 20, kurtar: 660, kayip: 600, yeniden: 6, birim: "kosumun yarisi, 10 sa" }, { ad: "kullaniciya yanit veren servis", ornek: 30, saat: 24, kurtar: 20, kayip: 0.08, yeniden: 2, birim: "akistaki 24 istek" }, ]; export const kayip = (is, b) => (b >= is.kurtar ? 0 : is.kayip); if (import.meta.url === `file://${process.argv[1]}`) { console.log("is turu".padEnd(32) + "kurtarma".padEnd(11) + BILDIRIM.map((b) => `${b} sn`.padEnd(9)).join("") + "kesintide kaybedilen"); for (const is of IS) console.log(is.ad.padEnd(32) + `${is.kurtar} sn`.padEnd(11) + BILDIRIM.map((b) => `${kayip(is, b).toFixed(2)}`.padEnd(9)).join("") + is.birim); console.log("\n(hucreler bir kesintide kaybedilen is-dakikasidir)"); const dayanmaz = IS.filter((is) => BILDIRIM.every((b) => kayip(is, b) > 0)); console.log(`bildirim taramasinin hicbir degerinde kaybi sifirlanmayan is: ` + dayanmaz.map((x) => x.ad).join(", ")); console.log(`gerekcesi: kurtarma ${dayanmaz[0].kurtar} sn istiyor, taramanin en uzun ` + `bildirimi ${Math.max(...BILDIRIM)} sn`); } ``` ``` is turu kurtarma 0 sn 30 sn 60 sn 120 sn 300 sn kesintide kaybedilen gecelik toplu is 45 sn 15.00 15.00 0.00 0.00 0.00 ara kayittan beri gecen 15 dk kuyruk iscisi 90 sn 0.75 0.75 0.75 0.00 0.00 yarim gorev, kuyruga doner uzun suren tek kosum 660 sn 600.00 600.00 600.00 600.00 600.00 kosumun yarisi, 10 sa kullaniciya yanit veren servis 20 sn 0.08 0.00 0.00 0.00 0.00 akistaki 24 istek (hucreler bir kesintide kaybedilen is-dakikasidir) bildirim taramasinin hicbir degerinde kaybi sifirlanmayan is: uzun suren tek kosum gerekcesi: kurtarma 660 sn istiyor, taramanin en uzun bildirimi 300 sn ``` Tabloda üç satır bir eşikte sıfırlanır, bir satır hiç sıfırlanmaz. Kullanıcıya yanıt veren servis 20 saniyede boşalır ve 30 saniyelik bildirimde kaybı biter; gecelik toplu iş 45 saniyede acil bir ara kayıt alır ve 60 saniyede kurtulur; kuyruk işçisi elindeki 90 saniyelik görevi bitirebilirse kaybetmez. Bu üçünde kesintiye dayanmayı sağlayan şey kapasitenin türü değil, **işin bölünebilir olmasıdır**: iş küçük parçalara ayrılmışsa bir parçadan fazlası kaybolmaz. Dördüncü satır bölünmemiş işin ne olduğunu gösterir. Ara kaydı olmayan 20 saatlik koşum, kesinti geldiğinde o ana kadarki bütün ilerlemeyi kaybeder ve bunu kurtarmak 660 saniyelik bir ara kayıt ister. Taramanın en uzun bildirimi 300 saniyedir; **bildirim ne kadar uzarsa uzasın kayıp değişmez**. Kesintiye hiç dayanmayan iş budur ve adı `uzun suren tek kosum`'dur. Çözümü daha uzun bir bildirim değildir — işin kendisini bölmektir, yani ara kayıt eklemektir; bu da kapasite kararı değil, uygulama kararıdır. #### Otuz Günlük Dönem Kesinti başına kayıp bir birim fiyattır; asıl soru bu birimin ayda kaç kez ödendiğidir. Aşağıdaki koşum aynı üreteçle 30 günlük bir dönem üretir ve iki bildirim düzeyini — sıfır ve 120 saniye — aynı kesinti dizisi üzerinde karşılaştırır. ```js // olcum-agi/kesinti-donemi.mjs — 30 gunluk kesintili kapasite kosumu (model) import { uretec, IS, kayip } from "./is-turleri.mjs"; export const GUN = 30, ORAN = 0.06; // kesinti/ornek-saat (kurgu) const r = uretec(20260901); // tohum gorunur export const kosum = (is) => { const saat = is.ornek * is.saat * GUN; let kesinti = 0; for (let i = 0; i < saat; i++) if (r() < ORAN) kesinti++; const yeniden = kesinti * is.yeniden; const olc = (b) => (60 * saat) / (60 * saat + kesinti * kayip(is, b) + yeniden); return { saat, kesinti, yeniden, sifir: kesinti * kayip(is, 0), yuz: kesinti * kayip(is, 120), verimSifir: olc(0), verimYuz: olc(120) }; }; // Ara kaydi olmayan 20 saatlik kosum: her denemede bastan baslar. export const tekKosum = (is) => { const TOPLAM = GUN * 24; let gecen = 0, deneme = 0, biten = 0, bosa = 0; while (gecen < TOPLAM) { deneme++; let h = 0; while (h < is.saat && gecen < TOPLAM) { h++; gecen++; if (r() < ORAN) break; } if (h === is.saat) biten++; else { bosa += h; gecen += is.yeniden / 60; } } return { deneme, biten, bosa, kalici: Math.floor(TOPLAM / is.saat) }; }; if (import.meta.url === `file://${process.argv[1]}`) { console.log(`${GUN} gun, kesinti orani ${ORAN}/ornek-saat, tohum 20260901\n`); console.log("is turu".padEnd(32) + "ornek-saat".padEnd(12) + "kesinti".padEnd(10) + "kayip sa (0 sn)".padEnd(17) + "kayip sa (120 sn)".padEnd(19) + "yeniden sa".padEnd(12) + "verim 0 sn".padEnd(12) + "verim 120 sn"); const s = {}; for (const is of IS) { const k = (s[is.ad] = kosum(is)); console.log(is.ad.padEnd(32) + String(k.saat).padEnd(12) + String(k.kesinti).padEnd(10) + (k.sifir / 60).toFixed(1).padEnd(17) + (k.yuz / 60).toFixed(1).padEnd(19) + (k.yeniden / 60).toFixed(1).padEnd(12) + `%${(100 * k.verimSifir).toFixed(1)}`.padEnd(12) + `%${(100 * k.verimYuz).toFixed(1)}`); } const uzun = IS.find((x) => x.ad === "uzun suren tek kosum"); const t = tekKosum(uzun); console.log(`\nara kaydi olmayan ${uzun.saat} saatlik kosum: ${t.deneme} deneme, ` + `${t.biten} tamamlanma; kalici kapasitede ${t.kalici} tamamlanma`); console.log(`bosa giden kosum saati: ${t.bosa}; tamamlanma orani ` + `%${(100 * t.biten / t.kalici).toFixed(0)}`); const srv = s["kullaniciya yanit veren servis"], kuy = s["kuyruk iscisi"]; console.log(`0 sn bildirimde: servis ${srv.kesinti * 24} istek dusuruyor, ` + `kuyruk ${kuy.kesinti} gorevi kuyruga geri koyuyor`); } ``` ``` 30 gun, kesinti orani 0.06/ornek-saat, tohum 20260901 is turu ornek-saat kesinti kayip sa (0 sn) kayip sa (120 sn) yeniden sa verim 0 sn verim 120 sn gecelik toplu is 2160 137 34.3 0.0 9.1 %98.0 %99.6 kuyruk iscisi 14400 964 12.1 0.0 48.2 %99.6 %99.7 uzun suren tek kosum 2400 164 1640.0 1640.0 16.4 %59.2 %59.2 kullaniciya yanit veren servis 21600 1450 1.9 0.0 48.3 %99.8 %99.8 ara kaydi olmayan 20 saatlik kosum: 66 deneme, 15 tamamlanma; kalici kapasitede 36 tamamlanma bosa giden kosum saati: 415; tamamlanma orani %42 0 sn bildirimde: servis 34800 istek dusuruyor, kuyruk 964 gorevi kuyruga geri koyuyor ``` Bildirimin değeri iş türüne göre başka bir yerde birikir. Gecelik toplu işte 120 saniyelik bildirim ayda 34,3 iş-saatini kurtarır — bir ayın toplam işinin yüzde 1,6'sı. Servis satırında kurtarılan iş yalnız 1,9 saattir, ama o 1,9 saatin içinde **34.800 istek** vardır ve her biri bir kullanıcının beklediği bir yanıttır. Aynı ölçü birimi iki iş türünde farklı şey ifade eder: toplu işte kaybedilen şey zaman, serviste kaybedilen şey kullanıcıdır. Yeniden başlama sütunu bildirimle hiç kurtulamayan bedeldir. Servis ayda 1450 kesinti alır ve her biri iki dakikalık bir açılış ister; toplamı 48,3 saattir — kurtarılan 1,9 saatin yirmi beş katı. Kesintili kapasitede açılış süresi bir kereye mahsus değildir; önceki dersin 48,9 saniyesi burada ayda 1450 kez ödenen bir kalemdir. Üçüncü satır iki kere okunmalıdır. Kaba hesap, ortalama kaybı koşumun yarısı sayar ve verimi yüzde 59,2 bulur. Deneme deneme koşturulduğunda gerçek **yüzde 42** çıkar: 66 denemenin yalnız 15'i tamamlanır, 415 koşum saati boşa gider ve kalıcı kapasitede ayda 36 kez biten iş kesintilide 15 kez biter. Ortalama kayıp varsayımı burada yanıltır, çünkü kayıp koşumun yarısı değil, **kesintiye kadar geçen sürenin tamamıdır** ve uzun koşumda bu süre beklenenden büyüktür. #### Bedel ve Karışım Kayıp sayıldıktan sonra fiyat farkı anlamlı hale gelir. Kesintili kapasite ucuzdur ama kaybedilen iş yeniden yapılır; yeniden yapılan iş de saat tutar. Karşılaştırma bu yüzden birim fiyat üzerinden değil, **aynı işi bitirmek için tutulan saat** üzerinden yapılır. ```js // olcum-agi/kapasite-bedeli.mjs — kalici ile kesintili kapasitenin is turu basina bedeli (model) import { IS } from "./is-turleri.mjs"; import { kosum, tekKosum } from "./kesinti-donemi.mjs"; const KALICI = 1.0, KESINTILI = 0.32; // M23/K01'den girdi: kurgu birim, gercek fiyat degil const KARISIM = [1.0, 0.7, 0.5, 0.3]; // kalici payi taramasi // Uretec sirasi onceki kosumla ayni tutulur: once dort is, sonra tek kosum denemesi. const K = IS.map(kosum), T = tekKosum(IS[2]); if (import.meta.url === `file://${process.argv[1]}`) { console.log(`kalici ${KALICI.toFixed(2)} birim/ornek-saat, kesintili ${KESINTILI} birim ` + `(kurgu; basabas verim %${(100 * KESINTILI / KALICI).toFixed(0)})\n`); console.log("is turu".padEnd(32) + "verim".padEnd(9) + "kalici birim".padEnd(14) + "kesintili birim".padEnd(17) + "tasarruf".padEnd(11) + "sure carpani"); IS.forEach((is, i) => { const k = K[i], verim = i === 2 ? T.biten / T.kalici : k.verimYuz; const kalici = k.saat * KALICI, kesintili = (k.saat / verim) * KESINTILI; console.log(is.ad.padEnd(32) + `%${(100 * verim).toFixed(1)}`.padEnd(9) + kalici.toFixed(0).padEnd(14) + kesintili.toFixed(0).padEnd(17) + `%${(100 * (1 - kesintili / kalici)).toFixed(0)}`.padEnd(11) + (1 / verim).toFixed(2)); }); const srv = IS[3], s = K[3]; console.log("\nservis icin kalici/kesintili karisimi (30 ornek, ayni kapasite):"); console.log("kalici pay".padEnd(13) + "kalici ornek".padEnd(14) + "kesintili ornek".padEnd(17) + "aylik birim".padEnd(13) + "bir anda kaybedilebilir"); for (const p of KARISIM) { const kal = Math.round(srv.ornek * p), kes = srv.ornek - kal; const birim = (kal * KALICI + (kes / s.verimYuz) * KESINTILI) * srv.saat * 30; console.log(`%${(100 * p).toFixed(0)}`.padEnd(13) + String(kal).padEnd(14) + String(kes).padEnd(17) + birim.toFixed(0).padEnd(13) + `%${(100 * kes / srv.ornek).toFixed(0)} kapasite`); } const ELDE = ["is turunun kesintili kapasiteye konmasi", "ara kayit sikligi", "bildirim penceresinde yapilacak is", "kalici/kesintili karisim orani", "yeniden deneme politikasi"]; const DEVIR = ["kesinti ani", "bildirim suresi", "ayni anda geri alinan ornek sayisi", "kapasitenin geri gelme zamani"]; const GERI_YOK = ["kesilen ornegin yerel diskindeki kaydedilmemis is", "bildirim penceresinde yarim kalan dis yazma", "kosum baslayinca ara kayit eklenememesi"]; console.log(`\nkarar defteri: ${ELDE.length} kalem elde, ${DEVIR.length} kalem saglayicida`); console.log(` saglayicida: ${DEVIR.join(", ")}`); for (const g of GERI_YOK) console.log(` geri alinamaz — ${g}`); } ``` ``` kalici 1.00 birim/ornek-saat, kesintili 0.32 birim (kurgu; basabas verim %32) is turu verim kalici birim kesintili birim tasarruf sure carpani gecelik toplu is %99.6 2160 694 %68 1.00 kuyruk iscisi %99.7 14400 4623 %68 1.00 uzun suren tek kosum %41.7 2400 1843 %23 2.40 kullaniciya yanit veren servis %99.8 21600 6927 %68 1.00 servis icin kalici/kesintili karisimi (30 ornek, ayni kapasite): kalici pay kalici ornek kesintili ornek aylik birim bir anda kaybedilebilir %100 30 0 21600 %0 kapasite %70 21 9 17198 %30 kapasite %50 15 15 14264 %50 kapasite %30 9 21 11329 %70 kapasite karar defteri: 5 kalem elde, 4 kalem saglayicida saglayicida: kesinti ani, bildirim suresi, ayni anda geri alinan ornek sayisi, kapasitenin geri gelme zamani geri alinamaz — kesilen ornegin yerel diskindeki kaydedilmemis is geri alinamaz — bildirim penceresinde yarim kalan dis yazma geri alinamaz — kosum baslayinca ara kayit eklenememesi ``` Tasarruf sütunu üç iş türünde aynıdır — yüzde 68 — ve bu, verimin yüzde 99'un üstünde kaldığı her işin indirimin tamamını aldığı anlamına gelir. Uzun koşumda tasarruf yüzde 23'e iner. Dikkat çeken şey tasarrufun **hâlâ artı olmasıdır**: başabaş verim yüzde 32'dir ve koşumun verimi yüzde 41,7, yani eşiğin üstündedir. Kesintili kapasite bu iş için de kâğıt üzerinde ucuzdur. Kararı ucuzluk vermez, son sütun verir. Süre çarpanı 2,40'tır: aynı koşum kesintili kapasitede iki buçuk kat uzun sürer ve ayda 36 yerine 15 kez biter. Gecelik bir rapor iki gün gecikiyorsa ödenen şey birim değil, **sonucun geç gelmesidir** ve o bedel bu tabloda hiç görünmez. Ucuzluk ölçülebilir, gecikmenin değeri işe göre değişir — kesintili kapasitenin gerçek sınırı buradadır. Karışım tablosu servisin ara yolunu sayar. Kapasitenin yüzde 30'u kesintiliye çevrilince aylık bedel 21.600'den 17.198 birime iner ve bir anda kaybedilebilecek kapasite yüzde 30'a çıkar; yüzde 70'i çevrilince bedel 11.329'a iner ama kapasitenin yüzde 70'i tek bir kararla geri alınabilir hale gelir. Kalıcı pay, kesinti anında ayakta kalması gereken en küçük kapasitedir. Karar defterinde dokuz kalemin **beşi elde, dördü sağlayıcıdadır** — ve devredilen dördü bu kursta şimdiye kadarki en ağır devirdir, çünkü içlerinde kesintinin **anı** vardır. Geri alınamayan üç kalem de bu devirden doğar: kesilen örneğin yerel diskindeki kaydedilmemiş iş geri gelmez, bildirim penceresinde yarım kalan bir dış yazma geri alınmaz ve koşum başladıktan sonra ara kayıt eklenemez. Üçüncüsü en sinsisidir: kesintili kapasiteye geçiş kararı geri alınabilir, ama **o anda koşan işin** kesintiye dayanıp dayanmadığı koşum sırasında değiştirilemez. #### Özet - Bildirim penceresi ancak kurtarma süresinden uzunsa işe yarar: servis 20, toplu iş 45, kuyruk işçisi 90 saniyede kurtulur; ara kaydı olmayan 20 saatlik koşum 660 saniye ister ve taramanın hiçbir değerinde kaybı sıfırlanmaz. - Kesintiye hiç dayanmayan iş `uzun suren tek kosum`'dur; çözümü daha uzun bildirim değil, işin bölünmesidir — bu da kapasite değil uygulama kararıdır. - Aynı ölçü birimi farklı şey anlatır: 120 saniyelik bildirim toplu işte ayda 34,3 iş-saati, serviste 1,9 saat kurtarır — ama o 1,9 saat 34.800 istektir. - Yeniden başlama bildirimle kurtulmayan bedeldir: servis ayda 1450 kesinti alır ve 48,3 saat açılışa gider, kurtarılan sürenin yirmi beş katı. - Ortalama kayıp varsayımı uzun koşumda yanıltır: kaba hesap yüzde 59,2 verim der, deneme deneme koşumda yüzde 42 çıkar — 66 denemenin 15'i tamamlanır, 415 saat boşa gider. - Dokuz kalemin beşi elde, dördü sağlayıcıdadır; kesintili kapasite üç iş türünde yüzde 68 tasarruf verir, uzun koşumda yüzde 23 verir ama süreyi 2,40 katına çıkarır. #### Sonraki Adım Bu üç ders bir örneğin bütün kararlarını saydı: ailesi, boyutu, imajı, açılışta yaptığı iş, kalıcı mı kesintili mi olduğu. Sayılan her kalem tek bir örnek için verilmiş bir karardır — ve kesintili kapasite bölümü bu kararların **sık sık yeniden verildiğini** gösterdi: ayda 1450 örnek açılıyor. O 1450 örneğin her birinde aynı aile, aynı boyut, aynı imaj, aynı alt ağ ve aynı başlangıç betiği seçilmek zorundadır. Elle başlatılan bir örnekte bu seçimlerin her biri ayrı bir yazma işlemidir ve her yazma bir sapma fırsatıdır. Sonraki ders bu kalemleri tek bir tanıma toplar ve sorar: elle başlatılan örneklerle şablondan başlatılanlar bir dönem sonunda kaç kalemde birbirinden ayrışıyor, şablon güncellenince kaç örnek geride kalıyor ve şablonun kendisi kaç girdilik bir yüzey açıyor? ### Başlatma Şablonları Source: https://academia.sh/tr/kurslar/bulut-hesaplama-ve-ag/baslatma-sablonlari Elle başlatılan örneklerle şablondan başlatılanlar bir dönem sonunda alan alan karşılaştırılır ve ayrışan örnek ile ayrı yapılandırma varyantı sayılır; şablon güncellendiğinde geride kalan örnek, aynı anda koşan sürüm sayısı ve bir güvenlik düzeltmesinin ulaşmadığı örnek çıkarılır; şablonun kendi girdi yüzeyi ile geri alınamayan alanları adıyla yazılır. Önceki ders kesintili kapasitede ayda 1450 örnek açıldığını saydı. O 1450 açılışın her birinde aynı aile, aynı boyut, aynı imaj, aynı alt ağ ve aynı başlangıç betiği seçilir. Seçim elle yapılıyorsa her açılış ayrı bir yazma işlemidir; ayrı her yazma, tanımdan ayrılma fırsatıdır. **Başlatma şablonu** bu kalemleri tek bir tanıma toplar: örnek başlatılırken tek tek alan verilmez, şablonun adı verilir. Bu ders şablonun ne kadarını kapattığını ölçer. Ölçüm üç yerde yapılır — başlatma anındaki sapmada, şablon güncellendiğinde geride kalan örnekte ve şablonun kendi girdi yüzeyinde. M22/K01 sapmayı aynı biçimde, tanımdan ayrışan makine sayısı olarak ölçmüştü; buradaki büyüklük aynıdır ama kaynağı çalışırken oluşan sürüklenme değil, **başlatma anında yapılan yazmadır**. **BH19.** Şablon 12 alanlıdır; alanlar ve sapma olasılıkları kurgudur. **BH20.** Dönem boyunca bölgesel ölçüm ağının — su sayaçlarından okuma toplayan kurgu yazılımın — 140 örneği başlatılır; tohum 20260915 görünürdür ve üreteç kendi yazılmıştır. **BH21.** Filo 60 örnektir, 90 gün koşar, her örneğin günlük değiştirilme olasılığı 0,02'dir ve şablon 21 günde bir güncellenir; tohum 20260921. **BH22.** Bir güvenlik düzeltmesi şablonun ikinci sürümüyle gelir. **BH23.** Yerinde düzeltme 4, yeniden yaratma 35 dakikadır ve aynı anda 2 örnek ele alınır. **BH24.** Geçersiz kılma bilerek yapılan bir iştir ve kaza sapmasından ayrı modellenir. #### Aynı Tanımı Kaç Kez Yazmak Elle başlatmada her alan her seferinde ayrı verilir; şablonda alan bir kez verilir ve başlatma anında yalnız **geçersiz kılınabilir**. İki yol aynı dönemde koşturulup alan alan sayıldığında farkın nerede olduğu görünür. ```js // olcum-agi/sablon-alanlari.mjs — elle baslatma ile sablondan baslatmanin sapmasi (model) export const uretec = (tohum) => () => (tohum = (tohum * 1103515245 + 12345) % 2147483648) / 2147483648; export const BASLATMA = 140; // donem boyunca baslatilan ornek (kurgu) // [ad, zorunlu mu, gecersiz kilinabilir mi, yaratildiktan sonra degisir mi, elle sapma, gecersiz kilma] export const ALAN = [ ["ornek ailesi ve boyutu", true, true, true, 0.09, 0.020], ["makine imaji", true, true, false, 0.11, 0.010], ["alt ag", true, true, false, 0.06, 0.005], ["guvenlik grubu", true, true, true, 0.08, 0.010], ["anahtar kimligi", true, true, true, 0.05, 0.005], ["kok disk boyutu", false, true, true, 0.12, 0.020], ["kok disk sifrelemesi", false, true, false, 0.07, 0.005], ["baslangic betigi", false, true, false, 0.10, 0.015], ["kiralama bicimi", false, true, false, 0.04, 0.030], ["yerlestirme tercihi", false, false, false, 0.05, 0.000], ["etiketler", false, true, true, 0.18, 0.040], ["izleme aracisi", false, true, true, 0.09, 0.005], ]; // Yaratildiktan sonra degismeyen alanlar: sapmasi yerinde duzeltilemez, ornek yeniden yaratilir. export const GERI_YOK = ALAN.map(([, , , deg], j) => (deg ? -1 : j)).filter((j) => j >= 0); export const donem = (tohum) => { const r = uretec(tohum), sapan = ALAN.map(() => [0, 0]), imza = [new Set(), new Set()]; const duzeltme = [[0, 0], [0, 0]]; // [yeniden yaratma, yerinde duzeltme] for (let i = 0; i < BASLATMA; i++) { const iz = [[], []]; ALAN.forEach(([, , gecersiz, , elle, sab], j) => { if (r() < elle) { sapan[j][0]++; iz[0].push(j); } if (gecersiz && r() < sab) { sapan[j][1]++; iz[1].push(j); } }); imza[0].add(iz[0].join(",")); imza[1].add(iz[1].join(",")); [0, 1].forEach((k) => { if (iz[k].some((j) => GERI_YOK.includes(j))) duzeltme[k][0]++; else if (iz[k].length) duzeltme[k][1]++; }); } return { sapan, duzeltme, varyant: imza.map((s) => s.size) }; }; if (import.meta.url === `file://${process.argv[1]}`) { const d = donem(20260915); console.log(`${BASLATMA} ornek baslatildi; tohum 20260915\n`); console.log("alan".padEnd(24) + "zorunlu".padEnd(9) + "gecersiz kilinir".padEnd(18) + "sonradan degisir".padEnd(18) + "elle sapan".padEnd(12) + "sablonla sapan"); ALAN.forEach(([ad, zor, gec, deg], j) => console.log(ad.padEnd(24) + (zor ? "evet" : "hayir").padEnd(9) + (gec ? "evet" : "hayir").padEnd(18) + (deg ? "evet" : "hayir").padEnd(18) + `${d.sapan[j][0]}/${BASLATMA}`.padEnd(12) + `${d.sapan[j][1]}/${BASLATMA}`)); const t = [0, 1].map((k) => d.sapan.reduce((s, x) => s + x[k], 0)); console.log(`\ntoplam alan sapmasi: elle ${t[0]}, sablonla ${t[1]} (${(t[0] / t[1]).toFixed(1)} kat)`); console.log(`ayri yapilandirma varyanti: elle ${d.varyant[0]}, sablonla ${d.varyant[1]}`); } ``` ``` 140 ornek baslatildi; tohum 20260915 alan zorunlu gecersiz kilinir sonradan degisir elle sapan sablonla sapan ornek ailesi ve boyutu evet evet evet 8/140 5/140 makine imaji evet evet hayir 12/140 4/140 alt ag evet evet hayir 10/140 0/140 guvenlik grubu evet evet evet 9/140 1/140 anahtar kimligi evet evet evet 8/140 2/140 kok disk boyutu hayir evet evet 18/140 2/140 kok disk sifrelemesi hayir evet hayir 6/140 1/140 baslangic betigi hayir evet hayir 12/140 2/140 kiralama bicimi hayir evet hayir 5/140 7/140 yerlestirme tercihi hayir hayir hayir 4/140 0/140 etiketler hayir evet evet 30/140 9/140 izleme aracisi hayir evet evet 12/140 1/140 toplam alan sapmasi: elle 134, sablonla 34 (3.9 kat) ayri yapilandirma varyanti: elle 38, sablonla 13 ``` Toplam sapma 134'ten 34'e iner — dört kata yakın. Ama asıl sayı son satırdadır: elle başlatılan 140 örnek **38 ayrı yapılandırma varyantı** üretir, şablondan başlatılanlar 13. Varyant sayısı filonun kaç farklı şeyden oluştuğunu söyler; bir sorun araştırılırken karşılaşılan soru "bu makine diğerlerinden nasıl farklı" olduğunda cevabın kaç yerde aranacağını belirleyen budur. `alt ag` ve `yerlestirme tercihi` satırları şablonun ne kadar kapatabildiğinin sınırını çizer. Yerleştirme tercihi geçersiz kılınamayan tek alandır ve şablon yolunda sapması **sıfırdır** — tam korunan tek alan odur. Alt ağ geçersiz kılınabilir olduğu halde yine sıfır çıkar, çünkü kimse onu bilerek değiştirmez; koruma buradaki gibi çoğu zaman yeterlidir ama garanti değildir. `kiralama bicimi` satırı tersini gösterir ve dikkatle okunmalıdır: şablon yolunda sapma **elleden yüksektir** — 7'ye karşı 5. Bu bir hata değil, bir kullanımdır. Önceki dersin sonucu iş türüne göre kalıcı ile kesintili arasında seçim yapmayı gerektirir ve o seçim örnek başına verilir. Şablon kaza sapmasını kaldırır; **bilerek yapılan geçersiz kılmayı kaldırmaz** ve kaldırmamalıdır. Ölçünün işi ikisini ayırmaktır, ikisini birden bastırmak değil. #### Şablon Güncellenince Ne Oluyor Şablon bir tanımdır; tanımın değişmesi çalışan örnekleri değiştirmez. Bir örnek hangi sürümle başlatıldıysa ömrü boyunca o sürümü taşır. Bu yüzden şablonun sürümü ile filonun sürümü aynı şey değildir. ```js // olcum-agi/sablon-surumu.mjs — sablon guncellenince kac ornek geride kaliyor (model) import { uretec } from "./sablon-alanlari.mjs"; const FILO = 60, GUN = 90, DEGISIM = 0.02, ARALIK = 21; // gunluk ornek degistirme olasiligi const DUZELTME = 2; // guvenlik duzeltmesinin girdigi surum export const kosum = (tohum = 20260921) => { const r = uretec(tohum); const ornek = Array.from({ length: FILO }, () => ({ surum: 0, dogum: 0 })); const surumler = [{ no: 0, gun: 0, baslatilan: FILO }]; for (let g = 1; g <= GUN; g++) { if (g % ARALIK === 0) surumler.push({ no: surumler.length, gun: g, baslatilan: 0 }); const su = surumler[surumler.length - 1]; for (const o of ornek) if (r() < DEGISIM) { o.surum = su.no; o.dogum = g; su.baslatilan++; } } return { ornek, surumler }; }; if (import.meta.url === `file://${process.argv[1]}`) { const { ornek, surumler } = kosum(); console.log(`${FILO} ornek, ${GUN} gun, gunluk degistirme olasiligi ${DEGISIM}, ` + `sablon ${ARALIK} gunde bir guncelleniyor; tohum 20260921\n`); console.log("surum".padEnd(9) + "cikis gunu".padEnd(13) + "bu surumle baslatilan".padEnd(23) + "donem sonunda kosan".padEnd(21) + "en eski ornegin yasi"); for (const s of surumler) { const k = ornek.filter((o) => o.surum === s.no); console.log(`v${s.no}`.padEnd(9) + `gun ${s.gun}`.padEnd(13) + String(s.baslatilan).padEnd(23) + `${k.length}/${FILO}`.padEnd(21) + (k.length ? `${GUN - Math.min(...k.map((o) => o.dogum))} gun` : "—")); } const eski = ornek.filter((o) => o.surum < DUZELTME).length; const son = surumler[surumler.length - 1]; console.log(`\nson surum v${son.no} gun ${son.gun}'de cikti; ${GUN - son.gun} gun sonra ` + `${FILO - ornek.filter((o) => o.surum === son.no).length}/${FILO} ornek hala geride`); console.log(`guvenlik duzeltmesi v${DUZELTME} ile geldi (gun ${surumler[DUZELTME].gun}); ` + `${GUN - surumler[DUZELTME].gun} gun sonra ${eski}/${FILO} ornek hala eski degerde`); console.log(`ayni anda kosan surum sayisi: ` + `${new Set(ornek.map((o) => o.surum)).size}/${surumler.length}`); } ``` ``` 60 ornek, 90 gun, gunluk degistirme olasiligi 0.02, sablon 21 gunde bir guncelleniyor; tohum 20260921 surum cikis gunu bu surumle baslatilan donem sonunda kosan en eski ornegin yasi v0 gun 0 78 14/60 90 gun v1 gun 21 30 8/60 69 gun v2 gun 42 29 15/60 46 gun v3 gun 63 21 14/60 26 gun v4 gun 84 9 9/60 5 gun son surum v4 gun 84'de cikti; 6 gun sonra 51/60 ornek hala geride guvenlik duzeltmesi v2 ile geldi (gun 42); 48 gun sonra 22/60 ornek hala eski degerde ayni anda kosan surum sayisi: 5/5 ``` Şablon beş kez sürümlendi ve dönem sonunda **beş sürüm de koşuyor**. Filonun tamamı tek bir tanımdan başlatıldığı halde, o tanımın beş farklı anı aynı anda ayakta durmaktadır. Bu, önceki bölümün varyant sayısıyla aynı büyüklüğün zaman boyutudur: orada sapma başlatma anında doğuyordu, burada **şablon değişmediği halde** filo ayrışıyor. En eski örnek 90 günlüktür ve ilk sürümü taşımaktadır. Günlük değiştirme olasılığı 0,02 olan bir filoda bir örneğin 90 gün yaşama olasılığı düşüktür ama sıfır değildir; 60 örneğin 14'ü hiç değişmeden dönemi tamamlar. Ortalamaya bakan bir plan bu örnekleri görmez, çünkü ortalama örnek yaşı 50 günün altındadır. Güvenlik satırı bunun bedelidir. Düzeltme 42. günde ikinci sürümle geldi; **48 gün sonra 60 örneğin 22'si hâlâ eski değerdedir**. Şablonu güncellemek bir düzeltmeyi yayımlamak değildir, yalnız bundan sonra başlatılacak örnekler için geçerli kılmaktır. Düzeltmenin filoya ulaşması ancak örneklerin değiştirilmesiyle olur ve o hızı şablon değil, filonun yenilenme politikası belirler. #### Şablonun Kendi Yüzeyi Şablon sapmayı azaltır ama kendisi de bir girdi yüzeyidir: on iki alan bir yerde durur ve o yerdeki her alan yanlış olabilir. Yüzeyin büyüklüğü alan sayısıyla değil, **kaç alanın geçersiz kılınabildiğiyle** ve sapmanın düzeltilebilirliğiyle ölçülür. ```js // olcum-agi/sablon-yuzeyi.mjs — sablonun kendi girdi yuzeyi ve duzeltme bedeli (model) import { ALAN, BASLATMA, GERI_YOK, donem } from "./sablon-alanlari.mjs"; const YENIDEN = 35, YERINDE = 4, PENCERE = 2; // dakika, dakika, ayni anda ele alinan ornek const say = (f) => ALAN.filter(f).length; if (import.meta.url === `file://${process.argv[1]}`) { console.log(`sablonun girdi yuzeyi: ${ALAN.length} alan — ${say((a) => a[1])} zorunlu, ` + `${say((a) => !a[1])} varsayilanli, ${say((a) => a[2])} gecersiz kilinabilir, ` + `${GERI_YOK.length} yaratildiktan sonra degismez`); console.log(`gecersiz kilinamayan alan: ` + ALAN.filter((a) => !a[2]).map((a) => a[0]).join(", ") + "\n"); const d = donem(20260915); console.log("yol".padEnd(11) + "ayrisan ornek".padEnd(16) + "yerinde duzelir".padEnd(17) + "yeniden yaratilir".padEnd(19) + "duzeltme duvar saati"); ["elle", "sablonla"].forEach((ad, k) => { const [yen, yer] = d.duzeltme[k]; const dk = Math.ceil(yen / PENCERE) * YENIDEN + Math.ceil(yer / PENCERE) * YERINDE; console.log(ad.padEnd(11) + `${yen + yer}/${BASLATMA}`.padEnd(16) + String(yer).padEnd(17) + String(yen).padEnd(19) + `${(dk / 60).toFixed(1)} sa`); }); const ELDE = ["sablonun alanlari", "hangi alan gecersiz kilinabilir", "varsayilan degerler", "surum politikasi", "sablonu kimin guncelleyebildigi"]; const DEVIR = ["sablonun saklanmasi", "surum gecmisinin tutulma suresi", "baslatma cagrisinin dogrulama kurallari"]; console.log(`\nkarar defteri: ${ELDE.length} kalem elde, ${DEVIR.length} kalem saglayicida`); console.log(` saglayicida: ${DEVIR.join(", ")}`); console.log(` geri alinamayan ${GERI_YOK.length} alan: ` + GERI_YOK.map((j) => ALAN[j][0]).join(", ")); } ``` ``` sablonun girdi yuzeyi: 12 alan — 5 zorunlu, 7 varsayilanli, 11 gecersiz kilinabilir, 6 yaratildiktan sonra degismez gecersiz kilinamayan alan: yerlestirme tercihi yol ayrisan ornek yerinde duzelir yeniden yaratilir duzeltme duvar saati elle 92/140 47 45 15.0 sa sablonla 32/140 18 14 4.7 sa karar defteri: 5 kalem elde, 3 kalem saglayicida saglayicida: sablonun saklanmasi, surum gecmisinin tutulma suresi, baslatma cagrisinin dogrulama kurallari geri alinamayan 6 alan: makine imaji, alt ag, kok disk sifrelemesi, baslangic betigi, kiralama bicimi, yerlestirme tercihi ``` İlk satır şablonun sınırını tek sayıda verir: **12 alanın 11'i başlatma anında geçersiz kılınabilir**. Şablon bir kapı değil, bir varsayılan kümesidir; sapmanın geri kapısı kapalı değildir, dardır. Tam kapalı tek alan yerleştirme tercihidir ve o alanın şablon yolunda sıfır sapma vermesi tesadüf değildir. İkinci tablo düzeltmenin fiyatını iki kaleme ayırır. Elle başlatmada 140 örneğin 92'si ayrışır; bunların 47'si yerinde düzelir, **45'i yeniden yaratılmalıdır**, çünkü sapma yaratıldıktan sonra değişmeyen bir alandadır. Toplam duvar saati 15,0'tir. Şablon yolunda ayrışan örnek 32'ye, yeniden yaratılacak örnek 14'e ve duvar saati 4,7'ye iner. Şablonun kazandırdığı asıl şey sapma sayısındaki düşüş değil, **düzeltilemez sapmadaki** düşüştür: 45'ten 14'e. Geri alınamayan altı alan bu ayrımın kaynağıdır ve üçü bu kursun önceki derslerinden gelir: makine imajı, alt ağ ve kök disk şifrelemesi örnek yaratılırken verilir, başlangıç betiği o örnek için donar, kiralama biçimi kalıcı başlatılan örneği kesintiliye çeviremez, yerleştirme tercihi ise örneğin nereye konduğunu belirler ve sonradan taşınmaz. Bu altı alandan birinde yanlış değer, düzeltme değil **değiştirme** ister. Yüzeyin bir de yazılmayan tarafı vardır. Şablonda **kaç örnek başlatılacağı** yoktur; şablon bir örneğin nasıl olacağını söyler, kaç tane olacağını söylemez. Sayı hâlâ her başlatmada dışarıdan verilir ve dönem boyunca 140 kez verilmiştir. Aynı biçimde şablon, başlatılan örneğin **ne zaman** sonlandırılacağını da yazmaz; 90 günlük koşumda 14 örneğin hiç değişmemesinin nedeni budur. Karar defterinde sekiz kalemin **beşi elde, üçü sağlayıcıdadır**. Sağlayıcıda kalan üçü — şablonun saklanması, sürüm geçmişinin ne kadar tutulacağı ve başlatma çağrısının hangi alanı doğruladığı — şablonun kendisini bir bağımlılık haline getirir: elde kalan beş kalem ancak o üçü çalışırken anlamlıdır. #### Özet - Şablon toplam alan sapmasını 134'ten 34'e indirir, ama daha anlamlı sayı varyanttır: 140 örnek elle başlatıldığında 38, şablondan başlatıldığında 13 ayrı yapılandırma çıkar. - Şablon kaza sapmasını kaldırır, bilerek yapılan geçersiz kılmayı kaldırmaz: `kiralama bicimi` alanında şablon yolunda 7, elle yolda 5 sapma vardır ve bu bir hata değil, iş türüne göre verilen bir karardır. - Şablon güncellenince hiçbir çalışan örnek değişmez: beş sürüm aynı anda koşar, son sürüm çıktıktan 6 gün sonra 60 örneğin 51'i hâlâ geridedir. - Güvenlik düzeltmesi ikinci sürümle geldiği halde 48 gün sonra 22 örnek eski değerdedir; düzeltmenin hızını şablon değil, filonun yenilenme politikası belirler. - Şablonun girdi yüzeyi 12 alandır ve 11'i başlatma anında geçersiz kılınabilir; tam korunan tek alan yerleştirme tercihidir. - Şablonun asıl kazancı düzeltilemez sapmadadır: yeniden yaratılması gereken örnek 45'ten 14'e, düzeltme duvar saati 15,0'ten 4,7'ye iner; geri alınamayan alan sayısı 6'dır. #### Sonraki Adım Bu ders örnek başlatmayı tek bir tanıma indirdi, ama başlatma kararını hâlâ bir kişi veriyor: şablon var, düğmeye basan var. Önceki derslerin sayıları bu düğmeye ayda binlerce kez basıldığını gösterdi — kesintili kapasitede 1450 kesinti, 90 günde 180 örnek değişimi. Bir grup örneği tek bir şablondan üretmek, o gruba iki iş daha devretmeyi mümkün kılar: sayıyı talebe göre değiştirmek ve sağlıksız örneği kendiliğinden yenilemek. M22/K03 yatay ölçeklemeyi ve ölçütün gecikmesinden doğan salınımı ölçmüştü; o tarama tekrarlanmaz. Sonraki ders bu iki işin **birlikte** davranışını ölçer ve sorar: sağlıksız örnek değiştirilirken ölçekleme de tetiklenirse grup boyutu ne yapıyor, aynı anda kaç örnek değişiyor ve kapasitenin altına kaç turda düşülüyor? ### Otomatik Ölçekleme Grupları Source: https://academia.sh/tr/kurslar/bulut-hesaplama-ve-ag/otomatik-olcekleme-gruplari Ölçekleme politikası ile sağlık denetimi aynı grupta birlikte koşturulur ve grup boyutu dalgalanması, aynı anda değiştirilen örnek sayısı ile kapasitenin altına düşülen tur sayılır; sağlık denetimi eşiği ile ölçekleme soğuma süresi dokuz çift halinde taranır ve sürekli değişim üreten çift adıyla yazılır; sürekli değişimin günlük bedeli ile grubun geri alınamayan üç kalemi çıkarılır. Önceki ders örnek başlatmayı tek bir tanıma indirdi ve şablonun yazmadığı iki şeyi bıraktı: kaç örnek olacağı ve ne zaman sonlandırılacağı. **Otomatik ölçekleme grubu** bu iki soruyu da devralır. Grup bir şablona bağlanır, bir en az ve en çok örnek sayısı verilir ve iki ayrı döngü örnek sayısını kendi başına değiştirmeye başlar. Birinci döngü **ölçekleme politikasıdır**: talep ölçütüne bakar, örnek ekler ya da çıkarır. M22/K03 yatay ölçeklemeyi ve ölçütün gecikmesinden doğan salınımı ölçtü; o tarama burada tekrarlanmaz. İkinci döngü **sağlık denetimidir**: örneklere düzenli aralıklarla sorar, yanıt vermeyeni sonlandırıp yerine yenisini başlatır. Bu dersin ölçüsü ikisinin ayrı ayrı davranışı değil, **birlikte davranışıdır** — çünkü ikisi de aynı sayıyı, grubun boyutunu değiştirir ve birbirinin eylemini talep sanabilir. **BH25.** Grup, bölgesel ölçüm ağının — su sayaçlarından okuma toplayan kurgu yazılımın — okuma alan katmanıdır; talep eğrisi kurgudur ve her koşumda aynıdır. **BH26.** Bir tur bir dakikadır, dönem 240 turdur ve örnek başına kapasite 100 istek/turdur. **BH27.** Açılış 2 tur sürer; önceki derslerin 48,9 saniyesi bu ölçekte iki tura yuvarlanır. **BH28.** Geçici denetim hatası olasılığı 0,08'dir; üreteç kendi yazılmıştır ve tohum 20261001 görünürdür. **BH29.** Kalıcı bozulma 40., 95. ve 170. turlarda olur; anlar kurgudur ve her koşumda aynıdır. **BH30.** Ölçekleme yalnız hazır örnekleri sayar ve sağlık değiştirmesi soğuma süresi tanımaz. #### İki Döngü Aynı Grupta Sağlık denetimi bir örneği sonlandırdığında grup küçülür. Ölçekleme politikası o anda gruba bakar ve hazır örnek sayısını gerekliden az bulur — yerine gelen örnek henüz açılmaktadır. Politika bunu talep artışı sanar ve örnek ekler. Açılanlar hazır olduğunda grup gereğinden büyük olur ve politika bu kez küçültür. ```js // olcum-agi/grup.mjs — otomatik olcekleme grubu ile saglik denetiminin birlikte kosumu (model) export const uretec = (tohum) => () => (tohum = (tohum * 1103515245 + 12345) % 2147483648) / 2147483648; export const TUR = 240, KAPASITE = 100, ACILIS = 2; // tur, ornek basina istek, acilis turu const GECICI = 0.08; // gecici denetim hatasi olasiligi const BOZULMA_ANI = [40, 95, 170]; // kalici bozulmanin oldugu turlar (kurgu) // Talep egrisi kurgudur ve her kosumda aynidir; rastgelelik yalniz saglik denetimindedir. export const talep = (t) => 900 + 380 * Math.sin((2 * Math.PI * t) / 120) + (t >= 150 && t < 190 ? 520 : 0); export const gerekli = (t) => Math.ceil(talep(t) / KAPASITE); export const kosum = ({ esik, soguma, tohum = 20261001 }) => { const r = uretec(tohum); let grup = Array.from({ length: gerekli(0) }, () => ({ hazir: true, kalan: 0, ardisik: 0, bozuk: false })); const m = { min: 99, max: 0, esZamanli: 0, oran: 0, alti: 0, baslatilan: 0, yanlis: 0, bozukTur: 0, olcekleme: 0, degistirme: 0 }; let sonEylem = -soguma; for (let t = 0; t < TUR; t++) { const g = gerekli(t); if (BOZULMA_ANI.includes(t)) { const kurban = grup.find((o) => o.hazir && !o.bozuk); if (kurban) kurban.bozuk = true; } const kalan = []; // saglik denetimi (soguma tanimaz) for (const o of grup) { if (!o.hazir) { kalan.push(o); continue; } if (o.bozuk) m.bozukTur++; const gecti = !o.bozuk && r() >= GECICI; o.ardisik = gecti ? 0 : o.ardisik + 1; if (o.ardisik >= esik) { m.degistirme++; if (!o.bozuk) m.yanlis++; kalan.push({ hazir: false, kalan: ACILIS, ardisik: 0, bozuk: false }); m.baslatilan++; } else kalan.push(o); } grup = kalan; const hazir = grup.filter((o) => o.hazir).length; // olcekleme yalniz hazir ornegi sayar if (t - sonEylem >= soguma) { if (hazir < g) { for (let i = 0; i < g - hazir; i++) grup.push({ hazir: false, kalan: ACILIS, ardisik: 0, bozuk: false }); m.baslatilan += g - hazir; m.olcekleme++; sonEylem = t; } else if (hazir > g + 1) { for (let i = 0; i < hazir - g - 1; i++) grup.splice(grup.findIndex((o) => o.hazir), 1); m.olcekleme++; sonEylem = t; } } for (const o of grup) if (!o.hazir && --o.kalan <= 0) o.hazir = true; const acilan = grup.filter((o) => !o.hazir).length; m.min = Math.min(m.min, grup.length); m.max = Math.max(m.max, grup.length); m.esZamanli = Math.max(m.esZamanli, acilan); m.oran = Math.max(m.oran, acilan / grup.length); if (grup.filter((o) => o.hazir).length < g) m.alti++; } return m; }; if (import.meta.url === `file://${process.argv[1]}`) { const kotu = kosum({ esik: 2, soguma: 0 }), iyi = kosum({ esik: 5, soguma: 8 }); console.log(`${TUR} tur, ornek basina ${KAPASITE} istek, acilis ${ACILIS} tur; tohum 20261001`); console.log(`gerekli ornek ${Math.min(...Array.from({ length: TUR }, (_, t) => gerekli(t)))}` + ` ile ${Math.max(...Array.from({ length: TUR }, (_, t) => gerekli(t)))} arasinda degisiyor\n`); console.log("cift".padEnd(22) + "grup min-max".padEnd(15) + "dalgalanma".padEnd(13) + "es zamanli degisim".padEnd(20) + "kapasite alti tur".padEnd(19) + "baslatilan ornek"); for (const [ad, m] of [["esik 2, soguma 0", kotu], ["esik 5, soguma 8", iyi]]) console.log(ad.padEnd(22) + `${m.min}-${m.max}`.padEnd(15) + String(m.max - m.min).padEnd(13) + `${m.esZamanli} (%${Math.round(100 * m.oran)})`.padEnd(20) + `${m.alti}/${TUR}`.padEnd(19) + String(m.baslatilan)); for (const [ad, m] of [["esik 2, soguma 0", kotu], ["esik 5, soguma 8", iyi]]) console.log(`${ad}: ${m.degistirme} saglik degistirmesi (${m.yanlis} yanlis), ` + `${m.olcekleme} olcekleme eylemi, bozuk ornek ${m.bozukTur} tur trafikte kaldi`); } ``` ``` 240 tur, ornek basina 100 istek, acilis 2 tur; tohum 20261001 gerekli ornek 6 ile 18 arasinda degisiyor cift grup min-max dalgalanma es zamanli degisim kapasite alti tur baslatilan ornek esik 2, soguma 0 7-24 17 6 (%26) 10/240 46 esik 5, soguma 8 7-18 11 5 (%28) 46/240 19 esik 2, soguma 0: 17 saglik degistirmesi (14 yanlis), 40 olcekleme eylemi, bozuk ornek 5 tur trafikte kaldi esik 5, soguma 8: 2 saglik degistirmesi (0 yanlis), 22 olcekleme eylemi, bozuk ornek 11 tur trafikte kaldi ``` En açık sayı grup boyutunun üst sınırıdır. Talep hiçbir turda 18 örnekten fazlasını gerektirmediği halde ilk çift grubu **24 örneğe** çıkarır. Fazladan altı örnek talepten gelmez; sağlık değiştirmelerinin açtığı boşluğu politikanın doldurmasından gelir. İkinci çift aynı talep eğrisinde 18'i hiç aşmaz. İkinci sayı daha az görünür ama daha ağırdır: ilk çiftte **grubun yüzde 26'sı aynı anda değişiyordu** — dört örnekten biri açılmakta, yani ne eski ne yeni. Sağlıklı örnek sayısı bu oranda dalgalanıyorsa ölçüt, politikanın kendi eyleminin sonucunu ölçmeye başlar. Alt satırlar kaynağı ayırır. İlk çift 17 sağlık değiştirmesi yaptı ve **14'ü yanlıştı** — o örnekler bozuk değildi, yalnız iki denetimi üst üste geçemedi. Aynı çift 40 ölçekleme eylemi üretti, ikinci çift 22. Yanlış değiştirmelerin her biri politikaya bir sahte talep sinyali göndermiştir. Ama ikinci çift bedava değildir. Kapasite altı tur 10'dan **46'ya** çıkar: soğuma süresi uzun olduğu için politika gerçek talep artışına geç yanıt verir. Ve bozuk örnek 5 tur yerine **11 tur** trafikte kalır; eşik yüksek olduğu için gerçekten bozulan örnek de geç yakalanır. İki çift iki ayrı hatayı azaltır ve öbürünü büyütür. #### Eşik ile Soğumanın Taraması İki uç nokta yönü gösterdi; asıl soru aradaki çiftlerin ne yaptığıdır. Aşağıdaki tarama üç eşik ile üç soğuma süresini birlikte koşturur — dokuz çift, aynı talep eğrisi, aynı tohum. ```js // olcum-agi/grup-taramasi.mjs — saglik esigi ile soguma suresinin birlikte taranmasi (model) import { TUR, kosum } from "./grup.mjs"; const ESIK = [2, 3, 5], SOGUMA = [0, 3, 8], SAAT = TUR / 60; // bir tur bir dakika (kurgu) if (import.meta.url === `file://${process.argv[1]}`) { console.log(`${TUR} tur = ${SAAT} saat; her satir ayni talep egrisi ve ayni tohumla kosuldu\n`); console.log("esik".padEnd(7) + "soguma".padEnd(9) + "grup min-max".padEnd(15) + "dalgalanma".padEnd(13) + "es zamanli".padEnd(13) + "kapasite alti".padEnd(16) + "yanlis degisim".padEnd(17) + "bozuk tur".padEnd(12) + "saatte baslatilan"); const hepsi = []; for (const e of ESIK) for (const s of SOGUMA) { const m = kosum({ esik: e, soguma: s }); hepsi.push({ e, s, m }); console.log(String(e).padEnd(7) + String(s).padEnd(9) + `${m.min}-${m.max}`.padEnd(15) + String(m.max - m.min).padEnd(13) + String(m.esZamanli).padEnd(13) + `${m.alti}/${TUR}`.padEnd(16) + String(m.yanlis).padEnd(17) + String(m.bozukTur).padEnd(12) + (m.baslatilan / SAAT).toFixed(1)); } const enCok = hepsi.reduce((a, b) => (b.m.baslatilan > a.m.baslatilan ? b : a)); const enAz = hepsi.reduce((a, b) => (b.m.baslatilan < a.m.baslatilan ? b : a)); const enUzun = hepsi.reduce((a, b) => (b.m.bozukTur > a.m.bozukTur ? b : a)); console.log(`\nsurekli degisim ureten cift: esik ${enCok.e}, soguma ${enCok.s} — ` + `saatte ${(enCok.m.baslatilan / SAAT).toFixed(1)} ornek, ${enCok.m.yanlis} yanlis degistirme`); console.log(`en az degisim ureten cift: esik ${enAz.e}, soguma ${enAz.s} — ` + `saatte ${(enAz.m.baslatilan / SAAT).toFixed(1)} ornek, kapasite alti ${enAz.m.alti} tur`); console.log(`bozuk ornegi en uzun tasiyan cift: esik ${enUzun.e}, soguma ${enUzun.s} — ` + `${enUzun.m.bozukTur} tur trafikte`); } ``` ``` 240 tur = 4 saat; her satir ayni talep egrisi ve ayni tohumla kosuldu esik soguma grup min-max dalgalanma es zamanli kapasite alti yanlis degisim bozuk tur saatte baslatilan 2 0 7-24 17 6 10/240 14 5 11.5 2 3 7-18 11 5 13/240 12 6 8.5 2 8 7-18 11 4 42/240 13 6 8.5 3 0 7-23 16 5 8/240 0 8 6.3 3 3 7-18 11 5 14/240 0 7 5.0 3 8 7-18 11 5 47/240 1 8 5.3 5 0 7-23 16 5 7/240 0 12 6.0 5 3 7-18 11 5 13/240 0 12 4.8 5 8 7-18 11 5 46/240 0 11 4.8 surekli degisim ureten cift: esik 2, soguma 0 — saatte 11.5 ornek, 14 yanlis degistirme en az degisim ureten cift: esik 5, soguma 3 — saatte 4.8 ornek, kapasite alti 13 tur bozuk ornegi en uzun tasiyan cift: esik 5, soguma 0 — 12 tur trafikte ``` Her sütun tek bir ayarı izler ve dördü ayrı yönlere gider. **Yanlış değiştirme yalnız eşiğe bakar**: eşik 2'de 12–14, eşik 3'te 0–1, eşik 5'te 0. **Bozuk tur da yalnız eşiğe bakar** ama ters yönde: 5–6'dan 11–12'ye çıkar. Eşik iki hata arasında doğrudan bir takastır — sağlıklı örneği öldürmek ile bozuk örneği trafikte tutmak. Soğuma süresi başka iki sütunu yönetir. **Dalgalanma yalnız soğumaya bakar**: soğuma 0'da 16–17, soğuma 3 ve 8'de 11. Sıfır soğuma politikanın her turda eylem yapmasına izin verir ve grup, kendi eyleminin sonucunu ölçüt sanar. **Kapasite altı tur da yalnız soğumaya bakar** ve ters yönde: 7–10'dan 42–47'ye çıkar. Uzun soğuma dalgalanmayı keser, gerçek talep artışına yanıtı geciktirir. Uçlardaki çiftler adıyla okunur. En kötüsü **eşik 2, soğuma 0**: saatte 11,5 örnek başlatır, grubu 24'e çıkarır, 14 yanlış değiştirme yapar. Bu çiftin ürettiği şey ölçekleme değil, **sürekli değişimdir**; grup hiçbir zaman durulmaz. En sakini eşik 5, soğuma 3'tür — saatte 4,8 örnek — ama bozuk örneği 12 tur trafikte tutar. Orta çift (eşik 3, soğuma 3) saatte 5,0 örnekle neredeyse aynı sakinliği verir ve bozuk örneği 7 turda yakalar. #### Sürekli Değişimin Bedeli Sürekli değişimin görünen bedeli açılıştır: her başlatılan örnek iki tur boyunca ödenir ve hiç iş yapmaz. Görünmeyen bedeli, o örneklerin sonlandırdığı şeydir. ```js // olcum-agi/grup-defteri.mjs — surekli degisimin bedeli ve grubun karar defteri (model) import { TUR, ACILIS, kosum } from "./grup.mjs"; const SAAT = TUR / 60, BIRIM = 1.0; // kalici kapasite birimi (kurgu; M23/K01'den girdi) const CIFT = [[2, 0], [3, 3], [5, 3]]; if (import.meta.url === `file://${process.argv[1]}`) { console.log("cift".padEnd(22) + "gunde baslatilan".padEnd(18) + "acilista gecen".padEnd(16) + "gunluk bos birim".padEnd(18) + "kapasite alti".padEnd(16) + "bozuk tur"); for (const [e, s] of CIFT) { const m = kosum({ esik: e, soguma: s }), gunluk = (m.baslatilan / SAAT) * 24; const bos = (gunluk * ACILIS) / 60; // ornek-saat: acilirken odenen ama is yapmayan console.log(`esik ${e}, soguma ${s}`.padEnd(22) + gunluk.toFixed(0).padEnd(18) + `${bos.toFixed(1)} ornek-saat`.padEnd(16) + (bos * BIRIM).toFixed(1).padEnd(18) + `${m.alti}/${TUR}`.padEnd(16) + String(m.bozukTur)); } const ELDE = ["en az ve en cok ornek", "olcekleme olcutu ve esikleri", "soguma suresi", "saglik denetimi esigi ve araligi", "kucultmede hangi ornegin secilecegi", "grubun bagli oldugu sablon surumu"]; const DEVIR = ["saglik denetimi cagrisinin kendi gecikmesi", "olcekleme eyleminin uygulanma gecikmesi", "istenen kapasitenin o an bulunabilirligi"]; const GERI_YOK = ["sonlandirilan ornegin elindeki is ve yerel diski", "sagliksiz damgasi — ornek geri dondurulmez, degistirilir", "kucultulen kapasite — geri almak yeni acilis ve soguma turu ister"]; console.log(`\nkarar defteri: ${ELDE.length} kalem elde, ${DEVIR.length} kalem saglayicida`); console.log(` saglayicida: ${DEVIR.join("; ")}`); for (const g of GERI_YOK) console.log(` geri alinamaz — ${g}`); } ``` ``` cift gunde baslatilan acilista gecen gunluk bos birim kapasite alti bozuk tur esik 2, soguma 0 276 9.2 ornek-saat 9.2 10/240 5 esik 3, soguma 3 120 4.0 ornek-saat 4.0 14/240 7 esik 5, soguma 3 114 3.8 ornek-saat 3.8 13/240 12 karar defteri: 6 kalem elde, 3 kalem saglayicida saglayicida: saglik denetimi cagrisinin kendi gecikmesi; olcekleme eyleminin uygulanma gecikmesi; istenen kapasitenin o an bulunabilirligi geri alinamaz — sonlandirilan ornegin elindeki is ve yerel diski geri alinamaz — sagliksiz damgasi — ornek geri dondurulmez, degistirilir geri alinamaz — kucultulen kapasite — geri almak yeni acilis ve soguma turu ister ``` Kötü çift günde **276 örnek** başlatır; iyi ayarda aynı grup aynı işi 120 örnekle yapar. Aradaki 156 örnek açılır, hazır olur ve kısa süre sonra sonlandırılır. Açılışta geçen 9,2 örnek-saat, günde 9,2 kurgu birim ödenip iş yapmayan kapasitedir — faturaya bakan kimsenin dikkatini çekmez. Asıl bedel geri alınamayan üç kalemdedir. Sonlandırılan her örnek elindeki işi ve yerel diskini götürür; kötü çiftte bu günde 156 fazladan kez olur ve bunların büyük bölümü **sağlıklı** örneklerin sonlandırılmasıdır. Sağlıksız damgası geri döndürülemez: bir örnek iki denetimi geçemediği için sağlıksız sayıldıysa, üçüncü denetimde yanıt verse bile geri alınmaz — çünkü artık yoktur. Küçültülen kapasite de geri alınamaz; geri almak yeni bir açılış ve bir soğuma turu ister. Grubun karar defterinde dokuz kalemin **altısı elde, üçü sağlayıcıdadır**. Elde kalanlar bu dersin taradığı ayarlardır ve hepsi sayıyla seçilebilir. Sağlayıcıda kalan üçü sinsidir: sağlık denetimi çağrısının kendi gecikmesi eşiği fiilen kaydırır, ölçekleme eyleminin uygulanma gecikmesi soğuma süresine eklenir, istenen kapasitenin o an bulunamaması ise politikayı sessizce başarısız kılar. #### Özet - İki döngü aynı sayıyı değiştirir: sağlık değiştirmesi grubu küçültür, politika bunu talep sanıp büyütür — talep hiç 18 örnek aşmadığı halde kötü çift grubu 24'e çıkarır. - Kötü çiftte grubun yüzde 26'sı aynı anda değişmektedir; bu oranda ne ölçüt ne de gözlem grubun o anki durumunu söyler. - Eşik iki hata arasında doğrudan takastır: eşik 2'de 12–14 yanlış değiştirme, eşik 5'te 0 — ama bozuk örnek 5–6 tur yerine 11–12 tur trafikte kalır. - Soğuma süresi başka iki sütunu yönetir: dalgalanma 16–17'den 11'e iner, kapasite altı tur 7–10'dan 42–47'ye çıkar. - Sürekli değişim üreten çift eşik 2, soğuma 0'dır: saatte 11,5 örnek, günde 276 başlatma, 9,2 örnek-saat boş kapasite; aynı işi eşik 3, soğuma 3 çifti günde 120 başlatmayla yapar. - Dokuz kalemin altısı elde, üçü sağlayıcıdadır; geri alınamayan üç kalem sonlandırılan örneğin elindeki iş, sağlıksız damgası ve küçültülen kapasitedir. #### Sonraki Adım Bu ders grubu iki döngüye devretti ve karşılığında altı ayar kalemi bıraktı: en az ve en çok örnek, ölçüt, eşikler, soğuma, sağlık aralığı, şablon sürümü. Devir gerçektir — kimse artık örnek başlatmıyor — ama elde kalan kalem sayısı azalmadı, yalnız türü değişti. Örnek seçmek yerine politika seçiliyor. Devir bir adım daha ileri gidebilir: makineyi hiç görmemek. M22/K02 ve M22/K03 konteyneri ve orkestrasyonu ölçtü; o mekanik burada tekrarlanmaz. Sonraki ders aynı iş yükünü kendi kümesini işletmekle yönetilen bir serviste çalıştırmak arasında karşılaştırır ve tek soruyu sorar: düğüm boyutu, sürüm, yama, ağ eklentisi ve ölçekleme kararlarından kaçı her devirde elde kalıyor, görev tabanlı çalıştırmada bu sayı ne oluyor ve her devirde hangi kalem geri alınamaz hale geliyor? ### Yönetilen Konteyner Servisleri Source: https://academia.sh/tr/kurslar/bulut-hesaplama-ve-ag/yonetilen-konteyner-servisleri Aynı iş yükü üç çalıştırma düzeyinde — kendi kümen, yönetilen küme ve görev tabanlı çalıştırma — on beş karar kalemi üzerinden sayılır ve her devirde kaç kararın elde kaldığı, kaçının devredildiği ve yıllık bakım yükünün ne olduğu çıkarılır; her düzeyin geri alınamayan kalemleri adıyla yazılır ve çıkışta taşınamayan yapılandırma ile devrin geri ödeme süresi ölçülür. Önceki ders örnek sayısını bir gruba devretti ve karşılığında altı ayar kalemi bıraktı. Devir gerçekti ama kısmiydi: makine hâlâ ortadaydı — ailesi seçiliyor, imajı pişiriliyor, açılışı ölçülüyordu. Devir bir adım daha ileri gidebilir ve makineyi tümüyle görüş alanının dışına çıkarabilir. Bu ders aynı iş yükünü üç düzeyde karşılaştırır: **kendi kümen** (orkestrasyonu kendi örneklerinde işletmek), **yönetilen küme servisi** (kontrol düzlemi devredilmiş, düğümler hâlâ senin) ve **görev tabanlı çalıştırma** (düğüm diye bir kalem yok). M22/K02 konteyner ve imaj katmanını, M22/K03 orkestrasyon mekaniğini ölçtü; o mekanik burada tekrarlanmaz. Buradaki tek ölçü **devredilen karardır**: her düzeyde kaç kalem elde kalıyor, kaçı devrediliyor ve devredilenlerin hangisi bir daha geri alınamıyor. **BH31.** On beş karar kalemi bölgesel ölçüm ağının — su sayaçlarından okuma toplayan kurgu yazılımın — konteyner katmanındandır; kalemler ve yıllık bakım saatleri kurgudur. **BH32.** Üç düzey yukarıdaki gibidir ve aynı iş yükünü çalıştırır. **BH33.** "yok" bir kalemin o düzeyde hiç bulunmadığını gösterir; "paylasik" kararın bir bölümünün elde kaldığını. **BH34.** Taşıma kuralı kurgudur: tanım sende ise taşınır (2 sa), sağlayıcının biçimindeyse yeniden yazılır (10 sa), tümüyle devredilmişse yeniden kurulur (24 sa), o düzeyde hiç yoksa karar sıfırdan verilir (16 sa). **BH35.** Geri alınamayan kalemler düzey başına üçtür ve kurgudur. **BH36.** Bakım saatleri yıllık ve kurgudur; bir kalem yalnız elde ya da paylaşıkken bakım yükü doğurur. #### Aynı İş Yükü, Üç Çalıştırma Düzeyi Devir bir hepsi-ya-hiç kararı değildir; kalem kalem verilir. Aşağıdaki envanter on beş kalemi üç düzeyde tek tek yerleştirir. ```js // olcum-agi/devir-envanteri.mjs — ayni is yukunun uc calistirma duzeyindeki karar dagilimi (model) export const DUZEY = ["kendi kumen", "yonetilen kume", "gorev tabanli"]; // [kalem, [duzey1, duzey2, duzey3], yillik bakim saati (kalem sende ya da paylasikken)] export const KALEM = [ ["dugum boyutu ve ailesi", ["sende", "sende", "yok"], 12], ["dugum sayisi", ["sende", "sende", "yok"], 8], ["kume surumu", ["sende", "paylasik", "yok"], 20], ["dugum isletim sistemi yamasi", ["sende", "paylasik", "saglayicida"], 40], ["kontrol duzlemi isletimi", ["sende", "saglayicida", "saglayicida"], 60], ["kontrol duzlemi yedekligi", ["sende", "saglayicida", "saglayicida"], 24], ["ag eklentisi secimi", ["sende", "sende", "saglayicida"], 16], ["depolama eklentisi secimi", ["sende", "sende", "saglayicida"], 12], ["gorev zamanlayici ayari", ["sende", "sende", "paylasik"], 18], ["gorev olceklemesi", ["sende", "sende", "sende"], 14], ["kaynak istegi ve siniri", ["sende", "sende", "sende"], 10], ["imaj deposu ve cekme kimligi", ["sende", "sende", "sende"], 8], ["gunluk ve olcum toplama", ["sende", "sende", "paylasik"], 22], ["ic ag adres plani", ["sende", "sende", "saglayicida"], 14], ["dugum uzerinde ortak surec", ["sende", "sende", "yok"], 10], ]; export const say = (d, tur) => KALEM.filter((k) => k[1][d] === tur).length; export const bakim = (d) => KALEM.filter((k) => k[1][d] !== "saglayicida" && k[1][d] !== "yok").reduce((t, k) => t + k[2], 0); if (import.meta.url === `file://${process.argv[1]}`) { console.log("karar kalemi".padEnd(32) + DUZEY.map((d) => d.padEnd(17)).join("") + "yillik bakim"); for (const [ad, yer, sa] of KALEM) console.log(ad.padEnd(32) + yer.map((y) => y.padEnd(17)).join("") + `${sa} sa`); console.log(""); console.log("duzey".padEnd(17) + "elde".padEnd(8) + "paylasik".padEnd(11) + "saglayicida".padEnd(14) + "kalem yok".padEnd(12) + "yillik bakim"); DUZEY.forEach((d, i) => console.log(d.padEnd(17) + String(say(i, "sende")).padEnd(8) + String(say(i, "paylasik")).padEnd(11) + String(say(i, "saglayicida")).padEnd(14) + String(say(i, "yok")).padEnd(12) + `${bakim(i)} sa`)); } ``` ``` karar kalemi kendi kumen yonetilen kume gorev tabanli yillik bakim dugum boyutu ve ailesi sende sende yok 12 sa dugum sayisi sende sende yok 8 sa kume surumu sende paylasik yok 20 sa dugum isletim sistemi yamasi sende paylasik saglayicida 40 sa kontrol duzlemi isletimi sende saglayicida saglayicida 60 sa kontrol duzlemi yedekligi sende saglayicida saglayicida 24 sa ag eklentisi secimi sende sende saglayicida 16 sa depolama eklentisi secimi sende sende saglayicida 12 sa gorev zamanlayici ayari sende sende paylasik 18 sa gorev olceklemesi sende sende sende 14 sa kaynak istegi ve siniri sende sende sende 10 sa imaj deposu ve cekme kimligi sende sende sende 8 sa gunluk ve olcum toplama sende sende paylasik 22 sa ic ag adres plani sende sende saglayicida 14 sa dugum uzerinde ortak surec sende sende yok 10 sa duzey elde paylasik saglayicida kalem yok yillik bakim kendi kumen 15 0 0 0 288 sa yonetilen kume 11 2 2 0 204 sa gorev tabanli 3 2 6 4 72 sa ``` Birinci devir sanıldığından küçüktür. Yönetilen kümeye geçince on beş kalemin yalnız **ikisi** tam devredilir: kontrol düzleminin işletilmesi ve yedekliliği. İki kalem daha paylaşığa iner — küme sürümü ve düğüm yaması artık sağlayıcıyla birlikte verilir. Geri kalan on bir kalem yerinde kalır; düğüm boyutu, ağ eklentisi, adres planı ve düğümde koşan ortak süreçler hâlâ seçilir. Yıllık bakım 288 saatten 204 saate iner — yüzde 29. "Paylaşık" sütunu bu tablonun en kolay yanlış okunan kısmıdır. Küme sürümü paylaşık olduğunda yükseltmeyi sağlayıcı yapar ama **ne zaman yapılacağını** o söyler: bir sürüm desteği bittiğinde yükseltme bir seçenek olmaktan çıkar. Düğüm yaması da aynıdır — yama gelir, ama düğümün yeniden başlatılması iş yükünü keser ve o kesintiyi karşılayan taraf sensin. Paylaşık kalem, bakım yükünün yarısını devreder, **zamanlama kararının tamamını** devreder. İkinci devir gerçekten büyüktür ama biçimi farklıdır. Görev tabanlı çalıştırmada altı kalem sağlayıcıya geçer ve **dört kalem tümüyle ortadan kalkar**: düğüm boyutu, düğüm sayısı, küme sürümü ve düğümde koşan ortak süreç diye bir soru artık yoktur. Bu, devirlerin en güçlü biçimidir — karar başka birine verilmez, karar **var olmaz**. Elde kalan üç kalem görev ölçeklemesi, kaynak isteği ve imaj kimliğidir; yıllık bakım 72 saate iner. Ama son satır dikkatle okunmalıdır. Bu dersin ilk beş dersinde sayılan kalemlerin çoğu — örnek ailesi, boyutlandırma, imaj tazeliği, açılış süresi, sağlık eşiği — görev tabanlı düzeyde kaybolmaz; **görünmez olur**. Görev hâlâ bir makinede koşar, imaj hâlâ çekilir, açılış hâlâ sürer. Devredilen şey kararlardır; fizik değil. #### Her Devirde Açılan ve Kapanan Devir iki sayıyı aynı anda değiştirir: elde kalan kalem azalır, ama azalan kalemlerin bir bölümü **kurulduktan sonra değiştirilemeyen** kalemlere dönüşür. İkinci sayı devir oranıyla birlikte düşmez. ```js // olcum-agi/devir-yuzeyi.mjs — her devirde acik yuzey ve geri alinamayan kalem (model) import { DUZEY, KALEM, say, bakim } from "./devir-envanteri.mjs"; // Duzey basina, o duzeyde kurulduktan sonra degistirilemeyen kalemler (kurgu). const GERI_YOK = [ ["kumenin ic adres alani", "kume surumu yukseltmesi (tek yon)", "dugum havuzunun mimarisi"], ["kume yaratilirken verilen ag eklentisi", "kume surumu yukseltmesi (tek yon)", "kumenin ic adres alani"], ["yayimlanmis gorev tanimi surumu", "goreve verilen ag kipi", "calistirma kimliginin baglandigi kaynak"], ]; if (import.meta.url === `file://${process.argv[1]}`) { console.log("duzey".padEnd(17) + "acik yuzey".padEnd(13) + "devredilen".padEnd(13) + "devir orani".padEnd(14) + "yillik bakim".padEnd(15) + "geri alinamayan kalem"); DUZEY.forEach((d, i) => { const acik = say(i, "sende") + say(i, "paylasik"); const dev = say(i, "saglayicida") + say(i, "yok"); console.log(d.padEnd(17) + `${acik}/${KALEM.length}`.padEnd(13) + `${dev}/${KALEM.length}`.padEnd(13) + `%${Math.round((100 * dev) / KALEM.length)}`.padEnd(14) + `${bakim(i)} sa`.padEnd(15) + GERI_YOK[i].length); }); console.log(""); DUZEY.forEach((d, i) => console.log(`${d}: ` + GERI_YOK[i].join("; "))); const b0 = bakim(0), b2 = bakim(2); console.log(`\ndevir kazanci: yillik bakim ${b0} saatten ${b2} saate iniyor ` + `(${b0 - b2} saat, %${Math.round((100 * (b0 - b2)) / b0)})`); console.log(`devir bedeli: elde kalan karar ${say(0, "sende")} kalemden ${say(2, "sende")} kaleme ` + `iniyor, ama geri alinamayan kalem sayisi ucte de ${GERI_YOK[0].length}`); } ``` ``` duzey acik yuzey devredilen devir orani yillik bakim geri alinamayan kalem kendi kumen 15/15 0/15 %0 288 sa 3 yonetilen kume 13/15 2/15 %13 204 sa 3 gorev tabanli 5/15 10/15 %67 72 sa 3 kendi kumen: kumenin ic adres alani; kume surumu yukseltmesi (tek yon); dugum havuzunun mimarisi yonetilen kume: kume yaratilirken verilen ag eklentisi; kume surumu yukseltmesi (tek yon); kumenin ic adres alani gorev tabanli: yayimlanmis gorev tanimi surumu; goreve verilen ag kipi; calistirma kimliginin baglandigi kaynak devir kazanci: yillik bakim 288 saatten 72 saate iniyor (216 saat, %75) devir bedeli: elde kalan karar 15 kalemden 3 kaleme iniyor, ama geri alinamayan kalem sayisi ucte de 3 ``` Son sütun bu kursun baştan beri saydığı şeyin özetidir: **açık yüzey 15'ten 5'e inerken geri alınamayan kalem sayısı üçte kalır**. Devir oranı yüzde 67'ye çıkar, bakım yükü yüzde 75 düşer, ama kurulduktan sonra değiştirilemeyen kalem sayısı hiç değişmez. Yalnız kalemlerin adı değişir. Üç düzeyin geri alınamayan kalemleri karşılaştırılınca bir örüntü çıkar. Kendi kümende ve yönetilen kümede sabit kalan şey **adres alanıdır**; küme kurulurken verilir ve kümenin ömrü boyunca durur. Görev tabanlı düzeyde adres alanı sorusu ortadan kalkar, ama yerine üç yeni sabit gelir: yayımlanmış görev tanımının sürümü değişmez, göreve verilen ağ kipi görev yaratılırken verilir, çalıştırma kimliğinin bağlandığı kaynak sonradan değiştirilemez. Bunlar kursun ilk dersindeki alt ağ ve mimari kalemlerinin aynı biçimde, başka adla dönmüş halidir. Bakım saatlerinin nereye gittiği de aynı tabloda okunur. Yüzde 75'lik düşüşün en büyük parçası tek bir kalemden gelir: kontrol düzleminin işletilmesi ve yedekliliği, yılda 84 saatle envanterin en pahalı iki kalemidir ve ilk devirde tümüyle gider. İkinci devirde giden 132 saatin çoğu ise düğüm bakımıdır — yama, ağ ve depolama eklentisi, adres planı. Devrin kazancı kalem sayısıyla değil, **hangi kalemlerin gittiğiyle** orantılıdır. Küme sürümü yükseltmesi iki düzeyde birden geri alınamaz kalemdir ve nedeni tektir: yükseltme tek yönlüdür. Sürüm yükseltildikten sonra eski sürüme dönmek bir geri alma değil, **yeni bir küme kurmaktır** — ve o kümeye taşınmak, bu dersin son bölümünün ölçtüğü işi gerektirir. #### Çıkışta Ne Taşınıyor Devir kararı, o düzeyde kalındığı sürece bir kazançtır. Kazancın karşı tarafı ancak çıkarken görünür: yapılandırmanın ne kadarı taşınabilir bir tanım, ne kadarı sağlayıcının biçimine yazılmış bir kayıttır. ```js // olcum-agi/cikis-bedeli.mjs — her devirde cikista tasinamayan yapilandirma (model) import { DUZEY, KALEM, say, bakim } from "./devir-envanteri.mjs"; // Tasima kurali (kurgu saat): tanim sende ise tasinir; saglayicinin bicimindeyse yeniden yazilir; // tumuyle devredilmisse yeni yerde yeniden kurulur; o duzeyde hic yoksa karar sifirdan verilir. const TASIMA = { sende: ["tasinir", 2], paylasik: ["yeniden yazilir", 10], saglayicida: ["yeniden kurulur", 24], yok: ["yeniden dogar", 16] }; if (import.meta.url === `file://${process.argv[1]}`) { const tur = Object.keys(TASIMA); console.log("duzey".padEnd(17) + tur.map((t) => `${TASIMA[t][0]}`.padEnd(18)).join("") + "cikis saati".padEnd(14) + "tasinamayan"); const saat = DUZEY.map((d, i) => { const n = tur.map((t) => say(i, t)); const s = n.reduce((a, v, j) => a + v * TASIMA[tur[j]][1], 0); console.log(d.padEnd(17) + n.map((v) => String(v).padEnd(18)).join("") + `${s} sa`.padEnd(14) + `${n[2] + n[3]}/${KALEM.length}`); return s; }); const kazanc = bakim(0) - bakim(2), fark = saat[2] - saat[0]; console.log(`\nyillik bakim kazanci ${kazanc} sa; cikis bedeli farki ${fark} sa`); console.log(`devrin geri odemesi ${(fark / kazanc).toFixed(2)} yil: gorev tabanli calistirmanin ` + `bir yilda kazandirdigi sure, cikista neredeyse tamamen geri odeniyor`); console.log(`gorev tabanlida karar ${say(0, "sende")} kalemden ${say(2, "sende")} kaleme indi, ` + `ama cikista ${say(2, "yok")} kalem sifirdan yeniden verilecek`); } ``` ``` duzey tasinir yeniden yazilir yeniden kurulur yeniden dogar cikis saati tasinamayan kendi kumen 15 0 0 0 30 sa 0/15 yonetilen kume 11 2 2 0 90 sa 2/15 gorev tabanli 3 2 6 4 234 sa 10/15 yillik bakim kazanci 216 sa; cikis bedeli farki 204 sa devrin geri odemesi 0.94 yil: gorev tabanli calistirmanin bir yilda kazandirdigi sure, cikista neredeyse tamamen geri odeniyor gorev tabanlida karar 15 kalemden 3 kaleme indi, ama cikista 4 kalem sifirdan yeniden verilecek ``` Son sütun devir kararının fiyat etiketidir: görev tabanlı çalıştırmada **on beş kalemin onu taşınmaz**. Altısı yeni yerde yeniden kurulur, dördü ise sıfırdan yeniden karara bağlanır — düğüm boyutu, düğüm sayısı, küme sürümü ve düğümde koşan ortak süreç soruları çıkışta geri gelir. Devretmek kararı yok etmedi; **erteledi**. İki sayı yan yana konunca kararın ölçüsü çıkar. Görev tabanlı çalıştırma yılda 216 saat bakım kazandırır; aynı düzeyden çıkmak, kendi kümenden çıkmaktan 204 saat daha pahalıdır. Geri ödeme **0,94 yıldır**: bir yıldan kısa kalınacaksa devir zaman kazandırmaz, bir yıldan uzun kalınacaksa her ek yıl net kazançtır. Bu, "hangi düzey daha iyi" sorusunun sayıyla verilebilecek tek cevabıdır ve cevap düzeyin kendisine değil, **kalış süresine** bağlıdır. İlk sütun da kendi başına bir sonuçtur. Üç düzeyin hepsinde taşınabilir kalan üç kalem vardır: görev ölçeklemesi, kaynak isteği ve sınırı, imaj deposu kimliği. Bunlar hiçbir düzeyde devredilmediği için hiçbir çıkışta yeniden yazılmaz. Devredilemeyen bu üç kalem, iş yükünün kendisine ait olan kararlardır — kaç kopya koşacağı, her kopyanın ne kadar kaynak isteyeceği ve hangi imajı çalıştıracağı. Devir ne kadar ilerlerse ilerlesin bu üçü kalır; kiralanan katmanın üstünde kalan asıl karar kümesi budur. Bir uyarı da tabloda görünmeyen yerdedir. Çıkış saatleri yalnız yapılandırmanın yeniden yazılmasını sayar; taşıma sırasındaki kesinti, çift koşum dönemi ve veri taşıma bu tabloda yoktur. Gerçek çıkış bu satırlardan uzun sürer, kısa değil. #### Özet - Yönetilen kümeye geçmek sanılandan az devreder: on beş kalemin ikisi tam, ikisi paylaşık olarak devredilir; on bir kalem yerinde kalır ve yıllık bakım 288'den 204 saate iner. - Görev tabanlı çalıştırmada devir oranı yüzde 67'ye çıkar ve dört kalem tümüyle ortadan kalkar — karar başkasına verilmez, var olmaz; bakım 72 saate iner. - Açık yüzey 15'ten 5'e inerken geri alınamayan kalem sayısı üç düzeyde de üçtür; devir kalemlerin adını değiştirir, geri alınamazlığı kaldırmaz. - Küme sürümü yükseltmesi iki düzeyde geri alınamaz kalemdir: eski sürüme dönmek geri alma değil, yeni bir küme kurup taşınmaktır. - Çıkışta görev tabanlı düzeyde on beş kalemin onu taşınmaz; altısı yeniden kurulur, dördü sıfırdan karara bağlanır — devretmek kararı yok etmez, erteler. - Devrin geri ödemesi 0,94 yıldır: yılda 216 saat bakım kazandırır, çıkışı 204 saat pahalılaştırır; kararı düzeyin kendisi değil, kalış süresi belirler. #### Sonraki Adım Bu konu makineyi baştan sona kiraladı. Ailesi ve boyutu seçildi ve atıl kaynak sayıldı; imajı pişirildi ve açılış süresiyle tazelik arasındaki denge tarandı; kalıcı ile kesintili kapasite iş türüne göre ayrıldı; tanım bir şablona toplandı; sayı bir gruba devredildi; ve son olarak kararların üçte ikisi bir servise verildi. Her derste iki sayı hep birlikte gitti — elde kalan karar ve geri alınamayan kalem. Bütün bu örnekler, gruplar ve görevler bir varsayımın üzerinde durdu: birbirlerini buluyorlar. Toplayıcı dizine yazıyor, dizin api ucundan okunuyor, ölçekleme grubuna trafik geliyor. Bu konuda tek bir adres, tek bir kural, tek bir sınır yazılmadı — makineler sanki aynı odadaymış gibi konuşturuldu. Sıradaki konu o odayı kurar ve ilk sorusu şudur: bu örnekler hangi adres alanında duruyor, o alan kurulduktan sonra değişiyor mu ve dışarıya açılan ilk kapı hangi kararı geri alınamaz hale getiriyor? ## Ağ Makineleri birbirine bağlayan katmanın kurulması: adres alanı planlamasının sonradan değiştirilemezliği, genel ile özel alt ağ ayrımı, yönlendirme tablolarının trafiği belirlemesi, dışarı ve içeri erişim geçitleri, durum bilgili ve bilgisiz filtrelemenin kural sayısı ve yanlış kapatma farkı, yük dengeleyici katman seçimi ve sağlık denetimi, adres kararlılığı ve ad tümleştirmesi, kenar önbelleğiyle içerik dağıtımı ve ağlar arası özel erişim. ### Sanal Özel Ağ Source: https://academia.sh/tr/kurslar/bulut-hesaplama-ve-ag/sanal-ozel-ag Adres alanı planlaması kalem kalem sayılır: önek uzunluğu taranınca kaç adres kullanılabilir kalıyor, kaçı ayrılmış, kaçı israf; dar seçim hangi dönemde büyümeyi durduruyor, geniş seçim hangi komşu bloklarla çakışıyor ve kurulduktan sonra değişmeyen bu kalemin bedeli kaç birim tutuyor. Makine kiralandı, imajı seçildi ve ölçeklenmesi bir gruba devredildi. Kiralanan her örneğin bir adresi var ve o adres bir yerden geliyor: örnekler açılmadan önce çizilmiş bir adres alanından. Sanal özel ağ, kiracıya ayrılan ve içinde adres dağıtımı kiracıya bırakılan alandır. Sağlayıcı iletim düzlemini, kiracılar arasındaki yalıtımı ve adres tahsis mekanizmasını üstlenir; blok, önek uzunluğu ve bloğun kurumun aralığındaki yeri yazana kalır. Bu kalem ötekilerden bir yönüyle ayrılır. Yönlendirme kuralı yanlış yazılırsa düzeltilir, filtre kuralı gevşekse daraltılır — adres bloğu kurulduktan sonra değişmez. Sorulan üç şey var: bir blokta kaç adres gerçekten kullanılabilir, seçim hangi dönemde dar gelir ve dar geldiği gün ne kadar tutar. - **BA1.** Sekiz dönemlik büyüme dizisi ve komşu blok listesi kurgusal bölgesel ölçüm ağına aittir. Gerçek bir ağ kurulmuyor; ölçülen şey `node` ile kurulan modeldir. Adres aritmetiği gerçektir. - **BA2.** Bütün bloklar özel adres aralıklarından yazıldı; gerçek genel blok kullanılmıyor. - **BA3.** Sağlayıcının her alt ağda beş adresi ayırdığı varsayıldı. Gerçekte bu sayı sağlayıcıya göre değişir; kullanılabilir adres sayısını kaydırır, yönünü değiştirmez. - **BA4.** Büyüme dizisi elle yazıldı; rastgelelik yok, her koşum aynı sayıları üretir. - **BA5.** Bedeller kurgu **birim** cinsindendir, para birimi değildir. Yolların birbirine oranını taşır, mutlak bir tutar bildirmez. - **BA6.** Komşu blok listesi yediye indirgendi. Gerçekte bir kurumda kayıtlı blok sayısı çok daha yüksektir; çakışma sayısını büyütür, tarama mantığını değiştirmez. #### Adres Alanı Modeli Model üç şey tutuyor: bloğu adres aritmetiğiyle çözen birkaç işlev, aynı kurumda kayıtlı komşu bloklar ve ölçüm ağının sekiz dönemlik talebi. Talep satırı bir dönemde kaç alana yayıldığını, kaç katman kullandığını ve kaç örnek koştuğunu yazıyor; alt ağ sayısı bu ikisinin çarpımıdır. ```js // adres.mjs — adres alani plani modeli; gercek ag kurulmuyor, adres aritmetigi gercek export const toInt = (ip) => ip.split('.').reduce((a, o) => a * 256 + Number(o), 0); export const toIp = (n) => [16777216, 65536, 256, 1].map((b) => Math.floor(n / b) % 256).join('.'); export const blok = (c) => { const [ip, e] = c.split('/'); const onek = Number(e); const boyut = 2 ** (32 - onek); const bas = Math.floor(toInt(ip) / boyut) * boyut; // onek kisaldikca taban geriye kayar return { ad: `${toIp(bas)}/${onek}`, onek, boyut, bas, son: bas + boyut - 1 }; }; export const kesisir = (a, b) => a.bas <= b.son && b.bas <= a.son; // Ayni kurumun var olan bloklari (kurgu); hepsi ozel aralikta. export const KOMSU = [ ['merkez-salon', '10.0.0.0/16'], ['eski-olcum', '10.8.0.0/14'], ['laboratuvar', '10.32.0.0/16'], ['saha-gecici', '10.41.0.0/16'], ['olcut-arsivi', '10.42.128.0/17'], ['yedek-toplama', '10.44.0.0/14'], ['ortak-baglanti', '172.20.0.0/14'], ].map(([ad, c]) => ({ ...blok(c), ad })); export const CAPA = '10.42.0.0'; // planlayicinin yazdigi baslangic adresi export const KURUM = blok('10.32.0.0/12'); // kuruma ayrilan aralik; yeni ekipler buradan alir export const AYRILAN = 5; // saglayici her alt agda bes adres ayirir (BA3) // [donem, alan, katman, ornek] — kurgusal olcum aginin buyume dizisi (BA4) export const TALEP = [ [1, 2, 2, 18], [2, 2, 2, 26], [3, 3, 2, 44], [4, 3, 2, 71], [5, 3, 3, 118], [6, 3, 3, 196], [7, 4, 3, 340], [8, 4, 3, 612], ]; export const altAg = (t) => t[1] * t[2]; export const gerek = (t) => t[3] + t[1] + 2; // ornek + alan basina gecit + iki dengeleyici export const ayrilan = (t) => AYRILAN * altAg(t); export const kullanilan = (t) => gerek(t) + ayrilan(t); export const tasma = (b) => (TALEP.find((t) => kullanilan(t) > b.boyut) || [0])[0]; export const cakisan = (b) => KOMSU.filter((k) => kesisir(b, k)); export const TOPLAM_DILIM = KURUM.boyut / 4096; // kurum araliginda kac /20 dilimi var export const dilim = (b) => { // blogun tuttugu /20 dilimleri const s = new Set(); if (b.son < KURUM.bas || b.bas > KURUM.son) return s; const ilk = Math.floor((Math.max(b.bas, KURUM.bas) - KURUM.bas) / 4096); const sn = Math.floor((Math.min(b.son, KURUM.son) - KURUM.bas) / 4096); for (let i = ilk; i <= sn; i++) s.add(i); return s; }; export const KOMSU_DILIM = new Set(KOMSU.flatMap((k) => [...dilim(k)])); ``` `blok` işlevindeki taban hesabı modelin sessiz iddiasıdır: yazılan adres seçilen blok değildir. Önek kısaldıkça taban hizalanmak için geriye kayar, yani `10.42.0.0` yazıp kısa bir önek vermek başka bir yerden başlayan bir blok kurar. `dilim` ise ikinci bir eksen açıyor — bloğun kuruma ayrılan aralıkta kaç dilim tuttuğunu sayıyor, çünkü alınan yer başka bir ekibe kalmıyor. #### Önek Uzunluğu Taraması ```js // kosum1.mjs — onek uzunlugu taranir: kaci kullanilabilir, ne zaman tasar, kime carpar import { blok, CAPA, TALEP, altAg, gerek, ayrilan, kullanilan, tasma, cakisan, dilim, KOMSU_DILIM, TOPLAM_DILIM } from './adres.mjs'; const s = TALEP[TALEP.length - 1]; console.log(`donem-8 talebi: ${s[3]} ornek + ${s[1]} gecit + 2 dengeleyici = ${gerek(s)} adres; ` + `${altAg(s)} alt ag x 5 = ${ayrilan(s)} ayrilan; toplam ${kullanilan(s)}`); console.log(`${'blok'.padEnd(17)} ${'toplam'.padStart(8)} ${'kullanilabilir'.padStart(14)} ` + `${'tasma'.padStart(8)} ${'israf'.padStart(8)} ${'cakisan'.padStart(8)} ${'kalan /20'.padStart(10)} carptigi komsu`); for (const onek of [25, 24, 23, 22, 21, 20, 18, 16, 14, 12]) { const b = blok(`${CAPA}/${onek}`), t = tasma(b), c = cakisan(b); const yeni = new Set([...KOMSU_DILIM, ...dilim(b)]); console.log(`${b.ad.padEnd(17)} ${String(b.boyut).padStart(8)} ${String(b.boyut - ayrilan(s)).padStart(14)} ` + `${String(t ? `donem ${t}` : '-').padStart(8)} ${String(t ? '-' : b.boyut - kullanilan(s)).padStart(8)} ` + `${String(c.length).padStart(8)} ${String(TOPLAM_DILIM - yeni.size).padStart(10)} ${c.map((k) => k.ad).join(' ')}`.trimEnd()); } ``` ``` donem-8 talebi: 612 ornek + 4 gecit + 2 dengeleyici = 618 adres; 12 alt ag x 5 = 60 ayrilan; toplam 678 blok toplam kullanilabilir tasma israf cakisan kalan /20 carptigi komsu 10.42.0.0/25 128 68 donem 5 - 0 151 10.42.0.0/24 256 196 donem 7 - 0 151 10.42.0.0/23 512 452 donem 8 - 0 151 10.42.0.0/22 1024 964 - 346 0 151 10.42.0.0/21 2048 1988 - 1370 0 151 10.42.0.0/20 4096 4036 - 3418 0 151 10.42.0.0/18 16384 16324 - 15706 0 148 10.42.0.0/16 65536 65476 - 64858 1 144 olcut-arsivi 10.40.0.0/14 262144 262084 - 261466 2 112 saha-gecici olcut-arsivi 10.32.0.0/12 1048576 1048516 - 1047898 4 0 laboratuvar saha-gecici olcut-arsivi yedek-toplama ``` Ayrılan altmış adres her satırda aynı, oranı değil: `/25` bloğunda toplamın yüzde kırk yedisi ayrılmışa gidiyor, `/20` bloğunda yüzde bir buçuğu. Küçük blokta bölme düzeninin kendisi bloğun yarısını yiyor ve bu yem hiçbir örneğe verilmiyor. Taşma sütunu dar tarafın bedelini veriyor: `/25` beşinci dönemde, `/24` yedincide, `/23` sekizincide duruyor. Sekizinci dönemin talebi altı yüz yetmiş sekiz adres, `/23` bloğunda beş yüz on iki adres var. Sağ taraf ters yöndeki bedeli sayıyor. `/16` bloğu tek komşuya çarpıyor ve o komşu tam olarak `10.42.128.0/17` — planlayıcının kendi ikinci sekizlisinin içinde oturan bir kalem. `/14` yazmak tabanı `10.40.0.0` adresine, `/12` yazmak `10.32.0.0` adresine kaydırıyor; ikisinde de yazılan adres kurulan bloğun başlangıcı değil. Kaydırma iki komşuyu daha içeri alıyor. Çakışan bir blok eşlenemez: iki tarafta aynı adres iki makineye karşılık geldiği için eşleme reddedilir ve geriye yalnız adres dönüştürme kalır. Son sütun geniş seçimin görünmeyen bedelidir. Kuruma ayrılan aralıkta iki yüz elli altı dilim var; komşular yüz dördünü tutuyor. `/20` ve altındaki her seçim bir dilim alıp yüz elli birini bırakıyor, `/18` yüz kırk sekiz, `/14` yüz on iki, `/12` sıfır. Aynı gün başka bir ekip aynı aralıktan blok isteyecek. Sıfır ile yüz elli bir arasındaki fark bugün hiçbir uyarı üretmez. Tarama pencereyi kendisi çiziyor: `/22` ile `/18` arasında hem taşma yok hem çakışma yok. `/20` sekizinci dönemde üç bin dört yüz on sekiz adres boş bırakıyor — bu israf bir maliyet kalemine karşılık gelmiyor, yalnız bir dilim tutuyor. `/23` ile arasındaki fark, kurulum gününde tek karakterdir. #### Dar Seçimin Bedeli ```js // kosum2.mjs — /23 secilmisti; tasma aninda uc cikis yolu kurgu birimle sayilir import { blok, CAPA, TALEP, altAg, kullanilan, tasma } from './adres.mjs'; const SECIM = blok(`${CAPA}/23`), GENIS = blok(`${CAPA}/20`); const t = tasma(SECIM), d = TALEP.find((x) => x[0] === t); console.log(`secilen blok ${SECIM.ad}: ${SECIM.boyut} adres, donem-1 talebi ${kullanilan(TALEP[0])} ` + `-> ${(SECIM.boyut / kullanilan(TALEP[0])).toFixed(1)}x pay, kurulum gunu hicbir sey soylemiyor`); console.log(`ayni gun ${GENIS.ad} yazmanin ek bedeli: 0 birim, 0 ek satir, 0 ek dakika`); console.log(`tasma donem ${t}: ${d[3]} ornek, ${altAg(d)} alt ag, ${kullanilan(d)} adres gerekiyor, ${SECIM.boyut} var\n`); // Bedeller kurgu "birim" (BA5); oranlari tasiyor, para birimi degil. const YOL = [ ['yeniden kurma', d[3] * 2 + altAg(d) * 15 + 5 * 40, 0, 0], ['ikinci ag + esleme', 120, 95, altAg(d)], ['adres donusturme katmani', 40, 60, 2], ]; const taban = YOL[0][1]; console.log(`${'cikis yolu'.padEnd(25)} ${'kurulum'.padStart(8)} ${'donem basi'.padStart(11)} ` + `${'kalici kalem'.padStart(13)} ${'6 donem'.padStart(8)} ${'yeniden kurmayi gectigi'.padStart(23)}`); for (const [ad, k, dn, kal] of YOL) { let n = 0; if (dn > 0) { n = 1; while (k + dn * n <= taban) n++; } console.log(`${ad.padEnd(25)} ${String(k).padStart(8)} ${String(dn).padStart(11)} ${String(kal).padStart(13)} ` + `${String(k + dn * 6).padStart(8)} ${String(n ? `donem ${n}` : '-').padStart(23)}`); } ``` ``` secilen blok 10.42.0.0/23: 512 adres, donem-1 talebi 42 -> 12.2x pay, kurulum gunu hicbir sey soylemiyor ayni gun 10.42.0.0/20 yazmanin ek bedeli: 0 birim, 0 ek satir, 0 ek dakika tasma donem 8: 612 ornek, 12 alt ag, 678 adres gerekiyor, 512 var cikis yolu kurulum donem basi kalici kalem 6 donem yeniden kurmayi gectigi yeniden kurma 1604 0 0 1604 - ikinci ag + esleme 120 95 12 690 donem 16 adres donusturme katmani 40 60 2 400 donem 27 ``` İkinci satır dersin ölçüsüdür. `/23` yerine `/20` yazmak kurulum gününde sıfır birim tutuyor: aynı komut, aynı dakika, aynı satır sayısı. Birinci dönemde `/23` bloğunda on iki kat pay görünüyordu ve bu görüntü yedi dönem boyunca doğru kaldı. Sekizinci dönemde blok bitiyor ve bitmesiyle birlikte üç yoldan biri seçilmek zorunda kalıyor. Yeniden kurma bin altı yüz dört birim; altı yüz on iki örneği taşımak, on iki alt ağı yeniden kurmak ve kesintili bir pencere açmak. Tek seferliktir ve arkasında kalıcı kalem bırakmaz. İkinci ağ açıp eşlemek yüz yirmi birime kuruluyor ve toplantıda her seferinde bunu kazanır — altı dönem sonunda hâlâ altı yüz doksan birimde, yeniden kurmanın yarısından ucuz. Onaltıncı dönemde geçiyor. Adres dönüştürme katmanı daha da ucuz başlıyor ve yirmi yedinci dönemde geçiyor. Kalıcı kalem sütunu asıl farkı taşıyor. İkinci ağ on iki kalıcı kalem bırakıyor: on iki yönlendirme tablosunun her birine yazılması ve bundan sonra her değişiklikte güncellenmesi gereken birer satır. Adres dönüştürme katmanının iki kalıcı kalemi satır değil özelliktir — iki taraf birbirini gerçek adresiyle göremez ve günlüklerde kaynak adres katmanın adresine dönüşür. Ertelemenin bedeli birim sayısında değil, bu iki sütunun ilerideki her derse taşınmasındadır. #### Elde Kalan Karar | Kalem | Kimde | Sonradan değişir mi | |---|---|---| | Adres bloğu ve önek uzunluğu | ekip | hayır | | Bloğun kurum aralığındaki yeri | ekip | hayır | | Alan sayısı | ekip | yalnız artar | | Alt ağ sınırları | ekip | yalnız artar | | Yönlendirme kuralları | ekip | evet | | Filtre kuralları | ekip | evet | | Ad çözümleme ve akış günlüğü | ekip | evet | | Eşleme ve özel bağlantı | ekip | çakışma yoksa evet | | Alt ağ başına ayrılan beş adres | sağlayıcı | — | | Adres tahsis mekanizması | sağlayıcı | — | | İletim düzlemi ve kiracı yalıtımı | sağlayıcı | — | | Geçidin kendi yedekliliği | sağlayıcı | — | On iki kalemin sekizi elde kalıyor, dördü devrediliyor. Devredilen dördü hiç sorulmuyor da denebilir — ayrılan beş adres bir tercih değil, bir kesintidir ve `/25` bloğunda toplamın yarısına yaklaşır. Elde kalan sekizin dördü serbestçe değişiyor, ikisi yalnız büyüyebiliyor, ikisi kurulduktan sonra hiç değişmiyor. "Değişmez" burada bir yasak değil, bir bağımlılık yığınıdır. Blok yazıldığı andan sonra ona dayanan üç kalem doğuyor: dağıtılmış adresler, o adreslere göre yazılmış yönlendirme kuralları ve aynı adreslere göre yazılmış filtre kuralları. Bloğu genişletmek üçünü birden geçersiz kılar, çünkü genişleme tabanı kaydırır — `10.42.0.0/23` bloğunu `/20` yapmak yeni bir bloktur, aynı bloğun büyümüş hâli değil. Kurumun kaydında da yer değiştirir ve o sırada komşuların hangisine çarpacağı yeniden sorulmak zorunda kalır. Geri alınamayan kalem bu iki satırdır: bloğun kendisi ve bloğun kurum aralığındaki yeri. Bu kursun öteki kalemleri yanlış yazıldığında bir kural düzeltilir; burada yanlış yazıldığında bin altı yüz dört birimlik bir taşıma ya da her yönlendirme tablosuna dokunan kalıcı bir ek yapı doğar. Kararın alındığı an, elde en az bilginin olduğu andır — birinci dönemde on sekiz örnek koşuyordu ve sekizinci dönemin altı yüz on iki örneği hiçbir yerde yazılı değildi. #### Özet - Sekizinci dönem talebi 618 adres artı 12 alt ağ için 60 ayrılmış adres. Aynı 60 adres `/25` bloğunun yüzde 47'sini, `/20` bloğunun yüzde 1,5'ini yiyor; bölme düzeninin kesintisi küçük blokta blok kadar belirleyici. - Dar tarafın bedeli taşma dönemidir: `/25` dönem 5'te, `/24` dönem 7'de, `/23` dönem 8'de duruyor. Geniş tarafın bedeli çakışmadır: `/16` bir, `/14` iki, `/12` dört komşu bloğa çarpıyor ve çakışan blok eşlenemez. - Kısa önek tabanı hizalamak için geriye kaydırıyor; `10.42.0.0` yazıp `/12` vermek `10.32.0.0` adresinden başlayan bir blok kuruyor ve kuruma ayrılan 256 dilimin tamamını tutuyor. `/20` bir dilim tutup 151 dilim bırakıyor. - Geri alınamayan kalem adres bloğu ve önek uzunluğudur. Kurulum gününde `/23` yerine `/20` yazmak 0 birim tutuyor; sekizinci dönemde aynı fark yeniden kurmada 1.604 birim, ikinci ağda 120 birim artı dönem başına 95 birim ve 12 kalıcı yönlendirme satırı. - Ucuz görünen çıkış yolu kalıcı olanıdır: ikinci ağ 16. dönemde, adres dönüştürme katmanı 27. dönemde yeniden kurmanın toplamını geçiyor ve o zamana kadar doğrudan adreslemenin bitmiş olması geri alınmıyor. #### Sonraki Adım Blok seçildi ve içinde altı yüz yetmiş sekiz adreslik bir talep var — ama blok henüz tek parça. Adresler kullanılabilmek için bölünmek zorunda ve bölme düzeni yeni bir soru açıyor: her örnek dışarıdan doğrudan erişilebilir olmalı mı. Sonraki dersin sorusu bölmenin iki eksenini birden sayar: aynı blok az sayıda büyük parçaya ve çok sayıda küçük parçaya bölündüğünde kaç adres kullanılabilir kalıyor, alt ağ başına kesilen beş adres kaç parçada kaç yüz adres tutuyor ve bir alanın kaybı hangi düzende kaç örneği götürüyor — ve parçaların bir bölümünü dışarıya kapatmak doğrudan erişilebilir örnek sayısını kaça indirirken karşılığında hangi ek bileşeni zorunlu kılıyor. ### Alt Ağlar Source: https://academia.sh/tr/kurslar/bulut-hesaplama-ve-ag/alt-aglar Aynı blok iki eksende bölünür ve her düzende kullanılabilir adres, ayrılan pay, atanmamış artık ve bir alanın kaybındaki örnek sayısı sayılır; genel ve özel alt ağ ayrımının dışarıdan erişilebilir kalemi kaça indirdiği ve karşılığında kaç ek bileşenle kaç yönlendirme tablosu istediği kalem kalem çıkarılır. Blok seçildi ve içinde sekizinci dönem için altı yüz yetmiş sekiz adreslik bir talep var. Blok şimdilik tek parça: dört bin doksan altı adres yan yana duruyor ve hiçbiri bir örneğe verilemiyor. Adres bir alt ağdan dağıtılır, alt ağ bir alana bağlıdır ve alt ağ sınırı çizildikten sonra o sınır da yerinde kalır. Bölme kararı iki ekseni birden taşıyor. Birincisi alt ağın boyu: az sayıda büyük parça mı, çok sayıda küçük parça mı. İkincisi alanlara dağılım: aynı blok kaç alana yayılsın. İkisi de aynı adres sayısını harcıyor ve bambaşka iki sonuç üretiyor. Üçüncü bir soru bunların üstüne biniyor: her parça dışarıdan doğrudan erişilebilir olmalı mı. - **BA7.** Bölme düzenleri ve talep dağılımı kurgusal bölgesel ölçüm ağına aittir. Gerçek bir ağ bölünmüyor; ölçülen şey `node` ile kurulan modeldir. Adres aritmetiği gerçektir. - **BA8.** Önceki dersin `/20` bloğu ve alt ağ başına beş ayrılan adres varsayımı sürüyor. - **BA9.** Katman payları yüzde olarak elle yazıldı: genel 8, uygulama 62, veri 30. Gerçekte pay iş yüküne göre değişir; en yoğun alt ağın hangisi olduğunu kaydırır, tarama mantığını değiştirmez. - **BA10.** Bölme tekdüze varsayıldı: bütün alt ağlar aynı boyda. Gerçekte karışık boy kullanılır; atanmamış artığı azaltır, dilim yuvarlaması cezasını kaldırmaz. - **BA11.** Her örnekte dört kapı dinlediği varsayıldı. Makine düzeyinde bu sayı ayrıca ölçüldü; burada yalnız çarpan olarak kullanılıyor. - **BA12.** Bir alanın kaybı tam kayıp sayıldı. Gerçekte kısmi bozulma daha sıktır; kayıp örnek sayısını düşürür, alan sayısıyla ilişkisini değiştirmez. #### Bölme Düzeni Modeli Model tek bir şeyi ciddiye alıyor: bir bloğu tekdüze bölmek için parça sayısının ikinin kuvveti olması gerekir. On iki alt ağ isteyen bir düzen on altı dilime bölünür ve dördü atanmadan kalır. `dilim` işlevi bu yuvarlamayı yapıyor, geri kalan her sayı ondan türüyor. ```js // bolme.mjs — /20 blogun alt aglara bolunmesi; gercek ag kurulmuyor, aritmetik gercek export const BLOK = 4096; // onceki derste secilen /20 export const AYRILAN = 5; // saglayici her alt agda bes adres ayirir (BA8) export const ORNEK = 612; // donem-8 talebi // Katman paylari yuzde olarak; toplami 100 (BA9) export const KATMAN = [['genel', 8], ['uygulama', 62], ['veri', 30]]; export const onek = (boyut) => 32 - Math.log2(boyut); export const dilim = (n) => 2 ** Math.ceil(Math.log2(n)); // duzen ikinin kuvvetine yuvarlanir export const boyut = (n) => BLOK / dilim(n); export const kullanilabilir = (n) => boyut(n) - AYRILAN; // Bir alandaki en kalabalik katmanin ornek sayisi export const yogun = (alan) => Math.max(...KATMAN.map(([, p]) => Math.ceil(ORNEK * p / 100 / alan))); export const duzen = (alan, katman = KATMAN.length) => { const n = alan * katman, k = kullanilabilir(n); const normal = yogun(alan), ariza = alan > 1 ? yogun(alan - 1) : normal; return { alan, katman, n, dilim: dilim(n), boyut: boyut(n), kullanilabilir: k, toplam: n * k, ayrilan: AYRILAN * n, atanmamis: BLOK - n * boyut(n), normal, ariza, kayip: Math.ceil(ORNEK / alan), sigar: normal <= k, arizaSigar: ariza <= k, pay: (k / normal) }; }; ``` `ariza` alanı modelin ikinci iddiasıdır: bir alan düştüğünde yük kalan alanlara dağılır ve en yoğun alt ağın talebi büyür. Bölme düzeni normal günde sığıyor diye arıza gününde de sığmak zorunda değil, çünkü alt ağın sınırı o gün genişletilemez. #### İki Eksende Tarama ```js // kosum1.mjs — ayni /20 blok iki eksende bolunur: alt ag boyu ve alan sayisi import { BLOK, ORNEK, AYRILAN, onek, yogun, duzen } from './bolme.mjs'; const ALAN = 4, KATMAN = 3, N = ALAN * KATMAN; console.log(`${BLOK} adreslik blok, ${ALAN} alan x ${KATMAN} katman = ${N} alt ag, ${ORNEK} ornek`); console.log(`${'alt ag'.padEnd(7)} ${'dilim'.padStart(6)} ${'kullanilabilir'.padStart(14)} ` + `${'toplam'.padStart(7)} ${'ayrilan'.padStart(8)} ${'atanmamis'.padStart(10)} ${'en yogun'.padStart(9)} durum`); for (const b of [1024, 512, 256, 128, 64, 32]) { const d = BLOK / b, k = b - AYRILAN, y = yogun(ALAN), yer = d >= N; console.log(`/${String(onek(b)).padEnd(6)} ${String(d).padStart(6)} ${String(k).padStart(14)} ` + `${String(yer ? N * k : '-').padStart(7)} ${String(yer ? AYRILAN * N : '-').padStart(8)} ` + `${String(yer ? BLOK - N * b : '-').padStart(10)} ${String(y).padStart(9)} ` + (!yer ? `${N} alt ag kurulamaz, en cok ${d}` : y <= k ? `sigar, ${(k / y).toFixed(1)}x pay` : `en yogun katman sigmiyor`)); } console.log(`\nayni blok, ${KATMAN} katman sabit, alan sayisi taranir:`); console.log(`${'alan'.padEnd(5)} ${'alt ag'.padStart(7)} ${'dilim'.padStart(6)} ${'kullanilabilir'.padStart(14)} ` + `${'en yogun'.padStart(9)} ${'buyume payi'.padStart(12)} ${'bir alan dusunce'.padStart(17)} ${'ariza sonrasi'.padStart(14)}`); for (const a of [2, 3, 4, 6, 8]) { const d = duzen(a); console.log(`${String(a).padEnd(5)} ${String(d.n).padStart(7)} ${String(d.dilim).padStart(6)} ` + `${String(d.kullanilabilir).padStart(14)} ${String(d.normal).padStart(9)} ${`${d.pay.toFixed(1)}x`.padStart(12)} ` + `${`${d.kayip} ornek`.padStart(17)} ${`${d.ariza}/${d.kullanilabilir}`.padStart(14)}`); } ``` ``` 4096 adreslik blok, 4 alan x 3 katman = 12 alt ag, 612 ornek alt ag dilim kullanilabilir toplam ayrilan atanmamis en yogun durum /22 4 1019 - - - 95 12 alt ag kurulamaz, en cok 4 /23 8 507 - - - 95 12 alt ag kurulamaz, en cok 8 /24 16 251 3012 60 1024 95 sigar, 2.6x pay /25 32 123 1476 60 2560 95 sigar, 1.3x pay /26 64 59 708 60 3328 95 en yogun katman sigmiyor /27 128 27 324 60 3712 95 en yogun katman sigmiyor ayni blok, 3 katman sabit, alan sayisi taranir: alan alt ag dilim kullanilabilir en yogun buyume payi bir alan dusunce ariza sonrasi 2 6 8 507 190 2.7x 306 ornek 380/507 3 9 16 251 127 2.0x 204 ornek 190/251 4 12 16 251 95 2.6x 153 ornek 127/251 6 18 32 123 64 1.9x 102 ornek 76/123 8 24 32 123 48 2.6x 77 ornek 55/123 ``` Üst tablonun ilk iki satırı adres sayısıyla ilgili değil. `/23` alt ağında beş yüz yedi kullanılabilir adres var, on iki alt ağın toplam talebinden fazla — ama blok yalnız sekiz parçaya bölünüyor ve dört alan ile üç katmanın çarpımı sekize sığmıyor. Bloğun sınırı adres sayısında değil, parça sayısında bağlıyor. Alt tarafta ise adres yeter, parça sığar ve düzen yine tutmaz: `/26` alt ağının elli dokuz kullanılabilir adresine doksan beş örneklik uygulama katmanı girmiyor. Pencere iki satır geniş. `/24` düzeninde en yoğun alt ağın iki buçuk katlık payı var, `/25` düzeninde payı bire üçte bir düşüyor — bir büyüme adımı sonrasında alt ağ doluyor ve alt ağ sınırı o gün genişletilemiyor. Ayrılan altmış adres her satırda aynı, ağırlığı değil: `/24` düzeninde atanan üç bin yetmiş iki adresin yüzde ikisi, `/26` düzeninde yedi yüz altmış sekiz adresin yüzde sekizi. Atanmamış sütunu bin yirmi dörtten üç bin yedi yüz on ikiye çıkıyor; bu adresler kaybolmuyor ama seçilen dilim boyuna kilitleniyor — `/26` seçen bir plan gelecekte de `/26` ekleyebilir. Alt tablo ikinci ekseni ölçüyor ve beklenmedik bir ceza çıkarıyor. Alan sayısı ikinin kuvveti olduğunda büyüme payı iki buçuk katın üstünde kalıyor: iki alanda 2,7 kat, dört alanda 2,6, sekiz alanda 2,6. Üç ve altı alan aynı bloğu daha kötü kullanıyor — 2,0 ve 1,9 kat. Sebep adres talebi değil, yuvarlama: dokuz alt ağ on altı dilime, on sekiz alt ağ otuz iki dilime yuvarlanıyor ve karşılığı alınmayan dilimler alt ağ boyunu bir kademe küçültüyor. Alan sayısını üçe çekmek dayanıklılık adına alınmış bir karardır ve bedelini adres planında ödetir. Son iki sütun arıza etkisini ayırıyor. Bir alanın kaybı iki alanda üç yüz altı örnek, sekiz alanda yetmiş yedi örnek götürüyor: aynı blok, aynı adres sayısı, dört kat fark. Arıza sonrası sütununda ise her düzen sığıyor — kalan alanlara dağılan yük en yoğun alt ağı dolduramıyor. Bölme düzeni arıza gününde adres yüzünden değil, ayakta kalan örnek sayısı yüzünden ayrışıyor. #### Genel ve Özel Ayrımı ```js // kosum2.mjs — ayni 12 alt ag uc erisim duzeninde; disaridan gorunen yuzey sayilir import { ORNEK, KATMAN } from './bolme.mjs'; const ALAN = 4, KAPI = 4; // ornek basina dinleyen kapi (BA11) const sayi = (p) => Math.ceil(ORNEK * p / 100 / ALAN) * ALAN; const ORNEKLER = Object.fromEntries(KATMAN.map(([ad, p]) => [ad, sayi(p)])); const TOPLAM = Object.values(ORNEKLER).reduce((a, b) => a + b, 0); console.log(`${ALAN} alan x ${KATMAN.length} katman: ` + KATMAN.map(([ad]) => `${ad} ${ORNEKLER[ad]}`).join(', ') + `, toplam ${TOPLAM} ornek, ornek basina ${KAPI} kapi`); // [ad, genel adresli katmanlar, dis dengeleyici, alan basina donusturme gecidi] const DUZEN = [ ['ayrim yok', ['genel', 'uygulama', 'veri'], 0, 0], ['yalniz genel katman', ['genel'], 0, 0], ['hicbiri genel', [], 1, 1], ]; console.log(`\n${'duzen'.padEnd(20)} ${'genel ag'.padStart(9)} ${'ozel ag'.padStart(8)} ${'genel adres'.padStart(12)} ` + `${'acik kalem'.padStart(11)} ${'ozel ornek'.padStart(11)} ${'ek bilesen'.padStart(11)} ${'tablo'.padStart(6)}`); for (const [ad, genel, dng, gec] of DUZEN) { const genelAg = genel.length * ALAN, ozelAg = (KATMAN.length - genel.length) * ALAN; const genelOrnek = genel.reduce((a, k) => a + ORNEKLER[k], 0); const kalem = genelOrnek * KAPI + dng; // dis dengeleyici tek kapi dinliyor const bilesen = 1 + dng + gec * ALAN; // internet gecidi + dengeleyici + alan basina gecit const tablo = gec ? 1 + ALAN : genelAg && ozelAg ? 2 : 1; console.log(`${ad.padEnd(20)} ${String(genelAg).padStart(9)} ${String(ozelAg).padStart(8)} ` + `${String(genelOrnek).padStart(12)} ${String(kalem).padStart(11)} ${String(TOPLAM - genelOrnek).padStart(11)} ` + `${String(bilesen).padStart(11)} ${String(tablo).padStart(6)}`); } console.log(`\nblok icinde her ornek her ornege ulasabiliyor: ${TOPLAM} x ${TOPLAM - 1} yon, uc duzende de ayni`); console.log(`disa acik kalem: ${TOPLAM * KAPI} -> ${ORNEKLER.genel * KAPI} -> 1`); ``` ``` 4 alan x 3 katman: genel 52, uygulama 380, veri 184, toplam 616 ornek, ornek basina 4 kapi duzen genel ag ozel ag genel adres acik kalem ozel ornek ek bilesen tablo ayrim yok 12 0 616 2464 0 1 1 yalniz genel katman 4 8 52 208 564 1 2 hicbiri genel 0 12 0 1 616 6 5 blok icinde her ornek her ornege ulasabiliyor: 616 x 615 yon, uc duzende de ayni disa acik kalem: 2464 -> 208 -> 1 ``` Ayrım yapılmayan düzen bir tercih gibi görünmüyor çünkü kimse onu seçmiyor; alt ağ oluşturulurken genel adres atama davranışı açık bırakıldığı için oluyor. Sonucu iki bin dört yüz altmış dört kalem: altı yüz on altı örneğin dördü de dışarıdan erişilebilir. Genel katmanı ayırmak bu sayıyı iki yüz sekize indiriyor — on iki kat — ve tek maliyeti yönlendirme tablosunun ikiye çıkması. Üçüncü satır ayrımın sonuna kadar götürülmüş hâli. Dışarıdan erişilebilen tek kalem, yük dengeleyicinin dinlediği kapıdır. Altı yüz on altı örnek hâlâ dört kapı dinliyor; hiçbiri dışarıdan çağrılamıyor. Bedeli sağ iki sütunda: bileşen sayısı birden altıya, yönlendirme tablosu birden beşe çıkıyor. Beş tablo, dört alanın her birinin kendi geçidine bakması gerektiği için doğuyor ve bu sayı yeni bir yükün habercisidir — her yeni alt ağ artık bir tabloya değil, doğru tabloya yazılmak zorunda. Son iki satır ayrımın ölçmediği şeyi söylüyor. Blok içinde altı yüz on altı örnek birbirine ulaşabiliyor ve bu sayı üç düzende de aynı: alt ağ ayrımı iç yüzeye dokunmuyor. Ayrıca altı yüz on altı örneğin altı yüz on altısı artık kendi başına dışarıya çıkamıyor; çıkabilmesi için sayılan altı bileşenden dördü var. Bu iki eksik ilerideki iki dersin konusudur: birincisi kuralların hangi tabloda ve hangi sırayla yazıldığı, ikincisi kapalı bir alt ağın dışarıya nasıl çıktığı. İkisinin de faturası bu derste açılan ayrımdan doğuyor — dışa açık kalemi 2.464'ten 1'e indiren karar, aynı anda beş tablo ve dört geçit borcu yazıyor. Bu derste elde kalan karar beş kalemdir: dilim boyu, alan sayısı, katman sayısı, hangi katmanın genel olacağı ve her alt ağın hangi alana bağlanacağı. Devredilen üç kalem hiç sorulmuyor: alt ağ başına kesilen beş adres, tekdüze bölmede parça sayısının ikinin kuvvetine yuvarlanması ve bir alt ağın oluşturulduktan sonra alan değiştirememesi. Devredilen üçünden ikisi yukarıdaki tabloların sayılarını doğrudan üretiyor — altmış adreslik kesinti ve üç alanda 2,0 kata düşen büyüme payı. Bir kalemin sağlayıcıda olması onu etkisiz yapmıyor, yalnız görünmez yapıyor. Geri alınamayan kalem burada alt ağ sınırıdır. Bir alt ağ oluşturulup içine örnek yerleştikten sonra öneki daraltılamaz ve başka bir alana taşınamaz; genişletme sağlayıcıya bağlıdır — kimi sağlayıcı öneki büyütmeye izin verir, kimi hiç değiştirmez. Bu ders öneki sabit sayar. Dilim boyu seçimi bunun üstüne biner: `/24` seçen plan gelecekte de `/24` ekler. Alan ataması da kalıcıdır — üç alan seçmenin bedeli 2,0 katlık büyüme payıdır ve o pay dolduğunda çözüm yeni alt ağ eklemektir, var olanı büyütmek değil. #### Özet - Aynı 4096 adreslik blok, aynı 12 alt ağ: `/22` ve `/23` düzenleri adres yüzünden değil parça sayısı yüzünden kurulamıyor, `/26` ve `/27` düzenlerinde 95 örneklik en yoğun katman 59 ve 27 kullanılabilir adrese sığmıyor. Pencere iki satır geniş. - Ayrılan 60 adres her düzende aynı, ağırlığı değil: `/24` düzeninde atananın yüzde 2'si, `/26` düzeninde yüzde 8'i. Atanmamış artık 1.024'ten 3.712'ye çıkıyor ve seçilen dilim boyuna kilitleniyor. - Alan sayısı ikinin kuvveti olduğunda büyüme payı 2,6–2,7 kat; 3 ve 6 alanda 2,0 ve 1,9 kata düşüyor. Ceza dilim yuvarlamasından geliyor: 9 alt ağ 16 dilime, 18 alt ağ 32 dilime yuvarlanıp alt ağ boyunu bir kademe küçültüyor. - Bir alanın kaybı 2 alanda 306, 8 alanda 77 örnek götürüyor — dört kat fark. Arıza sonrası her düzende adres yetiyor; düzenler ayakta kalan örnek sayısında ayrışıyor. - Genel ve özel ayrımı dışa açık kalemi 2.464'ten 208'e, oradan 1'e indiriyor ve genel adres sayısını 616'dan 0'a çekiyor. Karşılığı 1 bileşen ve 1 tablo yerine 6 bileşen ve 5 tablodur; iç yüzey olan 616 örneklik erişilebilirlik üç düzende de değişmiyor. #### Sonraki Adım Beş yönlendirme tablosu son koşumda tek bir sayı olarak geçti, oysa asıl yükü orada. Dört alanın özel alt ağları kendi geçidine, genel alt ağlar başka bir yere bakıyor ve hangi trafiğin nereye gittiği bu tabloların içinde yazılı. Sonraki dersin sorusu bu kuralları kalem kalem çıkarır: bir hedef adres verildiğinde hangi satır kazanıyor ve en uzun önek eşleşmesi hangi durumlarda sezgiye aykırı bir yol seçiyor, eksik ya da fazla yazılmış tek bir satır kaç alt ağı erişilemez bırakıyor ve trafiği beklenmedik bir yoldan çıkarınca çıkış ücretine ne ekliyor, aynı kural kaç tabloda tekrarlanıyor ve on üçüncü alt ağ eklendiğinde kaç tabloya dokunmak gerekiyor. ### Yönlendirme Tabloları Source: https://academia.sh/tr/kurslar/bulut-hesaplama-ve-ag/yonlendirme-tablolari Beş yönlendirme tablosu modellenir ve her akış için kazanan satır en uzun önek eşleşmesiyle hesaplanır: geniş yazılmış kural kaç akışı sessizce yutuyor, dar yazılmış kural aynı akışı kaç birim ücretle yutuyor, tek satırın düşmesi kaç örneği ve kaç birimi etkiliyor, aynı kural kaç tabloda tekrarlanıyor. Önceki ders beş yönlendirme tablosuyla kapandı ve beş yalnız bir sayıydı. Tabloların içinde bir alt ağdan çıkan paketin nereye gideceği yazılı: bloğun kendi içine mi, eşlenmiş bir ağa mı, özel bir bağlantıya mı, yoksa dışarı mı. Bir paket birden çok satıra uyabilir ve hangisinin kazandığı tek bir kurala bağlıdır — en uzun önek. Bu kural iki şeyi birden yapıyor. Beklenen tarafı şu: bloğun kendi içine giden trafik, ne kadar geniş yazılmış olursa olsun başka bir satıra kapılmaz. Beklenmeyen tarafı ise satır yazmanın taşıma yeteneği vermemesidir — kazanan satır bir hedefi gösterebilir, o hedef adresi taşımıyor olabilir ve paket geri dönmez. İki taraf aynı tabloda, çoğu zaman aynı satırda durur; ayıran şey satırın yazılışı değil, gösterdiği hedefin gerçekte ne taşıdığıdır. - **BA13.** Beş tablo, altı kural ve sekiz akış kurgusal bölgesel ölçüm ağına aittir. Gerçek bir ağ yönlendirilmiyor; ölçülen şey `node` ile kurulan modeldir. Önek eşleşmesi gerçek adres aritmetiğiyle hesaplanıyor. - **BA14.** Bütün hedefler özel adres blokları ile belgeleme için ayrılmış bloklardan seçildi. - **BA15.** Bir tablo satırı yazmak taşıma kapasitesi vermez; her hedefin gerçekten taşıdığı aralık ayrı modellendi. Gerçekte bu ayrım bağlantının kendi yapılandırmasında durur. - **BA16.** Sekiz akış ve dönemlik hacimleri elle yazıldı; rastgelelik yok, her koşum aynı sayıları üretir. - **BA17.** Çıkış ücreti yüz hacim birimi başına iki kurgu **birim** sayıldı. Para birimi değildir; yolların birbirine oranını taşır. - **BA18.** Dört alanın özel tablosu birbirinin aynı varsayıldı. Gerçekte alanlar arasında fark olur; tekrar sayısını düşürür, dokunuş sayısını değiştirmez. #### Yönlendirme Tablosu Modeli Model iki şeyi ayrı tutuyor: tabloya yazılan satır ve hedefin gerçekten taşıdığı aralık. `TASIR` sözlüğü ikincisidir ve modelin ana iddiası oradadır. `sonuc` işlevi önce kazanan satırı buluyor, sonra o satırın gösterdiği hedefin adresi taşıyıp taşımadığına bakıp dört sonuçtan birini döndürüyor. ```js // yol.mjs — yonlendirme tablosu modeli ve en uzun onek eslesmesi; gercek ag yok export const toInt = (ip) => ip.split('.').reduce((a, o) => a * 256 + Number(o), 0); export const blok = (c) => { const [ip, e] = c.split('/'); const n = Number(e), b = 2 ** (32 - n); const bas = Math.floor(toInt(ip) / b) * b; return { onek: n, bas, son: bas + b - 1 }; }; export const icinde = (c, ip) => { const b = blok(c), a = toInt(ip); return a >= b.bas && a <= b.son; }; export const OZEL = ['10.0.0.0/8', '172.16.0.0/12', '192.168.0.0/16']; export const ozelMi = (ip) => OZEL.some((c) => icinde(c, ip)); // Hedefin gercekten tasidigi aralik; satir yazmak tasima kapasitesi vermez (BA15). null: her yeri tasir, ucretli. export const TASIR = { 'yerel': ['10.42.0.0/20'], 'esleme-merkez': ['10.0.0.0/16'], 'esleme-yedek': ['10.44.0.0/14'], 'esleme-eski': ['10.8.0.0/14'], 'ozel-baglanti': ['172.20.0.0/14'], 'gecit': null, }; export const en = (t, ip) => t.filter(([c]) => icinde(c, ip)) .sort((a, b) => blok(b[0]).onek - blok(a[0]).onek)[0]; // en uzun onek kazanir export const sonuc = (t, ip) => { const s = en(t, ip); if (!s) return { satir: '-', hedef: '-', son: 'yol yok', ucret: false }; const tas = TASIR[s[1]]; const son = tas === null ? (ozelMi(ip) ? 'gecit-bosa' : 'gecit') : tas.some((c) => icinde(c, ip)) ? 'ulasir' : 'kara delik'; return { satir: s[0], hedef: s[1], son, ucret: son.startsWith('gecit') }; }; const ORTAK = [['10.42.0.0/20', 'yerel'], ['172.20.0.0/14', 'ozel-baglanti'], ['0.0.0.0/0', 'gecit']]; export const KUME = { genis: [...ORTAK, ['10.0.0.0/8', 'esleme-merkez']], dar: [...ORTAK, ['10.0.0.0/16', 'esleme-merkez']], tam: [...ORTAK, ['10.0.0.0/16', 'esleme-merkez'], ['10.44.0.0/14', 'esleme-yedek'], ['10.8.0.0/14', 'esleme-eski']], }; // [ad, hedef adres, donemlik akis hacmi] — kurgusal olcum aginin akislari (BA16) export const AKIS = [ ['ic olcum toplayici', '10.42.3.14', 4200], ['ic veri deposu', '10.42.9.7', 9100], ['merkez salon kaydi', '10.0.4.7', 2600], ['eski olcum arsivi', '10.8.3.1', 340], ['ortak baglanti ucu', '172.20.5.9', 780], ['yedek toplama', '10.44.2.3', 150], ['dis paket deposu', '198.51.100.9', 60], ['dis olcum hizmeti', '203.0.113.4', 1900], ]; export const UCRET = (h) => Math.round(h * 2) / 100; // 100 hacim birimi basina 2 kurgu birim (BA17) export const ALAN = 4; ``` Üç tablo kümesi aynı iskeletten türüyor: üç ortak satır ve üzerine eşleme kuralının bir biçimi. `genis` kümesi tek satırla bütün iç adres alanını kapsamaya çalışıyor, `dar` kümesi yalnız gerçekten eşlenmiş aralığı yazıyor, `tam` kümesi eksik kalan iki hedefi ayrıca ekliyor. Akış listesinin sekiz satırından ikisi bloğun içine, üçü kurumun başka bloklarına, biri ortak bağlantıya ve ikisi dışarıya gidiyor; hacimler dönemliktir ve ücreti onlar belirliyor. #### Kazanan Satır ```js // kosum1.mjs — her akis icin kazanan satir cikarilir, sonra uc tablo kumesi karsilastirilir import { KUME, AKIS, UCRET, sonuc, icinde } from './yol.mjs'; console.log(`genis kume (${KUME.genis.length} satir), akis akis kazanan satir:`); console.log(`${'akis'.padEnd(20)} ${'hedef adres'.padEnd(14)} ${'eslesen'.padStart(7)} ` + `${'kazanan satir'.padEnd(14)} ${'yon'.padEnd(14)} sonuc`); for (const [ad, ip] of AKIS) { const es = KUME.genis.filter(([c]) => icinde(c, ip)).length, r = sonuc(KUME.genis, ip); console.log(`${ad.padEnd(20)} ${ip.padEnd(14)} ${String(es).padStart(7)} ` + `${r.satir.padEnd(14)} ${r.hedef.padEnd(14)} ${r.son}`); } console.log(`\n${'kume'.padEnd(7)} ${'satir'.padStart(6)} ${'ulasan'.padStart(7)} ${'kara delik'.padStart(11)} ` + `${'gecit-bosa'.padStart(11)} ${'ucretli hacim'.padStart(14)} ${'cikis ucreti'.padStart(13)}`); for (const [ad, t] of Object.entries(KUME)) { const r = AKIS.map(([, ip, h]) => ({ ...sonuc(t, ip), h })); const n = (s) => r.filter((x) => x.son === s).length; const hacim = r.filter((x) => x.ucret).reduce((a, x) => a + x.h, 0); console.log(`${ad.padEnd(7)} ${String(t.length).padStart(6)} ${String(n('ulasir')).padStart(7)} ` + `${String(n('kara delik')).padStart(11)} ${String(n('gecit-bosa')).padStart(11)} ` + `${String(hacim).padStart(14)} ${String(UCRET(hacim)).padStart(13)}`); } ``` ``` genis kume (4 satir), akis akis kazanan satir: akis hedef adres eslesen kazanan satir yon sonuc ic olcum toplayici 10.42.3.14 3 10.42.0.0/20 yerel ulasir ic veri deposu 10.42.9.7 3 10.42.0.0/20 yerel ulasir merkez salon kaydi 10.0.4.7 2 10.0.0.0/8 esleme-merkez ulasir eski olcum arsivi 10.8.3.1 2 10.0.0.0/8 esleme-merkez kara delik ortak baglanti ucu 172.20.5.9 2 172.20.0.0/14 ozel-baglanti ulasir yedek toplama 10.44.2.3 2 10.0.0.0/8 esleme-merkez kara delik dis paket deposu 198.51.100.9 1 0.0.0.0/0 gecit gecit dis olcum hizmeti 203.0.113.4 1 0.0.0.0/0 gecit gecit kume satir ulasan kara delik gecit-bosa ucretli hacim cikis ucreti genis 4 4 2 0 1960 39.2 dar 4 4 0 2 2450 49 tam 6 6 0 0 1960 39.2 ``` İlk iki satır kuralın beklenen tarafıdır: blok içine giden trafik üç satıra birden uyuyor ve `/20` kazanıyor. `10.0.0.0/8` satırını yazan kişi bunu bozmayacağını biliyordu ve haklıydı. Dördüncü ve altıncı satır aynı kuralın öteki tarafı. `10.8.3.1` ile `10.44.2.3` de `/8` satırına uyuyor, o satır kazanıyor ve paket eşleme bağlantısına gidiyor — ama o bağlantı yalnız `10.0.0.0/16` aralığını taşıyor. Kazanan satır doğru yazılmış, gösterdiği hedef adresi taşımıyor. Paket gidiyor, dönmüyor, ücret üretmiyor ve faturada iz bırakmıyor. Eşleşen sütunu kuralın işleyişini görünür kılıyor: sekiz akışın altısı iki ya da üç satıra birden uyuyor, yalnız ikisi tek satıra. Tabloda hangi satırın kazandığı yazmıyor; kazanan, önek uzunlukları sıralandığında o an belirleniyor. Bunun sonucu şudur: yeni bir satır eklemek var olan hiçbir satırı değiştirmeden bir akışın yolunu değiştirebilir. Alttaki üç satır asıl karşılaştırmadır. Geniş kümede iki akış sessizce kayboluyor. Kuralı daraltmak, yani `/8` yerine `/16` yazmak, kara deliği sıfırlıyor — ama akışları düzeltmiyor, yalnız varsayılan yola düşürüyor. İkisi de çıkış geçidinden dışarı çıkıyor, özel bir adrese gitmeye çalışıyor, yine ulaşmıyor ve bu kez dönemde dokuz virgül sekiz birim fazladan ödetiyor: kırk dokuz birim, geniş kümenin otuz dokuz virgül ikisine karşı. Dar kümenin bu farkı bir kayıp gibi görünüyor ve değil. Sessiz arıza ücretli arızaya dönüştü; ücretli arızanın bir yerde satırı var. Doğru sonuç üçüncü satırda: iki satır eklemek altı satırlık bir küme yapıyor, sekiz akışın sekizi ulaşıyor ve çıkış ücreti geniş kümenin ücretine iniyor. Kuralı daraltmak düzeltmedi, eksik iki hedefi yazmak düzeltti. #### Eksik Satır ve Tekrar ```js // kosum2.mjs — bes tablonun tekrari, sonra alan-3 tablosundan tek satir dusurulur import { KUME, AKIS, UCRET, ALAN, sonuc } from './yol.mjs'; const GENEL = [['10.42.0.0/20', 'yerel'], ['0.0.0.0/0', 'gecit']]; const TABLO = [['genel', GENEL], ...Array.from({ length: ALAN }, (_, i) => [`ozel-alan-${i + 1}`, KUME.tam])]; const satir = TABLO.reduce((a, [, t]) => a + t.length, 0); const benzersiz = new Set(TABLO.flatMap(([, t]) => t.map((r) => r.join(' ')))); const kacTablo = (r) => TABLO.filter(([, t]) => t.some((x) => x.join(' ') === r.join(' '))).length; const ORNEK_ALAN = 141; // alan basina ozel ornek (onceki dersin dagilimindan) const taban = AKIS.map(([, ip, h]) => ({ ...sonuc(KUME.tam, ip), h })); const tabanUcret = taban.filter((x) => x.ucret).reduce((a, x) => a + x.h, 0); console.log(`${TABLO.length} tablo, ${satir} satir, ${benzersiz.size} benzersiz kural, ${satir - benzersiz.size} tekrar`); console.log(`\nalan-3 tablosundan tek satir dusurulurse (${ORNEK_ALAN} ornek etkilenir):`); console.log(`${'dusen satir'.padEnd(15)} ${'yon'.padEnd(14)} ${'tabloda'.padStart(8)} ${'bozulan'.padStart(8)} ` + `${'yeni sonuc'.padEnd(12)} ${'ucret farki'.padStart(12)}`); for (const r of KUME.tam) { const eksik = KUME.tam.filter((x) => x !== r); const yeni = AKIS.map(([, ip, h]) => ({ ...sonuc(eksik, ip), h })); const bozuk = yeni.filter((x, i) => x.son !== taban[i].son); const ucret = yeni.filter((x) => x.ucret).reduce((a, x) => a + x.h, 0); const fark = UCRET(ucret) - UCRET(tabanUcret); console.log(`${r[0].padEnd(15)} ${r[1].padEnd(14)} ${String(kacTablo(r)).padStart(8)} ` + `${String(bozuk.length).padStart(8)} ${[...new Set(bozuk.map((x) => x.son))].join(',').padEnd(12)} ` + `${String(fark > 0 ? `+${fark.toFixed(1)}` : fark.toFixed(1)).padStart(12)}`); } console.log(`\ndonemlik cikis ucreti (tam kume): ${UCRET(tabanUcret)} birim`); console.log(`yeni alt ag eklenince dokunulan tablo: 1 (iliskilendirme)`); console.log(`yeni hedef ag eklenince dokunulan tablo: ${ALAN} (${ALAN} satir, ayni satir ${ALAN} kez)`); console.log(`yeni alan eklenince: 1 yeni tablo, ${KUME.tam.length} satir, 1 gecit`); ``` ``` 5 tablo, 26 satir, 6 benzersiz kural, 20 tekrar alan-3 tablosundan tek satir dusurulurse (141 ornek etkilenir): dusen satir yon tabloda bozulan yeni sonuc ucret farki 10.42.0.0/20 yerel 5 2 gecit-bosa +266.0 172.20.0.0/14 ozel-baglanti 4 1 gecit-bosa +15.6 0.0.0.0/0 gecit 5 2 yol yok -39.2 10.0.0.0/16 esleme-merkez 4 1 gecit-bosa +52.0 10.44.0.0/14 esleme-yedek 4 1 gecit-bosa +3.0 10.8.0.0/14 esleme-eski 4 1 gecit-bosa +6.8 donemlik cikis ucreti (tam kume): 39.2 birim yeni alt ag eklenince dokunulan tablo: 1 (iliskilendirme) yeni hedef ag eklenince dokunulan tablo: 4 (4 satir, ayni satir 4 kez) yeni alan eklenince: 1 yeni tablo, 6 satir, 1 gecit ``` En sıradan görünen satır en pahalısı. Yerel yol düşerse blok içi trafik varsayılan yola kayıyor, geçitten dışarı çıkıyor ve dönemde iki yüz altmış altı birim ekliyor — tam kümenin bütün çıkış ücretinin yaklaşık yedi katı. Ölçüm toplayıcısı ile veri deposu arasındaki trafik hem duruyor hem ödeniyor. Varsayılan yolun düşmesi ise ters yönde çalışıyor: ücret otuz dokuz virgül iki birim azalıyor ve iki dış akış yolsuz kalıyor. Fatura düşerken erişim kesiliyor. Üçüncü sütun bunun neden fark edilmediğini söylüyor. Her satır dört ya da beş tabloda yazılı ve düşürme yalnız bir alanın tablosundan yapıldı: yüz kırk bir örnek etkileniyor, öteki üç alandaki dört yüz yetmiş beş örnek etkilenmiyor. Aynı isteğin dörtte üçü çalışıp dörtte biri çalışmıyor. Bu, tek bir bozuk satırın ürettiği en zor arıza biçimidir — kesintili, tekrar denenince geçen ve yönlendirme tablosuna değil ağın kendisine yorulan bir arıza. Tek satırın düşmesi kâğıt üstünde uzak bir olasılık gibi durur, oysa tarama gerçek bir işi modelliyor. Dört özdeş tablo tek elden yazılmaz; biri elle düzeltilir, biri bir şablondan yeniden üretilir, biri arıza sırasında geçici olarak değiştirilip eski hâline getirilmez. Satır eklemenin gerekçesi olur, satırın dört tablonun dördünde de bulunduğunu doğrulamanın gerekçesi olmaz — çünkü hiçbir şey bozulmuş görünmez. Son üç satır tekrarın faturasını veriyor. Yirmi altı satırın yalnız altısı benzersiz; yirmisi kopya. Yeni bir alt ağ eklemek tek dokunuş istiyor, çünkü alt ağ var olan bir tabloyla ilişkilendiriliyor. Yeni bir hedef ağ eklemek dört dokunuş ve dört özdeş satır istiyor. Dördünden üçünü yazıp birini atlamak yukarıdaki taramanın tam olarak ürettiği duruma çıkıyor. Geri alınamayan kalem burada satırın kendisi değil. Yönlendirme satırı yazılır, silinir, düzeltilir — bu kursun en kolay geri alınan kalemi budur. Geri alınamayan şey satırın yanlış olduğu dönemde olan şeydir: sessizce yutulan dört yüz doksan hacim birimlik ölçüm bir daha toplanamaz ve ödenmiş iki yüz altmış altı birim geri gelmez. Elde kalan karar üç kalemdir — kural genişliği, tablo sayısı ve hangi alt ağın hangi tabloyla ilişkilendirileceği. Devredilen kalem ikidir: en uzun önek eşleşmesinin kendisi ve yerel yolun her tabloya kendiliğinden yazılması. İkisi de tartışmaya kapalıdır ve yukarıdaki sayıların yarısını onlar üretiyor. #### Özet - En uzun önek eşleşmesi blok içi trafiği koruyor: `10.42.3.14` üç satıra uyuyor, `/20` kazanıyor. Aynı kural ters yönde de çalışıyor — `10.0.0.0/8` satırı `10.8.3.1` ve `10.44.2.3` akışlarını da kazanıyor ve eşleme bağlantısı yalnız `10.0.0.0/16` taşıdığı için ikisi kara deliğe düşüyor. - Kuralı `/8` yerine `/16` yazmak kara deliği 2'den 0'a indiriyor ama akışları düzeltmiyor: varsayılan yola düşen aynı iki akış dışarı çıkıp yine ulaşmıyor ve dönemlik ücret 39,2 birimden 49 birime çıkıyor. Düzelten şey daraltmak değil, eksik iki hedefi yazmak; 6 satırlık küme sekiz akışın sekizini ulaştırıyor ve ücreti 39,2 birime döndürüyor. - Tek satırın düşmesi eşit bedelde değil: yerel yol +266,0 birim, eşleme satırları +3,0 ile +52,0 arası, varsayılan yol −39,2 birim ve iki akış yolsuz. Ücreti düşüren değişiklik erişimi kesen değişiklikle aynı satırdır. - 5 tabloda 26 satır var, yalnız 6'sı benzersiz, 20'si kopya. Her kural 4 ya da 5 tabloda yazılı; bir alanın tablosundan düşen satır 141 örneği etkileyip 475 örneği etkilemiyor ve arıza kesintili görünüyor. - Yeni alt ağ 1 dokunuş, yeni hedef ağ 4 dokunuş ve 4 özdeş satır, yeni alan 1 tablo artı 6 satır artı 1 geçit istiyor. Geri alınamayan kalem satır değil, satırın yanlış olduğu dönemde yutulan 490 hacim birimlik ölçüm ile ödenmiş 266 birimdir. #### Sonraki Adım Son iki koşumda geçit hem çözüm hem fatura olarak geçti: dışarıya çıkan her akış oradan çıktı, yanlış yola düşen her akış oraya düştü ve her yeni alan bir tane daha istedi. Geçidin kendisi hiç ölçülmedi. Sonraki dersin sorusu özel alt ağdaki örneklerin dışarıyla ilişkisini üç düzende sayar: hiç geçit koymamak neyi adıyla engelliyor, tek bir dönüştürme geçidi kaç örneğin trafiğini tek bir noktadan geçirip hangi darboğazı ve hangi arıza noktasını doğuruyor, alan başına geçit koymak bunu kaça bölüp bedeli kaç birime çıkarıyor — ve her örneğe genel adres vermek dışarıdan erişilebilir yüzeyi kaç kaleme çıkarıyor. ### İnternet ve Adres Dönüştürme Geçitleri Source: https://academia.sh/tr/kurslar/bulut-hesaplama-ve-ag/internet-ve-adres-donusturme-gecitleri Özel alt ağdaki örneklerin dışarıyla ilişkisi dört düzende sayılır: geçitsiz düzende hangi beş iş adıyla duruyor, tek geçit kaç örneğin trafiğini tek noktadan geçirip hangi dönemde bağlantı sınırını aşıyor, alan başına geçit arıza yarıçapını kaça bölüp bedeli kaç birime çıkarıyor ve örnek başına genel adres kaç kalem ile kaç dış kayıt açıyor. Önceki iki derste geçit hem çözüm hem fatura olarak geçti: dışarı çıkan her akış oradan çıktı, yanlış yola düşen her akış oraya düştü ve her yeni alan bir tane daha istedi. Geçidin kendisi hiç sayılmadı. Alt ağların hepsi özel yapıldığında dışarıdan erişilebilir kalem bire indi — geriye ters yöndeki soru kaldı: içeriden dışarıya çıkmak. Bu soru bir güvenlik sorusu gibi durmuyor ve öyle. Dışarıya çıkan yol, dışarıdan gelen yolu açmadan da bir bağımlılık yaratır: geçidin dışa görünen adresi karşı taraflarca kaydedilir ve o kayıtlar geri alınması en zor kalemi oluşturur. Dört düzen aynı iş yükünde karşılaştırılıyor. - **BA19.** Dört düzen, iş listesi ve bedeller kurgusal bölgesel ölçüm ağına aittir. Gerçek bir geçit kurulmuyor; ölçülen şey `node` ile kurulan modeldir. - **BA20.** Geçidin eşanlı bağlantı sınırı 55.000, tepe anda örnek başına giden bağlantı 90 olarak elle yazıldı. Gerçekte ikisi de sağlayıcıya ve iş yüküne göre değişir; doyma dönemini kaydırır, darboğazın varlığını değiştirmez. - **BA21.** Bedeller kurgu **birim** cinsindendir, para birimi değildir. Sabit bileşen geçit ve adres başına, akış bileşeni yüz hacim birimi başına yazıldı. - **BA22.** Üç dış hizmetin çıkış adresini kendi kayıtlarına yazdığı varsayıldı. Gerçekte bu sayı bağımlılık sayısıyla büyür; geri dönüş bedelini büyütür, yönünü değiştirmez. - **BA23.** Tek geçit düzeninde üç alanın trafiği alan sınırını geçtiği için ayrıca ücretlendirildi. - **BA24.** Geçidin kendi yedekliliği sağlayıcıda sayıldı. "Geçit düşerse" ile kastedilen alan düzeyindeki kayıptır; arıza yarıçapının nasıl hesaplandığını değiştirmez. #### Dört Düzenin Modeli Model bir düzeni üç sayıyla tanımlıyor: kaç geçit var, her örneğe genel adres verilmiş mi ve bunlardan hangi sonuçlar doğuyor. `olc` işlevi altı ayrı kalemi birden döndürüyor — dışarı çıkabilen örnek, dışarıdan erişilebilir kalem, duran iş, tepe bağlantı, arıza yarıçapı ve dış kayıt. Bedel sabit ve akış olarak ikiye ayrılıyor, çünkü ikisi dönemle farklı hızda büyüyor. ```js // gecit.mjs — ozel alt agin disariyla iliskisi; gercek gecit kurulmuyor, model sayilir export const ORNEK = 616, ALAN = 4, KAPI = 4; // onceki dersin ucuncu duzeni: hepsi ozel alt agda export const SINIR = 55000; // gecidin esanli baglanti siniri (kurgu, BA20) export const BAGLANTI = 90; // tepe anda ornek basina giden baglanti (BA20) export const HACIM = 1960; // donemlik dis cikis hacmi (onceki dersten) export const DIS_TARAF = 3; // gecidin adresini kaydeden dis hizmet sayisi (BA22) // Bedeller kurgu birim (BA21); 100 hacim birimi basina yazilanlar oran tasir, para birimi degil. export const GECIT_SABIT = 40, ADRES_KIRA = 0.5, CIKIS = 2, ISLEME = 1, ALAN_DISI = 1; export const IS = ['yama ve paket alma', 'dis olcum hizmetine cagri', 'zaman kaynagi', 'sertifika yenileme', 'gunluk aktarimi']; // [ad, gecit sayisi, her ornege genel adres mi] export const DUZEN = [['gecit yok', 0, false], ['tek donusturme gecidi', 1, false], ['alan basina gecit', ALAN, false], ['ornek basina genel adres', 0, true]]; export const olc = ([ad, gecit, adresli], ornek = ORNEK, hacim = HACIM) => { const adres = adresli ? ornek : 0; // ornek basina bir genel adres const cikabilir = gecit > 0 || adres > 0; const alanDisi = gecit === 1 ? hacim * (ALAN - 1) / ALAN : 0; // tek gecit uc alanin trafigini cekiyor const akis = cikabilir ? (hacim * CIKIS + (gecit ? hacim * ISLEME + alanDisi * ALAN_DISI : 0)) / 100 : 0; const sabit = gecit * GECIT_SABIT + adres * ADRES_KIRA; return { ad, gecit, adres, cikabilir: cikabilir ? ornek : 0, kalem: adres * KAPI, duran: cikabilir ? 0 : IS.length, tepe: gecit ? Math.round(ornek * BAGLANTI / gecit) : 0, yaricap: gecit ? Math.round(ornek / gecit) : 0, kayit: (gecit || adres) * DIS_TARAF, akis: Math.round(akis * 10) / 10, sabit, toplam: Math.round((akis + sabit) * 10) / 10 }; }; ``` #### Aynı İş Yükünde Dört Düzen ```js // kosum1.mjs — dort duzen ayni is yukunde: yuzey, darbogaz, ariza yaricapi ve bedel import { DUZEN, IS, SINIR, ORNEK, HACIM, olc } from './gecit.mjs'; console.log(`${ORNEK} ozel ornek, donemlik dis hacim ${HACIM}, gecit esanli baglanti siniri ${SINIR}`); console.log(`${'duzen'.padEnd(25)} ${'cikan'.padStart(6)} ${'acik kalem'.padStart(11)} ${'duran is'.padStart(9)} ` + `${'tepe baglanti'.padStart(14)} ${'ariza yaricapi'.padStart(15)} ${'dis kayit'.padStart(10)} ${'toplam bedel'.padStart(13)}`); for (const d of DUZEN) { const m = olc(d); const tepe = m.gecit ? `${m.tepe} (%${Math.round(m.tepe * 100 / SINIR)})` : '-'; console.log(`${m.ad.padEnd(25)} ${String(m.cikabilir).padStart(6)} ${String(m.kalem).padStart(11)} ` + `${String(m.duran).padStart(9)} ${tepe.padStart(14)} ${String(m.yaricap ? `${m.yaricap} ornek` : '-').padStart(15)} ` + `${String(m.kayit).padStart(10)} ${String(m.toplam).padStart(13)}`); } console.log(`\ngecit yok duzeninde duran is (${IS.length} kalem): ${IS.join(', ')}`); const [tek, alanBasi] = [olc(DUZEN[1]), olc(DUZEN[2])]; console.log(`bedelin dagilimi tek gecit: sabit ${tek.sabit} + akis ${tek.akis} ` + `alan basina: sabit ${alanBasi.sabit} + akis ${alanBasi.akis}`); console.log(`tek gecitten alan basina gecmek: ${alanBasi.kayit - tek.kayit} yeni dis kayit, geri donus ayni sayida`); ``` ``` 616 ozel ornek, donemlik dis hacim 1960, gecit esanli baglanti siniri 55000 duzen cikan acik kalem duran is tepe baglanti ariza yaricapi dis kayit toplam bedel gecit yok 0 0 5 - - 0 0 tek donusturme gecidi 616 0 0 55440 (%101) 616 ornek 3 113.5 alan basina gecit 616 0 0 13860 (%25) 154 ornek 12 218.8 ornek basina genel adres 616 2464 0 - - 1848 347.2 gecit yok duzeninde duran is (5 kalem): yama ve paket alma, dis olcum hizmetine cagri, zaman kaynagi, sertifika yenileme, gunluk aktarimi bedelin dagilimi tek gecit: sabit 40 + akis 73.5 alan basina: sabit 160 + akis 58.8 tek gecitten alan basina gecmek: 9 yeni dis kayit, geri donus ayni sayida ``` İlk satır sıfırlarla dolu ve bu onu iyi göstermiyor. Geçitsiz düzende açık kalem yok, dış kayıt yok, bedel yok — ve dışarı çıkabilen örnek de yok. Duran iş sütunundaki beş kalem adıyla yazılı: yama ve paket alma, dış ölçüm hizmetine çağrı, zaman kaynağı, sertifika yenileme, günlük aktarımı. İlki makinelerin yamasız kalması demektir, üçüncüsü saatin kayması, dördüncüsü sertifikaların süresinin dolması. Sıfır bedelli düzen, birkaç dönem sonra makine düzeyindeki bütün kazanımları geri veren düzendir. Tek geçit satırı üç sayıyı birden taşıyor. Bedel en düşük olan odur: yüz on üç virgül beş birim, alan başına geçidin yarısından az. Tepe bağlantı sütunu birinci sınırı gösteriyor — elli beş bin dört yüz kırk, sınırın yüzde yüz biri. Bu dönemde geçit doldu ve dolduğunda ne olacağı bir arıza değil, yavaşlama olarak görünür: yeni bağlantılar sıraya girer. Arıza yarıçapı ikinci sınırdır: geçidin bulunduğu alan kaybedilirse altı yüz on altı örneğin tamamı dışarı çıkamaz hâle gelir, çünkü üç alandaki dört yüz altmış iki örnek de trafiğini oradan geçiriyordu. Alan başına geçit ikisini birden çözüyor ve faturayı ters çeviriyor. Sabit bedel kırktan yüz altmışa çıkıyor, akış bedeli yetmiş üç virgül beşten elli sekiz virgül sekize iniyor — çünkü alan sınırını geçen trafik kalmıyor. Toplam yüz on üç virgül beşten iki yüz on sekiz virgül sekize, yaklaşık iki katına çıkıyor. Karşılığında tepe doluluk yüzde yüz birden yüzde yirmi beşe, arıza yarıçapı altı yüz on altı örnekten yüz elli dörde iniyor. Akış bedelindeki on dört virgül yedi birimlik fark tek başına küçük ve nereden geldiği önemli. Tek geçit dört alandan üçünün trafiğini kendi alanına çekiyor; o trafik alan sınırını iki kez geçiyor ve her geçiş ayrıca ücretleniyor. Bu kalem yönlendirme tablosunda görünmüyor, geçit sayısında görünmüyor, yalnız faturada görünüyor — ve geçidi hangi alana koyduğuna bağlı olduğu için tek satırlık bir kararın sonucudur. Son satır dördüncü düzendir ve tek başına bir uyarıdır. Örnek başına genel adres vermek geçit sorununu ortadan kaldırıyor: darboğaz yok, arıza yarıçapı yok, akış bedeli en düşük. Karşılığında iki yüzey açılıyor. Birincisi iki bin dört yüz altmış dört açık kalem — önceki dersin bire indirdiği sayı geri geliyor ve fazlasıyla. İkincisi bin sekiz yüz kırk sekiz dış kayıt: her örneğin adresi üç dış hizmetin kayıtlarında duruyor. #### Sekiz Dönem Boyunca ```js // kosum2.mjs — sekiz donem boyunca: tek gecit ne zaman doluyor, hangi duzen ne zaman pahalilasiyor import { DUZEN, SINIR, HACIM, ORNEK, olc } from './gecit.mjs'; // Onceki derslerin buyume dizisi; donem-8 alan basina yuvarlanmis sayidir const SERI = [[1, 18], [2, 26], [3, 44], [4, 71], [5, 118], [6, 196], [7, 340], [8, 616]]; console.log(`${'donem'.padEnd(6)} ${'ornek'.padStart(6)} ${'tek gecit doluluk'.padStart(18)} ${'alan basina'.padStart(12)} ` + `${'tek gecit'.padStart(10)} ${'alan basina'.padStart(12)} ${'ornek basina'.padStart(13)} ${'acik kalem'.padStart(11)}`); for (const [d, n] of SERI) { const h = Math.round(HACIM * n / ORNEK); const [tek, dort, adres] = [1, 2, 3].map((i) => olc(DUZEN[i], n, h)); const yuzde = (m) => `%${Math.round(m.tepe * 100 / SINIR)}`; console.log(`${String(d).padEnd(6)} ${String(n).padStart(6)} ` + `${`${tek.tepe} ${yuzde(tek)}${tek.tepe > SINIR ? ' asti' : ''}`.padStart(18)} ${yuzde(dort).padStart(12)} ` + `${String(tek.toplam).padStart(10)} ${String(dort.toplam).padStart(12)} ${String(adres.toplam).padStart(13)} ` + `${String(adres.kalem).padStart(11)}`); } const ucuz = SERI.map(([d, n]) => { const h = Math.round(HACIM * n / ORNEK); const m = [1, 2, 3].map((i) => olc(DUZEN[i], n, h)); return [d, m.reduce((a, b) => (b.toplam < a.toplam ? b : a)).ad]; }); const kayit = (n) => olc(DUZEN[3], n).kayit; console.log(`\nornek basina adres duzeninden geri donus: donem 4'te ${kayit(71)} dis kayit, donem 8'de ${kayit(616)}`); console.log('donem donem en ucuz duzen:'); for (const [ad, gecen] of Object.entries(ucuz.reduce((a, [d, ad]) => ({ ...a, [ad]: [...(a[ad] || []), d] }), {}))) console.log(` ${ad.padEnd(25)} donem ${gecen.join(', ')}`); ``` ``` donem ornek tek gecit doluluk alan basina tek gecit alan basina ornek basina acik kalem 1 18 1620 %3 %1 42.1 161.7 10.1 72 2 26 2340 %4 %1 43.1 162.5 14.7 104 3 44 3960 %7 %2 45.3 164.2 24.8 176 4 71 6390 %12 %3 48.5 166.8 40 284 5 118 10620 %19 %5 54.1 171.3 66.5 472 6 196 17640 %32 %8 63.4 178.7 110.5 784 7 340 30600 %56 %14 80.6 192.5 191.6 1360 8 616 55440 %101 asti %25 113.5 218.8 347.2 2464 ornek basina adres duzeninden geri donus: donem 4'te 213 dis kayit, donem 8'de 1848 donem donem en ucuz duzen: ornek basina genel adres donem 1, 2, 3, 4 tek donusturme gecidi donem 5, 6, 7, 8 ``` Tarama iki eğri gösteriyor. Geçitli düzenlerin bedeli sabit bir tabanla başlıyor ve yavaş büyüyor; örnek başına adres düzeninin bedeli sıfırdan başlayıp örnek sayısıyla doğrusal artıyor. Kesişme beşinci dönemde. İlk dört dönem boyunca en ucuz düzen, açık kalemi en yüksek olan düzendir ve o dönemlerde açık kalem yetmiş iki ile iki yüz seksen dört arasında — geçitli düzenlerin sıfırına karşı büyük, ama bir alarm üretecek kadar değil. Tek geçit sütununun doluluk değeri asıl uyarıdır. Yedinci dönemde yüzde elli altı, sekizinci dönemde yüzde yüz bir. İki dönem arasında örnek sayısı seksen bir yüzde arttı ve doluluk yüzde kırk beş puan sıçradı; doğrusal bir eğride sürprizin yeri, eğrinin kendisi değil sınırın nerede durduğudur. Alan başına geçit aynı dönemde yüzde yirmi beşte kalıyor, yani üç dönem daha payı var. Tek geçitten alan başına geçmek dokuz yeni dış kayıt istiyor ve bu, yapılması gereken anda yapılamayacak bir iştir: dış tarafların takvimine bağlıdır. Doluluğun yüzde yüzü aşması ayrıca bir arıza kaydı üretmiyor ve aranan yerde de görünmüyor. Sınıra dayanan geçit bağlantıyı reddetmiyor, bekletiyor; içeriden bakan taraf bunu yavaşlayan bir dış çağrı olarak görüyor. Beş işten üçü — dış ölçüm hizmetine çağrı, sertifika yenileme ve günlük aktarımı — zaman aşımına düşmeye başlıyor ve üçü de kendi bileşenlerinin arızası gibi okunuyor. Ölçülen sayı geçitte, belirti başka beş yerde. Geri alınamayan kalem bu derste geçidin kendisi değil, çıkış adresinin dışarıda bıraktığı izdir. Geçit silinir, yeniden kurulur, sayısı artırılır — ama adres bir kez üç dış hizmetin kayıtlarına yazıldıktan sonra o kayıtlar elde değildir. Örnek başına adres düzeninin geri dönüş bedeli tam olarak budur ve dönemle büyüyor: dördüncü dönemde iki yüz on üç kayıt, sekizinci dönemde bin sekiz yüz kırk sekiz. İlk dört dönem en ucuz olan düzen, beşinci dönemde terk edilmesi en pahalı olan düzendir. Elde kalan karar dört kalemdir: geçit sayısı, geçidin hangi alanda duracağı, hangi örneklerin genel adres alacağı ve çıkışın hangi adresten görüneceği. Devredilen kalem üçtür — geçidin eşanlı bağlantı sınırı, kendi yedekliliği ve dönüştürme işleminin gecikmesi. Devredilen üçünden birincisi sekizinci dönemin bütün tablosunu belirliyor ve hiçbir yerde sorulmuyor. #### Özet - Geçitsiz düzen 0 açık kalem, 0 dış kayıt ve 0 bedel üretiyor; karşılığında 616 örneğin hiçbiri dışarı çıkamıyor ve 5 iş adıyla duruyor: yama ve paket alma, dış ölçüm hizmetine çağrı, zaman kaynağı, sertifika yenileme, günlük aktarımı. - Tek dönüştürme geçidi en ucuz geçitli düzen — 113,5 birim — ve iki sınırı birden taşıyor: tepe bağlantı 55.440 ile sınırın yüzde 101'i, arıza yarıçapı 616 örnek. Üç alandaki 462 örnek trafiğini başka bir alandan geçiriyor. - Alan başına geçit doluluğu yüzde 25'e, arıza yarıçapını 154 örneğe indiriyor. Sabit bedel 40'tan 160'a çıkıyor, akış bedeli alan sınırı aşılmadığı için 73,5'ten 58,8'e iniyor; toplam 113,5'ten 218,8'e, yaklaşık iki katına. - Örnek başına genel adres darboğazı ve arıza yarıçapını sıfırlıyor, karşılığında 2.464 açık kalem ve 1.848 dış kayıt açıyor. İlk 4 dönem en ucuz düzen budur; 5. dönemde tek geçide geçiyor. - Geri alınamayan kalem çıkış adresinin dışarıda bıraktığı izdir. Tek geçitten alan başına geçmek 9 yeni dış kayıt, örnek başına adres düzeninden çıkmak 4. dönemde 213, 8. dönemde 1.848 kayıt istiyor ve bunların hiçbiri kendi takvimimize bağlı değil. #### Sonraki Adım Dört düzenin dördünde de dışarı çıkan trafik sayıldı, dışarıdan gelen bağlantı sayıldı — ama hiçbir yerde hangi bağlantıya izin verildiği yazılmadı. Açık kalem sütunu bir örneğin dört kapı dinlediğini varsayıyordu ve o kapıların kaçının gerçekten açık olması gerektiği sorulmadı. Sonraki dersin sorusu aynı politikayı iki ayrı mekanizmada yazar ve bilinen bir akış kümesinde koşturur: dönüş trafiğini kendiliğinden tanıyan bir filtre kaç kural istiyor, tanımayan bir filtre aynı politika için kaç kural istiyor, hangi akışlar yakalanıyor, hangileri kaçıyor ve hangileri yanlışlıkla kapanıyor — ve iki mekanizma birlikte kullanıldığında hangisi önce değerlendiriliyor, bu sıra hangi durumda yazılana bakıp da anlaşılamayan bir sonuç üretiyor. ### Güvenlik Grupları ve Ağ Erişim Listeleri Source: https://academia.sh/tr/kurslar/bulut-hesaplama-ve-ag/guvenlik-gruplari-ve-ag-erisim-listeleri Aynı politika durum bilgili ve durum bilgisiz iki mekanizmada yazılıp on iki bilinen akışta koşturulur: her biri kaç kural istiyor, dönüş trafiği için kaç satır ekleniyor, kaç akış kaçıyor ve kaç meşru akış yanlışlıkla kapanıyor, kural numarasını değiştirmek neyi çözüyor ve ikisi birlikte kullanıldığında hangisi belirleyici oluyor. Önceki derste açık kalem sütunu bir örneğin dört kapı dinlediğini varsayıyordu ve o kapıların kaçının gerçekten açık kalması gerektiği hiç sorulmadı. Alt ağ ayrımı bir örneğin dışarıdan çağrılmasını engelliyor; hangi çağrının kabul edileceğini söylemiyor. Bunu söyleyen iki ayrı mekanizma var ve bu modelde ikisi aynı ağda birlikte bulunuyor. Her sağlayıcı iki mekanizmayı birden sunmaz; kimi ağda yalnız durum bilgili olanı vardır ve aşağıdaki karşılaştırma o zaman tek sütuna iner. Aralarındaki tek fark durum tutup tutmamalarıdır. Biri giden isteği hatırlıyor ve dönüşünü kendiliğinden kabul ediyor; öteki her paketi tek başına, hiçbir şey hatırlamadan değerlendiriyor. Makine düzeyinde açık kapı ve varsayılan reddet ayrı bir derste ölçüldü; buradaki soru kapının açık olup olmadığı değil, aynı politikanın iki mekanizmada kaç kural ettiği ve farkın nerede patladığıdır. - **BA25.** On iki akış, dört blok ve kural kümeleri kurgusal bölgesel ölçüm ağına aittir. Gerçek paket akmıyor; ölçülen şey `node` ile kurulan modeldir. - **BA26.** Bütün akışlar uygulama alt ağına göre yazıldı ve tek alan modellendi. Gerçekte her alanın kendi listesi olur; kural sayısını alan sayısıyla çarpar, sonucun yönünü değiştirmez. - **BA27.** Geçici kapı aralığı 32768–60999 varsayıldı. Gerçekte aralık işletim sistemine göre değişir; kaçan akışların kapı numaralarını kaydırır, kaçışın mekanizmasını değiştirmez. - **BA28.** Durum tablosunun kapasitesi ve zaman aşımı modellenmedi; grup, giden her isteğin dönüşünü tanıyor sayıldı. - **BA29.** Akışların meşru olup olmadığı elle işaretlendi; rastgelelik yok, her koşum aynı sınıflandırmayı üretir. - **BA30.** Dış taraf adresleri belgeleme için ayrılmış bloklardan seçildi. #### İki Mekanizmanın Modeli Model iki mekanizmayı da aynı politikadan türetiyor. Grup yalnız istek yönünü yazıyor ve dönüşü `kosu` işlevi kendiliğinden geçiriyor. Liste numaralı satırlardan oluşuyor, ilk eşleşen kazanıyor ve her akışın iki yönü ayrı ayrı değerlendiriliyor — bu ayrı değerlendirme modelin bütün iddiasıdır. ```js // filtre.mjs — ayni politika iki mekanizmada; gercek paket akmiyor, model kosuyor export const toInt = (ip) => ip.split('.').reduce((a, o) => a * 256 + Number(o), 0); export const icinde = (c, ip) => { const [a, e] = c.split('/'); const b = 2 ** (32 - Number(e)); const bas = Math.floor(toInt(a) / b) * b, n = toInt(ip); return n >= bas && n <= bas + b - 1; }; export const B = { genel: '10.42.0.0/24', uygulama: '10.42.1.0/24', veri: '10.42.2.0/24', yonetim: '10.42.3.0/24', her: '0.0.0.0/0' }; const G = [32768, 60999]; // gecici kapi araligi (BA27) // Durum bilgili grup: yalniz istek yonu yazilir, donus kendiliginden acilir export const GRUP = { dar: { gelen: [[B.genel, 8080], [B.yonetim, 22], [B.yonetim, 9100]], giden: [[B.veri, 5432], [B.her, 443]] }, gevsek: { gelen: [[B.her, 8080], [B.yonetim, 22], [B.yonetim, 9100]], giden: [[B.veri, 5432], [B.her, 443]] }, }; // Durum bilgisiz liste: numarali, ilk eslesen kazanir; donus icin ayri satir gerekir const L_GELEN = [[100, B.genel, 8080, 8080, 'izin'], [110, B.yonetim, 22, 22, 'izin'], [120, B.yonetim, 9100, 9100, 'izin'], [130, B.veri, ...G, 'izin'], [140, B.her, ...G, 'izin']]; const L_GIDEN = [[100, B.veri, 5432, 5432, 'izin'], [110, B.her, 443, 443, 'izin'], [120, B.genel, ...G, 'izin'], [130, B.yonetim, ...G, 'izin']]; export const LISTE = { taban: { gelen: L_GELEN, giden: L_GIDEN }, 'reddet-145': { gelen: [...L_GELEN, [145, B.her, ...G, 'reddet']], giden: L_GIDEN }, 'reddet-135': { gelen: [...L_GELEN, [135, B.her, ...G, 'reddet']], giden: L_GIDEN }, }; // [ad, yon, karsi taraf, hedef kapi, karsi kapi, mesru mu] — uygulama alt agina gore (BA26) export const AKIS = [ ['genel -> uygulama', 'gelen', '10.42.0.5', 8080, 41200, true], ['eski istemci', 'gelen', '10.42.0.9', 8080, 5000, true], ['yonetim kabugu', 'gelen', '10.42.3.4', 22, 52100, true], ['olcut cekme', 'gelen', '10.42.3.7', 9100, 44300, true], ['veri sorgusu', 'giden', '10.42.2.6', 5432, 39800, true], ['dis hizmete cagri', 'giden', '198.51.100.9', 443, 47700, true], ['dis -> uygulama:8080', 'gelen', '203.0.113.4', 8080, 51000, false], ['dis -> uygulama:22', 'gelen', '203.0.113.4', 22, 51100, false], ['dis -> olcut ucu', 'gelen', '203.0.113.4', 9100, 51200, false], ['dis -> gecici aralik', 'gelen', '203.0.113.4', 45000, 8443, false], ['sahte donus (kaynak 443)', 'gelen', '203.0.113.4', 46000, 443, false], ['veri -> uygulama:22', 'gelen', '10.42.2.6', 22, 53000, false], ]; export const cevir = ([, yon, ip, hk, kk]) => yon === 'gelen' ? { istek: ['gelen', ip, hk], donus: ['giden', ip, kk] } : { istek: ['giden', ip, hk], donus: ['gelen', ip, kk] }; export const grupIzin = (g, [y, ip, k]) => g[y].some(([c, kapi]) => icinde(c, ip) && kapi === k); export const listeIzin = (l, [y, ip, k]) => { const s = [...l[y]].sort((a, b) => a[0] - b[0]).find(([, c, alt, ust]) => icinde(c, ip) && k >= alt && k <= ust); return { izin: !!s && s[4] === 'izin', no: s ? s[0] : '-' }; }; export const kosu = (a, { g, l } = {}) => { const { istek, donus } = cevir(a); const ok = (d) => (g ? grupIzin(g, d) : true) && (l ? listeIzin(l, d).izin : true); if (!ok(istek)) return 'istek durdu'; if (l && !listeIzin(l, donus).izin) return 'donus durdu'; // liste durumu bilmiyor, donusu ayri bakar return 'gecti'; }; export const sinif = (a, son) => a[5] ? (son === 'gecti' ? 'dogru' : 'yanlis kapali') : (son === 'istek durdu' ? 'yakalandi' : 'kacan'); export const say = (secim) => { const r = AKIS.map((a) => sinif(a, kosu(a, secim))); const n = (s) => r.filter((x) => x === s).length; return { dogru: n('dogru'), yanlis: n('yanlis kapali'), yakalandi: n('yakalandi'), kacan: n('kacan') }; }; export const kural = ({ g, l } = {}) => (g ? g.gelen.length + g.giden.length : 0) + (l ? l.gelen.length + l.giden.length : 0); ``` #### Aynı Politika, İki Mekanizma ```js // kosum1.mjs — ayni politika iki mekanizmada, on iki bilinen akista akis akis import { AKIS, GRUP, LISTE, kosu, sinif, say, kural } from './filtre.mjs'; const g = GRUP.dar, l = LISTE.taban; console.log(`ayni politika: durum bilgili grup ${kural({ g })} kural, durum bilgisiz liste ${kural({ l })} kural`); console.log(`${'akis'.padEnd(26)} ${'hedef kapi'.padStart(11)} ${'karsi kapi'.padStart(11)} ${'mesru'.padStart(6)} ` + `${'grup'.padEnd(24)} liste`); for (const a of AKIS) { const [sg, sl] = [kosu(a, { g }), kosu(a, { l })]; console.log(`${a[0].padEnd(26)} ${String(a[3]).padStart(11)} ${String(a[4]).padStart(11)} ` + `${String(a[5] ? 'evet' : 'hayir').padStart(6)} ${`${sg} (${sinif(a, sg)})`.padEnd(24)} ${sl} (${sinif(a, sl)})`); } console.log(`\n${'mekanizma'.padEnd(22)} ${'kural'.padStart(6)} ${'dogru'.padStart(6)} ${'yanlis kapali'.padStart(14)} ` + `${'yakalandi'.padStart(10)} ${'kacan'.padStart(6)}`); for (const [ad, s] of [['durum bilgili grup', { g }], ['durum bilgisiz liste', { l }]]) { const r = say(s); console.log(`${ad.padEnd(22)} ${String(kural(s)).padStart(6)} ${String(r.dogru).padStart(6)} ` + `${String(r.yanlis).padStart(14)} ${String(r.yakalandi).padStart(10)} ${String(r.kacan).padStart(6)}`); } ``` ``` ayni politika: durum bilgili grup 5 kural, durum bilgisiz liste 9 kural akis hedef kapi karsi kapi mesru grup liste genel -> uygulama 8080 41200 evet gecti (dogru) gecti (dogru) eski istemci 8080 5000 evet gecti (dogru) donus durdu (yanlis kapali) yonetim kabugu 22 52100 evet gecti (dogru) gecti (dogru) olcut cekme 9100 44300 evet gecti (dogru) gecti (dogru) veri sorgusu 5432 39800 evet gecti (dogru) gecti (dogru) dis hizmete cagri 443 47700 evet gecti (dogru) gecti (dogru) dis -> uygulama:8080 8080 51000 hayir istek durdu (yakalandi) istek durdu (yakalandi) dis -> uygulama:22 22 51100 hayir istek durdu (yakalandi) istek durdu (yakalandi) dis -> olcut ucu 9100 51200 hayir istek durdu (yakalandi) istek durdu (yakalandi) dis -> gecici aralik 45000 8443 hayir istek durdu (yakalandi) donus durdu (kacan) sahte donus (kaynak 443) 46000 443 hayir istek durdu (yakalandi) gecti (kacan) veri -> uygulama:22 22 53000 hayir istek durdu (yakalandi) istek durdu (yakalandi) mekanizma kural dogru yanlis kapali yakalandi kacan durum bilgili grup 5 6 0 6 0 durum bilgisiz liste 9 5 1 4 2 ``` Aynı politika beş satır ve dokuz satır ediyor. Fark dört satırdır ve dördü de hiçbir politika yazmıyor: yalnız dönüş trafiği için varlar. Gelen yöndeki iki tanesi veri katmanından ve herhangi bir yerden geçici kapı aralığına izin veriyor, giden yöndeki ikisi genel ve yönetim bloklarına aynı aralıkta izin veriyor. Politika üç izinli çağrıdan ibaretti; satırların yarısına yakını politikanın kendisiyle ilgili değil. Kaçan iki akış aynı satırdan geçiyor: herhangi bir kaynaktan geçici kapı aralığına izin veren gelen satırı. O satır yazılmak zorundaydı, çünkü dış hizmete yapılan çağrının dönüşü tanımı gereği dışarıdan gelir ve kaynağı önceden bilinmez. Sahte dönüş akışı bunun tam sınırındadır: kaynak kapısı dört yüz kırk üç, hedef kapısı geçici aralıkta — meşru bir dönüşten paket düzeyinde ayırt edilemiyor ve iki yönde birden geçiyor. Ayrımı yapacak tek bilgi, daha önce o tarafa giden bir istek olup olmadığıdır ve durum bilgisiz mekanizma o bilgiyi tutmuyor. Yanlış kapatılan tek akış öteki yönde aynı kusuru gösteriyor. Eski istemci sekiz binin üzerindeki bir kapıdan değil, beş binden bağlanıyor. İstek geçiyor, uygulama isteği alıyor ve işliyor; dönüş beş bin kapısına çıkamıyor çünkü giden satırlar yalnız geçici aralığı kapsıyor. Sunucu günlüğünde başarılı bir istek var, istemcide zaman aşımı var ve ikisi aynı olayın iki ucu. #### Sıra ve Birlikte Kullanım ```js // kosum2.mjs — reddet satirinin numarasi ve iki mekanizmanin birlikte degerlendirilmesi import { AKIS, GRUP, LISTE, kosu, sinif, say, kural, listeIzin, cevir } from './filtre.mjs'; console.log(`${'liste bicimi'.padEnd(14)} ${'kural'.padStart(6)} ${'dogru'.padStart(6)} ${'yanlis kapali'.padStart(14)} ` + `${'yakalandi'.padStart(10)} ${'kacan'.padStart(6)} gecici araliga bakan satir`); for (const [ad, l] of Object.entries(LISTE)) { const r = say({ l }), s = listeIzin(l, ['gelen', '203.0.113.4', 45000]); console.log(`${ad.padEnd(14)} ${String(kural({ l })).padStart(6)} ${String(r.dogru).padStart(6)} ` + `${String(r.yanlis).padStart(14)} ${String(r.yakalandi).padStart(10)} ${String(r.kacan).padStart(6)} ` + `${s.no} numarali satir kazaniyor`); } const K = [['grup (dar)', { g: GRUP.dar }], ['grup (gevsek)', { g: GRUP.gevsek }], ['liste (taban)', { l: LISTE.taban }], ['dar + liste', { g: GRUP.dar, l: LISTE.taban }], ['gevsek + liste', { g: GRUP.gevsek, l: LISTE.taban }]]; console.log(`\n${'mekanizma'.padEnd(16)} ${'kural'.padStart(6)} ${'dogru'.padStart(6)} ${'yanlis kapali'.padStart(14)} ` + `${'yakalandi'.padStart(10)} ${'kacan'.padStart(6)}`); for (const [ad, s] of K) { const r = say(s); console.log(`${ad.padEnd(16)} ${String(kural(s)).padStart(6)} ${String(r.dogru).padStart(6)} ` + `${String(r.yanlis).padStart(14)} ${String(r.yakalandi).padStart(10)} ${String(r.kacan).padStart(6)}`); } console.log('\nikisi ayni akista ayri sey soyluyorsa belirleyen hangisi:'); console.log(`${'akis'.padEnd(31)} ${'yalniz grup'.padEnd(14)} ${'yalniz liste'.padEnd(14)} birlikte`); for (const g of [GRUP.dar, GRUP.gevsek]) for (const a of AKIS) { const [sg, sl, sb] = [kosu(a, { g }), kosu(a, { l: LISTE.taban }), kosu(a, { g, l: LISTE.taban })]; if (sg === sl) continue; const ad = g === GRUP.dar ? 'dar' : 'gevsek'; console.log(`${`${a[0]} [${ad}]`.padEnd(31)} ${sg.padEnd(14)} ${sl.padEnd(14)} ${sb} (${sinif(a, sb)})`); } const eski = AKIS[1], d = cevir(eski); console.log(`\n"${eski[0]}" akisinda istek gelen yonde ${eski[3]} kapisina giriyor, donus giden yonde ` + `${d.donus[2]} kapisina cikiyor; liste bu iki yonu ayri iki satir olarak goruyor.`); ``` ``` liste bicimi kural dogru yanlis kapali yakalandi kacan gecici araliga bakan satir taban 9 5 1 4 2 140 numarali satir kazaniyor reddet-145 10 5 1 4 2 140 numarali satir kazaniyor reddet-135 10 4 2 6 0 135 numarali satir kazaniyor mekanizma kural dogru yanlis kapali yakalandi kacan grup (dar) 5 6 0 6 0 grup (gevsek) 5 6 0 5 1 liste (taban) 9 5 1 4 2 dar + liste 14 5 1 6 0 gevsek + liste 14 5 1 6 0 ikisi ayni akista ayri sey soyluyorsa belirleyen hangisi: akis yalniz grup yalniz liste birlikte eski istemci [dar] gecti donus durdu donus durdu (yanlis kapali) dis -> gecici aralik [dar] istek durdu donus durdu istek durdu (yakalandi) sahte donus (kaynak 443) [dar] istek durdu gecti istek durdu (yakalandi) eski istemci [gevsek] gecti donus durdu donus durdu (yanlis kapali) dis -> uygulama:8080 [gevsek] gecti istek durdu istek durdu (yakalandi) dis -> gecici aralik [gevsek] istek durdu donus durdu istek durdu (yakalandi) sahte donus (kaynak 443) [gevsek] istek durdu gecti istek durdu (yakalandi) "eski istemci" akisinda istek gelen yonde 8080 kapisina giriyor, donus giden yonde 5000 kapisina cikiyor; liste bu iki yonu ayri iki satir olarak goruyor. ``` Kaçan iki akışı kapatmak için bir reddet satırı yazıldı ve numarası yüz kırk beş verildi. Kural sayısı dokuzdan ona çıktı, sonuç sütunlarının hiçbiri değişmedi. Sağdaki sütun nedenini veriyor: geçici aralığa bakan satır hâlâ yüz kırk numaralıdır, çünkü ilk eşleşen kazanıyor ve yüz kırk önce geliyor. Denetim listesinde bir reddet satırı görünüyor; koşumda hiç çalışmıyor. Numarayı yüz otuz beşe çekmek gerçekten çalışıyor: kaçan ikiden sıfıra iniyor. Aynı hareket doğru akışı beşten dörde, yanlış kapatmayı birden ikiye götürüyor. Kapanan ikinci şey dış hizmete yapılan çağrının dönüşüdür. Kaçış ile o dönüş aynı satıra uyuyor çünkü paket olarak aynı şeyler: dışarıdan gelen, geçici aralıktaki bir kapıya giden paket. Sıra bunları ayırmıyor; yalnız hangisinin feda edileceğini seçiyor. Durum bilgisiz mekanizmada bu iki akışı ayıran bir satır yazılamaz. Alttaki tablo ikisini birlikte koyuyor. Değerlendirme sırası şudur: gelen yönde alt ağ listesi önce, örneğin grubu sonra; giden yönde tersi. Dar grup tek başına on dört kuralın verdiği sonucun aynısını veriyor. Dokuz satırlık liste bir kaçış kapatmıyor, bir yanlış kapatma getiriyor. Gevşek grup satırı ise listenin kazancını gösteriyor: grup dışarıdan sekiz bin seksen kapısına izin vermiş, liste onu alt ağ sınırında durduruyor. Şaşırtıcı sonuç son tablonun ilk satırındadır. Eski istemci akışında grup "geçti" diyor, liste "dönüş durdu" diyor, birlikte "dönüş durdu" çıkıyor. Doğru yazılmış bir grup, yanlış yazılmış bir listeyi kurtarmıyor; tersi kurtarıyor. Durum bilgisiz katman yalnız çıkarabilir — grubun yanlışlıkla açtığını kapatır, grubun doğru olarak açtığını da kapatabilir, ama hiçbir dönüş yolunu açamaz. Grubun durum tablosunda bağlantı "kurulmuş" görünürken paket alt ağ sınırında düşüyor ve iki yerde bakılan iki kayıt birbirini doğrulamıyor. Geri alınamayan kalem bu satırdır. Kural yazılır, numarası değiştirilir, satır silinir — hepsi geri alınabilir. Geri alınamayan şey, dönüşü düşen isteğin sunucu tarafında yaptığı iştir: istek işlendi, yanıt gitmedi, istemci yeniden denedi ve aynı ölçüm iki kez kaydedildi. Satırı düzeltmek çift kaydı geri almıyor. Elde kalan karar dört kalemdir — hangi mekanizmanın kullanılacağı, kural genişliği, numaralandırma ve geçici aralık varsayımı. Devredilen kalem de dörttür: durum tablosunun kendisi, iki mekanizmanın değerlendirme sırası, geçici kapının istemci tarafında seçilmesi ve durum tablosunun kapasitesi. Yukarıdaki iki kaçış ile bir yanlış kapatmanın üçü de devredilen dörtlüden doğuyor. #### Özet - Aynı politika durum bilgili mekanizmada 5, durum bilgisiz mekanizmada 9 kural ediyor. Aradaki 4 satır hiçbir politika yazmıyor; yalnız dönüş trafiği için var. - Durum bilgisiz liste 2 akış kaçırıyor ve ikisi de aynı satırdan geçiyor: herhangi bir kaynaktan geçici kapı aralığına izin veren satır. Sahte dönüş akışı iki yönde birden geçiyor, çünkü meşru bir dönüşten paket düzeyinde ayırt edilemiyor. - Aynı liste 1 meşru akışı yanlışlıkla kapatıyor: kaynak kapısı 5000 olan istemcinin isteği ulaşıyor, yanıtı çıkamıyor. Sunucu günlüğünde başarılı istek, istemcide zaman aşımı. - Reddet satırını 145 numarayla yazmak hiçbir sayıyı değiştirmiyor; 140 önce eşleşiyor. 135 numarayla yazmak kaçanı 2'den 0'a indiriyor ama doğruyu 5'ten 4'e düşürüp yanlış kapatmayı 1'den 2'ye çıkarıyor — kaçış ile meşru dönüş aynı satıra uyduğu için sıra yalnız hangisinin feda edileceğini seçiyor. - Birlikte kullanımda dar grup + liste 14 kuralla, dar grubun tek başına 5 kuralla verdiği sonucu veriyor ve üstüne 1 yanlış kapatma ekliyor; listenin kazancı yalnız grubun yanlış yazıldığı akışta görünüyor. Geri alınamayan kalem, dönüşü düşen isteğin sunucuda bıraktığı çift kayıttır. #### Sonraki Adım İki dersten beri dışarıdan erişilebilen tek kalem yük dengeleyicinin dinlediği kapıydı ve o kapı şimdiye dek yalnız bir sayı olarak geçti. Arkasındaki seçim ise küçük değil: dengeleyici trafiği aktarım katmanında da uygulama katmanında da karşılayabilir ve iki katman aynı isteğe bakarken farklı şeyler görür. Sonraki dersin sorusu bu seçimi kalem kalem sayar: her katman istekten hangi alanları okuyabiliyor, okuyabilmek için kaç ek tur ve kaç ek işlem gerekiyor, arkadaki örnek karşı tarafın kim olduğunu hangi düzende hâlâ görebiliyor — ve katmanı yükseltmek dışarıya bakan yüzeye hangi yeni kalemleri ekliyor. ### Yük Dengeleyiciler Source: https://academia.sh/tr/kurslar/bulut-hesaplama-ve-ag/yuk-dengeleyiciler Yük dengeleyicide katman seçiminin ne belirlediği: aktarım katmanının iki alan görüp beş kuraldan birini uygulayabilmesi ve bin iki yüz isteğin bin yirmi dördünü yanlış havuza göndermesi, kapı ayrımının bunu altı yüz elli üçe indirirken istemciye iki kalem yazması, uygulama katmanının beş kuralı da uygulayıp anahtar kopyasını altıdan bire indirmesi ve sonlandırma noktasını altıdan yediye çıkarması, sağlık denetimi eşiğinin fark etme süresi ile yanlış çıkarma arasında kurduğu takas. Bir önceki ders trafiği filtreledi: hangi kaynaktan hangi kapıya gelen isteğin geçeceği kural kural yazıldı ve geçmeyenler sayıldı. Filtreden geçen istek artık ağın içindedir. Geçen isteğin **hangi örneğe** gideceği hâlâ belirsiz. Ölçüm ağının panosunu altı örnek sunuyor; bunlardan biri şu anda yeniden başlıyor, biri yüksek yükte, biri de yeni açılmış ve henüz hazır değil. İsteği bir örneğe bağlayan şey yük dengeleyicidir. Dengeleme algoritmaları — sırayla dağıtım, en az bağlantı, oturum yapışkanlığı — ve sağlık denetiminin ne olduğu daha önce ölçüldü; bu ders o mekaniği tekrarlamaz. Kiralanan katmanda elde kalan karar başkadır: dengeleyicinin **hangi katmanda** çalışacağı. Katman, dengeleyicinin isteğin neresini görebileceğini belirler ve gördüğü bilgi kadar yönlendirme yapabilir. Burada ölçülen üç şeydir: her katmanın gördüğü alan ve uygulayabildiği kural, uygulama katmanının eklediği tur ile açtığı sonlandırma noktası ve sağlık denetimi eşiğinin taranması. - **BA31.** Kurgu bölgesel ölçüm ağı: iki ana ad (`pano`, `varlik`), beş içerik yolu, altı arka uç örneği. İstek akışı kendi üretecimizle üretilir; tohum `30631` görünürdür ve koşumdan koşuma aynı diziyi verir. Bin iki yüz istek. - **BA32.** Operatörün niyeti beş kuralda yazılıdır: iki yol öneki, bir ana ad, bir yönetim yolu ve bir varsayılan. Kurallar sırayla denenir, eşleşen ilki kazanır. - **BA33.** Aktarım katmanı dengeleyicisi yalnız **adres ve kapıyı** görür; uygulama katmanı adres, kapı, yol, ana ad ve oturum alanını görür. Kapı ayrımı düzeninde istemci varlık ve yönetim trafiğini ayrı kapılara gönderir — bu, istemci tarafında değişen kalemdir. - **BA34.** El sıkışma turu, sonlandırma noktası ve anahtar kopyası sayıları model sabitidir: aktarım katmanı bağlantıyı geçirir (bir tur, anahtar altı arka uçta), uygulama katmanı bağlantıyı sonlandırıp arkaya yenisini açar (iki tur, anahtar dengeleyicide). - **BA35.** Sağlık denetimi modeli altı örnek ve üç yüz denetim turudur; üçüncü örnek yüz yirminci turda kalıcı olarak bozulur. Sağlıklı örnekte geçici sapma olasılığı her denetimde bağımsızdır ve aralıktan etkilenmez; tohum `41129`. - **BA36.** Örnek eşik kadar ardışık başarısız denetimden sonra trafikten çıkarılır, iki ardışık başarılı denetimden sonra geri alınır. Model süre ölçmez; saniye değerleri tur sayısı ile denetim aralığının çarpımıdır. ```js // dengeleyici/katman.mjs — model: yuk dengeleyici katman secimi ve saglik denetimi esigi. // Kurgu bolgesel olcum aginin istek akisi kendi uretecimizle uretilir; tohum gorunur. // Dengeleme algoritmasi yeniden tanimlanmaz; olculen sey katmanin gordugu bilgi, o bilgiyle // yapabildigi yonlendirme ve actigi yuzeydir. const TOHUM = 30631, ISTEK = 1200, ARKA_UC = 6; // [yol, ana ad, agirlik, operatorun istedigi havuz] const AKIS = [ ["/harita/bolge", "pano", 30, "harita"], ["/sayac/liste", "pano", 25, "sayac"], ["/gecelik/ozet", "pano", 15, "genel"], ["/varlik/logo.png", "varlik", 20, "varlik"], ["/yonetim/dugum", "pano", 10, "yonetim"], ]; const TOPLAM = AKIS.reduce((a, x) => a + x[2], 0); // [bakilan alan, deger, havuz] — kurallar sirayla denenir, sonuncusu varsayilandir const KURAL = [["yol", "/harita", "harita"], ["yol", "/sayac", "sayac"], ["ad", "varlik", "varlik"], ["yol", "/yonetim", "yonetim"], ["kapi", "*", "genel"]]; const KAPILI = ["varlik", "yonetim"]; // kapi ayriminda ayri kapiya alinan havuzlar const uretec = (t) => { let s = t >>> 0; return () => (s = (Math.imul(s, 1664525) + 1013904223) >>> 0) / 4294967296; }; const sec = (u) => { let e = u * TOPLAM; return AKIS.find((x) => (e -= x[2]) < 0) ?? AKIS[0]; }; function kosu({ alanlar, ayrim }) { const r = uretec(TOHUM); let dogru = 0, yanlis = 0, bakilan = 0; for (let i = 0; i < ISTEK; i += 1) { const [yol, ad, , hedef] = sec(r()); let giden = "genel"; if (alanlar.includes("yol")) { // uygulama katmani: kural zinciri yurutulur for (const [alan, deger, havuz] of KURAL) { bakilan += 1; if (alan === "kapi" || (alan === "yol" ? yol.startsWith(deger) : ad === deger)) { giden = havuz; break; } } } else { // aktarim katmani: yalniz kapiya bakilir bakilan += 1; giden = ayrim && KAPILI.includes(hedef) ? hedef : "genel"; } if (giden === hedef) dogru += 1; else yanlis += 1; } const kural = KURAL.filter(([alan, , havuz]) => alanlar.includes(alan) || (ayrim && KAPILI.includes(havuz))).length; return { dogru, yanlis, bakilan, kural }; } // [ad, gorulen alanlar, kapi ayrimi, el sikisma turu, sonlandirma noktasi, anahtar kopyasi] const DUZEN = [ ["aktarim/tek kapi", ["adres", "kapi"], false, 1, ARKA_UC, ARKA_UC], ["aktarim/kapi ayrimi", ["adres", "kapi"], true, 1, ARKA_UC, ARKA_UC], ["uygulama katmani", ["adres", "kapi", "yol", "ad", "oturum"], false, 2, ARKA_UC + 1, 1], ]; const E = [22, 13, 16, 13, 13, 15]; const yaz = (h) => h.map((d, i) => String(d)[i ? "padStart" : "padEnd"](E[i])).join(""); console.log(yaz(["duzen", "gorulen alan", "uygulanan kural", "dogru havuz", "yanlis havuz", "istemci kalemi"])); const O = []; for (const [ad, alanlar, ayrim] of DUZEN) { const o = kosu({ alanlar, ayrim }); O.push(o); console.log(yaz([ad, alanlar.length, o.kural, o.dogru, o.yanlis, ayrim ? KAPILI.length : 0])); } const P = [22, 14, 16, 20, 16]; const yaz2 = (h) => h.map((d, i) => String(d)[i ? "padStart" : "padEnd"](P[i])).join(""); console.log("\n" + yaz2(["duzen", "el sikisma tur", "bakilan alan", "sonlandirma noktasi", "anahtar kopyasi"])); DUZEN.forEach(([ad, , , tur, son, anahtar], i) => console.log(yaz2([ad, tur, O[i].bakilan, son, anahtar]))); // --- Saglik denetimi esigi ------------------------------------------------------ // Model: alti ornek, uc yuz denetim turu. Ucuncu ornek 120. turda kalici olarak bozulur. // Saglikli ornekte gecici sapma olasiligi her denetimde bagimsizdir ve araliktan etkilenmez. const ORNEK = 6, DENETIM = 300, BOZULMA = 120, SAPMA = 0.06, TOHUM2 = 41129, BOZUK = 3; function saglik(esik) { const r = uretec(TOHUM2); const ardisik = Array(ORNEK).fill(0), disarida = Array(ORNEK).fill(false); const basarili = Array(ORNEK).fill(0); let farkTur = 0, yanlisCikarma = 0, kayipTur = 0; for (let t = 1; t <= DENETIM; t += 1) { for (let o = 0; o < ORNEK; o += 1) { const kalici = o === BOZUK && t >= BOZULMA; const basarisiz = (r() < SAPMA) || kalici; if (basarisiz) { ardisik[o] += 1; basarili[o] = 0; } else { ardisik[o] = 0; basarili[o] += 1; } if (!disarida[o] && ardisik[o] >= esik) { disarida[o] = true; if (kalici) { if (farkTur === 0) farkTur = t; } else yanlisCikarma += 1; } else if (disarida[o] && basarili[o] >= 2) disarida[o] = false; if (disarida[o] && !kalici) kayipTur += 1; } } return { farkTur, yanlisCikarma, kayipTur }; } const S = [12, 8, 17, 16, 17, 20, 13]; const yaz3 = (h) => h.map((d, i) => String(d)[i ? "padStart" : "padEnd"](S[i])).join(""); console.log("\n" + yaz3(["aralik(sn)", "esik", "fark etme turu", "fark etme(sn)", "yanlis cikarma", "kayip kapasite(sn)", "denetim/dk"])); for (const aralik of [2, 5, 10]) { for (const esik of [1, 2, 3]) { const s = saglik(esik); console.log(yaz3([aralik, esik, s.farkTur, (s.farkTur - BOZULMA + 1) * aralik, s.yanlisCikarma, s.kayipTur * aralik, (60 / aralik) * ORNEK])); } } ``` ``` duzen gorulen alan uygulanan kural dogru havuz yanlis havuz istemci kalemi aktarim/tek kapi 2 1 176 1024 0 aktarim/kapi ayrimi 2 3 547 653 2 uygulama katmani 5 5 1200 0 0 duzen el sikisma tur bakilan alan sonlandirma noktasi anahtar kopyasi aktarim/tek kapi 1 1200 6 6 aktarim/kapi ayrimi 1 1200 6 6 uygulama katmani 2 3075 7 1 aralik(sn) esik fark etme turu fark etme(sn) yanlis cikarma kayip kapasite(sn) denetim/dk 2 1 120 2 78 330 180 2 2 121 4 2 8 180 2 3 122 6 0 0 180 5 1 120 5 78 825 72 5 2 121 10 2 20 72 5 3 122 15 0 0 72 10 1 120 10 78 1650 36 10 2 121 20 2 40 36 10 3 122 30 0 0 36 ``` #### Görülen Alan, Uygulanabilen Kural Birinci tablonun ilk sütunu katmanın gördüğü alan sayısıdır: aktarım katmanı **iki**, uygulama katmanı **beş**. İkinci sütun bu görüşle uygulanabilen kural sayısıdır. Operatörün yazdığı beş kuraldan aktarım katmanı yalnız **birini** uygulayabiliyor: varsayılanı. Diğer dördü yola ya da ana ada bakıyor ve aktarım katmanı bu iki alanı hiç görmüyor. Sonuç üçüncü sütunda: bin iki yüz isteğin yalnız **yüz yetmiş altısı** operatörün istediği havuza gitti, **bin yirmi dördü** yanlış havuza düştü. Doğru gidenler yalnızca zaten varsayılana ait olan gecelik özet istekleridir. Bu, yanlış yapılandırma değildir. Kural yazılmıştır ve doğrudur; dengeleyici kuralın baktığı alanı görmediği için uygulayamaz. Beş kurallık bir niyet, iki alanlık bir görüşe sığmıyor. İkinci satır bu sıkışmanın bilinen çözümünü ölçüyor: **kapı ayrımı**. Varlık trafiği bir kapıya, yönetim trafiği başka bir kapıya alınıyor. Aktarım katmanı kapıyı gördüğü için bu iki kuralı artık uygulayabiliyor — uygulanan kural sayısı bire değil **üçe** çıkıyor, doğru havuza giden istek yüz yetmiş altıdan **beş yüz kırk yediye** yükseliyor. Kazanç son sütunda ödeniyor. Kapı ayrımı dengeleyicide değil, **istemcide** bir değişikliktir: iki kalem istemci yapılandırması değişti. Harita ile sayaç istekleri ise hâlâ aynı ana ada, aynı kapıya geliyor — bunları kapıyla ayırmanın yolu yok, altı yüz elli üç istek yanlış havuzda kalıyor. Üçüncü satırda uygulama katmanı beş alanı görüyor, beş kuralı da uyguluyor, yanlış havuza giden istek **sıfır**, istemcide değişen kalem **sıfır**. #### Uygulama Katmanının Faturası İkinci tablo aynı üç düzenin bedelini sayıyor. Bakılan alan sütunu hesaplanmıştır: aktarım katmanı her istekte tek alana bakıyor (kapı), toplam **bin iki yüz** bakış. Uygulama katmanı kural zincirini eşleşene kadar yürütüyor — harita isteği birinci kuralda, sayaç ikincide, varlık üçüncüde, yönetim dördüncüde, gecelik özet ise beşinci kurala kadar iniyor. Ağırlıklı toplam **üç bin yetmiş beş** bakış, iki buçuk katı. Zincirin **sırası** ölçülebilir bir şeydir: ağır trafiği başa almak bu sayıyı düşürür. El sıkışma turu sütunu daha keskin. Aktarım katmanı bağlantıyı geçirir: şifreli oturum istemci ile arka uç arasında kurulur, dengeleyici baytları taşır, tur sayısı **bir**. Uygulama katmanı isteğin yolunu okumak zorundadır ve okumak için şifreyi çözmek zorundadır: oturum dengeleyicide sonlanır, arkaya ikinci bir oturum açılır, tur sayısı **iki**. Son iki sütun bu zorunluluğun iki yüzünü gösteriyor ve ikisi ters yöne bakıyor. Anahtar kopyası aktarım katmanında **altıdır**: şifre arka uçta sonlandığı için özel anahtarın altı örneğin her birinde durması gerekir. Anahtarı değiştirmek altı makineye dokunmak demektir. Uygulama katmanında anahtar kopyası **bire** iner — anahtar yalnız dengeleyicidedir. Sonlandırma noktası ters yöne gidiyor: altıdan **yediye**. İsteğin baş kısmı önce dengeleyicide düz metne dönüyor, sonra arka uçta bir daha. Eklenen nokta öbür altısına benzemez: **kiralanan bileşendir**. Yolu, ana adı, oturum çerezini ve isteği yapan adresi gören, işletilmeyen bir bileşen zincire girdi. O bileşen bu alanları kendi günlüğüne de yazar ve günlüğün nerede durduğu bu dersin kararları arasında değildir. Takas tek cümlede sayılabilir: anahtar kopyası altıdan bire, sonlandırma noktası altıdan yediye, yanlış yönlendirme bin yirmi dörtten sıfıra. #### Sağlık Denetiminin Üç Sayısı Üçüncü tablo dengeleyicinin ikinci işini ölçüyor. Kiralanan dengeleyicide sağlık denetiminin nasıl çalıştığı sağlayıcının işidir; elde kalan üç sayıdır: **aralık**, **eşik** ve denetim yolu. Tarama bu üç sayıdan ikisini geziyor. Fark etme turu eşiğe bağlı ve aralıktan bağımsızdır: eşik bir iken bozuk örnek yüz yirminci turda, eşik üç iken yüz yirmi ikinci turda çıkarılıyor. Aynı tur sayısı, aralık iki saniyeyken **iki ila altı saniyeye**, aralık on saniyeyken **on ila otuz saniyeye** karşılık geliyor. Bozuk örneğin trafik almaya devam ettiği süre budur. Yanlış çıkarma sütunu ters yönde çalışıyor. Eşik bir iken **yetmiş sekiz** kez sağlıklı bir örnek trafikten çıkarıldı: tek bir başarısız denetim, geçici bir sapma ve örnek dışarı alındı. Eşik ikiye çıktığında bu sayı **ikiye**, üçe çıktığında **sıfıra** iniyor. Kayıp kapasite sütunu yanlış çıkarmanın faturasıdır. Eşik bir ve aralık on iken **bin altı yüz elli saniye**: altı örnekten biri sırayla dışarı alınıp geri kondu ve yaklaşık yirmi sekiz dakika boyunca kapasite eksik çalıştı. Aynı satırda bozuk örnek on saniyede fark edilmişti. On saniyelik kazanç için bin altı yüz elli saniyelik kapasite ödendi. Son sütun üçüncü bedeli sayıyor: aralığı kısaltmak denetim isteğini çoğaltır. Aralık on iken dakikada otuz altı denetim isteği, aralık iki iken **yüz seksen**. Bu istekler arka uca iner ve denetim yolu ucuz değilse ölçülebilir yük oluşturur. Üç sütun birlikte okunduğunda düzen ortaya çıkıyor: **aralık hızı belirler ve yükü ödetir, eşik doğruluğu belirler ve gecikmeyi ödetir.** Eşiği üçte tutup aralığı ikiye indirmek altı saniyede fark etme, sıfır yanlış çıkarma ve dakikada yüz seksen denetim isteği verir. Eşik bir ve aralık iki iki saniyede fark ediyor ama üç yüz otuz saniye kapasite kaybediyor: dört saniyelik fark, üç yüz otuz saniyeye mal oluyor. #### Elde Kalan Karar Kiralanan dengeleyicide sağlayıcının devraldığı kalemler bellidir: dağıtım algoritmasının uygulaması, dengeleyicinin kendi kapasitesi ve ölçeklenmesi, bağlantı kuyruğunun sınırları, düğümlerin nereye yerleştiği. Bunların hiçbiri bu derste ölçülmedi, çünkü üzerlerinde karar yok. Elde kalan dokuz kalem sayılabilir: katman, kural zinciri ve sırası, arka uç havuzlarının tanımı, sağlık denetimi yolu, aralık, eşik, zaman aşımı, anahtarın nerede duracağı, oturum yapışkanlığı. Sekizi her an değişir. Dokuzuncusu değişmez. **Katman, dengeleyici yaratıldığında sabitlenir.** Aktarım katmanı dengeleyicisi sonradan uygulama katmanına dönmez; dönüştürme diye bir işlem yoktur. Yapılan şey yeni bir dengeleyici yaratmak, ona yeni bir uç adı verilmesini beklemek ve bütün istemcileri o ada taşımaktır. Bu dersin **geri alınamayan kalemi** budur. Bedeli tabloda duruyor. Aktarım katmanıyla başlayan bir kurulum bin yirmi dört yanlış yönlendirmeyi kapı ayrımıyla altı yüz elli üçe indirebilir ve bunun için istemcide iki kalem değiştirir. Kalan altı yüz elli üçü kapatmak katman değiştirmek, katman değiştirmek de istemcinin bağlandığı adı değiştirmektir: kapı ayrımı için dokunulan iki kalem yeniden dokunulacaktır. #### Özet - Aktarım katmanı iki alan (adres, kapı) görüyor ve beş kuraldan yalnız varsayılanı uygulayabiliyor; bin iki yüz isteğin bin yirmi dördü yanlış havuza düştü. Uygulama katmanı beş alan görüyor, beş kuralı da uyguluyor, yanlış yönlendirme sıfır. - Kapı ayrımı aktarım katmanına iki kural kazandırdı ve doğru yönlendirmeyi yüz yetmiş altıdan beş yüz kırk yediye çıkardı; bedeli istemcide değişen iki kalem oldu ve aynı ada gelen harita ile sayaç trafiği ayrılamadı. - Uygulama katmanı bakılan alanı bin iki yüzden üç bin yetmiş beşe, el sıkışma turunu birden ikiye çıkardı; anahtar kopyasını altıdan bire indirirken sonlandırma noktasını altıdan yediye çıkardı ve eklenen nokta kiralanan bileşenin kendisidir. - Sağlık denetiminde eşiği birden üçe çıkarmak yanlış çıkarmayı yetmiş sekizden sıfıra indirdi ve fark etme süresini eşik sayısı kadar tur uzattı; aralık hızı belirleyip denetim yükünü ödetiyor, eşik doğruluğu belirleyip gecikmeyi ödetiyor. - Eşik bir ve aralık on düzeninde bozuk örnek on saniyede fark edildi ama bin altı yüz elli saniyelik sağlıklı kapasite boşuna dışarıda kaldı; on saniyelik kazancın bedeli budur. - Elde kalan dokuz kalemden sekizi her an değişir; katman değişmez. Katmanı değiştirmek yeni bir dengeleyici ve yeni bir uç adı demektir — bu dersin geri alınamayan kalemi. #### Sonraki Adım Bu ders dengeleyiciyi kurdu ve arkasındaki altı örneği trafiğe bağladı. Bütün ölçümler tek bir şeyi sabit varsaydı: istemcinin bağlandığı **uç**. O uç sabit değildir. Örnek değiştiğinde adresi değişir, dengeleyici yeniden yaratıldığında adı değişir, ölçekleme grubunun eklediği her örnek yeni bir adresle gelir. İstemcinin elinde ise tek bir adres ya da tek bir ad vardır ve o değer yapılandırma dosyasında, izleme hedefinde, üçüncü tarafın izin listesinde ayrı ayrı yazılıdır. Sonraki ders adres kararlılığını üç düzende karşılaştırır: adresin örnekle birlikte gitmesi, ayrı bir kaynak olarak taşınması ve ada bağlanması. Ölçülen şey istemcinin değişimi kaç saniyede fark ettiği, elle güncellenen kaç kalem olduğu ve bayat adrese kaç isteğin gittiğidir. Kalıcı adresin kendi bedeli de sayılır: sayısı sınırlıdır, taşınması bir işlemdir ve kullanılmayanı da ücret yazar. ### Kalıcı Adres ve Ad Tümleştirmesi Source: https://academia.sh/tr/kurslar/bulut-hesaplama-ve-ag/kalici-ip-ve-dns-tumlestirmesi Örnek değiştiğinde adresin ne olduğunun üç düzende ölçülmesi: geçici adreste beş kalemin elle güncellenmesinin fark etme süresini dört yüz elli saniyeye ve bayat isteği on bin sekiz yüze çıkarması, kalıcı adresin bunu iki yüze indirmesi, ad üzerinden çözümlemenin arada durması ve kalıcı adresin kendi bedeli — bölge kotası, taşıma işlemi, boşta duran adresin aylık ücreti ve bırakıldıktan sonra geri alınamaması. Bir önceki ders dengeleyiciyi kurdu ve bütün ölçümleri tek bir şeyi sabit sayarak yaptı: istemcinin bağlandığı uç. O uç sabit değildir. Kurgu bölgesel ölçüm ağının toplayıcıları düzenli olarak değişiyor. Biri bakım penceresinde yeniden yaratılıyor, biri sağlık denetiminden düştüğü için değiştiriliyor, biri de ölçekleme grubunun kararıyla ekleniyor. Her değişimde makinenin kendisi yenilenir — ve makinenin adresi makineye aittir, makineyle birlikte gider. Adresi elinde tutan yerler ise makinede değildir. İstemcinin yapılandırma dosyasında, izleme sisteminin hedef listesinde, bir güvenlik grubunun kaynak alanında, üçüncü taraf duyarga sahiplerinin izin listesinde ve işletim belgesinde ayrı ayrı yazılıdır. Bu ders adresin kararlılığını üç düzende karşılaştırır ve kalıcı adresin kendi faturasını sayar. Ad kaydının yaşam süresinin nasıl işlediği daha önce ölçüldü; bu ders o ölçümü tekrarlamaz, yaşam süresini **girdi** olarak alır. - **BA37.** Kurgu ölçüm ağında bir dönem üç bin altı yüz saniyedir ve içinde üç örnek değişimi olur: bakım, sağlıksızlık, ölçekleme. Toplayıcıya gelen istek hızı sabit sekiz istek/saniyedir. - **BA38.** Adresi elinde tutan kalemler beş tanedir: istemci yapılandırması, izleme hedefi, güvenlik grubu kaynağı, üçüncü tarafın izin listesi, işletim belgesi. Elle güncellenen bir kalem kurgu olarak doksan saniye sürer ve kalemler sırayla güncellenir. - **BA39.** Kalıcı adresin yeni örneğe taşınması yirmi beş saniye, ad kaydının güncellenmesi doksan saniye sürer; ikisi de kurgudur. Ad kaydının yaşam süresi altmış saniyedir ve **girdidir** — bu değerin nasıl ölçüldüğü daha önce yapıldı, burada yeniden ölçülmez. - **BA40.** Ad üzerinden düzende eski örnek yaşam süresi boyunca ayakta tutulur; bayat çözümlemeler bu yüzden eski örneğe gider, boşluğa değil. - **BA41.** Kalıcı adres kotası bölge başına beştir. Bu modelde bağlı adres ücretsiz, boşta duran adres saatte bir birimdir; ay yedi yüz yirmi saattir. Para birimi kurgudur ve adı **birim**dir. Gerçek sağlayıcılar bugün genel adresi bağlı olsun olmasın ücretlendiriyor; model boşta durmanın ek yükünü yalıtmak için bu ayrımı kuruyor. - **BA42.** Bırakılan adres havuza döner ve ikinci haftada başka bir kiracıya verilir. Bayat isteğin haftalık sönüm çarpanı 0,55'tir; başlangıç değeri ve çarpan kurgudur. ```js // adres/kararlilik.mjs — model: ornek degistiginde adresin ne oldugu. Kurgu bolgesel olcum // aginin toplayicilari uc kez degisiyor. Ad kaydinin yasam suresi daha once olculdu; burada // girdidir, yeniden olculmez. Para birimi kurgudur: "birim". const OLAY = [["bakim", 600], ["sagliksizlik", 1500], ["olcekleme", 2900]]; const HIZ = 8; // istek/saniye, sabit const KALEM = ["istemci yapilandirmasi", "izleme hedefi", "guvenlik grubu kaynagi", "ucuncu tarafin izin listesi", "isletim belgesi"]; const KALEM_SURE = 90; // kurgu: elle guncellenen bir kalem 90 saniye const TASIMA = 25; // kurgu: kalici adresin yeni ornege tasinmasi const KAYIT = 90; // kurgu: ad kaydinin guncellenmesi const YASAM = 60; // girdi: ad kaydinin yasam suresi (daha once olculdu) // [ad, elle kalem, tasima, kayit, yasam suresi devrede mi, bayat istek nereye gidiyor] const DUZEN = [ ["gecici adres", KALEM.length, 0, 0, false, "eski adres / yeni sahip"], ["kalici adres", 0, TASIMA, 0, false, "dusuyor"], ["ad uzerinden", 0, 0, KAYIT, true, "eski ornek"], ["kalici adres + ad", 0, TASIMA, 0, false, "dusuyor"], ]; const farkEtme = (d) => d[1] * KALEM_SURE + d[2] + d[3] + (d[4] ? YASAM : 0); const E = [20, 12, 15, 18, 16, 25]; const yaz = (h) => h.map((d, i) => String(d)[i ? "padStart" : "padEnd"](E[i])).join(""); console.log(yaz(["duzen", "elle kalem", "fark etme(sn)", "olay basina istek", `${OLAY.length} olayda`, "bayat istek nereye"])); for (const d of DUZEN) { const s = farkEtme(d); console.log(yaz([d[0], d[1], s, s * HIZ, s * HIZ * OLAY.length, d[5]])); } // --- Kalici adresin kendi bedeli ------------------------------------------------ // Toplayicilar ucuncu taraf duyarga sahiplerinin izin listesinde adresle yaziyor; bu yuzden // her ornek ayri bir kalici adres istiyor. Kota ve ucret kurgudur. const KOTA = 5, BOSTA_UCRET = 1, SAAT = 720; // birim/saat, kurgu aylik saat const K = [12, 16, 15, 16, 18, 14]; const yaz2 = (h) => h.map((d, i) => String(d)[i ? "padStart" : "padEnd"](K[i])).join(""); console.log("\n" + yaz2(["tepe ornek", "ortalama ornek", "gereken adres", "kota disi ornek", "bosta adres-saat", "aylik birim"])); for (const tepe of [3, 5, 7, 9]) { const ortalama = Math.round(tepe * 0.6); const ayrilan = Math.min(tepe, KOTA); const bosta = Math.max(0, ayrilan - ortalama); console.log(yaz2([tepe, ortalama, tepe, Math.max(0, tepe - KOTA), bosta * SAAT, bosta * SAAT * BOSTA_UCRET])); } // --- Birakilan adres: geri alinamayan kalem ------------------------------------- // Adres birakildiginda havuza doner. Yayimlanmis oldugu icin istemcilerde yasamaya devam eder; // sonum carpani kurgudur. Adres ikinci haftada baska bir kiraciya veriliyor. const BASLANGIC = 4200, SONUM = 0.55, HAFTA = 6, DEVIR = 2; const H = [8, 16, 22, 26]; const yaz3 = (h) => h.map((d, i) => String(d)[i ? "padStart" : "padEnd"](H[i])).join(""); console.log("\n" + yaz3(["hafta", "bayat istek", "adresin sahibi", "yabanciya giden (toplam)"])); let toplam = 0; for (let h = 1; h <= HAFTA; h += 1) { const istek = Math.round(BASLANGIC * SONUM ** (h - 1)); if (h >= DEVIR) toplam += istek; console.log(yaz3([h, istek, h < DEVIR ? "havuzda" : "baska kiraci", h < DEVIR ? 0 : toplam])); } ``` ``` duzen elle kalem fark etme(sn) olay basina istek 3 olayda bayat istek nereye gecici adres 5 450 3600 10800 eski adres / yeni sahip kalici adres 0 25 200 600 dusuyor ad uzerinden 0 150 1200 3600 eski ornek kalici adres + ad 0 25 200 600 dusuyor tepe ornek ortalama ornek gereken adres kota disi ornek bosta adres-saat aylik birim 3 2 3 0 720 720 5 3 5 0 1440 1440 7 4 7 2 720 720 9 5 9 4 0 0 hafta bayat istek adresin sahibi yabanciya giden (toplam) 1 4200 havuzda 0 2 2310 baska kiraci 2310 3 1271 baska kiraci 3581 4 699 baska kiraci 4280 5 384 baska kiraci 4664 6 211 baska kiraci 4875 ``` #### Kalem Sayısı Süreyi Belirliyor Birinci tablonun ikinci sütunu bu dersin çekirdeğidir: **elle güncellenen kalem sayısı**. Geçici adres düzeninde bu sayı beştir. Örnek değiştiğinde adres de değişir ve adresi tutan beş yerin beşi de elle güncellenmelidir. Üçüncü sütun bunun süreye çevrilmiş hâlidir: beş kalem, kalem başına doksan saniye, toplam **dört yüz elli saniye**. İstemcinin değişimi fark etmesi bu kadar sürüyor. Fark etme süresi bir yetenek sorunu değildir, **kalem sayısının doğrudan çarpımıdır**. Altıncı bir yer adresi tutmaya başlasa süre beş yüz kırk saniyeye çıkar. Adresi kaç yerde yazdığını bilmeyen bir kurulumda fark etme süresi de bilinmez. Dördüncü sütun bunu isteğe çeviriyor: saniyede sekiz istek, olay başına **üç bin altı yüz** bayat istek. Dönemde üç olay olduğu için toplam **on bin sekiz yüz**. İkinci satır kalıcı adresi koyuyor. Adres artık örneğe ait değildir; ayrı bir kaynaktır ve örnek değiştiğinde yeni örneğe **taşınır**. Elle güncellenen kalem sayısı beşten **sıfıra** iniyor, çünkü beş yerdeki değer hiç değişmiyor. Fark etme süresi taşıma işleminin kendisine, yirmi beş saniyeye iniyor; bayat istek olay başına iki yüze, dönemde altı yüze düşüyor. On bin sekiz yüzden altı yüze: **on sekiz kat**. Üçüncü satır ad üzerinden çözümlemeyi ölçüyor. Adres yine geçicidir ama beş kalem adresi değil **adı** tutuyor; değişimde güncellenen tek şey ad kaydıdır. Elle kalem sıfır, ama süre kalıcı adresinkinden altı kat uzun: doksan saniye kayıt güncellemesi artı altmış saniye yaşam süresi, toplam **yüz elli saniye**. Yaşam süresi burada ölçülmüyor, katılıyor. Dördüncü satır ikisini birleştiriyor: ad kalıcı adrese işaret ediyor, örnek değiştiğinde yalnız adres taşınıyor, kayıt hiç değişmiyor. Süre kalıcı adresin süresine, yirmi beş saniyeye dönüyor ve yaşam süresi denklemden çıkıyor. Ad tümleştirmesinin kalıcı adresi gereksiz kılmadığı, tersine onunla birlikte çalıştığı yer burasıdır. #### Bayat İsteğin Nereye Gittiği Son sütun aynı sayıların çok farklı üç anlamı olduğunu gösteriyor. Bayat istek sayısı tek başına karar taşımaz; o isteklerin **nereye ulaştığı** taşır. Kalıcı adres düzenlerinde bayat istekler **düşüyor**. Adres taşınma anında hiçbir arayüze bağlı değildir; istemci bağlanamaz, hata alır, yeniden dener. Altı yüz istek kayboldu ve bunu istemci de biliyor. Ad üzerinden düzende bayat istekler **eski örneğe** gidiyor. Bu, düzenin bir yan etkisi değil, bir kararın sonucudur: eski örnek yaşam süresi boyunca ayakta tutuluyor. Üç bin altı yüz istek doğru yanıtı alıyor. Bedeli tabloda görünmüyor ama sayılabilir: altmış saniye × üç olay = yüz seksen örnek-saniye boyunca iki örnek birden çalışıyor. Yaşam süresi uzadıkça hem pencere hem bu fazladan kapasite büyür. Geçici adres düzeninde bayat istekler **eski adrese** gidiyor ve o adres artık serbesttir. Dört yüz elli saniyelik pencere boyunca üç bin altı yüz istek, kime ait olduğu bilinmeyen bir adrese ölçüm verisi ve kimlik bilgisi taşıyor. Üç düzen arasında sayıca en kötüsü aynı zamanda niteliğe göre de en kötüsüdür — ama bu iki kötülük birbirinden bağımsızdır. Bayat isteği sıfıra indirmek onun yabancıya gitmesini engellemez; bunun için adresin **kime ait olduğunun** değişmemesi gerekir. #### Kalıcı Adresin Faturası İkinci tablo kalıcı adresi kendi başına ölçüyor. Toplayıcılar üçüncü taraf duyarga sahiplerinin izin listesinde adresle yazılı olduğu için her örneğin ayrı bir kalıcı adrese ihtiyacı var. Üçüncü sütun ihtiyacı, dördüncü sütun ise **kotayı** gösteriyor. Bölge başına beş kalıcı adres vardır. Tepe örnek sayısı yediye çıktığında iki örnek, dokuza çıktığında **dört örnek** kalıcı adres alamıyor. Bu örnekler ne kadar doğru yapılandırılırsa yapılandırılsın üçüncü tarafın izin listesinden geçemez. Kalıcı adres, sayısı sabit bir kaynaktır ve ölçeklenen bir gruba takılmıştır: grup büyüyebilir, adres havuzu büyümez. Beşinci ve altıncı sütunlar ters yöndeki bedeli sayıyor. Ayrılan adres tepe değere göre tutulmalıdır, ama grup ortalamada tepe değerin altında çalışır. Tepe beş, ortalama üç iken iki adres ayın çoğunda hiçbir örneğe bağlı değildir: **bin dört yüz kırk adres-saat**, aylık **bin dört yüz kırk birim**. Kullanılmayan adres ücretlidir; bağlı adres değildir. İki sütun birlikte okunduğunda kalıcı adresin dar bandı görünüyor. Tepe üç ile beş arasında kota yetiyor ama boşta ücret en yüksek noktasında. Tepe dokuzda boşta ücret sıfıra iniyor — çünkü beş adresin beşi de her zaman bağlı — ama dört örnek adressiz kalıyor. Kalıcı adres ne az ölçeklenen ne çok ölçeklenen bir gruba oturuyor; ortada dar bir aralıkta çalışıyor. Üçüncü bedel tabloda sayı olarak değil, birinci tablonun ikinci satırında duruyor: **taşıma bir işlemdir.** Adres kendiliğinden yeni örneğe geçmez; bir çağrı yapılır, adres eski arayüzden çözülür ve yenisine bağlanır. Yirmi beş saniyelik pencere ile altı yüz düşen istek bu işlemin süresidir. İşlemin bir başka yüzü daha var: adresi bir örnekten alıp başkasına bağlayabilen yetki bir yönetim ucudur ve o yetkiye sahip olan, trafiği kendi örneğine çekebilir. Kalıcı adres istemcinin gördüğü değeri sabitlerken, o değerin arkasındaki makineyi değiştirebilen bir düğme ekliyor. #### Bırakılan Adres Üçüncü tablo bu dersin **geri alınamayan kalemini** ölçüyor. Kalıcı adres bırakıldığında havuza döner. Bırakma tek bir işlemdir ve geri alınmaz: aynı adresin yeniden verilmesi diye bir işlem yoktur. Adres ikinci haftada başka bir kiracıya veriliyor. Sorun adresin gitmesi değildir. Sorun adresin **yayımlanmış** olmasıdır. Beş kalemde yazılıydı ve o beş kalemin hepsi senin denetiminde değil: üçüncü tarafın izin listesi ve bir başkasının işletim belgesi senin güncelleme turuna girmez. İlk hafta dört bin iki yüz istek bırakılan adrese gitmeye devam ediyor. Sönüm sürüyor ama bitmiyor: altıncı haftada hâlâ iki yüz on bir istek var. İkinci sütunun toplamı asıl sayıdır. İkinci haftadan altıncı haftaya kadar **dört bin sekiz yüz yetmiş beş** istek, adresin yeni sahibine gitti. Bu isteklerin içinde ölçüm verisi, toplayıcı kimliği ve belki bir erişim belirteci var. Yeni sahip hiçbir şey yapmadı; adresi kiraladı ve trafik geldi. Bu yüzeyin kapatılması geriye dönük değildir. Adres bırakıldıktan sonra yapılabilecek tek şey kalemleri güncellemektir ve senin denetimindeki kalemler zaten güncellenmişti. Yüzeyi kapatan tek karar adresi **bırakmamaktır** — yani boşta duran adresin aylık bin dört yüz kırk birimini ödemeye devam etmektir. Fatura ile yüzey aynı kararın iki yüzüdür. #### Elde Kalan Karar Bu katmanda sağlayıcının devraldığı kalemler: adres havuzunun yönetimi, bırakılan adresin yeniden dağıtımı, ad çözümleme altyapısının kendisi ve kotanın büyüklüğü. Elde kalan altı kalem: hangi düzenin kullanılacağı, adresin kaç kalemde yazılı olduğu, yaşam süresi değeri, eski örneğin ne kadar ayakta tutulacağı, kaç kalıcı adres ayrılacağı ve adresin bırakılıp bırakılmayacağı. Beşi her an değişir ve beşinin de sayısı bu derste ölçüldü. Altıncısı değişmez: **bırakılmış bir adres geri alınmaz.** Bir dengeleyicinin katmanı gibi bu da yaratılış anında değil, bırakma anında kilitlenen bir karardır — ve bırakma, elde kalan kalemler içinde en kolay yapılanıdır: tek bir çağrı, hiçbir uyarı, aylık ücretin sıfırlanması. Bedeli aylar sonra, adresi hiç bilmediğin bir kiracının izin listesinde okurken görünür. Açılan yüzeyler de üç tanedir ve üçü de bu derste eklendi: taşıma yetkisi (trafiği başka bir örneğe çekebilen bir düğme), ad kaydını değiştirebilen yetki (istemci hiçbir şey fark etmeden bütün trafiği yönlendirir) ve bırakılmış adresin yabancıya taşıdığı istek. Üçü de "adres kararlı olsun" cümlesinin içinde görünmez. #### Özet - Geçici adres düzeninde beş kalem elle güncelleniyor ve fark etme süresi doğrudan bu sayının çarpımı: dört yüz elli saniye, olay başına üç bin altı yüz bayat istek, üç olayda on bin sekiz yüz. - Kalıcı adres elle güncellenen kalemi sıfıra, fark etme süresini yirmi beş saniyeye ve bayat isteği altı yüze indirdi — on sekiz kat. Ad üzerinden çözümleme arada duruyor: yüz elli saniye, üç bin altı yüz istek, çünkü kayıt güncellemesine yaşam süresi ekleniyor. - Bayat istek sayısı tek başına karar taşımıyor: kalıcı adreste istekler düşüyor, ad düzeninde ayakta tutulan eski örneğe gidiyor (yüz seksen örnek-saniye fazladan kapasite), geçici adreste serbest kalmış bir adrese gidiyor. - Kalıcı adres dar bir bantta çalışıyor: tepe dokuz örnekte dört örnek kota dışı kalıyor, tepe beşte ise iki adres boşta duruyor ve ayda bin dört yüz kırk birim yazıyor. Modelde bağlı adres ücretsiz, boşta adres ücretlidir. - Bırakılan adres geri alınmaz ve yayımlanmış olduğu için ölmez: ikinci haftadan altıncıya kadar dört bin sekiz yüz yetmiş beş istek adresin yeni sahibine gitti. Yüzeyi kapatan tek karar adresi bırakmamak, yani boşta ücreti ödemeye devam etmektir. #### Sonraki Adım Son iki ders isteğin bulduğu ucu kurdu: dengeleyici hangi örneğe gideceğini belirledi, adres ve ad o ucun kararlı kalmasını sağladı. Ölçüm ağının panosuna gelen her istek artık doğru makineye varıyor. Her istek hâlâ **o makineye varıyor**. Bölge haritası, sayaç listesi ve varlık dosyaları uzaktaki bir istemci için de aynı yolu kat ediyor ve kaynak sunucudan çıkan her bayt için çıkış ücreti yazılıyor. Aynı harita günde binlerce kez, aynı bölgeden dışarı çıkıyor. Bu yanıtların bir bölümü istemciye çok daha yakın bir yerde tutulabilir. Kenar önbelleğinin mekaniği daha önce ölçüldü; sonraki ders kenarı **kiralanan bir hizmet** olarak ele alır ve üç şeyi sayar: isabet oranı kaynağa inen isteği ne kadar düşürüyor, kenar çıkışı ile kaynak çıkışı ayrı fiyatlandığında toplam fatura hangi isabet oranında dönüyor ve geçersizleştirme kaç istek ile kaç saniyeye mal oluyor. Kenarın devraldığı kararlar da kalem kalem sayılır: önbellek anahtarı, tazelik ve sıkıştırma kararlarından kaçı elde kalıyor. ### İçerik Dağıtım Ağı Source: https://academia.sh/tr/kurslar/bulut-hesaplama-ve-ag/icerik-dagitim-agi Kenarın hizmet olarak kiralanmasının ölçülmesi: kenar çıkışı ile kaynak çıkışı ayrı fiyatlandığında faturanın yüzde altmış yedi isabette dönmesi ve yüzde altmışta kaynak yükü düşmüşken faturanın hâlâ yüksek kalması, önek geçersizleştirmesinin ücretsiz görünüp yüz seksen bin ısınma isteği üretmesi, geçersizleştirmenin doksan saniyelik kenar penceresini kapatıp üç bin altı yüz saniyelik istemci penceresine hiç dokunmaması ve on beş karar kaleminden dokuzunun elde kalması. Son iki ders isteğin bulduğu ucu kurdu ve o ucu kararlı hâle getirdi. Ölçüm ağının panosuna gelen her istek artık doğru makineye varıyor — ve her istek **o makineye** varıyor. Bölge haritası, sayaç listesi ve varlık dosyaları uzaktaki bir istemci için de aynı yolu kat ediyor. Kaynak sunucudan çıkan her bayt için çıkış ücreti yazılıyor ve aynı harita günde binlerce kez aynı bölgeden dışarı çıkıyor. Kenar önbelleğinin nasıl çalıştığı, isabet oranının nasıl oluştuğu ve tazeliğin pencereyi nasıl belirlediği daha önce ölçüldü; bu ders o mekaniği tekrarlamaz. Burada kenar **kiralanan bir hizmettir** ve ölçülen üç şey vardır: iki ayrı çıkış fiyatı altında faturanın hangi isabet oranında döndüğü, geçersizleştirmenin kaç istek ve kaç saniyeye mal olduğu ve kenara verilen kararlardan kaçının elde kaldığı. İsabet oranı burada bir sonuç değil, taranan bir eksendir. - **BA43.** Kurgu bölgesel ölçüm ağının aylık trafiği dört milyon istek ve ortalama kırk KB yanıttır; toplam yüz altmış GB. Kenar açıldığında istemciye giden bütün baytlar kenardan çıkar. - **BA44.** Fiyatlandırma kurgudur, para biriminin adı **birim**dir: kaynak çıkışı GB başına dokuz birim, kenar çıkışı GB başına beş birim, istek ücreti on bin istek başına 0,4 birim. Modelin gerçeğe dayandığı tek nokta kenar çıkışının kaynak çıkışından ucuz, ama sıfır olmamasıdır. - **BA45.** Kırk kenar düğümü vardır ve bir nesne ortalama on düğümde durur; kapsama kurgudur. - **BA46.** Geçersizleştirmenin en yavaş düğüme ulaşma süresi kurgudur: tek tek yol için doksan, önek için yüz elli saniye. Ayda bin yol ücretsizdir, üstü yol başına 0,005 birimdir. - **BA47.** Bir sürümde iki bin dört yüz varlık dosyası değişir; önek altında toplam on sekiz bin nesne vardır. - **BA48.** Yanıt istemcinin kendi önbelleğinde tazelik süresi kadar durur — kurgu olarak üç bin altı yüz saniye — ve geçersizleştirme istemciye ulaşmaz. ```js // kenar/dagitim.mjs — model: kenar bir hizmet olarak kiralandiginda ne degisiyor. Onbellek // mekanigi ve isabet oraninin nasil olustugu daha once olculdu; burada isabet bir eksendir, // taranir. Fiyatlar kurgudur, para biriminin adi "birim"dir. const ISTEK_AY = 4e6, ORT_KB = 40; const VERI = (ISTEK_AY * ORT_KB) / 1e6; // GB const KAYNAK_CIKIS = 9, KENAR_CIKIS = 5, ISTEK_UCRET = 0.4; // birim/GB, birim/GB, birim/10bin const istekUcreti = (n) => (n / 1e4) * ISTEK_UCRET; const fatura = (isabet, kenarVar) => { const inen = Math.round(ISTEK_AY * (1 - isabet)); const kaynakGB = VERI * (kenarVar ? 1 - isabet : 1); return { inen, kaynakGB, kaynak: kaynakGB * KAYNAK_CIKIS, kenar: kenarVar ? VERI * KENAR_CIKIS : 0, istek: kenarVar ? istekUcreti(ISTEK_AY) : 0 }; }; const topla = (f) => f.kaynak + f.kenar + f.istek; const TABAN = topla(fatura(0, false)); const E = [12, 20, 18, 15, 13, 13, 15]; const yaz = (h) => h.map((d, i) => String(d)[i ? "padStart" : "padEnd"](E[i])).join(""); console.log(yaz(["isabet(%)", "kaynaga inen istek", "kaynak cikisi(GB)", "kaynak ucreti", "kenar ucreti", "istek ucreti", "toplam(birim)"])); const sat = (ad, f) => console.log(yaz([ad, f.inen, f.kaynakGB.toFixed(1), f.kaynak.toFixed(1), f.kenar.toFixed(1), f.istek.toFixed(1), topla(f).toFixed(1)])); sat("kenar yok", fatura(0, false)); for (const p of [0, 40, 60, 67, 80, 90, 95]) sat(String(p), fatura(p / 100, true)); let donus = 100; for (let p = 0; p <= 100; p += 1) if (topla(fatura(p / 100, true)) <= TABAN) { donus = p; break; } console.log(`\nkenar yok fatura ${TABAN.toFixed(1)} birim; kenarin bunu gectigi isabet: %${donus}`); // --- Gecersizlestirmenin maliyeti ----------------------------------------------- // Bir surumde 2400 varlik dosyasi degisti. Onek altinda toplam 18000 nesne var. // Yayilma sureleri, kapsama ve ucretler kurgudur. const DUGUM = 40, KAPSAMA = Math.round(DUGUM / 4), KOTA = 1000, YOL_UCRET = 0.005; const DEGISEN = 2400, ONEK_NESNE = 18000, TAZELIK = 3600; // [yontem, gecersizlestirme istegi, dusen nesne, kenar penceresi, istemci penceresi] const YONTEM = [ ["tek tek yol", DEGISEN, DEGISEN, 90, TAZELIK], ["onek", 1, ONEK_NESNE, 150, TAZELIK], ["surumlu yol", 0, 0, 0, 0], ]; const Y = [14, 16, 14, 18, 20, 14, 16]; const yaz2 = (h) => h.map((d, i) => String(d)[i ? "padStart" : "padEnd"](Y[i])).join(""); console.log("\n" + yaz2(["yontem", "istek", "ucret(birim)", "kenar penceresi", "istemci penceresi", "dusen nesne", "isinma istegi"])); for (const [ad, istek, dusen, kp, ip] of YONTEM) { const ucret = Math.max(0, istek - KOTA) * YOL_UCRET; const isinma = (ad === "surumlu yol" ? DEGISEN : dusen) * KAPSAMA; console.log(yaz2([ad, istek, ucret.toFixed(2), kp, ip, dusen, isinma])); } // --- Devredilen karar: kalem sayimi --------------------------------------------- // [grup, kalem, kimde, yaratilista sabit mi] const KARAR = [ ["anahtar", "yol", "sen", false], ["anahtar", "sorgu parametreleri", "sen", false], ["anahtar", "secilen basliklar", "sen", false], ["anahtar", "cerez", "sen", false], ["tazelik", "tazelik suresi", "sen", false], ["tazelik", "hata aninda eski nesne", "sen", false], ["tazelik", "kenarin tazelik ust siniri", "saglayici", false], ["sikistirma", "acik mi", "sen", false], ["sikistirma", "algoritma ve duzey", "saglayici", false], ["dagitim", "kaynak tanimi", "sen", false], ["dagitim", "dagitim adi", "sen", true], ["dagitim", "dugum sayisi ve yeri", "saglayici", false], ["dagitim", "istemcinin dustugu dugum", "saglayici", false], ["dagitim", "bellek dolunca atilan nesne", "saglayici", false], ["dagitim", "yayilma suresi", "saglayici", false], ]; const G = [14, 10, 9, 15, 20]; const yaz3 = (h) => h.map((d, i) => String(d)[i ? "padStart" : "padEnd"](G[i])).join(""); console.log("\n" + yaz3(["grup", "kalem", "sende", "saglayicida", "yaratilista sabit"])); const gruplar = [...new Set(KARAR.map((k) => k[0]))]; const say = (l) => [l.length, l.filter((k) => k[2] === "sen").length, l.filter((k) => k[2] === "saglayici").length, l.filter((k) => k[3]).length]; for (const g of gruplar) console.log(yaz3([g, ...say(KARAR.filter((k) => k[0] === g))])); console.log(yaz3(["toplam", ...say(KARAR)])); ``` ``` isabet(%) kaynaga inen istek kaynak cikisi(GB) kaynak ucreti kenar ucreti istek ucreti toplam(birim) kenar yok 4000000 160.0 1440.0 0.0 0.0 1440.0 0 4000000 160.0 1440.0 800.0 160.0 2400.0 40 2400000 96.0 864.0 800.0 160.0 1824.0 60 1600000 64.0 576.0 800.0 160.0 1536.0 67 1320000 52.8 475.2 800.0 160.0 1435.2 80 800000 32.0 288.0 800.0 160.0 1248.0 90 400000 16.0 144.0 800.0 160.0 1104.0 95 200000 8.0 72.0 800.0 160.0 1032.0 kenar yok fatura 1440.0 birim; kenarin bunu gectigi isabet: %67 yontem istek ucret(birim) kenar penceresi istemci penceresi dusen nesne isinma istegi tek tek yol 2400 7.00 90 3600 2400 24000 onek 1 0.00 150 3600 18000 180000 surumlu yol 0 0.00 0 0 0 24000 grup kalem sende saglayicida yaratilista sabit anahtar 4 4 0 0 tazelik 3 2 1 0 sikistirma 2 1 1 0 dagitim 6 2 4 1 toplam 15 9 6 1 ``` #### İki Ayrı Eşik Birinci tablonun ilk satırı taban durumdur: kenar yok, dört milyon isteğin dördü de kaynağa iniyor, yüz altmış GB kaynaktan çıkıyor, fatura **bin dört yüz kırk birim**. İkinci satır kenarı açıyor ve isabeti sıfır tutuyor. Fatura **iki bin dört yüze** çıkıyor — yüzde altmış yedi artış. Nedeni ortadadır: istemciye giden bütün baytlar artık kenardan çıkıyor ve kenar çıkışı bedavaya gelmiyor (sekiz yüz birim), üstüne bir de istek ücreti yazılıyor (yüz altmış birim). Kaynak çıkışı ise hiç azalmadı, çünkü isabet sıfır. Kenarı açmak tek başına bir tasarruf değildir; **iki fatura kalemi eklemektir**. Aşağı inen satırlarda değişen tek kalem kaynak çıkışıdır. Kenar ücreti sekiz yüz birimde, istek ücreti yüz altmış birimde **sabit duruyor** — bu iki kalem isabetten hiç etkilenmiyor. Toplam faturanın eğrisi bu yüzden kaynak eğrisinden farklı: dokuz yüz altmış birimlik bir taban var ve kaynak tasarrufu bu tabanın üstüne biniyor. Dönüş noktası koşumun sonunda hesaplandı: **yüzde altmış yedi**. Bu isabette toplam bin dört yüz otuz beş birim, kenarsız düzenin bin dört yüz kırk biriminin hemen altında. Asıl okuma altmışlık satırdadır. Yüzde altmış isabette kaynağa inen istek dört milyondan **bir milyon altı yüz bine** inmiş; kaynak sunucunun yükü yüzde altmış azalmış, ölçeklemesi rahatlamış, örnek sayısı düşürülebilir durumda. Fatura ise **bin beş yüz otuz altı birim** — kenarsız düzenden hâlâ yüksek. Kaynak yükünü düşürmek ile parayı düşürmek **iki ayrı eşiktir** ve bu modelde ikincisi daha geç geliyor. Dönüş noktasını belirleyen şey iki fiyatın oranıdır. Kenar çıkışı kaynak çıkışının beş bölü dokuzu olduğu için tasarruf edilecek pay kaynak kaleminin yalnız bir bölümüdür. İki fiyat eşit olsaydı dönüş noktası hiç gelmezdi: sabit sekiz yüz artı yüz altmış birim, kaynak tarafında kazanılabilecek en fazla bin dört yüz kırk birimin altında kalmaz. Kararın dayandığı sayı "kenar ucuzdur" değil, **kaç kat ucuz olduğudur**. Yüzde doksanda fatura bin yüz dört birime, yüzde doksan beşte bin otuz iki birime iniyor. Taban düzene göre en iyi tasarruf yaklaşık yüzde yirmi sekizdir ve bunun karşılığında kaynağa inen istek yirmi kat azalmıştır. Kenarın verdiği asıl şey paradan çok **kaynak yükü**dür; para ikincil ve daha geç gelen bir kazançtır. #### Geçersizleştirmenin Görünmeyen Faturası İkinci tablo bir sürüm yayınını ölçüyor: iki bin dört yüz varlık dosyası değişti ve kenardaki eski kopyaların düşmesi gerekiyor. Tek tek yol yöntemi iki bin dört yüz geçersizleştirme isteği gönderiyor. Bin tanesi ücretsiz kota içinde, kalan bin dört yüzü yol başına 0,005 birim: toplam **yedi birim**. Bu, aylık bin dört yüz kırk birimlik faturanın yanında görünmez bir sayıdır. Pencere doksan saniye, düşen nesne iki bin dört yüz. Önek yöntemi tek bir istek gönderiyor ve ücreti **sıfır**. İki sütun yan yana okunduğunda önek her bakımdan üstün görünüyor: iki bin dört yüz istek yerine bir istek, yedi birim yerine sıfır. Son sütun bu görüntüyü bozuyor. Önek altındaki **on sekiz bin nesnenin tamamı** düşüyor, yalnız değişen iki bin dört yüzü değil. Her düşen nesne ortalama on düğümde durduğuna göre ısınma sırasında kaynağa **yüz seksen bin istek** iniyor. Tek tek yol yönteminde bu sayı yirmi dört bindir: yedi buçuk katı fark. Bu sayının büyüklüğü birinci tabloyla karşılaştırınca görünür. Yüzde doksan isabetli bir ayda kaynağa inen toplam istek dört yüz bindi. Tek bir önek geçersizleştirmesi, o ayın kaynak yükünün **yüzde kırk beşini** birkaç dakikaya sıkıştırarak üretiyor. Ücret sıfır, fatura yedi birim değil; fatura kaynak tarafında, ölçekleme grubunun açtığı örneklerde yazılıyor. Önek ayrıca daha yavaş yayılıyor: yüz elli saniyeye karşı doksan saniye. Ucuz görünen yöntem hem daha geniş hem daha yavaş. Üçüncü satır geçersizleştirmeyi tümüyle ortadan kaldırıyor. Sürümlü yolda değişen dosya yeni bir adla yayımlanır; eski ad hiç geçersizleştirilmez, yeni ad zaten kenarda yoktur. Geçersizleştirme isteği sıfır, ücret sıfır, pencere sıfır, düşen nesne sıfır. Isınma isteği yirmi dört bin — yalnız gerçekten değişen iki bin dört yüz dosya için. Bedeli tabloda görünmüyor: eski adlar kenarda ve depoda durmaya devam eder ve bir yerde temizlenmeleri gerekir. #### Geçersizleştirmenin Ulaşamadığı Yer Dördüncü ve beşinci sütun bu dersin en sessiz sayısıdır. Kenar penceresi ilk yöntemde doksan saniyedir: doksan saniye sonra kırk düğümün kırkında da eski kopya gitmiştir. İstemci penceresi ise aynı satırda **üç bin altı yüz saniye**. Kırk kat fark. Sebebi tek cümledir: geçersizleştirme kenara gönderilen bir mesajdır ve istemciye giden bir mesaj yoktur. Bir saatlik tazelikle yayımlanmış bir yanıt istemcinin kendi önbelleğinde bir saat durur ve o süre boyunca istemci hiçbir isteğe çıkmaz. Geçersizleştirmenin kapattığı doksan saniye, gerçek pencerenin kırkta biridir. Bu, kursun **geri alınamayan kalemidir**: yayımlanmış yanıt. Kenardaki kopya bir çağrıyla silinir, istemcideki kopya silinemez. Yanlış bir fiyat, yanlış bir bölge haritası ya da kişiye özel bir yanıt bir saatlik tazelikle çıktıysa, o yanıt bir saat boyunca dolaşımdadır ve bunu durduran bir düğme yoktur. Üçüncü satır tek çözümü gösteriyor: istemci penceresi **sıfır**, çünkü sürümlü yolda yanıtın adı değişir ve istemci elindeki eski adı hiç sormaz. Ama bu da geçmişe dönük değildir — dünkü adla dağıtılmış yanıt bugün de istemcide durmaktadır. Sürümlü yol bundan sonrasını çözer, öncesini çözmez. Kısa tazelik akla gelen ikinci çözümdür ve birinci tabloya bağlanır: tazeliği kısaltmak istemci penceresini daraltır, kenar isabetini düşürür ve isabet yüzde altmış yedinin altına inerse fatura kenarsız düzenin üstüne çıkar. Üç sayı tek düğümde bağlıdır: **tazelik, isabet, fatura.** #### Kenara Ne Devredildi Üçüncü tablo bu kursun sorusunu bu derse uyguluyor. On beş karar kalemi sayıldı: **dokuzu sende**, altısı sağlayıcıda, biri yaratılışta sabit. Anahtar grubunun dördü de sende. Yola, sorgu parametrelerine, seçilen başlıklara ve çereze neyin gireceği kiralanan hizmette bile senin yapılandırma satırındır. Paylaşılan bir önbellekte kişiye özel yanıtın başkasına gitmesi daha önce ölçülmüştü; kenarı hizmet olarak kiralamak o kararı devretmiyor, yalnız yanlışın yayılacağı düğüm sayısını kırka çıkarıyor. Tazelikte üç kalemin ikisi sende. Üçüncüsü — kenarın kendi tazelik üst sınırı — değildir: yazdığın süre bir tavana takılabilir ve o tavan senin kararın değildir. Sıkıştırmada iki kalemin biri sende. Sıkıştırmanın açık olup olmayacağına sen karar veriyorsun, hangi algoritmanın hangi düzeyde uygulanacağına sağlayıcı. Bu ikinci kalem doğrudan birinci tabloya bağlanır: sıkıştırma düzeyi yanıtın bayt boyutunu, bayt boyutu da yüz altmış GB'lik toplamı ve dolayısıyla hem kenar hem kaynak çıkış ücretini belirler. Faturanın çarpanı sağlayıcının seçimindedir. Dağıtım grubunun altı kaleminden yalnız ikisi sende. Düğüm sayısı ve yerleşimi, istemcinin hangi düğüme düştüğü, bellek dolunca hangi nesnenin atıldığı ve yayılmanın ne kadar sürdüğü — dördü de bu dersin ölçtüğü sayıları doğrudan etkiliyor ve dördü de karar dışı. Özellikle atma politikası önemlidir: yüzde altmış yedilik dönüş noktası senin hesabındır, ama o noktaya ulaşıp ulaşmadığını kısmen sağlayıcının bellek yönetimi belirler. Yaratılışta sabitlenen tek kalem dağıtım adıdır. Bir dağıtımın adı sonradan değişmez; değiştirmek yeni bir dağıtım yaratmak ve bir önceki dersin ölçtüğü ad tümleştirmesini yeniden kurmaktır. #### Özet - Kenarı açmak tek başına faturayı bin dört yüz kırk birimden iki bin dört yüze çıkardı: kenar çıkışı ve istek ücreti isabetten bağımsız, dokuz yüz altmış birimlik sabit bir taban ekliyor. - Fatura yüzde altmış yedi isabette dönüyor. Yüzde altmışta kaynağa inen istek dört milyondan bir milyon altı yüz bine düşmüşken fatura hâlâ kenarsız düzenin üstünde: kaynak yükünü düşürmek ile parayı düşürmek iki ayrı eşiktir ve ikincisi daha geç gelir. - Önek geçersizleştirmesi sıfır ücretle bir istek gönderiyor ama on sekiz bin nesne düşürüp kaynağa yüz seksen bin ısınma isteği indiriyor — yüzde doksan isabetli bir ayın kaynak yükünün yüzde kırk beşi. Tek tek yol yedi birim tutuyor ve yirmi dört bin istek üretiyor. - Geçersizleştirme doksan saniyelik kenar penceresini kapatıyor, üç bin altı yüz saniyelik istemci penceresine hiç dokunmuyor. Yayımlanmış yanıt geri çağrılamaz: kursun geri alınamayan kalemi budur ve sürümlü yol yalnız bundan sonrasını çözer. - On beş karar kaleminin dokuzu sende kaldı: anahtarın dördü de, tazeliğin ikisi, sıkıştırmanın biri, dağıtımın ikisi. Sıkıştırma düzeyi sağlayıcıdadır ve faturanın çarpanını o belirler. #### Sonraki Adım Bu dersle birlikte dışarıdan gelen isteğin yolu tamamlandı: adres alanı bölündü, trafik yönlendirildi, filtrelendi, dengelendi, adresi kararlı hâle getirildi ve kenara taşındı. Yolun her adımı **genel ağdan gelen** istemciyi karşılıyor. Ölçüm ağının kendi bileşenleri de birbirine istek gönderiyor. Toplayıcı veri ambarına yazıyor, pano faturalama servisini çağırıyor ve bir de başka bir hesapta duran ortak bir doğrulama servisi var. Bu trafiğin hiçbiri istemci trafiği değil, ama bugün aynı yoldan akıyor: genel adreslerle, genel ağ üzerinden, kenarın ve dengeleyicinin bütün yüzeyini kullanarak. Çıkış ücreti de aynı sütuna yazılıyor. İki ağ birbirine genel ağa hiç çıkmadan bağlanabilir. Sonraki ders bunu ölçer: iki ağı doğrudan eşlemek ile tek bir servisi özel bağlantıyla açmak arasında açılan yüzey kaç kalem farkeder, adres alanları çakıştığında ne olur ve bu kararın hangi bölümü kurulduktan sonra sabit kalır. ### Özel Bağlantı ve Eşleme Source: https://academia.sh/tr/kurslar/bulut-hesaplama-ve-ag/ozel-baglanti-ve-esleme İki ağın birbirine bağlanmasının üç yolu aynı iş yükünde sayılır: eşleme erişilebilir kalemi bire karşı üç yüz seksen dörde çıkarır ve hiçbir kararı devretmez, özel bağlantı kalemi birde tutar ama altı kalemden dördünü sağlayıcıya verir; yedi ağlık bir adres planında yirmi bir çiftin dördü çakışma yüzünden eşlenemez ve düzeltmesi üç ağın yeniden adreslenmesidir; eşlemenin geçişli olmaması yüzünden on iki ağ için gereken altmış altı eşleme altı yüz altmış yönlendirme satırı ister. Bir önceki ders içeriği kenara taşıdı ve dışarıdan gelen isteğin yolunu tamamladı. Bütün bu yol tek bir yöne bakıyor: genel ağdan gelen istemciye. Kurgu bölgesel ölçüm ağının kendi bileşenleri de birbirine istek gönderiyor. Toplayıcı ağı veri ambarına yazıyor, pano başka bir hesapta duran ortak doğrulama servisini çağırıyor. Bu trafiğin hiçbiri istemci trafiği değil — ama bugün istemci trafiğiyle aynı yoldan akıyor: genel adreslerle, genel ağ üzerinden, geçidin ve kenarın bütün yüzeyini kullanarak. İki ağ birbirine genel ağa hiç çıkmadan bağlanabilir. **Eşleme** iki ağı doğrudan bağlar, **özel bağlantı** yalnız bir hizmeti tek bir uç üzerinden açar. Bu ders üçünü aynı iş yükünde karşılaştırır ve kursun sorusunu son kez sorar. - **BA49.** Kurgu ölçüm ağının bileşenleri ayrı ağlarda durur; dönemlik akış hacmi iki bin dört yüz birimdir. Karşı ağda doksan altı örnek vardır ve her örnek dört kapı dinler. Kendi tarafımızda beş yönlendirme tablosu vardır. - **BA50.** Gecikme değerleri kurgu model sabitidir: genel uç on dört, eşleme iki, özel bağlantı üç milisaniye. Model süre ölçmez, sabitleri yazar. - **BA51.** Fiyatlar kurgudur, para biriminin adı **birim**dir: genel çıkış yüz hacim başına iki birim, ağlar arası özel yol bir birim, özel bağlantı ucunun dönemlik kirası yirmi beş birim. Merkezî geçiş katmanı dönemde yüz yirmi birim sabit artı bağlantı başına otuz birimdir. - **BA52.** Yedi ağın adres blokları kurgudur ve hepsi özel aralıklardadır; adres aritmetiği gerçektir. Yeniden adreslemenin bin altı yüz dört birimlik bedeli bu konunun ilk dersinden girdi olarak gelir. - **BA53.** Eşleme geçişli değildir: bir eşleme yalnız iki ucunu birbirine ulaştırır. Yeniden adreslenecek ağ açgözlü seçilir — en çok çakışan ağ önce taşınır. ```js // baglanti/aglar-arasi.mjs — model: iki agin birbirine baglanma yollari. Kurgu bolgesel olcum // agi; gercek ag kurulmuyor, adres aritmetigi gercektir. Fiyatlar kurgudur, birimin adi "birim". const KARSI_ORNEK = 96, KAPI = 4, TABLO = 5, HACIM = 2400; // [yol, erisilebilen kalem, gecikme(ms), 100 hacim basina birim, donemlik sabit, // yonlendirme satiri, filtre kurali, dis kayit] const YOL = [ ["genel uc", 1, 14, 2.0, 0, 0, 2, 1], ["esleme", KARSI_ORNEK * KAPI, 2, 1.0, 0, TABLO, 2, 0], ["ozel baglanti", 1, 3, 1.0, 25, 0, 1, 0], ]; // [karar kalemi, genel uc, esleme, ozel baglanti] const KARAR = [ ["hangi araliga yol yazilir", "sen", "sen", "saglayici"], ["karsi tarafta hangi hizmete erisilir", "karsi taraf", "sen", "saglayici"], ["trafigin hangi yonde baslayabilecegi", "sen", "sen", "saglayici"], ["cikis adresinin karsi tarafta kayitli olmasi", "sen", "yok", "yok"], ["ad cozumlemesi", "sen", "sen", "saglayici"], ["filtre kurallari", "sen", "sen", "sen"], ["adres alanlarinin cakismamasi", "yok", "sen", "yok"], ["ucun yerlestigi alt ag", "yok", "yok", "sen"], ]; const elde = (i) => KARAR.filter((k) => k[i + 1] === "sen").length; const devir = (i) => KARAR.filter((k) => ["saglayici", "karsi taraf"].includes(k[i + 1])).length; const E = [15, 17, 13, 15, 13, 8, 13]; const yaz = (h) => h.map((d, i) => String(d)[i ? "padStart" : "padEnd"](E[i])).join(""); console.log(yaz(["yol", "erisilebilen kalem", "gecikme(ms)", "donemlik birim", "kural+satir", "elde", "devredilen"])); YOL.forEach(([ad, kalem, ms, oran, sabit, satir, filtre, kayit], i) => console.log(yaz([ad, kalem, ms, ((HACIM / 100) * oran + sabit).toFixed(1), satir + filtre + kayit, elde(i), devir(i)]))); // --- Adres alani cakismasi: eslemenin geri alinamayan kalemi --------------------- // Yedi agin bloklari kurgudur, hepsi ozel araliktadir; adres aritmetigi gercektir. const toInt = (ip) => ip.split(".").reduce((a, o) => a * 256 + Number(o), 0); const blok = (c) => { const [ip, e] = c.split("/"); const b = 2 ** (32 - Number(e)); const bas = Math.floor(toInt(ip) / b) * b; return { bas, son: bas + b - 1 }; }; const kesisir = (a, b) => a.bas <= b.son && b.bas <= a.son; const AG = [["olcum-toplayici", "10.42.0.0/20"], ["veri-ambari", "10.42.16.0/20"], ["ortak-dogrulama", "10.0.0.0/16"], ["saha-birimi", "10.0.0.0/16"], ["is-ortagi-a", "172.31.0.0/16"], ["is-ortagi-b", "172.31.0.0/16"], ["arsiv", "10.42.0.0/16"]].map(([ad, c]) => ({ ad, c, ...blok(c) })); const CIFT = AG.flatMap((a, i) => AG.slice(i + 1).map((b) => [a, b])); const CAKISAN = CIFT.filter(([a, b]) => kesisir(a, b)); const YENIDEN = []; // acgozlu: en cok cakisan ag once tasinir for (let kalan = [...CAKISAN]; kalan.length; ) { const sayac = new Map(); for (const [a, b] of kalan) for (const x of [a, b]) sayac.set(x, (sayac.get(x) ?? 0) + 1); const en = [...sayac.entries()].sort((p, q) => q[1] - p[1] || AG.indexOf(p[0]) - AG.indexOf(q[0]))[0][0]; YENIDEN.push(en); kalan = kalan.filter(([a, b]) => a !== en && b !== en); } const YENIDEN_BIRIM = 1604; // girdi: bu konunun ilk dersinden const A = [18, 17, 17, 10, 20]; const yaz2 = (h) => h.map((d, i) => String(d)[i ? "padStart" : "padEnd"](A[i])).join(""); console.log("\n" + yaz2(["ag", "blok", "eslenebilen ag", "cakisan", "yeniden adreslenir"])); for (const a of AG) { const c = AG.filter((b) => b !== a && kesisir(a, b)).length; console.log(yaz2([a.ad, a.c, AG.length - 1 - c, c, YENIDEN.includes(a) ? "evet" : "hayir"])); } console.log(`\ncift ${CIFT.length}; esleme ${CIFT.length - CAKISAN.length}/${CIFT.length}, ` + `ozel baglanti ${CIFT.length}/${CIFT.length} (adres alani gorunmez)`); console.log(`yeniden adreslenecek ag: ${YENIDEN.length} (${YENIDEN.map((x) => x.ad).join(", ")}) ` + `= ${YENIDEN.length * YENIDEN_BIRIM} birim`); // --- Geciskenlik yok: N ag icin esleme sayisi ----------------------------------- // Bir esleme yalniz iki ucunu birbirine ulastirir; ulasan cift = dogrudan kenar sayisi. const GECIS_SABIT = 120, GECIS_BAGLANTI = 30; // kurgu birim const G = [6, 14, 15, 12, 11, 15, 13, 12]; const yaz3 = (h) => h.map((d, i) => String(d)[i ? "padStart" : "padEnd"](G[i])).join(""); console.log("\n" + yaz3(["ag", "gereken cift", "yildiz ulasan", "tam esleme", "tam satir", "gecis baglanti", "gecis satir", "birim/cift"])); for (const n of [3, 4, 6, 8, 12]) { const cift = (n * (n - 1)) / 2, ucret = GECIS_SABIT + GECIS_BAGLANTI * n; console.log(yaz3([n, cift, n - 1, cift, n * (n - 1) * TABLO, n, (TABLO + 1) * n, (ucret / cift).toFixed(1)])); } ``` ``` yol erisilebilen kalem gecikme(ms) donemlik birim kural+satir elde devredilen genel uc 1 14 48.0 3 5 1 esleme 384 2 24.0 7 6 0 ozel baglanti 1 3 49.0 1 2 4 ag blok eslenebilen ag cakisan yeniden adreslenir olcum-toplayici 10.42.0.0/20 5 1 hayir veri-ambari 10.42.16.0/20 5 1 hayir ortak-dogrulama 10.0.0.0/16 5 1 evet saha-birimi 10.0.0.0/16 5 1 hayir is-ortagi-a 172.31.0.0/16 5 1 evet is-ortagi-b 172.31.0.0/16 5 1 hayir arsiv 10.42.0.0/16 4 2 evet cift 21; esleme 17/21, ozel baglanti 21/21 (adres alani gorunmez) yeniden adreslenecek ag: 3 (arsiv, ortak-dogrulama, is-ortagi-a) = 4812 birim ag gereken cift yildiz ulasan tam esleme tam satir gecis baglanti gecis satir birim/cift 3 3 2 3 30 3 18 70.0 4 6 3 6 60 4 24 40.0 6 15 5 15 150 6 36 20.0 8 28 7 28 280 8 48 12.9 12 66 11 66 660 12 72 7.3 ``` #### Üç Yolun Faturası Birinci tablonun ikinci sütunu bu dersin ana ölçüsüdür: bağlantı kurulduktan sonra kaç kalem erişilebilir hale geliyor. Genel uçta bu sayı **birdir** — karşı tarafın yayımladığı tek uç. Özel bağlantıda da **birdir**. Eşlemede **üç yüz seksen dört**: doksan altı örneğin dört kapısı. Eşleme bir hizmeti değil, bir **ağı** bağlar; hangi hizmete erişileceği artık yönlendirmenin değil, filtre kurallarının işidir. Fatura sütunu beklenmedik. Eşleme en ucuzudur — **yirmi dört birim** — çünkü genel çıkış ücreti yerine ağlar arası ücret yazılır. Genel uç kırk sekiz birim. Özel bağlantı **kırk dokuz birim** ile en pahalısıdır: hacim ücreti eşlemeyle aynıdır, üstüne ucun kirası biner. Üç sayı yan yana okunduğunda düzen çıkıyor: **en ucuz yol en geniş yüzeyi açan yoldur.** Aradaki yirmi beş birim, üç yüz seksen üç kalemin kapatılma fiyatıdır. Kural sayısı da aynı yöne bakıyor. Eşleme yedi kalem yazdırıyor: beş tablonun her birine bir satır ve iki filtre kuralı. Beş satırın hepsi aynı satırdır; dördünü yazıp birini atlamak bir alanın trafiğini sessizce başka yola düşürür. Özel bağlantı **tek kalem** yazdırıyor. #### Devredilen Karar Son iki sütun kursun kendi ölçüsüdür. Genel uçta sekiz karar kaleminden **beşi elde**, biri karşı taraftadır; sağlayıcıya devredilen kalem yoktur. Eşlemede **altı kalem elde**, devredilen **sıfırdır**. Eşleme hiçbir kararı devretmez — hangi aralığa yol yazılacağı, trafiğin yönü, ad çözümlemesi, filtreler ve adres alanlarının çakışmaması, hepsi iki tarafın ortak işidir. Özel bağlantı bunun tersidir: **iki kalem elde, dört kalem sağlayıcıda**. Yol yazılmaz — uç senin bir alt ağında adres alır ve yerel yol onu zaten kapsar. Hangi hizmete erişileceği seçilmez; uç tek bir hizmete bağlıdır. Yön de seçilmez: bağlantı tek yönlüdür, karşı taraf sana bağlanamaz. Elde kalan iki kalem filtre kuralları ile ucun hangi alt ağa yerleşeceğidir. İkincisi bu dersin küçük tuzağıdır: uç bir alt ağda oturur, onun adresini tüketir ve alt ağ sınırı önceki bir dersin geri alınamayan kalemidir. Devir bir kayıp değil takastır: dört kalem gitti, karşılığında üç yüz seksen üç erişilebilir kalem ve beş yönlendirme satırı gitti. #### Adres Alanı Çakışması İkinci tablo eşlemenin **geri alınamayan kalemini** ölçüyor ve bu kursun ilk dersine bağlanıyor. İki ağ eşlenebilmek için adres alanlarının çakışmaması gerekir. Çakışırlarsa aynı adres iki ayrı makineye karşılık gelir ve yönlendirme kararı verilemez. Yedi ağlık kurgu planda yirmi bir çift var ve **dördü eşlenemiyor**. Nedeni tabloda okunuyor. `ortak-dogrulama` ile `saha-birimi` aynı bloğu yazmış; `is-ortagi-a` ile `is-ortagi-b` de öyle. Bunlar hata değil, **varsayılan**: iki ayrı ekip birbirinden habersiz aynı başlangıç değerini bırakmış. Dördüncü çakışma başka türlü: `arsiv` bloğunu bir basamak geniş yazmış ve kendi kurumundaki iki ağı içine almış — tek başına iki çift kaybettiriyor. Çözüm yönlendirmede değildir. Eşleme reddedilir, hiçbir kural onu kabul ettiremez; yapılabilecek tek şey bir tarafı **yeniden adreslemektir**. Model dört çakışmayı kapatmak için üç ağ çıkarıyor: **dört bin sekiz yüz on iki kurgu birim**. Hangi tarafın taşınacağı ayrı bir karardır; ortak bir doğrulama servisini taşımak, bir saha birimini taşımaktan başka bir iştir. Son satır asıl karşılaştırmayı veriyor. Özel bağlantı yirmi bir çiftin **yirmi birini** bağlıyor. Adres alanları hâlâ çakışıyor ama önemi kalmıyor: uç senin alt ağında kendi adresini alır ve karşı ağın alanı sana hiç görünmez. Dört kalemlik devrin karşılığında alınan asıl şey budur. #### Geçişliliğin Olmaması Üçüncü tablo eşlemenin ikinci sınırını sayıyor. Bir eşleme yalnız iki ucunu birbirine ulaştırır: A ile B eşliyse ve B ile C eşliyse, A ile C konuşamaz. Ortadaki ağ bir yol değildir. Yıldız sütunu bunun sonucudur. Altı ağı merkezî bir ağa bağlamak beş eşleme ister ve **beş çift** ulaşır — oysa gereken on beş çifttir. Kurulum bittiğinde her ağ bir yere bağlıdır ve çiftlerin üçte ikisi birbirini bulamaz. Tam ağ eşlemesi bunu çözer ve karesel büyür. Altı ağ için on beş eşleme ve **yüz elli yönlendirme satırı**; on iki ağ için altmış altı eşleme ve **altı yüz altmış satır**. Satır sayısı beş tabloyla çarpılıyor, çünkü her ağın kendi tabloları var. Merkezî geçiş katmanı sayıyı doğrusal yapıyor: on iki ağ için on iki bağlantı, **yetmiş iki satır** ve aynı altmış altı çift. Bedeli son sütunda ve ölçek büyüdükçe düşüyor: üç ağda çift başına yetmiş birim, on iki ağda **yedi virgül üç birim**. #### Özet - Eşleme erişilebilir kalemi bire karşı **üç yüz seksen dörde** çıkarıyor ve yirmi dört birimle en ucuz yol; özel bağlantı kalemi birde tutuyor ve kırk dokuz birimle en pahalısı. Aradaki yirmi beş birim, üç yüz seksen üç kalemin kapatılma fiyatıdır. - Eşleme hiçbir kararı devretmiyor (altı kalem elde, sıfır devir); özel bağlantı dört kalemi sağlayıcıya veriyor ve elde iki kalem bırakıyor — filtre kuralları ile ucun yerleştiği alt ağ. - Yedi ağlık planda yirmi bir çiftin dördü adres çakışması yüzünden eşlenemiyor; düzeltmesi üç ağın yeniden adreslenmesi, dört bin sekiz yüz on iki kurgu birim. Özel bağlantı aynı planda yirmi bir çiftin yirmi birini bağlıyor. - Eşleme geçişli olmadığı için yıldız düzeninde altı ağdan yalnız beş çift ulaşıyor; on iki ağda tam ağ eşlemesi altı yüz altmış yönlendirme satırı isterken merkezî geçiş katmanı yetmiş iki satırla aynı altmış altı çifti bağlıyor. #### Kurs Kapanışı | Ders | Elde kalan karar | Geri alınamayan kalem | Açtığı yüzey ya da bedeli | |---|---|---|---| | Sanal makine örnekleri | 6/11 kalem, aile ve boyut | 3 kalem: mimari, alt ağ, şifreleme | 5,3 saat filo yenileme | | Makine imajları | 6/9 kalem, gömme düzeyi | 3 kalem: yayımlanmış imaj, gömülü sır | 1.161 dakika pişirici | | Kalıcı ve kesintili kapasite | 5/9 kalem, iş türü eşlemesi | 3 kalem: kaydedilmemiş iş | 2,40 kat süre | | Başlatma şablonları | 5/8 kalem, alan varsayılanları | 6 alan: imaj, alt ağ, betik | 11/12 alan geçersiz kılınır | | Otomatik ölçekleme grupları | 6/9 kalem, eşik ve soğuma | 3 kalem: sağlıksız damgası | günde 276 başlatma | | Yönetilen konteyner servisleri | 3/15 kalem, görev ölçeklemesi | 3 kalem: görev tanımı sürümü | 234 saat çıkış | | Sanal özel ağ | 8/12 kalem, önek uzunluğu | 2 kalem: blok ve yeri | 1.604 birim yeniden kurma | | Alt ağlar | 5 kalem, dilim boyu ve alan | 1 kalem: alt ağ sınırı | 6 bileşen, 5 tablo | | Yönlendirme tabloları | 3 kalem, kural genişliği | 490 hacim birimi, yutulan ölçüm | 266 birim yanlış çıkış | | İnternet ve dönüştürme geçitleri | 4 kalem, geçit sayısı ve yeri | 1.848 dış kayıt | %101 bağlantı doluluğu | | Güvenlik grupları ve erişim listeleri | 4 kalem, mekanizma ve sıra | çift kaydedilen ölçüm | 9 kural, 2 kaçan akış | | Yük dengeleyiciler | 9 kalem, katman ve eşik | 1 kalem: dengeleyici katmanı | 7 sonlandırma noktası | | Kalıcı adres ve ad tümleştirmesi | 6 kalem, adres düzeni | bırakılmış adres | 4.875 istek yabancıya | | İçerik dağıtım ağı | 9/15 kalem, önbellek anahtarı | yayımlanmış yanıt | 3.600 saniye istemcide | | Özel bağlantı ve eşleme | 6 kalem eşlemede, 2 özel bağlantıda | adres alanı çakışması | 384 erişilebilir kalem | İkinci sütun bu kursun kuralını yazıyor: **kiralanan katmanda bile kararların bir bölümü sende kalır; bunların hangisinin geri alınamadığını bilmek kiralama kararından daha çok belirler.** Devir oranı en yüksek derste bile üç kalem elde kaldı ve yanında üç geri alınamayan kalem durdu. Üçüncü sütun dört kümeye toplanıyor. **Adres alanı ve sınırı** dört derste: bloğun kendisi, alt ağ sınırı, örneğin yerleştiği alt ağ ve eşlemeyi engelleyen çakışma. **Yaratılışta sabitlenen tanım** dört derste: yayımlanmış imaj, başlangıç betiği, görev tanımı sürümü, dengeleyicinin katmanı. **Dışarıya çıkmış iz** üç derste: geçidin dış kayıtları, bırakılmış adres, yayımlanmış yanıt — üçü de senin denetiminde olmayan bir yerde yaşıyor. **Kaybolan ya da tekrarlanan iş** dört derste: kesilen örneğin kaydedilmemiş işi, sonlandırılan örneğin elindekiler, yutulan ölçüm, çift kayıt. Dört kümenin hiçbiri fatura satırı değildir. On beş dersin hiçbirinde geri alınamayan kalem bir uyarı üretmedi; hepsi kurulum günü sessizce yazıldı, bedeli dönemler sonra ölçüldü. Makine kiralandı, ölçeklendi ve kısmen devredildi; ağ bölündü, yönlendirildi, filtrelendi, dengelendi ve kenara taşındı. Üstlerinde koşan şeyin **verisi** ise hâlâ hiçbir yerde durmuyor; ölçüm kayıtları ve gecelik özetler bu kursta yalnız trafik olarak geçti. **M23/K03 Bulutta Depolama ve Veri** o veriyi ele alır ve aynı soruyu sorar: veri kiralandığında hangi karar devrediliyor, hangi kalem yazıldıktan sonra bir daha değişmiyor?