---
title: 'Konteyner ile Karşılaştırma'
source: 'https://academia.sh/tr/kurslar/bt-temelleri/konteyner-ile-karsilastirma'
course: 'Bilgi Teknolojileri ve Sistem Temelleri'
language: tr
updated: '2026-08-17T18:08:39+00:00'
license: 'CC BY-SA 4.0'
---

# Konteyner ile Karşılaştırma

Aynı yalıtım sorusunun iki teknolojide sınırı geçmek için gereken kalem cinsinden ölçülmesi: konuk sistemin beş, aynı çekirdeği paylaşan bölmenin on iki zorunlu paylaşılan kalemi, sekiz hedefin her birinde aynı anda yanlış olması gereken kalem sayısı, tek kalemle geçilen hedef sayısı ve gereken kalemlerin tek bir kalemde yoğunlaşması.

Önceki üç ders aynı soruyu tek bir teknolojide sordu: konuk sistemin sınırı nerede, kaç kalemle
geçiliyor, geçilirse neye erişiliyor. Aynı iş için ikinci bir yol daha var ve o yolda konuk sistem
hiç yok: aynı çekirdeğin üzerinde birbirinden ayrılmış bölmeler koşuyor. Bölgesel ölçüm ağının şube
sunucularında iki düzen de kullanılıyor — doğrulayıcı bir konuk sistemde, okuma toplayıcının üç
kopyası aynı çekirdeği paylaşan bölmelerde.

Bu ders iki teknolojiyi hız, boyut ya da işletme kolaylığı üzerinden karşılaştırmaz; o ölçümler
Konteynerler kursunda yapıldı ve tekrarlanmaz. Buradaki tek soru yalıtım gücüdür ve o güç bu
kursun ölçü birimiyle yazılır: **sınırı geçmek için aynı anda yanlış olması gereken kalem sayısı.**
İki teknoloji aynı hedef kümesinde bu sayıyla karşılaştırılır.

**SA20 — Karşılaştırma aynı işi yapan iki düzen arasındadır**: bir konuk sistem ve aynı çekirdeği
paylaşan bir bölme. **SA21 — Konuk sistemin zorunlu beş paylaşılan kalemi önceki dersten girdidir**;
bölmenin listesi aynı ölçüyle sayılır. **SA22 — Bir ad alanı görünümü ayırır, kaynağı ayırmaz**; bu
ayrım kalem sayımında ayrı sütun olarak tutulur. **SA23 — Hedef kümesi sekiz kalemdir** ve her hedef
için gereken kalemler adıyla yazılır; kalem adları modeldir, sayım gerçektir. **SA24 — Yoğunlaşma,
aynı kalemin kaç hedefte geçtiğidir.** **SA25 — Erişim evreni 52 kalemdir**: dört iş yükünün
dokuzar kalemi, konağın on üç kalemi ve üç ayar kalemi.

## Paylaşılan Kalem Sayısı

İki düzen aynı konak üzerinde koşarken farklı sayıda kalem paylaşır. Konuk sistemde paylaşım
hipervizörün açtığı kadardır; bölmede paylaşım çekirdeğin kendisidir.

```js
// bolme.mjs — konuk sistem ile ayni cekirdegi paylasan bolmenin konakla paylastigi kalem (MODEL).
// Konuk sistemin zorunlu bes kalemi onceki dersten girdidir; bolme ayni olcuyle sayilir.
export const KONUK = [['zamanlayici', false], ['islemci onbellegi', false], ['saat kaynagi', false],
  ['disk denetleyicisi oykunmesi', false], ['ag arayuzu oykunmesi', false]];
// [kalem, gorunumu bir ad alani ayiriyor mu] — kaynak her satirda ortaktir
export const BOLME = [['zamanlayici', false], ['islemci onbellegi', false], ['saat kaynagi', false],
  ['sistem cagrisi yuzeyi', false], ['cekirdek veri yapilari', false], ['sayfa onbellegi', false],
  ['cekirdek gunluk arabellegi', false], ['cekirdek modul kumesi', false],
  ['surec numarasi uzayi', true], ['kullanici kimligi uzayi', true], ['ag yigini', true],
  ['dosya sistemi gorunumu', true]];

if (import.meta.url === `file://${process.argv[1]}`) {
  const s = (x, n) => String(x).padStart(n);
  console.log(`${'teknoloji'.padEnd(34)}${s('paylasilan kalem', 18)}${s('gorunumu ayrilan', 18)}`
    + `${s('kaynagi ortak', 15)}`);
  for (const [ad, liste] of [['konuk sistem', KONUK], ['ayni cekirdegi paylasan bolme', BOLME]])
    console.log(`${ad.padEnd(34)}${s(liste.length, 18)}`
      + `${s(liste.filter(([, a]) => a).length, 18)}${s(liste.length, 15)}`);
  const ayrilmayan = BOLME.filter(([, a]) => !a).map(([k]) => k);
  console.log(`\nbolmede gorunumu ayrilmayan ${ayrilmayan.length} kalem:`);
  for (let i = 0; i < ayrilmayan.length; i += 4) console.log(`  ${ayrilmayan.slice(i, i + 4).join(', ')}`);
  console.log(`oran: bolme / konuk = ${(BOLME.length / KONUK.length).toFixed(1)} kat paylasilan kalem`);
}
```

```
teknoloji                           paylasilan kalem  gorunumu ayrilan  kaynagi ortak
konuk sistem                                       5                 0              5
ayni cekirdegi paylasan bolme                     12                 4             12

