---
title: 'Otomatik Ölçekleme Grupları'
source: 'https://academia.sh/tr/kurslar/bulut-hesaplama-ve-ag/otomatik-olcekleme-gruplari'
course: 'Bulutta Hesaplama ve Ağ'
language: tr
updated: '2026-08-17T18:06:56+00:00'
license: 'CC BY-SA 4.0'
---

# Otomatik Ölçekleme Grupları

Ölçekleme politikası ile sağlık denetimi aynı grupta birlikte koşturulur ve grup boyutu dalgalanması, aynı anda değiştirilen örnek sayısı ile kapasitenin altına düşülen tur sayılır; sağlık denetimi eşiği ile ölçekleme soğuma süresi dokuz çift halinde taranır ve sürekli değişim üreten çift adıyla yazılır; sürekli değişimin günlük bedeli ile grubun geri alınamayan üç kalemi çıkarılır.

Önceki ders örnek başlatmayı tek bir tanıma indirdi ve şablonun yazmadığı iki şeyi bıraktı: kaç
örnek olacağı ve ne zaman sonlandırılacağı. **Otomatik ölçekleme grubu** bu iki soruyu da devralır.
Grup bir şablona bağlanır, bir en az ve en çok örnek sayısı verilir, ve iki ayrı döngü örnek
sayısını kendi başına değiştirmeye başlar.

Birinci döngü **ölçekleme politikasıdır**: talep ölçütüne bakar, örnek ekler ya da çıkarır. M22/K03
yatay ölçeklemeyi ve ölçütün gecikmesinden doğan salınımı ölçtü; o tarama burada tekrarlanmaz.
İkinci döngü **sağlık denetimidir**: örneklere düzenli aralıklarla sorar, yanıt vermeyeni
sonlandırıp yerine yenisini başlatır. Bu dersin ölçüsü ikisinin ayrı ayrı davranışı değil,
**birlikte davranışıdır** — çünkü ikisi de aynı sayıyı, grubun boyutunu değiştirir ve birbirinin
eylemini talep sanabilir.

**BH25.** Grup, bölgesel ölçüm ağının — su sayaçlarından okuma toplayan kurgu yazılımın — okuma
alan katmanıdır; talep eğrisi kurgudur ve her koşumda aynıdır. **BH26.** Bir tur bir dakikadır,
dönem 240 turdur ve örnek başına kapasite 100 istek/turdur. **BH27.** Açılış 2 tur sürer; önceki
derslerin 48,9 saniyesi bu ölçekte iki tura yuvarlanır. **BH28.** Geçici denetim hatası olasılığı
0,08'dir; üreteç kendi yazılmıştır ve tohum 20261001 görünürdür. **BH29.** Kalıcı bozulma 40., 95.
ve 170. turlarda olur; anlar kurgudur ve her koşumda aynıdır. **BH30.** Ölçekleme yalnız hazır
örnekleri sayar ve sağlık değiştirmesi soğuma süresi tanımaz.

## İki Döngü Aynı Grupta

Sağlık denetimi bir örneği sonlandırdığında grup küçülür. Ölçekleme politikası o anda gruba bakar
ve hazır örnek sayısını gerekliden az bulur — yerine gelen örnek henüz açılmaktadır. Politika
bunu talep artışı sanar ve örnek ekler. Açılanlar hazır olduğunda grup gereğinden büyük olur ve
politika bu kez küçültür.

