---
title: 'Yedekleme ve Dayanıklılık'
source: 'https://academia.sh/tr/kurslar/bt-temelleri/yedekleme-ve-dayaniklilik'
course: 'Bilgi Teknolojileri ve Sistem Temelleri'
language: tr
updated: '2026-08-17T18:08:39+00:00'
license: 'CC BY-SA 4.0'
---

# Yedekleme ve Dayanıklılık

Anlık görüntü ile yedeğin aynı yedi kayıp senaryosunda koşturulması: anlık görüntünün üç senaryoda 8/8, yedeğin yedi senaryoda 6/8 kalem getirmesi, ikisinin birlikte 56 kalemin 48'ini kurtarması, tam, artımlı ve ayrımsal yedekte bir dosya bozulduğunda kaybolan nokta sayısının 1, 18 ve 1 olması ve depolamanın 1.120, 91,3 ve 758,2 GiB'a ayrılması.

Dört ders boyunca sınır hep aynı yönden ölçüldü: birinin sınırı geçmesi durumunda ne olacağı. Sınırın
düşmesinin tek yolu bu değil. Bir depolama birimi arızalanır, bir konuk yanlışlıkla silinir, bir
konak açılmaz hâle gelir — sınırı geçen kimse yoktur, yine de konuk kaybolur. Sanallaştırmanın bu
soruya iki karşılığı var ve ikisi de "geri getirir" diye anılıyor: **anlık görüntü** ve **yedek**.

İkisi aynı şeyi getirmiyor. Anlık görüntü konakta, konuk imajının durduğu depolama biriminin üzerinde
durur ve saklaması kısadır; yedek konak dışında durur, saklaması uzundur ve kapsamı bir listeyle
sınırlıdır. Bu ders ikisini aynı yedi senaryoda koşturup **kurtarılan ve kurtarılamayan kalemi ayrı
ayrı** sayar.

**SA26 — Kurgu doğrulayıcı konuğu sekiz kalem taşır.** **SA27 — Anlık görüntü konakta, konuk
imajının depolama biriminde durur**; saklama 7 gün, alım aralığı 1 saattir. **SA28 — Yedek konak
dışında durur**; saklama 90 gün, alım aralığı 24 saattir. **SA29 — Yedeğin kapsamı dışında iki kalem
vardır**: yerel sırlar ve bellekteki oturum durumu; bu kapsam boşluğu Sunucu Yönetimi ve
Sertleştirme kursunda ölçülmüştü, burada girdidir. **SA30 — Bir yöntem, o senaryoda çalışıyorsa
kapsamındaki bütün kalemleri getirir.** **SA31 — Yedek zinciri 28 günlük bir penceredir**; boyutlar
kurgudur.

## Aynı Kayıp Senaryosunda İki Yöntem

