---
title: 'Ortam ve Sürüm Yönetimi'
source: 'https://academia.sh/tr/kurslar/veri-hatlari/ortam-ve-surum-yonetimi'
course: 'Veri Hatları ve Orkestrasyon'
language: tr
updated: '2026-08-17T18:08:49+00:00'
license: 'CC BY-SA 4.0'
---

# Ortam ve Sürüm Yönetimi

Aynı hat kodunun üç ortamda ürettiği farklı sonucun ve sürüm damgası yazılmadığında kaybolan kimliğin sayılması: geliştirme, hazırlık ve üretim ortamları aynı 2400 satırdan sırasıyla 400, 1000 ve 2200 tüketim satırı üretir ve raporları birbirinden ayrılır; yüklenen bölüm sayısı sunumu 20,41 ile 62,55 arasında, kural sürümü 20,77 ile 35,87 arasında kaydırır, iki etki aynı büyüklük düzeninde olduğu için sunuma bakarak ayrılamaz ve bir bölgede birbirlerini götürüp farkı −5,72'ye indirir. On bir koşumluk arşivde kural sürümü yedinci dönemden sonra değiştiğinde gözlenen sıçramanın kodun payı 20,40 ile 34,71 arasındadır ve kod hiç değişmeseydi görülecek olağan dönem hareketinin 0,42 ile 38,30 aralığının içinde kalır; dört bölgede veri aşağı giderken rapor yukarı gider. Damgasız arşivde 11 raporun hiçbiri kimlik taşımaz ve kimlikleme 22 koşum ister. Ders kursun kapanışıdır.

Bir önceki ders üç göstergeyi hattın üstüne koydu ve her birinin ne gördüğünü saydı. Her sayı tek
bir sessiz varsayıma yaslanıyordu: kod hep aynıydı ve hep aynı ayarla koşuyordu. Oysa bant 0,05'ti,
tolerans 1'di, yüklenen dönem sayısı on ikiydi — üçü de hattın kodunda değil, koşumun
**çevresinde** duruyordu.

Bu ders o çevreyi ölçüm nesnesine çevirir. Tek bir hat kodu üç ortama dağıtılır ve iki soru sorulur:
aynı kod bu ortamlarda ne kadar farklı sonuç verir, ve elinizdeki bir rapordan **hangi ortamda hangi
kodla** üretildiği okunabilir mi.

- **OR47.** Kaynak, beş aşamalı hat ve üç ortam ayarı **kurgudur** ve ders içinde üretilir. Hiçbir
  orkestratör, dağıtım aracı ya da sürüm yönetimi ürünü çağrılmaz. Tohum 20260218.
- **OR48.** Sürekli tümleştirme, dağıtım ve ortam terfisi yordamı DevOps ve Platform Mühendisliği
  müfredatındaki Sürekli Tümleştirme ve Teslimat ile Kod Olarak Altyapı kurslarında ölçüldü;
  **tekrarlanmaz**. Buradaki tek ölçü aynı kodun ortamlar arasında ürettiği **farklı sonuçtur**.
- **OR49.** Ortam üç ayar taşır ve üçü de kodun dışındadır: yüklenen **bölüm** sayısı, gösterge
  **bandı** ve raporlama kuralının **sürümü**. `s1` işyeri tüketimini 1,00, `s2` 1,05 katsayıyla
  raporlar; geri doldurma yordamı Dönüştürme konusunun son dersinde ölçüldü.
- **OR50. Sürüm damgası**, bir koşumun çıktısına yazılan dönem, kod sürümü ve ayar üçlüsüdür. Taban
  çizgisi orkestrasyonsuz koşumdur: tek ortam varsayılır, damga yazılmaz, kimlik taşıyan rapor
  **0**'dır.

## Aynı Kod, Üç Ortam

Aşağıdaki blok tek bir `rapor` işlevi tanımlar ve onu üç ayarla koşturur. İşlev ortamdan yalnız
yüklenecek dönem kümesini ve kural katsayısını alır; bant hattı değil göstergeyi ayarladığı için
tabloya bir önceki dersin ölçüsüyle, gizlediği en büyük kayıpla girer.

