---
title: 'Sanal Makine Yönetimi'
source: 'https://academia.sh/tr/kurslar/bt-temelleri/sanal-makine-yonetimi'
course: 'Bilgi Teknolojileri ve Sistem Temelleri'
language: tr
updated: '2026-08-17T18:08:39+00:00'
license: 'CC BY-SA 4.0'
---

# Sanal Makine Yönetimi

Klonlama ve anlık görüntünün sınır kalemi cinsinden ölçülmesi: altın imajdaki yedi sır kaleminin kaçının ilk açılışta yenilendiği ve kaçının bütün klonlarda aynı kaldığı, benzersizleştirmenin adım bedeli, yedi noktalı anlık görüntü zincirinde her noktaya dönmek için gereken sağlam halka sayısı, geri dönüşün yeniden açtığı açık ve sildiği denetim kaydı.

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

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

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

## Klonun Taşıdığı Sır

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

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

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

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

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

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

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

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

## Anlık Görüntü Zinciri

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

## Özet

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

## Sonraki Adım

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