---
title: 'Betikle Aygıt Yönetimi'
source: 'https://academia.sh/tr/kurslar/ag-isletimi/betikle-aygit-yonetimi'
course: 'Ağ İşletimi ve Otomasyon'
language: tr
updated: '2026-08-17T18:07:15+00:00'
license: 'CC BY-SA 4.0'
---

# Betikle Aygıt Yönetimi

Şablon hangi sınıfa göre yazılırsa yazılsın sapan aygıt her seferinde 6'dır; değişen tek şey raporda görünmeyenin 6, 3 ve 3 olmasıdır. Kuru çalışma altısını da uygulamadan önce bulur, rapor 0, 3 ve 3 bulur, ve bir şablonda kademeli yayma hiç durmaz.

Önceki ders tek bir isteğin tek bir aygıtta ne bıraktığını ölçtü. İşletmede istek tek
değildir: bir betik envanteri gezer, kırk aygıta sırayla bağlanır, her birine aynı şablonu
uygular ve sonunda bir rapor yazar. Betik yazıldığı andan sonra kırk aygıtın kırkına aynı
kararı taşır — kaldıraç tam olarak budur.

Bu dersin sorusu betiğin nasıl yazılacağı değil, betiğin **ne göremediğidir**. Şablon
uygulandığında kaç aygıt şablonun dışında kalıyor, bu aygıtların kaçı yazılan raporda
görünüyor, ve iki sayı arasındaki fark hangi kararla açılıyor.

## Betiğin Yaptığı İş

Toplu değişiklik yedi adımdır ve adımların sırası ölçümün sonucunu belirler.

```text
# ogretilen toplu degisiklik yordami , calistirilmamistir

1  envanteri oku             -> 40 aygit
2  sablonu kuru calistir     -> aygit basina fark listesi
3  farki gozden gecir        -> sablonun disinda kalanlari isaretle
4  dilim 1 uygula            -> ilk 10 aygit
5  raporu oku                -> gorunen sapma var mi
6  yoksa dilim 2 , 3 , 4     -> yayma surer
7  varsa durdur ve geri al   -> yalnizca uygulanmis olanlar
```

İkinci adım **kuru çalışma**, dördüncüden yedinciye kadarki döngü **kademeli yayma**,
yedincinin ikinci yarısı **geri alma**. Üçü ayrı üç koruma değildir; aynı korumanın üç ayrı
zamandaki hâlidir — uygulamadan önce, uygularken ve uyguladıktan sonra.

Kod olarak altyapı yordamının kendisi ve araç tartışması Kod Olarak Altyapı kursunun
konusudur ve burada tekrarlanmaz. Burada nesne bir ağ aygıtıdır ve ölçülen şey yordamın
verimi değil, **şablonun dışında kalan azınlıktır.**

## Doğrulamanın İki Kaynağı

Betiğin değişikliğin doğru gittiğini anlamasının iki yolu vardır ve ikisi aynı şeyi ölçmez.

**Kuru çalışma niyeti aygıtın durumuyla karşılaştırır.** Şablonun ne yazacağını hesaplar,
aygıttan mevcut yapılandırmayı okur, ikisinin farkını çıkarır ve **hiçbir aygıta yazmaz**.
Kapsamı envanterin tamamıdır: kırk aygıdın kırkına bakar, çünkü bakmak için bir göstergeye
ihtiyacı yoktur.

**Rapor göstergelerden gelir.** Uygulamadan sonra toplanan ölçütler okunur ve beklenenden
sapan aygıtlar listelenir. Kapsamı ise **göstergelerin kapsamıdır** — ve gösterge kümesi
hiçbir zaman kırk aygıdın kırkını eşit ayrıntıda görmez. Bu kurguda rapor etkileşim sınıfının
göstergeleri üzerine kuruludur; öteki sınıflardaki bir sapma rapora hiç düşmez.

Bu, raporu yazanın bir kusuru değildir. Gösterge kümesi her zaman bir kapsam kararıdır:
hangi sınıfın hangi ölçütü, hangi sıklıkla toplanacak. Karar verilirken sorulan soru "hangi
aygıtlar önemli" olur; sorulmayan soru ise "hangi sapmayı görmez hâle geliyoruz" olur.

Ölçümün varsayımları:

- **OT19** — Kırk aygıtlık özne kümesi kursun sabitidir ve bu derste değiştirilmez.
- **OT20** — Şablon aygıtın sınıfına göre yazılır. Sınıfı şablonunkiyle uyuşmayan özel aygıt
  sapar; sapma şablonun kapsam kararından doğar, aygıtın kusurundan değil.
- **OT21** — Kuru çalışma niyeti aygıdın gerçek durumuyla karşılaştırır ve hiçbir aygıta
  yazmaz. Kâhini kullanmaz; sapmayı aygıdın kendi durumundan okur.
- **OT22** — Rapor etkileşim sınıfının göstergeleri üzerine kuruludur. Başka sınıftaki bir
  sapma rapora hiç düşmez.
- **OT23** — Kademeli yayma aygıtları numara sırasıyla dilimler. Her dilimin sonunda rapor
  okunur; raporda görünen bir sapma varsa yayma durdurulur.
- **OT24** — Yayma durdurulduğunda o ana kadar uygulanmış sapan aygıtlar geri alınır; sonraki
  dilimlerdeki sapan aygıtlara hiç dokunulmamıştır.
- **OT25** — Dilim boyu 40 olduğunda yayma tek adımdır ve durdurma kararının verilebileceği
  bir ara yoktur.

## Ölçüm

```python
"""Toplu degisiklik: sapan aygit sabit, gorunen sapma degisken.

Bolum 1 - sablon uygulanir: uyan, sapan, raporda gorunen ve gorunmeyen.
Bolum 2 - kuru calisma ile raporun kapsami yan yana.
Bolum 3 - kademeli yayma: durdurulana kadar degisen ve onlenen sapan.
"""
TOHUM = 20260812
SINIFLAR = ("etkilesim", "toplu", "yedek")


def uretec(tohum):
    d = tohum % 2147483646 + 1

    def r(n):
        nonlocal d
        d = (d * 48271) % 2147483647
        return d % n
    return r


def ozneler(sayi=40, tohum=TOHUM):
    r, liste = uretec(tohum), []
    for i in range(sayi):
        liste.append({"no": i + 1, "kapasite": 20 + r(81),
                      "gecikme": 5 + r(45),
                      "sinif": ("etkilesim", "toplu", "yedek")[r(3)],
                      "ozel": r(9) == 0})
    return liste


def uygula(oz, sablon_sinifi):
    """Tek sablon kirk aygita uygulanir; ozel aygitlar sapar."""
    uyan = sapan = gizli = 0
    for o in oz:
        if o["sinif"] == sablon_sinifi or not o["ozel"]:
            uyan += 1
        else:
            sapan += 1
            if o["sinif"] != "etkilesim":
                gizli += 1
    return uyan, sapan, gizli


def kuru_calisma(oz, sablon_sinifi):
    """Uygulamadan once niyet ile aygitin durumu karsilastirilir."""
    return [o["no"] for o in oz
            if not (o["sinif"] == sablon_sinifi or not o["ozel"])]


def raporda(oz, sablon_sinifi):
    """Rapor etkilesim sinifinin gostergeleri uzerine kuruludur."""
    return [no for no in kuru_calisma(oz, sablon_sinifi)
            if oz[no - 1]["sinif"] == "etkilesim"]


def kademeli(oz, sablon_sinifi, dilim):
    """Dilim dilim uygulanir; raporda gorunen ilk sapmada durulur."""
    uygulanan = sapan_uygulanan = dalga = 0
    for bas in range(0, len(oz), dilim):
        dalga += 1
        gorunen = 0
        for o in oz[bas:bas + dilim]:
            uygulanan += 1
            if not (o["sinif"] == sablon_sinifi or not o["ozel"]):
                sapan_uygulanan += 1
                if o["sinif"] == "etkilesim":
                    gorunen += 1
        if gorunen:
            return dalga, uygulanan, sapan_uygulanan
    return 0, uygulanan, sapan_uygulanan


oz = ozneler()
print(f"özne {len(oz)} | özel aygıt {sum(o['ozel'] for o in oz)} | "
      f"sınıf dağılımı " +
      " ".join(f"{s} {sum(1 for o in oz if o['sinif'] == s)}" for s in SINIFLAR))
print()
print(f"{'şablon sınıfı':<14s} {'uyan':>5s} {'sapan':>6s} {'raporda görünen':>16s} "
      f"{'raporda görünmeyen':>19s} {'raporun kapsamı':>16s}")
for s in SINIFLAR:
    u, sp, g = uygula(oz, s)
    print(f"{s:<14s} {u:5d} {sp:6d} {sp - g:16d} {g:19d} "
          f"{(sp - g) / sp:16.3f}")

print()
print(f"{'şablon sınıfı':<14s} {'kuru çalışma bulur':>19s} {'rapor bulur':>12s} "
      f"{'yalnız kuru çalışmanın bulduğu':>31s}")
for s in SINIFLAR:
    k, r = kuru_calisma(oz, s), raporda(oz, s)
    print(f"{s:<14s} {len(k):19d} {len(r):12d} {len(k) - len(r):31d}")
for s in SINIFLAR:
    print(f"  {s:<12s} sapan aygıtlar {kuru_calisma(oz, s)} | "
          f"raporda {raporda(oz, s)}")

print()
print(f"{'şablon sınıfı':<14s} {'dilim':>6s} {'duran dalga':>12s} "
      f"{'değişen aygıt':>14s} {'geri alınacak':>14s} {'önlenen sapan':>14s}")
for s in SINIFLAR:
    for dilim in (4, 10, 40):
        d, u, su = kademeli(oz, s, dilim)
        print(f"{s:<14s} {dilim:6d} {d if d else '-':>12} {u:14d} "
              f"{su:14d} {len(kuru_calisma(oz, s)) - su:14d}")
```