```js
// olcum-agi/grup.mjs — otomatik olcekleme grubu ile saglik denetiminin birlikte kosumu (model)

export const uretec = (tohum) => () =>
  (tohum = (tohum * 1103515245 + 12345) % 2147483648) / 2147483648;

export const TUR = 240, KAPASITE = 100, ACILIS = 2;   // tur, ornek basina istek, acilis turu
const GECICI = 0.08;                                  // gecici denetim hatasi olasiligi
const BOZULMA_ANI = [40, 95, 170];                    // kalici bozulmanin oldugu turlar (kurgu)

// Talep egrisi kurgudur ve her kosumda aynidir; rastgelelik yalniz saglik denetimindedir.
export const talep = (t) =>
  900 + 380 * Math.sin((2 * Math.PI * t) / 120) + (t >= 150 && t < 190 ? 520 : 0);
export const gerekli = (t) => Math.ceil(talep(t) / KAPASITE);

export const kosum = ({ esik, soguma, tohum = 20261001 }) => {
  const r = uretec(tohum);
  let grup = Array.from({ length: gerekli(0) }, () => ({ hazir: true, kalan: 0, ardisik: 0, bozuk: false }));
  const m = { min: 99, max: 0, esZamanli: 0, oran: 0, alti: 0, baslatilan: 0,
    yanlis: 0, bozukTur: 0, olcekleme: 0, degistirme: 0 };
  let sonEylem = -soguma;
  for (let t = 0; t < TUR; t++) {
    const g = gerekli(t);
    if (BOZULMA_ANI.includes(t)) {
      const kurban = grup.find((o) => o.hazir && !o.bozuk);
      if (kurban) kurban.bozuk = true;
    }
    const kalan = [];                                  // saglik denetimi (soguma tanimaz)
    for (const o of grup) {
      if (!o.hazir) { kalan.push(o); continue; }
      if (o.bozuk) m.bozukTur++;
      const gecti = !o.bozuk && r() >= GECICI;
      o.ardisik = gecti ? 0 : o.ardisik + 1;
      if (o.ardisik >= esik) {
        m.degistirme++; if (!o.bozuk) m.yanlis++;
        kalan.push({ hazir: false, kalan: ACILIS, ardisik: 0, bozuk: false });
        m.baslatilan++;
      } else kalan.push(o);
    }
    grup = kalan;
    const hazir = grup.filter((o) => o.hazir).length;  // olcekleme yalniz hazir ornegi sayar
    if (t - sonEylem >= soguma) {
      if (hazir < g) {
        for (let i = 0; i < g - hazir; i++)
          grup.push({ hazir: false, kalan: ACILIS, ardisik: 0, bozuk: false });
        m.baslatilan += g - hazir; m.olcekleme++; sonEylem = t;
      } else if (hazir > g + 1) {
        for (let i = 0; i < hazir - g - 1; i++) grup.splice(grup.findIndex((o) => o.hazir), 1);
        m.olcekleme++; sonEylem = t;
      }
    }
    for (const o of grup) if (!o.hazir && --o.kalan <= 0) o.hazir = true;
    const acilan = grup.filter((o) => !o.hazir).length;
    m.min = Math.min(m.min, grup.length); m.max = Math.max(m.max, grup.length);
    m.esZamanli = Math.max(m.esZamanli, acilan);
    m.oran = Math.max(m.oran, acilan / grup.length);
    if (grup.filter((o) => o.hazir).length < g) m.alti++;
  }
  return m;
};

if (import.meta.url === `file://${process.argv[1]}`) {
  const kotu = kosum({ esik: 2, soguma: 0 }), iyi = kosum({ esik: 5, soguma: 8 });
  console.log(`${TUR} tur, ornek basina ${KAPASITE} istek, acilis ${ACILIS} tur; tohum 20261001`);
  console.log(`gerekli ornek ${Math.min(...Array.from({ length: TUR }, (_, t) => gerekli(t)))}` +
    ` ile ${Math.max(...Array.from({ length: TUR }, (_, t) => gerekli(t)))} arasinda degisiyor\n`);
  console.log("cift".padEnd(22) + "grup min-max".padEnd(15) + "dalgalanma".padEnd(13) +
    "es zamanli degisim".padEnd(20) + "kapasite alti tur".padEnd(19) + "baslatilan ornek");
  for (const [ad, m] of [["esik 2, soguma 0", kotu], ["esik 5, soguma 8", iyi]])
    console.log(ad.padEnd(22) + `${m.min}-${m.max}`.padEnd(15) + String(m.max - m.min).padEnd(13) +
      `${m.esZamanli} (%${Math.round(100 * m.oran)})`.padEnd(20) + `${m.alti}/${TUR}`.padEnd(19) +
      String(m.baslatilan));
  for (const [ad, m] of [["esik 2, soguma 0", kotu], ["esik 5, soguma 8", iyi]])
    console.log(`${ad}: ${m.degistirme} saglik degistirmesi (${m.yanlis} yanlis), ` +
      `${m.olcekleme} olcekleme eylemi, bozuk ornek ${m.bozukTur} tur trafikte kaldi`);
}
```

```
240 tur, ornek basina 100 istek, acilis 2 tur; tohum 20261001
gerekli ornek 6 ile 18 arasinda degisiyor

