Sanal Makine Yönetimi

Önceki iki ders koşan bir konuğu ölçtü: altında kaç katman var, konakla kaç kalem paylaşıyor. Sanal makineyi fiziksel makineden ayıran asıl özellik ise koşarken değil, durdurulup kopyalanırken görünüyor. Bir konuk dosyadan ibarettir: anlık görüntüsü alınıp saklanabilir, imajı yirmi dört kez klonlanıp yirmi dört makineye dağıtılabilir, bir hafta önceki durumuna birkaç saniyede dönülebilir. Bu üç işlem yönetimi hafifletir ve hepsi bir sınır kalemi taşır.

Ölçülen şey işlemlerin kolaylığı değil, taşıdıkları kalemdir. Klonda soru şudur: bir imajdan üretilen makineler kaç kalemi ortak taşıyor ve o kalemlerden biri düşerse kaç makineye erişiliyor. Anlık görüntüde soru zincirin uzunluğudur: bir noktaya dönmek kaç halkanın sağlam olmasını istiyor. Geri dönüşte soru kayıptır: dönülen nokta ile bugün arasında kapatılmış olan kaç açık yeniden açılıyor.

SA13 — Kurgu şube parkında tek bir altın imajdan 24 konuk klonlanır; kalem listesi modeldir, sayım gerçektir. SA14 — Sır kalemi, kopyalandığında iki makinede aynı olan gizli değerdir. SA15 — Benzersizleştirme, klonun ilk açılışında bir kalemi yeniden üreten adımdır; bedeli adım ve servis yeniden başlatma sayısıyla yazılır. SA16 — Anlık görüntü zinciri artımlıdır: her halka bir öncekinin üstüne yazılır, bir noktayı açmak taban ile o noktaya kadarki bütün halkaları ister. SA17 — Doğrulayıcı konuğunun çizelgesi 42 gündür; altı anlık görüntü ve altı yama olayı içerir, yama olayları toplam 17 açık kapatır. SA18 — Konuk günde 240 denetim kaydı üretir. SA19 — Konuk üzerinde dört bileşen koşar ve her biri ancak belirli bir hazırlık düzeyinde tutarlı olur; hazırlık düzeyinin bedeli konuğa verilen kesinti saniyesidir.

Klonun Taşıdığı Sır

Bir altın imaj bir kez kurulur, sertleştirilir ve şubelere dağıtılır. İçindeki dosyaların bir bölümü o kuruluma özgü gizli değerlerdir ve klonlama onları da kopyalar.

// klon.mjs — altin imajdan uretilen klonlarin tasidigi sir kalemi (MODEL).
// Kurgu sube parki: tek bir altin imajdan 24 konuk klonlaniyor.
const KLON = 24;
// [kalem, ilk acilista yenileniyor mu, yenilemenin istedigi ek adim, servis yeniden baslatma]
const SIR = [
  ['konak anahtari', true, 1, 1], ['makine kimligi', true, 1, 0],
  ['yonetim ajani belirteci', false, 1, 1], ['gunluk gonderim anahtari', false, 1, 1],
  ['yonetici oturum belirteci onbellegi', false, 1, 0],
  ['yerel yonetici parola ozeti', false, 1, 0], ['sertifika ozel anahtari', false, 2, 1],
];
const s = (x, n) => String(x).padStart(n);
console.log(`altin imaj ${SIR.length} sir kalemi tasiyor; ${KLON} klon uretiliyor`);
console.log(`${'kalem'.padEnd(36)}${s('yenileniyor', 12)}${s('ayni kalan makine', 19)}`);
for (const [ad, y] of SIR)
  console.log(`${ad.padEnd(36)}${s(y ? 'evet' : 'hayir', 12)}${s(y ? 1 : KLON, 19)}`);

const ortak = SIR.filter(([, y]) => !y);
console.log(`\nyenilenen ${SIR.length - ortak.length}, ortak ${ortak.length}; `
  + `ortak kalem-makine cifti ${ortak.length * KLON}`);