```python
# KURGUDUR. Olcum aginin sayac okumalari , bes asamali hat ve uc ortam ayari ders
# icinde uretilir; hicbir orkestrator , dagitim araci ya da surum yonetimi urunu
# cagrilmaz. Tohum 20260218.
TOHUM, M32 = 20260218, 0xFFFFFFFF


def uretec(t):
    x = ((t ^ (t >> 16)) * 2246822507) & M32
    x = ((x ^ (x >> 13)) * 3266489909) & M32
    s = [(x ^ (x >> 16)) & M32]

    def sonraki():
        s[0] = (s[0] * 1664525 + 1013904223) & M32
        return s[0] / 4294967296
    return sonraki


BOLGE = ["dogu", "bati", "kuzey", "guney", "merkez"]
TIP = ["mesken", "isyeri"]
DONEM = [f"2026-{a:02d}" for a in range(1, 13)]
ABONE = {}
for i in range(200):
    r = uretec(TOHUM + 37 * i)
    ABONE[f"A{i + 1:03d}"] = {"bolge": BOLGE[int(r() * 5)], "tip": TIP[int(r() * 2)],
                              "baslangic": 10000 + int(r() * 60000)}


def kaynak_uret():
    kayit = []
    for i, (ab, a) in enumerate(ABONE.items()):
        e = a["baslangic"]
        for d in DONEM:
            r = uretec(TOHUM + 101 * i + 7 * DONEM.index(d))
            e += 4 + int(r() * 46)
            kayit.append({"abone": ab, "donem": d, "bolge": a["bolge"], "tip": a["tip"],
                          "endeks": e, "birim": "m3"})
    return kayit


def a3_tuketim(kayit):
    tablo = {(k["abone"], k["donem"]): k for k in kayit}
    cikti, dusen = [], 0
    for k in kayit:
        i = DONEM.index(k["donem"])
        if i == 0:
            continue
        onceki = tablo.get((k["abone"], DONEM[i - 1]))
        if onceki is None:
            dusen += 1
            continue
        cikti.append(dict(k, m3=int(k["endeks"]) - int(onceki["endeks"])))
    return cikti, dusen


def a4_ozet(kayit):
    top = {}
    for k in kayit:
        ad = (k["bolge"], k["donem"])
        top[ad] = top.get(ad, 0) + k["m3"]
    return top, 0


def a5_sun(ozet):
    bolge = {}
    for (b, d), v in ozet.items():
        bolge.setdefault(b, []).append(v)
    return {b: round(sum(v) / len(v), 2) for b, v in bolge.items()}, 0


# ---- TEK hat kodu. Ortamdan gelen: yuklenen donemler ve kural katsayisi.
# Saglam kaynakta ayikla ve tekille asamalari satir dusurmedigi icin tuketim
# dogrudan yuklenen donemlerden hesaplanir.
def rapor(kayitlar, donemler, kural):
    v, _ = a3_tuketim([k for k in kayitlar if k["donem"] in donemler])
    v = [dict(k, m3=k["m3"] * (kural if k["tip"] == "isyeri" else 1.0)) for k in v]
    oz, _ = a4_ozet(v)
    sun, _ = a5_sun(oz)
    return sun, len(v)


def fark(a, b):
    return {x: round(a[x] - b[x], 2) for x in sorted(a)}


KAYNAK = kaynak_uret()
AYAR = {"gelistirme": (3, 0.30, 1.00), "hazirlik": (6, 0.10, 1.00), "uretim": (12, 0.05, 1.05)}
SON = {ad: set(DONEM[len(DONEM) - b:]) for ad, (b, _, _) in AYAR.items()}
print("ortam        bolum  bant  kural  tuketim satiri  bandin gizledigi  2026-07 yuklu")
for ad, (b, e, ku) in AYAR.items():
    s, n = rapor(KAYNAK, SON[ad], ku)
    print(f"{ad:<12} {b:>5}  {e:<4}  {ku:<5}  {n:>14}  {int(e * 200):>16}"
          f"  {'evet' if '2026-07' in SON[ad] else 'hayir':>13}")
print()
for ad in AYAR:
    print(f"{ad:<12} {rapor(KAYNAK, SON[ad], AYAR[ad][2])[0]}")
```

