---
title: 'Değişken Uzunluklu Alt Ağlar'
source: 'https://academia.sh/tr/kurslar/ag-modelleri/degisken-uzunluklu-alt-aglar'
course: 'Ağ Modelleri ve Protokoller'
language: tr
updated: '2026-08-17T18:07:11+00:00'
license: 'CC BY-SA 4.0'
---

# Değişken Uzunluklu Alt Ağlar

Farklı maskelerle bölme yöntemi, hizalama kuralı, örnek kurumsal planın kurulması ve çakışma sınaması ile yol özetleme.

Önceki ders eşit bölmenin `192.168.10.0/24` bloğunu kurumun gereksinimlerine
yetiştiremediğini gösterdi: yöntem 640 adres istiyordu, elde 256 vardı. Kusurun kaynağı tüm
alt ağların aynı maskeyi taşıması zorunluluğuydu.

CIDR bu zorunluluğu kaldırır. **Değişken uzunluklu alt ağ maskesi (variable length subnet
mask, VLSM)** yaklaşımında her alt ağ kendi gereksinimine göre boyutlanır. Bu dersin sorusu,
bu bölmenin hangi kurala göre yapılacağı ve sonucun nasıl sınanacağıdır.

## Hizalama Kuralı

Değişken bölmede yalnızca tek bir kısıtlama vardır: **bir alt ağın başlangıç adresi, kendi
boyutunun katı olmalıdır.**

Kural bir düzenleme tercihi değil, maske aritmetiğinin zorunlu sonucudur. Bir `/27` bloğunun
son beş biti düğüm bitidir ve ağ adresinde hepsi sıfır olmalıdır; bu ancak adresin 32'nin
katı olmasıyla sağlanır. `192.168.10.200/27` gösterimi geçerli bir ağ tanımlamaz, çünkü 200
sayısı 32'nin katı değildir — bu adres `192.168.10.192/27` ağının içindeki bir düğümdür.

| Önek | Blok boyu | Geçerli başlangıçlar (son bayt) |
|---|---|---|
| /25 | 128 | 0, 128 |
| /26 | 64 | 0, 64, 128, 192 |
| /27 | 32 | 0, 32, 64, …, 224 |
| /28 | 16 | 0, 16, 32, …, 240 |
| /30 | 4 | 0, 4, 8, …, 252 |

Kuralın planlamadaki sonucu şudur: **büyük bloklar önce yerleştirilmelidir.** Küçük bloklar
önce yerleştirilirse, sonraki büyük blok kendi hizasına atlamak zorunda kalır ve arada
kullanılamayan bir boşluk bırakır.

## Planın Kurulması

Yöntem üç adımdır:

1. Bölümleri düğüm gereksinimine göre **azalan** sırala.
2. Her bölüm için $2^{32-p} - 2 \ge N$ eşitsizliğini sağlayan en uzun öneki seç.
3. Blokları sırayla, hizalamaya uyarak yerleştir.

Kurumun gereksinimleri sıralanmış hâlde: misafir kablosuz 100, laboratuvar 50, yönetim 20,
sunucu 10, noktadan noktaya bağlantı 2 düğüm.

**Misafir kablosuz, 100 düğüm.** $2^7 - 2 = 126 \ge 100$ olduğundan `/25` yeterlidir; `/26`
yalnızca 62 verir. Blok `192.168.10.0/25`, aralık `.1` – `.126`, yayın `.127`.

**Laboratuvar, 50 düğüm.** `/26` 62 düğüm verir. Sıradaki hizalı adres 128'dir. Blok
`192.168.10.128/26`, aralık `.129` – `.190`, yayın `.191`.

**Yönetim, 20 düğüm.** `/27` 30 düğüm verir. Sıradaki hizalı adres 192'dir. Blok
`192.168.10.192/27`, aralık `.193` – `.222`, yayın `.223`.

**Sunucu, 10 düğüm.** `/28` 14 düğüm verir. Sıradaki hizalı adres 224'tür. Blok
`192.168.10.224/28`, aralık `.225` – `.238`, yayın `.239`.

**Noktadan noktaya bağlantı, 2 düğüm.** `/30` tam olarak 2 düğüm verir. Sıradaki hizalı
adres 240'tır. Blok `192.168.10.240/30`, aralık `.241` – `.242`, yayın `.243`.

## Planın Doğrulanması

Elle yapılan hesap, programla sınanmalıdır. Aşağıdaki program yöntemi kodlar ve planı
üretir.

