---
title: 'Sanal Özel Ağ'
source: 'https://academia.sh/tr/kurslar/bulut-hesaplama-ve-ag/sanal-ozel-ag'
course: 'Bulutta Hesaplama ve Ağ'
language: tr
updated: '2026-08-17T18:06:57+00:00'
license: 'CC BY-SA 4.0'
---

# Sanal Özel Ağ

Adres alanı planlaması kalem kalem sayılır: önek uzunluğu taranınca kaç adres kullanılabilir kalıyor, kaçı ayrılmış, kaçı israf; dar seçim hangi dönemde büyümeyi durduruyor, geniş seçim hangi komşu bloklarla çakışıyor ve kurulduktan sonra değişmeyen bu kalemin bedeli kaç birim tutuyor.

Makine kiralandı, imajı seçildi ve ölçeklenmesi bir gruba devredildi. Kiralanan her örneğin bir
adresi var ve o adres bir yerden geliyor: örnekler açılmadan önce çizilmiş bir adres alanından.
Sanal özel ağ, kiracıya ayrılan ve içinde adres dağıtımı kiracıya bırakılan alandır. Sağlayıcı
iletim düzlemini, kiracılar arasındaki yalıtımı ve adres tahsis mekanizmasını üstlenir; blok,
önek uzunluğu ve bloğun kurumun aralığındaki yeri yazana kalır.

Bu kalem ötekilerden bir yönüyle ayrılır. Yönlendirme kuralı yanlış yazılırsa düzeltilir, filtre
kuralı gevşekse daraltılır — adres bloğu kurulduktan sonra değişmez. Sorulan üç şey var: bir
blokta kaç adres gerçekten kullanılabilir, seçim hangi dönemde dar gelir ve dar geldiği gün ne
kadar tutar.

- **BA1.** Sekiz dönemlik büyüme dizisi ve komşu blok listesi kurgusal bölgesel ölçüm ağına
  aittir. Gerçek bir ağ kurulmuyor; ölçülen şey `node` ile kurulan modeldir. Adres aritmetiği
  gerçektir.
- **BA2.** Bütün bloklar özel adres aralıklarından yazıldı; gerçek genel blok kullanılmıyor.
- **BA3.** Sağlayıcının her alt ağda beş adresi ayırdığı varsayıldı. Gerçekte bu sayı sağlayıcıya
  göre değişir; kullanılabilir adres sayısını kaydırır, yönünü değiştirmez.
- **BA4.** Büyüme dizisi elle yazıldı; rastgelelik yok, her koşum aynı sayıları üretir.
- **BA5.** Bedeller kurgu **birim** cinsindendir, para birimi değildir. Yolların birbirine oranını
  taşır, mutlak bir tutar bildirmez.
- **BA6.** Komşu blok listesi yediye indirgendi. Gerçekte bir kurumda kayıtlı blok sayısı çok daha
  yüksektir; çakışma sayısını büyütür, tarama mantığını değiştirmez.

## Adres Alanı Modeli

Model üç şey tutuyor: bloğu adres aritmetiğiyle çözen birkaç işlev, aynı kurumda kayıtlı komşu
bloklar ve ölçüm ağının sekiz dönemlik talebi. Talep satırı bir dönemde kaç alana yayıldığını, kaç
katman kullandığını ve kaç örnek koştuğunu yazıyor; alt ağ sayısı bu ikisinin çarpımıdır.

