---
title: 'Dosya Depolama'
source: 'https://academia.sh/tr/kurslar/bulut-depolama/dosya-depolama'
course: 'Bulutta Depolama ve Veri'
language: tr
updated: '2026-08-17T18:06:56+00:00'
license: 'CC BY-SA 4.0'
---

# Dosya Depolama

Paylaşımlı dosya sisteminin çok yazarlı erişimde ölçülmesi: aynı verinin nesne, blok ve paylaşımlı dosya olarak tutulup kaç örneğin aynı anda yazabildiğinin, kilidin nasıl çalıştığının, gecikmenin ve aylık ücretin sayılması; paylaşımlı dosya sisteminin kazandırmadığı durumun adıyla yazılması ve erişim protokolünün geri alınamayan kalem olarak çıkarılması.

Önceki ders bir kapıyla bitti: blok birimi tek örneğe bağlıdır ve on iki toplayıcı örnekten aynı
anda yalnız biri yazabilir. Kurgu ölçüm ağında bu bir ayrıntı değil doğrudan engeldir — saha ekipleri
iş emri eklerini aynı dosyalara bırakır, fatura üretimi aynı dizinden okur ve bunların hepsi ayrı
örneklerde koşar. Nesne deposu birden çok yazarı kabul eder ama kilit ve kısmi güncelleme sunmaz;
blok birimi ikisini de sunar ama tek yazara izin verir.

Üçüncü tür bu boşluğu doldurur: **paylaşımlı dosya sistemi**. Ağ üzerinden bağlanır, birden çok
örnek aynı anda takar, tam bir dosya sistemi arayüzü sunar — dizin, yeniden adlandırma, kısmi yazma
ve bayt aralığı kilidi. Ölçülecek şey bunun ne kadarının gerçekten kazanç olduğudur: aynı veri üç
türde de tutulabilir ve üçünün farkı yalnız çok yazarlı erişimde görünür.

- **DT25** — Kurgu iş yükü: on iki saha örneği, saniyede 340 ek, her ek 2 KiB, 4.800 etkin iş emri
  dosyası. Yazmaların hangi dosyaya düştüğü modeldeki üreteçle belirlenir, tohum 71549'dur.
- **DT26** — Gecikmeler modeldir: nesne deposu isteği 25 ms, blok birimi 0,6 ms, paylaşımlı dosya
  sistemi 2,5 ms; uzak örnekten tek yazara ağ turu 0,4 ms.
- **DT27** — Nesne deposunda oku-değiştir-yaz penceresi 50 ms'dir; aynı dosyaya bu pencere içinde
  gelen ikinci yazma birincisini ezer.

```js
// dosya/model.mjs — uc depolama turu, cok yazarli is yuku ve ucretler MODELDIR. Ucretler kurgu
// birimdir; turler urun adiyla degil erisim bicimiyle anilir.
export const ORNEK = 12, YAZMA_S = 340, EK_KIB = 2, DOSYA_KIB = 11, AKTIF = 4800;
export const AY_SN = 2_592_000;                    // 30 gunluk ay, saniye
export const TUR = {
  "nesne deposu": { yazar: ORNEK, kilit: "yok", gecikmeMs: 25, saklama: 0.023, istek: 0.0050 / 1000, verim: 0 },
  "blok birimi": { yazar: 1, kilit: "tek yazar", gecikmeMs: 0.6, saklama: 0.080, istek: 0, verim: 0 },
  "paylasimli dosya": { yazar: ORNEK, kilit: "bayt araligi", gecikmeMs: 2.5, saklama: 0.300, istek: 0, verim: 0.60 },
};
export const AG_TURU_MS = 0.4;                     // uzak ornekten tek yazara giden tur
export const CAKISMA_MS = 50;                      // nesne deposunda oku-degistir-yaz penceresi
export const GIB = (bayt) => bayt / 1024 ** 3;

// Yazmalarin hangi dosyaya dustugu MODELDIR: uretec burada, tohum gorunur. Dagilim carpiktir.
export const TOHUM = 71549;
export function* yazmalar(adet) {
  let x = TOHUM >>> 0;
  const u = () => (x = (Math.imul(x, 1664525) + 1013904223) >>> 0) / 4294967296;
  for (let i = 0; i < adet; i++)
    yield { t: (i / YAZMA_S) * 1000, dosya: Math.floor(AKTIF * Math.pow(u(), 3)) };
}
// Tek sunucuda kuyruk: sabit hizmet suresiyle ortalama bekleme (yogunluk p, hizmet S).
export const bekleme = (p, S) => (p >= 1 ? Infinity : (p / (2 * (1 - p))) * S);
```

