Kabul Denetleyicisi

Önceki ders koşan konteynerin davranışını ölçtü ve tespitin on yedi ya da kırk yedi saniye sonra geldiğini yazdı. Yakalanan on iki olayın dokuzu için erken bir aşama vardı: görüntüde bulunmaması gereken bir ikili, koşum başlamadan önce çıkarılabilirdi. O kararın alındığı yer bir kapıdır ve o kapı henüz ölçülmedi.

Bu ders kabul denetleyicisini ölçer: kümeye bir nesne gönderildiğinde nesnenin bildirilen alanlarına bakıp kabul ya da ret veren kapı. Küme nesnesi mekaniği — nesne türleri, ad alanı, yetkilendirme — Konteyner Orkestrasyonu kursunda ölçüldü ve burada girdi olarak alınıyor. Buradaki ölçü üç sütunludur: kaç kusur kapanıyor, kaç meşru dağıtım reddediliyor, kaç ekip etkileniyor. Üçüncüsü yazılmadığında ilk ikisi bir şey ölçmez, çünkü zorlama kipine geçmek bir yapılandırma değişikliği değil, beş ekibin dağıtım akışına dokunan bir karardır.

• AD12. Ortam aynı kurgusal bölgesel ölçüm ağıdır: bir küme, dokuz servisin nesneleri, zamanlanmış iş nesneleri ve platform iş yükleri; beş ekip. Nesne kümesi node ile kurulmuş bir modeldir.
• AD13. Modellenen tek şey bir nesnenin hangi kuralları ihlal ettiğidir. Nesnelerin alan yapısı, sürüm nesnesi ile kapsül ilişkisi ve ad alanı mekaniği modellenmiyor.
• AD14. İhlaller üç sınıfa ayrıldı: kusur (sahibinin düzeltmesi gereken kalem), gerekçe (belgelenmiş meşru ihtiyaç), uyumsuz (kuralın o nesne türüne uymaması). Üretimde bu ayrım bir inceleme sonucudur ve en pahalı adım odur; modelde verilmiş kabul ediliyor.
• AD15. Bir nesne, zorlanan kurallardan birini ihlal ediyorsa reddedilir; kısmi kabul yok.
• AD16. Haftalık dağıtım sayıları nesne başına sabittir. Ondalık değer daha seyrek bir sıklığı temsil eder: 0,2 beş haftada bir dağıtım demektir.
• AD17. Kapının kendi arızası — kapı düştüğünde dağıtımın açılması mı durması mı gerektiği — modellenmiyor; bu ayrı bir karardır.

Nesne Kümesi ve Kural Kümesi

// nesne.mjs — yirmi iki kume nesnesi, on kabul kurali ve ihlallerin sinifi. MODELDIR.
export const KURAL = ['kaynak siniri yok', 'salt okunur kok degil', 'ayricalikli kip',
  'ana makine ag alani', 'kok kullanici', 'degisken goruntu etiketi', 'imzasiz goruntu',
  'saglik yoklamasi yok', 'sahip etiketi yok', 'sir ortam degiskeninde'];
export const K = Object.fromEntries(KURAL.map((a, i) => [`K${i + 1}`, a]));