```js
// kayip.mjs — ayni kayip senaryolarinda anlik goruntu ile yedek: kurtarilan ve kurtarilamayan kalem.
// Kurgu dogrulayici konugu 8 kalem tasir. Kapsam bosluklari onceki kurstan girdidir.
const KALEM = ['isletim sistemi kok dosyalari', 'uygulama ikilileri', 'yapilandirma',
  'veritabani sayfalari', 'is emri kuyrugu', 'denetim gunlugu', 'yerel sirlar', 'bellekteki oturum durumu'];
const DISI = ['yerel sirlar', 'bellekteki oturum durumu'];       // yedegin kapsami disinda
const ANLIK = { kapsam: KALEM.length, saklama: 7, pencere: 1 };   // konakta, ayni depolama biriminde
const YEDEK = { kapsam: KALEM.length - DISI.length, saklama: 90, pencere: 24 };
// [senaryo, kaybin yasi (gun), depolama birimi kayboldu, konak kayboldu, konuk nesnesi silindi]
const SENARYO = [
  ['konuk dosya sisteminin bozulmasi', 0, false, false, false],
  ['yanlis yapilandirma (2 saat once)', 0, false, false, false],
  ['konuk icindeki dosyalarin sifrelenmesi', 0, false, false, false],
  ['30 gun once silinen kayit', 30, false, false, false],
  ['depolama biriminin kaybi', 0, true, false, false],
  ['konak makinenin kaybi', 0, false, true, false],
  ['yonetim arayuzunden silinen konuk', 0, false, false, true],
];
const anlikOk = ([, yas, b, k, s]) => !b && !k && !s && yas <= ANLIK.saklama;
const yedekOk = ([, yas]) => yas <= YEDEK.saklama;

const s = (x, n) => String(x).padStart(n);
console.log(`${KALEM.length} kalem; anlik goruntu kapsami ${ANLIK.kapsam}, saklama ${ANLIK.saklama} gun; `
  + `yedek kapsami ${YEDEK.kapsam}, saklama ${YEDEK.saklama} gun`);
console.log(`\n${'senaryo'.padEnd(40)}${s('anlik goruntu', 15)}${s('yedek', 8)}${s('en iyisi', 10)}`);
let a = 0, y = 0, en = 0;
for (const sen of SENARYO) {
  const ka = anlikOk(sen) ? ANLIK.kapsam : 0, ky = yedekOk(sen) ? YEDEK.kapsam : 0;
  a += ka; y += ky; en += Math.max(ka, ky);
  console.log(`${sen[0].padEnd(40)}${s(`${ka}/${KALEM.length}`, 15)}${s(`${ky}/${KALEM.length}`, 8)}`
    + `${s(`${Math.max(ka, ky)}/${KALEM.length}`, 10)}`);
}
const T = SENARYO.length * KALEM.length;
console.log(`${'toplam'.padEnd(40)}${s(`${a}/${T}`, 15)}${s(`${y}/${T}`, 8)}${s(`${en}/${T}`, 10)}`);
console.log(`\nanlik goruntu ${SENARYO.filter(anlikOk).length}/${SENARYO.length} senaryoda calisir, `
  + `calistiginda ${ANLIK.kapsam}/${KALEM.length} kalem getirir`);
console.log(`yedek ${SENARYO.filter(yedekOk).length}/${SENARYO.length} senaryoda calisir, `
  + `her seferinde ${DISI.length} kalem kapsam disi: ${DISI.join(', ')}`);
console.log(`ikisi birlikte ${en}/${T}; kurtarilamayan ${T - en} kalem`);
console.log(`veri kaybi penceresi: anlik goruntu ${ANLIK.pencere} saat, yedek ${YEDEK.pencere} saat`);
```

```
8 kalem; anlik goruntu kapsami 8, saklama 7 gun; yedek kapsami 6, saklama 90 gun

senaryo                                   anlik goruntu   yedek  en iyisi
konuk dosya sisteminin bozulmasi                    8/8     6/8       8/8
yanlis yapilandirma (2 saat once)                   8/8     6/8       8/8
konuk icindeki dosyalarin sifrelenmesi              8/8     6/8       8/8
30 gun once silinen kayit                           0/8     6/8       6/8
depolama biriminin kaybi                            0/8     6/8       6/8
konak makinenin kaybi                               0/8     6/8       6/8
yonetim arayuzunden silinen konuk                   0/8     6/8       6/8
toplam                                            24/56   42/56     48/56

anlik goruntu 3/7 senaryoda calisir, calistiginda 8/8 kalem getirir
yedek 7/7 senaryoda calisir, her seferinde 2 kalem kapsam disi: yerel sirlar, bellekteki oturum durumu
ikisi birlikte 48/56; kurtarilamayan 8 kalem
veri kaybi penceresi: anlik goruntu 1 saat, yedek 24 saat
```

İki sütun iki farklı biçimde eksik. Anlık görüntü **çalıştığı yerde tam**, çalışmadığı yerde
sıfırdır: üç senaryoda sekiz kalemin sekizini getirir, dört senaryoda hiçbirini. Sıfırların hepsi
aynı sebepten gelir — anlık görüntü kaybolan şeyin **yanında** durur. Depolama birimi, konak ya da
konuk nesnesi gittiğinde anlık görüntüler de gider; otuz gün önceki kayıt ise yedi günlük saklamanın
dışındadır.