```js
// adres.mjs — adres alani plani modeli; gercek ag kurulmuyor, adres aritmetigi gercek
export const toInt = (ip) => ip.split('.').reduce((a, o) => a * 256 + Number(o), 0);
export const toIp = (n) => [16777216, 65536, 256, 1].map((b) => Math.floor(n / b) % 256).join('.');
export const blok = (c) => {
  const [ip, e] = c.split('/'); const onek = Number(e); const boyut = 2 ** (32 - onek);
  const bas = Math.floor(toInt(ip) / boyut) * boyut;      // onek kisaldikca taban geriye kayar
  return { ad: `${toIp(bas)}/${onek}`, onek, boyut, bas, son: bas + boyut - 1 };
};
export const kesisir = (a, b) => a.bas <= b.son && b.bas <= a.son;

// Ayni kurumun var olan bloklari (kurgu); hepsi ozel aralikta.
export const KOMSU = [
  ['merkez-salon', '10.0.0.0/16'], ['eski-olcum', '10.8.0.0/14'], ['laboratuvar', '10.32.0.0/16'],
  ['saha-gecici', '10.41.0.0/16'], ['olcut-arsivi', '10.42.128.0/17'], ['yedek-toplama', '10.44.0.0/14'],
  ['ortak-baglanti', '172.20.0.0/14'],
].map(([ad, c]) => ({ ...blok(c), ad }));

export const CAPA = '10.42.0.0';            // planlayicinin yazdigi baslangic adresi
export const KURUM = blok('10.32.0.0/12');  // kuruma ayrilan aralik; yeni ekipler buradan alir
export const AYRILAN = 5;                   // saglayici her alt agda bes adres ayirir (BA3)

// [donem, alan, katman, ornek] — kurgusal olcum aginin buyume dizisi (BA4)
export const TALEP = [
  [1, 2, 2, 18], [2, 2, 2, 26], [3, 3, 2, 44], [4, 3, 2, 71],
  [5, 3, 3, 118], [6, 3, 3, 196], [7, 4, 3, 340], [8, 4, 3, 612],
];
export const altAg = (t) => t[1] * t[2];
export const gerek = (t) => t[3] + t[1] + 2;             // ornek + alan basina gecit + iki dengeleyici
export const ayrilan = (t) => AYRILAN * altAg(t);
export const kullanilan = (t) => gerek(t) + ayrilan(t);
export const tasma = (b) => (TALEP.find((t) => kullanilan(t) > b.boyut) || [0])[0];
export const cakisan = (b) => KOMSU.filter((k) => kesisir(b, k));

export const TOPLAM_DILIM = KURUM.boyut / 4096;          // kurum araliginda kac /20 dilimi var
export const dilim = (b) => {                            // blogun tuttugu /20 dilimleri
  const s = new Set();
  if (b.son < KURUM.bas || b.bas > KURUM.son) return s;
  const ilk = Math.floor((Math.max(b.bas, KURUM.bas) - KURUM.bas) / 4096);
  const sn = Math.floor((Math.min(b.son, KURUM.son) - KURUM.bas) / 4096);
  for (let i = ilk; i <= sn; i++) s.add(i);
  return s;
};
export const KOMSU_DILIM = new Set(KOMSU.flatMap((k) => [...dilim(k)]));
```

`blok` işlevindeki taban hesabı modelin sessiz iddiasıdır: yazılan adres seçilen blok değildir.
Önek kısaldıkça taban hizalanmak için geriye kayar, yani `10.42.0.0` yazıp kısa bir önek vermek
başka bir yerden başlayan bir blok kurar. `dilim` ise ikinci bir eksen açıyor — bloğun kuruma
ayrılan aralıkta kaç dilim tuttuğunu sayıyor, çünkü alınan yer başka bir ekibe kalmıyor.

## Önek Uzunluğu Taraması

```js
// kosum1.mjs — onek uzunlugu taranir: kaci kullanilabilir, ne zaman tasar, kime carpar
import { blok, CAPA, TALEP, altAg, gerek, ayrilan, kullanilan, tasma, cakisan,
  dilim, KOMSU_DILIM, TOPLAM_DILIM } from './adres.mjs';

const s = TALEP[TALEP.length - 1];
console.log(`donem-8 talebi: ${s[3]} ornek + ${s[1]} gecit + 2 dengeleyici = ${gerek(s)} adres; ` +
  `${altAg(s)} alt ag x 5 = ${ayrilan(s)} ayrilan; toplam ${kullanilan(s)}`);
console.log(`${'blok'.padEnd(17)} ${'toplam'.padStart(8)} ${'kullanilabilir'.padStart(14)} ` +
  `${'tasma'.padStart(8)} ${'israf'.padStart(8)} ${'cakisan'.padStart(8)} ${'kalan /20'.padStart(10)}  carptigi komsu`);
for (const onek of [25, 24, 23, 22, 21, 20, 18, 16, 14, 12]) {
  const b = blok(`${CAPA}/${onek}`), t = tasma(b), c = cakisan(b);
  const yeni = new Set([...KOMSU_DILIM, ...dilim(b)]);
  console.log(`${b.ad.padEnd(17)} ${String(b.boyut).padStart(8)} ${String(b.boyut - ayrilan(s)).padStart(14)} ` +
    `${String(t ? `donem ${t}` : '-').padStart(8)} ${String(t ? '-' : b.boyut - kullanilan(s)).padStart(8)} ` +
    `${String(c.length).padStart(8)} ${String(TOPLAM_DILIM - yeni.size).padStart(10)}  ${c.map((k) => k.ad).join(' ')}`.trimEnd());
}
```