## Aynı Veri, Üç Tür, Çok Yazar

```js
// dosya/cok-yazar.mjs — ayni veri uc turde: kac yazar, kilit nasil, gecikme ve ucret ne
import { ORNEK, YAZMA_S, EK_KIB, DOSYA_KIB, AKTIF, AY_SN, TUR, AG_TURU_MS, CAKISMA_MS, GIB, TOHUM, yazmalar, bekleme }
  from "./model.mjs";

const g = (x, n, d = 2) => x.toFixed(d).padStart(n);
const s = (x, n) => String(x).padStart(n);
const SURE_SN = 60, ADET = YAZMA_S * SURE_SN;

// 1) Nesne deposu: kilit yok. Ayni dosyaya CAKISMA_MS icinde gelen ikinci yazma oncekini eziyor.
const sonYazma = new Map();
let kayip = 0, enSicak = 0;
const sayac = new Map();
for (const y of yazmalar(ADET)) {
  const onceki = sonYazma.get(y.dosya);
  if (onceki !== undefined && y.t - onceki < CAKISMA_MS) kayip++;
  sonYazma.set(y.dosya, y.t);
  sayac.set(y.dosya, (sayac.get(y.dosya) ?? 0) + 1);
}
for (const n of sayac.values()) enSicak = Math.max(enSicak, n);
const sicakHiz = enSicak / SURE_SN;

// 2) Blok birimi: tek yazar. Digerleri ag uzerinden o ornege gonderiyor, kuyruk orada olusuyor.
const S_BLOK = TUR["blok birimi"].gecikmeMs, pBlok = YAZMA_S * S_BLOK / 1000;
const blokGecikme = AG_TURU_MS + S_BLOK + bekleme(pBlok, S_BLOK);
// 3) Paylasimli dosya sistemi: dosya basina bayt araligi kilidi; kuyruk yalniz ayni dosyada.
const S_PAY = TUR["paylasimli dosya"].gecikmeMs, pSicak = sicakHiz * S_PAY / 1000;
const payGecikme = S_PAY + bekleme(pSicak, S_PAY);

const veriGib = GIB(AKTIF * DOSYA_KIB * 1024);
const aylikYazma = YAZMA_S * AY_SN;
const UCRET = {
  "nesne deposu": TUR["nesne deposu"].saklama * veriGib + aylikYazma * TUR["nesne deposu"].istek,
  "blok birimi": TUR["blok birimi"].saklama * Math.ceil(YAZMA_S / 3 / 4) * 4,   // is/s butcesi boyut ister
  "paylasimli dosya": TUR["paylasimli dosya"].saklama * veriGib +
    TUR["paylasimli dosya"].verim * (YAZMA_S * EK_KIB / 1024),
};
console.log(`${ORNEK} saha ornegi, saniyede ${YAZMA_S} ek (${EK_KIB} KiB), ${AKTIF} etkin is emri dosyasi ` +
  `(${DOSYA_KIB} KiB). Dagilim carpik, uretec modelde, tohum ${TOHUM}. ${SURE_SN} sn kosuldu.`);
console.log(`en sicak dosya ${SURE_SN} sn'de ${enSicak} yazma aldi: ${g(sicakHiz, 0, 1)} yazma/s.`);
console.log("\ntur              | ayni anda yazar | kilit        | gecikme (ms) | kayip guncelleme | aylik ucret");
console.log("-----------------|-----------------|--------------|--------------|------------------|------------");
const GECIKME = { "nesne deposu": TUR["nesne deposu"].gecikmeMs, "blok birimi": blokGecikme, "paylasimli dosya": payGecikme };
const KAYIP = { "nesne deposu": kayip, "blok birimi": 0, "paylasimli dosya": 0 };
for (const [ad, t] of Object.entries(TUR))
  console.log(`${ad.padEnd(16)} | ${s(t.yazar, 15)} | ${t.kilit.padEnd(12)} | ${g(GECIKME[ad], 12, 2)} | ` +
    `${s(KAYIP[ad], 16)} | ${g(UCRET[ad], 11)}`);