bolmede gorunumu ayrilmayan 8 kalem:
  zamanlayici, islemci onbellegi, saat kaynagi, sistem cagrisi yuzeyi
  cekirdek veri yapilari, sayfa onbellegi, cekirdek gunluk arabellegi, cekirdek modul kumesi
oran: bolme / konuk = 2.4 kat paylasilan kalem
```

Bölme 2,4 kat kalem paylaşıyor. Bu oran tek başına bir sonuç değil, bir tabandır: paylaşılan her
kalem bir yol adayıdır ve aday sayısı beşten on ikiye çıkmıştır. Konuk sistemin beş kaleminin ikisi
bir öykünme kodudur — yani konak tarafında koşan, sınırlı ve tek amaçlı bir yazılım parçası.
Bölmenin on iki kalemi ise doğrudan çekirdeğin kendisidir; araya konan bir öykünme katmanı yoktur.

İkinci sütun daha ilginç. On iki kalemin yalnız dördünde bir ad alanı görünümü ayırıyor: süreç
numarası, kullanıcı kimliği, ağ yığını, dosya sistemi görünümü. Kalan sekizde ayrı bir görünüm bile
yok — zamanlayıcı, işlemci önbelleği, saat, sistem çağrısı yüzeyi, çekirdek veri yapıları, sayfa
önbelleği, çekirdek günlük arabelleği ve çekirdek modül kümesi bölme için de konak için de aynı
nesnedir. Üçüncü sütun ise ayrımı bitiriyor: on iki kalemin on ikisinde **kaynak ortaktır**. Ad
alanı olan dört kalemde bile ayrılan şey görünümdür; altta duran sayı uzayı ve veri yapısı tektir.

## Sekiz Hedef, İki Sayı

Paylaşılan kalem sayısı yalıtım gücü değildir; yalıtım gücü belirli bir hedefe ulaşmak için aynı
anda yanlış olması gereken kalem sayısıdır. Aşağıdaki koşum aynı sekiz hedefi iki düzende yazıyor.

```js
// hedef.mjs — ayni sekiz hedef iki teknolojide: siniri gecmek icin ayni anda yanlis olmasi
// gereken kalemler. Kalem adlari model, sayim gercektir.
const HEDEF = [
  ['komsunun dosyalarini okuma', ['hipervizor kusuru', 'komsu imajina erisim'], ['cekirdek kusuru']],
  ['komsunun bellegini okuma', ['hipervizor kusuru', 'bellek yalitimi hatasi'],
    ['cekirdek kusuru', 'surec izleme yetkisi']],
  ['konak dosya sistemine yazma', ['hipervizor kusuru', 'konak yazma yetkisi'], ['yazilabilir takma']],
  ['konak cekirdeginde kod calistirma', ['hipervizor kusuru', 'konak cekirdek kusuru'], ['cekirdek kusuru']],
  ['konak saatini degistirme', ['hipervizor kusuru', 'konak saat yetkisi'], ['saat degistirme yetkisi']],
  ['komsuyu kaynak tuketerek durdurma', ['acik kalan kaynak siniri'], ['acik kalan kaynak siniri']],
  ['konagin sirlarini okuma', ['hipervizor kusuru', 'konak dosya erisimi'],
    ['sir dosyasinin takilmasi', 'okuma izni']],
  ['konak agindaki bir uca ulasma', ['acik ag yolu'], ['acik ag yolu']],
];
const AD = ['konuk sistem', 'bolme'];
const s = (x, n) => String(x).padStart(n);
console.log(`${'hedef'.padEnd(36)}${s(AD[0], 14)}${s(AD[1], 8)}`);
for (const [h, a, b] of HEDEF) console.log(`${h.padEnd(36)}${s(a.length, 14)}${s(b.length, 8)}`);
const gereken = (i) => HEDEF.reduce((t, h) => t + h[i + 1].length, 0);
const tek = (i) => HEDEF.filter((h) => h[i + 1].length === 1).length;
console.log(`${'toplam gereken kalem'.padEnd(36)}${s(gereken(0), 14)}${s(gereken(1), 8)}`);
console.log(`${'tek kalemle gecilen hedef'.padEnd(36)}${s(tek(0), 14)}${s(tek(1), 8)}`);