```python
import ipaddress
import math

BLOK = ipaddress.ip_network("192.168.10.0/24")
IHTIYAC = [
    ("Misafir kablosuz", 100),
    ("Laboratuvar", 50),
    ("Yönetim", 20),
    ("Sunucu", 10),
    ("Bağlantı", 2),
]


def gereken_onek(dugum: int) -> int:
    """dugum adet kullanılabilir adres için en uzun yeterli önek."""
    return 32 - math.ceil(math.log2(dugum + 2))


def vlsm_plani(blok: ipaddress.IPv4Network,
               ihtiyac: list[tuple[str, int]]) -> list[tuple]:
    sirali = sorted(ihtiyac, key=lambda k: k[1], reverse=True)
    imlec = int(blok.network_address)
    plan = []
    for ad, dugum in sirali:
        onek = gereken_onek(dugum)
        boyut = 2 ** (32 - onek)
        if imlec % boyut:                       # hizalama: blok kendi boyuna oturmalı
            imlec += boyut - (imlec % boyut)
        alt = ipaddress.ip_network((imlec, onek))
        if not alt.subnet_of(blok):
            raise ValueError(f"{ad} için yer kalmadı")
        plan.append((ad, dugum, alt))
        imlec += boyut
    return plan


plan = vlsm_plani(BLOK, IHTIYAC)
print(f"{'Bölüm':18s} {'İhtiyaç':>7s}  {'Blok':<19s} {'Maske':<16s} "
      f"{'Yayın':<15s} {'Aralık':<31s} {'Boş':>4s}")
for ad, dugum, alt in plan:
    d = list(alt.hosts())
    aralik = f"{d[0]} - {d[-1]}"
    print(f"{ad:18s} {dugum:7d}  {str(alt):<19s} {str(alt.netmask):<16s} "
          f"{str(alt.broadcast_address):<15s} {aralik:<31s} {len(d) - dugum:4d}")

kullanilan = sum(alt.num_addresses for _, _, alt in plan)
print(f"\nkullanılan adres: {kullanilan} / {BLOK.num_addresses}  "
      f"artan: {BLOK.num_addresses - kullanilan}")

aglar = [alt for _, _, alt in plan]
for i in range(len(aglar)):
    for j in range(i + 1, len(aglar)):
        assert not aglar[i].overlaps(aglar[j]), (aglar[i], aglar[j])
print("çakışma sınaması: geçti")
```

Çıktı:

```
Bölüm              İhtiyaç  Blok                Maske            Yayın           Aralık                           Boş
Misafir kablosuz       100  192.168.10.0/25     255.255.255.128  192.168.10.127  192.168.10.1 - 192.168.10.126     26
Laboratuvar             50  192.168.10.128/26   255.255.255.192  192.168.10.191  192.168.10.129 - 192.168.10.190   12
Yönetim                 20  192.168.10.192/27   255.255.255.224  192.168.10.223  192.168.10.193 - 192.168.10.222   10
Sunucu                  10  192.168.10.224/28   255.255.255.240  192.168.10.239  192.168.10.225 - 192.168.10.238    4
Bağlantı                 2  192.168.10.240/30   255.255.255.252  192.168.10.243  192.168.10.241 - 192.168.10.242    0

kullanılan adres: 244 / 256  artan: 12
çakışma sınaması: geçti
```

Elle yapılan hesabın tamamı doğrulanmıştır. Eşit bölmenin 640 adres istediği yerde değişken
bölme 244 adresle yetinmiş, geriye 12 adres bırakmıştır.

`gereken_onek` işlevindeki `dugum + 2` terimi, her ağın ağ ve yayın adreslerini harcadığı
gerçeğini kodlar. `math.ceil(math.log2(...))` çağrısı, gereken düğüm sayısını üstüne
yuvarlar: 102 için $\lceil \log_2 102 \rceil = 7$ ve önek $32 - 7 = 25$ çıkar.

Çakışma sınaması bir formalite değildir. Elle kurulan planlarda en sık yapılan hata, bir
bloğun bir öncekinin içine düşmesidir; `overlaps` çağrısı bu hatayı sessiz kalmadan
yakalar.

## Kesinleşen Plan

Kurs boyunca kullanılacak plan budur:

| Bölüm | Blok | Maske | Geçit | Kullanılabilir aralık | Yayın |
|---|---|---|---|---|---|
| Misafir kablosuz | `192.168.10.0/25` | 255.255.255.128 | `.1` | `.1` – `.126` | `.127` |
| Laboratuvar | `192.168.10.128/26` | 255.255.255.192 | `.129` | `.129` – `.190` | `.191` |
| Yönetim | `192.168.10.192/27` | 255.255.255.224 | `.193` | `.193` – `.222` | `.223` |
| Sunucu | `192.168.10.224/28` | 255.255.255.240 | `.225` | `.225` – `.238` | `.239` |
| Bağlantı | `192.168.10.240/30` | 255.255.255.252 | — | `.241` – `.242` | `.243` |

Her bölümde ilk kullanılabilir adres yönlendirici arayüzüne ayrılmıştır. Kursun ilk
dersinde tanıtılan istemci `192.168.10.196` yönetim ağındadır ve geçidi `192.168.10.193`
adresidir — plan bu iki değeri doğrular.

Artan 12 adres `192.168.10.244` ile `192.168.10.255` arasındadır ve üç `/30` bloğuna
karşılık gelir: `.244/30`, `.248/30`, `.252/30`. Bunlar ileride eklenecek noktadan noktaya
bağlantılar için kullanılabilir.