console.log(`tek ortak sir kalemi icin gereken kalem 1, erisilen makine ${KLON}`);
const [adim, servis] = ortak.reduce(([a, r], [, , x, y]) => [a + x, r + y], [0, 0]);
console.log(`bes ortak kalemi de yenilemenin bedeli: ${adim} ilk acilis adimi, `
  + `${servis} servis yeniden baslatma, klon basina`);
console.log(`park genelinde ${adim * KLON} adim; yenilenmeyen tek kalem kalirsa erisilen makine `
  + `yine ${KLON}`);

altin imaj 7 sir kalemi tasiyor; 24 klon uretiliyor
kalem                                yenileniyor  ayni kalan makine
konak anahtari                              evet                  1
makine kimligi                              evet                  1
yonetim ajani belirteci                    hayir                 24
gunluk gonderim anahtari                   hayir                 24
yonetici oturum belirteci onbellegi        hayir                 24
yerel yonetici parola ozeti                hayir                 24
sertifika ozel anahtari                    hayir                 24

yenilenen 2, ortak 5; ortak kalem-makine cifti 120
tek ortak sir kalemi icin gereken kalem 1, erisilen makine 24
bes ortak kalemi de yenilemenin bedeli: 6 ilk acilis adimi, 3 servis yeniden baslatma, klon basina
park genelinde 144 adim; yenilenmeyen tek kalem kalirsa erisilen makine yine 24

Yedi kalemin ikisi yenileniyor. Bu ikisi yenileniyor çünkü yenilenmediklerinde sistem görünür biçimde bozulur: iki makinenin makine kimliği aynıysa ağ yönetimi ikisini ayırt edemez, konak anahtarı aynıysa bağlantı istemcileri uyarı verir. Kalan beşi yenilenmiyor çünkü yenilenmediklerinde hiçbir şey bozulmuyor. Yirmi dört makine aynı yönetim ajanı belirtecini, aynı günlük gönderim anahtarını ve aynı sertifika özel anahtarını taşıyor ve park sorunsuz çalışıyor.

Ortak kalem-makine çifti yüz yirmi. Bu sayı hasar değil, yüzeydir. Asıl sayı onun altındadır: bir sır kalemi için sınırı geçmek üzere gereken kalem birdir ve o bir kalem düştüğünde erişilen makine yirmi dörttür. Bir makinenin diskinden okunan tek bir özel anahtar, yirmi dört şubede aynı anahtardır. Klonlama bir yol açmaz; var olan yolun ucundaki makine sayısını yirmi dörde çıkarır.

Bedel sütunu bu kez küçük. Beş kalemi de benzersizleştirmek klon başına altı ilk açılış adımı ve üç servis yeniden başlatma, park genelinde yüz kırk dört adım ister — bir kereye mahsus ve betiklenebilir bir iş. Son satır ise ölçümün en sert yeridir: yenilenmeyen tek bir kalem kalırsa erişilen makine yine yirmi dörttür. Benzersizleştirme kısmi yapılamaz; dördü yenilenip biri unutulduğunda kazanılan sayı sıfırdır.

Anlık Görüntü Zinciri

Anlık görüntü bir kopya değil, bir farktır: her halka bir öncekinin üstüne yazılan değişikliği tutar. Bu, alma işlemini ucuzlatır ve okuma işlemini zincirin uzunluğuna bağlar.

// zincir.mjs — anlik goruntu zinciri ve geri donusun geri getirdigi acik (MODEL).
// Kurgu dogrulayici konugunun 42 gunluk cizelgesi: alti anlik goruntu, alti yama olayi.
const BUGUN = 42, GUNLUK = 240;                 // gunde 240 denetim kaydi
const NOKTA = [['taban', 0], ['ag-1', 3], ['ag-2', 10], ['ag-3', 17],
  ['ag-4', 24], ['ag-5', 31], ['ag-6', 38]];
const YAMA = [[5, 3], [12, 1], [19, 4], [26, 2], [33, 5], [40, 2]];  // [gun, kapatilan acik]
const TABAN_GIB = 40, HALKA_GIB = 1.9;

const acik = (gun) => YAMA.filter(([g]) => g > gun).reduce((t, [, n]) => t + n, 0);
const s = (x, n) => String(x).padStart(n);
console.log(`bugun gun ${BUGUN}; ${NOKTA.length - 1} anlik goruntu, ${YAMA.length} yama olayi, `
  + `kapatilan acik ${acik(0)}`);