cift                  grup min-max   dalgalanma   es zamanli degisim  kapasite alti tur  baslatilan ornek
esik 2, soguma 0      7-24           17           6 (%26)             10/240             46
esik 5, soguma 8      7-18           11           5 (%28)             46/240             19
esik 2, soguma 0: 17 saglik degistirmesi (14 yanlis), 40 olcekleme eylemi, bozuk ornek 5 tur trafikte kaldi
esik 5, soguma 8: 2 saglik degistirmesi (0 yanlis), 22 olcekleme eylemi, bozuk ornek 11 tur trafikte kaldi
```

En açık sayı grup boyutunun üst sınırıdır. Talep hiçbir turda 18 örnekten fazlasını gerektirmediği
halde ilk çift grubu **24 örneğe** çıkarır. Fazladan altı örnek talepten gelmez; sağlık
değiştirmelerinin açtığı boşluğu politikanın doldurmasından gelir. İkinci çift aynı talep eğrisinde
18'i hiç aşmaz.

İkinci sayı daha az görünür ama daha ağırdır: ilk çiftte **grubun yüzde 26'sı aynı anda
değişiyordu** — dört örnekten biri açılmakta, yani ne eski ne yeni. Sağlıklı örnek sayısı bu oranda
dalgalanıyorsa ölçüt, politikanın kendi eyleminin sonucunu ölçmeye başlar.

Alt satırlar kaynağı ayırır. İlk çift 17 sağlık değiştirmesi yaptı ve **14'ü yanlıştı** — o
örnekler bozuk değildi, yalnız iki denetimi üst üste geçemedi. Aynı çift 40 ölçekleme eylemi
üretti, ikinci çift 22. Yanlış değiştirmelerin her biri politikaya bir sahte talep sinyali
göndermiştir.

Ama ikinci çift bedava değildir. Kapasite altı tur 10'dan **46'ya** çıkar: soğuma süresi uzun
olduğu için politika gerçek talep artışına geç yanıt verir. Ve bozuk örnek 5 tur yerine **11 tur**
trafikte kalır; eşik yüksek olduğu için gerçekten bozulan örnek de geç yakalanır. İki çift iki ayrı
hatayı azaltır ve öbürünü büyütür.

## Eşik ile Soğumanın Taraması

İki uç nokta yönü gösterdi; asıl soru aradaki çiftlerin ne yaptığıdır. Aşağıdaki tarama üç eşik
ile üç soğuma süresini birlikte koşturur — dokuz çift, aynı talep eğrisi, aynı tohum.

```js
// olcum-agi/grup-taramasi.mjs — saglik esigi ile soguma suresinin birlikte taranmasi (model)
import { TUR, kosum } from "./grup.mjs";

const ESIK = [2, 3, 5], SOGUMA = [0, 3, 8], SAAT = TUR / 60;   // bir tur bir dakika (kurgu)