// [ad, ekip, hattan geciyor mu, haftalik dagitim, {kural: ihlal sinifi}]
// ihlal sinifi: kusur = sahibinin duzeltmesi gereken kalem, gerekce = belgelenmis mesru
// ihtiyac, uyumsuz = kural bu nesne turune uymuyor (tek seferlik is nesnesi).
export const NESNE = [
  ['portal-onu', 'abone', 1, 2, { K6: 'kusur' }],
  ['abone-servisi', 'abone', 1, 2, { K1: 'kusur', K10: 'kusur' }],
  ['bildirim', 'abone', 1, 1, { K2: 'kusur' }],
  ['portal-toplu-is', 'abone', 1, 0.5, { K1: 'kusur', K8: 'uyumsuz' }],
  ['faturalama', 'faturalama', 1, 2, { K5: 'kusur', K10: 'kusur' }],
  ['rapor', 'faturalama', 1, 1, { K6: 'kusur' }],
  ['aylik-uzlastirma', 'faturalama', 1, 0.2, { K8: 'uyumsuz' }],
  ['ceyreklik-arsiv', 'faturalama', 1, 0.1, { K8: 'uyumsuz', K9: 'kusur' }],
  ['is-emri', 'saha', 1, 2, { K2: 'kusur' }],
  ['saha-senkron', 'saha', 1, 2, { K1: 'kusur', K2: 'kusur', K7: 'kusur' }],
  ['saha-yukleme-isi', 'saha', 1, 0.5, { K8: 'uyumsuz' }],
  ['sayac-toplama', 'olcum', 1, 2, {}],
  ['dogrulayici', 'olcum', 1, 2, { K5: 'kusur' }],
  ['sayac-yedek-isi', 'olcum', 1, 0.3, { K2: 'kusur', K8: 'uyumsuz' }],
  ['giris-denetleyici', 'platform', 1, 0.5, { K4: 'gerekce' }],
  ['gunluk-toplayici', 'platform', 1, 0.5, { K2: 'kusur', K3: 'gerekce' }],
  ['izleme-toplayici', 'platform', 1, 0.5, { K3: 'gerekce' }],
  ['sertifika-dagitici', 'platform', 1, 0.3, { K10: 'kusur' }],
  ['kayit-aynasi', 'platform', 1, 0.3, { K6: 'kusur', K7: 'kusur' }],
  ['yedek-surucusu', 'platform', 0, 0.2, { K1: 'kusur', K5: 'kusur' }],
  ['ag-eklentisi', 'platform', 0, 0.2, { K3: 'gerekce', K4: 'gerekce', K5: 'gerekce' }],
  ['dugum-aracisi', 'platform', 0, 0.1, { K3: 'gerekce', K5: 'gerekce', K9: 'kusur' }],
];

export const EKIP = [...new Set(NESNE.map((n) => n[1]))];
export const ihlal = (n, E) => Object.entries(n[4]).filter(([k]) => E.includes(k));

// Zorlama kipinde bir nesne, zorlanan kurallardan birini ihlal ediyorsa reddedilir.
// Reddedilen nesnede zorlanan kurallar arasinda hic kusur yoksa bu bir MESRU rettir.
export function zorla(E) {
  const ret = NESNE.filter((n) => ihlal(n, E).length);
  const mesru = ret.filter((n) => ihlal(n, E).every(([, s]) => s !== 'kusur'));
  return { ret, mesru, kusur: NESNE.reduce((a, n) => a + ihlal(n, E).filter(([, s]) => s === 'kusur').length, 0),
    ekip: new Set(ret.map((n) => n[1])).size, mekip: new Set(mesru.map((n) => n[1])).size,
    dagitim: ret.reduce((a, n) => a + n[3], 0), mdagitim: mesru.reduce((a, n) => a + n[3], 0) };
}

export const TUM = Object.keys(K);
export const gen = (B) => (h) => h.map((v, j) => j ? String(v).padStart(B[j]) : String(v).padEnd(B[0])).join('');

Kural kümesi bir nesnenin yalnız bildirilen alanlarına bakıyor; koşan bir şeye değil. Bu, dersin sonundaki karşılaştırmanın da dayanağıdır.

Üç Kip ve Kural Başına Bilanço

// kosum1.mjs — uc kip, kural basina bilanco ve kurallari siraya koyarak zorlama
import { NESNE, KURAL, K, TUM, EKIP, ihlal, zorla, gen } from './nesne.mjs';

const say = (s) => NESNE.reduce((a, n) => a + Object.values(n[4]).filter((x) => x === s).length, 0);
const z = zorla(TUM);
console.log(`${NESNE.length} nesne, ${EKIP.length} ekip, ${KURAL.length} kural; ihlal ${say('kusur') + say('gerekce') + say('uyumsuz')} ` +
  `(kusur ${say('kusur')} / gerekce ${say('gerekce')} / uyumsuz ${say('uyumsuz')})\n`);