console.log(`\n${'donulen nokta'.padEnd(15)}${s('gun', 4)}${s('gereken halka', 15)}`
  + `${s('yeniden acilan acik', 21)}${s('kaybolan gunluk kaydi', 23)}`);
NOKTA.forEach(([ad, gun], i) => {
  console.log(`${ad.padEnd(15)}${s(gun, 4)}${s(i + 1, 15)}${s(acik(gun), 21)}`
    + `${s((BUGUN - gun) * GUNLUK, 23)}`);
});

const halka = NOKTA.length - 1;
console.log(`\nzincir: taban ${TABAN_GIB} GiB + ${halka} halka x ${HALKA_GIB} GiB = `
  + `${(TABAN_GIB + halka * HALKA_GIB).toFixed(1)} GiB; en yeni noktayi acmak ${NOKTA.length} halka okur`);
const BOZUK = 3;                                // ag-3'un deltasi bozuldu
const [ad, gun] = NOKTA[BOZUK - 1];
console.log(`halka ${BOZUK} bozuk -> donulebilen en yeni nokta ${ad} (gun ${gun}), `
  + `yeniden acilan acik ${acik(gun)}, kaybolan kayit ${(BUGUN - gun) * GUNLUK}`);
console.log(`bozuk halkadan sonraki ${NOKTA.length - BOZUK} nokta acilamaz; `
  + `zincirde gereken saglam halka ${NOKTA.length}`);

bugun gun 42; 6 anlik goruntu, 6 yama olayi, kapatilan acik 17

donulen nokta   gun  gereken halka  yeniden acilan acik  kaybolan gunluk kaydi
taban             0              1                   17                  10080
ag-1              3              2                   17                   9360
ag-2             10              3                   14                   7680
ag-3             17              4                   13                   6000
ag-4             24              5                    9                   4320
ag-5             31              6                    7                   2640
ag-6             38              7                    2                    960

zincir: taban 40 GiB + 6 halka x 1.9 GiB = 51.4 GiB; en yeni noktayi acmak 7 halka okur
halka 3 bozuk -> donulebilen en yeni nokta ag-2 (gun 10), yeniden acilan acik 14, kaybolan kayit 7680
bozuk halkadan sonraki 4 nokta acilamaz; zincirde gereken saglam halka 7

Üçüncü sütun zincirin fiyatını yazıyor: en yeni noktaya dönmek yedi halkanın yedisinin de sağlam olmasını istiyor. Bu sayı yalıtımda iyi, dayanıklılıkta kötüdür — bir sınırı geçmek için gereken kalemin çok olması istenir, bir kurtarma noktasını açmak için gereken halkanın çok olması istenmez. Anlık görüntü zinciri uzadıkça geri dönüş kolaylaşmaz, tek bir noktaya daha çok bağlanır.

Dördüncü sütun geri dönüşün asıl bedelidir. Kırk iki günde altı yama olayı on yedi açık kapattı. Tabana dönmek bu on yedisini de yeniden açar; gün 38’deki noktaya dönmek yalnız ikisini. Aradaki fark bir tercih değil, bir çizelge sorunudur: yama gün 40’ta yapıldı, en yakın anlık görüntü gün 38’de alındı. Geri dönüşün maliyeti dönülen noktanın yaşı değil, o nokta ile bugün arasında kaç yama olayı kaldığıdır.

Beşinci sütun daha sessiz bir kalem sayıyor. Geri dönüş yalnız açığı geri getirmez, dönülen nokta ile bugün arasında üretilmiş denetim kayıtlarını da siler. Tabana dönmek 10.080 kaydı, gün 38’e dönmek 960 kaydı götürür. Bir olayın ardından temiz bir duruma dönmek, o olayın izini taşıyan kayıtları da silmek anlamına gelir — bu yüzden geri dönüşten önce kayıtların konuk dışına kopyalanması ayrı bir adımdır.