```
donem-8 talebi: 612 ornek + 4 gecit + 2 dengeleyici = 618 adres; 12 alt ag x 5 = 60 ayrilan; toplam 678
blok                toplam kullanilabilir    tasma    israf  cakisan  kalan /20  carptigi komsu
10.42.0.0/25           128             68  donem 5        -        0        151
10.42.0.0/24           256            196  donem 7        -        0        151
10.42.0.0/23           512            452  donem 8        -        0        151
10.42.0.0/22          1024            964        -      346        0        151
10.42.0.0/21          2048           1988        -     1370        0        151
10.42.0.0/20          4096           4036        -     3418        0        151
10.42.0.0/18         16384          16324        -    15706        0        148
10.42.0.0/16         65536          65476        -    64858        1        144  olcut-arsivi
10.40.0.0/14        262144         262084        -   261466        2        112  saha-gecici olcut-arsivi
10.32.0.0/12       1048576        1048516        -  1047898        4          0  laboratuvar saha-gecici olcut-arsivi yedek-toplama
```

Ayrılan altmış adres her satırda aynı, oranı değil: `/25` bloğunda toplamın yüzde kırk yedisi
ayrılmışa gidiyor, `/20` bloğunda yüzde bir buçuğu. Küçük blokta bölme düzeninin kendisi bloğun
yarısını yiyor ve bu yem hiçbir örneğe verilmiyor. Taşma sütunu dar tarafın bedelini veriyor:
`/25` beşinci dönemde, `/24` yedincide, `/23` sekizincide duruyor. Sekizinci dönemin talebi altı
yüz yetmiş sekiz adres, `/23` bloğunda beş yüz on iki adres var.

Sağ taraf ters yöndeki bedeli sayıyor. `/16` bloğu tek komşuya çarpıyor ve o komşu tam olarak
`10.42.128.0/17` — planlayıcının kendi ikinci sekizlisinin içinde oturan bir kalem. `/14` yazmak
tabanı `10.40.0.0` adresine, `/12` yazmak `10.32.0.0` adresine kaydırıyor; ikisinde de yazılan
adres kurulan bloğun başlangıcı değil. Kaydırma iki komşuyu daha içeri alıyor. Çakışan bir blok
eşlenemez: iki tarafta aynı adres iki makineye karşılık geldiği için eşleme reddedilir ve geriye
yalnız adres dönüştürme kalır.

Son sütun geniş seçimin görünmeyen bedelidir. Kuruma ayrılan aralıkta iki yüz elli altı dilim
var; komşular yüz dördünü tutuyor. `/20` ve altındaki her seçim bir dilim alıp yüz elli birini
bırakıyor, `/18` yüz kırk sekiz, `/14` yüz on iki, `/12` sıfır. Aynı gün başka bir ekip aynı
aralıktan blok isteyecek. Sıfır ile yüz elli bir arasındaki fark bugün hiçbir uyarı üretmez.

Tarama pencereyi kendisi çiziyor: `/22` ile `/18` arasında hem taşma yok hem çakışma yok. `/20`
sekizinci dönemde üç bin dört yüz on sekiz adres boş bırakıyor — bu israf bir maliyet kalemine
karşılık gelmiyor, yalnız bir dilim tutuyor. `/23` ile arasındaki fark, kurulum gününde tek
karakterdir.

## Dar Seçimin Bedeli