const yk = gen([10, 12, 14, 13, 16, 13]);
console.log(yk(['kip', 'uyari kaydi', 'reddedilen', 'mesru ret', 'etkilenen ekip', 'ret/hafta']));
console.log(yk(['kapali', 0, 0, 0, 0, 0]));
console.log(yk(['uyari', z.ret.reduce((a, n) => a + ihlal(n, TUM).length, 0), 0, 0, 0, 0]));
console.log(yk(['zorlama', 0, z.ret.length, z.mesru.length, `${z.ekip}/${EKIP.length}`, z.dagitim.toFixed(1)]));

const bilanco = TUM.map((k) => ({ k, kusur: zorla([k]).kusur, mesru: zorla([k]).mesru.length }));
console.log('\n' + gen([6, 26, 8, 11])(['kural', 'ad', 'kusur', 'mesru ret']));
for (const b of bilanco) console.log(gen([6, 26, 8, 11])([b.k, K[b.k], b.kusur, b.mesru]));

const sira = [...bilanco].sort((a, b) => b.kusur / (1 + b.mesru) - a.kusur / (1 + a.mesru)).map((b) => b.k);
console.log(`\nkurallar kusur/(1+mesru ret) oranina gore siraya konup birer birer zorlaniyor:`);
const yz = gen([8, 26, 15, 13, 12, 15]);
console.log(yz(['adim', 'eklenen kural', 'kapanan kusur', 'reddedilen', 'mesru ret', 'mesru ret ekip']));
for (let i = 1; i <= sira.length; i++) {
  const r = zorla(sira.slice(0, i));
  console.log(yz([i, K[sira[i - 1]], r.kusur, r.ret.length, r.mesru.length, r.mekip]));
}

22 nesne, 5 ekip, 10 kural; ihlal 35 (kusur 22 / gerekce 8 / uyumsuz 5)

kip        uyari kaydi    reddedilen    mesru ret  etkilenen ekip    ret/hafta
kapali               0             0            0               0            0
uyari               35             0            0               0            0
zorlama              0            21            5             5/5         18.2

kural                         ad   kusur  mesru ret
K1             kaynak siniri yok       4          0
K2         salt okunur kok degil       5          0
K3               ayricalikli kip       0          4
K4           ana makine ag alani       0          2
K5                 kok kullanici       3          2
K6      degisken goruntu etiketi       3          0
K7               imzasiz goruntu       2          0
K8          saglik yoklamasi yok       0          5
K9             sahip etiketi yok       2          0
K10       sir ortam degiskeninde       3          0

kurallar kusur/(1+mesru ret) oranina gore siraya konup birer birer zorlaniyor:
adim                 eklenen kural  kapanan kusur   reddedilen   mesru ret mesru ret ekip
1            salt okunur kok degil              5            5           0              0
2                kaynak siniri yok              9            8           0              0
3         degisken goruntu etiketi             12           11           0              0
4           sir ortam degiskeninde             15           13           0              0
5                  imzasiz goruntu             17           13           0              0
6                sahip etiketi yok             19           15           0              0
7                    kok kullanici             22           17           1              1
8                  ayricalikli kip             22           18           2              1
9              ana makine ag alani             22           19           3              1
10            saglik yoklamasi yok             22           21           5              3

Üst tablo zorlama kipine hepsi birden geçmenin fiyatını veriyor. Uyarı kipi otuz beş kayıt üretir ve hiçbir dağıtımı durdurmaz; bu, kapının kurulduğu ama hiçbir şeyi değiştirmediği evredir. Zorlama açıldığında yirmi bir nesne reddedilir, haftada on sekiz virgül iki dağıtım düşer ve beş ekibin beşi etkilenir. Reddedilenlerin beşinde ise kapının şikâyet ettiği tek bir kusur yoktur: ihlal ettikleri kuralların hepsi ya belgelenmiş bir gerekçedir ya da o nesne türüne uymayan bir kuraldır.