Yedek **her yerde eksik**: yedisinde de çalışır ve her seferinde altı kalem getirir. Kaçırdığı iki
kalem adıyla yazılıdır — yerel sırlar ve bellekteki oturum durumu — ve senaryodan bağımsız olarak
kapsam dışıdır. **Anlık görüntünün eksiği koşula bağlıdır, yedeğinki kapsama.**

Alt satırlar toplamı veriyor: anlık görüntü 24/56, yedek 42/56, her senaryoda iyisi seçildiğinde
48/56. İki yöntem birbirinin yerine geçmiyor, birbirinin boşluğunu dolduruyor — ama kalan sekiz kalem
hiçbir düzende gelmiyor ve hepsi anlık görüntünün çalışmadığı dört senaryodaki kapsam dışı
kalemlerdir. Bunun üstüne veri kaybı penceresi eklenir: anlık görüntü bir, yedek yirmi dört saat.

## Zincir Bozulduğunda Dönülebilen Nokta

Yedek de tek bir dosya değildir. Her gün tam kopya almak en pahalı düzendir; artımlı ve ayrımsal
düzenler maliyeti düşürür ve karşılığında noktaları birbirine bağlar.

```js
// yedekzincir.mjs — tam, artimli ve ayrimsal yedekte zincir bozuldugunda donulebilen nokta (MODEL).
// 28 gunluk pencere; gun 0'da tam yedek, sonraki her gun bir nokta. Boyutlar kurgudur.
const GUN = 28, TAM_GIB = 40, DELTA_GIB = 1.9, BOZUK = 10;

// nokta d'yi acmak icin gereken dosyalar (gun numaralari)
const GEREKEN = {
  tam: (d) => [d],
  artimli: (d) => Array.from({ length: d + 1 }, (_, i) => i),
  ayrimsal: (d) => (d === 0 ? [0] : [0, d]),
};
const BOYUT = {
  tam: () => GUN * TAM_GIB,
  artimli: () => TAM_GIB + (GUN - 1) * DELTA_GIB,
  ayrimsal: () => TAM_GIB + DELTA_GIB * ((GUN - 1) * GUN) / 2,
};
const kayip = (tur, bozuk) => Array.from({ length: GUN }, (_, d) => d)
  .filter((d) => GEREKEN[tur](d).includes(bozuk));

const s = (x, n) => String(x).padStart(n);
console.log(`${GUN} gun, gun 0'da tam yedek; tam ${TAM_GIB} GiB, gunluk delta ${DELTA_GIB} GiB`);
console.log(`\n${'tur'.padEnd(11)}${s('dosya', 6)}${s('nokta basina dosya', 20)}`
  + `${s(`gun ${BOZUK} bozuk: kayip`, 22)}${s('donulebilen en yeni', 21)}${s('depolama GiB', 14)}`);
for (const tur of Object.keys(GEREKEN)) {
  const n = Array.from({ length: GUN }, (_, d) => GEREKEN[tur](d).length);
  const k = kayip(tur, BOZUK);
  const saglam = Array.from({ length: GUN }, (_, d) => d).filter((d) => !k.includes(d));
  console.log(`${tur.padEnd(11)}${s(GUN, 6)}${s(n[0] === n[GUN - 1] ? n[0] : `${Math.min(...n)}-${Math.max(...n)}`, 20)}`
    + `${s(`${k.length} nokta`, 22)}${s(`gun ${Math.max(...saglam)}`, 21)}${s(BOYUT[tur]().toFixed(1), 14)}`);
}
console.log(`\ntam yedek (gun 0) bozulursa kaybolan nokta: `
  + Object.keys(GEREKEN).map((t) => `${t} ${kayip(t, 0).length}`).join(', '));
console.log(`ayrimsal, artimliya gore ${(BOYUT.ayrimsal() / BOYUT.artimli()).toFixed(1)} kat depolama ister`
  + ` ve gun ${BOZUK} bozuldugunda ${kayip('artimli', BOZUK).length - kayip('ayrimsal', BOZUK).length}`
  + ' nokta daha kurtarir');
```

```
28 gun, gun 0'da tam yedek; tam 40 GiB, gunluk delta 1.9 GiB

