Ağ Politikaları

Önceki dersin matrisi kimin küme arayüzü üzerinden ne yapabileceğini sınırladı. İki kapsül arasındaki trafik o matristen geçmez: doğrulayıcı, faturalama servisinin ucuna doğrudan bağlanır ve küme arayüzüne hiç uğramaz. Yetki matrisinde birbirine ulaşamayan iki özne, ağ üzerinde birbirine serbestçe ulaşabilir. Erişilebilirlik matrisi daha önce, tek makinedeki ağ ayrımı bağlamında kurulup ölçüldü — hangi kapsül hangi kapsüle ulaşabiliyor. O ölçüm burada tekrarlanmıyor; buranın sorusu aynı matrisin politika ile kurulmasıdır.

Devredilen karar şudur: bir bağlantı isteğinin kabul edilip edilmeyeceğine, kaynağın ve hedefin kim olduğuna bakarak ağ vekili karar verir. Bunun için bilmesi gereken kalemler şunlardır: hangi kapsül hangi gruba ait, hangi gruplar arası akış meşru, hangi uç üzerinden. İlk kalem kümede zaten vardır — kapsül etiketleri. Üçüncüsü de vardır. Eksik olan ikincisidir ve onu kimse ölçmez; birinin yazması gerekir. Bu dersin ölçüsü, yazmanın ve yazmamanın bedelidir.

• OI19. On servis grubu ve üç uç türü var; hepsi kurgusal bölgesel ölçüm ağına aittir. Gerçek bir küme koşturulmuyor, ölçülen şey node ile kurulan modeldir.
• OI20. Meşru akış kümesi yirmi ikidir ve dördü otuz günlük izde görünmez. Bu ayrım elle yazıldı; gerçekte hangi akışın seyrek olduğu ancak izleme süresi uzatılarak bilinir.
• OI21. Uç türü üç değere indirgendi. Gerçekte kapı numarası ve protokol ayrı eksenlerdir; matrisi büyütürler, sonucun yönünü değiştirmezler.
• OI22. Politika yalnız hedefe göre yazılır, yani gelen trafiği sınırlar. Çıkan trafiği ayrıca sınırlayan kurallar bu modelde yok; olsalardı kural sayısı artar, kapanan yol sayısı artmazdı.
• OI23. Kural sayısı kendi küçük şemamızla sayılır; şema ders içinde tanımlıdır. Etiket ataması kural sayılmaz, ayrı sütunda gösterilir.
• OI24. Bir yol ya açıktır ya kapalı. Hız sınırı, karşılıklı kimlik doğrulama ve bağlantı başına yetkilendirme modellenmiyor.

Politika Modeli

Politika kendi küçük şemamızla yazılıyor: bir kural, hedef etiketini, kaynağın taşıması gereken etiketi ve ucu belirtir. Kurallar yalnız izin verir; varsayılan kapalı düzende yazılmayan her yol kapalıdır.