console.log(`nesne deposunda ${ADET} yazmanin ${kayip} tanesi (%${g(100 * kayip / ADET, 0, 2)}) sessizce kayboldu: ` +
  `kilit yok, son yazan kazandi.`);
console.log(`blok biriminde 11 ornek dogrudan yazamiyor; tek yazarin yogunlugu %${g(100 * pBlok, 0, 1)}, ` +
  `bekleme ${g(bekleme(pBlok, S_BLOK), 0, 3)} ms. O ornek dusunce ${ORNEK}/${ORNEK} yazar duruyor.`);
console.log(`paylasimli dosya sisteminde en sicak dosyanin yogunlugu %${g(100 * pSicak, 0, 2)}, ` +
  `kilit beklemesi ${g(bekleme(pSicak, S_PAY), 0, 4)} ms; kilit dosya basina, kova basina degil.`);

// Kazandirmadigi durum: tek yazar, buyuk sirali okuma. Ayni veri, ayni is, uc turde ucret.
const FATURA = { veriGib: 400, mibS: 180 };
const F = {
  "nesne deposu": TUR["nesne deposu"].saklama * FATURA.veriGib,
  "blok birimi": 0.045 * 452,                        // verim ayarli birim, onceki derste hesaplandi
  "paylasimli dosya": TUR["paylasimli dosya"].saklama * FATURA.veriGib + TUR["paylasimli dosya"].verim * FATURA.mibS,
};
console.log(`\nkazandirmadigi durum — fatura uretimi: tek yazar, ${FATURA.mibS} MiB/s sirali okuma, ${FATURA.veriGib} GiB:`);
for (const [ad, u] of Object.entries(F))
  console.log(`  ${ad.padEnd(16)} ${g(u, 8)} birim/ay${ad === "paylasimli dosya" ?
    ` — en ucuzun ${g(u / Math.min(...Object.values(F)), 0, 1)} kati, kazandirdigi tek sey kullanilmayan kilit` : ""}`);
```

```
12 saha ornegi, saniyede 340 ek (2 KiB), 4800 etkin is emri dosyasi (11 KiB). Dagilim carpik, uretec modelde, tohum 71549. 60 sn kosuldu.
en sicak dosya 60 sn'de 1168 yazma aldi: 19.5 yazma/s.

tur              | ayni anda yazar | kilit        | gecikme (ms) | kayip guncelleme | aylik ucret
-----------------|-----------------|--------------|--------------|------------------|------------
nesne deposu     |              12 | yok          |        25.00 |             1057 |     4406.40
blok birimi      |               1 | tek yazar    |         1.08 |                0 |        9.28
paylasimli dosya |              12 | bayt araligi |         2.56 |                0 |        0.41
nesne deposunda 20400 yazmanin 1057 tanesi (%5.18) sessizce kayboldu: kilit yok, son yazan kazandi.
blok biriminde 11 ornek dogrudan yazamiyor; tek yazarin yogunlugu %20.4, bekleme 0.077 ms. O ornek dusunce 12/12 yazar duruyor.
paylasimli dosya sisteminde en sicak dosyanin yogunlugu %4.87, kilit beklemesi 0.0639 ms; kilit dosya basina, kova basina degil.

