---
title: 'Paylaşılan Sorumluluk Modeli'
source: 'https://academia.sh/tr/kurslar/bulut-temelleri/paylasilan-sorumluluk-modeli'
course: 'Bulut Temelleri'
language: tr
updated: '2026-08-17T18:06:54+00:00'
license: 'CC BY-SA 4.0'
---

# Paylaşılan Sorumluluk Modeli

Sağlayıcı ile müşteri sınırının ölçüsü: 24 kalemlik sorumluluk matrisinde sağlayıcıya geçen kalemin 6'dan 16 ve 20'ye çıkması, boşlukta kalan kalemin 2, 4 ve 5, çakışan kalemin 2, 4 ve 2 olması, sekiz olayın toplam 56, 73 ve 68 turda kapanması ve bu turların 28, 35 ve 35'inin yalnız boşluktan gelmesi, sekiz olaydan 4, 5 ve 4'ünün veri kaybıyla kapanması, çıkışta taşınan kalemin 18'den 8 ve 4'e inmesi.

Önceki ders kiralamanın bedelini paraya çevirdi ve bir kalemi adıyla saydı: **işletim emeği**.
Kendi donanımında o emek tek bir sayıdır ve tümü kurumundur. Kiralamada bir kısmı sağlayıcıya
geçer — ama tam olarak hangi kısmı? Bu ders o sınırı çizer ve çizginin iki yanında değil,
**üstünde** ne olduğunu sayar.

**Paylaşılan sorumluluk**, bir hizmetin ayakta ve güvende kalması için gereken işlerin sağlayıcı
ile müşteri arasında bölünmesidir. M20'nin **devir sözleşmesi**yle aynı biçimdedir ama sınırı
başka yerdedir: orada iş yazan ekip ile işleten ekip arasında bölünüyordu ve iki taraf da aynı
kurumdaydı; burada sınırın öte yanı bir sözleşmedir ve karşı taraf masaya oturmaz. Bu fark tek bir
yeni sınıf üretir: bir kalem **hiç kimsenin** olabilir.

## Sorumluluk Matrisi

Örnek, kursun kurgu **bölgesel ölçüm ağı**dır: okuma toplayıcı, doğrulayıcı, faturalama ve iş emri
servisleri, gecelik toplu iş, beş ekip. Ağ da servisler de kurgudur; aşağıdaki matris bir
**modeldir**, gerçek bir sağlayıcı, sözleşme ya da olay kaydı yoktur.

**BK25:** sorumluluk matrisi 24 kalemdir; her kalem üç hizmet modelinde sağlayıcıda, müşteride ya
da paylaşılandır. **BK26:** paylaşılan kalem üç biçimde davranır — **sağlam** (iki taraf da kendi
payını üstlenir), **boşluk** (iki taraf da ötekinin yaptığını sanır, kimse yapmaz), **çakışma**
(ikisi de yapar, hangisinin geçerli olduğu belirsizdir); bu eğilim kaleme özgüdür ve modelden
bağımsızdır. **BK27:** sekiz olay vardır, her olay üç kaleme dokunur. **BK28:** olay turu kalemin
sınıfına göredir — sağlayıcıda 1, müşteride 1, sağlam paylaşılan 2, çakışan 3, boşlukta 8 tur;
boşluktaki kalem olay sırasında sıfırdan kurulur. **BK29:** dokunduğu kalemlerden biri boşlukta
olan olay veri kaybıyla kapanır. **BK30:** çıkışta müşteride kalan kalem taşınır; sağlayıcıda ve
paylaşılan olan kalemler yeni sağlayıcıda yeniden pazarlık edilir.