```js
// kosum2.mjs — /23 secilmisti; tasma aninda uc cikis yolu kurgu birimle sayilir
import { blok, CAPA, TALEP, altAg, kullanilan, tasma } from './adres.mjs';

const SECIM = blok(`${CAPA}/23`), GENIS = blok(`${CAPA}/20`);
const t = tasma(SECIM), d = TALEP.find((x) => x[0] === t);
console.log(`secilen blok ${SECIM.ad}: ${SECIM.boyut} adres, donem-1 talebi ${kullanilan(TALEP[0])} ` +
  `-> ${(SECIM.boyut / kullanilan(TALEP[0])).toFixed(1)}x pay, kurulum gunu hicbir sey soylemiyor`);
console.log(`ayni gun ${GENIS.ad} yazmanin ek bedeli: 0 birim, 0 ek satir, 0 ek dakika`);
console.log(`tasma donem ${t}: ${d[3]} ornek, ${altAg(d)} alt ag, ${kullanilan(d)} adres gerekiyor, ${SECIM.boyut} var\n`);

// Bedeller kurgu "birim" (BA5); oranlari tasiyor, para birimi degil.
const YOL = [
  ['yeniden kurma', d[3] * 2 + altAg(d) * 15 + 5 * 40, 0, 0],
  ['ikinci ag + esleme', 120, 95, altAg(d)],
  ['adres donusturme katmani', 40, 60, 2],
];
const taban = YOL[0][1];
console.log(`${'cikis yolu'.padEnd(25)} ${'kurulum'.padStart(8)} ${'donem basi'.padStart(11)} ` +
  `${'kalici kalem'.padStart(13)} ${'6 donem'.padStart(8)} ${'yeniden kurmayi gectigi'.padStart(23)}`);
for (const [ad, k, dn, kal] of YOL) {
  let n = 0; if (dn > 0) { n = 1; while (k + dn * n <= taban) n++; }
  console.log(`${ad.padEnd(25)} ${String(k).padStart(8)} ${String(dn).padStart(11)} ${String(kal).padStart(13)} ` +
    `${String(k + dn * 6).padStart(8)} ${String(n ? `donem ${n}` : '-').padStart(23)}`);
}
```

```
secilen blok 10.42.0.0/23: 512 adres, donem-1 talebi 42 -> 12.2x pay, kurulum gunu hicbir sey soylemiyor
ayni gun 10.42.0.0/20 yazmanin ek bedeli: 0 birim, 0 ek satir, 0 ek dakika
tasma donem 8: 612 ornek, 12 alt ag, 678 adres gerekiyor, 512 var

cikis yolu                 kurulum  donem basi  kalici kalem  6 donem yeniden kurmayi gectigi
yeniden kurma                 1604           0             0     1604                       -
ikinci ag + esleme             120          95            12      690                donem 16
adres donusturme katmani        40          60             2      400                donem 27
```

İkinci satır dersin ölçüsüdür. `/23` yerine `/20` yazmak kurulum gününde sıfır birim tutuyor:
aynı komut, aynı dakika, aynı satır sayısı. Birinci dönemde `/23` bloğunda on iki kat pay
görünüyordu ve bu görüntü yedi dönem boyunca doğru kaldı. Sekizinci dönemde blok bitiyor ve
bitmesiyle birlikte üç yoldan biri seçilmek zorunda kalıyor.

Yeniden kurma bin altı yüz dört birim; altı yüz on iki örneği taşımak, on iki alt ağı yeniden
kurmak ve kesintili bir pencere açmak. Tek seferliktir ve arkasında kalıcı kalem bırakmaz. İkinci
ağ açıp eşlemek yüz yirmi birime kuruluyor ve toplantıda her seferinde bunu kazanır — altı dönem
sonunda hâlâ altı yüz doksan birimde, yeniden kurmanın yarısından ucuz. Onaltıncı dönemde geçiyor.
Adres dönüştürme katmanı daha da ucuz başlıyor ve yirmi yedinci dönemde geçiyor.

Kalıcı kalem sütunu asıl farkı taşıyor. İkinci ağ on iki kalıcı kalem bırakıyor: on iki
yönlendirme tablosunun her birine yazılması ve bundan sonra her değişiklikte güncellenmesi gereken
birer satır. Adres dönüştürme katmanının iki kalıcı kalemi satır değil özelliktir — iki taraf
birbirini gerçek adresiyle göremez ve günlüklerde kaynak adres katmanın adresine dönüşür.
Ertelemenin bedeli birim sayısında değil, bu iki sütunun ilerideki her derse taşınmasındadır.

## Elde Kalan Karar

| Kalem | Kimde | Sonradan değişir mi |
|---|---|---|
| Adres bloğu ve önek uzunluğu | ekip | hayır |
| Bloğun kurum aralığındaki yeri | ekip | hayır |
| Alan sayısı | ekip | yalnız artar |
| Alt ağ sınırları | ekip | yalnız artar |
| Yönlendirme kuralları | ekip | evet |
| Filtre kuralları | ekip | evet |
| Ad çözümleme ve akış günlüğü | ekip | evet |
| Eşleme ve özel bağlantı | ekip | çakışma yoksa evet |
| Alt ağ başına ayrılan beş adres | sağlayıcı | — |
| Adres tahsis mekanizması | sağlayıcı | — |
| İletim düzlemi ve kiracı yalıtımı | sağlayıcı | — |
| Geçidin kendi yedekliliği | sağlayıcı | — |