// ag.mjs — kapsul gruplari arasi erisilebilirlik matrisi ve politika; model, gercek kume degil
export const UC = ['api', 'veri', 'olcut'];
export const SERVIS = {                                // servis -> etiketler
  'giris-kurali': ['kenar'], 'okuma-toplayici': ['uygulama'], 'dogrulayici': ['uygulama'],
  'faturalama': ['uygulama'], 'is-emri': ['uygulama'], 'gecelik-toplu-is': ['toplu'],
  'veri-deposu': ['depo'], 'kuyruk': ['depo'], 'olcut-toplayici': ['izleme'], 'pano': ['izleme'],
};
// Gercekten mesru akislar; "seyrek" olanlar otuz gunluk izde gorunmedi.
export const MESRU = [
  ['giris-kurali', 'okuma-toplayici', 'api'], ['giris-kurali', 'faturalama', 'api'],
  ['giris-kurali', 'is-emri', 'api'], ['okuma-toplayici', 'kuyruk', 'veri'],
  ['dogrulayici', 'kuyruk', 'veri'], ['dogrulayici', 'veri-deposu', 'veri'],
  ['okuma-toplayici', 'veri-deposu', 'veri'], ['faturalama', 'veri-deposu', 'veri'],
  ['is-emri', 'veri-deposu', 'veri'], ['gecelik-toplu-is', 'veri-deposu', 'veri'],
  ['gecelik-toplu-is', 'kuyruk', 'veri'], ['olcut-toplayici', 'okuma-toplayici', 'olcut'],
  ['olcut-toplayici', 'dogrulayici', 'olcut'], ['olcut-toplayici', 'faturalama', 'olcut'],
  ['olcut-toplayici', 'is-emri', 'olcut'], ['pano', 'olcut-toplayici', 'api'],
  ['faturalama', 'is-emri', 'api'], ['is-emri', 'kuyruk', 'veri'],
  ['gecelik-toplu-is', 'faturalama', 'api', 'seyrek'], ['olcut-toplayici', 'gecelik-toplu-is', 'olcut', 'seyrek'],
  ['dogrulayici', 'faturalama', 'api', 'seyrek'], ['giris-kurali', 'pano', 'api', 'seyrek'],
];
// Etiket politikasi, kendi semamizla: "hedef <etiket> <- <kaynak etiketi> : <uc>"
export const ETIKET_KURAL = [
  ['depo', 'uygulama', 'veri'], ['depo', 'toplu', 'veri'], ['uygulama', 'kenar', 'api'],
  ['uygulama', 'izleme', 'olcut'], ['izleme', 'izleme', 'api'], ['uygulama', 'uygulama', 'api'],
];
export const yol = (k, h, u) => `${k}->${h}:${u}`;
export const tumYollar = (s = SERVIS) => {
  const a = [];
  for (const k of Object.keys(s)) for (const h of Object.keys(s)) if (k !== h) for (const u of UC) a.push(yol(k, h, u));
  return a;
};
export const varsayilanAcik = (s = SERVIS) => new Set(tumYollar(s));
export const izdenKural = () => MESRU.filter((m) => !m[3]).map((m) => [m[0], m[1], m[2]]);
export const izdenAcik = (kural) => new Set(kural.map(([k, h, u]) => yol(k, h, u)));
export function etiketAcik(kural = ETIKET_KURAL, s = SERVIS) {
  const acik = new Set();
  for (const [hE, kE, u] of kural)
    for (const [h, he] of Object.entries(s)) if (he.includes(hE))
      for (const [k, ke] of Object.entries(s)) if (k !== h && ke.includes(kE)) acik.add(yol(k, h, u));
  return acik;
}
export const say = (acik, mesru = MESRU) => {
  const m = new Set(mesru.map((x) => yol(x[0], x[1], x[2])));
  return { acik: acik.size, gereksizAcik: [...acik].filter((y) => !m.has(y)).length,
    kapananMesru: [...m].filter((y) => !acik.has(y)).length, kapanan: tumYollar().length - acik.size };
};

İki politika yazım biçimi var ve ikisi aynı matristen türemiyor. izdenKural gözlenen akışın kendisini kurala çeviriyor: her satır bir kaynak, bir hedef, bir uç. etiketAcik ise etiketler üzerinden yazıyor; bir kural, etiketi taşıyan bütün kaynak–hedef çiftlerini birden açıyor.

Varsayılan Açık ve Varsayılan Kapalı

// kosum7.mjs — varsayilan acik ile varsayilan kapali karsilastirilir
import { SERVIS, UC, MESRU, ETIKET_KURAL, tumYollar, varsayilanAcik, izdenKural, izdenAcik, etiketAcik, say } from './ag.mjs';

const iz = izdenKural();
console.log(`${Object.keys(SERVIS).length} servis x ${Object.keys(SERVIS).length - 1} hedef x ${UC.length} uc` +
  ` = ${tumYollar().length} olasi yol`);
