---
title: 'Sağlık Denetimleri'
source: 'https://academia.sh/tr/kurslar/orkestrasyon/saglik-denetimleri'
course: 'Konteyner Orkestrasyonu'
language: tr
updated: '2026-08-17T18:09:09+00:00'
license: 'CC BY-SA 4.0'
---

# Sağlık Denetimleri

Canlılık, hazır olma ve başlangıç denetiminin ayrımı sayıyla kurulur: yanlış kapsamlı canlılık denetiminin gereksiz yeniden başlatması ve yeniden başlatma döngüsü, hazır olma denetimi olmadan erken trafiğe açılan kopyaya giden hatalı istek, başlangıç denetimi olmadan yavaş açılan kopyanın öldürülmesi ayrı ayrı sayılır.

Önceki dersin modeli boyunca bir kopya havuza girdiği anda hizmet verebiliyordu. Dağıtım
denetleyicisi de bu varsayımla ilerledi: bir kopya ayağa kalktıysa sayılır, sayıldıysa pay alır.
Gerçekte bir sürecin başlaması ile istek karşılayabilmesi arasında bir aralık vardır — bağlantı
havuzu kurulur, önbellek ısıtılır, bağımlılıklar yoklanır. Bu aralığı kimse bildirmezse
denetleyici kopyayı erken trafiğe açar. Tersi de olur: yavaş açılan bir kopyayı arızalı sayıp
öldürür ve bunu her açılışta yineler.

Devredilen karar burada iki tanedir ve çoğu zaman tek karar sanılırlar. Birincisi **bu kopya
yeniden başlatılsın mı**, ikincisi **bu kopyaya istek gönderilsin mi**. İlkinin cevabı yanlışsa
çalışan bir süreç öldürülür; ikincisininki yanlışsa çalışmayan bir sürece istek gider. Sistemin
bu iki kararı verebilmek için bilmesi gerekenler ayrı bilgi kalemleridir: sürecin kendisi yanıt
veriyor mu, bağımlılıkları elinde mi, ve hâlâ açılmakta mı. Üç soru, üç denetim. Bu dersin ölçüsü,
soruları birleştirmenin ne kadara mal olduğudur.

Hazır olma denetimi terimi daha önce tek makinedeki bileşim bağlamında kullanıldı; burada aynı
kavram küme ölçeğinde, havuz üyeliğini belirleyen denetim olarak geçiyor.

- **OI7.** Küme, kurgusal bölgesel ölçüm ağının doğrulayıcı servisini sekiz kopyayla, sıcak
  başlangıçla çalıştırır; tur başına elli istek gelir. Ağ da rakamlar da kurgudur.
- **OI8.** Altı kopya altı turda, iki kopya yirmi beş turda hizmet verebilir hâle gelir. İkisi
  açılışta önbellek ısıtan kopyalardır; bu fark uygulamadan gelir, kümeden değil.
- **OI9.** Olaylar elle yazıldı, rastgelelik yok. Geçici bağımlılık kaybı süresi dolunca
  kendiliğinden düzelir; kalıcı takılma yalnız yeniden başlatmayla çözülür.
- **OI10.** Denetim yanıtı kesindir: kopya ya yanıt verir ya vermez. Ağ kaynaklı yanlış negatif,
  denetim ucunun kendi gecikmesi ve zaman aşımı ayarı modellenmiyor.
- **OI11.** Yeniden başlatma anında olur. Kapsülün yeniden çizelgelenmesi, görüntü çekme ve düğüm
  seçimi bu ölçümün dışındadır; hepsi gecikmeyi büyütür, yönünü değiştirmez.
- **OI12.** "Gerçekten hizmette" sütunu, tur başına sağlıklı kopya sayısının ortalamasıdır. Hedef
  sekizdir ve bu sayı denetimlere değil, kopyaların gerçek durumuna bakar.

## Ölçüm Düzeneği

Ölçülen şey gerçek bir küme değil, `node` ile kurulan bir modeldir. Bir kopya her turda dört
durumdan birindedir: açılıyor, takıldı, bağımlılığı yok, sağlıklı. Denetimler bu durumu doğrudan
görmez; yalnız kendi kapsamlarına giren bir soruya evet ya da hayır alırlar.