for (let i = 0; i < 2; i++) {                    // yogunlasma: en sik gecen kalem
  const hepsi = HEDEF.flatMap((h) => h[i + 1]);
  const [kalem, n] = [...new Set(hepsi)].map((k) => [k, hepsi.filter((x) => x === k).length])
    .sort((a, b) => b[1] - a[1])[0];
  const sonra = HEDEF.filter((h) => h[i + 1].filter((k) => k !== kalem).length <= 1).length;
  console.log(`\n${AD[i]}: en sik kalem "${kalem}" ${n}/${HEDEF.length} hedefte`);
  console.log(`o kalem yerindeyse tek kalemle gecilen hedef ${tek(i)} -> ${sonra}`);
}
```

```
hedef                                 konuk sistem   bolme
komsunun dosyalarini okuma                       2       1
komsunun bellegini okuma                         2       2
konak dosya sistemine yazma                      2       1
konak cekirdeginde kod calistirma                2       1
konak saatini degistirme                         2       1
komsuyu kaynak tuketerek durdurma                1       1
konagin sirlarini okuma                          2       2
konak agindaki bir uca ulasma                    1       1
toplam gereken kalem                            14      10
tek kalemle gecilen hedef                        2       6

konuk sistem: en sik kalem "hipervizor kusuru" 6/8 hedefte
o kalem yerindeyse tek kalemle gecilen hedef 2 -> 8

bolme: en sik kalem "cekirdek kusuru" 3/8 hedefte
o kalem yerindeyse tek kalemle gecilen hedef 6 -> 7
```

Beklenen fark tabloda var: sekiz hedefin altısı bölmede tek kalemle geçiliyor, konuk sistemde ikisi.
Toplam gereken kalem on dörde karşı on. Bir hedefe ulaşmak için ortalama olarak konuk sistemde 1,75,
bölmede 1,25 kalemin aynı anda yanlış olması gerekiyor.

Eşit çıkan iki satır bu farkın nereden **gelmediğini** gösteriyor. Kaynak tüketerek komşuyu durdurmak
ve konak ağındaki bir uca ulaşmak iki düzende de tek kalem istiyor, çünkü bu iki hedef yalıtım
sınırına değil bir yapılandırma kalemine bağlıdır: kaynak sınırı açık bırakılmışsa ve ağ yolu açıksa
sınırın türü sonucu değiştirmiyor. **Yalıtım teknolojisi seçmek, yapılandırma kaleminin açık
kalmasını telafi etmiyor.**

Son iki bölüm ise tablonun kendisini düzeltiyor. Konuk sistemdeki altı "iki kalem" bağımsız değil:
altısı da aynı ikinci kaleme, **hipervizör kusuruna** bağlı. O kalem yerindeyse tek kalemle geçilen
hedef sayısı ikiden **sekize** çıkıyor — yani konuk sistemin yalıtımı sekiz hedefte birden tek bir
kalemin doğruluğuna dayanıyor. Bölmede aynı yoğunlaşma yok: en sık kalem üç hedefte geçiyor ve o
kalem yerindeyken tek kalemle geçilen hedef altıdan yediye çıkıyor, sekize değil.

İki teknolojinin ayrıldığı yer budur. **Konuk sistem daha yüksek ama daha yoğunlaşmış bir sayı verir:
sekiz hedefin altısı tek bir kaleme bağlıdır. Bölme daha düşük ama daha dağınık bir sayı verir: altı
ayrı hedef altı ayrı kaleme bağlıdır.** Birincisinde savunmanın gideceği yer bellidir ve tektir;
ikincisinde altı ayrı kalem ayrı ayrı doğru tutulmalıdır.

## Sınır Düştüğünde Erişilen Kalem

Gereken kalem sayısı üç sütunun ikincisidir; üçüncüsü sınır bir kez geçildiğinde kaç kaleme
erişildiğidir. Bu sayı yerleşimden gelir ve iki teknoloji arasında değil, üç düzen arasında ayrılır.

```js
// dusus.mjs — sinir dustugunde erisilen kalem, uc yerlesim duzeninde (MODEL).
// Kurgu sube sunucusu: dort is yuku, her biri 6 dosya ve 3 bellek kalemi tasiyor.
const IS = 4, DOSYA = 6, BELLEK = 3, KONAK_FS = 9, KONAK_SIR = 4, AYAR = 3;
const TOPLAM = IS * (DOSYA + BELLEK) + KONAK_FS + KONAK_SIR + AYAR;
// [duzen, siniri gecmek icin gereken kalem, ilk dususte erisilen kalem, bakimda yama kalemi]
const DUZEN = [
  ['tek konuk sistemde 4 is yuku', 2, IS * (DOSYA + BELLEK) + AYAR, 2],
  ['tek konakta 4 bolme', 1, TOPLAM, 1],
  ['is yuku basina konuk sistem + bolme', 1, DOSYA + BELLEK, 5],
  ['  ayni duzende konak duzeyine', 3, IS * (DOSYA + BELLEK) + AYAR, 5],
];
const s = (x, n) => String(x).padStart(n);
console.log(`evren ${TOPLAM} kalem: ${IS} is yuku x ${DOSYA + BELLEK}, konak ${KONAK_FS + KONAK_SIR}, ayar ${AYAR}`);
console.log(`\n${'duzen'.padEnd(38)}${s('gereken', 8)}${s('erisilen', 10)}${s('yama kalemi', 13)}`);
for (const [ad, g, e, y] of DUZEN)
  console.log(`${ad.padEnd(38)}${s(g, 8)}${s(`${e}/${TOPLAM}`, 10)}${s(y, 13)}`);