Son iki satır zincirin kırılganlığını gösteriyor. Üçüncü halka bozulduğunda ondan sonraki dört noktanın dördü de açılamaz hâle geliyor. Dönülebilen en yeni nokta otuz iki gün geriye, gün 10’a düşüyor; yeniden açılan açık ikiden on dörde çıkıyor, kaybolan kayıt 960’tan 7.680’e. Yedi kurtarma noktası vardı, tek bir bozuk halka bunların dördünü aynı anda götürdü. Zincirdeki nokta sayısı bağımsız kurtarma noktası sayısı değildir.

Anlık Görüntünün Tutarlı Olduğu An

Zincir tablosu her noktayı bir “durum” gibi saydı. Bu, sorulmamış bir soruyu içeriyor: anlık görüntü alındığı anda konuk koşuyordu ve konak diskin o anki hâlini aldı. Diskte olan ile bileşenlerin bellekte tuttuğu hâl aynı an değildir.

// tutarlilik.mjs — anlik goruntunun tutarli oldugu an ile bilesenlerin tutarli oldugu an (MODEL).
// Konak duzeyinde alinan anlik goruntu diskin o anki halini alir; bellekte bekleyen yazma diskte yok.
// [bilesen, tutarli olmasi icin gereken hazirlik duzeyi, geri yuklemede elle kurtarma adimi]
const BILESEN = [['dosya sistemi ust verisi', 1, 1], ['dosya kuyrugu', 1, 1],
  ['veritabani sayfalari', 2, 3], ['bellekteki uygulama durumu', 3, 2]];
// [hazirlik duzeyi, ad, konuga verdigi kesinti (saniye)]
const DUZEY = [[0, 'hicbir hazirlik', 0], [1, 'konuk icinde yazma bosaltma', 0.4],
  [2, 'uygulama duraklatma', 3.2], [3, 'konuk durdurma', 95]];

const s = (x, n) => String(x).padStart(n);
console.log(`${'hazirlik'.padEnd(30)}${s('tutarli', 8)}${s('yarim', 7)}${s('kesinti sn', 12)}`
  + `${s('elle kurtarma adimi', 21)}`);
for (const [d, ad, sn] of DUZEY) {
  const yarim = BILESEN.filter(([, g]) => g > d);
  console.log(`${ad.padEnd(30)}${s(`${BILESEN.length - yarim.length}/${BILESEN.length}`, 8)}`
    + `${s(yarim.length, 7)}${s(sn.toFixed(1), 12)}${s(yarim.reduce((t, [, , a]) => t + a, 0), 21)}`);
}
const tam = DUZEY.find(([d]) => BILESEN.every(([, g]) => g <= d));
console.log(`\ndort bilesenin dordu ancak "${tam[1]}" ile tutarli; kesinti ${tam[2]} saniye`);
console.log(`hazirliksiz anlik goruntu ${BILESEN.filter(([, g]) => g > 0).length} kalemi yarim birakir; `
  + `alma islemi yine de basarili doner`);

hazirlik                       tutarli  yarim  kesinti sn  elle kurtarma adimi
hicbir hazirlik                    0/4      4         0.0                    7
konuk icinde yazma bosaltma        2/4      2         0.4                    5
uygulama duraklatma                3/4      1         3.2                    2
konuk durdurma                     4/4      0        95.0                    0

dort bilesenin dordu ancak "konuk durdurma" ile tutarli; kesinti 95 saniye
hazirliksiz anlik goruntu 4 kalemi yarim birakir; alma islemi yine de basarili doner

Birinci satır dersin en yanıltıcı satırıdır: kesinti sıfır, alma işlemi başarılı döner ve dört bileşenin dördü de yarımdır. Konak, konuğun içinde ne olup bittiğini görmez; diskin o anki hâlini kopyalar ve işlemi tamamlanmış sayar. Konuk düzeyinde yazma boşaltma iki bileşeni tutarlı hâle getiriyor ve bunun bedeli 0,4 saniye. Veritabanı sayfaları ancak uygulamanın duraklatılmasıyla, bellekteki uygulama durumu ancak konuğun durdurulmasıyla tutarlı oluyor — doksan beş saniyelik bir kesinti karşılığında.