```js
// saglik.mjs — canlilik, hazir olma ve baslangic denetimlerinin tur tabanli modeli
export const TUR = 180, TUR_ISTEK = 50, ACILIS = [6, 6, 6, 6, 6, 6, 25, 25];
export const PLANLI = [{ kopya: 6, tur: 20 }, { kopya: 7, tur: 20 }];  // iki kopya yeni surume gecer
export const ARIZA = [                                   // olaylar elle yazildi, rastgelelik yok
  { kopya: 3, tur: 50, tip: 'bagimlilikYok', sure: 18 }, // gecici: kendiliginden duzelir
  { kopya: 1, tur: 80, tip: 'takildi' },                 // kalici: ancak yeniden baslatma cozer
  { kopya: 4, tur: 120, tip: 'bagimlilikYok', sure: 10 },
  { kopya: 5, tur: 140, tip: 'takildi' } ];

export function kostur({ ad, canlilik, hazirOlma, baslangic }) {
  const k = ACILIS.map(() => ({ hazirTur: 0, takildi: false, cS: 0, hS: 0, bS: 0,
    basBitti: true, havuzda: true, yeniden: 0 }));
  const s = { ad, yeniden: 0, gereksiz: 0, acilista: 0, erken: 0, hatali: 0, havuzTur: 0, gec: [] };
  const takilmaTur = {};
  const durum = (i, t) => t < k[i].hazirTur ? 'aciliyor' : k[i].takildi ? 'takildi'
    : ARIZA.some((a) => a.kopya === i && a.sure && t >= a.tur && t < a.tur + a.sure)
      ? 'bagimlilikYok' : 'saglikli';
  const ac = (i, t) => Object.assign(k[i], { hazirTur: t + ACILIS[i], takildi: false,
    cS: 0, hS: 0, bS: 0, basBitti: !baslangic, havuzda: !hazirOlma });
  for (let t = 0; t < TUR; t += 1) {
    for (const p of PLANLI) if (p.tur === t) ac(p.kopya, t);          // planli acilis, sayaca girmez
    for (const a of ARIZA) if (a.tur === t && a.tip === 'takildi') { k[a.kopya].takildi = true; takilmaTur[a.kopya] = t; }
    for (let i = 0; i < k.length; i += 1) {
      const d = durum(i, t);
      if (!k[i].basBitti) {                              // baslangic denetimi bitmeden otekiler bakmaz
        if (t % baslangic.p) continue;
        if (d !== 'aciliyor') k[i].basBitti = true;
        else if ((k[i].bS += 1) >= baslangic.e) { s.yeniden += 1; s.acilista += 1; s.gereksiz += 1; k[i].yeniden += 1; ac(i, t); }
        continue;
      }
      if (canlilik && t % canlilik.p === 0) {
        const kotu = canlilik.kapsam === 'bagimlilik' ? d !== 'saglikli' : d === 'aciliyor' || d === 'takildi';
        if (!kotu) k[i].cS = 0;
        else if ((k[i].cS += 1) >= canlilik.e) {
          s.yeniden += 1; k[i].yeniden += 1;
          if (d === 'takildi') s.gec.push(t - takilmaTur[i]); else s.gereksiz += 1;
          if (d === 'aciliyor') s.acilista += 1;
          ac(i, t);
        }
      }
      if (hazirOlma && t % hazirOlma.p === 0) {
        if (d === 'saglikli') { k[i].hS = 0; k[i].havuzda = true; }
        else if ((k[i].hS += 1) >= hazirOlma.e) k[i].havuzda = false;
      }
    }
    const havuz = k.map((_, i) => i).filter((i) => k[i].havuzda);        // denetimin inandigi havuz
    s.havuzTur += k.filter((_, i) => durum(i, t) === 'saglikli').length; // gercekten hizmet verebilen
    for (let r = 0; r < TUR_ISTEK; r += 1) {
      if (!havuz.length) { s.hatali += 1; continue; }
      const d = durum(havuz[r % havuz.length], t);
      if (d === 'saglikli') continue;
      s.hatali += 1;
      if (d === 'aciliyor') s.erken += 1;
    }
  }
  s.dongu = k.filter((c) => c.yeniden >= 3).length;
  return s;
}
```

İki satır bu modelin bütün ayrımını taşıyor. Canlılık denetiminin `kapsam` alanı `surec` ise
denetim yalnız açılıyor ve takıldı durumlarında başarısız olur — bağımlılık kaybını görmez. Aynı
alan `bagimlilik` ise denetim hazır olma denetimiyle **aynı soruyu** sorar; tek bir denetim ucu
hem yeniden başlatmayı hem havuz üyeliğini sürdürür. İkinci satır `havuz` ile `havuzTur`
arasındaki farktır: birincisi denetimin inandığı havuz, ikincisi gerçekten hizmet verebilen kopya
sayısı. İkisinin ayrılabildiği her yerde bir yanlış karar vardır.