```js
// bulut/sorumluluk.mjs — kurgu olcum agi icin paylasilan sorumluluk matrisi (model): gercek bir
// saglayici, gercek bir sozlesme ya da gercek bir olay kaydi yok. Rastgelelik yok.

export const MODEL = ["altyapi", "platform", "yazilim"];
// Sutunlar: altyapi platform yazilim. S saglayicida, M musteride, P paylasilan.
// egilim: paylasilan kalem nasil davranir — saglam / bosluk / cakisma.
export const KALEM = `
  fiziksel-guvenlik        S S S  saglam
  ana-makine-yamasi        S S S  saglam
  konuk-is-sistemi-yamasi  M S S  saglam
  uygulama-yamasi          M M S  saglam
  ag-kurali                P P S  bosluk
  kenar-korunmasi          P P S  cakisma
  duragan-sifreleme        M P S  saglam
  aktarim-sifrelemesi      P P S  cakisma
  anahtar-yonetimi         M P P  bosluk
  kimlik-ve-erisim         M M M  saglam
  yedekleme-alma           M P S  saglam
  yedekten-donme-provasi   M M M  bosluk
  gunluk-toplama           M P P  saglam
  gunluk-saklama           M M P  bosluk
  uyari-esigi              M M M  saglam
  olay-ilk-yanit           M P P  cakisma
  olay-kok-neden           P P P  bosluk
  kapasite                 M P S  saglam
  imaj-dagitimi            M S S  saglam
  yapilandirma-denetimi    M M P  bosluk
  veri-siniflandirma       M M M  saglam
  veri-silme               M P P  bosluk
  bilesen-taramasi         M M P  saglam
  felaket-tatbikati        M P P  cakisma`
  .trim().split("\n").map((r) => {
    const [ad, ...k] = r.trim().split(/\s+/);
    return { ad, egilim: k[3], s: Object.fromEntries(MODEL.map((m, i) => [m, k[i]])) };
  });

// Cozumleme: sozlesme degeri P ise kalemin egilimi sinifi belirler.
export const sinif = (k, m) =>
  (k.s[m] === "P" ? { saglam: "pay", bosluk: "BOS", cakisma: "CAK" }[k.egilim]
    : k.s[m] === "S" ? "sag" : "mus");
export const SINIF = ["sag", "mus", "pay", "BOS", "CAK"];
export const say = (m, c) => KALEM.filter((k) => sinif(k, m) === c).length;

// Olay turu: kalem hangi siniftaysa o kadar tur. Boslukta kalem olay sirasinda sifirdan kurulur.
export const TUR = { sag: 1, mus: 1, pay: 2, CAK: 3, BOS: 8 };

export const OLAY = `
  sizinti-suphesi       gunluk-toplama gunluk-saklama olay-kok-neden
  veri-kaybi            yedekleme-alma yedekten-donme-provasi veri-siniflandirma
  disaridan-tarama      ag-kurali kenar-korunmasi olay-ilk-yanit
  anahtar-suresi        aktarim-sifrelemesi anahtar-yonetimi uyari-esigi
  yetkisiz-erisim       kimlik-ve-erisim gunluk-toplama olay-kok-neden
  yama-acigi            konuk-is-sistemi-yamasi bilesen-taramasi imaj-dagitimi
  yanlis-yapilandirma   yapilandirma-denetimi ag-kurali olay-ilk-yanit
  genis-kesinti         felaket-tatbikati kapasite yedekten-donme-provasi`
  .trim().split("\n").map((r) => {
    const [ad, ...k] = r.trim().split(/\s+/);
    return { ad, kalem: k.map((x) => KALEM.find((y) => y.ad === x)) };
  });

export function kos(m) {
  const olay = OLAY.map((o) => {
    const c = o.kalem.map((k) => sinif(k, m));
    return { ad: o.ad, tur: c.reduce((a, x) => a + TUR[x], 0),
      bos: c.filter((x) => x === "BOS").length, cak: c.filter((x) => x === "CAK").length };
  });
  const t = (f) => olay.reduce((a, o) => a + f(o), 0);
  return { olay, tur: t((o) => o.tur), kayipli: olay.filter((o) => o.bos > 0).length,
    bosTur: t((o) => o.bos * (TUR.BOS - 1)), cakTur: t((o) => o.cak * (TUR.CAK - 1)),
    tasinan: say(m, "mus"), pazarlik: KALEM.length - say(m, "mus") };
}
```