if (import.meta.url === `file://${process.argv[1]}`) {
  console.log(`${TUR} tur = ${SAAT} saat; her satir ayni talep egrisi ve ayni tohumla kosuldu\n`);
  console.log("esik".padEnd(7) + "soguma".padEnd(9) + "grup min-max".padEnd(15) +
    "dalgalanma".padEnd(13) + "es zamanli".padEnd(13) + "kapasite alti".padEnd(16) +
    "yanlis degisim".padEnd(17) + "bozuk tur".padEnd(12) + "saatte baslatilan");
  const hepsi = [];
  for (const e of ESIK)
    for (const s of SOGUMA) {
      const m = kosum({ esik: e, soguma: s });
      hepsi.push({ e, s, m });
      console.log(String(e).padEnd(7) + String(s).padEnd(9) + `${m.min}-${m.max}`.padEnd(15) +
        String(m.max - m.min).padEnd(13) + String(m.esZamanli).padEnd(13) +
        `${m.alti}/${TUR}`.padEnd(16) + String(m.yanlis).padEnd(17) +
        String(m.bozukTur).padEnd(12) + (m.baslatilan / SAAT).toFixed(1));
    }
  const enCok = hepsi.reduce((a, b) => (b.m.baslatilan > a.m.baslatilan ? b : a));
  const enAz = hepsi.reduce((a, b) => (b.m.baslatilan < a.m.baslatilan ? b : a));
  const enUzun = hepsi.reduce((a, b) => (b.m.bozukTur > a.m.bozukTur ? b : a));
  console.log(`\nsurekli degisim ureten cift: esik ${enCok.e}, soguma ${enCok.s} — ` +
    `saatte ${(enCok.m.baslatilan / SAAT).toFixed(1)} ornek, ${enCok.m.yanlis} yanlis degistirme`);
  console.log(`en az degisim ureten cift: esik ${enAz.e}, soguma ${enAz.s} — ` +
    `saatte ${(enAz.m.baslatilan / SAAT).toFixed(1)} ornek, kapasite alti ${enAz.m.alti} tur`);
  console.log(`bozuk ornegi en uzun tasiyan cift: esik ${enUzun.e}, soguma ${enUzun.s} — ` +
    `${enUzun.m.bozukTur} tur trafikte`);
}
```

```
240 tur = 4 saat; her satir ayni talep egrisi ve ayni tohumla kosuldu

esik   soguma   grup min-max   dalgalanma   es zamanli   kapasite alti   yanlis degisim   bozuk tur   saatte baslatilan
2      0        7-24           17           6            10/240          14               5           11.5
2      3        7-18           11           5            13/240          12               6           8.5
2      8        7-18           11           4            42/240          13               6           8.5
3      0        7-23           16           5            8/240           0                8           6.3
3      3        7-18           11           5            14/240          0                7           5.0
3      8        7-18           11           5            47/240          1                8           5.3
5      0        7-23           16           5            7/240           0                12          6.0
5      3        7-18           11           5            13/240          0                12          4.8
5      8        7-18           11           5            46/240          0                11          4.8

surekli degisim ureten cift: esik 2, soguma 0 — saatte 11.5 ornek, 14 yanlis degistirme
en az degisim ureten cift: esik 5, soguma 3 — saatte 4.8 ornek, kapasite alti 13 tur
bozuk ornegi en uzun tasiyan cift: esik 5, soguma 0 — 12 tur trafikte
```

Her sütun tek bir ayarı izler ve dördü ayrı yönlere gider. **Yanlış değiştirme yalnız eşiğe
bakar**: eşik 2'de 12–14, eşik 3'te 0–1, eşik 5'te 0. **Bozuk tur da yalnız eşiğe bakar** ama ters
yönde: 5–6'dan 11–12'ye çıkar. Eşik iki hata arasında doğrudan bir takastır — sağlıklı örneği
öldürmek ile bozuk örneği trafikte tutmak.

Soğuma süresi başka iki sütunu yönetir. **Dalgalanma yalnız soğumaya bakar**: soğuma 0'da 16–17,
soğuma 3 ve 8'de 11. Sıfır soğuma politikanın her turda eylem yapmasına izin verir ve grup, kendi
eyleminin sonucunu ölçüt sanar. **Kapasite altı tur da yalnız soğumaya bakar** ve ters yönde:
7–10'dan 42–47'ye çıkar. Uzun soğuma dalgalanmayı keser, gerçek talep artışına yanıtı geciktirir.

Uçlardaki çiftler adıyla okunur. En kötüsü **eşik 2, soğuma 0**: saatte 11,5 örnek başlatır, grubu
24'e çıkarır, 14 yanlış değiştirme yapar. Bu çiftin ürettiği şey ölçekleme değil, **sürekli
değişimdir**; grup hiçbir zaman durulmaz. En sakini eşik 5, soğuma 3'tür — saatte 4,8 örnek — ama
bozuk örneği 12 tur trafikte tutar. Orta çift (eşik 3, soğuma 3) saatte 5,0 örnekle neredeyse aynı
sakinliği verir ve bozuk örneği 7 turda yakalar.

## Sürekli Değişimin Bedeli

Sürekli değişimin görünen bedeli açılıştır: her başlatılan örnek iki tur boyunca ödenir ve hiç iş
yapmaz. Görünmeyen bedeli, o örneklerin sonlandırdığı şeydir.

```js
// olcum-agi/grup-defteri.mjs — surekli degisimin bedeli ve grubun karar defteri (model)
import { TUR, ACILIS, kosum } from "./grup.mjs";