```
özne 40 | özel aygıt 9 | sınıf dağılımı etkilesim 11 toplu 20 yedek 9

şablon sınıfı   uyan  sapan  raporda görünen  raporda görünmeyen  raporun kapsamı
etkilesim         34      6                0                   6            0.000
toplu             34      6                3                   3            0.500
yedek             34      6                3                   3            0.500

şablon sınıfı   kuru çalışma bulur  rapor bulur  yalnız kuru çalışmanın bulduğu
etkilesim                        6            0                               6
toplu                            6            3                               3
yedek                            6            3                               3
  etkilesim    sapan aygıtlar [7, 12, 20, 25, 26, 40] | raporda []
  toplu        sapan aygıtlar [4, 20, 25, 26, 31, 33] | raporda [4, 31, 33]
  yedek        sapan aygıtlar [4, 7, 12, 31, 33, 40] | raporda [4, 31, 33]

şablon sınıfı   dilim  duran dalga  değişen aygıt  geri alınacak  önlenen sapan
etkilesim           4            -             40              6              0
etkilesim          10            -             40              6              0
etkilesim          40            -             40              6              0
toplu               4            1              4              1              5
toplu              10            1             10              1              5
toplu              40            1             40              6              0
yedek               4            1              4              1              5
yedek              10            1             10              2              4
yedek              40            1             40              6              0
```

## Sapan Sabit, Görünen Değişken

Üst tablo bu konunun ana sonucunu veriyor. Şablon hangi sınıfa göre yazılırsa yazılsın uyan
aygıt **34**, sapan aygıt **6**. Üç satırın üçünde de aynı sayı. Sapan sayısı şablonun
niteliğine bağlı değildir çünkü sapmanın kaynağı şablonun yanlış yazılması değil, **tek bir
şablonun kırk farklı aygıtı temsil etme iddiasıdır.** Daha iyi bir şablon yazmak bu altıyı
beşe indirmez; ancak kapsamı daraltmak ya da ikinci bir şablon yazmak indirir, ki o da
kaldıracın tekliğinden vazgeçmektir.

Sağdaki üç sütun ise değişiyor. Etkileşim sınıfına göre yazılan şablonda raporda görünen
sapan **0**, görünmeyen **6**; raporun kapsamı **0,000**. Öteki iki şablonda görünen **3**,
görünmeyen **3**, kapsam **0,500**. Aynı altı aygıt, üç ayrı görünürlük.

Bu, kursun üçüncü iddiasının ikinci ödemesidir ve burada en çıplak hâliyle duruyor:
**otomasyon sapmayı azaltmaz, görünürlüğünü değiştirir.** Sapan altı aygıt her üç şablonda
da oradadır; değişen tek şey kaçının rapora düştüğüdür. Bir işletmede bu iki sayıdan yalnız
ikincisi gösterge tablosuna yazılır, ve gösterge tablosu iyileştikçe sapmanın azaldığı
sanılır.