```
ortam        bolum  bant  kural  tuketim satiri  bandin gizledigi  2026-07 yuklu
gelistirme       3  0.3   1.0               400                60          hayir
hazirlik         6  0.1   1.0              1000                20           evet
uretim          12  0.05  1.05             2200                10           evet

gelistirme   {'merkez': 1384.0, 'kuzey': 1265.0, 'dogu': 928.5, 'bati': 853.5, 'guney': 1102.5}
hazirlik     {'merkez': 1387.6, 'kuzey': 1229.0, 'dogu': 897.8, 'bati': 846.2, 'guney': 1077.8}
uretim       {'merkez': 1357.32, 'kuzey': 1235.57, 'dogu': 902.13, 'bati': 859.22, 'guney': 1095.81}
```

Üç satır aynı kodun üç çıktısıdır ve hiçbiri hatalı değildir; her biri kendi ayarına göre doğrudur.
`merkez` geliştirmede 1384,00, hazırlıkta 1387,60, üretimde 1357,32 raporlanır, oysa kaynak üç
koşumda da aynı 2400 satırdır.

Son sütun bir önceki derse bağlanır. Geliştirme ortamı yalnız son üç dönemi yükler ve `2026-07` o
pencereye girmez, oysa K01'in altı bozulma sınıfının hepsi tam o dönemi bozar. Hattı doğrulayan
koşum bozulmanın dönemini **hiç görmez**; üstelik bandı 0,30'dur ve altmış satıra kadarki kaybı
zaten gizler. Doğrulama yeşil biter, üretim bitmez.

## Sapma Nereden Geldi

İkinci blok sapmayı iki kaynağa ayırır, sonra kural sürümünün `2026-08` koşumunda dağıtıldığı on bir
koşumluk arşive bakar.

```python
# Bu blok ilk bloktaki rapor , fark , KAYNAK , DONEM , AYAR ve SON tanimlarini surdurur.
TUM = set(DONEM)
TABAN, GEL, KUR = (rapor(KAYNAK, TUM, 1.00)[0], rapor(KAYNAK, SON["gelistirme"], 1.00)[0],
                   rapor(KAYNAK, TUM, 1.05)[0])
print("bolge   bolum etkisi  kural etkisi  gelistirme eksi uretim")
for b in sorted(TABAN):
    bl, ku = round(GEL[b] - TABAN[b], 2), round(KUR[b] - TABAN[b], 2)
    print(f"{b:<8} {bl:>12}  {ku:>12}  {round(bl - ku, 2):>22}")

# ---- ARSIV: her donem bir kosum , o doneme kadarki butun donemler yuklenir.
# Kural surumu s1 (1,00) idi ; 2026-08 kosumunda s2 (1,05) dagitildi.
KOD, DAGITIM = {"s1": 1.00, "s2": 1.05}, "2026-08"
arsiv = {d: ("s2" if d >= DAGITIM else "s1",
             rapor(KAYNAK, set(DONEM[:i + 1]), KOD["s2" if d >= DAGITIM else "s1"])[0])
         for i, d in enumerate(DONEM) if i > 0}

# Olagan donem hareketi: kod hic degismeseydi rapor ne kadar oynardi. Ilk iki
# kosum atlanir , orada ortalama iki donemden azini tasir.
olagan = [abs(v) for i in range(3, len(DONEM))
          for v in fark(rapor(KAYNAK, set(DONEM[:i + 1]), 1.00)[0],
                        rapor(KAYNAK, set(DONEM[:i]), 1.00)[0]).values()]
y07, y08 = set(DONEM[:7]), set(DONEM[:8])
gozlenen = fark(arsiv["2026-08"][1], arsiv["2026-07"][1])
veriden = fark(rapor(KAYNAK, y08, 1.00)[0], rapor(KAYNAK, y07, 1.00)[0])
koddan = fark(rapor(KAYNAK, y08, 1.05)[0], rapor(KAYNAK, y08, 1.00)[0])
print("\nbolge   gozlenen sicrama  veriden  koddan")
for b in sorted(gozlenen):
    print(f"{b:<8} {gozlenen[b]:>16}  {veriden[b]:>7}  {koddan[b]:>6}")
print(f"olagan donem hareketi (kod sabit) {round(min(olagan), 2)} ile {round(max(olagan), 2)} ;"
      f" kodun biraktigi iz {min(koddan.values())} ile {max(koddan.values())}")

damgasiz = {d: {"donem": d, "sunum": s} for d, (_, s) in arsiv.items()}
damgali = {d: dict(x, kod=arsiv[d][0], ayar=f"uretim/{len(DONEM)}/{KOD[arsiv[d][0]]:.2f}")
           for d, x in damgasiz.items()}
kimlik = [sum("kod" in x and "ayar" in x for x in a.values()) for a in (damgasiz, damgali)]
print(f"\narsiv {len(arsiv)} rapor ; kimlik tasiyan damgasizda {kimlik[0]} ,"
      f" damgalida {kimlik[1]} ; kimlikleme icin kosum damgasizda"
      f" {len(KOD) * len(arsiv)} , damgalida 0")
print(f"2026-08 damgasi: {damgali['2026-08']['kod']} / {damgali['2026-08']['ayar']}")
```