const [, , enaz] = DUZEN.reduce((a, b) => (b[2] < a[2] ? b : a));
console.log(`\nen dar ilk dusus ${enaz}/${TOPLAM} (%${((100 * enaz) / TOPLAM).toFixed(1)}), `
  + `bedeli ${DUZEN[2][3] - DUZEN[1][3]} ek yama kalemi`);
```

```
evren 52 kalem: 4 is yuku x 9, konak 13, ayar 3

duzen                                  gereken  erisilen  yama kalemi
tek konuk sistemde 4 is yuku                 2     39/52            2
tek konakta 4 bolme                          1     52/52            1
is yuku basina konuk sistem + bolme          1      9/52            5
  ayni duzende konak duzeyine                3     39/52            5

en dar ilk dusus 9/52 (%17.3), bedeli 4 ek yama kalemi
```

İlk iki satır önceki tablonun sonucunu erişim tarafında tekrarlıyor: dört bölme tek konakta
koştuğunda sınır bir kalemle geçilir ve elli iki kalemin elli ikisine erişilir; dört iş yükü bir
konuk sistemde koştuğunda sınır iki kalem ister ve otuz dokuz kaleme erişilir. Bölmede erişilen
kalemin evrenin tamamı olmasının nedeni yapısaldır: sınırı çizen katman çekirdektir ve o çekirdek
konağın kendisidir; onu geçen, konağın dosya sistemine ve sırlarına da geçmiş olur.

Üçüncü satır iki teknolojinin karşıt değil, **üst üste** konabildiğini gösteriyor. Her iş yükü kendi
konuk sisteminde bir bölme içinde koştuğunda ilk düşüşte erişilen kalem elli ikinin dokuzu — yüzde
17,3 — çünkü o bölmeden çıkan yalnız kendi konuk sisteminin içine çıkar. Konak düzeyine ulaşmak için
gereken kalem üçe çıkıyor: bölme sınırının bir kalemi ile konuk sisteminin iki kalemi toplanıyor.
**Katmanlar üst üste konduğunda gereken kalem toplanır; bu, kursta gereken kalemin üçe çıktığı tek
düzendir.**

Sağ sütun bedeli yazıyor. Tek konakta dört bölme bir yama kalemi ister — tek çekirdek. Üç numaralı
düzen beş yama kalemi ister: bir hipervizör ve dört ayrı konuk çekirdeği. Dört ek yama kalemi,
sürekli ve tekrar eden bir iştir; erişilen kalemi 52'den 9'a indirmenin karşılığı budur.

## Sayının Okunma Biçimi

Bu ölçüm bir teknolojiyi öbürüne yeğlemeyi söylemiyor, iki farklı savunma programı tarif ediyor.
Konuk sistemde program tek kalemlidir ve o kalem hipervizördür: yamalı tutulması, yönetim arayüzünün
ayrılması, üzerinde başka iş çalıştırılmaması. Bu programın tamamı bir bileşene bakar ve o bileşen
düştüğünde sekiz hedefin sekizi tek kalemle geçilir. Yoğunlaşmanın hem gücü hem zayıflığı budur.

Bölmede program altı kalemlidir: çekirdeğin yamalı olması, takmanın salt okunur bırakılması, saat
yetkisinin verilmemesi, süreç izleme yetkisinin kapatılması, kaynak sınırının konması, ağ yolunun
kapatılması. Altısı ayrı ayrı doğru tutulduğunda tek kalemle geçilen hedef sayısı düşer; biri
unutulduğunda o hedef tek kalemle geçilir ve ötekiler bunu telafi etmez.

Kalan iki satır ikisinde de aynı: kaynak sınırı ve ağ yolu. Bu iki kalem yalıtım teknolojisinin
dışındadır ve iki düzende de tek başına yeterlidir.

Üçüncü tablo bu iki programın birbirini dışlamadığını gösteriyor. İş yükünü kendi konuk sistemi
içindeki bir bölmede koşturmak iki programı da yürütmeyi gerektirir — hipervizör de çekirdek de
yamalı tutulacaktır, beş yama kalemi — ama karşılığında ilk düşüşte erişilen kalemi elli ikinin
dokuzuna indirir ve konak düzeyine ulaşmak için gereken kalemi üçe çıkarır. **Bu kursta gereken
kalemin üçe çıktığı tek satır budur ve bir teknoloji seçiminden değil, iki teknolojinin üst üste
konmasından gelir.** Bir sonraki dersin ölçüsü aynı kalem evreninden başlayacak: sınır düştüğünde
geriye ne kaldığı sorusu, sınırın türünden bağımsızdır.

## Özet

- Konuk sistem konakla beş zorunlu kalem paylaşır, aynı çekirdeği paylaşan bölme on iki; oran 2,4
  kattır.
- Bölmedeki on iki kalemin yalnız dördünde bir ad alanı görünümü ayırır ve on ikisinde de kaynak
  ortaktır; kalan sekizde ayrı bir görünüm bile yoktur.
- Sekiz hedefte toplam gereken kalem konuk sistemde 14, bölmede 10'dur; tek kalemle geçilen hedef
  sayısı 2'ye karşı 6'dır.
- İki hedef — kaynak tüketerek durdurma ve konak ağındaki uca ulaşma — iki düzende de tek kalem
  ister, çünkü yalıtım sınırına değil bir yapılandırma kalemine bağlıdır.
- Konuk sistemdeki altı "iki kalem" bağımsız değildir: altısı da hipervizör kusuruna bağlıdır ve o
  kalem yerindeyse tek kalemle geçilen hedef 2'den 8'e çıkar. Bölmede en sık kalem 3 hedefte geçer
  ve sayı 6'dan 7'ye çıkar.
- İlk düşüşte erişilen kalem üç düzende 39/52, 52/52 ve 9/52'dir; iş yükü başına konuk sistem içinde
  bölme düzeninde konak düzeyine ulaşmak üç kalem ister ve bedeli dört ek yama kalemidir.

## Sonraki Adım

Dört ders boyunca sınır hep aynı yönden ölçüldü: birinin sınırı geçmesi durumunda ne olacağı. Sınırın
düşmesinin tek yolu bu değil. Bir disk arızalanır, bir dosya yanlışlıkla silinir, bir konak açılmaz
hâle gelir — ve bu durumlarda sınırı geçen kimse yoktur, yine de konuk kaybolur. Sanallaştırmanın bu
soruya iki ayrı karşılığı var: anlık görüntü ve yedek. İkisi de "geri getirir" diye anılıyor ve ikisi
aynı şeyi getirmiyor. Son ders ikisini aynı kayıp senaryosunda koşturup kurtarılan ve kurtarılamayan
kalemi ayrı ayrı sayar, tam, artımlı ve ayrımsal yedeğin zincir bozulduğunda dönülebilen noktasını
hesaplar ve kursu on bir dersin sınır tablosuyla kapatır.