Orta tablo bu beş meşru reddin nereden geldiğini tek tek gösteriyor. Üç kural — ayrıcalıklı kip, ana makine ağ alanı ve sağlık yoklaması — hiçbir kusur kapatmıyor ve meşru reddin tamamını üretiyor. Sağlık yoklaması kuralı tek başına beş meşru ret verir, çünkü beş nesnenin beşi de tek seferlik iş nesnesidir ve kural onlara hiç uygulanmamalıydı. Kök kullanıcı kuralı ikisinin arasında durur: üç kusur kapatır, iki meşru ret verir. Bir kuralı zorlamaya almanın kararı bu iki sütunun oranıdır, kuralın adı değil.

Kademeli Zorlama Nereye Kadar Bedavadır

Alt tablo kuralları o orana göre sıraya koyup birer birer zorluyor. İlk altı adımda meşru ret sıfırdır ve kapanan kusur on dokuza çıkar: yirmi iki kusurun yüzde seksen altısı, hiçbir meşru dağıtımı durdurmadan kapanıyor. Yedinci adım kök kullanıcı kuralını ekler, üç kusur daha kapatarak yirmi ikiyi tamamlar ve bedeli tek bir meşru rettir.

Son üç adım sıfır kusur kapatıyor. Sekizinci, dokuzuncu ve onuncu satırda kapanan kusur sütunu yirmi ikide sabit kalırken meşru ret birden beşe, meşru redde uğrayan ekip birden üçe çıkıyor. Kapının bir hafta içinde üç ekibin dağıtımını gerekçesiz durdurmasının kaynağı bu üç kuraldır ve üçünün de kazancı sıfırdır. Zorlama kipine hepsi birden geçmenin yanlışlığı burada sayıya bağlanır: aynı yirmi iki kusur, sıralı bir açılışla ve tek bir meşru retle kapanabiliyordu.

Muafiyetin Genişliği ve Hat Kapısı

// kosum2.mjs — muafiyetin genisligi ve ayni kuralin hat kapisinda kosmasi
import { NESNE, KURAL, EKIP, gen } from './nesne.mjs';

// Muafiyet iki granuluk: nesne basina (ad|kural) ya da ad alani basina (ekip|kural).
const anahtar = (i) => NESNE.flatMap((n) => Object.entries(n[4])
  .filter(([, s]) => s !== 'kusur').map(([k]) => `${n[i]}|${k}`));
const NESNE_MUAF = new Set(anahtar(0)), EKIP_MUAF = new Set(anahtar(1));
const hucre = (M, i) => NESNE.reduce((a, n) => a + KURAL.filter((_, j) => M.has(`${n[i]}|K${j + 1}`)).length, 0);

const olc = (muaf) => {
  const acik = (n) => Object.entries(n[4]).filter(([k]) => !muaf(n, k));
  const ret = NESNE.filter((n) => acik(n).length);
  return { ret: ret.length, mesru: ret.filter((n) => acik(n).every(([, s]) => s !== 'kusur')).length,
    kusur: NESNE.reduce((a, n) => a + acik(n).filter(([, s]) => s === 'kusur').length, 0),
    dagitim: ret.reduce((a, n) => a + n[3], 0) };
};

const AYAR = [['muafiyet yok', () => false, 0, 0],
  ['nesne basina', (n, k) => NESNE_MUAF.has(`${n[0]}|${k}`), NESNE_MUAF.size, hucre(NESNE_MUAF, 0)],
  ['ad alani basina', (n, k) => EKIP_MUAF.has(`${n[1]}|${k}`), EKIP_MUAF.size, hucre(EKIP_MUAF, 1)]];