```
bolge   bolum etkisi  kural etkisi  gelistirme eksi uretim
bati            20.41         26.13                   -5.72
dogu            47.14         20.77                   26.37
guney           36.95         30.26                    6.69
kuzey           52.45         23.02                   29.43
merkez          62.55         35.87                   26.68

bolge   gozlenen sicrama  veriden  koddan
bati                13.74   -11.88   25.62
dogu                15.59    -4.81    20.4
guney                25.1    -3.76   28.86
kuzey                9.88    -11.4   21.28
merkez              52.24    17.53   34.71
olagan donem hareketi (kod sabit) 0.42 ile 38.3 ; kodun biraktigi iz 20.4 ile 34.71

arsiv 11 rapor ; kimlik tasiyan damgasizda 0 , damgalida 11 ; kimlikleme icin kosum damgasizda 22 , damgalida 0
2026-08 damgasi: s2 / uretim/12/1.05
```

İlk tablonun iki etkisi aynı büyüklük düzenindedir: bölüm sayısı sunumu 20,41 ile 62,55, kural
sürümü 20,77 ile 35,87 arasında kaydırır ve ikisi de artı yöndedir. Raporun otuz birim yükseldiğini
gören biri bunun kural sürümünden mi yüklenen dönem sayısından mı geldiğini **sunuma bakarak**
ayıramaz. `bati` satırı daha kötüsünü söyler: iki etki +20,41 ile +26,13, toplam fark **−5,72**.
Neredeyse hiçbir şeyin değişmediğini söyleyen bir sayı, birbirini götüren iki büyük etkidir. **Küçük
fark, küçük değişikliğin kanıtı değildir.**

İkinci tabloda okuyucu yalnız gözlenen sıçramayı görür, 9,88 ile 52,24 arasını. Ayrıştırma bunun ne
olduğunu söyler: beş bölgenin dördünde **veri aşağı, rapor yukarı** gitmiştir; `bati`'de tüketim
11,88 düşerken rapor 13,74 yükselmiştir. Son satır kapıyı kapatır: kodun bıraktığı iz 20,40 ile
34,71, olağan dönem hareketi ise 0,42 ile 38,30 arasındadır. Kodun izi olağanın **içindedir**;
sıçramaya bakarak bir dağıtımın olduğunu anlamanın yolu yoktur.

Geriye damga kalır. On bir raporun damgasız arşivde **hiçbiri** kimlik taşımaz, damgalıda on biri
de taşır. Damgasız arşivde bir raporun hangi kodla üretildiğini bulmak iki sürümü on bir dönem
boyunca yeniden koşturmayı, yani **22 koşumu** gerektirir — her eski sürüm hâlâ kurulabiliyorsa.
Kapsam da ölçülür: kural sürümü kodun içinde değil ortam ayarındaydı, damgaya yalnız kod parmak izi
yazılsaydı `s1` ile `s2` **aynı damgayı** taşırdı. **Damganın sınırı kodun sınırı değil, koşumu
belirleyen her şeyin sınırıdır.**

## Özet

- Aynı hat kodu üç ortamda üç ayrı rapor üretir ve hiçbiri hatalı değildir: aynı 2400 satırdan 400,
  1000 ve 2200 tüketim satırı çıkar, `merkez` 1384,00, 1387,60 ve 1357,32 raporlanır.