On iki kalemin sekizi elde kalıyor, dördü devrediliyor. Devredilen dördü hiç sorulmuyor da
denebilir — ayrılan beş adres bir tercih değil, bir kesintidir ve `/25` bloğunda toplamın yarısına
yaklaşır. Elde kalan sekizin dördü serbestçe değişiyor, ikisi yalnız büyüyebiliyor, ikisi
kurulduktan sonra hiç değişmiyor.

"Değişmez" burada bir yasak değil, bir bağımlılık yığınıdır. Blok yazıldığı andan sonra ona
dayanan üç kalem doğuyor: dağıtılmış adresler, o adreslere göre yazılmış yönlendirme kuralları ve
aynı adreslere göre yazılmış filtre kuralları. Bloğu genişletmek üçünü birden geçersiz kılar,
çünkü genişleme tabanı kaydırır — `10.42.0.0/23` bloğunu `/20` yapmak yeni bir bloktur, aynı
bloğun büyümüş hâli değil. Kurumun kaydında da yer değiştirir ve o sırada komşuların hangisine
çarpacağı yeniden sorulmak zorunda kalır.

Geri alınamayan kalem bu iki satırdır: bloğun kendisi ve bloğun kurum aralığındaki yeri. Bu kursun
öteki kalemleri yanlış yazıldığında bir kural düzeltilir; burada yanlış yazıldığında bin altı yüz
dört birimlik bir taşıma ya da her yönlendirme tablosuna dokunan kalıcı bir ek yapı doğar. Kararın
alındığı an, elde en az bilginin olduğu andır — birinci dönemde on sekiz örnek koşuyordu ve
sekizinci dönemin altı yüz on iki örneği hiçbir yerde yazılı değildi.

## Özet

- Sekizinci dönem talebi 618 adres artı 12 alt ağ için 60 ayrılmış adres. Aynı 60 adres `/25`
  bloğunun yüzde 47'sini, `/20` bloğunun yüzde 1,5'ini yiyor; bölme düzeninin kesintisi küçük
  blokta blok kadar belirleyici.
- Dar tarafın bedeli taşma dönemidir: `/25` dönem 5'te, `/24` dönem 7'de, `/23` dönem 8'de
  duruyor. Geniş tarafın bedeli çakışmadır: `/16` bir, `/14` iki, `/12` dört komşu bloğa çarpıyor
  ve çakışan blok eşlenemez.
- Kısa önek tabanı hizalamak için geriye kaydırıyor; `10.42.0.0` yazıp `/12` vermek `10.32.0.0`
  adresinden başlayan bir blok kuruyor ve kuruma ayrılan 256 dilimin tamamını tutuyor. `/20` bir
  dilim tutup 151 dilim bırakıyor.
- Geri alınamayan kalem adres bloğu ve önek uzunluğudur. Kurulum gününde `/23` yerine `/20` yazmak
  0 birim tutuyor; sekizinci dönemde aynı fark yeniden kurmada 1.604 birim, ikinci ağda 120 birim
  artı dönem başına 95 birim ve 12 kalıcı yönlendirme satırı.
- Ucuz görünen çıkış yolu kalıcı olanıdır: ikinci ağ 16. dönemde, adres dönüştürme katmanı 27.
  dönemde yeniden kurmanın toplamını geçiyor ve o zamana kadar doğrudan adreslemenin bitmiş olması
  geri alınmıyor.

## Sonraki Adım

Blok seçildi ve içinde altı yüz yetmiş sekiz adreslik bir talep var — ama blok henüz tek parça.
Adresler kullanılabilmek için bölünmek zorunda ve bölme düzeni yeni bir soru açıyor: her örnek
dışarıdan doğrudan erişilebilir olmalı mı. Sonraki dersin sorusu bölmenin iki eksenini birden
sayar: aynı blok az sayıda büyük parçaya ve çok sayıda küçük parçaya bölündüğünde kaç adres
kullanılabilir kalıyor, alt ağ başına kesilen beş adres kaç parçada kaç yüz adres tutuyor ve bir
alanın kaybı hangi düzende kaç örneği götürüyor — ve parçaların bir bölümünü dışarıya kapatmak
doğrudan erişilebilir örnek sayısını kaça indirirken karşılığında hangi ek bileşeni zorunlu
kılıyor.