console.log(`mesru akis ${MESRU.length}, bunun ${MESRU.filter((m) => m[3]).length} tanesi otuz gunluk izde gorunmuyor\n`);
console.log('politika              kural  acik yol  kapanan yol  gereksiz acik  yanlislikla kapanan');
for (const [ad, kural, acik] of [
  ['varsayilan acik', 0, varsayilanAcik()],
  ['izden turetilen', iz.length, izdenAcik(iz)],
  ['etiket tabanli', ETIKET_KURAL.length, etiketAcik()],
]) {
  const s = say(acik);
  console.log(`${ad.padEnd(21)} ${String(kural).padEnd(6)} ${String(s.acik).padEnd(9)} ` +
    `${String(s.kapanan).padEnd(12)} ${String(s.gereksizAcik).padEnd(14)} ${s.kapananMesru}`);
}
console.log('\netiket politikasinin ilk uc kurali ve actigi yol sayisi:');
for (const k of ETIKET_KURAL.slice(0, 3))
  console.log(`  hedef ${k[0]} <- ${k[1]} : ${k[2]}   ->  ${etiketAcik([k]).size} yol`);

10 servis x 9 hedef x 3 uc = 270 olasi yol
mesru akis 22, bunun 4 tanesi otuz gunluk izde gorunmuyor

politika              kural  acik yol  kapanan yol  gereksiz acik  yanlislikla kapanan
varsayilan acik       0      270       0            248            0
izden turetilen       18     18        252          0              4
etiket tabanli        6      36        234          17             3

etiket politikasinin ilk uc kurali ve actigi yol sayisi:
  hedef depo <- uygulama : veri   ->  8 yol
  hedef depo <- toplu : veri   ->  2 yol
  hedef uygulama <- kenar : api   ->  4 yol

Varsayılan açık satırı sıfır kuralla iki mükemmel sayı üretiyor: hiçbir meşru yol kapanmıyor ve kapanan yol yok. Üçüncü sayı bedelidir — iki yüz kırk sekiz yol, hiçbir meşru akışa karşılık gelmediği hâlde açık duruyor. Yüzde olarak matrisin yüzde doksan ikisi. Bu, ağ ayrımı olmayan bir kümede bir kapsülün ele geçirilmesi hâlinde ulaşabileceği yerlerin sayısıdır: sır barındıran veri deposuna, kuyruğa, ödeme akışına, hepsine.

İzden türetilen politika bunu on sekiz kuralla iki yüz elli iki yol kapatarak bitiriyor ve gereksiz açık yol bırakmıyor — açık olan on sekiz yolun on sekizi de gerçekten kullanılıyor. Ama son sütunda dört var: dört meşru akış yanlışlıkla kapandı. Bunlar otuz günlük izde görünmeyen seyrek akışlardır — ay sonu mutabakatı, düzeltme akışı, haftalık rapor. Politika yazıldığı gün hiçbir şey bozulmaz; ay sonu geldiğinde bozulur ve bozulduğunda görünen şey bir ağ hatasıdır, bir politika satırı değil. Yanlış alarmın gecikmeli olması onu pahalı yapan şeydir.

Etiket tabanlı politika üçte bir kuralla — altı — benzer bir kapanma elde ediyor: iki yüz otuz dört yol. Bedeli ortadaki sütunda: on yedi gereksiz açık yol. Alt bloktaki üç satır bunun nereden geldiğini gösteriyor. “Depo etiketli hedefe uygulama etiketli kaynaklardan veri ucu” tek bir kuraldır ve sekiz yol açar; bunların yedisi izde vardır, biri yoktur. Etiketli kural, aynı etiketi taşıyan her şeye aynı muameleyi yapar — ayrım yapamadığı yerde fazladan açar.