kazandirmadigi durum — fatura uretimi: tek yazar, 180 MiB/s sirali okuma, 400 GiB:
  nesne deposu         9.20 birim/ay
  blok birimi         20.34 birim/ay
  paylasimli dosya   228.00 birim/ay — en ucuzun 24.8 kati, kazandirdigi tek sey kullanilmayan kilit
```

Tablo üç türü tek ekranda ayırıyor. Nesne deposu on iki yazarı kabul eder ama kilidi yoktur:
altmış saniyede 20.400 yazmanın 1.057'si, yüzde 5,18'i, sessizce kaybolur. Hata dönmez, günlükte iz
kalmaz, saha ekibinin eklediği not yalnızca yoktur. Aylık ücreti de en yüksektir — 4.406,40 birim,
neredeyse tamamı yazma isteklerinden gelir: küçük ve sık yazma, nesne deposunun en pahalı kullanım
biçimidir.

Blok birimi kilidi ve kısmi yazmayı verir, gecikmesi en düşüktür (1,08 ms), ücreti 9,28 birimdir —
ama yazar sayısı birdir. On bir örnek doğrudan yazamaz, yazmalarını tek örneğe gönderir. Bu örneğin
yoğunluğu yüzde 20,4'tür, yani bugün rahattır; asıl kalem başarımda değil yapıdadır: o örnek
düştüğünde on iki yazarın on ikisi birden durur. Tek yazarlı huni bir başarım kısıtı değil, bir
kullanılabilirlik kalemidir.

Paylaşımlı dosya sistemi ikisini birden verir: on iki yazar, bayt aralığı kilidi, kayıp güncelleme
sıfır. Kilit dosya başınadır, kova başına değil — en sıcak dosya bile saniyede 19,5 yazma alır,
yoğunluğu yüzde 4,87'dir ve ortalama kilit beklemesi 0,064 ms'dir. Gecikmesi blok biriminin iki
katıdır (2,56 ms), çünkü her işlem ağdan geçer.

Son blok türün sınırını adıyla yazıyor. Fatura üretimi tek yazarlıdır ve büyük sıralı okuma yapar;
kilide ihtiyacı yoktur, dizin ağacına ihtiyacı yoktur. Paylaşımlı dosya sisteminde aylık 228,00
birim tutar — en ucuz seçeneğin 24,8 katı. **Paylaşımlı dosya sistemi çok yazarlı erişim için
alınır; tek yazarlı büyük sıralı okumada kazandırdığı tek şey kullanılmayan bir kilittir.**

## Erişim Protokolü Geri Alınamayan Kalemdir

- **DT28** — Kurgu uygulamanın dosya erişim noktaları ve her birinin kaç yerde geçtiği modelde
  yazılıdır.
- **DT29** — Paylaşımlı dosya sistemi bölgeye bağlıdır; veriyi başka bir yere kopyalamak çıkış
  ücreti doğurur.
- **DT30** — Ücretler kurgu birimdir; paylaşımlı dosya sistemi kullanılan boyutu ve verimi
  faturalandırır, blok birimi ayrılan boyutu.

```js
// dosya/protokol.mjs — erisim protokolu geri alinamayan kalemdir: cagri noktalari sayilir (MODEL)
import { AKTIF, DOSYA_KIB, GIB } from "./model.mjs";

// Kurgu uygulamanin dosya erisim noktalari: cagri, kac yerde gectigi, nesne modelinde karsiligi.
const NOKTA = [
  ["dosyayi bastan sona oku", 9, "var", "tam nesne getirme"],
  ["dosyanin bir araligini oku", 6, "var", "aralik istegi"],
  ["dosyayi bastan sona yaz", 5, "var", "tam nesne koyma"],
  ["dosyanin ortasina yaz", 7, "yok", "kismi guncelleme yok, nesne bastan yazilir"],
  ["dosyaya ekle", 8, "yok", "ekleme yok, nesne bastan yazilir"],
  ["dosyayi kirp", 2, "yok", "karsiligi yok"],
  ["dizin listele", 4, "kismen", "onek listeleme, sayfali ve ucretli"],
  ["dizin boyutunu oku", 2, "yok", "tum anahtarlar taranir"],
  ["yeniden adlandir", 3, "yok", "kopyala ve sil"],
  ["bayt araligi kilidi al", 5, "yok", "kilit yok"],
  ["degisikligi diske zorla", 3, "yok", "yazma zaten butun ya da hic"],
];
const g = (x, n, d = 2) => x.toFixed(d).padStart(n);
const s = (x, n) => String(x).padStart(n);
const toplam = NOKTA.reduce((a, n) => a + n[1], 0);
const tasinabilir = NOKTA.filter((n) => n[2] === "var").reduce((a, n) => a + n[1], 0);
const kismen = NOKTA.filter((n) => n[2] === "kismen").reduce((a, n) => a + n[1], 0);