```js
// bulut/olc.mjs — sinir nerede, kac kalem boslukta, kac kalem cakisiyor, olayda ne oluyor.
import { KALEM, MODEL, OLAY, SINIF, TUR, sinif, say, kos } from "./sorumluluk.mjs";

const yaz = (g, ...s) => console.log(s.map((v, i) =>
  (g[i] < 0 ? String(v).padEnd(-g[i]) : String(v).padStart(g[i]))).join(""));
const R = Object.fromEntries(MODEL.map((m) => [m, kos(m)]));

console.log(`sorumluluk matrisi: ${KALEM.length} kalem x 3 hizmet modeli; ` +
  `${OLAY.length} olay, olay basina 3 kalem; olay turu ` +
  SINIF.map((c) => `${c} ${TUR[c]}`).join(", "));

const A = [-25, 11, 11, 10];
console.log("\n1. sorumluluk matrisi (sag saglayicida, mus musteride, pay paylasilan,");
console.log("   BOS ikisi de otekinin yaptigini saniyor, CAK ikisi de yapiyor)");
yaz(A, "kalem", ...MODEL);
for (const k of KALEM) yaz(A, k.ad, ...MODEL.map((m) => sinif(k, m)));

const B = [-36, 11, 11, 10];
console.log("\n2. sinir uc modelde nereye kayiyor");
yaz(B, "sinif", ...MODEL);
for (const c of SINIF) yaz(B, c, ...MODEL.map((m) => say(m, c)));
yaz(B, "saglayiciya gecen (sag+pay+BOS+CAK)", ...MODEL.map((m) => KALEM.length - say(m, "mus")));
yaz(B, "sorunlu kalem (BOS+CAK)", ...MODEL.map((m) => say(m, "BOS") + say(m, "CAK")));

const C = [-28, 11, 11, 10];
console.log("\n3. sekiz olay kac turda kapaniyor (parantez: boslukta kalem sayisi)");
yaz(C, "olay", ...MODEL);
OLAY.forEach((o, i) => yaz(C, o.ad,
  ...MODEL.map((m) => `${R[m].olay[i].tur} (${R[m].olay[i].bos})`)));
for (const [ad, f] of [["toplam tur", (r) => r.tur],
  ["  bosluktan gelen ek tur", (r) => r.bosTur],
  ["  cakismadan gelen ek tur", (r) => r.cakTur],
  ["veri kaybiyla kapanan olay", (r) => `${r.kayipli}/${OLAY.length}`]])
  yaz(C, ad, ...MODEL.map((m) => f(R[m])));

const D = [-33, 11, 11, 10];
console.log("\n4. cikista ne tasinir");
yaz(D, "olcu", ...MODEL);
for (const [ad, f] of [["tasinan kalem (musteride)", (m) => R[m].tasinan],
  ["yeniden pazarlik edilecek kalem", (m) => R[m].pazarlik],
  ["  bunlarin kaci zaten sorunlu", (m) => say(m, "BOS") + say(m, "CAK")],
  ["tasinan kalem orani (%)", (m) => Math.round((R[m].tasinan / KALEM.length) * 100)]])
  yaz(D, ad, ...MODEL.map(f));
```

```
sorumluluk matrisi: 24 kalem x 3 hizmet modeli; 8 olay, olay basina 3 kalem; olay turu sag 1, mus 1, pay 2, BOS 8, CAK 3

1. sorumluluk matrisi (sag saglayicida, mus musteride, pay paylasilan,
   BOS ikisi de otekinin yaptigini saniyor, CAK ikisi de yapiyor)
kalem                        altyapi   platform   yazilim
fiziksel-guvenlik                sag        sag       sag
ana-makine-yamasi                sag        sag       sag
konuk-is-sistemi-yamasi          mus        sag       sag
uygulama-yamasi                  mus        mus       sag
ag-kurali                        BOS        BOS       sag
kenar-korunmasi                  CAK        CAK       sag
duragan-sifreleme                mus        pay       sag
aktarim-sifrelemesi              CAK        CAK       sag
anahtar-yonetimi                 mus        BOS       BOS
kimlik-ve-erisim                 mus        mus       mus
yedekleme-alma                   mus        pay       sag
yedekten-donme-provasi           mus        mus       mus
gunluk-toplama                   mus        pay       pay
gunluk-saklama                   mus        mus       BOS
uyari-esigi                      mus        mus       mus
olay-ilk-yanit                   mus        CAK       CAK
olay-kok-neden                   BOS        BOS       BOS
kapasite                         mus        pay       sag
imaj-dagitimi                    mus        sag       sag
yapilandirma-denetimi            mus        mus       BOS
veri-siniflandirma               mus        mus       mus
veri-silme                       mus        BOS       BOS
bilesen-taramasi                 mus        mus       pay
felaket-tatbikati                mus        CAK       CAK

2. sinir uc modelde nereye kayiyor
sinif                                   altyapi   platform   yazilim
sag                                           2          4        11
mus                                          18          8         4
pay                                           0          4         2
BOS                                           2          4         5
CAK                                           2          4         2
saglayiciya gecen (sag+pay+BOS+CAK)           6         16        20
sorunlu kalem (BOS+CAK)                       4          8         7

3. sekiz olay kac turda kapaniyor (parantez: boslukta kalem sayisi)
olay                            altyapi   platform   yazilim
sizinti-suphesi                  10 (1)     11 (1)    18 (2)
veri-kaybi                        3 (0)      4 (0)     3 (0)
disaridan-tarama                 12 (1)     14 (1)     5 (0)
anahtar-suresi                    5 (0)     12 (1)    10 (1)
yetkisiz-erisim                  10 (1)     11 (1)    11 (1)
yama-acigi                        3 (0)      3 (0)     4 (0)
yanlis-yapilandirma              10 (1)     12 (1)    12 (1)
genis-kesinti                     3 (0)      6 (0)     5 (0)
toplam tur                           56         73        68
  bosluktan gelen ek tur             28         35        35
  cakismadan gelen ek tur             4         10         6
veri kaybiyla kapanan olay          4/8        5/8       4/8

4. cikista ne tasinir
olcu                                 altyapi   platform   yazilim
tasinan kalem (musteride)                 18          8         4
yeniden pazarlik edilecek kalem            6         16        20
  bunlarin kaci zaten sorunlu              4          8         7
tasinan kalem orani (%)                   75         33        17
```