İlginç olan son sütun: etiket tabanlı politika dört değil üç meşru akışı kapatıyor. Etiketin genelliği seyrek akışlardan birini kazara karşıladı. Aynı gevşeklik hem on yedi gereksiz yol açıyor hem bir yanlış alarmı önlüyor; ikisi tek bir ayarın iki yüzüdür.

Yeni Servis Eklendiğinde

Politikanın asıl maliyeti yazıldığı gün değil, kümenin değiştiği gün ortaya çıkıyor.

// kosum8.mjs — kumeye yeni bir servis eklenince her iki politikada ne guncelleniyor
import { SERVIS, MESRU, ETIKET_KURAL, izdenKural, izdenAcik, etiketAcik, yol, say } from './ag.mjs';

const YENI = [['gecelik-toplu-is', 'arsivleyici', 'api'], ['arsivleyici', 'veri-deposu', 'veri'],
  ['olcut-toplayici', 'arsivleyici', 'olcut']];
const kapsam = (kural, servis) => {                    // kac yeni akis mevcut kurallarla karsilaniyor
  const acik = etiketAcik(kural, servis);
  return YENI.filter(([k, h, u]) => acik.has(yol(k, h, u))).length;
};
console.log('yeni servis: arsivleyici, uc yeni mesru akis\n');
console.log('politika                  etiket   karsilanan  eklenecek  gereksiz acik');
console.log('                          atamasi  akis        kural      once -> sonra');
const izOnce = say(izdenAcik(izdenKural())).gereksizAcik;
const izSonra = say(izdenAcik([...izdenKural(), ...YENI]), [...MESRU, ...YENI]).gereksizAcik;
console.log(`${'izden turetilen'.padEnd(25)} ${'-'.padEnd(8)} ${String(0).padEnd(11)} ` +
  `${String(YENI.length).padEnd(10)} ${izOnce} -> ${izSonra}`);
for (const etiket of [['toplu'], ['toplu', 'uygulama']]) {
  const servis = { ...SERVIS, arsivleyici: etiket };
  const k = kapsam(ETIKET_KURAL, servis);
  const eksik = YENI.filter(([a, b, u]) => !etiketAcik(ETIKET_KURAL, servis).has(yol(a, b, u)));
  const kural = [...ETIKET_KURAL, ...eksik.map(([a, b, u]) => [servis[b][0], servis[a][0], u])];
  const once = say(etiketAcik(ETIKET_KURAL)).gereksizAcik;
  const sonra = say(etiketAcik(kural, servis), [...MESRU, ...YENI]).gereksizAcik;
  console.log(`${`etiket: ${etiket.join('+')}`.padEnd(25)} ${String(etiket.length).padEnd(8)} ` +
    `${String(k).padEnd(11)} ${String(kural.length - ETIKET_KURAL.length).padEnd(10)} ${once} -> ${sonra}`);
}

yeni servis: arsivleyici, uc yeni mesru akis

politika                  etiket   karsilanan  eklenecek  gereksiz acik
                          atamasi  akis        kural      once -> sonra
izden turetilen           -        0           3          0 -> 0
etiket: toplu             1        1           2          17 -> 21
etiket: toplu+uygulama    2        2           1          17 -> 29

İzden türetilen politikada yeni servisin üç akışının hiçbiri mevcut kurallarla karşılanmıyor — karşılanan akış sıfır — ve üçü için üç kural yazılıyor. Karşılığında gereksiz açık yol sıfırda kalıyor. Bu biçim değişikliğe doğrusal tepki verir: her yeni akış bir satır.

Etiket tabanlı politikada iki seçenek var ve ikisi arasındaki fark bu dersin sonucudur. Arşivleyici yalnız toplu etiketiyle geldiğinde mevcut kurallar üç akıştan birini karşılıyor, iki kural yazmak gerekiyor ve gereksiz açık yol on yediden yirmi bire çıkıyor. Arşivleyiciye ikinci bir etiket, uygulama, verildiğinde karşılanan akış ikiye çıkıyor, yazılacak kural bire iniyor — ama gereksiz açık yol yirmi dokuza fırlıyor.