- Geliştirme ortamı `2026-07`'yi hiç yüklemez ve bandı altmış satıra kadarki kaybı gizler; hattı
  doğrulayan koşum bozulmanın bulunduğu dönemi görmeden yeşil biter.
- Ortam ayarının etkisi (20,41 … 62,55) ile kural sürümünün etkisi (20,77 … 35,87) aynı büyüklük
  düzenindedir; `bati`'de ikisi birbirini götürüp farkı **−5,72**'ye indirir.
- Kodun bıraktığı iz (20,40 … 34,71) olağan dönem hareketinin (0,42 … 38,30) içinde kalır ve dört
  bölgede veri aşağı giderken rapor yukarı gider.
- Damgasız arşivde kimlik taşıyan rapor **0**, damgalıda **11**'dir; kimlikleme 22 koşum ister ve
  damga kodu değil, kural sürümünü de içeren bütün ayarı kapsar.

## Kurs Kapanışı

Satırlar ortak birim taşımaz; her satırın **hangi ölçütle** okunduğu ders adının yanındadır.
Parantezdeki fark **orkestrasyonlu kurulum eksi orkestrasyonsuz tabandır**; işaretin yönü ölçüt
adından okunur.

| Ders | Orkestrasyonsuz taban | Orkestrasyonlu kurulum | Bedel |
|---|---|---|---|
| `veri-alma/01` — taşınan satır ve kaçan değişiklik | tam yükleme **15.560**, kaçan **0** | artımlı yükleme **2.360** (**−13.200**), kaçan **148** (**+148**) | kaçanı yalnız dağılım denetimi, aşama 4'te bildirir |
| `veri-alma/02` — alınan satır, sayfa 25 | yeniden denemesiz **2075** | yeniden denemeli **2025** (**−50**) | 112 sayfa gecikir, `2026-12` hiç alınmaz |
| `veri-alma/03` — etkin tüketici | tek bölüm **1/4** | dört bölüm **4/4** (**+3**) | abone anahtarında yük 708 ile 492 arasında eğrilir |
| `veri-alma/04` — düşen satır ve kirli hücre | tolerans 0: **40** ve **10/55** | tolerans 1: **0** ve **0** (**−40**, **−10**) | taşınan durum 400'den **600** girdiye çıkar |
| `veri-alma/05` — tüketim satırı ve sapma | en çok bir kez **2162**, −9,18 … −28,36 | en az bir kez **2200** (**+38**), sapma **boş** | 19 yinelenme oluşur, kayıp iki eşiğin de altındadır |
| `veri-alma/06` — koşumlar arası fark | geri yazmayan hat **0,00** | ters ETL **47,00 / 10,90 / 14,36** | 55 hücrenin **55'i** kirlenir, dört denetim yeşildir |
| `donusturme/01` — yeniden hesaplanabilen kural | ETL **0**, hedefe 55 satır | ELT **3** (**+3**), hedefe 2400 satır (**+2345**) | hedefte okunan hücre 110'dan **33110**'a çıkar |
| `donusturme/02` — ihlal edilen bağımlılık | elle sıra **1**, eksik girdili **7** model | çözümleyici **0** ve **0** (**−1**, **−7**) | ihlalli koşum hata vermez, sunum 17,46 … 28,37 sapar |
| `donusturme/03` — durdurulan bozulma sınıfı | yalnız sunum **2/6**, 55 hücre | üç katman **6/6** (**+4**), 2400 + 2200 + 55 | yakalanan altının **üçü** sunulan değeri değiştirmez |
| `donusturme/04` — yakalanan bozulma sınıfı | beklentisiz **0/6** | altı beklenti **4/6** (**+4**) | `yinelenen` ile `kayan_tip` dönüşümde yutulur |
| `donusturme/05` — yeniden hesaplanan dönem | tam uygulama **12** dönem, 2200 satır | kısmi uygulama **2** dönem, 400 satır (**−10**) | rapor **−16,98 … −29,57** sapar, altı beklenti yeşildir |
| `orkestrasyon/01` — düşen görev başına yeniden koşan görev | elle **48** | çizgeyle **5** (**−43**) | kırk yedi kenar elle yazılır |
| `orkestrasyon/02` — eksik dönem ve tüketim satırı | sabit takvim **6** eksik, **900** | veri hazırlığı tetikleyicisi **0** ve **2200** (**+1300**) | yedi dönemlik toplam gecikme |
| `orkestrasyon/03` — sapma ve ateşleyen denetim | yarım yazım **−49,09 … −121,82**, iki denetim yeşil | atomik yazım **−2,89 … +12,80**, ikisi de ateşler | tüketim 2040 yerine **1800**'e iner |
| `orkestrasyon/04` — görülen bozulma sınıfı | göstergesiz **0/6**, gecikme tanımsız | üç gösterge **5/6** (**+5**), gecikme 0–1 dönem | `birim_degisti` görünmez ve iki dönem çöp bırakır |
| `orkestrasyon/05` — kimlik taşıyan rapor | damgasız arşiv **0/11** | damgalı arşiv **11/11** (**+11**) | kimlikleme damgasızda **22 koşum** ister |