tur         dosya  nokta basina dosya   gun 10 bozuk: kayip  donulebilen en yeni  depolama GiB
tam            28                   1               1 nokta               gun 27        1120.0
artimli        28                1-28              18 nokta                gun 9          91.3
ayrimsal       28                 1-2               1 nokta               gun 27         758.2

tam yedek (gun 0) bozulursa kaybolan nokta: tam 1, artimli 28, ayrimsal 28
ayrimsal, artimliya gore 8.3 kat depolama ister ve gun 10 bozuldugunda 17 nokta daha kurtarir
```

Üç türün nokta sayısı aynı: yirmi sekiz. Fark noktaların birbirine ne kadar bağlı olduğudur. Tam
düzende her nokta bir dosyadır ve bir dosyanın bozulması yalnız o noktayı götürür. Artımlı düzende
gün 27'yi açmak yirmi sekiz dosyanın yirmi sekizini ister; gün 10'daki tek dosya bozulduğunda on
sekiz nokta birden gider ve dönülebilen en yeni nokta gün 9'a düşer. Ayrımsal düzende her nokta iki
dosyadır ve gün 10'un bozulması yalnız gün 10'u götürür.

Depolama sütunu takası yazıyor: 1.120, 91,3 ve 758,2 GiB. Artımlı düzen en ucuzu ve en kırılganıdır;
ayrımsal düzen 8,3 kat depolama karşılığında aynı bozulmada on yedi nokta daha kurtarır. **Yedek türü
bir depolama kararı gibi görünür; ölçüldüğünde bir bağımlılık kararı olduğu çıkar.** Üçünün ortak
zayıflığı son satırdadır: tam yedeğin kendisi bozulursa artımlı ve ayrımsal düzenlerde yirmi sekiz
noktanın yirmi sekizi birden gider.

## Kopyanın Nerede Durduğu

Zincir bağımlılığı ölçüldü; kopyanın **nerede** durduğu ayrı bir sayıdır. Aynı senaryolar bu kez
kopya kümesi üzerinde koşuyor.

```js
// kopya.mjs — kopya dagilimi: hangi senaryoda kac kopya hayatta kaliyor (MODEL).
// [ad, konum, cevrimici mi, ayni yonetim kimligiyle silinebilir mi, kurtarma dakikasi]
const KOPYA = [
  ['konak anlik goruntusu', 'konak', true, true, 8],
  ['sube sunucusunda yedek', 'sube', true, true, 45],
  ['merkez nesne deposunda yedek', 'merkez', true, true, 210],
  ['merkezde cevrimdisi kopya', 'merkez', false, false, 720],
];
const SENARYO = [
  ['konak makinenin kaybi', (k) => k[1] === 'konak'],
  ['sube tesisinin kaybi', (k) => k[1] === 'konak' || k[1] === 'sube'],
  ['merkez nesne deposunun kaybi', (k) => k[1] === 'merkez' && k[2]],
  ['yonetim kimliginin ele gecirilmesi', (k) => k[3]],
  ['konuk icindeki dosyalarin sifrelenmesi', () => false],
];
const kalan = (liste, yiten) => liste.filter((k) => !yiten(k));
const s = (x, n) => String(x).padStart(n);
console.log(`${'senaryo'.padEnd(40)}${s('kalan', 7)}   en hizli kurtarma`);
let enkotu = KOPYA.length;
for (const [ad, yiten] of SENARYO) {
  const k = kalan(KOPYA, yiten);
  const hizli = k.length ? k.reduce((a, b) => (b[4] < a[4] ? b : a)) : null;
  enkotu = Math.min(enkotu, k.length);
  console.log(`${ad.padEnd(40)}${s(`${k.length}/${KOPYA.length}`, 7)}   `
    + (hizli ? `${hizli[0]} (${hizli[4]} dk)` : 'yok'));
}
const konum = new Set(KOPYA.map((k) => k[1])).size;
console.log(`\n${KOPYA.length} kopya, ${konum} konum; en kotu senaryoda kalan ${enkotu}`);
const cevrimici = KOPYA.filter((k) => k[2]);
const sonra = Math.min(...SENARYO.map(([, y]) => kalan(cevrimici, y).length));
console.log(`cevrimdisi kopya cikarilinca kopya ${KOPYA.length} -> ${cevrimici.length}, `
  + `en kotu senaryoda kalan ${enkotu} -> ${sonra}`);