Sağ sütun farkı geri yükleme tarafında yazıyor: hazırlıksız alınan bir anlık görüntüden dönüldüğünde yedi elle kurtarma adımı gerekir, uygulama duraklatılarak alınandan dönüldüğünde iki. Anlık görüntünün tutarlı olduğu an konak için diskin dondurulduğu andır; veri katmanı için ise ancak bekleyen yazmaların diske indiği andır ve bu ikisi hazırlık yapılmadıkça aynı an değildir.

Sınırın Üç Sütunu

Bu dersin sınırı yönetim işlemlerinin çizdiği sınırdır ve üç sütunu şöyle doldurur. Sınırın adı klon ve anlık görüntü sınırıdır. Sınırı geçmek için gereken kalem sayısı birdir: yirmi dört makinede ortak duran beş sır kaleminden herhangi biri. Sınır düştüğünde erişilen kalem sayısı yirmi dört makinedir — klonlama, tek kalemin arkasındaki makine sayısını çarpan işlemdir.

Anlık görüntü bu tabloya ikinci bir satır ekliyor ve o satırda sayı ters yönde çalışıyor. Bir noktayı açmak için gereken sağlam halka yedidir; bu bir yalıtım kazancı değil, bir dayanıklılık borcudur. Geri dönüş ise sınırın geçilmesini değil, daha önce kapatılmış sınırların yeniden açılmasını sağlar: on yedi açığa kadar geriye gidilebilir ve bu, hiçbir kaçış yolu kullanılmadan yapılır.

Üç ölçümün ortak yanı, hepsinin yönetimi kolaylaştıran işlemler olmasıdır. Klonlama yirmi dört makineyi bir imajdan kurar, anlık görüntü bir haftalık işi bir dosyaya sığdırır, geri dönüş bozulan bir sistemi saniyeler içinde çalışır hâle getirir. Üçünün de sınır kalemi aynı yerden gelir: bir makinenin durumunun kopyalanabilir bir nesne hâline gelmesi. O nesne kopyalandığında içindeki sır da kopyalanır, saklandığında o andaki yama düzeyi de saklanır, geri yüklendiğinde o düzeye dönülür.

Özet

• Altın imajdaki yedi sır kaleminin ikisi ilk açılışta yenilenir, beşi yirmi dört klonda aynı kalır; ortak kalem-makine çifti 120’dir.
• Bir ortak sır kalemi için sınırı geçmek üzere gereken kalem birdir ve erişilen makine yirmi dörttür; yenilenmeyen tek kalem kalırsa bu sayı yine yirmi dörttür.
• Beş kalemi de benzersizleştirmenin bedeli klon başına altı ilk açılış adımı ve üç servis yeniden başlatma, park genelinde 144 adımdır.
• Yedi noktalı artımlı zincirde en yeni noktayı açmak yedi halkanın sağlam olmasını ister; üçüncü halka bozulduğunda dört nokta birden açılamaz hâle gelir.
• Geri dönüş dönülen nokta ile bugün arasındaki yamaları geri alır: tabana dönmek 17 açığı yeniden açar ve 10.080 denetim kaydını siler, gün 38’e dönmek 2 açığı açar ve 960 kaydı siler.
• Hazırlıksız alınan anlık görüntüde dört bileşenin dördü yarımdır ve geri yükleme yedi elle adım ister; dördünün de tutarlı olması konuğun durdurulmasını ve 95 saniyelik kesintiyi ister.

Sonraki Adım

Buraya kadarki üç ders aynı soruyu tek bir teknolojide sordu: konuk sistemin sınırı nerede, kaç kalemle geçiliyor, geçilirse neye erişiliyor. Aynı iş için ikinci bir yol daha var ve o yolda konuk sistem hiç yok: aynı çekirdeğin üzerinde birbirinden ayrılmış süreçler koşuyor. İki yol aynı işi yapıyorsa aynı ölçüyle karşılaştırılabilir. Sonraki ders bunu yapar: aynı sekiz hedef için sınırı geçmek üzere gereken kalem sayısı konuk sistemde kaç, aynı çekirdeği paylaşan bölmede kaç; paylaşılan çekirdek kaç kalem paylaşımı demek ve iki sayının farkı nereden geliyor.