const ym = gen([18, 8, 12, 13, 13, 11, 12]);
console.log(ym(['muafiyet bicimi', 'satir', 'kapsanan', 'acik kusur', 'reddedilen', 'mesru ret', 'ret/hafta']));
for (const [ad, f, satir, kaps] of AYAR) {
  const r = olc(f);
  console.log(ym([ad, satir, kaps, r.kusur, r.ret, r.mesru, r.dagitim.toFixed(1)]));
}

const hatta = NESNE.filter((n) => n[2]), disi = NESNE.filter((n) => !n[2]);
const kusur = (l) => l.reduce((a, n) => a + Object.values(n[4]).filter((s) => s === 'kusur').length, 0);
console.log(`\non kuralin onu da nesnenin bildirilen alanlarina bakiyor: ayni kural hat kapisinda kosabilir`);
console.log(`  hattan gecen nesne ${hatta.length}/${NESNE.length}, tasidiklari kusur ${kusur(hatta)}/${kusur(NESNE)}`);
console.log(`  hat disinda olusturulan nesne ${disi.length} (${disi.map((n) => n[0]).join(', ')}), kusur ${kusur(disi)}`);

const mesruN = NESNE.filter((n) => Object.values(n[4]).length && Object.values(n[4]).every((s) => s !== 'kusur'));
const toplam = NESNE.reduce((a, n) => a + n[3], 0), kalici = mesruN.reduce((a, n) => a + n[3], 0);
console.log(`\nhaftalik dagitim ${toplam.toFixed(1)}; zorlama acildigi hafta reddedilen ${olc(() => false).dagitim.toFixed(1)}`);
console.log(`  ${kusur(NESNE)} kusur duzeltildikten sonra kalici mesru ret ${kalici.toFixed(1)}/hafta, ` +
  `${EKIP.length} ekibin ${new Set(mesruN.map((n) => n[1])).size}'unde; kalici olmasinin nedeni kusur degil kural kapsamidir`);

muafiyet bicimi      satir    kapsanan   acik kusur   reddedilen  mesru ret   ret/hafta
muafiyet yok             0           0           22           21          5        18.2
nesne basina            13          13           22           16          0        16.3
ad alani basina          7          38           21           16          0        16.3

on kuralin onu da nesnenin bildirilen alanlarina bakiyor: ayni kural hat kapisinda kosabilir
  hattan gecen nesne 19/22, tasidiklari kusur 19/22
  hat disinda olusturulan nesne 3 (yedek-surucusu, ag-eklentisi, dugum-aracisi), kusur 3

haftalik dagitim 20.2; zorlama acildigi hafta reddedilen 18.2
  22 kusur duzeltildikten sonra kalici mesru ret 1.9/hafta, 5 ekibin 3'unde; kalici olmasinin nedeni kusur degil kural kapsamidir

Üst tablonun ikinci ve üçüncü satırı meşru reddi ikisi de sıfırlıyor, reddedilen nesneyi ikisi de on altıya indiriyor. Fark iki sütundadır. Nesne başına muafiyet on üç satırdır ve tam olarak on üç hücreyi kapsar; ad alanı başına muafiyet yedi satırdır ve otuz sekiz hücreyi kapsar — yarı yarıya az satır, üç kattan fazla kapsam. Bedeli üçüncü sütunda: açık kusur yirmi ikiden yirmi bire iniyor. Yedek sürücüsünün kök kullanıcı olarak koşması, ağ eklentisi ile düğüm aracısı için yazılmış olan platform muafiyetinin altında sessizce meşrulaşıyor.

Kapsanan hücre sayısı gelecekteki nesneleri de içerir: o ad alanında sonradan oluşturulan her nesne muafiyeti hazır bulur. Muafiyet listesi bu yüzden önceki iki derste ölçülen listelerle aynı türdendir — bir ayar değil, kapsamı sayılmadığında kural kümesinden daha belirleyici olan bir envanter.

Daha Erken Nerede Kapanırdı