Sayılar **ölçüm** sınıfındadır; girdileri BK25–BK30'dur.

## Sınır Nereye Kayıyor

İkinci tablo sınırı üç modelde okur. Sağlayıcıda duran kalem 2'den 4 ve 11'e çıkar; müşteride kalan
18'den 8 ve 4'e iner. Sağlayıcı tarafına geçen toplam kalem — sağlayıcıda, paylaşılan, boşlukta ve
çakışan — 6, 16 ve 20'dir. Buraya kadarki tablo önceki derslerin devredilen karar sayımıyla aynı
yöne bakar.

Asıl bulgu son satırdadır. **Sorunlu kalem sayısı — boşlukta artı çakışan — 4, 8 ve 7'dir.** En
yüksek sayı en çok devreden modelde değil, **ortadaki** modeldedir. Nedeni üçüncü satırdır:
paylaşılan kalem sayısı 0, 4 ve 2'dir ve boşluk ile çakışma yalnız paylaşılan kalemlerde doğar.
Altyapı hizmetinde neredeyse her şey müşterinindir, yazılım hizmetinde neredeyse her şey
sağlayıcının; ortada ise kalemlerin yarısı iki tarafa birden bakar.

**Belirsizlik, sınırın uçlarında değil kaydığı yerde birikir.** `olay-kok-neden` üç modelde de
boşluktadır: sağlayıcı kendi katmanının altını görmez, müşteri sağlayıcının içini göremez.
`kenar-korunmasi` ve `aktarim-sifrelemesi` altyapı ve platformda çakışmadadır — ikisi de
yapıldığı için kimse yokluğunu fark etmez, ama hangi ayarın geçerli olduğu bir olay anında
sorulur.

## Boşluk Bir Olayda Ne Yapıyor

Üçüncü tablo matrisi sekiz olayın üstünde koşturur. Toplam kapanış turu altyapıda 56, platformda
73, yazılımda 68'dir. Alt satırlar bu turların nereden geldiğini yazar: sıradan bir kalem
bir tur tutar, boşluktaki kalem sekiz; aradaki **ek tur boşlukta 28, 35 ve 35**, çakışmada 4, 10
ve 6'dır.

Altyapı sütunu bu dersin en keskin sayısını verir. Yirmi dört kalemin **ikisi** boşluktadır ve o
iki kalem, sekiz olayın toplam 56 turunun **tam yarısını** yazar. Boşlukta kalan kalem bir belge
eksiği değildir; olay anında sıfırdan kurulan bir iştir ve olayın saatini durdurmaz.

Tek tek olaylara bakıldığında etki daha nettir. `sizinti-suphesi` yazılım hizmetinde iki boşluk
kalemine birden dokunur ve 18 turda kapanır; aynı olay altyapıda 10 turdur. Buna karşılık
`veri-kaybi` ve `yama-acigi` hiçbir modelde boşluğa dokunmaz ve üç ile dört tur arasında kapanır.
Olayın pahalı olup olmadığını olayın kendisi değil, **dokunduğu kalemin matriste nereye düştüğü**
belirler.

Son satır bedeli teknik olmayan bir birime çevirir: sekiz olaydan **dördü, beşi ve dördü veri
kaybıyla kapanır**. Bu sayı üç modelde neredeyse aynıdır. Hizmet modelini derinleştirmek boşluk
sayısını 2'den 5'e çıkarır ama veri kaybıyla kapanan olay sayısını düşürmez — çünkü boşluk
kalemleri olay yollarının üstünde dağınık durur, tek bir yerde toplanmaz.

## Çakışma Boşluktan Ucuzdur

İki sorunlu sınıf aynı ağırlıkta değildir. Çakışan kalem olay başına iki ek tur yazar, boşluktaki
kalem yedi. Platformda matris dört çakışan ve dört boşlukta kalan kalem içerir; sekiz olayda
çakışma 10, boşluk 35 ek tur yazar — kalem sayıları eşit, bedelleri üç buçuk kat farklı.