Aradaki sekiz yol, ikinci etiketin fiyatıdır. uygulama etiketi arşivleyiciyi dört kuralın birden kapsamına sokuyor; o kuralların açtığı yolların çoğu arşivleyici için gereksiz. Yani kural yazmaktan kaçınmanın yolu etiketi genişletmekten geçiyor ve etiketi genişletmek matrisi açıyor. İki kurallı seçenekle bir kurallı seçenek arasındaki tercih, bir satır yazma emeğiyle sekiz açık yol arasında yapılıyor.

Sessiz olan taraf da burada. Fazladan açılan sekiz yol hiçbir hata üretmez, hiçbir kayda düşmez ve hiç kullanılmayabilir; varlıkları ancak matris yeniden sayıldığında görünür. Buna karşılık eksik bırakılan bir kural — izden türetilen biçimde üç satırdan biri unutulsa — hemen bir bağlantı hatası verir ve düzeltilir. İki politika biçimi bu yüzden farklı yönde bozulur: biri gürültülü ve düzeltilebilir, öteki sessiz ve birikimli.

Küme Büyüdükçe

Tek bir servis eklemek iki biçim arasında küçük bir fark üretti. Fark, ekleme yinelendiğinde yönünü belli ediyor.

// kosum9.mjs — kume buyudukce iki politikanin kural sayisi nasil artiyor
import { SERVIS, MESRU, ETIKET_KURAL, izdenKural, izdenAcik, etiketAcik, yol, say } from './ag.mjs';

const akis = (ad) => [['gecelik-toplu-is', ad, 'api'], [ad, 'veri-deposu', 'veri'],
  ['olcut-toplayici', ad, 'olcut']];
let servis = { ...SERVIS }, kural = [...ETIKET_KURAL], mesru = [...MESRU], izKural = izdenKural();
console.log('yeni  izden turetilen      etiket tabanli (yeni servis etiketi: toplu+uygulama)');
console.log('servis kural  gereksiz acik  kural  gereksiz acik  bu adimda eklenen kural');
for (let n = 1; n <= 6; n += 1) {
  const ad = `arsiv-${n}`;
  servis = { ...servis, [ad]: ['toplu', 'uygulama'] };
  const yeni = akis(ad);
  mesru = [...mesru, ...yeni]; izKural = [...izKural, ...yeni];
  const eksik = yeni.filter(([a, b, u]) => !etiketAcik(kural, servis).has(yol(a, b, u)));
  const eklendi = eksik.map(([a, b, u]) => [servis[b][0], servis[a][0], u]);
  kural = [...kural, ...eklendi];
  const i = say(izdenAcik(izKural), mesru), e = say(etiketAcik(kural, servis), mesru);
  console.log(`${String(n).padEnd(6)} ${String(izKural.length).padEnd(6)} ${String(i.gereksizAcik).padEnd(14)} ` +
    `${String(kural.length).padEnd(6)} ${String(e.gereksizAcik).padEnd(14)} ${eklendi.length}`);
}

yeni  izden turetilen      etiket tabanli (yeni servis etiketi: toplu+uygulama)
servis kural  gereksiz acik  kural  gereksiz acik  bu adimda eklenen kural
1      21     0              7      29             1
2      24     0              7      43             0
3      27     0              7      59             0
4      30     0              7      77             0
5      33     0              7      97             0
6      36     0              7      119            0

İki sütun iki ayrı eğri çiziyor. İzden türetilen politikada kural sayısı her serviste üçer artıyor — yirmi birden otuz altıya — ve gereksiz açık yol altı serviste de sıfır kalıyor. Bakım maliyeti doğrusal, açıklık sabit.