const SAAT = TUR / 60, BIRIM = 1.0;      // kalici kapasite birimi (kurgu; M23/K01'den girdi)
const CIFT = [[2, 0], [3, 3], [5, 3]];

if (import.meta.url === `file://${process.argv[1]}`) {
  console.log("cift".padEnd(22) + "gunde baslatilan".padEnd(18) + "acilista gecen".padEnd(16) +
    "gunluk bos birim".padEnd(18) + "kapasite alti".padEnd(16) + "bozuk tur");
  for (const [e, s] of CIFT) {
    const m = kosum({ esik: e, soguma: s }), gunluk = (m.baslatilan / SAAT) * 24;
    const bos = (gunluk * ACILIS) / 60;                 // ornek-saat: acilirken odenen ama is yapmayan
    console.log(`esik ${e}, soguma ${s}`.padEnd(22) + gunluk.toFixed(0).padEnd(18) +
      `${bos.toFixed(1)} ornek-saat`.padEnd(16) + (bos * BIRIM).toFixed(1).padEnd(18) +
      `${m.alti}/${TUR}`.padEnd(16) + String(m.bozukTur));
  }
  const ELDE = ["en az ve en cok ornek", "olcekleme olcutu ve esikleri", "soguma suresi",
    "saglik denetimi esigi ve araligi", "kucultmede hangi ornegin secilecegi",
    "grubun bagli oldugu sablon surumu"];
  const DEVIR = ["saglik denetimi cagrisinin kendi gecikmesi",
    "olcekleme eyleminin uygulanma gecikmesi", "istenen kapasitenin o an bulunabilirligi"];
  const GERI_YOK = ["sonlandirilan ornegin elindeki is ve yerel diski",
    "sagliksiz damgasi — ornek geri dondurulmez, degistirilir",
    "kucultulen kapasite — geri almak yeni acilis ve soguma turu ister"];
  console.log(`\nkarar defteri: ${ELDE.length} kalem elde, ${DEVIR.length} kalem saglayicida`);
  console.log(`  saglayicida: ${DEVIR.join("; ")}`);
  for (const g of GERI_YOK) console.log(`  geri alinamaz — ${g}`);
}
```

```
cift                  gunde baslatilan  acilista gecen  gunluk bos birim  kapasite alti   bozuk tur
esik 2, soguma 0      276               9.2 ornek-saat  9.2               10/240          5
esik 3, soguma 3      120               4.0 ornek-saat  4.0               14/240          7
esik 5, soguma 3      114               3.8 ornek-saat  3.8               13/240          12

karar defteri: 6 kalem elde, 3 kalem saglayicida
  saglayicida: saglik denetimi cagrisinin kendi gecikmesi; olcekleme eyleminin uygulanma gecikmesi; istenen kapasitenin o an bulunabilirligi
  geri alinamaz — sonlandirilan ornegin elindeki is ve yerel diski
  geri alinamaz — sagliksiz damgasi — ornek geri dondurulmez, degistirilir
  geri alinamaz — kucultulen kapasite — geri almak yeni acilis ve soguma turu ister