Yönleri de terstir. Devir derinleştikçe çakışma 2'den 4'e çıkıp yeniden 2'ye iner, boşluk ise 2, 4,
5 diye artar. Sağlayıcı bir kalemi açıkça üstlendiğinde çakışma kaybolur; **açıkça üstlenilmeyen
kalem ise kaybolmaz, boşluğa düşer.** Bir sorumluluk matrisinde tehlikeli olan hücre iki işaretin
birden olduğu hücre değil, **hiç işaret olmayan** hücredir — ve o hücre denetlenirken
atlanır, çünkü tabloda boş görünen bir satır tamamlanmamış bir kayıt gibi durur, karşılıksız bir
yükümlülük gibi değil.

Bu ayrım denetim sırasını da belirler. Çakışan kalem, iki tarafın da yaptığı iş olduğu için ilk
bakışta göze çarpar: iki ayrı ayar, iki ayrı kayıt, iki ayrı fatura satırı vardır. Boşluktaki
kalemin hiçbir izi yoktur — ne bir ayar, ne bir kayıt, ne bir sorumlu. Matriste dört çakışan
kalemi bulmak bir öğleden sonra sürer; dört boşluğu bulmak, her kalemi tek tek iki tarafa da
sormayı gerektirir. **Sorumluluk matrisinin değeri doldurulmuş hücrelerinde değil, boş bırakılmış
hücrelerinin arandığında ortaya çıkar.**

## Çıkışta Ne Taşınır

Dördüncü tablo kursun ölçü eksenini kapatır. Müşteride kalan ve bu yüzden yeni bir düzene olduğu
gibi taşınan kalem 18, 8 ve 4'tür — sırasıyla 24 kalemin %75'i, %33'ü ve %17'si. Yeniden pazarlık
edilecek kalem 6, 16 ve 20'dir.

Son satır çıkışın gizli kısmını gösterir: yeniden pazarlık edilecek kalemlerin 4, 8 ve 7'si
**zaten sorunludur**. Yani çıkarken taşınan şey yalnız bir sorumluluk listesi değil, o listedeki
tanımsız hücrelerdir; boşlukta kalan bir kalem yeni sağlayıcıda da boşlukta kalmaya eğilimlidir,
çünkü boşluğun nedeni sağlayıcı değil, kalemin iki tarafın da görüş alanının dışında durmasıdır.

## Özet

- 24 kalemlik matriste sağlayıcıya geçen kalem 6, 16 ve 20'dir; müşteride kalan 18, 8 ve 4.
- Boşlukta kalan kalem 2, 4 ve 5; çakışan kalem 2, 4 ve 2'dir. Sorunlu kalem toplamı (4, 8, 7) en
  çok devreden modelde değil, **sınırın en çok kaydığı ortadaki modelde** en yüksektir.
- Sekiz olay 56, 73 ve 68 turda kapanır; bu turların 28, 35 ve 35'i yalnız boşluktan gelir.
  Altyapıda iki boşluk kalemi toplam turun tam yarısını yazar.
- Sekiz olaydan 4, 5 ve 4'ü veri kaybıyla kapanır; hizmet modelini derinleştirmek bu sayıyı
  düşürmez, çünkü boşluk kalemleri olay yollarının üstünde dağınık durur.
- Çakışma boşluktan ucuzdur: kalem sayıları eşitken platformda çakışma 10, boşluk 35 tur üretir.
  Devir derinleştikçe çakışma azalır, boşluk artar.
- Çıkışta taşınan kalem oranı %75, %33 ve %17'dir; yeniden pazarlık edilecek kalemlerin 4, 8 ve
  7'si zaten boşlukta ya da çakışmadadır.

## Sonraki Adım

Bu konu kiralamayı beş kez ölçtü: kapasitenin ne kadar çabuk geldiğini, kaç kararın devredildiğini,
iş yükünün hangi düzene sığdığını, hesabın kaç kalemi sakladığını ve sorumluluk sınırının nereden
geçtiğini. Sınır artık çizilidir ve kimin neyi yaptığı — ve kimsenin yapmadığı — yazılıdır.

Yine de bütün bu ölçümlerde bir soru hiç sorulmadı: kiralanan şey **fiziksel olarak nerede
duruyor**. Sorumluluk matrisindeki `fiziksel-guvenlik` satırı üç modelde de sağlayıcıdadır, ama
sağlayıcının o kalemi hangi coğrafyada, kaç ayrı yerde ve hangi arıza sınırlarıyla tuttuğu
sorulmadı. Bir arıza olduğunda ayakta kalanı belirleyen şey sorumluluk tablosu değil, kiralanan
kaynağın **nerede durduğudur**. Sonraki konu bu soruyla başlar.
