Sanal Makine Örnekleri

Ö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.

// 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.

// 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.

// 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?