Aygıt numaraları bunu doğruluyor. Etkileşim şablonunda sapanlar `[7, 12, 20, 25, 26, 40]`,
raporda görünen liste ise boş. Toplu şablonunda sapanlar `[4, 20, 25, 26, 31, 33]`, raporda
`[4, 31, 33]` — üçü görünüyor, üçü görünmüyor. Yedek şablonunda sapanlar başka aygıtlar ama
raporda görünenler yine `[4, 31, 33]`, çünkü rapor sapmaya değil **sınıfa** bakıyor.

Kırk öznelik bir kümede ölçülebilen en küçük fark **1/40 = 0,025**'tir. Altı ile üç
arasındaki fark **0,075**'tir ve bandın rahatça içindedir.

## Kuru Çalışmanın Bulduğu

Orta tablo iki doğrulama kaynağını yan yana koyuyor. Kuru çalışma üç şablonun üçünde de
**6** sapan aygıdı buluyor. Rapor **0**, **3** ve **3** buluyor. Yalnız kuru çalışmanın
bulduğu aygıt sayısı sırasıyla **6**, **3** ve **3**.

Farkın nedeni yöntemin kendisidir. Kuru çalışma göstergeye bakmaz; envanterdeki her aygıda
tek tek sorar ve niyetle karşılaştırır. Kapsamı gösterge kümesinin değil, **envanterin**
kapsamıdır — ve envanter kırk aygıdın kırkını içerir. Bu yüzden kuru çalışma, gösterge
tasarımının bütün kör noktalarından bağımsızdır.

İkinci fark zamandadır ve daha önemlidir. Kuru çalışma sapmayı **hiçbir aygıt değişmeden
önce** bulur; rapor ise değişiklik uygulandıktan sonra bulur. Birinci durumda geri alınacak
aygıt sayısı sıfırdır, çünkü geri alınacak bir şey yoktur. Kuru çalışmanın kazandırdığı asıl
şey bulduğu altı aygıt değil, o altısını bulduğu **an**dır.

## Kademeli Yaymanın Ödettiği

Alt tablo yaymanın dilim boyuna göre ne değiştirdiğini veriyor ve ilk üç satır konunun en
sert sonucunu taşıyor.

**Etkileşim şablonunda yayma hiçbir dilim boyunda durmuyor.** Duran dalga sütununda üç satır
da boş; değişen aygıt her üçünde de **40**, geri alınacak **6**, önlenen sapan **0**. Neden
açık: yayma raporda görünen bir sapmada durur ve bu şablonda raporda görünen sapma **yoktur**.
Dilimi dörde indirmek bir şey değiştirmiyor, çünkü sorun dilimin büyüklüğü değil, **durdurma
kararının okuduğu sinyalin boş olması.** Kademeli yayma, sinyali olmayan bir kör noktada
kademesiz yaymayla aynı şeydir.

Öteki iki şablonda yayma birinci dalgada duruyor. Toplu şablonunda dilim **4** iken değişen
aygıt **4**, geri alınacak **1**, önlenen sapan **5**; dilim **10** iken değişen **10**, geri
alınacak yine **1**, önlenen **5**. Yedek şablonunda dilim **4** iken geri alınacak **1**,
dilim **10** iken **2** — dilim büyüdüğü için ilk dalgaya bir sapan aygıt daha giriyor.

Dilim **40** satırları karşılaştırma için duruyor: tek adımda uygulandığında üç şablonda da
değişen **40**, geri alınacak **6**, önlenen **0**. Kademeli yaymanın bütün kazancı buradan
okunur — doğru sinyal varken **5** sapmayı önlüyor, sinyal yokken **0**.

## Geri Alma ve Yıkıcı Değişiklik

Geri alma bir işlem değil, değişiklikten önce verilmiş bir karardır. Uygulanmadan önce
aygıdın yürürlükteki yapılandırması saklanmamışsa geri alınacak bir hedef yoktur ve tablodaki
"geri alınacak" sütunu bir istek listesi olarak kalır.