## Dört Ayar, Tek Olay Dizisi

```js
// kosum3.mjs — dort ayar ayni olay dizisinde kosturulur
import { kostur, TUR, TUR_ISTEK } from './saglik.mjs';

const AYAR = [
  { ad: 'denetim yok', canlilik: null, hazirOlma: null, baslangic: null },
  { ad: 'tek birlesik denetim', canlilik: { p: 5, e: 3, kapsam: 'bagimlilik' },
    hazirOlma: { p: 5, e: 3 }, baslangic: null },
  { ad: 'canlilik + hazir olma', canlilik: { p: 5, e: 3, kapsam: 'surec' },
    hazirOlma: { p: 2, e: 1 }, baslangic: null },
  { ad: 'ustune baslangic', canlilik: { p: 5, e: 3, kapsam: 'surec' },
    hazirOlma: { p: 2, e: 1 }, baslangic: { p: 5, e: 6 } },
];
console.log(`8 kopya, ${TUR} tur, tur basina ${TUR_ISTEK} istek; iki kopya 25 turda aciliyor`);
console.log('tur 20: iki yavas kopya planli olarak yeniden acilir | tur 80 ve 140: kalici takilma');
console.log('tur 50 ve 120: gecici bagimlilik kaybi, 18 ve 10 tur surer, kendiliginden duzelir\n');
console.log('ayar                  yeniden  gereksiz  acilista  donguye  erken   toplam  gercekten  takilmayi');
console.log('                      baslatma yeniden   oldurulen giren    hatali  hatali  hizmette   fark etme');
for (const a of AYAR) {
  const s = kostur(a);
  console.log(`${s.ad.padEnd(21)} ${String(s.yeniden).padEnd(8)} ${String(s.gereksiz).padEnd(9)} ` +
    `${String(s.acilista).padEnd(9)} ${String(s.dongu).padEnd(8)} ${String(s.erken).padEnd(7)} ` +
    `${String(s.hatali).padEnd(7)} ${(s.havuzTur / TUR).toFixed(2).padEnd(10)} ${s.gec.join(', ') || '-'}`);
}
```

```
8 kopya, 180 tur, tur basina 50 istek; iki kopya 25 turda aciliyor
tur 20: iki yavas kopya planli olarak yeniden acilir | tur 80 ve 140: kalici takilma
tur 50 ve 120: gecici bagimlilik kaybi, 18 ve 10 tur surer, kendiliginden duzelir

ayar                  yeniden  gereksiz  acilista  donguye  erken   toplam  gercekten  takilmayi
                      baslatma yeniden   oldurulen giren    hatali  hatali  hizmette   fark etme
denetim yok           0        0         0         0        300     1408    6.79       -
tek birlesik denetim  23       21        20        2        0       330     5.89       10, 10
canlilik + hazir olma 22       20        20        2        0       0       5.89       10, 10
ustune baslangic      2        0         0         0        0       0       7.39       10, 10
```

Denetimsiz satır tabanı veriyor: hiçbir kopya yeniden başlatılmadı, iki kalıcı takılma yüz ve kırk
tur boyunca fark edilmeden sürdü, bin dört yüz sekiz istek hata aldı. Bunun üç yüzü açılmakta olan
kopyalara gitti — yani hazır olma denetiminin olmamasının tek başına bedeli üç yüz istektir. Geri
kalan bin yüz sekiz, takılan ve bağımlılığını yitiren kopyalara giden isteklerdir.

Tek birleşik denetim hatalı isteği bin dört yüzden üç yüz otuza indirdi ve takılmayı on turda fark
etti. Bedeli ikinci ve üçüncü sütunda: yirmi üç yeniden başlatmanın yirmi biri gereksizdi. Bu
denetim bağımlılık kaybını da arıza sayıyor, dolayısıyla dışarıdaki bir kesinti sağlıklı bir süreci
öldürüyor. Kalıcı takılmayla geçici bağımlılık kaybını ayırt edememenin fiyatı budur: kendiliğinden
düzelecek bir durum, yeniden başlatmayla düzeltiliyor.