console.log("cagri                      | yer | nesne modelinde | karsilik");
console.log("---------------------------|-----|-----------------|--------------------------------------");
for (const [ad, yer, durum, not] of NOKTA)
  console.log(`${ad.padEnd(26)} | ${s(yer, 3)} | ${durum.padEnd(15)} | ${not}`);
console.log(`\ntoplam ${toplam} cagri noktasi: ${tasinabilir} tanesi dogrudan tasinir, ${kismen} tanesi ` +
  `davranis degistirerek tasinir, ${toplam - tasinabilir - kismen} tanesi yeniden yazilir.`);
console.log(`yeniden yazilacak oran %${g(100 * (toplam - tasinabilir - kismen) / toplam, 0, 1)}; bu sayi ` +
  `veri boyutundan bagimsizdir — ${GIB(AKTIF * DOSYA_KIB * 1024).toFixed(3)} GiB de olsa ayni ${toplam - tasinabilir - kismen} nokta yazilir.`);

// Cikis ve aktarim: paylasimli dosya sistemi bolgeye baglidir.
const CIKIS = { "bolge ici": 0, "bolgeler arasi": 0.020, "internete": 0.085 };
const veriGib = GIB(AKTIF * DOSYA_KIB * 1024), YEDEK_GIB = 640;
console.log(`\ncikis: ${YEDEK_GIB} GiB'lik saha arsivi paylasimli dosya sisteminden okunup baska bir yere kopyalanirsa`);
for (const [nere, oran] of Object.entries(CIKIS))
  console.log(`  ${nere.padEnd(14)} ${g(YEDEK_GIB * oran, 7)} birim`);
console.log(`etkin is emri verisi ${veriGib.toFixed(3)} GiB; cikis ucreti verinin boyutuyla degil, ` +
  `nereye tasindigiyla olculur.`);
```

```
cagri                      | yer | nesne modelinde | karsilik
---------------------------|-----|-----------------|--------------------------------------
dosyayi bastan sona oku    |   9 | var             | tam nesne getirme
dosyanin bir araligini oku |   6 | var             | aralik istegi
dosyayi bastan sona yaz    |   5 | var             | tam nesne koyma
dosyanin ortasina yaz      |   7 | yok             | kismi guncelleme yok, nesne bastan yazilir
dosyaya ekle               |   8 | yok             | ekleme yok, nesne bastan yazilir
dosyayi kirp               |   2 | yok             | karsiligi yok
dizin listele              |   4 | kismen          | onek listeleme, sayfali ve ucretli
dizin boyutunu oku         |   2 | yok             | tum anahtarlar taranir
yeniden adlandir           |   3 | yok             | kopyala ve sil
bayt araligi kilidi al     |   5 | yok             | kilit yok
degisikligi diske zorla    |   3 | yok             | yazma zaten butun ya da hic

toplam 54 cagri noktasi: 20 tanesi dogrudan tasinir, 4 tanesi davranis degistirerek tasinir, 30 tanesi yeniden yazilir.
yeniden yazilacak oran %55.6; bu sayi veri boyutundan bagimsizdir — 0.050 GiB de olsa ayni 30 nokta yazilir.

cikis: 640 GiB'lik saha arsivi paylasimli dosya sisteminden okunup baska bir yere kopyalanirsa
  bolge ici         0.00 birim
  bolgeler arasi   12.80 birim
  internete        54.40 birim