Etiket tabanlı politikada tersi oluyor. Kural sayısı ilk serviste bir artıyor ve orada duruyor: yedi kural, sonraki beş serviste de yedi. Son sütun beş kez sıfır — yeni servis etiketleri taşıdığı için mevcut kurallar onu kendiliğinden karşılıyor. Bakım maliyeti sıfıra iniyor. Bunun karşılığı üçüncü sayı sütununda birikiyor: gereksiz açık yol yirmi dokuzdan yüz on dokuza çıkıyor ve artış hızlanıyor — sırasıyla on dört, on altı, on sekiz, yirmi, yirmi iki. Her yeni uygulama etiketli servis, kendinden önceki bütün uygulama etiketli servislerle karşılıklı yol açıyor; artış bu yüzden servis sayısıyla doğrusal değil, çiftlerin sayısıyla orantılı.

Devredilen kararın bedeli bu tabloda okunuyor. Ağ vekiline “bu bağlantı meşru mu” kararını devretmek için ona meşru akış kümesini bildirmek gerekir. Bildirimi tek tek yapmak her değişiklikte emek ister ama bildirilen şey doğrudur. Bildirimi etiketle yapmak emeği sıfıra indirir ve bildirilen şeyi kabaca doğru kılar; kabalığın büyüklüğü kümenin büyümesiyle birlikte artar ve hiçbir yerde ölçülmediği sürece görünmez.

Özet

• On servis, üç uç ve dokuz hedef 270 yolluk bir matris kurar; meşru akış 22’dir, yani varsayılan açık düzende 248 yol karşılığı olmadan açık durur.
• İzden türetilen politika 18 kuralla 252 yol kapatır ve hiç gereksiz açık bırakmaz, ama izde görünmeyen 4 seyrek akışı yanlışlıkla kapatır; bu yanlış alarm ancak akış ilk kez denendiğinde görünür.
• Etiket tabanlı politika 6 kuralla 234 yol kapatır; bedeli 17 gereksiz açık yoldur, tek bir kural sekiz yolu birden açabilir ve aynı gevşeklik seyrek akışlardan birini kazara karşılayarak yanlış alarmı dörtten üçe indirir.
• Yeni servis eklendiğinde izden türetilen politika üç kural ister ve gereksiz açık yolu sıfırda tutar; etiket tabanlı politikada dar etiket iki kural ve 21 gereksiz yol, geniş etiket bir kural ve 29 gereksiz yol üretir.
• Altı servis eklendiğinde izden türetilen politika 36 kurala çıkar ve gereksiz açık yolu sıfırda tutar; etiket tabanlı politika 7 kuralda kalır ama gereksiz açık yol 29’dan 119’a çıkar, çünkü artış servis sayısıyla değil çiftlerin sayısıyla orantılıdır.
• Eksik kural gürültülü bozulur ve düzeltilir; fazla açık yol sessiz bozulur ve birikir. Politika biçimi seçimi bu iki bozulma türü arasındaki seçimdir.

Sonraki Adım

Bu dersin politikası kapsüller arasındaki trafiği sınırlıyor; kapsülün kendi içinde ne yapabildiğini sınırlamıyor. Ayrıcalıklı çalışan, ana makinenin dosya sistemine uzanan ya da geniş yetenek kümesiyle açılan bir süreç, ağ politikası eksiksiz yazılmış olsa bile durduğu düğümde başka bir alan açar. Bu ayarların ne olduğu ve tek makinede neye mal olduğu daha önce ölçüldü. Sonraki dersin sorusu ayarların kendisi değil, kümenin onları nasıl dayattığıdır: bir kabul denetimi kuralı yazılır ve mevcut kapsül tanımlarına uygulanır; kaç tanımın politikaya uymadığı, dayatmanın kaç dağıtımı durdurduğu, uyarma kipi ile engelleme kipinin farkı ve muafiyet verilirse kaç tanımın açıkta kaldığı sayılır.