Üçüncü satır canlılık denetiminin kapsamını süreçle sınırlıyor ve hazır olma denetimini ayırıyor.
Hatalı istek sıfıra indi — havuz artık bağımlılığını yitirmiş kopyayı iki turda dışarı alıyor, ama
onu öldürmüyor. Gereksiz yeniden başlatma yine de yirmi. Kaynağı geçici arıza değil: yirmisi de
**açılışta öldürme**. Canlılık denetimi beş turda bir bakıyor, üç ardışık başarısızlıkta
öldürüyor; on beş turluk bu pay, yirmi beş turda açılan iki kopya için yetmiyor. O iki kopya her
seferinde açılışın ortasında öldürülüp baştan başlıyor — iki kopya yeniden başlatma döngüsünde.

Bu satırın asıl ölçüsü sondan ikinci sütundur. Hatalı istek sıfır, ama gerçekten hizmet veren kopya
sayısı 5,89 — sekiz hedeflenen kümede **iki kopyadan fazlası kalıcı olarak yok**. Hazır olma
denetimi döngüdeki kopyaları havuzun dışında tuttuğu için bu kayıp tek bir hata kaydı üretmiyor.
Kümenin hata oranına bakan biri her şeyin yolunda olduğunu görür; kayıp yalnız kapasitede durur ve
yük arttığında kalan altı kopyanın üstüne biner.

Dördüncü satır başlangıç denetimini ekliyor: yeniden başlatma yirmi üçten ikiye, yani **yalnız iki
gerçek takılmaya** iniyor, gereksiz yeniden başlatma sıfırlanıyor, hizmetteki kopya 7,39'a çıkıyor.
Takılmayı fark etme süresi değişmedi. Başlangıç denetiminin yaptığı şey yeni bir arıza yakalamak
değil, **canlılık denetimini açılış penceresi boyunca susturmaktır**.

## Eşik ve Periyot

Üçüncü satırın açılışta öldürmesi canlılık denetiminin ayarını gevşeterek de giderilebilir.
Tarama bunun neye mal olduğunu gösteriyor.

```js
// kosum4.mjs — canlilik denetiminin periyodu ve esigi taranir, once baslangic denetimi olmadan
import { kostur, TUR } from './saglik.mjs';

const HAZIR = { p: 2, e: 1 };
const yaz = (etiket, baslangic) => {
  console.log(`\n${etiket}`);
  console.log('periyot  esik  hosgoru  takilmayi   acilista   donguye  gercekten');
  console.log('               (tur)    fark etme   oldurulen  giren    hizmette');
  for (const p of [2, 5, 10]) for (const e of [2, 3, 6]) {
    const s = kostur({ ad: '', canlilik: { p, e, kapsam: 'surec' }, hazirOlma: HAZIR, baslangic });
    console.log(`${String(p).padEnd(8)} ${String(e).padEnd(5)} ${String(p * e).padEnd(8)} ` +
      `${(s.gec.join(', ') || '-').padEnd(11)} ${String(s.acilista).padEnd(10)} ` +
      `${String(s.dongu).padEnd(8)} ${(s.havuzTur / TUR).toFixed(2)}`);
  }
};
console.log('yavas acilan iki kopya 25 turda hazir oluyor; kalici takilma tur 80 ve 140');
yaz('baslangic denetimi yok:', null);
yaz('baslangic denetimi var (periyot 5, esik 6 — 30 turluk acilis payi):', { p: 5, e: 6 });
```

```
yavas acilan iki kopya 25 turda hazir oluyor; kalici takilma tur 80 ve 140

baslangic denetimi yok:
periyot  esik  hosgoru  takilmayi   acilista   donguye  gercekten
               (tur)    fark etme   oldurulen  giren    hizmette
2        2     4        2, 2        113        4        5.29
2        3     6        4, 4        52         2        5.96
2        6     12       10, 10      26         2        5.89
5        2     10       5, 5        32         2        5.94
5        3     15       10, 10      20         2        5.89
5        6     30       25, 25      0          0        7.22
10       2     20       10, 10      16         2        5.89
10       3     30       20, 20      2          0        7.06
10       6     60       50          0          0        7.03

baslangic denetimi var (periyot 5, esik 6 — 30 turluk acilis payi):
periyot  esik  hosgoru  takilmayi   acilista   donguye  gercekten
               (tur)    fark etme   oldurulen  giren    hizmette
2        2     4        2, 2        0          0        7.48
2        3     6        4, 4        0          0        7.46
2        6     12       10, 10      0          0        7.39
5        2     10       5, 5        0          0        7.44
5        3     15       10, 10      0          0        7.39
5        6     30       25, 25      0          0        7.22
10       2     20       10, 10      0          0        7.39
10       3     30       20, 20      0          0        7.28
10       6     60       50          0          0        7.03
```