Toplu değişiklik **geri alınamaz bir işlemdir**: kırk aygıta uygulanan şablon, uygulandığı
anda kırk aygıttaki önceki durumu siler. Bir aygıdın yapılandırmasını boşaltan, arayüzünü
kapatan, yönetim erişimini kesen ya da ağı ikiye bölen bir değişiklik bu kursta
**çalıştırılabilir biçimde yazılmaz**. Söylenecek olan ne yaptığı ve geri alınamaz olduğudur:
ağı bölen bir değişiklikten sonra bölünmüş ağın öteki yarısındaki aygıtlara ulaşıp düzeltme
yapmak mümkün olmayabilir, ve o aygıtlar tam olarak geri almanın çalıştırılması gereken
aygıtlardır.

Sayılan yüzeyler ve daraltmaları şunlardır.

**Birinci yüzey — kapsamın kendisi.** Betik envanterin tamamına dokunabiliyorsa bir yazım
hatası kırk aygıda birden gider. **Daraltma:** betiğin kapsamı her koşumda açıkça verilir ve
varsayılan kapsam boş olur; kapsam bir dilim listesiyle sınırlanır; kuru çalışmanın çıktısı
gözden geçirilmeden uygulama adımı çalışmaz.

**İkinci yüzey — raporun kör noktası.** Ölçümde bir şablonda sapmanın **6**'sı da rapora
düşmüyor. **Daraltma:** durdurma kararı yalnız rapora bağlanmaz; her dilimin sonunda o dilime
giren aygıtlar için kuru çalışma yeniden koşturulur ve niyetle karşılaştırılır. Bu, raporun
göremediği üç aygıdı da durdurma kararının kapsamına sokar.

**Üçüncü yüzey — kimlik bilgisi.** Betik kırk aygıda bağlanır ve bunun için bir kimlik
kullanır. Kimlik bilgisi, anahtar ve erişim belirteci bu kursun hiçbir örneğinde yazılmaz;
betik yalnız bir başvuru taşır ve değeri çalıştığı ortamdan alır, şablonun ya da yapılandırma
deposunun içinden değil.

**Dördüncü yüzey — geri alınamaz adımın kendisi.** **Daraltma:** yıkıcı olabilecek adım bir
geri alma zamanlayıcısıyla uygulanır — belirli bir süre içinde operatör onaylamazsa aygıt
kendiliğinden eski yapılandırmaya döner. Erişimini kaybetmiş bir operatörün elindeki tek araç
budur ve zamanlayıcı, uygulamadan önce kurulmuş olmak zorundadır.

## Özet

- Toplu değişiklik yedi adımdır; kuru çalışma, kademeli yayma ve geri alma aynı korumanın
  uygulamadan önceki, uygularkenki ve sonraki hâlleridir.
- Şablon hangi sınıfa göre yazılırsa yazılsın uyan **34**, sapan **6**; sapmanın kaynağı
  şablonun yanlışlığı değil, tek şablonun kırk farklı aygıtı temsil etme iddiasıdır.
- Raporda görünen sapan **0 / 3 / 3**, görünmeyen **6 / 3 / 3**, raporun kapsamı
  **0,000 / 0,500 / 0,500**. Aynı altı aygıt, üç ayrı görünürlük: **otomasyon sapmayı
  azaltmaz, görünürlüğünü değiştirir.**
- Kuru çalışma üç şablonda da **6** sapanı bulur çünkü kapsamı göstergenin değil envanterin
  kapsamıdır; ve onları hiçbir aygıt değişmeden önce bulur.
- Etkileşim şablonunda kademeli yayma hiçbir dilim boyunda durmaz — değişen **40**, önlenen
  **0**. Öteki iki şablonda birinci dalgada durur ve **5** sapmayı önler; sinyali olmayan bir
  kör noktada kademeli yayma, kademesiz yaymayla aynı şeydir.

## Sonraki Adım

Bu konuda sayılan her sapan aygıt, envanterinde adı yazan, yapılandırmasını okuyabildiğimiz
ve gerektiğinde geri alabildiğimiz bir aygıttı. Kuru çalışmanın altı sapanı bulabilmesi de
buna dayanıyordu: aygıda sorabiliyorduk ve verdiği yanıt bizimdi. Peki özne **kendi sahip
olmadığımız** bir nesne olursa? Sonraki ders kaldıracın altındaki nesneyi değiştirir ve
aynı ölçüyü — tek karar, kırk özne, kalan kuyruk — bize ait olmayan bir yapılandırma
düzleminde yeniden sorar.