On kuralın onu da nesnenin bildirilen alanlarına bakıyor; hiçbiri koşan bir şeyi okumuyor. Bu, kuralların tamamının hat kapısında, nesne kümeye gönderilmeden önce koşabileceği anlamına gelir. Fark kuralın kendisinde değil, reddin kime ve ne zaman değdiğindedir: hat kapısında ret değişikliği yazan kişiye birleştirme anında gelir; kabul kapısında dağıtım sırasında, çoğu zaman o anda nöbette olan başka birine gelir ve bir sürüm penceresini bloke eder.

Yirmi iki nesnenin on dokuzu hattan geçiyor ve yirmi iki kusurun on dokuzu bu nesnelerde. Yani kusurların yüzde seksen altısı, hiç kimsenin dağıtımını durdurmadan, sahibinin masasında kapatılabilirdi. Kalan üç kusur hat dışında elle oluşturulan üç platform nesnesindedir ve hat kapısı onları tanım gereği hiç görmez. Kabul kapısının yalnız kendisine ait payı bu üçtür; kalan on dokuz için kapı ikinci savunma hattıdır, birinci değil.

Son satır kalıcı bir kalemi yazıyor. Yirmi iki kusur düzeltildikten sonra bile haftada bir virgül dokuz dağıtım reddedilmeye devam eder ve bu üç ekibi ilgilendirir. Nedeni bir kusur değil, kural kapsamının nesne türüyle uyuşmamasıdır. Bu kalem muafiyetle kapatılabilir ve kapatıldığında on üç ya da yedi satırlık bir envanter doğar — ya da kural nesne türünü okuyacak biçimde yeniden yazılır ve envanter hiç doğmaz.

Özet

• 22 nesnede 35 ihlal var: 22 kusur, 8 belgelenmiş gerekçe, 5 kuralın uymadığı nesne. Uyarı kipi 35 kayıt üretir ve hiçbir dağıtımı durdurmaz.
• Zorlama kipine hepsi birden geçmek 21 nesneyi reddeder, haftada 18,2 dağıtımı düşürür ve 5 ekibin 5’ini etkiler; reddedilenlerin 5’i hiçbir kusur taşımayan meşru dağıtımdır.
• Üç kural (ayrıcalıklı kip, ana makine ağ alanı, sağlık yoklaması) hiç kusur kapatmadan meşru reddin tamamını üretir; sağlık yoklaması tek başına 5 meşru ret verir.
• Kurallar kusur oranına göre sıraya konduğunda ilk 6 adım 22 kusurun 19’unu sıfır meşru retle kapatır, 7. adım kalan 3 kusuru tek bir meşru retle kapatır; son 3 adım sıfır kusur kapatıp meşru reddi 5’e, etkilenen ekibi 3’e çıkarır.
• Muafiyet nesne başına 13 satırla 13 hücre, ad alanı başına 7 satırla 38 hücre kapsar; ikincisi bir gerçek kusuru sessizce muaf tutar ve ad alanındaki gelecek nesneleri de kapsar.
• On kuralın onu da hat kapısında koşabilir; 22 kusurun 19’u hattan geçen nesnelerdedir. Yalnız kabul kapısında kapatılabilen kusur 3’tür ve üçü de elle oluşturulan platform nesnelerindedir.

Sonraki Adım

Bu dersin kapısı yalnız gönderilen nesneyi gördü. Kümede hâlihazırda koşan nesneler kapıdan bir daha geçmez; kural kümesi bugün sıkılaştırılsa bile dün kabul edilmiş yirmi iki nesne yerinde durur. Kümenin dışındaki altyapı kaynakları — depolama, ağ, kayıt defteri, kimlik tanımları — zaten hiçbir kabul kapısından geçmiyor. Bunları ancak sürekli koşan bir denetim tarar ve o denetim bir bulgu listesi üretir. Sonraki ders o listeyi ölçer, ama bulgu sayısını değil: her bulgunun kimin işine düştüğünü, kaçının hiçbir sahibi olmadığını ve sahipsiz bulguların hangi hızda biriktiğini.