## Sıralamanın Etkisi

Bölümler artan sırada yerleştirilseydi ne olurdu? En küçük blok başa konur, sonrakiler
hizalanmak için ileri atlar:

| Sıra | Bölüm | Blok | Atlanan boşluk |
|---|---|---|---|
| Artan | Bağlantı | `192.168.10.0/30` | — |
| Artan | Sunucu | `192.168.10.16/28` | `.4` – `.15` (12 adres) |
| Artan | Yönetim | `192.168.10.32/27` | — |
| Artan | Laboratuvar | `192.168.10.64/26` | — |
| Artan | Misafir | `192.168.10.128/25` | — |

Plan yine sığar, ancak artan 12 adres bloğun **ortasında** kalır ve iki ayrı parçaya
bölünür. Azalan sıralamada aynı 12 adres bloğun **sonunda** ve bitişik durur.

Fark, büyümede kendini gösterir. Sonda duran bitişik bir boşluk daha büyük bir alt ağa
dönüştürülebilir; ortada kalan parçalı boşluk yalnızca kendi boyutunda kullanılabilir. Bu,
Bilgisayarlar Nasıl Çalışır kursundaki Bellek Düzeni dersinde ayırıcılar bağlamında
tanıtılan parçalanma sorununun adres uzayındaki karşılığıdır.

## Yol Özetleme

Değişken bölmenin ikinci kazancı yönlendirme tablosundadır. Bitişik ve hizalı alt ağlar,
tek bir önekte **özetlenebilir (route summarization)**.

Kurumun beş alt ağı `192.168.10.0/24` bloğunun içindedir. Sağlayıcı yönlendiricisinin bu
beş ağı ayrı ayrı bilmesine gerek yoktur; tek bir satır yeter:

```
192.168.10.0/24  ->  203.0.113.10
```

Özetleme, hizalama kuralının doğrudan sonucudur. Dört bitişik `/24` bloğu — `192.168.8.0`,
`192.168.9.0`, `192.168.10.0`, `192.168.11.0` — tek bir `192.168.8.0/22` önekiyle anılabilir,
çünkü dördü de 8'in katıyla başlayan hizalı bir dörtlü oluşturur. Aynı dörtlü `192.168.9.0`
ile başlasaydı özetlenemezdi.

Özetlemenin kazancı doğrudandır: yönlendirme tablosundaki satır sayısı azalır, arama ucuzlar
ve iç ağdaki bir değişiklik dış tabloları etkilemez. Adreslerin hiyerarşik dağıtılmasının
gerekçesi budur.

## Planın Belgelenmesi

Bir adres planı, yalnızca hesaplandığı anda değil, sonraki her değişiklikte kullanılır.
Belgelenmesi gereken alanlar şunlardır: bölüm adı, blok, maske, geçit adresi, statik
atamalar için ayrılan aralık, dinamik dağıtıma bırakılan aralık ve büyüme payı.

Büyüme payı özellikle gözden kaçar. Yukarıdaki planda misafir ağının 26, laboratuvarın 12,
yönetimin 10 boş adresi vardır; sunucu ağında yalnızca 4 boş adres kalmıştır. Sunucu sayısı
15'e çıkarsa `/28` yetmez ve blok yeniden boyutlandırılmalıdır. Planı kuran kişi, hangi
bölümün hangi eşikte taşacağını baştan not etmelidir.

## Özet

- Değişken uzunluklu bölmede her alt ağ kendi gereksinimine göre boyutlanır; tek kısıt,
  başlangıç adresinin blok boyunun katı olmasıdır.
- Yöntem üç adımdır: gereksinimleri azalan sırala, her biri için en uzun yeterli öneki seç,
  hizalamaya uyarak yerleştir.
- Kurumun beş ağı `192.168.10.0/24` içine 244 adres kullanarak sığar; eşit bölme aynı iş
  için 640 adres isterdi.
- Azalan sıralama artan boşluğu bloğun sonunda ve bitişik bırakır; artan sıralama boşluğu
  ortada parçalar.
- Bitişik ve hizalı alt ağlar tek bir önekte özetlenebilir; beş alt ağ dışarıya
  `192.168.10.0/24` olarak duyurulur.
- Plan belgelenirken büyüme payı da yazılmalıdır; örnek planda en dar pay 4 adresle sunucu
  ağındadır.

## Sonraki Adım

Bu plan 32 bitlik adres uzayının kıtlığıyla baş etmenin bir yoludur: özel adresler kullanmak
ve onları özenle bölmek. Kıtlığın kendisini ortadan kaldıran başka bir yol daha vardır —
adres uzayını genişletmek. Sonraki ders 128 bitlik adresleri, yazım kurallarını, arayüzlerin
adreslerini kendi kendine kurmasını ve iki sürümün bir arada çalışma yöntemlerini ele
alacak.