Üst tabloda tek bir ayar iki işi birden yapıyor ve iki iş ters yöne çekiyor. Hoşgörü penceresi
kısaldıkça takılma çabuk fark ediliyor — dört turluk pencerede iki turda — ama açılışta öldürme
yüz on üçe fırlıyor ve dört kopya döngüye giriyor; hizmetteki kopya 5,29'a düşüyor. Pencere
uzadıkça öldürme azalıyor, fark etme gecikmesi büyüyor. Açılışta hiç öldürmeyen üç satır var ve
üçünün de hoşgörüsü otuz turun üstünde: takılmayı yirmi beş, yirmi ve elli turda fark ediyorlar.
Son satırda takılma sütununda tek bir sayı var — altmış turluk pencere, yüz kırkıncı turdaki
ikinci takılmayı ölçüm ufkunun sonuna kadar hiç fark etmedi.

Alt tablo aynı taramayı otuz turluk açılış payı veren bir başlangıç denetimiyle yineliyor. Açılışta
öldürme sütunu **her satırda sıfır**, döngü sütunu her satırda sıfır. Gerilim ortadan kalktı,
çünkü iki iş iki ayara bölündü: açılış penceresini başlangıç denetimi karşılıyor, canlılık denetimi
yalnız açılışı bitmiş kopyalara bakıyor. Artık periyot ve eşik tek bir ölçüte göre seçilebilir —
takılmayı fark etme gecikmesi. En hızlı satır dört turluk pencere: iki turda fark ediyor ve
hizmetteki kopya 7,48 ile taramanın en yükseği.

Üç denetimin ayrımı bu iki tablonun farkıdır. Aynı canlılık ayarı, üstte 113 gereksiz öldürme
üretirken altta sıfır üretiyor. Değişen tek şey, sistemin **açılmakta olmakla arızalı olmayı**
ayırt edebilmesi. Bu ayrım bir bilgi kalemidir ve bedeli bir denetim daha koşturmaktır; karşılığı,
canlılık ayarının uygulamanın açılış süresinden bağımsız hâle gelmesidir.

## Özet

- Denetimsiz kümede iki kalıcı takılma hiç fark edilmedi ve 1408 istek hata aldı; bunun 300'ü
  açılmakta olan kopyalara giden isteklerdir, yani hazır olma denetiminin yokluğunun payıdır.
- Tek birleşik denetim hatalı isteği 330'a indirdi ama 23 yeniden başlatmanın 21'i gereksizdi:
  bağımlılık kaybını takılmadan ayırt edemeyen denetim, kendiliğinden düzelecek durumu
  yeniden başlatmayla düzeltir.
- Canlılık denetimini süreçle sınırlayıp hazır olma denetimini ayırmak hatalı isteği sıfıra
  indirdi, ama yavaş açılan iki kopya açılışın ortasında öldürülmeye devam etti ve döngüye girdi.
- Yeniden başlatma döngüsü hata oranında görünmez: hatalı istek sıfırken gerçekten hizmet veren
  kopya sayısı 8 hedefine karşı 5,89'du; kayıp kapasitede durur, hata kaydında değil.
- Tek ayarla iki iş yapıldığında hoşgörü penceresi kısaldıkça fark etme hızlanır ve açılışta
  öldürme 113'e çıkar; uzadıkça öldürme biter ama 60 turluk pencere ikinci takılmayı hiç görmez.
- Başlangıç denetimi eklendiğinde taramanın dokuz satırında da açılışta öldürme sıfırlanır;
  canlılık ayarı artık yalnız fark etme gecikmesine göre seçilir ve 4 turluk pencere hem en hızlı
  hem en yüksek kapasiteli satırdır.

## Sonraki Adım

Bu iki dersin denetleyicileri kümede kısıtsız iş görüyor: sürüm nesnesini değiştiriyor, kopya
öldürüyor, havuz üyeliğini yazıyor. Aynı arayüzü insanlar ve otomatik süreçler de kullanıyor ve
şimdiye kadar hiçbiri "bunu yapmaya yetkin var mı" sorusuyla karşılaşmadı. Sonraki ders bu soruyu
sayıya çeviriyor: bir özne × fiil × nesne yetki matrisi kurulur, geniş yetkiden en az yetkiye
inince kaç işlemin düştüğü ve bunun kaç satır rol tanımına mal olduğu ölçülür — ve bir özneye
verilen yetkinin başka bir özneye yetki verebildiği yollar sayılır.