etkin is emri verisi 0.050 GiB; cikis ucreti verinin boyutuyla degil, nereye tasindigiyla olculur.
```

Paylaşımlı dosya sistemi seçildiğinde devredilen karar listesi kısadır: sağlayıcı üst veri
sunucusunu, çoğaltmayı ve büyümeyi devralır. Elde kalan taraf ise bir şey daha içerir ve fatura
sütununda görünmez — **erişim protokolü**. Uygulama dosya yollarına, dizin ağacına ve kilitlere göre
yazılır. Bu bir yapılandırma değil, kod biçimidir.

Tablo bunun ölçüsünü veriyor. Elli dört erişim noktasının yirmisi nesne modeline doğrudan taşınır,
dördü davranış değiştirerek taşınır, otuzu yeniden yazılır: yüzde 55,6. Bu sayı **veri boyutundan
bağımsızdır** — 0,050 GiB'lik iş emri verisi de olsa aynı otuz nokta yeniden yazılır. Anahtar düzeni
geri alınamayan kalemdi çünkü veriyi taşımak gerekiyordu; erişim protokolü geri alınamayan kalemdir
çünkü **uygulamayı** taşımak gerekir, ve o taşımanın bedeli veriyle küçülmez.

Çıkış tarafı üçüncü kalemi kapatıyor. Paylaşımlı dosya sistemi tek bölgeye bağlıdır; 640 GiB'lik
saha arşivini bölge içinde okumak çıkış ücreti doğurmaz, bölgeler arasına taşımak 12,80 birim,
internete indirmek 54,40 birim tutar. Bu kursun ilk dersinden beri aynı kural işliyor: veri girerken
ücretsizdir, çıkarken ücretlidir ve ücreti nereye gittiğiyle ölçülür.

## Özet

- Üç tür çok yazarlı erişimde ayrışır: nesne deposu on iki yazar alır ama kilidi yoktur, blok birimi
  kilidi verir ama tek yazar alır, paylaşımlı dosya sistemi ikisini birden verir.
- Kilitsiz erişimin bedeli sessizdir: altmış saniyede 20.400 yazmanın 1.057'si, yüzde 5,18'i, hata
  dönmeden kaybolur. Aynı iş yükünde nesne deposu 4.406,40 birimle en pahalı seçenektir.
- Tek yazarlı huni bir başarım kısıtı değil kullanılabilirlik kalemidir: yoğunluk yüzde 20,4 ile
  rahattır, ama o örnek düştüğünde on iki yazarın on ikisi durur.
- Kilit dosya başınadır: en sıcak dosya saniyede 19,5 yazma alır, yoğunluğu yüzde 4,87, kilit
  beklemesi 0,064 ms. Gecikme blok biriminin iki katıdır, çünkü her işlem ağdan geçer.
- Kazandırmadığı durum adıyla yazılır: tek yazarlı büyük sıralı okumada 228,00 birim tutar, en ucuz
  seçeneğin 24,8 katı. Geri alınamayan kalem erişim protokolüdür — elli dört çağrı noktasının otuzu
  veri boyutundan bağımsız olarak yeniden yazılır.

## Sonraki Adım

Beş ders bir eksik bırakıyor. Kurgu ölçüm ağının saha fotoğrafları bir kez yazılıp neredeyse hiç
okunmuyor; ikinci derste ölçülen dağılımda bu ailenin yüzde 97'si yıl boyunca hiç açılmadı. Böyle
veri için sık erişilen sınıf açık bir israftır, ama arşiv katmanının ne olduğu henüz ölçülmedi:
saklama ücreti neredeyse yok gibidir, karşılığında veri **hemen okunamaz**. Sonraki ders bu takası
sayar — geri getirme hızı seçenekleri taranır, her birinde süre ile ücret birlikte çıkarılır, bir
denetim isteğinde kaç saat beklendiği hesaplanır ve en az saklama süresinin erken silinen nesneye ne
ödettiği gösterilir.