```

```
senaryo                                   kalan   en hizli kurtarma
konak makinenin kaybi                       3/4   sube sunucusunda yedek (45 dk)
sube tesisinin kaybi                        2/4   merkez nesne deposunda yedek (210 dk)
merkez nesne deposunun kaybi                3/4   konak anlik goruntusu (8 dk)
yonetim kimliginin ele gecirilmesi          1/4   merkezde cevrimdisi kopya (720 dk)
konuk icindeki dosyalarin sifrelenmesi      4/4   konak anlik goruntusu (8 dk)

4 kopya, 3 konum; en kotu senaryoda kalan 1
cevrimdisi kopya cikarilinca kopya 4 -> 3, en kotu senaryoda kalan 1 -> 0
```

Üç fiziksel senaryoda en az iki kopya ayakta kalıyor. Dördüncü satır ötekilerden farklıdır: yönetim
kimliğinin ele geçirilmesi hiçbir donanımı yok etmez, yine de dört kopyanın üçünü birden götürür — o
üçü aynı kimliğin silebildiği çevrimiçi kopyalardır ve konum çeşitliliği burada bir şey ifade etmez.

Son satır ölçünün özetidir: çevrimdışı kopya çıkarıldığında kopya sayısı dörtten üçe iner, ama en
kötü senaryoda kalan kopya **birden sıfıra** düşer. **Dayanıklılık kopya sayısı değil, kopyaları
aynı anda yok edebilen kalem sayısıdır.**

## Kurtarma Testi

Bütün bu sayılar bir varsayıma dayanıyor: yedek dosyası okunabilir. Bu varsayımın sınanmasına
**kurtarma testi** denir; Sunucu Yönetimi ve Sertleştirme kursundaki geri yükleme tatbikatının
aynısıdır ve orada ölçülmüştü. Bu kursun ölçüsüyle söylenecek tek şey şudur: kurtarma testi
yapılmadığında kurtarma sınırını geçmek için gereken kalem **birdir** — bir bozuk dosya, bir kapsam
dışı kalem ya da bir okunamayan anahtar — ve o kalem yerindeyse erişilebilen kurtarma noktası
sıfırdır.

## Özet

- Yedi kayıp senaryosunda anlık görüntü 3'ünde çalışır ve çalıştığında 8/8 kalem getirir; yedek
  7'sinde çalışır ve her seferinde 6/8 getirir.
- Anlık görüntünün eksiği koşula bağlıdır — kaybolan şeyin yanında durur; yedeğinki kapsama bağlıdır
  ve iki kalem senaryodan bağımsız olarak dışarıda kalır.
- İki yöntem toplamda 56 kalemin 48'ini kurtarır; kalan 8 kalem hiçbir düzende gelmez. Veri kaybı
  penceresi anlık görüntüde 1, yedekte 24 saattir.
- Yirmi sekiz noktalı zincirde bir dosyanın bozulması tam düzende 1, artımlı düzende 18, ayrımsal
  düzende 1 nokta götürür; depolama sırasıyla 1.120, 91,3 ve 758,2 GiB'dir. Tam yedeğin kendisi
  bozulursa artımlı ve ayrımsal düzenlerde 28 noktanın 28'i birden gider.
- Dört kopyalı düzende en kötü senaryo yönetim kimliğinin ele geçirilmesidir ve 3 kopyayı birden
  götürür; çevrimdışı kopya çıkarıldığında en kötü senaryoda kalan kopya 1'den 0'a iner.
- Kurtarma testi yapılmadığında kurtarma sınırını geçmek için gereken kalem birdir ve o kalem
  yerindeyse erişilebilen kurtarma noktası sıfırdır.

## Kurs Kapanışı

| Ders | Sınırın adı | Geçmek için gereken kalem | Düşerse erişilen kalem |
|---|---|---|---|
| Bilgisayar Donanım Bileşenleri | 8 bileşen, 43 kalem | uzaktan 1–3, fiziksel 0 | 3–43; bellenim tek başına 43 |
| İşletim Sistemi Aileleri | yönetici sınırı, 14 istek | ailelere göre 1, 2, 3 | 13, 9, 5 istek |
| Kurulum ve Yapılandırma | varsayılan sınırı, 20 kalem | 1 riskli kalem | 17 kalem; sertleştirmeden sonra 5 |
| Dosya İzinleri ve Sahiplik | izin sınırı, 70 istek | sahiplikte 1 | nesnenin tüm izin kararları; 6 sapma |
| Grafik Arayüz ve Komut Satırı | denetim izi sınırı, 21 kayıt | silinebilen 1 kalem | 10 kayıt görünmez; 3 iş izsiz |
| Sorun Giderme Yöntemi | belirti–neden sınırı, 16 olasılık | 3,50 adım; kötü sırada 5,81 | 14 senaryo tek nedene; 2 ayrılamaz |
| Hipervizör Türleri | hipervizör sınırı, 19 ve 26 kalem | komşuya 1; donanıma 2 ve 3 | 15/19 ve 22/26 |
| Konuk ve Konak Sistem | paylaşım sınırı, 11 kalem | 4 yolda 1, 10 yolda 2, 2 yolda 3 | 16 yolun 6'sı kapatılamaz |
| Sanal Makine Yönetimi | klon ve anlık görüntü sınırı, 7 sır | ortak sırda 1 | 24 makine; geri dönüşte 17 açık |
| Konteyner ile Karşılaştırma | yalıtım sınırı, 52 kalem | konuk 2, bölme 1, iç içe 3 | 39/52, 52/52, iç içe 9/52 |
| Yedekleme ve Dayanıklılık | kurtarma sınırı, 56 kalem | bozuk dosyada 1 | 8 kalem kurtarılamaz; 18 nokta |

Üçüncü sütun kursun kuralını on bir satırda aynı biçimde okutuyor: **yalıtım bir sıfat değil, sınırı
geçmek için aynı anda yanlış olması gereken kalem sayısıdır; o sayı bir ise sınır yoktur.** On bir
satırın on birinde en az bir "1" var. Bir riskli varsayılan kalemi, bir sahiplik kaydı, silinebilen
bir denetim kaydı, bir ortak sır, bir bozuk yedek dosyası — hepsi tek başına yeterlidir ve hiçbiri
bir kaçış yolu kullanmaz.

Sayının birden büyük olduğu yerler üç kaynaktan geliyor: **katman üstüne katman** (donanıma iki ve üç
kalem, iç içe düzende üç), **doğrulama zinciri** (imzalı açılış gereken kalemi bire karşı dörde
çıkarır) ve **bölünmüş ayrıcalık** (yönetici sınırı bir ailede bir, ötekinde üç kalem). Üçünün de
bedeli yazılıdır — dört ek yama kalemi, her güncellemede yeniden imzalanan üç halka, yönetici olunsa
da erişilemeyen dokuz istek. **Bedeli yazılmayan bir sınır ölçülmemiştir.**

Dördüncü sütun sınırın yetmediği yeri gösteriyor: kapatılamayan altı paylaşım yolu, kurtarılamayan
sekiz kalem, ayrılamayan iki neden ve hiç kapanmayan bir kurulum kalemi. Hiçbiri daha iyi bir
yapılandırmayla kapanmıyor.

Bütün bu sayılar tek bir makinede ve üzerindeki konuk sistemlerde ölçüldü. Ama şube sunucusu yalnız
başına durmuyor: sayaç uç noktaları ve saha ekiplerinin dizüstü bilgisayarları ona, kendisi de
merkeze bağlanıyor. Bu bağlantıların her biri işletim
sisteminin çizdiği sınırın **dışından** geçen bir yoldur; ne izin bitleri ne hipervizör ne de bölme
onu görür. **M24/K03 Ağ Güvenliği** bu soruyla başlar: iki makine arasındaki her bağlantı kaç yol
açıyor ve o yolları kim sayıyor.