Tablo tek bir kuralın on altı kez yazılmasıdır. **Bir hattın sayısı bir kez doğru koşması değil,
yeniden koşturulduğunda aynı sonucu vermesidir; yeniden koşturulamayan hat ölçülmemiş sayılır.**
Ölçüt adları kuralın kendisidir: `orkestrasyon/01`'de yeniden koşan görev 48'den 5'e iner,
`donusturme/01`'de yeniden hesaplanabilen kural 0'dan 3'e çıkar, `veri-alma/06`'da hat kendi
çıktısını okuduğu için koşumlar arası fark 0,00 olmaktan çıkıp 47,00'ye ulaşır.

**İkinci iddia aynı tablodan okunur: orkestrasyon da bozar.** `veri-alma/02`'de yeniden deneme
kotayı yer, alınan satırı 2075'ten 2025'e düşürür ve bir dönemi yok eder. `veri-alma/06`'da ters ETL
koşumlar arası farkı 47,00'ye çıkarıp 55 hücrenin 55'ini kirletir, `orkestrasyon/03`'te üç denemeli
yeniden deneme 240 satır çoğaltır, `donusturme/05`'te kısmi geri doldurma raporu −16,98 ile −29,57
arasında saptırır, `orkestrasyon/02`'de emniyet penceresi koşumu 24'e çıkarır. `orkestrasyon/04`'te
bant genişledikçe hacmin gördüğü sınıf sıfıra iner, bu derste ortam ayarı aynı kodu 62,55'e kadar
saptırır.

**Üçüncü iddia daha sessizdir: sunulan sayı değişmez ya da makul görünür.** `veri-alma/04`'te dokuz
kurulumun hiçbirinde sunulan beş değer değişmez, on hücre kirlidir. `veri-alma/05`'te on dokuz
yinelenme sunum farkını boş bırakır, kayıp ise hiçbir denetime takılmaz. `orkestrasyon/03`'te yarım
yazılan bölümde ham satır 2320'de kalır ve iki denetim yeşildir, `donusturme/04`'te dönem etiketini
kaydıran kural 2200 satırı ve beş değeri aynı bırakır, `donusturme/03`'te durdurulan altı sınıfın
üçü sunulan değeri değiştirmez, `orkestrasyon/04`'te `birim_degisti` üç göstergeye birden görünmez
ve bu derste kodun bıraktığı iz olağan hareketin içine düşer. Dokuz derste hat yanlış bir sayı sunar
ve hiçbir şey bunu söylemez.

On altı derste hat **tek bir makinede** koşuyormuş gibi ele alındı: görevler sıraya girdi, düştü,
yeniden denendi ve kırk sekiz düğüm tek listeye dizildi. Veri tek bir makineye sığmadığında **işin
nasıl bölüneceği**, bölümler dengesiz olduğunda hangi bölümün bitişi geciktireceği ve **ağ üzerinden
veri taşımanın** bedeli hiç sorulmadı. Sonraki kurs görevin sırasını değil, bir görevin **kaç parçaya
bölündüğünü** ve o parçaların birbirine ne kadar veri gönderdiğini ölçer.