```

Kötü çift günde **276 örnek** başlatır; iyi ayarda aynı grup aynı işi 120 örnekle yapar. Aradaki
156 örnek açılır, hazır olur ve kısa süre sonra sonlandırılır. Açılışta geçen 9,2 örnek-saat, günde
9,2 kurgu birim ödenip iş yapmayan kapasitedir — faturaya bakan kimsenin dikkatini çekmez.

Asıl bedel geri alınamayan üç kalemdedir. Sonlandırılan her örnek elindeki işi ve yerel diskini
götürür; kötü çiftte bu günde 156 fazladan kez olur ve bunların büyük bölümü **sağlıklı** örneklerin
sonlandırılmasıdır. Sağlıksız damgası geri döndürülemez: bir örnek iki denetimi geçemediği için
sağlıksız sayıldıysa, üçüncü denetimde yanıt verse bile geri alınmaz — çünkü artık yoktur.
Küçültülen kapasite de geri alınamaz; geri almak yeni bir açılış ve bir soğuma turu ister.

Grubun karar defterinde dokuz kalemin **altısı elde, üçü sağlayıcıdadır**. Elde kalanlar bu dersin
taradığı ayarlardır ve hepsi sayıyla seçilebilir. Sağlayıcıda kalan üçü sinsidir: sağlık denetimi
çağrısının kendi gecikmesi eşiği fiilen kaydırır, ölçekleme eyleminin uygulanma gecikmesi soğuma
süresine eklenir, istenen kapasitenin o an bulunamaması ise politikayı sessizce başarısız kılar.

## Özet

- İki döngü aynı sayıyı değiştirir: sağlık değiştirmesi grubu küçültür, politika bunu talep sanıp
  büyütür — talep hiç 18 örnek aşmadığı halde kötü çift grubu 24'e çıkarır.
- Kötü çiftte grubun yüzde 26'sı aynı anda değişmektedir; bu oranda ne ölçüt ne de gözlem grubun o
  anki durumunu söyler.
- Eşik iki hata arasında doğrudan takastır: eşik 2'de 12–14 yanlış değiştirme, eşik 5'te 0 — ama
  bozuk örnek 5–6 tur yerine 11–12 tur trafikte kalır.
- Soğuma süresi başka iki sütunu yönetir: dalgalanma 16–17'den 11'e iner, kapasite altı tur
  7–10'dan 42–47'ye çıkar.
- Sürekli değişim üreten çift eşik 2, soğuma 0'dır: saatte 11,5 örnek, günde 276 başlatma, 9,2
  örnek-saat boş kapasite; aynı işi eşik 3, soğuma 3 çifti günde 120 başlatmayla yapar.
- Dokuz kalemin altısı elde, üçü sağlayıcıdadır; geri alınamayan üç kalem sonlandırılan örneğin
  elindeki iş, sağlıksız damgası ve küçültülen kapasitedir.

## Sonraki Adım

Bu ders grubu iki döngüye devretti ve karşılığında altı ayar kalemi bıraktı: en az ve en çok örnek,
ölçüt, eşikler, soğuma, sağlık aralığı, şablon sürümü. Devir gerçektir — kimse artık örnek
başlatmıyor — ama elde kalan kalem sayısı azalmadı, yalnız türü değişti. Örnek seçmek yerine
politika seçiliyor.

Devir bir adım daha ileri gidebilir: makineyi hiç görmemek. M22/K02 ve M22/K03 konteyneri ve
orkestrasyonu ölçtü; o mekanik burada tekrarlanmaz. Sonraki ders aynı iş yükünü kendi kümesini
işletmekle yönetilen bir serviste çalıştırmak arasında karşılaştırır ve tek soruyu sorar: düğüm
boyutu, sürüm, yama, ağ eklentisi ve ölçekleme kararlarından kaçı her devirde elde kalıyor, görev
tabanlı çalıştırmada bu sayı ne oluyor ve her devirde hangi kalem geri alınamaz hale geliyor?
