---
title: 'İnternet Nasıl Çalışır'
source: 'https://academia.sh/tr/kurslar/internet-nasil-calisir'
language: tr
updated: '2026-08-17T04:39:07+00:00'
license: 'CC BY-SA 4.0'
lessons: 12
outcomes:
    - 'Bir adres satırına yazılan isteğin uçtan uca yolculuğunu anlatır'
    - 'Alan adı, barındırma ve sunucu kavramlarını ayırır'
    - 'HTTP istek/yanıt döngüsünün parçalarını okur'
---

# İnternet Nasıl Çalışır

Bir adres satırına yazılan isteğin ağdan sunucuya ve geri dönen yanıta uzanan yolculuğu; alan adı, barındırma ve HTTP kavramlarının kuruluşu.

## Ağların Temeli

Uçlar, bağlantılar ve paket anahtarlama sezgisi; istemci–sunucu modeli, ağların ağı olarak internetin yapısı ve IP adresleme.

### Ağ Nedir

Source: https://academia.sh/tr/kurslar/internet-nasil-calisir/ag-nedir

Uçlar, bağlantılar ve anahtarlama; paket anahtarlamanın devre anahtarlamaya göre neden seçildiği ve en iyi çaba teslimin sonuçları.

Bir adres satırına `http://ornek.test/` yazıp isteği gönderdiğinizde, saniyenin küçük bir
bölümü içinde bir sayfa görünür. Arada olan biteni tek bir cümleyle özetlemek mümkün
değildir: adın bir adrese çevrilmesi, iki makine arasında bir bağlantı kurulması, bir
isteğin biçimlendirilip gönderilmesi ve dönen yanıtın çizilmesi gerekir.

Bu kurs, o tek isteğin yolculuğunu parça parça açar. Her ders zincirin bir halkasını
kurar; son ders hepsini baştan sona birleştirir. Zincirin en altında, en somut soru
durur: iki makine arasında veri nasıl hareket eder?

#### Uçlar, Bağlantılar ve Anahtarlar

**Ağ (network)**, aralarında veri taşıyabilen makinelerden oluşan bir yapıdır. Üç
bileşenle tanımlanır.

**Konaklar (host)**, veri üreten ve tüketen uç makinelerdir. İsteği yazdığınız makine bir
konaktır; `ornek.test` sayfasını tutan makine de bir konaktır. Ağ, konaklar için vardır;
konaklar ağ için değil.

**Bağlantılar (link)**, iki noktayı fiziksel olarak birleştiren ortamdır: bakır tel, cam
lif, radyo dalgası. Her bağlantının iki ölçülebilir özelliği vardır. **Bant genişliği
(bandwidth)**, birim zamanda taşınabilen veri miktarıdır. **Gecikme (latency)**, bir
verinin bir uçtan diğerine varması için geçen süredir. İkisi bağımsızdır: geniş bant
genişlikli bir bağlantının gecikmesi yüksek olabilir. Gecikmenin bir bölümü fizik
yasalarıyla sınırlıdır; sinyal, ortamdaki yayılma hızından daha çabuk gidemez.

**Anahtarlama düğümleri**, ikiden çok konağı birbirine bağlar. Her konağı her konağa ayrı
bir bağlantıyla iliştirmek düşünülemez: $n$ konak için gereken bağlantı sayısı
$\frac{n(n-1)}{2}$ olur ve bu, $n$ büyüdükçe hızla olanaksızlaşır. Bunun yerine konaklar
ortak düğümlere bağlanır, düğümler birbirine bağlanır ve veri düğümden düğüme aktarılır.
Bu aktarma kararını veren düğüme **yönlendirici (router)** denir.

#### İki Anahtarlama Modeli

Veriyi düğümler üzerinden geçirmenin iki farklı yolu vardır ve aralarındaki seçim,
internetin tasarımını belirleyen kararların en temelidir.

##### Devre Anahtarlama

**Devre anahtarlama (circuit switching)** modelinde, iletişim başlamadan önce iki uç
arasında bir yol kurulur ve bu yol üzerindeki kaynaklar iletişim süresince o iki uca
ayrılır. Yol kurulduktan sonra veri, ayrılmış kapasiteden akar.

Bu modelin bir üstünlüğü vardır: kaynak ayrıldığı için başarım öngörülebilirdir. Devre
kurulduysa, ayrılan kapasite garanti edilmiştir.

Bedeli ise kaynak israfıdır. Bir sayfayı okurken hiçbir veri göndermezsiniz; bir metin
yazarken duraklarsınız. Veri iletişimi **patlamalıdır**: kısa yoğun aralıklar, uzun
sessizlikler. Ayrılmış devre, sessizlik boyunca da ayrılmış kalır ve o kapasiteyi başka
kimse kullanamaz. İkinci bedel kuruluş süresidir: tek bir sayfa isteği için önce bir yol
kurmak, sonra veriyi göndermek, sonra yolu yıkmak gerekir.

##### Paket Anahtarlama

**Paket anahtarlama (packet switching)** modelinde önceden hiçbir yol kurulmaz. Gönderilen
veri **paket (packet)** adı verilen parçalara bölünür. Her paket, nereye gideceğini kendi
üzerinde taşır ve düğümler her paketi ayrı ayrı, geldiği anda iletir.

Her paketin iki bölümü vardır. **Başlık (header)**, paketin nereden gelip nereye gittiği
gibi yönlendirme için gereken bilgiyi taşır. **Yük (payload)**, taşınan verinin
kendisidir. Zarf ve mektup benzetmesi doğrudur: düğümler zarfa bakar, mektubu açmaz.

Bu modelin kazancı **istatistiksel çoğullamadır**: bir bağlantı, o anda gönderecek verisi
olan herkes tarafından paylaşılır. Sessiz kalan bir konak kapasiteyi tutmaz. Toplam talep
ortalaması, tepe taleplerin toplamından çok küçük olduğu için aynı bağlantı çok daha fazla
konağa hizmet eder.

İkinci kazanç dayanıklılıktır. Önceden kurulmuş bir yol olmadığı için, bir bağlantı
koptuğunda o yolu kullanan bir "devre" yıkılmaz; sonraki paketler başka bir yoldan gider.
Ağın bir bölümünün arızalanması, iletişimi bütünüyle durdurmak yerine yeniden
yönlendirilmesine yol açar.

Bedeli belirsizliktir. Ayrılmış kapasite olmadığı için, aynı anda çok sayıda paket aynı
düğüme geldiğinde kuyruklar oluşur; kuyruk dolarsa paketler düşürülür. Teslim süresi
paketten pakete değişir.

##### Seçimin Gerekçesi

İnternet paket anahtarlama üzerine kuruludur. Gerekçe, taşınan trafiğin niteliğidir:
bilgisayar iletişimi patlamalıdır ve konak sayısı çok büyüktür. Kaynağı önceden ayırmak,
kaynağın büyük bölümünü boşta bırakır. Paket anahtarlama, öngörülebilirlikten vazgeçip
verimlilik ve dayanıklılık satın alır.

| Ölçüt | Devre anahtarlama | Paket anahtarlama |
|---|---|---|
| Kaynak ayırma | İletişimden önce, süre boyunca | Yok; paket başına paylaşım |
| Boşta kapasite | Ayrılmış kalır, kullanılamaz | Başkalarınca kullanılır |
| Kuruluş maliyeti | Her iletişim için yol kurulur | Yok |
| Arıza davranışı | Yol kopunca iletişim düşer | Paketler başka yoldan gider |
| Teslim süresi | Öngörülebilir | Yüke göre değişken |
| Yük altında | Yeni devre kabul edilmez | Kuyruklar uzar, paket düşebilir |

Bu ödünleşim, ağın verdiği sözün adını da belirler: **en iyi çaba (best effort)** teslim.
Ağ, paketi iletmek için elinden geleni yapar; ancak varacağına, sırasında varacağına veya
bir kez varacağına söz vermez.

#### Bir Mesajın Paketlere Bölünmesi

Söz bu kadar zayıfken güvenilir bir sayfa nasıl görüntülenir? Yanıt, eksik sözün konaklar
tarafından tamamlanmasıdır. Gönderen uç veriyi numaralandırılmış paketlere böler; alan uç
numaralara bakarak sırayı düzeltir ve eksikleri saptar.

Aşağıdaki program bu bölme ve yeniden kurma işini gösterir. Ağ katmanının kendisi
kullanılmadan, yalnızca veri üzerinde yapılan işlem incelenir.

```python
MESAJ = "Ornek Sayfa icerigi"
PAKET_BOYU = 5

paketler: list[tuple[int, str]] = [
    (sira, MESAJ[i:i + PAKET_BOYU])
    for sira, i in enumerate(range(0, len(MESAJ), PAKET_BOYU))
]
for sira, yuk in paketler:
    print(f"sira={sira}  yuk={yuk!r}")

print()
# Paketler farklı yollardan gidebilir; varış sırası gönderim sırası değildir.
varis_sirasi = [2, 0, 3, 1]
gelen = [paketler[i] for i in varis_sirasi]
print("varista gorulen sira:", [sira for sira, _ in gelen])

birlestirilmis = "".join(yuk for sira, yuk in sorted(gelen))
print("yeniden kurulan:", repr(birlestirilmis))
print("kayipsiz mi:", birlestirilmis == MESAJ)
```

Çıktı:

```
sira=0  yuk='Ornek'
sira=1  yuk=' Sayf'
sira=2  yuk='a ice'
sira=3  yuk='rigi'

varista gorulen sira: [2, 0, 3, 1]
yeniden kurulan: 'Ornek Sayfa icerigi'
kayipsiz mi: True
```

Paketler karışık sırayla geldi; sıra numarası sayesinde özgün mesaj kayıpsız kuruldu.
Numara olmasaydı, karışık varış onarılamaz bir bozulma olurdu.

Bu, ağ tasarımındaki bir ilkeyi örnekler: **zor güvenceler uçlarda kurulur.** Ara
düğümlerin sırayı korumasını istemek onları karmaşıklaştırır ve yavaşlatır; oysa uçlar
zaten veriyi bir bütün olarak görmek zorundadır. Sıra düzeltme, eksik parçayı yeniden
isteme ve yinelenen parçayı atma işleri uçlara bırakılır. Bu işleri yürüten protokoller
Ağ Modelleri ve Protokoller kursunun konusudur.

Gerçek paketlerde yükün baytları, Bilgisayarlar Nasıl Çalışır kursunda tanımlanan
kurallara göre yorumlanır: bir metin belirli bir karakter kodlamasıyla baytlara çevrilir
ve başlıktaki sayısal alanlar belirli bir bayt sırasıyla yazılır. Ağ başlıklarında
kullanılan büyük uçlu düzen, o kursta **ağ bayt sırası** adıyla geçmişti; adın kaynağı
budur.

#### Paket Boyu ve Bölünme

Paketin ne kadar büyük olacağı serbest değildir. Her bağlantı türünün taşıyabileceği en
büyük paket boyu vardır. Bu sınırı aşan veri bölünmek zorundadır.

Sınırın iki yönü de maliyetlidir. Paketler küçüldükçe başlık yükünün oranı artar: her
paket kendi başlığını taşır, yani aynı veriyi taşımak için daha çok başlık gönderilir.
Paketler büyüdükçe tek bir kaybın maliyeti artar ve bir paketin bağlantıyı meşgul ettiği
süre uzar.

Yukarıdaki örnekte 19 karakterlik mesaj 5 baytlık paketlere bölündüğünde dört paket
oluştu ve sonuncusu yalnızca dört bayt taşıdı. Son paketin eksik dolması olağandır; veri
boyu paket boyunun katı olmak zorunda değildir.

#### Özet

- Ağ, konaklar, bağlantılar ve aktarma kararı veren anahtarlama düğümlerinden oluşur;
  bağlantılar bant genişliği ve gecikme ile nitelenir.
- Devre anahtarlama iletişimden önce kaynak ayırır ve öngörülebilirlik sağlar, ancak
  patlamalı trafikte kapasiteyi boşta bırakır.
- Paket anahtarlama kaynağı önceden ayırmaz; istatistiksel çoğullamayla verimlilik,
  yolun sabit olmamasıyla arızaya dayanıklılık kazanır.
- Bu seçimin bedeli en iyi çaba teslimdir: ağ, paketin varacağına, sırasında varacağına
  veya yalnız bir kez varacağına söz vermez.
- Mesaj başlık ve yük taşıyan numaralı paketlere bölünür; sıra düzeltme ve eksik saptama
  ara düğümlerde değil uçlarda yapılır.

#### Sonraki Adım

Bu ders paketlerin nasıl taşındığını kurdu, ancak taşımayı kimin başlattığını
söylemedi. `ornek.test` sayfasını tutan makine ile isteği yazdığınız makine ağ açısından
eşit birer konaktır; buna karşın rolleri simetrik değildir. Biri sürekli bekler, diğeri
istediği anda konuşmaya başlar. Sonraki ders bu rol ayrımını tanımlar ve iki makinenin
birbirini nasıl bulduğunu göstermek üzere gerçek bir sunucu çalıştırır.

### İstemci–Sunucu Modeli

Source: https://academia.sh/tr/kurslar/internet-nasil-calisir/istemci-sunucu-modeli

Bağlantıyı başlatan ile bekleyen rollerinin ayrımı, bağlantı noktası kavramı ve eşler arası modelle karşılaştırma.

Önceki ders paketlerin ağ üzerinde nasıl taşındığını kurdu ve iletişimi kimin başlattığı
sorusunu açık bıraktı. Ağ, iki konağı da aynı biçimde taşır; aralarındaki fark ağın değil,
üzerlerinde çalışan programların özelliğidir.

Bu ders o farkı tanımlar: `ornek.test` sayfasını tutan makinedeki program neden sürekli
bekler, sizin makinenizdeki program neden istediği anda konuşmaya başlar? Ders sonunda bu
kursun örnek sunucusu çalışır durumda olacak.

#### Rolleri Ayıran Ölçüt

**Sunucu (server)**, bir bağlantı noktasında bekleyen ve gelen isteklere yanıt veren
programdır. **İstemci (client)**, bağlantıyı başlatan ve istek gönderen programdır.

Ayrımın tek ölçütü **bağlantıyı kimin başlattığıdır**. Yaygın bir yanlış anlama, sunucuyu
"güçlü makine", istemciyi "zayıf makine" saymaktır. Bu doğru değildir: rol donanıma değil,
programın davranışına aittir. Aynı makine bir program için sunucu, başka bir program için
istemci olabilir; sunucular sık sık başka sunucuların istemcisidir.

Roller iki asimetri doğurur.

**Bulunabilirlik.** İstemcinin sunucuyu bulabilmesi gerekir; sunucunun istemciyi
bilmesine gerek yoktur. Bu yüzden sunucunun adresi kararlı ve önceden bilinir olmak
zorundadır. İstemcinin adresi geçici olabilir, bağlantıdan bağlantıya değişebilir.

**Erişilebilirlik.** Sunucu, istek gelebileceği her an dinliyor olmalıdır. İstemci ise
yalnızca konuşacağı anda çalışır. Sunucunun sürekli çalışması gerekliliği, sonraki
derslerde ele alınacak barındırma sorununun kaynağıdır.

#### Bağlantı Noktası

Bir adres makineyi belirler. Ancak bir makinede aynı anda birden çok sunucu programı
çalışabilir. Gelen bir paketin hangi programa ait olduğunu ayırt etmek için ikinci bir
sayı gerekir: **bağlantı noktası (port)**.

Adres binayı, bağlantı noktası binadaki daireyi gösterir. Bir bağlantı, dört değerle
tanımlanır: kaynak adres, kaynak bağlantı noktası, hedef adres, hedef bağlantı noktası. Bu
dörtlü benzersiz olduğu sürece aynı iki makine arasında sayısız bağlantı bir arada
yaşayabilir.

Sunucular önceden bilinen numaralarda dinler; istemcinin adresi gibi istemcinin bağlantı
noktası da genellikle işletim sistemince o an atanan geçici bir numaradır. Web trafiğinin
şifrelenmemiş biçimi 80, şifrelenmiş biçimi 443 numaralı bağlantı noktasında dinlenir. Bu
numaralar bir kayıt kuruluşunca ayrılmıştır ve adres satırında yazılmadıkları için
görünmezler: `http://ornek.test/` yazdığınızda 80, `https://ornek.test/` yazdığınızda 443
varsayılır.

Farklı bir numara kullanılacaksa adreste açıkça yazılır. Bu kursun örneklerinde 8080
numarası kullanılır; ayrıcalıklı olmayan bir numara seçmek, sunucuyu yönetici yetkisi
olmadan çalıştırmayı sağlar.

#### Bir Sunucu Yazmak

Sunucunun ne yaptığını anlatmanın en kesin yolu bir tane çalıştırmaktır. Aşağıdaki program
bir bağlantı noktasında dinler, tek bir bağlantı kabul eder, aldığı baytları ekrana yazar
ve sabit bir yanıt gönderir.

```python
# tek_baglanti_sunucusu.py
import socket

GOVDE = b"<!doctype html>\n<html lang=\"tr\"><body><h1>Ornek Sayfa</h1></body></html>\n"

YANIT = (
    b"HTTP/1.1 200 OK\r\n"
    b"Content-Type: text/html; charset=utf-8\r\n"
    b"Content-Length: " + str(len(GOVDE)).encode() + b"\r\n"
    b"Connection: close\r\n"
    b"\r\n"
) + GOVDE


def sunucuyu_calistir(baglanti_noktasi: int = 8080) -> None:
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as dinleyici:
        dinleyici.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        dinleyici.bind(("127.0.0.1", baglanti_noktasi))
        dinleyici.listen(1)
        print("dinleniyor:", baglanti_noktasi, flush=True)
        istemci, adres = dinleyici.accept()
        with istemci:
            istek = istemci.recv(4096)
            print("--- gelen istek ---")
            print(istek.decode("utf-8", "replace"), end="")
            print("--- istek sonu ---")
            istemci.sendall(YANIT)


sunucuyu_calistir()
```

Program dört adımı sırayla yürütür ve bu dört adım her sunucuda aynıdır:

1. `bind` — bir adres ve bağlantı noktası sahiplenilir.
2. `listen` — gelen bağlantıları kabul etmeye hazır duruma geçilir.
3. `accept` — bir istemci bağlanana kadar **beklenir**. Bu satırda program durur.
4. `recv` / `sendall` — istek okunur, yanıt yazılır.

Üçüncü adım rolün özüdür. Sunucu, ne zaman ve kimin bağlanacağını bilmeden bekler.

`socket` çağrılarındaki **soket (socket)**, bir bağlantının program tarafındaki tutamağıdır;
işletim sistemi bu tutamak üzerinden veri okunmasını ve yazılmasını sağlar.

#### Bir İstemci Çalıştırmak

Sunucu çalışırken başka bir uçbirimden bir istemci çalıştırılır. Burada istemci olarak
`curl` kullanılır. `--resolve` seçeneği, `ornek.test` adının hangi adrese karşılık
geldiğini elle bildirir; ad çözümlemesi sonraki konunun konusudur, burada yerine geçici
olarak bu seçenek konur. `-A` seçeneği istemcinin kendini tanıttığı metni sabitler.
`--noproxy '*'` seçeneği ise ortamda tanımlı bir vekil sunucu ayarının bu yerel isteği
etkilemesini önler.

Aşağıdaki komutlar tek parça çalışır: sunucu arka planda başlatılır ve ekrana yazdıkları
`sunucu_cikti.txt` dosyasına yönlendirilir, `until` döngüsü sunucunun dinlemeye geçtiğini
bildiren satırı bekler (tek bağlantı kabul eden sunucuya yoklama isteği göndermek bağlantıyı
tüketirdi), `wait` ise sunucu tek bağlantısını işleyip çıkana kadar bekler. Sunucuyu ayrı
bir uçbirimde çalıştırırsanız yalnızca `curl` satırını yazmanız yeter.

```sh
rm -f sunucu_cikti.txt
python3 tek_baglanti_sunucusu.py > sunucu_cikti.txt &
until grep -q dinleniyor sunucu_cikti.txt; do sleep 0.05; done
curl -sv --noproxy '*' --resolve ornek.test:8080:127.0.0.1 -A "ornek-istemci" http://ornek.test:8080/
wait
```

İstemci tarafında görünen alışveriş (`>` giden, `<` gelen satırları gösterir):

```
* Added ornek.test:8080:127.0.0.1 to DNS cache
* Hostname ornek.test was found in DNS cache
*   Trying 127.0.0.1:8080...
* Connected to ornek.test (127.0.0.1) port 8080
> GET / HTTP/1.1
> Host: ornek.test:8080
> User-Agent: ornek-istemci
> Accept: */*
> 
< HTTP/1.1 200 OK
< Content-Type: text/html; charset=utf-8
< Content-Length: 73
< Connection: close
< 
{ [73 bytes data]
* Closing connection
<!doctype html>
<html lang="tr"><body><h1>Ornek Sayfa</h1></body></html>
```

`*` ile başlayan satırlar `curl`'ün kendi açıklamalarıdır, alışverişin parçası değildir.

Sunucu tarafında ise, yani `sunucu_cikti.txt` dosyasında (ayrı uçbirimde çalıştırılsaydı
sunucunun penceresinde), istemcinin gönderdiği baytlar göründü:

```
dinleniyor: 8080
--- gelen istek ---
GET / HTTP/1.1
Host: ornek.test:8080
User-Agent: ornek-istemci
Accept: */*

--- istek sonu ---
```

İki çıktı aynı alışverişin iki ucudur. Dikkat edilecek nokta, sunucunun aldığı şeyin
yapılandırılmış bir nesne değil, düz bir metin olmasıdır. İstek de yanıt da baytlardan
oluşur; kuralları belirleyen tek şey iki tarafın aynı biçimi izlemesidir. O biçim HTTP'dir
ve üçüncü konunun konusudur.

`127.0.0.1` adresi makinenin kendisini gösterir; bu adrese gönderilen paketler makineden
çıkmaz. Bu, gerçek bir ağa gerek kalmadan istemci–sunucu alışverişinin bütününü
incelemeyi sağlar.

#### Eşler Arası Model

İstemci–sunucu tek seçenek değildir. **Eşler arası (peer-to-peer)** modelde her konak hem
istemci hem sunucu gibi davranır: kaynağı hem alır hem başkalarına sunar. Merkezde
duran ayrıcalıklı bir makine yoktur.

İki model, aynı ölçütler üzerinden karşılaştırılır.

| Ölçüt | İstemci–sunucu | Eşler arası |
|---|---|---|
| Kaynağın yeri | Bilinen bir konakta | Katılan konaklara dağılmış |
| Bulma yöntemi | Sunucunun adresi bilinir | Eşlerin listesi keşfedilir |
| Talep artınca | Sunucu yükü artar | Kapasite de artar |
| Tek arıza noktası | Sunucu | Yok |
| Denetim ve tutarlılık | Tek yerde, kolay | Dağıtık, güç |
| Erişilebilirlik | Sunucuya bağlı | Yeterli eş varsa sürer |

Eşler arası modelin en belirgin üstünlüğü ölçeklenmedir: kaynağı isteyen her yeni konak,
aynı zamanda o kaynağı sunabilecek yeni bir kapasitedir. Talep arttıkça arz da artar.

Buna karşılık iki güçlüğü vardır. Birincisi bulunabilirliktir: kararlı bir adres
olmadığında bir kaynağın kimde bulunduğunu saptamak ayrı bir problemdir. İkincisi
denetimdir: içeriğin doğruluğunu, güncelliğini ve yetkilendirmesini tek bir noktadan
güvence altına almak dağıtık bir yapıda güçtür.

Web, istemci–sunucu modeli üzerine kuruludur. Gerekçe, bu iki güçlüğün web'in temel
gereksinimleriyle doğrudan çakışmasıdır: bir alan adının belirli bir içeriği göstermesi
beklenir ve o içeriğin kimin yetkisinde olduğu belirli olmalıdır. Kararlı ad ve kararlı
sorumluluk, kararlı bir sunucu gerektirir.

Bu ayrım keskin bir sınır değildir. Bir sunucunun ardında yükü paylaşan çok sayıda makine
bulunabilir; iki tarayıcı arasında doğrudan bağlantı kurulabilir. Roller, makinelere değil
belirli bir alışverişe göre belirlenir.

#### Özet

- İstemci ile sunucuyu ayıran ölçüt donanım değil, bağlantıyı kimin başlattığıdır.
- Sunucu kararlı bir adreste sürekli dinler; istemcinin adresi geçici olabilir.
- Bağlantı noktası, aynı makinedeki birden çok sunucu programını ayırır; bir bağlantı
  kaynak ve hedef adres ile bağlantı noktalarından oluşan dörtlüyle tanımlanır.
- Bir sunucu programı `bind`, `listen`, `accept` ve okuma/yazma adımlarını izler;
  `accept` çağrısında beklemek rolün özüdür.
- İstek ve yanıt yapılandırılmış nesneler değil, iki tarafın aynı biçimde yorumladığı
  bayt dizileridir.
- Eşler arası model talep arttıkça kapasite kazandırır, ancak kararlı adres ve merkezî
  denetim gerektiren web için istemci–sunucu modeli seçilmiştir.

#### Sonraki Adım

Sunucunun kararlı bir adreste dinlemesi gerektiği kuruldu; ancak bu sunucu sizin
makinenizle aynı yerel ağda değildir. Aradaki paketler, birbirinden bağımsız işletilen
çok sayıda ağdan geçer ve bu ağların ortak bir sahibi yoktur. Sonraki ders, tek bir
kuruluşa ait olmayan bu yapının nasıl bir arada durduğunu ve `ornek.test` sunucusuna giden
yolun kimler tarafından belirlendiğini ele alacak.

### İnternetin Yapısı

Source: https://academia.sh/tr/kurslar/internet-nasil-calisir/internetin-yapisi

Ağların ağı fikri, otonom sistemler arasındaki yönlendirme, merkezî yönetimin bulunmayışı ve ortak standartların bu yapıyı nasıl bir arada tuttuğu.

Önceki ders sunucunun kararlı bir adreste dinlediğini kurdu. Ancak `ornek.test` sunucusu
sizin makinenizle aynı yerel ağda değildir. İki uç arasındaki paketler, ayrı kuruluşlarca
işletilen ve ortak bir sahibi olmayan çok sayıda ağdan geçer.

Bu ders, o yapının nasıl bir arada durduğunu ele alır. Sorulacak soru şudur: kimsenin
tamamına sahip olmadığı bir sistemde, bir paketin hedefe giden yolu nasıl belirlenir?

#### Ağların Ağı

İnternet tek bir ağ değildir. Birbirine bağlanmış, her biri ayrı işletilen binlerce ağın
oluşturduğu bir birleşimdir. Bir üniversite kampüsündeki ağ, bir kurumun iç ağı, bir
erişim sağlayıcının ağı — her biri kendi donanımını seçer, kendi kurallarını koyar, kendi
personeliyle işletir.

Bu ağları internet yapan şey ortak sahiplik değil, iki ortak karardır: aynı adresleme
düzenini kullanmak ve birbirlerinin trafiğini taşımayı kabul etmek. Bir ağ bu ikisini
yaptığı anda internetin parçasıdır; bırakmak istediğinde bağlantısını keser.

Bu tasarımın adı **ağların ağıdır** ve doğrudan bir sonucu vardır: internetin bir açma
düğmesi, bir merkezî yönetim kurulu veya tam bir haritası yoktur. Hiçbir kuruluş tüm
bağlantıların listesini tutmaz, çünkü böyle bir liste hiçbir yerde üretilmez.

#### Otonom Sistem

Yönlendirme açısından anlamlı birim tek tek ağlar değil, **otonom sistemdir (autonomous
system)**: tek bir yönetim otoritesi altında, ortak bir yönlendirme politikasıyla işletilen
ağ veya ağlar kümesi.

Otonom sistemler numaralandırılır. Bu numara, sistemler arasındaki yönlendirme
konuşmalarında sistemi tanıtan kimliktir. Numaralar bir kayıt düzeni içinde dağıtılır;
aynı numarayı iki kuruluşun kullanamaması gerekir.

Yönlendirme problemi böylece iki düzeye ayrılır.

**Sistem içi yönlendirme.** Bir otonom sistemin içinde yolun nasıl seçileceği, o sistemi
işleten kuruluşun kendi kararıdır. Dışarıdan kimse karışmaz ve dışarısı bu ayrıntıyı
görmez.

**Sistemler arası yönlendirme.** Otonom sistemler birbirlerine hangi adres bloklarına
ulaşabildiklerini duyurur. Bir sistem, komşularından gelen duyuruları toplar ve her hedef
için hangi komşuya vereceğine kendi politikasına göre karar verir.

Bu ikinci düzeydeki kararın kime ait olduğu önemlidir: **her otonom sistem kendi kararını
verir.** Yolu belirleyen merkezî bir otorite yoktur; yol, bağımsız kararların zincirlenmesiyle
ortaya çıkar. Bir paketin izlediği yol, bu yüzden, hiçbir uçta önceden bilinmez.

Ayrımın pratik sonucu ölçeklenmedir. Sistemler arası yönlendirme, her konağı değil adres
bloklarını ve otonom sistemleri konuşur. Bir kuruluşun iç ağını değiştirmesi, dışarıdaki
yönlendirme tablolarında hiçbir değişiklik yaratmaz. Bu ayrım olmasaydı, dünyadaki her
yerel değişikliğin tüm ağlara duyurulması gerekirdi.

#### İlişki Türleri

Otonom sistemler arasındaki bağlantılar teknik olduğu kadar ticari ilişkilerdir ve
politikayı belirleyen de bu ilişkilerdir.

**Geçiş (transit)** ilişkisinde bir sistem, bir başkasının trafiğini internetin geri
kalanına taşımayı üstlenir; bunun karşılığında ücret alır. Trafik yukarı doğru akar.

**Eşleme (peering)** ilişkisinde iki sistem, yalnızca kendi müşterilerine ait trafiği
karşılıklı olarak doğrudan alışverişe açar. Aradaki taşımayı üçüncü bir tarafa ödemedikleri
için ikisi de kazanır; bu yüzden çoğu eşleme ücretsizdir.

Bu ilişkilerin sonucu, yolun her zaman en kısa olmamasıdır. Bir sistem, teknik olarak daha
kısa bir yol varken politika gereği başka bir komşuyu seçebilir. Ağın geometrisi ile
yönlendirmenin geometrisi aynı değildir.

#### Bir Yolun İzlenmesi

Bir paketin izlediği ara düğümler, yol izleme araçlarıyla gözlenebilir. Bu araçlar, gidiş
mesafesi kademeli olarak artırılan paketler göndererek yol üzerindeki düğümlerin sırayla
yanıt vermesini sağlar.

{/* run: skip */}
```sh
traceroute ornek.test
```

Bu komutun çıktısı burada verilmemiştir ve verilemez. Çıktı, komutu çalıştıran makinenin
bulunduğu yere, erişim sağlayıcısına ve o andaki yönlendirme durumuna bağlıdır; aynı komut
iki farklı yerde iki farklı sonuç, aynı yerde farklı zamanlarda farklı sonuç üretir.
Değişmeyen, çıktının **biçimidir**:

| Alan | Anlamı |
|---|---|
| Satır numarası | Kaçıncı ara düğüm olduğu |
| Ad veya adres | O düğümün kimliği |
| Süre ölçümleri | Gidiş–dönüş süresi; birden çok ölçüm yapılır |
| `*` işareti | Düğüm yanıt vermedi |

Son satırdaki `*` işaretleri arıza anlamına gelmez. Yol üzerindeki düğümlerin bu tür
paketlere yanıt verme zorunluluğu yoktur; yanıt vermemek bir yapılandırma tercihidir ve
paketlerin taşınmasını engellemez.

İki nokta bu çıktıyı okurken önemlidir. Birincisi, gidiş yolu ile dönüş yolu aynı olmak
zorunda değildir; ölçülen süre ikisinin toplamıdır. İkincisi, yol zaman içinde değişebilir;
iki ardışık ölçüm farklı düğümler gösterebilir. Bu, önceki derste kurulan paket
anahtarlamanın doğrudan sonucudur.

#### Merkezsizlik Neyin Merkezsizliğidir

İnternetin merkezî yönetimi olmaması, hiçbir şeyin ortak olmadığı anlamına gelmez.
Bazı işlevler tekil olmak zorundadır, çünkü çakışma olduğunda sistem çalışmaz.

**Tekil olmak zorunda olanlar.** Adresler ve otonom sistem numaraları benzersiz olmalıdır;
aynı adresi iki kuruluş kullanırsa paketler hangi hedefe gideceğini yitirir. Alan adı
hiyerarşisinin kökü de tekildir; aynı adın iki farklı yeri göstermemesi gerekir. Bu
sayıların ve adların dağıtımı, bölgesel kayıt kuruluşlarına devredilmiş bir düzen içinde
yürütülür.

**Tekil olması gerekmeyenler.** Hangi donanımın kullanılacağı, iç yönlendirmenin nasıl
yapılacağı, hangi komşuyla eşleneceği, kapasitenin ne kadar olacağı — bunların hepsi yerel
kararlardır.

**Ortak olması gereken ama zorunlu tutulamayan.** Protokoller. İki ağın konuşabilmesi için
aynı kuralları izlemesi gerekir, ancak bunu dayatan bir yaptırım yoktur. Kurallar açık
belgeler olarak yayımlanır ve gerçekleştirimler bu belgelere uyduğu için birlikte çalışır.
Uymayan bir gerçekleştirim yasaklanmaz; yalnızca kimse onunla konuşamaz.

Bu üçlü ayrım, internetin yönetişim modelini özetler: adlarda ve sayılarda tekillik,
işletmede özerklik, protokollerde gönüllü uyum.

#### Bu Yapının Bedeli

Merkezsiz tasarımın kazançları belirgindir: yeni bir ağın katılması için kimseden izin
alınması gerekmez, bir bölümün arızası bütünü durdurmaz, farklı ölçeklerdeki kuruluşlar
aynı yapıda yaşayabilir.

Bedelleri de aynı ölçüde belirgindir. Uçtan uca başarım kimsenin güvencesi altında
değildir; yol üzerindeki her sistemin kendi politikası vardır. Bir sorunun kaynağını
bulmak, birden çok kuruluşun görüş alanına yayılmış bir sorunu birleştirmeyi gerektirir.
Yönlendirme duyuruları güvene dayandığı için yanlış bir duyuru trafiği yanlış yere
çekebilir.

Bu bedeller tasarım hatası değil, seçilen ödünleşimin diğer yüzüdür. Önceki dersteki paket
anahtarlama kararında olduğu gibi burada da öngörülebilirlikten vazgeçilip esneklik ve
ölçeklenebilirlik alınmıştır.

#### Özet

- İnternet tek bir ağ değil, ortak adresleme düzenini kullanmayı ve birbirinin trafiğini
  taşımayı kabul etmiş bağımsız ağların birleşimidir.
- Otonom sistem, tek bir yönetim otoritesi altında ortak politikayla işletilen ağ
  kümesidir ve yönlendirmenin anlamlı birimidir.
- Sistem içi yönlendirme yerel bir karardır; sistemler arası yönlendirmede her sistem
  komşularından gelen duyurulara bakarak kendi kararını verir.
- Sistemler arası ilişkiler ticari olduğu için seçilen yol her zaman en kısa yol değildir.
- Yol izleme çıktısı yere ve zamana bağlıdır; kararlı olan çıktının biçimi ve yanıt
  vermeyen düğümlerin arıza anlamına gelmemesidir.
- Adresler, otonom sistem numaraları ve alan adı kökü tekil olmak zorundadır; işletme
  kararları yereldir, protokol uyumu gönüllüdür.

#### Sonraki Adım

Bu ders, paketlerin adres bloklarına göre yönlendirildiğini söyledi ancak adresin kendisini
tanımlamadı. Yönlendirme tablolarının tek tek makineleri değil blokları taşıyabilmesi,
adreslerin rastgele değil yapılı olmasına dayanır. Sonraki ders IP adresini tanımlayacak,
bu yapının ölçeklenme gerekçesini gösterecek ve `ornek.test` sunucusunun adresinin ne
anlama geldiğini açıklayacak.

### IP Adresi Kavramı

Source: https://academia.sh/tr/kurslar/internet-nasil-calisir/ip-adresi-kavrami

Adresin sayısal yapısı, ağ ve konak bölümlerine ayrılmasının yönlendirme tablolarını nasıl küçülttüğü, genel ve özel adres ayrımı.

Önceki ders, otonom sistemlerin birbirlerine tek tek makineleri değil **adres bloklarını**
duyurduğunu söyledi. Bu, adreslerin rastgele dağıtılmış etiketler olmadığını ima eder;
blok halinde konuşulabiliyorsa adreslerin bir yapısı olmalıdır.

Bu ders o yapıyı tanımlar. Sorulacak soru şudur: bir adres neye benzer ve bu biçim
seçilirken hangi problem çözülmeye çalışılmıştır?

#### Adres Bir Sayıdır

**IP adresi**, ağa bağlı bir arayüzü belirleyen sabit uzunluklu bir sayıdır. IPv4
düzeninde bu sayı 32 bittir.

Alışılmış `192.0.2.10` gösterimi, o 32 bitin sekizer bitlik dört parçaya bölünüp her
parçanın onluk tabanda yazılmasından ibarettir. Gösterim insan içindir; makine tek bir
sayı görür.

```python
import ipaddress

adres = ipaddress.ip_address("192.0.2.10")
print(adres.version)
print(int(adres))
print(format(int(adres), "032b"))
```

```
4
3221225994
11000000000000000000001000001010
```

Bit dizisinin ilk sekizlisi `11000000` ikilik tabanda 192, ikinci sekizlisi `00000000`
sıfır, üçüncüsü `00000010` iki, sonuncusu `00001010` ondur. Nokta ayracı bit dizisinde
yoktur; yalnızca yazımda vardır.

Her parçanın sekiz bit olması, alabileceği değerleri 0–255 aralığıyla sınırlar. `192.0.2.300`
gibi bir yazım geçersizdir çünkü 300 sekiz bite sığmaz.

Adresin baytlarının ağ üzerinde hangi sırayla yazılacağı ayrıca kararlaştırılmıştır.
Bilgisayarlar Nasıl Çalışır kursundaki bayt sırası dersinde bu düzen **ağ bayt sırası**
adıyla geçmişti: başlıklardaki çok baytlı sayılar büyük uçlu yazılır. Farklı bayt sırası
kullanan makinelerin aynı adresi aynı biçimde okuyabilmesi bu anlaşmaya dayanır.

32 bit toplam $2^{32}$, yani yaklaşık 4,3 milyar farklı değer verir. Bu sayı, düzen
tasarlandığında bol görünmüştür; sonradan yetmemiştir. IPv6 düzeni adresi 128 bite
çıkararak bu sınırı kaldırır ve `2001:db8::1` gibi onaltılık gruplarla yazılır. İki düzen
arasındaki teknik ayrıntılar Ağ Modelleri ve Protokoller kursunun konusudur.

#### Adres Neyi Adresler

Adresin bir makineyi değil, **bir ağ arayüzünü** belirlediğine dikkat edilmelidir. Birden
çok arayüzü olan bir makinenin birden çok adresi olur; bir yönlendiricinin her bacağı ayrı
bir adres taşır.

Adres, önceki derste tanımlanan bağlantı noktasıyla birlikte çalışır. Adres hangi arayüze
gidileceğini, bağlantı noktası o makinedeki hangi programa teslim edileceğini söyler.
`ornek.test` sunucusuna ulaşmak için ikisi de gerekir.

#### Hiyerarşi ve Yönlendirmenin Ölçeklenmesi

Adreslerin rastgele dağıtılabileceğini varsayalım. Bu durumda her yönlendiricinin, her
hedef adres için hangi yöne gideceğini ayrı ayrı bilmesi gerekirdi. Tablo, kullanımdaki
adres sayısı kadar satır taşırdı ve her yeni makine tüm ağlara duyurulurdu.

Çözüm, adresi ikiye bölmektir: soldaki bitler **ağı**, sağdaki bitler o ağ içindeki
**konağı** belirtir. Bölmenin nerede olduğu, adresin yanında yazılan **önek uzunluğuyla**
belirtilir.

```python
import ipaddress

ag = ipaddress.ip_network("192.0.2.0/24")
print(ag.network_address)
print(ag.netmask)
print(ag.num_addresses)
print(ipaddress.ip_address("192.0.2.10") in ag)
print(ipaddress.ip_address("198.51.100.10") in ag)
```

```
192.0.2.0
255.255.255.0
256
True
False
```

`/24` yazımı, soldaki 24 bitin ağ bölümü olduğunu söyler. Geriye konak için 8 bit kalır ve
bu blok $2^8 = 256$ adres içerir. `192.0.2.10` bu bloğun içindedir; `198.51.100.10`
değildir.

`255.255.255.0` değeri aynı bilginin **maske** biçimindeki yazılışıdır: bir olan bitler ağ
bölümünü, sıfır olan bitler konak bölümünü işaretler.

Kazanç şudur: yönlendirici artık 256 adres için tek bir satır tutar. `192.0.2.0/24` bloğuna
giden her paket aynı yöne gider; içindeki tek tek konaklar dışarıdan görünmez. Blok ne
kadar büyükse tablodaki tasarruf o kadar büyüktür.

Bu, bir adres verildiğinde onun hangi ağa ait olduğunun **adresin kendisinden**
okunabilmesi demektir. Adres yalnızca bir kimlik değil, aynı zamanda bir konum bildirimidir.
Bir kuruluş adres bloğunu değiştirdiğinde makinelerin adresleri de değişir; adres,
makinenin taşınabilir bir özelliği değildir.

Bloklar iç içe geçebilir ve bir yönlendirici birden çok eşleşen satır bulabilir. Bu
durumda **en uzun önek** kazanır: en ayrıntılı bilgiyi veren satır seçilir. Böylece genel
bir blok tek satırla özetlenirken, o bloğun içindeki bir bölüm ayrı bir satırla farklı
yöne gönderilebilir. Önek hesabının ayrıntısı ve alt ağ tasarımı Ağ Modelleri ve
Protokoller kursunda ele alınır.

#### Genel ve Özel Adresler

Adres alanının bir bölümü, internet üzerinde yönlendirilmemek üzere ayrılmıştır. Bu
**özel adresler**, yalnızca yerel bir ağın içinde anlam taşır.

Üç blok bu amaçla ayrılmıştır:

```python
import ipaddress

OZEL_BLOKLAR = [
    ipaddress.ip_network("10.0.0.0/8"),
    ipaddress.ip_network("172.16.0.0/12"),
    ipaddress.ip_network("192.168.0.0/16"),
]

for metin in ["10.0.0.5", "172.16.3.1", "192.168.1.1", "192.0.2.10"]:
    a = ipaddress.ip_address(metin)
    ozel = any(a in blok for blok in OZEL_BLOKLAR)
    print(f"{metin:<14} ozel_blokta={ozel}")
```

```
10.0.0.5       ozel_blokta=True
172.16.3.1     ozel_blokta=True
192.168.1.1    ozel_blokta=True
192.0.2.10     ozel_blokta=False
```

Özel adreslerin tanımlayıcı özelliği **benzersiz olmamalarıdır**. Sayısız yerel ağda aynı
anda `192.168.1.1` adresli bir makine bulunur ve bu bir çakışma değildir, çünkü bu adres
kendi ağının dışında hiçbir anlam taşımaz. Bir yönlendirici, hedefi özel bir adres olan
paketi internete iletmez.

Bunun doğrudan sonucu, özel adresli bir makinenin dışarıdan doğrudan erişilebilir
olmamasıdır. Böyle bir makine dışarıya bağlantı **başlatabilir**; çıkışta ağ sınırındaki
düzenek, paketin kaynak adresini kendi genel adresiyle değiştirir ve dönen yanıtı doğru iç
makineye geri çevirir. Bu dönüştürme işlemi Linux Ağ Yönetimi ve Sorun Giderme kursunun
adres dönüştürme dersinde ve
Ağ Modelleri ve Protokoller kursunda ayrıntılandırılır.

Bu, önceki derste kurulan istemci–sunucu asimetrisiyle örtüşür: istemci olmak için
erişilebilir bir adres gerekmez, sunucu olmak için gerekir. Bir sunucunun genel bir adrese
ihtiyaç duyması, barındırma konusunun teknik temelidir.

Bir blok daha ayrıdır: `127.0.0.0/8`, makinenin kendisini gösteren **geri döngü**
adreslerini içerir. Bu adrese gönderilen paketler ağ arayüzüne hiç çıkmaz. Önceki dersteki
sunucu `127.0.0.1` üzerinde dinlediği için yalnızca aynı makineden erişilebilirdi.

Bu kursun örneklerinde `192.0.2.0/24` ve `198.51.100.0/24` blokları kullanılır. Bu bloklar
belgeleme için ayrılmıştır; gerçek bir konağı göstermezler ve bu yüzden örneklerde
kullanılmaları güvenlidir.

#### Adres Nereden Gelir

Bir makine adresini iki yoldan alır. **Elle yapılandırma**, adresin bir insan tarafından
girilmesidir; sunucular gibi adresi değişmemesi gereken makinelerde kullanılır. **Otomatik
atama**, makinenin ağa katıldığında yerel bir hizmetten adres istemesidir; bu adres
kiralıktır ve süresi dolduğunda yenilenir.

İkinci yolun sonucu, istemci makinelerin adreslerinin kalıcı olmamasıdır. Aynı makine
farklı ağlarda farklı adres alır. Sunucunun adresinin kararlı, istemcinin adresinin geçici
olması, bu iki atama yönteminin doğal ayrımıdır.

Genel adres blokları kuruluşlara doğrudan verilmez; önceki derste anılan bölgesel kayıt
düzeni içinde tahsis edilir ve erişim sağlayıcılar aracılığıyla dağıtılır. Bir adres bloğu
sahiplenilmez, belirli koşullarla tahsis edilir.

#### Özet

- IP adresi, bir ağ arayüzünü belirleyen sabit uzunluklu bir sayıdır; noktalı gösterim
  yalnızca yazım kolaylığıdır.
- Adres, ağ ve konak bölümlerine ayrılır; bölme noktası önek uzunluğuyla veya eşdeğer
  maskeyle belirtilir.
- Hiyerarşi, yönlendiricilerin tek tek konaklar yerine blokları tablolamasını sağlar;
  çakışan bloklarda en uzun önek seçilir.
- Adres bir konum bildirimidir; kuruluş bloğu değişince makinelerin adresleri de değişir.
- Özel adresler benzersiz değildir ve internete yönlendirilmez; bu tür bir adresli makine
  bağlantı başlatabilir ama dışarıdan erişilemez.
- Sunucular kararlı ve elle yapılandırılmış adres kullanır; istemciler otomatik atanan
  geçici adreslerle çalışabilir.

#### Sonraki Adım

Sunucunun bir adresi olduğu ve o adresin kararlı tutulduğu kuruldu. Buna karşın adres
satırına bir sayı yazmadınız; `ornek.test` yazdınız. İnsanlar sayıları anımsamaz ve bir
kuruluş sunucusunu taşıdığında adresi değişir, oysa adının değişmemesi beklenir. Sonraki
konu, adlar ile adresler arasındaki bu bağı kurar: adın nasıl yapılandığını, kime ait
olduğunu ve bir adrese nasıl çevrildiğini ele alır.

## Alan Adı ve Barındırma

Ad hiyerarşisi ve kayıt süreci, alan adı sisteminin çözümleme zinciri ve önbelleklemesi, kayıt türleri ve barındırma modelleri.

### Alan Adı Nedir

Source: https://academia.sh/tr/kurslar/internet-nasil-calisir/alan-adi-nedir

Ad ile adres arasındaki dolaylılık, etiketlerden oluşan ad hiyerarşisi, yetkinin devri ve kayıt sürecindeki roller.

Önceki konu, sunucuya ulaşmak için bir adres gerektiğini kurdu. Buna karşın adres satırına
`192.0.2.10` yazmadınız; `ornek.test` yazdınız. İki gösterim aynı sunucuyu gösterir, ancak
aralarında yalnızca okunabilirlik farkı yoktur.

Bu ders adın kendisini inceler: nasıl yapılandığını, kime ait olduğunu ve neden adresin
üzerine ayrı bir katman konduğunu ele alır. Adın adrese çevrilmesi bir sonraki dersin
konusudur.

#### Dolaylılığın Gerekçesi

Adı adresten ayırmak, iki ayrı sorunu çözer.

**Anımsanabilirlik** bunlardan yalnızca birincisidir ve daha az önemli olanıdır. İnsanlar
sayı dizilerini güçlükle anımsar; adlar anlam taşır.

**Bağın koparılabilmesi** asıl gerekçedir. Önceki derste kurulduğu üzere adres bir konum
bildirimidir: bir kuruluş sunucusunu başka bir sağlayıcıya taşıdığında adresi değişmek
zorundadır. Adres doğrudan kullanılsaydı, taşınma her kullanıcıyı etkilerdi — herkesin
bildiği değer geçersizleşirdi.

Araya bir ad katmanı konduğunda taşınma tek bir kaydın güncellenmesine iner. Ad sabit
kalır, gösterdiği adres değişir. Kullanıcı hiçbir şey yapmaz.

Aynı dolaylılık ters yönde de çalışır. Bir ad birden çok adrese bağlanabilir; istekler bu
adresler arasında dağıtılır. Aynı adres birden çok adı barındırabilir; bu konunun son
dersinin konusudur. Ad ile adres arasındaki ilişki bire bir değildir.

Bu, bilgisayar biliminde tekrarlanan bir kalıptır: değişebilen bir değerin üzerine kararlı
bir ad koymak. Programlama Temelleri kursundaki değişken bağlaması ile aynı fikirdir; adın
işaret ettiği şey değişse de ada başvuran kod değişmez.

#### Adın Yapısı

**Alan adı (domain name)**, noktalarla ayrılmış **etiketlerden (label)** oluşan bir dizidir.
Hiyerarşi soldan sağa değil, **sağdan sola** okunur: en sağdaki etiket en genel düzeyi
gösterir.

```python
def etiketleri_ayir(alan_adi: str) -> list[str]:
    """Alan adini etiketlerine ayirir; kok en sagdadir."""
    return alan_adi.rstrip(".").split(".")


for ad in ["ornek.test", "www.ornek.test", "dosya.arsiv.ornek.test"]:
    etiketler = etiketleri_ayir(ad)
    print(f"{ad:<24} {len(etiketler)} etiket  saglama sira: {etiketler[::-1]}")
```

```
ornek.test               2 etiket  saglama sira: ['test', 'ornek']
www.ornek.test           3 etiket  saglama sira: ['test', 'ornek', 'www']
dosya.arsiv.ornek.test   4 etiket  saglama sira: ['test', 'ornek', 'arsiv', 'dosya']
```

Bu diziyi bir ağaç üzerinde okumak doğru sezgiyi verir. Veri Yapıları kursundaki ağaç
terminolojisi burada olduğu gibi geçerlidir: adın her etiketi bir düğüm, tam ad ise kökten
o düğüme giden yoldur.

- **Kök**, adın en sağındaki noktadır ve genellikle yazılmaz. `ornek.test` yazımı
  `ornek.test.` yazımının kısaltmasıdır. Sondaki noktanın açıkça yazıldığı biçime
  **tam nitelikli alan adı (fully qualified domain name)** denir.
- **Üst düzey alan adı (top-level domain)**, kökün hemen altındaki etikettir: örnekteki
  `test`.
- Onun altındaki etiket, kaydedilen addır: `ornek`.
- Daha soldaki etiketler, ad sahibinin kendi kararıyla oluşturduğu **alt alanlardır**:
  `arsiv`, `dosya`.

`www` etiketinin ayrıcalıklı bir anlamı yoktur. Yerleşmiş bir gelenektir; teknik olarak
diğer alt alanlardan farksızdır. `ornek.test` ile `www.ornek.test` iki ayrı addır ve
farklı yerleri gösterebilirler.

#### Etiket Kuralları

Etiketler serbest metin değildir. Uzunluk sınırlıdır ve karşılaştırma kuralları
tanımlanmıştır.

```python
def etiketleri_ayir(alan_adi: str) -> list[str]:
    return alan_adi.rstrip(".").split(".")


print(len("a" * 63))
print(all(len(e) <= 63 for e in etiketleri_ayir("dosya.arsiv.ornek.test")))
```

```
63
True
```

Bir etiket en çok 63 karakter, tam ad ise en çok 255 karakter uzunluğunda olabilir.
İlk sınır adın ağ üzerinde taşındığı biçimden gelir: her etiketin başındaki uzunluk
baytının altı biti kullanılır. İkincisi bir alan genişliğinin sonucu değil, belirtimin
gerçekleştirimleri basitleştirmek için koyduğu bir üst sınırdır.

Adlar **büyük–küçük harf ayrımı gözetmez**: `ORNEK.TEST` ile `ornek.test` aynı adı
gösterir. Buna karşılık bu kural yalnızca ada uygulanır; adres satırındaki yol bölümü için
geçerli değildir ve bu ayrım Web İsteğinin Yolculuğu konusunda ele alınır.

Adların özgün karakter kümesi harf, rakam ve kısa çizgiyle sınırlıdır; bu, protokolün
etikette taşıyabileceğinin değil, ad kayıt eden kuruluşların uyguladığı ve konak adı
geleneğiyle uyumlu olan kümenin sınırıdır. Türkçe harfler dahil olmak üzere bu kümenin
dışındaki karakterleri içeren adlar, sınırlı kümeye geri çevrilebilen bir kodlamayla
temsil edilir. Bilgisayarlar Nasıl Çalışır kursundaki karakter
kodlamaları dersinde kurulan ayrım burada da geçerlidir: kullanıcıya gösterilen biçim ile
ağ üzerinde taşınan biçim aynı olmak zorunda değildir.

#### Yetkinin Devri

Ad hiyerarşisinin asıl işlevi düzenli görünmek değil, **sorumluluğu bölmektir.**

Kök düzeyinde hangi üst düzey adların var olacağına karar veren bir otorite bulunur. Bu
otorite, her üst düzey adın altındaki adları kimin yöneteceğini o adın işletmecisine
devreder. İşletmeci `ornek` adını bir sahibe verdiğinde, `ornek.test` altındaki her şeyin
yetkisi o sahibe geçer.

Devrin sonucu şudur: `arsiv.ornek.test` alt alanını oluşturmak için kimseden izin
alınmaz. Ad sahibi kendi alt ağacında sınırsız yetkilidir. Kök otoritesinin bu adlardan
haberi bile olmaz.

Bu, önceki dersteki otonom sistem yapısıyla aynı ilkedir: üst düzeyde tekillik, alt
düzeyde özerklik. Tekil olması gereken tek şey, hiyerarşinin her düzeyinde kimin yetkili
olduğudur.

#### Kayıt Süreci ve Roller

Bir adın "satın alınması" yaygın ama yanıltıcı bir ifadedir. Ad satın alınmaz; belirli bir
süre için **kullanım hakkı kiralanır**. Süre dolduğunda yenilenmezse ad serbest kalır.

Süreçte üç rol ayrılır ve bunların karıştırılması yaygın bir karışıklıktır.

| Rol | İşlevi |
|---|---|
| Kayıt kuruluşu (registry) | Bir üst düzey adın altındaki kayıtların tek yetkili veritabanını tutar |
| Kayıt operatörü (registrar) | Ad sahibiyle kayıt kuruluşu arasında aracılık eder, kaydı iletir |
| Ad sahibi (registrant) | Adın kullanım hakkını elinde tutan kişi veya kuruluş |

Kayıt kuruluşu her üst düzey ad için tektir; kayıt operatörü ise çok sayıdadır ve ad
sahibi bunlar arasından seçim yapar. Bir adın operatörü değiştirilebilir; kayıt kuruluşu
değiştirilemez, çünkü o üst düzey adın tanımının parçasıdır.

Kaydın teknik olarak anlamlı bölümü, adın hangi sunucuların yetkisinde olduğunun
bildirilmesidir. Kayıt kuruluşu, adın kendisinin hangi adrese karşılık geldiğini tutmaz;
yalnızca "bu adın yanıtlarını şu sunuculara sorun" bilgisini tutar. Yanıtın içeriği ad
sahibinin denetimindedir. Bu ayrım, sonraki dersteki çözümleme zincirinin temelidir.

#### Ayrılmış Adlar

Bazı üst düzey adlar, hiçbir zaman gerçek bir kayda açılmamak üzere ayrılmıştır. `test`,
`example`, `invalid` ve `localhost` bunlar arasındadır.

Bu kursun örneklerinde `ornek.test` adının kullanılması bu nedenledir. Ayrılmış bir ad
kimseye ait değildir, çözümlendiğinde gerçek bir sunucuya ulaşmaz ve ileride birinin
mülkiyetine geçmez. Örneklerde gerçek bir ad kullanmak, o adın sahibi değiştiğinde ya da
içeriği farklılaştığında örneği yanlış kılardı.

Aynı gerekçe önceki derste kullanılan `192.0.2.0/24` adres bloğu için de geçerlidir:
belgeleme için ayrılmış olan, örnekte güvenle kullanılabilir.

#### Özet

- Ad katmanı, adresin değişebilmesine karşın kullanıcının bildiği değerin sabit kalmasını
  sağlar; asıl gerekçe anımsanabilirlik değil bu bağın koparılabilmesidir.
- Alan adı etiketlerden oluşur ve sağdan sola, kökten yapraklara okunur; sondaki nokta
  kökü gösterir ve genellikle yazılmaz.
- `www` etiketinin teknik bir ayrıcalığı yoktur; diğer alt alanlarla aynı düzeydedir.
- Etiketler en çok 63, tam ad en çok 255 karakterdir; adlar büyük–küçük harf ayrımı
  gözetmez.
- Hiyerarşinin işlevi yetkiyi devretmektir: ad sahibi kendi alt ağacında izin almadan
  yeni adlar oluşturur.
- Kayıt kuruluşu üst düzey ad başına tektir ve yalnızca yetkili sunucuların kimliğini
  tutar; yanıtın içeriği ad sahibinin denetimindedir.

#### Sonraki Adım

Adın yapısı ve kime ait olduğu kuruldu, ancak adres satırına `ornek.test` yazıldığında
makinenin bu addan bir adrese nasıl vardığı henüz söylenmedi. Yanıt tek bir yerde
saklanmaz: sorgu, kökten başlayıp yetkinin devredildiği her düzeyde bir adım ilerleyen bir
zincir izler. Sonraki ders bu zinciri ve zincirin her isteği baştan yürütmesini önleyen
önbellekleme düzenini ele alacak.

### Alan Adı Sistemi

Source: https://academia.sh/tr/kurslar/internet-nasil-calisir/alan-adi-sistemi

Adın adrese çevrilmesini yürüten dağıtık veritabanı, kökten yetkiliye uzanan çözümleme zinciri ve yaşam süresine dayalı önbellekleme.

Önceki ders adın yapısını ve yetkinin nasıl devredildiğini kurdu. Kayıt kuruluşunun adın
adresini değil, yalnızca "bu adı şu sunuculara sorun" bilgisini tuttuğu söylenmişti.

Bu ders o sormayı yürüten düzeni ele alır: **alan adı sistemi (domain name system)**.
Sorulacak soru, `ornek.test` adının bir adrese nasıl çevrildiği ve bu çevirinin her istekte
neden baştan yapılmadığıdır.

#### Neden Tek Bir Dosya Değil

Adları adreslere eşleyen bir dosya tutmak, ağdaki makine sayısı azken yapılan şeydi. Her
makine bu dosyanın bir kopyasını taşırdı; bir ad eklendiğinde dosya güncellenir ve
herkese dağıtılırdı.

Bu düzenin üç ayrı sınırı vardır ve üçü de ölçekle ilgilidir. Dosya, ad sayısıyla orantılı
olarak büyür. Her değişiklik tüm kopyaların yenilenmesini gerektirir; değişiklik sıklığı
makine sayısıyla artar. Ve tek bir dosya, tek bir yetkili demektir: her ad talebinin aynı
noktadan geçmesi gerekir.

Alan adı sistemi bu üç sınırı da hiyerarşiyi kullanarak aşar. Veritabanı bölünür, her
bölümün yetkisi ayrı bir tarafa devredilir ve hiç kimse bütünü tutmaz.

#### Zincirdeki Roller

Çözümlemede dört ayrı rol bulunur.

**Sağlayıcı (stub resolver)**, isteği yapan makinenin içindedir. Uygulamanın bir adı
adrese çevirme çağrısı, işletim sistemindeki bu bileşene gider. Kendisi çözümleme yapmaz;
soruyu bir çözümleyiciye iletir ve yanıtı bekler.

**Çözümleyici (recursive resolver)**, işi üstlenen sunucudur. Genellikle erişim
sağlayıcının ya da kuruluşun işlettiği bir sunucudur. Yanıtı bulmak için gereken tüm
adımları o yürütür ve önbelleği o tutar.

**Kök sunucular**, hiyerarşinin tepesindedir. Adreslerin kendisini bilmezler; yalnızca her
üst düzey adın hangi sunuculara devredildiğini bilirler.

**Yetkili sunucular (authoritative server)**, bir adın yanıtlarını asıl olarak tutan
sunuculardır. `ornek.test` için yetkili sunucu, ad sahibinin belirlediği sunucudur ve
önceki derste anlatılan kayıt sırasında bildirilen de budur.

#### Çözümleme Zinciri

`ornek.test` adı önbellekte hiç bulunmadığı varsayımıyla, sorgu şu adımları izler:

1. Uygulama, işletim sistemindeki sağlayıcıdan `ornek.test` adresini ister.
2. Sağlayıcı soruyu çözümleyiciye iletir ve yanıtı bekler.
3. Çözümleyici bir kök sunucuya sorar. Kök, adresi bilmez; `test` üst düzey adının
   yetkisinin hangi sunuculara devredildiğini söyler.
4. Çözümleyici o sunuculardan birine sorar. O da adresi bilmez; `ornek.test` adının
   yetkisinin hangi sunuculara devredildiğini söyler.
5. Çözümleyici yetkili sunucuya sorar ve adresi alır.
6. Yanıt sağlayıcıya, oradan uygulamaya döner.

İş bölümü, iki farklı sorgu biçimini ayırır. Sağlayıcının çözümleyiciye sorduğu soru
**özyinelemelidir (recursive)**: "bu adın yanıtını bul ve bana getir." Çözümleyicinin kök
ve ara sunuculara sorduğu sorular **yinelemelidir (iterative)**: "bunu biliyorsan söyle,
bilmiyorsan kime soracağımı söyle."

Bu ayrım tesadüfi değildir. Kök ve üst düzey sunucular, gelen her soru için başkasına sorup
yanıtı derlemek zorunda olsaydı, yükleri taşınamaz olurdu. Ara sunucuların yaptığı iş tek
bir adımdır ve sabit maliyetlidir; derleme işi tek bir çözümleyicide toplanır.

Her adımda alınan yanıtın "adresi bilmiyorum, şuna sor" biçiminde olması, önceki dersteki
yetki devrinin doğrudan yansımasıdır. Zincirin uzunluğu, adın etiket sayısıyla değil,
yetkinin kaç kez devredildiğiyle belirlenir.

#### Bir Kaydın Biçimi

Sorgulama araçlarıyla bu yanıtlar doğrudan görülebilir. Aşağıdaki komut, makinenin
kendisini gösteren adı sorgular. Çıktı makinenin çözümleyici yapılandırmasına bağlıdır;
`localhost` adını yerel çözümleyicisi kendisi yanıtlayan bir sistemde örnek bir koşum
şöyledir:

{/* run: skip */}
```sh
dig +noall +answer localhost A
```

```
localhost.		0	IN	A	127.0.0.1
```

Bu tek satır, bir kaydın beş alanını gösterir:

| Alan | Örnekteki değer | Anlamı |
|---|---|---|
| Ad | `localhost.` | Kaydın ait olduğu ad; sondaki nokta kökü belirtir |
| Yaşam süresi | `0` | Yanıtın saniye cinsinden önbellekte tutulabileceği süre |
| Sınıf | `IN` | Adres ailesi; internet için her zaman bu değer |
| Tür | `A` | Kaydın türü; `A` bir IPv4 adresi taşır |
| Veri | `127.0.0.1` | Kaydın içeriği |

Aynı komut gerçek bir alan adı için çalıştırıldığında biçim aynı kalır, değerler değişir.
Bu kursta gerçek bir adın çıktısı verilmemiştir: yaşam süresi sorgunun ne zaman yapıldığına,
dönen adres ise sorgunun nereden yapıldığına bağlıdır. İkisi de sayfaya yazıldığı anda
eskimeye başlar. Komutu kendiniz çalıştırdığınızda göreceğiniz beş alan yukarıdakilerle
aynı olacaktır.

Kayıt türlerinin ayrıntısı sonraki dersin konusudur.

#### Önbellekleme ve Yaşam Süresi

Yukarıdaki zincir her istekte baştan yürütülseydi, tek bir sayfa açmak birden çok ağ
gidiş–dönüşü gerektirirdi ve kök sunucular dünyadaki her sorguyu görürdü. Sistemi
işletilebilir kılan, yanıtların saklanmasıdır.

Her kayıt, kendisiyle birlikte bir **yaşam süresi (time to live)** taşır: yanıtın kaç
saniye boyunca yeniden sorulmadan kullanılabileceği. Çözümleyici yanıtı bu süre boyunca
önbelleğinde tutar ve aynı soru geldiğinde zinciri yürütmeden yanıtlar.

Süreyi belirleyen, yanıtı veren yetkili sunucudur; yani ad sahibidir. Bu, ad sahibine
doğrudan bir denetim verir ve bir ödünleşimi yönetmesini gerektirir.

Aşağıdaki program bu davranışı gösterir. Saat dışarıdan verildiği için çıktı her
çalıştırmada aynıdır.

```python
class AdOnbellegi:
    """TTL ile sinirli ad->adres onbellegi. Saat disaridan verilir."""

    def __init__(self) -> None:
        self.kayitlar: dict[str, tuple[str, int]] = {}
        self.yukari_sorgu_sayisi = 0

    def cozumle(self, ad: str, simdi: int, ttl: int, adres: str) -> str:
        kayit = self.kayitlar.get(ad)
        if kayit is not None and kayit[1] > simdi:
            return f"onbellekten  (kalan TTL: {kayit[1] - simdi})"
        self.yukari_sorgu_sayisi += 1
        self.kayitlar[ad] = (adres, simdi + ttl)
        return f"yukari sorgu (yeni TTL: {ttl})"


onbellek = AdOnbellegi()
for saniye in [0, 100, 250, 300, 400]:
    sonuc = onbellek.cozumle("ornek.test", simdi=saniye, ttl=300, adres="192.0.2.10")
    print(f"t={saniye:>3}s  {sonuc}")

print(f"toplam yukari sorgu: {onbellek.yukari_sorgu_sayisi}")
```

```
t=  0s  yukari sorgu (yeni TTL: 300)
t=100s  onbellekten  (kalan TTL: 200)
t=250s  onbellekten  (kalan TTL: 50)
t=300s  yukari sorgu (yeni TTL: 300)
t=400s  onbellekten  (kalan TTL: 200)
toplam yukari sorgu: 2
```

Beş çözümleme isteği, yalnızca iki yukarı sorguya yol açtı. Gerçek bir çözümleyicide aynı
kaydı çok sayıda kullanıcı paylaştığı için oran çok daha keskindir.

Ödünleşim şudur:

- **Uzun yaşam süresi**, yukarı sorguları azaltır ve yanıtları hızlandırır. Buna karşılık
  bir değişiklik yapıldığında eski yanıt, süre dolana kadar kullanımda kalır.
- **Kısa yaşam süresi**, değişikliğin çabuk yayılmasını sağlar. Buna karşılık sorgu yükünü
  ve ortalama yanıt süresini artırır.

Bunun işletme pratiğindeki karşılığı doğrudandır: bir sunucu taşınacaksa, taşınmadan önce
yaşam süresi düşürülür, taşınma yapılır, yayılma tamamlandıktan sonra süre geri yükseltilir.
Süre önceden düşürülmezse, eski adres önbelleklerde eski sürenin uzunluğu kadar yaşamaya
devam eder.

Bu, ders boyunca dikkat edilmesi gereken bir sonucu doğurur: **bir alan adı değişikliği
aynı anda her yerde görünmez.** Farklı kullanıcılar, önbelleklerinin durumuna göre bir
süre farklı yanıtlar alır. Bu bir arıza değil, önbelleklemenin tanımı gereğidir.

Yanıtı olumsuz olan sorgular da saklanır. Var olmayan bir ad sorulduğunda "böyle bir ad
yok" yanıtı da bir süre önbellekte tutulur; yeni oluşturulan bir adın hemen görünmemesinin
nedeni budur.

Önbellek tek bir yerde değildir. İşletim sistemindeki sağlayıcı, çözümleyici ve isteği
yapan uygulamanın kendisi ayrı ayrı önbellek tutabilir. Bir adın çözümlenmesindeki
gecikmenin ya da eskimiş bir yanıtın hangi katmandan geldiğini saptamak, bu yüzden
katmanları ayrı ayrı incelemeyi gerektirir.

#### Özet

- Adları tek bir dosyada tutmak ölçeklenmez; alan adı sistemi veritabanını hiyerarşiye
  göre böler ve her bölümün yetkisini devreder.
- Çözümleme zinciri kökten başlar, üst düzey ad sunucusuna, oradan yetkili sunucuya iner;
  her adımda alınan yanıt bir sonraki adresi değil, bir sonraki yetkiliyi gösterir.
- Sağlayıcı çözümleyiciye özyinelemeli sorar; çözümleyici ara sunuculara yinelemeli sorar.
  Bu iş bölümü kök ve üst düzey sunucuların yükünü sabit tutar.
- Bir kayıt ad, yaşam süresi, sınıf, tür ve veri alanlarından oluşur.
- Yaşam süresi ad sahibince belirlenir ve sorgu yükü ile değişikliğin yayılma hızı
  arasındaki ödünleşimi yönetir.
- Önbellekleme çok katmanlıdır ve olumsuz yanıtları da kapsar; bir değişiklik her yerde
  aynı anda görünmez.

#### Sonraki Adım

Bu ders bir kaydın beş alanını gösterdi ve tür alanını `A` örneğiyle geçti. Oysa bir adın
altında yalnızca adres tutulmaz: başka bir ada yönlendirme, posta yönlendirmesi, doğrulama
metinleri ve yetki bildirimleri de aynı düzende saklanır. Sonraki ders bu türleri, hangi
soruna yanıt verdiklerini ve aralarındaki birleşim kurallarını ele alacak.

### DNS Kayıt Türleri

Source: https://academia.sh/tr/kurslar/internet-nasil-calisir/dns-kayit-turleri

Adres, takma ad, posta, ad sunucusu ve metin kayıtları; her türün hangi soruna yanıt verdiği ve takma ad kayıtlarının birleşim kısıtları.

Önceki ders bir kaydın ad, yaşam süresi, sınıf, tür ve veri alanlarından oluştuğunu
gösterdi ve tür alanını tek bir örnekle, `A` ile geçti. Oysa bir adın altında yalnızca
adres tutulmaz.

Bu ders tür alanının aldığı değerleri ele alır. Her tür ayrı bir soruna yanıt verir; hangi
türün neden var olduğunu görmek, alan adı sisteminin bir adres defterinden fazlası olduğunu
gösterir.

#### Bölge ve Bölge Dosyası

Bir yetkili sunucunun sorumlu olduğu kayıtlar bütününe **bölge (zone)** denir. Bölgenin
metin biçiminde yazılışına **bölge dosyası** adı verilir; her satır bir kayıttır.

`ornek.test` adının bölgesi şöyle görünebilir:

```
ornek.test.         3600  IN  A      192.0.2.10
ornek.test.         3600  IN  AAAA   2001:db8::10
www.ornek.test.     3600  IN  CNAME  ornek.test.
ornek.test.         3600  IN  MX     10 posta.ornek.test.
posta.ornek.test.   3600  IN  A      192.0.2.20
ornek.test.          600  IN  TXT    "dogrulama=abc123"
ornek.test.        86400  IN  NS     ad1.ornek.test.
```

Satırların hepsi aynı beş alanlı düzeni izler. Aşağıdaki program bunu doğrular: satırları
alanlarına ayırır ve tür alanına göre yeniden yazar.

```python
BOLGE = """\
ornek.test.         3600  IN  A      192.0.2.10
ornek.test.         3600  IN  AAAA   2001:db8::10
www.ornek.test.     3600  IN  CNAME  ornek.test.
ornek.test.         3600  IN  MX     10 posta.ornek.test.
posta.ornek.test.   3600  IN  A      192.0.2.20
ornek.test.          600  IN  TXT    "dogrulama=abc123"
ornek.test.        86400  IN  NS     ad1.ornek.test.
"""


def kaydi_coz(satir: str) -> tuple[str, int, str, str, str]:
    ad, ttl, sinif, tur, *veri = satir.split()
    return ad, int(ttl), sinif, tur, " ".join(veri)


for satir in BOLGE.strip().splitlines():
    ad, ttl, sinif, tur, veri = kaydi_coz(satir)
    print(f"{tur:<6} ad={ad:<18} ttl={ttl:<6} veri={veri}")

print()
turler = sorted({kaydi_coz(s)[3] for s in BOLGE.strip().splitlines()})
print("bolgedeki tur sayisi:", len(turler))
print("turler:", turler)
```

```
A      ad=ornek.test.        ttl=3600   veri=192.0.2.10
AAAA   ad=ornek.test.        ttl=3600   veri=2001:db8::10
CNAME  ad=www.ornek.test.    ttl=3600   veri=ornek.test.
MX     ad=ornek.test.        ttl=3600   veri=10 posta.ornek.test.
A      ad=posta.ornek.test.  ttl=3600   veri=192.0.2.20
TXT    ad=ornek.test.        ttl=600    veri="dogrulama=abc123"
NS     ad=ornek.test.        ttl=86400  veri=ad1.ornek.test.

bolgedeki tur sayisi: 6
turler: ['A', 'AAAA', 'CNAME', 'MX', 'NS', 'TXT']
```

Ayrıştırıcının tüm türler için aynı olması, tasarımın bir özelliğidir: tür alanı yalnızca
veri alanının nasıl yorumlanacağını belirtir, kaydın çerçevesini değiştirmez. Yeni bir tür
tanımlamak, var olan sunucuların kaydı taşımasını engellemez.

Kaydın adı ile aranan ad arasındaki ilişkiye dikkat edilmelidir: bir bölgede aynı ada ait
birden çok kayıt bulunabilir. Sorgu, ad **ve** tür ikilisiyle yapılır.

#### Adres Kayıtları

`A` kaydı bir IPv4 adresi, `AAAA` kaydı bir IPv6 adresi taşır. İkisi ayrı türlerdir ve bir
ad ikisine birden sahip olabilir; yukarıdaki bölgede `ornek.test` için ikisi de tanımlıdır.

Bir ada birden çok adres kaydı verilebilir. Bu durumda çözümleyici hepsini döndürür ve
istemci birini seçer. Bu, istekleri birden çok sunucuya dağıtmanın en yalın yoludur.

Yöntemin sınırı belirgindir: alan adı sistemi, adreslerin hangisinin çalışır durumda
olduğunu bilmez. Bir sunucu arızalandığında kaydı elle kaldırılana kadar dağıtıma dahil
kalır ve kaldırıldıktan sonra da önbelleklerde yaşam süresi kadar yaşamayı sürdürür.
Önceki derste kurulan yaşam süresi ödünleşiminin doğrudan sonucudur bu.

#### Takma Ad Kayıtları

`CNAME` kaydı bir adresi değil, **başka bir adı** gösterir. `www.ornek.test` sorulduğunda
yanıt "bu adın karşılığı `ornek.test` adıdır" olur ve çözümleyici aramayı o ad üzerinden
sürdürür.

Kullanım gerekçesi, önceki derste kurulan dolaylılık fikrinin bir katman daha
uygulanmasıdır: adres bir yerde tanımlanır, diğer adlar oraya bağlanır. Adres
değiştiğinde tek bir kayıt güncellenir.

Bu türün iki kısıtı vardır ve ikisi de aynı nedenden gelir: takma ad kaydı, adın
**tamamını** başka bir ada devreder.

**Aynı adda başka kayıt bulunamaz.** Bir ad için takma ad kaydı varsa, o ad için başka
türde kayıt tanımlanamaz. Tanımlanabilseydi çelişki doğardı: ad hem "karşılığım şu addır"
hem de "adresim şudur" derdi.

**Bölgenin kök adında kullanılamaz.** `ornek.test` adının kendisi takma ad olamaz, çünkü o
adda zaten bulunması zorunlu olan kayıtlar vardır — aşağıda ele alınan yetki ve ad sunucusu
kayıtları. Birinci kısıt gereği bunlar takma adla bir arada duramaz.

Bu ikinci kısıt işletmede sık karşılaşılan bir engeldir: `www.ornek.test` adı bir
sağlayıcının adına takma adla bağlanabilirken, `ornek.test` adı için aynı şey yapılamaz ve
oraya doğrudan bir adres kaydı yazmak gerekir.

#### Posta Kayıtları

`MX` kaydı, o alan adına gönderilen postanın hangi sunucuya teslim edileceğini söyler.
Veri alanı iki parçadır: bir öncelik sayısı ve bir sunucu adı.

```
ornek.test.         3600  IN  MX     10 posta.ornek.test.
```

Öncelik sayısı **küçükse tercih edilir**. Birden çok posta kaydı tanımlandığında gönderen
taraf en küçük sayılı sunucuyu dener, ulaşamazsa sıradakine geçer. Sayının kendisi bir
anlam taşımaz; yalnızca sıralama içindir.

Bu kaydın varlığı önemli bir ayrımı gösterir: bir alan adının web trafiği ile posta trafiği
farklı sunuculara gidebilir. `ornek.test` sayfası `192.0.2.10` adresinden gelirken, aynı
adın postası `posta.ornek.test` üzerinden `192.0.2.20` adresine teslim edilir. Alan adı bir
makineyi değil, bir **yönetim alanını** adlandırır.

Posta kaydının işaret ettiği ad bir takma ad olmamalı, doğrudan adres kaydı taşımalıdır.

#### Ad Sunucusu ve Yetki Kayıtları

`NS` kaydı, bir bölgenin yetkisinin hangi sunuculara ait olduğunu bildirir. Önceki dersteki
çözümleme zincirinde her adımda alınan "şuna sor" yanıtı, tam olarak bu kayıttır.

Bu kayıt iki yerde birden bulunur: bölgenin kendisinde ve bir üst düzeydeki bölgede. Üst
düzeydeki kopya, yetkinin devredildiğini gösteren kayıttır; önceki derste anlatılan kayıt
sırasında kayıt kuruluşuna bildirilen budur. İki kopyanın uyuşmaması, çözümlemede güç
saptanan tutarsızlıklara yol açar.

Her bölgede ayrıca bir `SOA` kaydı bulunur. Bu kayıt bölgenin yönetsel bilgilerini taşır:
birincil ad sunucusu, sorumlu adres, bölgenin sürüm numarası ve ikincil sunucuların
kopyalarını ne sıklıkta yenileyeceğini belirleyen süreler. Sürüm numarası, ikincil
sunucuların bölgenin değişip değişmediğini anlamasını sağlar.

#### Metin Kayıtları

`TXT` kaydı serbest metin taşır. Belirli bir işlevi yoktur; bu yüzden bir adın sahibi
olduğunu kanıtlamak isteyen düzenler için ortak bir araç durumundadır.

Kullanım kalıbı şudur: bir hizmet, ad sahibinden bölgesine belirli bir metni koymasını
ister. Metin göründüğünde, o adın yönetimine erişimi olduğu kanıtlanmış olur. Bu, önceki
derste kurulan yetki devrine dayanır — bölgeye kayıt yazabilen, o adın yetkilisidir.

Posta doğrulama düzenleri de bu kayıt türü üzerinden çalışır ve belirli bir sözdizimi
izleyen metinler yazar. Bu düzenlerin ayrıntısı Uygulama Katmanı Protokolleri kursunun
konusudur.

#### Tür Seçimi

| Tür | Yanıtladığı soru |
|---|---|
| `A` | Bu adın IPv4 adresi nedir |
| `AAAA` | Bu adın IPv6 adresi nedir |
| `CNAME` | Bu ad hangi adın yerine geçiyor |
| `MX` | Bu adın postası nereye teslim edilir |
| `NS` | Bu bölgenin yetkisi kimde |
| `SOA` | Bu bölgenin yönetsel bilgileri neler |
| `TXT` | Bu ada iliştirilmiş serbest metin nedir |

Bir bölge tasarlarken izlenen sıra buradan çıkar: yetki kayıtları bölgenin var olması için
zorunludur, adres kayıtları hizmetin ulaşılabilirliği için gereklidir, takma ad kayıtları
bakımı azaltır, posta ve metin kayıtları ise alan adına bağlı diğer hizmetleri tanımlar.

#### Özet

- Bölge, bir yetkili sunucunun sorumlu olduğu kayıtlar bütünüdür; her kayıt aynı beş
  alanlı düzeni izler ve tür alanı yalnızca veri alanının yorumunu belirler.
- `A` ve `AAAA` adres taşır; bir ada birden çok adres verilerek istekler dağıtılabilir,
  ancak sistem sunucuların sağlığını bilmez.
- `CNAME` adı başka bir ada devreder; aynı adda başka kayıt bulunamayacağı için bölgenin
  kök adında kullanılamaz.
- `MX` postanın teslim edileceği sunucuyu öncelik sırasıyla bildirir; bir alan adının web
  ve posta trafiği farklı sunuculara gidebilir.
- `NS` yetkiyi bildirir ve hem bölgede hem üst düzeyde bulunur; `SOA` bölgenin yönetsel
  bilgilerini taşır.
- `TXT` serbest metin taşır ve ad üzerindeki yetkiyi kanıtlamak için kullanılır.

#### Sonraki Adım

Bu ders `ornek.test` adının `192.0.2.10` adresini gösterdiğini kayıt düzeyinde kurdu.
Geriye o adreste ne olduğu sorusu kalır: orada sürekli çalışan, isteği bekleyen bir makine
bulunmalıdır. Sonraki ders bu makinenin nasıl sağlandığını, aynı adresin birden çok alan
adına nasıl hizmet verebildiğini ve barındırma seçenekleri arasındaki ödünleşimleri ele
alacak.

### Barındırma Modelleri

Source: https://academia.sh/tr/kurslar/internet-nasil-calisir/barindirma-modelleri

Sunucunun sürekli çalışması gerekliliği, ada dayalı sanal barındırmanın işleyişi ve paylaşımlı, sanal, adanmış ve yönetilen modeller arasındaki ödünleşimler.

Önceki ders `ornek.test` adının `192.0.2.10` adresini gösterdiğini kurdu. Geriye şu soru
kalır: o adreste ne vardır?

Yanıt, İstemci–Sunucu Modeli dersinde yazılan programın bir benzeridir: bir bağlantı
noktasında bekleyen, isteği alıp yanıtlayan bir süreç. Bu ders, o sürecin nerede ve nasıl
çalıştırıldığını ele alır.

#### Barındırmanın Çözdüğü Sorun

Sunucu programının çalışması için üç koşulun sağlanması gerekir; üçü de daha önceki
derslerde ayrı ayrı kurulmuştu.

**Kararlı ve erişilebilir bir adres.** IP Adresi Kavramı dersinde görüldüğü gibi özel
adresli bir makineye dışarıdan bağlanılamaz ve otomatik atanan adresler değişir. Sunucunun
genel ve değişmeyen bir adrese gereksinimi vardır.

**Sürekli çalışma.** İstemci–Sunucu Modeli dersinde kurulduğu üzere sunucu, isteğin ne
zaman geleceğini bilmez; her an dinliyor olmalıdır. Bu, makinenin kapanmaması, ağ
bağlantısının kesilmemesi ve sürecin çökerse yeniden başlatılması demektir.

**İşletme.** Donanımın arızalanması, yazılımın güncellenmesi, yedeklerin alınması ve
yükün artması ele alınmalıdır.

**Barındırma (hosting)**, bu üç koşulun bir hizmet olarak sağlanmasıdır. Bir kuruluşun
kendi binasında sürekli çalışan bir makine bulundurması da barındırmadır; aradaki fark
koşulları kimin karşıladığıdır.

#### Bir Adres, Birden Çok Ad

Barındırmanın işletilebilir olmasının teknik dayanağı, bir adresin birden çok alan adına
hizmet verebilmesidir. Adresler sınırlı bir kaynaktır; her alan adı için ayrı bir adres
gerekseydi maliyet çok yüksek olurdu.

Sorun şudur: paket adrese gelir, adres tek bir makineyi gösterir. Sunucu, isteğin hangi
alan adı için yapıldığını nereden bilecektir?

Yanıt, isteğin kendisinde taşınır. İstemci, bağlandığı adı isteğin içinde `Host` başlığıyla
bildirir. İstemci–Sunucu Modeli dersindeki çıktıda bu satır zaten görünmüştü:

```
> GET / HTTP/1.1
> Host: ornek.test:8080
```

Sunucu bu başlığa bakarak hangi siteyi sunacağına karar verir. Bu düzene **ada dayalı
sanal barındırma (name-based virtual hosting)** denir.

Aşağıdaki sunucu tek bir adres ve bağlantı noktasında dinler, ancak iki ayrı site sunar:

```python
# barinma_sunucusu.py
from http.server import BaseHTTPRequestHandler, HTTPServer

SITELER: dict[str, bytes] = {
    "ornek.test": b"<h1>Ornek Sitesi</h1>\n",
    "deneme.test": b"<h1>Deneme Sitesi</h1>\n",
}


class Isleyici(BaseHTTPRequestHandler):
    protocol_version = "HTTP/1.1"

    def log_message(self, bicem: str, *arg: object) -> None:
        pass

    def do_GET(self) -> None:
        ad = self.headers.get("Host", "").split(":")[0]
        govde = SITELER.get(ad, b"<h1>Bilinmeyen konak</h1>\n")
        durum = 200 if ad in SITELER else 404
        self.send_response_only(durum)
        self.send_header("Content-Type", "text/html; charset=utf-8")
        self.send_header("Content-Length", str(len(govde)))
        self.end_headers()
        self.wfile.write(govde)


HTTPServer(("127.0.0.1", 8080), Isleyici).serve_forever()
```

Sunucu çalışırken üç istek yapılır. Üçü de aynı adrese gider; yalnızca bildirilen ad
değişir. Aşağıdaki komutlar tek parça çalışır: sunucu arka planda başlatılır, `until`
döngüsü sunucu bağlantı kabul edene kadar bekler ve sunucu en sonda kapatılır. Sunucuyu ayrı
bir uçbirimde çalıştırırsanız yalnızca `curl` satırlarını yazmanız yeter.

```sh
python3 barinma_sunucusu.py &
until curl -s -o /dev/null 127.0.0.1:8080; do sleep 0.05; done
curl -s --resolve ornek.test:8080:127.0.0.1  http://ornek.test:8080/
curl -s --resolve deneme.test:8080:127.0.0.1 http://deneme.test:8080/
curl -s --resolve baska.test:8080:127.0.0.1  http://baska.test:8080/
kill $!; wait $! 2>/dev/null
```

```
<h1>Ornek Sitesi</h1>
<h1>Deneme Sitesi</h1>
<h1>Bilinmeyen konak</h1>
```

Üç istek `127.0.0.1` adresinin 8080 numaralı bağlantı noktasına gitti ve üç farklı yanıt
aldı. Ayrımı yapan tek şey `Host` başlığıydı.

Bunun iki sonucu vardır. Birincisi, bir adresi paylaşan siteler birbirini adres düzeyinde
göremez; ayrım sunucu programının içinde yapılır. İkincisi, bu başlık zorunludur: bildirmeyen
bir istemci, sunucunun hangi siteyi sunacağını belirlemesini olanaksız kılar.

#### Barındırma Modelleri

Üç koşulun kimin tarafından ve hangi düzeyde karşılandığı, modelleri ayırır.

##### Paylaşımlı Barındırma

Bir makine, çok sayıda müşterinin sitesini aynı işletim sistemi üzerinde çalıştırır.
Yukarıdaki sanal barındırma düzeni doğrudan bu modelin temelidir.

Kaynaklar paylaşıldığı için maliyeti en düşük modeldir ve işletme yükünün tamamı
sağlayıcıdadır. Bedeli yalıtımın zayıflığıdır: bir sitenin tükettiği kaynak, aynı makinedeki
diğer siteleri etkiler. Yapılandırma seçenekleri sağlayıcının izin verdiğiyle sınırlıdır;
işletim sistemi düzeyinde denetim yoktur.

##### Sanal Özel Sunucu

Bir fiziksel makine, sanallaştırma yoluyla birbirinden yalıtılmış birden çok sanal makineye
bölünür. Her müşteri kendi işletim sistemine ve kendi yönetici yetkisine sahiptir.

Kaynaklar tanımlı sınırlarla ayrıldığı için komşu etkisi belirgin biçimde azalır; yazılım
seçimi ve yapılandırma müşterinin denetimindedir. Buna karşılık işletim sisteminin bakımı,
güvenlik güncellemeleri ve yedekleme müşterinin sorumluluğuna geçer.

Yalıtımın nasıl sağlandığı — ad alanları, denetim grupları ve sanallaştırma — Çekirdek
Arayüzleri ve İzolasyon kursunun kapsamındadır.

##### Adanmış Sunucu

Fiziksel makinenin tamamı tek bir müşteriye ayrılır. Kaynak paylaşımı yoktur; donanım
seçimi ve başarım öngörülebilirliği en yüksek düzeydedir.

Maliyet, kullanılsın kullanılmasın makinenin tamamı için ödenir. Donanım arızasının
etkisi doğrudandır ve yedeklilik ayrıca kurulmalıdır.

##### Yönetilen Barındırma

Ayırıcı ölçüt donanım değil, **sorumluluğun sınırıdır.** Yönetilen bir modelde sağlayıcı
yalnızca makineyi değil, üzerindeki yazılımın işletimini de üstlenir: güncelleme,
yedekleme, izleme ve ölçekleme.

Müşteri, yapılandırma özgürlüğünün bir bölümünden vazgeçerek işletme yükünden kurtulur. Bu
model diğer üçüyle aynı eksende değildir; bir sanal özel sunucu da adanmış bir sunucu da
yönetilen biçimde sunulabilir.

##### Karşılaştırma

| Ölçüt | Paylaşımlı | Sanal özel | Adanmış | Yönetilen |
|---|---|---|---|---|
| Yalıtım | Zayıf | Tanımlı sınırlarla | Tam | Modele bağlı |
| Yönetici yetkisi | Yok | Var | Var | Sınırlı |
| İşletme yükü | Sağlayıcıda | Müşteride | Müşteride | Sağlayıcıda |
| Başarım öngörülebilirliği | Düşük | Orta | Yüksek | Modele bağlı |
| Göreli maliyet | En düşük | Orta | En yüksek | Hizmete bağlı |

Ölçütlerin hiçbirinde tek bir seçenek üstün değildir. Seçim, sitenin gereksinimleri ile
işletmeye ayrılabilecek emek arasındaki dengeye bağlıdır.

#### Durağan ve Devingen İçerik

Barındırma gereksinimini belirleyen bir ayrım da içeriğin nasıl üretildiğidir.

**Durağan içerikte** sunucu, diskteki bir dosyayı olduğu gibi gönderir. Her istek aynı
yanıtı üretir. Bu tür içerik hesaplama gerektirmez ve çoğaltılması ucuzdur.

**Devingen içerikte** yanıt, istek geldiğinde hesaplanır: veritabanı sorgulanır, kullanıcıya
özel bölümler üretilir. Her istek işlemci ve bellek tüketir; ölçeklenmesi durağan içerikten
belirgin biçimde güçtür.

Bu ayrım bir yerleştirme kararına yol açar. Durağan içerik, kullanıcılara yakın konumlara
dağıtılmış sunucularda çoğaltılabilir. Bu düzende bir kullanıcının isteği kendisine en yakın
kopyaya gider; gecikme, Ağ Nedir dersinde kurulduğu üzere yayılma mesafesiyle sınırlı
olduğundan kazanç doğrudandır. Devingen içerik ise durumun tutulduğu yere bağlı kalır ve bu
biçimde çoğaltılamaz.

Bu yüzden pratikte iki içerik türü ayrılır: sayfanın değişmeyen bölümleri dağıtılmış
kopyalardan, kullanıcıya özel bölümleri kaynak sunucudan gelir.

#### Özet

- Barındırma, sunucu programı için kararlı bir adres, sürekli çalışma ve işletme
  koşullarını sağlar.
- Ada dayalı sanal barındırma, isteğin `Host` başlığına bakarak tek bir adreste birden çok
  siteyi sunar; ayrım adres düzeyinde değil sunucu programının içinde yapılır.
- Paylaşımlı barındırma en düşük maliyet ve en zayıf yalıtımı, adanmış sunucu tersini
  verir; sanal özel sunucu ikisinin arasındadır.
- Yönetilen barındırma donanımla değil sorumluluğun sınırıyla tanımlanır ve diğer
  modellerin üzerine uygulanabilir.
- Durağan içerik çoğaltılarak kullanıcıya yaklaştırılabilir; devingen içerik durumun
  tutulduğu yere bağlıdır.

#### Sonraki Adım

Bu konu, adres satırına yazılan adın nasıl bir sunucuya vardığını baştan sona kurdu: ad
yapısı, çözümleme zinciri, kayıtlar ve o adresteki makine. Buna karşın sunucuya varıldıktan
sonra ne söylendiği hep aynı iki satırla geçiştirildi. Sonraki konu o alışverişin kendisini
açar: isteğin ve yanıtın hangi parçalardan oluştuğunu, durum kodlarının ne bildirdiğini ve
sunucunun istekler arasında neden hiçbir şey anımsamadığını ele alacak.

## Web İsteğinin Yolculuğu

HTTP istek ve yanıtının parçaları, tarayıcının istekten çizime uzanan aşamaları, HTTPS'in verdiği sözler ve tüm zincirin uçtan uca birleştirilmesi.

### HTTP İstek ve Yanıtı

Source: https://academia.sh/tr/kurslar/internet-nasil-calisir/http-istek-ve-yaniti

İsteğin ve yanıtın parçaları, yöntemlerin güvenlik ve etkisizlik özellikleri, durum kodu sınıfları ve protokolün durumsuzluğu.

Önceki konu, adres satırına yazılan adın nasıl bir sunucuya vardığını kurdu. İstemci–Sunucu
Modeli dersinde bu sunucuya bağlanılmış ve alışverişin iki ucu da görülmüştü. Ancak
gönderilen metnin neden o biçimde olduğu açıklanmadı.

Bu ders o biçimi tanımlar. **HTTP**, istemci ile sunucu arasındaki alışverişin kurallarını
belirleyen protokoldür ve web'in üzerine kurulduğu sözleşmedir.

#### Metin Tabanlı Bir Protokol

İstemci–Sunucu Modeli dersindeki sunucu, aldığı baytları olduğu gibi ekrana yazmıştı:

```
GET / HTTP/1.1
Host: ornek.test:8080
User-Agent: ornek-istemci
Accept: */*

```

Bu, ikilik bir yapı değil, okunabilir bir metindir. Tasarımın bu yönde olması bir seçimdir
ve bedeli vardır: metin gösterimi, aynı bilgiyi ikilik gösterimden daha çok baytla taşır ve
ayrıştırılması daha pahalıdır. Karşılığında protokol, özel bir araç gerekmeden incelenebilir
ve genişletilebilir olur; yeni bir başlık eklemek var olan gerçekleştirimleri bozmaz.

Satır sonları `\r\n` iki karakteriyle yazılır. Başlıkların bittiğini gösteren şey, boş bir
satırdır — yukarıdaki çıktının sonundaki boşluk budur.

#### İsteğin Yapısı

Bir istek üç bölümden oluşur.

**İstek satırı**, ilk satırdır ve üç alan taşır: yöntem, hedef, sürüm.

```
GET / HTTP/1.1
```

`GET` yapılacak işlemi, `/` istenen kaynağın yolunu, `HTTP/1.1` istemcinin konuştuğu
protokol sürümünü bildirir. Hedefin yalnızca yol bölümü yazılır; alan adı ayrı bir
başlıkta taşınır.

**Başlıklar**, her satırda bir `ad: değer` çifti taşır. Başlık adları büyük–küçük harf
ayrımı gözetmez. Yukarıdaki üç başlığın işlevleri farklıdır: `Host` hangi siteye
bağlanıldığını bildirir ve Barındırma Modelleri dersinde görüldüğü gibi sanal barındırmanın
dayanağıdır; `User-Agent` istemciyi tanıtır; `Accept` istemcinin hangi içerik biçimlerini
işleyebildiğini söyler.

**Gövde**, boş satırdan sonra gelen isteğe bağlı veridir. `GET` isteklerinde genellikle
bulunmaz; veri gönderen yöntemlerde bulunur.

#### Yanıtın Yapısı

Yanıt aynı düzeni izler, yalnızca ilk satırı farklıdır.

```
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 73
Connection: close

<!doctype html>
<html lang="tr"><body><h1>Ornek Sayfa</h1></body></html>
```

**Durum satırı** sürümü, sayısal durum kodunu ve okunabilir açıklamasını taşır. Açıklama
metni bilgilendirme amaçlıdır; kararlar sayıya göre verilir.

`Content-Length` başlığı gövdenin kaç bayt olduğunu bildirir. Bu başlık bir ayrıntı değil,
protokolün işlemesi için zorunlu bir bilgidir: alıcının gövdenin nerede bittiğini bilmesi
gerekir. Bağlantı bir bayt akışıdır ve akışta doğal bir sınır yoktur. Uzunluk önceden
bilinmiyorsa gövde parçalar hâlinde, her parçanın başında boyu yazılarak gönderilir.

`Content-Type` gövdenin nasıl yorumlanacağını söyler. Buradaki `charset=utf-8` bölümü,
Bilgisayarlar Nasıl Çalışır kursundaki karakter kodlamaları dersinde kurulan soruyu
yanıtlar: baytların hangi kurala göre karakterlere çevrileceği alıcının tahminine
bırakılmaz, açıkça bildirilir.

#### Yöntemler

Yöntem, kaynak üzerinde yapılacak işlemi bildirir. Yöntemleri ayıran iki özellik vardır ve
bu özellikler istemcilerin davranışını belirler.

**Güvenli (safe)** bir yöntem sunucuda değişiklik yapmaz; yalnızca okur. **Etkisiz
(idempotent)** bir yöntem, bir kez ya da birden çok kez uygulandığında aynı sonucu bırakır.
Her güvenli yöntem etkisizdir; tersi doğru değildir.

| Yöntem | İşlevi | Güvenli | Etkisiz |
|---|---|---|---|
| `GET` | Kaynağı getirir | Evet | Evet |
| `HEAD` | Yalnızca başlıkları getirir | Evet | Evet |
| `POST` | Veri gönderir, yeni kaynak oluşturabilir | Hayır | Hayır |
| `PUT` | Kaynağı verilen içerikle değiştirir | Hayır | Evet |
| `DELETE` | Kaynağı siler | Hayır | Evet |

Bu özellikler kuramsal değildir. Bir yanıt alınamadığında isteğin yinelenip
yinelenemeyeceği doğrudan buradan çıkar: etkisiz bir istek güvenle tekrarlanabilir,
`POST` isteği tekrarlanırsa aynı işlem iki kez yapılabilir. `DELETE` yöntemi ikinci
çağrıda farklı bir durum kodu döndürse de sunucunun durumu aynı kalır; etkisizlik, dönen
kodun değil bırakılan durumun özelliğidir.

Bu özelliklerin sunucu tarafından **korunması gerekir**; protokol bunu zorlayamaz. Durumu
değiştiren bir `GET` işleyicisi yazmak sözdizimsel olarak olanaklıdır ve protokole
aykırıdır.

`HEAD` yöntemi, `GET` ile aynı başlıkları döndürür ancak gövde göndermez. Bir kaynağın
boyutunu veya varlığını içeriği indirmeden öğrenmek için kullanılır.

#### Durum Kodları

Durum kodu üç basamaklıdır ve ilk basamağı sonucun sınıfını verir.

| Sınıf | Anlamı |
|---|---|
| `1xx` | Bilgilendirme; işlem sürüyor |
| `2xx` | Başarı |
| `3xx` | Yönlendirme; kaynak başka yerde |
| `4xx` | İstemci hatası; istek kusurlu |
| `5xx` | Sunucu hatası; istek geçerliydi ama sunucu yerine getiremedi |

`4xx` ile `5xx` arasındaki ayrım işletme açısından belirleyicidir: birincisi isteği
düzeltmeyi, ikincisi sunucuyu incelemeyi gerektirir.

Aşağıdaki sunucu üç farklı durum kodu üretir ve bir yönlendirme tanımlar:

```python
# yonlendirme_sunucusu.py
from http.server import BaseHTTPRequestHandler, HTTPServer


class Isleyici(BaseHTTPRequestHandler):
    protocol_version = "HTTP/1.1"

    def log_message(self, bicem: str, *arg: object) -> None:
        pass

    def _gonder(self, durum: int, govde: bytes, ek: list[tuple[str, str]] = []) -> None:
        self.send_response_only(durum)
        self.send_header("Content-Type", "text/plain; charset=utf-8")
        self.send_header("Content-Length", str(len(govde)))
        for ad, deger in ek:
            self.send_header(ad, deger)
        self.end_headers()
        self.wfile.write(govde)

    def do_GET(self) -> None:
        if self.path == "/eski":
            self._gonder(301, b"", [("Location", "/yeni")])
        elif self.path == "/yeni":
            self._gonder(200, b"yeni adresteki icerik\n")
        else:
            self._gonder(404, b"bulunamadi\n")

    def do_POST(self) -> None:
        uzunluk = int(self.headers.get("Content-Length", "0"))
        govde = self.rfile.read(uzunluk)
        self._gonder(201, b"alinan govde: " + govde + b"\n")


HTTPServer(("127.0.0.1", 8080), Isleyici).serve_forever()
```

Üç yol sorgulandığında dönen kodlar. Aşağıdaki komutlar tek parça çalışır: sunucu arka
planda başlatılır, `until` döngüsü sunucu bağlantı kabul edene kadar bekler ve sunucu en
sonda kapatılır. Sunucuyu ayrı bir uçbirimde çalıştırırsanız yalnızca `curl` satırlarını
yazmanız yeter; bu dersteki sonraki örneklerde de başlatma ve kapatma satırları aynıdır.

```sh
python3 yonlendirme_sunucusu.py &
until curl -s -o /dev/null 127.0.0.1:8080; do sleep 0.05; done
for yol in /yeni /eski /yok; do
  printf "%-6s " "$yol"
  curl -s -o /dev/null -w "%{http_code}\n" --resolve ornek.test:8080:127.0.0.1 "http://ornek.test:8080$yol"
done
kill $!; wait $! 2>/dev/null
```

```
/yeni  200
/eski  301
/yok   404
```

Yönlendirme yanıtının kendisi incelendiğinde, kaynağın yeni yerinin bir başlıkta
taşındığı görülür:

```sh
python3 yonlendirme_sunucusu.py &
until curl -s -o /dev/null 127.0.0.1:8080; do sleep 0.05; done
curl -sD - -o /dev/null --resolve ornek.test:8080:127.0.0.1 http://ornek.test:8080/eski
kill $!; wait $! 2>/dev/null
```

```
HTTP/1.1 301 Moved Permanently
Content-Type: text/plain; charset=utf-8
Content-Length: 0
Location: /yeni
```

Yanıtın gövdesi boştur; taşınan bilgi `Location` başlığındadır. İstemci bu yanıtı alınca
yeni hedefe ikinci bir istek yapar. `curl` bunu kendiliğinden yapmaz; istendiğinde yapar:

```sh
python3 yonlendirme_sunucusu.py &
until curl -s -o /dev/null 127.0.0.1:8080; do sleep 0.05; done
curl -sL --resolve ornek.test:8080:127.0.0.1 http://ornek.test:8080/eski
kill $!; wait $! 2>/dev/null
```

```
yeni adresteki icerik
```

Tarayıcılar yönlendirmeleri kendiliğinden izler. `301` kodu taşınmanın kalıcı olduğunu
bildirir ve istemcinin eski adresi anımsamamasına izin verir; geçici taşınmalar için ayrı
kodlar vardır ve bu ayrım önemlidir, çünkü kalıcı yönlendirmeler istemcide saklanabilir.

Gövde taşıyan bir istek de aynı düzeni izler:

```sh
python3 yonlendirme_sunucusu.py &
until curl -s -o /dev/null 127.0.0.1:8080; do sleep 0.05; done
curl -s -X POST -d "ad=deneme" --resolve ornek.test:8080:127.0.0.1 http://ornek.test:8080/kayit
kill $!; wait $! 2>/dev/null
```

```
alinan govde: ad=deneme
```

#### Durumsuzluk

HTTP **durumsuz (stateless)** bir protokoldür: sunucu, iki istek arasında istemciye ilişkin
hiçbir şey anımsamaz. Her istek kendi başına, önceki isteklerden bağımsız olarak yorumlanır.

Bu, gözlenebilir bir özelliktir. Aşağıdaki sunucu, isteğin taşıdığı sayacı okur ve bir
artırılmış değeri istemciye geri verir. Komut, sunucuyu `sayac_sunucusu.py` dosyasına yazar:

```sh
cat > sayac_sunucusu.py <<'SON'
from http.server import BaseHTTPRequestHandler, HTTPServer


class Isleyici(BaseHTTPRequestHandler):
    protocol_version = "HTTP/1.1"

    def log_message(self, bicem: str, *arg: object) -> None:
        pass

    def do_GET(self) -> None:
        gelen = self.headers.get("Cookie", "")
        sayac = int(gelen.removeprefix("sayac=")) if gelen.startswith("sayac=") else 0
        govde = f"gorulen sayac: {sayac}\n".encode()
        self.send_response_only(200)
        self.send_header("Content-Type", "text/plain; charset=utf-8")
        self.send_header("Content-Length", str(len(govde)))
        self.send_header("Set-Cookie", f"sayac={sayac + 1}")
        self.end_headers()
        self.wfile.write(govde)


HTTPServer(("127.0.0.1", 8080), Isleyici).serve_forever()
SON
```

Üç istek, aralarında hiçbir şey taşımadan yapılırsa:

```sh
python3 sayac_sunucusu.py &
until curl -s -o /dev/null 127.0.0.1:8080; do sleep 0.05; done
for i in 1 2 3; do curl -s --resolve ornek.test:8080:127.0.0.1 http://ornek.test:8080/; done
kill $!; wait $! 2>/dev/null
```

```
gorulen sayac: 0
gorulen sayac: 0
gorulen sayac: 0
```

Sunucu üç kez de sıfır gördü. Kendisinde hiçbir kayıt tutmuyor.

Aynı üç istek, sunucunun verdiği değeri geri taşıyarak yapılırsa:

```sh
python3 sayac_sunucusu.py &
until curl -s -o /dev/null 127.0.0.1:8080; do sleep 0.05; done
rm -f kavanoz.txt
for i in 1 2 3; do curl -s -b kavanoz.txt -c kavanoz.txt --resolve ornek.test:8080:127.0.0.1 http://ornek.test:8080/; done
kill $!; wait $! 2>/dev/null
```

```
gorulen sayac: 0
gorulen sayac: 1
gorulen sayac: 2
```

Sunucu kodu değişmedi. Değişen tek şey, istemcinin `Set-Cookie` ile verilen değeri
saklayıp bir sonraki istekte `Cookie` başlığıyla geri göndermesidir. Durum sunucuda değil,
**istekte** taşınmaktadır.

Durumsuzluğun gerekçesi ölçeklenmedir. Sunucu istemciye özel bir bellek tutmadığı için,
ardışık iki istek farklı makineler tarafından yanıtlanabilir; sunucu çökerse
yeniden başlatıldığında kaybolan bir oturum durumu olmaz. Bedeli, her isteğin kendini
tanıtmak için gereken bilgiyi yeniden taşımasıdır.

#### Özet

- HTTP metin tabanlı bir protokoldür; ayrıştırma maliyeti karşılığında incelenebilirlik ve
  genişletilebilirlik sağlar.
- İstek, istek satırı, başlıklar, boş satır ve isteğe bağlı gövdeden oluşur; yanıt aynı
  düzeni durum satırıyla izler.
- `Content-Length`, bayt akışında gövdenin nerede bittiğini bildirdiği için zorunludur;
  `Content-Type` baytların nasıl yorumlanacağını söyler.
- Yöntemler güvenli ve etkisiz olma özellikleriyle ayrılır; bu özellikler bir isteğin
  yinelenip yinelenemeyeceğini belirler ve sunucu tarafından korunmalıdır.
- Durum kodunun ilk basamağı sınıfı verir; `4xx` isteğin, `5xx` sunucunun düzeltilmesini
  gerektirir.
- Protokol durumsuzdur; oturum sürekliliği sunucunun belleğiyle değil, istemcinin her
  istekte geri taşıdığı verilerle kurulur.

#### Sonraki Adım

Bu ders tek bir isteği ve tek bir yanıtı inceledi. Oysa bir sayfa açıldığında yalnızca bir
istek yapılmaz: gelen belge başka kaynaklara başvurur ve her biri ayrıca istenir. Sonraki
ders, adres satırına yazılan metinden ekrandaki çizime uzanan aşamaları ele alacak ve bu
ek isteklerin nasıl ortaya çıktığını gerçek bir sunucunun kayıtları üzerinden gösterecek.

### Tarayıcı Ne Yapar

Source: https://academia.sh/tr/kurslar/internet-nasil-calisir/tarayici-ne-yapar

Adres satırındaki metnin çözümlenmesinden ekrandaki çizime uzanan aşamalar, alt kaynak istekleri ve bağlantıların yeniden kullanımı.

Önceki ders tek bir isteği ve tek bir yanıtı inceledi. Buna karşın bir sayfa açıldığında
tek bir istek yapılmaz. Gelen belge başka kaynaklara başvurur ve tarayıcı onları da ister.

Bu ders tarayıcının işini sırasıyla ele alır: adres satırındaki metnin çözümlenmesinden
ekrandaki çizime kadar. Tarayıcı bir görüntüleyici değil, bu aşamaları yürüten bir
düzenleyicidir.

#### Adresin Çözümlenmesi

İlk iş, yazılan metni bölümlerine ayırmaktır. Bir adres tek bir dizgi değil, yapılı bir
değerdir.

```python
from urllib.parse import urlsplit

adres = "https://ornek.test:8443/arsiv/belge?konu=ag&sayfa=2#bolum3"
parca = urlsplit(adres)

print("sema      :", parca.scheme)
print("konak     :", parca.hostname)
print("bag. nok. :", parca.port)
print("yol       :", parca.path)
print("sorgu     :", parca.query)
print("parca     :", parca.fragment)
```

```
sema      : https
konak     : ornek.test
bag. nok. : 8443
yol       : /arsiv/belge
sorgu     : konu=ag&sayfa=2
parca     : bolum3
```

Bölümlerin her biri farklı bir aşamada kullanılır:

| Bölüm | Kullanıldığı yer |
|---|---|
| Şema | Hangi protokolün konuşulacağı; bağlantı noktası varsayılanını da belirler |
| Konak | Alan Adı Sistemi dersindeki çözümlemeye verilen ad |
| Bağlantı noktası | Bağlantı kurulurken; yazılmazsa şemanın varsayılanı |
| Yol | İstek satırına konur, sunucuya gönderilir |
| Sorgu | İstek satırına yolla birlikte konur, sunucuya gönderilir |
| Parça | **Sunucuya gönderilmez**; yalnızca tarayıcıda kullanılır |

Son satır dikkat çekicidir. `#bolum3` bölümü ağa hiç çıkmaz; tarayıcı belgeyi aldıktan
sonra o adı taşıyan bölüme kaydırmak için kendisi kullanır. Sunucu bu değeri göremez.

Adın büyük–küçük harf ayrımı gözetmediği Alan Adı Nedir dersinde belirtilmişti. Yol bölümü
için aynı şey geçerli değildir: `/Arsiv` ile `/arsiv` farklı iki yol olabilir ve bunu
belirleyen sunucudur.

#### Aşamalar

Adres çözümlendikten sonra tarayıcı şu adımları izler:

1. **Ad çözümleme.** Konak adı bir adrese çevrilir. Alan Adı Sistemi dersindeki zincir
   burada işler ve önbellekler devreye girer.
2. **Bağlantı kurma.** Hedef adres ve bağlantı noktasına bağlanılır.
3. **Güvenlik el sıkışması.** Şema `https` ise şifreli kanal kurulur; sonraki dersin
   konusudur.
4. **İstek gönderme.** Önceki derste tanımlanan biçimde istek yazılır.
5. **Yanıt alma ve yorumlama.** Durum kodu ve `Content-Type` başlığına göre gövdenin ne
   olduğu belirlenir.
6. **Belgeyi ayrıştırma.** İçerik bir belgeyse yapısı çıkarılır.
7. **Alt kaynakları isteme.** Belgenin başvurduğu her kaynak için 1–5 adımları yinelenir.
8. **Yerleşim ve çizim.** Öğelerin ekrandaki yeri ve görünümü hesaplanır, çizilir.

Adımların bir bölümü örtüşür. Tarayıcı belgenin tamamını beklemeden ayrıştırmaya başlar ve
gördüğü ilk alt kaynak başvurusunda isteği yollar.

#### Alt Kaynak İstekleri

Yedinci adım, açılan bir sayfanın neden tek bir isteğe indirgenemeyeceğini açıklar.
Aşağıdaki sunucu üç kaynak sunar; kök belge diğer ikisine başvurur. Komut, sunucuyu
`alt_kaynak_sunucusu.py` dosyasına yazar.

```sh
cat > alt_kaynak_sunucusu.py <<'SON'
from http.server import BaseHTTPRequestHandler, HTTPServer

SAYFALAR: dict[str, tuple[str, bytes]] = {
    "/": ("text/html; charset=utf-8",
          b"<!doctype html>\n<html lang=\"tr\">\n"
          b"<head><link rel=\"stylesheet\" href=\"/bicem.css\"></head>\n"
          b"<body><h1>Ornek Sayfa</h1><img src=\"/logo.svg\" alt=\"\"></body>\n"
          b"</html>\n"),
    "/bicem.css": ("text/css; charset=utf-8", b"h1 { color: #333; }\n"),
    "/logo.svg": ("image/svg+xml",
                  b"<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"8\" height=\"8\"></svg>\n"),
}


class Isleyici(BaseHTTPRequestHandler):
    protocol_version = "HTTP/1.1"

    def log_message(self, bicem: str, *arg: object) -> None:
        print(f"{self.command} {self.path} -> {arg[1]}", flush=True)

    def _yanitla(self, durum: int, tip: str, govde: bytes, govde_gonder: bool) -> None:
        self.send_response_only(durum)
        self.send_header("Content-Type", tip)
        self.send_header("Content-Length", str(len(govde)))
        self.end_headers()
        if govde_gonder:
            self.wfile.write(govde)

    def _dagit(self, govde_gonder: bool) -> None:
        if self.path in SAYFALAR:
            tip, govde = SAYFALAR[self.path]
            self.log_request(200)
            self._yanitla(200, tip, govde, govde_gonder)
        else:
            govde = b"<h1>404 Bulunamadi</h1>\n"
            self.log_request(404)
            self._yanitla(404, "text/html; charset=utf-8", govde, govde_gonder)

    def do_GET(self) -> None:
        self._dagit(govde_gonder=True)

    def do_HEAD(self) -> None:
        self._dagit(govde_gonder=False)


HTTPServer(("127.0.0.1", 8080), Isleyici).serve_forever()
SON
```

Bir tarayıcının yapacağı üç istek, `curl` ile açıkça yapılır. Aşağıdaki komutlar tek parça
çalışır: sunucu arka planda başlatılır, `until` döngüsü sunucuya bağlanıp hiçbir şey
göndermeden kapatarak dinlemeye geçtiğini sınar ve sunucu en sonda kapatılır. Döngü bir HTTP
isteği göndermediği için sunucu kaydına girmez. Sunucuyu ayrı bir uçbirimde çalıştırırsanız
yalnızca `curl` satırını yazmanız yeter. Yanıt gövdeleri ekrana basılmaz (`> /dev/null`);
`curl`'ün `*`, `>`, `<` satırları ise stderr'e gider, sunucunun kaydıyla karışık görünür ve
sonraki bölümde incelenir.

```bash
python3 alt_kaynak_sunucusu.py &
until (exec 3<>/dev/tcp/127.0.0.1/8080) 2>/dev/null; do sleep 0.05; done
curl -sv --resolve ornek.test:8080:127.0.0.1 -A "ornek-istemci" \
  http://ornek.test:8080/ http://ornek.test:8080/bicem.css http://ornek.test:8080/logo.svg > /dev/null
kill $!; wait $! 2>/dev/null
```

Sunucunun kaydı üç isteği gösterir:

```
GET / -> 200
GET /bicem.css -> 200
GET /logo.svg -> 200
```

Kullanıcı tek bir adres yazdı; sunucu üç istek gördü. Gerçek sayfalarda bu sayı çok daha
yüksektir ve alt kaynaklar başka alan adlarında bulunabilir — bu durumda her yeni alan adı
için ad çözümleme ve bağlantı kurma adımları yeniden yürütülür.

#### Bağlantıların Yeniden Kullanımı

Her istek için ayrı bir bağlantı kurmak pahalıdır. Bağlantı kurmak en az bir gidiş–dönüş
süresi gerektirir; şifreli bağlantıda daha fazlası. Ağ Nedir dersinde kurulduğu üzere
gecikmenin bir bölümü fiziksel olarak azaltılamaz, dolayısıyla gidiş–dönüş sayısını azaltmak
doğrudan bir kazançtır.

Yukarıdaki üç isteğin bağlantı davranışı incelendiğinde durum görünür:

```
*   Trying 127.0.0.1:8080...
* Connected to ornek.test (127.0.0.1) port 8080
> GET / HTTP/1.1
< HTTP/1.1 200 OK
* Connection #0 to host ornek.test left intact
* Re-using existing connection with host ornek.test
> GET /bicem.css HTTP/1.1
< HTTP/1.1 200 OK
* Connection #0 to host ornek.test left intact
* Re-using existing connection with host ornek.test
> GET /logo.svg HTTP/1.1
< HTTP/1.1 200 OK
* Connection #0 to host ornek.test left intact
```

Bir kez bağlanıldı, üç istek aynı bağlantı üzerinden geçti. Bu **kalıcı bağlantı
(persistent connection)** davranışıdır ve HTTP/1.1 ile protokolün varsayılanı durumuna
gelmiştir; önceki sürümde her istek için bağlantı kurulup kapatılıyordu.

Kalıcı bağlantının çözmediği bir sorun kalır. Aynı bağlantı üzerindeki istekler **sırayla**
işlenir: ilk yanıt tamamlanmadan ikincisi gönderilemez. Yavaş bir yanıt, arkasındakileri
bekletir. Bu davranış **sıra başı engellemesi** olarak adlandırılır.

HTTP/2, aynı bağlantı üzerinde birden çok isteğin iç içe geçmesine izin vererek bu soruna
yanıt verir; buna **çoğullama (multiplexing)** denir. İstekler ve yanıtlar numaralanmış
akışlara bölünür, parçalar karışık sırayla gönderilir ve alıcı tarafta ayrıştırılır. Bu
fikir, Ağ Nedir dersindeki paket numaralandırma ile aynı akıl yürütmedir.

| Özellik | Ayrı bağlantı | Kalıcı bağlantı | Çoğullama |
|---|---|---|---|
| İstek başına bağlantı kurma | Her istekte | İlk istekte | İlk istekte |
| Aynı anda bekleyen istek | Bağlantı sayısı kadar | Bir | Çok |
| Yavaş yanıtın etkisi | Yalnız kendisi | Arkasındakileri bekletir | Diğerlerini bekletmez |

Bu üç davranış, protokolün sürümleri arasındaki teknik ayrımdır. Hangisinin kullanıldığı
istemci ile sunucunun bağlantı kurarken anlaşmasıyla belirlenir.

#### Belgeden Çizime

Alınan belge metindir; ekranda görünen ise yerleşimi ve biçimi hesaplanmış öğelerdir.
Arada üç iş vardır.

**Ayrıştırma.** Belge metni, iç içe geçmiş öğelerden oluşan bir ağaca çevrilir. Veri
Yapıları kursundaki ağaç yapısı burada doğrudan karşılığını bulur: her öğe bir düğüm, iç
içelik ise ata–alt ilişkisidir.

**Biçim hesabı.** Biçem kuralları öğelere uygulanır ve her öğenin görünüm özellikleri
belirlenir.

**Yerleşim ve çizim.** Her öğenin ekrandaki konumu ve boyutu hesaplanır, sonra çizilir.

Alt kaynakların bu sırayı etkileme biçimi farklıdır ve bu fark gözlenebilir bir sonuç
doğurur. Biçem dosyası alınmadan çizim yapmak, sayfanın önce biçimsiz görünüp sonra
değişmesine yol açar; bu yüzden çizim biçem dosyası beklenerek yapılır. Betikler ise
belgeyi değiştirebildikleri için ayrıştırmayı durdurabilir. Görseller ise beklenmez;
geldiklerinde yerlerine konur.

Bu, alt kaynakların yalnızca sayılarının değil **sıralarının** da sayfanın görünme süresini
belirlediği anlamına gelir.

#### Tarayıcı Önbelleği

Alınan kaynakların yeniden istenmemesi için tarayıcı bir önbellek tutar. Alan Adı Sistemi
dersindeki yaşam süresi mantığı burada da geçerlidir, ancak denetim başlıklarla yapılır.

Sunucu bir yanıtın ne kadar süre saklanabileceğini bildirir. Süre dolduğunda tarayıcı
kaynağı yeniden indirmek yerine **koşullu istek** yapar: elindeki kopyanın kimliğini
gönderir ve "değiştiyse gönder" der. Değişmemişse sunucu gövdesiz kısa bir yanıt döndürür ve
gövde ikinci kez taşınmamış olur.

Bu düzen, ilk açılış ile sonraki açılışlar arasındaki farkın kaynağıdır ve önceki dersteki
`HEAD` yönteminin gerekçesiyle aynı fikre dayanır: içeriği taşımadan içerik hakkında bilgi
almak.

#### Özet

- Adres yapılı bir değerdir; şema, konak, bağlantı noktası, yol, sorgu ve parça bölümleri
  farklı aşamalarda kullanılır ve parça bölümü sunucuya hiç gönderilmez.
- Tarayıcı ad çözümleme, bağlantı kurma, istek gönderme, ayrıştırma, alt kaynak isteme ve
  çizim adımlarını yürütür; adımlar örtüşerek ilerler.
- Tek bir adres yazılması çok sayıda isteğe yol açar; alt kaynaklar farklı alan adlarındaysa
  çözümleme ve bağlantı adımları yeniden yürütülür.
- Kalıcı bağlantı, bağlantı kurma maliyetini istekler arasında paylaştırır; çoğullama,
  aynı bağlantıdaki isteklerin birbirini beklemesini ortadan kaldırır.
- Belge bir öğe ağacına çevrilir; biçem beklenerek, betikler ayrıştırmayı durdurarak,
  görseller beklenmeden işlenir.
- Tarayıcı önbelleği, süresi dolan kaynaklar için koşullu istek yaparak gövdenin yeniden
  taşınmasını önler.

#### Sonraki Adım

Bu ders adresin şema bölümünü ayırdı ve `https` durumunda bir güvenlik el sıkışması
yapıldığını söyleyip geçti. O adım atlanamaz: alışverişin yol üzerindeki hiç kimse
tarafından okunamaması, değiştirilememesi ve karşı tarafın gerçekten iddia ettiği taraf
olması gerekir. Sonraki ders bu üç sözü ayrı ayrı tanımlayacak ve yerel olarak üretilmiş bir
sertifikayla her birinin nasıl sınandığını gösterecek.

### HTTPS'in Rolü

Source: https://academia.sh/tr/kurslar/internet-nasil-calisir/httpsin-rolu

Şifreleme, kimlik doğrulama ve bütünlük sözleri; sertifikanın adı açık anahtara bağlaması ve güven çıpalarının rolü.

Önceki ders, adresin şema bölümü `https` olduğunda bir güvenlik el sıkışması yapıldığını
söyleyip geçmişti. Bu ders o adımı açar.

HTTP İstek ve Yanıtı dersinde görüldüğü gibi istek ve yanıt düz metindir. Bu metin, Ağ Nedir
dersinde kurulan yol boyunca çok sayıda ara düğümden geçer ve bu düğümler İnternetin Yapısı
dersinde belirtildiği üzere farklı kuruluşların denetimindedir. Düz metin, yol üzerindeki
her düğüm tarafından okunabilir ve değiştirilebilir.

**HTTPS**, HTTP'nin **TLS** adı verilen bir güvenlik katmanı üzerinden taşınmasıdır.
Protokolün kendisi değişmez; taşındığı kanal değişir.

#### Üç Söz

TLS üç ayrı söz verir. Bunları ayırmak önemlidir, çünkü yaygın karışıklık üçünü tek bir
"şifreleme" başlığı altında toplamaktan doğar.

**Gizlilik.** Alışverişin içeriği, iki uç dışında kimse tarafından okunamaz. Yol üzerindeki
düğümler şifreli baytları taşır, anlamlarını göremez.

**Bütünlük.** İçerik yolda değiştirilirse bu değişiklik saptanır. Değişikliğin
engellenmesi değil, **fark edilmesi** söz konusudur; bozulmuş veri sessizce kabul edilmez.

**Kimlik doğrulama.** Bağlanılan tarafın gerçekten o ad olduğu doğrulanır.

Üçüncü söz olmadan ilk ikisi anlamsızdır. Aradaki bir düğüm bağlantıyı kesip kendisini
sunucu gibi tanıtabilirse, sizinle arasında şifreli bir kanal kurar; içerik gizli ve bütün
olur, ancak yanlış tarafla. Kimliği doğrulanmamış bir şifreleme, konuştuğunuz kişinin kim
olduğunu bilmeden fısıldamaktır.

Bu yüzden zor olan bölüm şifreleme değil, kimlik doğrulamadır. Şifreleme matematiksel bir
problemdir; kimlik doğrulama, hiç tanışmadığınız bir tarafın kim olduğuna nasıl karar
vereceğiniz sorusudur.

#### Sertifika

Kimlik doğrulama **sertifika (certificate)** ile yapılır. Sertifika, üç şeyi bir arada
taşıyan bir belgedir: bir ad, o ada ait bir açık anahtar ve bu ikisinin birlikteliğini
onaylayan bir imza.

Sertifikanın kurduğu bağ şudur: **bu açık anahtar bu ada aittir.** Sunucu, karşılık gelen
özel anahtarı elinde tuttuğunu el sıkışma sırasında kanıtlar. Böylece "bu ada bağlanmak
istiyorum" ile "bu anahtarın sahibiyle konuşuyorum" ifadeleri birleşir.

Bir sertifika yerel olarak üretilebilir. Aşağıdaki komut, `ornek.test` adı için bir anahtar
çifti ve sertifika oluşturur:

```sh
openssl req -x509 -newkey rsa:2048 -nodes \
  -keyout anahtar.pem -out sertifika.pem -days 3650 \
  -subj "/CN=ornek.test" -addext "subjectAltName=DNS:ornek.test"
```

Üretilen sertifikanın kimlik alanları incelendiğinde:

```sh
openssl x509 -in sertifika.pem -noout -subject -issuer
openssl x509 -in sertifika.pem -noout -ext subjectAltName
```

```
subject=CN = ornek.test
issuer=CN = ornek.test
X509v3 Subject Alternative Name: 
    DNS:ornek.test
```

İki alan aynıdır. **Konu (subject)** sertifikanın kime ait olduğunu, **veren (issuer)**
onu kimin onayladığını söyler. İkisinin aynı olması sertifikanın kendi kendini onayladığı
anlamına gelir; buna **kendinden imzalı** sertifika denir.

Kendinden imzalı bir sertifikanın kanıt değeri yoktur. Bu belge, "ben `ornek.test`
adıyım, çünkü öyle diyorum" demektedir. Herkes aynı belgeyi herhangi bir ad için
üretebilir.

#### Güven Çıpaları

Sorun şu hâle gelir: bir sertifikanın doğru olduğuna kim karar verecek?

Yanıt, doğrudan tanımadığınız bir tarafı, tanıdığınız bir tarafın onayına dayanarak kabul
etmektir. **Sertifika yetkilisi (certificate authority)**, adın gerçekten başvurana ait
olduğunu sınadıktan sonra sertifikayı kendi anahtarıyla imzalayan kuruluştur.

İstemcide önceden yüklü, doğrudan güvenilen bir sertifika kümesi bulunur; bunlara **güven
çıpası (trust anchor)** denir. Doğrulama, sunucunun sertifikasından başlayıp imzalayanları
izleyerek bu kümeden birine ulaşmayı dener. Ulaşırsa sertifika kabul edilir; ulaşamazsa
edilmez.

Bu, güveni bir zincire indirger. Zincirin son halkası, istemcinin önceden sahip olduğu bir
şeydir; sıfırdan güven üretilmez, var olan güven aktarılır.

Bu sertifikayla bir sunucu çalıştırılabilir. Sunucu, HTTP İstek ve Yanıtı dersindekiyle
aynıdır; tek fark, dinleyen soketin TLS ile sarılmasıdır:

```python
# tls_sunucusu.py
import ssl
from http.server import BaseHTTPRequestHandler, HTTPServer


class Isleyici(BaseHTTPRequestHandler):
    protocol_version = "HTTP/1.1"

    def log_message(self, bicem: str, *arg: object) -> None:
        pass

    def do_GET(self) -> None:
        govde = b"<h1>Ornek Sayfa</h1>\n"
        self.send_response_only(200)
        self.send_header("Content-Type", "text/html; charset=utf-8")
        self.send_header("Content-Length", str(len(govde)))
        self.end_headers()
        self.wfile.write(govde)


baglam = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
baglam.load_cert_chain("sertifika.pem", "anahtar.pem")
sunucu = HTTPServer(("127.0.0.1", 8443), Isleyici)
sunucu.socket = baglam.wrap_socket(sunucu.socket, server_side=True)
sunucu.serve_forever()
```

Sunucu çalışırken bağlanıldığında doğrulama başarısız olur. Aşağıdaki komutlar tek parça
çalışır: sunucu arka planda başlatılır, `until` döngüsü sunucu bağlantı kabul edene kadar
bekler ve sunucu en sonda kapatılır. Sunucuyu ayrı bir uçbirimde çalıştırırsanız yalnızca
`curl` satırını yazmanız yeter; bu dersteki sonraki örneklerde de başlatma ve kapatma
satırları aynıdır.

```bash
python3 tls_sunucusu.py &
until (exec 3<>/dev/tcp/127.0.0.1/8443) 2>/dev/null; do sleep 0.05; done
curl -sS --resolve ornek.test:8443:127.0.0.1 https://ornek.test:8443/
kill $!; wait $! 2>/dev/null
```

```
curl: (60) SSL certificate problem: self-signed certificate
More details here: https://curl.se/docs/sslcerts.html
```

İstek yanıtsız kaldı; çıkış kodu 60'tır. Sertifika geçerli bir belgedir, ad da doğrudur —
ancak imzalayanı istemcinin güven kümesinde yoktur. İleti metni araca göre değişebilir;
değişmeyen, doğrulamanın başarısız olması ve bağlantının kurulmamasıdır.

Aynı sertifika güven çıpası olarak verildiğinde bağlantı kurulur:

```bash
python3 tls_sunucusu.py &
until (exec 3<>/dev/tcp/127.0.0.1/8443) 2>/dev/null; do sleep 0.05; done
curl -s --cacert sertifika.pem --resolve ornek.test:8443:127.0.0.1 https://ornek.test:8443/
kill $!; wait $! 2>/dev/null
```

```
<h1>Ornek Sayfa</h1>
```

Sunucu, sertifika ve anahtar aynıdır. Değişen tek şey istemcinin neye güvendiğidir. Bu,
güvenin sertifikanın bir özelliği değil, **istemcinin bir kararı** olduğunu gösterir.

#### Ad Denetimi

Sertifikanın geçerli olması yetmez; taşıdığı adın bağlanılan adla eşleşmesi de gerekir.
Yukarıdaki sertifika güvenilir sayılırken başka bir adla bağlanıldığında:

```bash
python3 tls_sunucusu.py &
until (exec 3<>/dev/tcp/127.0.0.1/8443) 2>/dev/null; do sleep 0.05; done
curl -sS --cacert sertifika.pem --resolve baska.test:8443:127.0.0.1 https://baska.test:8443/
kill $!; wait $! 2>/dev/null
```

```
curl: (60) SSL: no alternative certificate subject name matches target host name 'baska.test'
More details here: https://curl.se/docs/sslcerts.html
```

Sertifika güvenilir bir imza taşıyor, ancak `ornek.test` adı için düzenlenmiş. `baska.test`
adına bağlanan istemci bunu kabul etmez.

Bu denetim olmasaydı, herhangi bir ad için geçerli sertifikası olan bir taraf, başka her
adın yerine geçebilirdi. Sertifika bir anahtarı **belirli bir ada** bağlar; bağ, adı da
kapsar.

#### El Sıkışma

El sıkışma iki işi birlikte yürütür.

**Anahtar üzerinde anlaşma.** İki taraf, o oturuma özgü bir şifreleme anahtarı üretir. Bu
anahtar ağ üzerinden gönderilmez; iki tarafın alışverişinden türetilir. Yolda dinleyen
biri tüm alışverişi kaydetse bile anahtarı hesaplayamaz.

**Kimliğin kanıtlanması.** Sunucu sertifikasını gönderir ve karşılık gelen özel anahtara
sahip olduğunu, o anahtarla yapabileceği bir işlemle gösterir. Sertifikayı kopyalamak
yeterli değildir; özel anahtar olmadan kimlik kanıtlanamaz.

Bunlar tamamlandıktan sonra HTTP alışverişi başlar ve bu noktadan sonra protokol, önceki
derslerde tanımlanan biçimin aynısıdır. Şifreleme HTTP'yi değiştirmez, sarar.

Oturum anahtarının her bağlantı için yeniden üretilmesinin bir sonucu vardır: özel anahtar
sonradan ele geçirilse bile, önceden kaydedilmiş alışverişler çözülemez. Bu özellik, anahtar
anlaşma yönteminin seçimine bağlıdır.

#### HTTPS Neyi Gizlemez

Verilen sözlerin sınırlarını bilmek, sözlerin kendisini bilmek kadar önemlidir.

**Ad çözümleme gizlenmez.** Bağlantı kurulmadan önce Alan Adı Sistemi dersindeki sorgu
yapılır ve bu sorgu TLS'in dışındadır. Hangi ada bağlanmak istediğiniz, o sorguyu gören
taraflarca bilinir.

**Hedef adres gizlenmez.** Paketlerin başlıkları şifrelenemez; şifrelenselerdi
yönlendirilemezlerdi. Kiminle konuştuğunuz yol üzerindeki düğümlerce görülür.

**Trafiğin büyüklüğü ve zamanlaması gizlenmez.** Ne kadar veri gittiği ve ne zaman gittiği
gözlenebilir. Bu bilgiler tek başına içeriği vermez ama çıkarım yapmaya elverişlidir.

**İçeriğin doğruluğu güvence altında değildir.** TLS, karşı tarafın iddia ettiği ad olduğunu
doğrular; söylediğinin doğru olduğunu değil. Doğrulanmış bir sitenin yanlış bilgi vermesi
protokolün ilgi alanında değildir.

Bu ayrım pratik bir sonuç doğurur: bir bağlantının şifreli olması, karşı tarafın güvenilir
olduğu anlamına gelmez. Doğrulanan şey kimliktir, niyet değil.

#### Özet

- HTTPS, HTTP'nin TLS üzerinden taşınmasıdır; protokolün biçimi değişmez, kanal değişir.
- TLS gizlilik, bütünlük ve kimlik doğrulama sözlerini birlikte verir; kimlik doğrulama
  olmadan ilk ikisi yanlış tarafla kurulabilir.
- Sertifika, bir açık anahtarı belirli bir ada bağlar ve bu bağı bir imzayla onaylar.
- Kendinden imzalı sertifikada konu ile veren aynıdır ve kanıt değeri yoktur; doğrulama,
  imza zincirini istemcideki güven çıpalarından birine ulaştırmayı dener.
- Sertifikanın geçerliliği yetmez; taşıdığı adın bağlanılan adla eşleşmesi ayrıca sınanır.
- HTTPS ad çözümleme sorgusunu, hedef adresi, trafik büyüklüğünü ve zamanlamasını gizlemez;
  içeriğin doğruluğuna ilişkin bir söz de vermez.

#### Sonraki Adım

Zincirin bütün halkaları artık ayrı ayrı kurulmuş durumda: paket anahtarlama, adresleme, ad
çözümleme, barındırma, HTTP alışverişi ve güvenli kanal. Son ders bunları tek bir isteğin
üzerinde baştan sona birleştirecek, her aşamanın hangi bilgiyi bir sonrakine devrettiğini
gösterecek ve her halkanın kopması durumunda ortaya çıkan belirtileri sıralayacak.

### Bir İsteğin Uçtan Uca İzi

Source: https://academia.sh/tr/kurslar/internet-nasil-calisir/bir-istegin-uctan-uca-izi

Ad çözümlemeden yanıtın çizilmesine kadar tüm zincirin birleştirilmesi, aşamalar arasında devredilen bilgi ve her halkanın kopmasındaki belirtiler.

Kurs boyunca tek bir örnek izlendi: `ornek.test` adresine yapılan bir istek. Her ders bu
yolculuğun bir parçasını açtı — paketlerin nasıl taşındığı, adreslerin ne anlama geldiği,
adın nasıl çözümlendiği, sunucunun nerede durduğu, alışverişin nasıl biçimlendiği ve
kanalın nasıl güvenceye alındığı.

Bu ders halkaları birleştirir. Amaç yeni bir kavram eklemek değil, aralarındaki bilgi
akışını görünür kılmaktır.

#### Zincirin Tamamı

Adres satırına `https://ornek.test/` yazılıp istek gönderildiğinde şu adımlar yürütülür.

**1. Adresin çözümlenmesi.** Yazılan metin bölümlerine ayrılır: şema `https`, konak
`ornek.test`, yol `/`. Şema, bağlantı noktasının 443 olacağını belirler. *Bir sonrakine
devredilen: çözümlenecek ad.*

**2. Ad çözümleme.** Sağlayıcı, çözümleyiciye sorar. Yanıt önbellekte varsa oradan gelir;
yoksa kökten yetkili sunucuya inen zincir yürütülür ve dönen adres yaşam süresi boyunca
saklanır. *Bir sonrakine devredilen: hedef IP adresi.*

**3. Bağlantı kurma.** Hedef adres ve bağlantı noktasına bir bağlantı açılır. Paketler,
yol boyunca birbirinden bağımsız işletilen otonom sistemlerden geçer; yolu hiçbir uç
belirlemez. *Bir sonrakine devredilen: veri taşıyabilen bir bayt akışı.*

**4. Güvenlik el sıkışması.** Sunucu sertifikasını sunar. İstemci imza zincirini güven
çıpalarından birine ulaştırmayı dener ve sertifikadaki adın `ornek.test` ile eşleştiğini
sınar. İki taraf oturum anahtarını üretir. *Bir sonrakine devredilen: şifreli ve kimliği
doğrulanmış kanal.*

**5. İsteğin gönderilmesi.** İstek satırı, başlıklar ve boş satır yazılır. `Host` başlığı
konak adını taşır — adres bu noktada bir sayıya indirgenmiş olduğu için, sunucunun hangi
siteyi sunacağını yalnızca bu başlık söyler. *Bir sonrakine devredilen: yöntem, yol ve
başlıklar.*

**6. Sunucunun işlemesi.** Sunucu `Host` başlığına bakarak siteyi seçer, yola bakarak
kaynağı bulur ve bir durum kodu ile gövde üretir. *Bir sonrakine devredilen: durum kodu,
başlıklar, gövde.*

**7. Yanıtın yorumlanması.** İstemci durum kodunu okur; yönlendirme ise 1. adıma yeni bir
hedefle döner. `Content-Type` gövdenin ne olduğunu, `Content-Length` nerede bittiğini
söyler. *Bir sonrakine devredilen: belge.*

**8. Ayrıştırma ve alt kaynaklar.** Belge bir öğe ağacına çevrilir. Başvurulan her kaynak
için 1–7 adımları yinelenir; aynı konağa yapılan istekler var olan bağlantıyı kullanır.

**9. Yerleşim ve çizim.** Öğelerin konumu hesaplanır ve sayfa çizilir.

Zincirin yapısına ilişkin iki gözlem önemlidir. Birincisi, **her aşama bir sonrakine
yalnızca tek bir şey devreder** ve öncesini unutur: adres çözümlendikten sonra ad, bağlantı
kurulduktan sonra adres, el sıkışma bittikten sonra sertifika ilgisizleşir. İkincisi, ad
5. adımda geri döner — çünkü adres artık ayırt edici değildir. Barındırma Modelleri dersinde
kurulan sanal barındırmanın zorunlu kıldığı budur.

#### Zinciri Çalıştırmak

Önce sertifika ve anahtar üretilir. HTTPS'in Rolü dersindeki dosyalar elinizdeyse bu adım
atlanabilir:

```sh
openssl req -x509 -newkey rsa:2048 -nodes \
  -keyout anahtar.pem -out sertifika.pem -days 3650 \
  -subj "/CN=ornek.test" -addext "subjectAltName=DNS:ornek.test"
```

Bu adımların tamamı yerel olarak kurulabilir. Aşağıdaki sunucu, TLS ile sarılmış ve `Host`
başlığına göre site seçen bir sunucudur; kursta ayrı ayrı kurulan parçaları bir araya
getirir.

```python
# zincir_sunucusu.py
import ssl
from http.server import BaseHTTPRequestHandler, HTTPServer

SITELER: dict[str, bytes] = {
    "ornek.test": b"<!doctype html>\n<html lang=\"tr\"><body><h1>Ornek Sayfa</h1></body></html>\n",
}


class Isleyici(BaseHTTPRequestHandler):
    protocol_version = "HTTP/1.1"

    def log_message(self, bicem: str, *arg: object) -> None:
        print(f"[sunucu] {self.command} {self.path} Host={self.headers.get('Host')}", flush=True)

    def do_GET(self) -> None:
        ad = self.headers.get("Host", "").split(":")[0]
        govde = SITELER.get(ad)
        self.log_request(200 if govde else 404)
        if govde is None:
            govde = b"<h1>Bilinmeyen konak</h1>\n"
            self.send_response_only(404)
        else:
            self.send_response_only(200)
        self.send_header("Content-Type", "text/html; charset=utf-8")
        self.send_header("Content-Length", str(len(govde)))
        self.end_headers()
        self.wfile.write(govde)


baglam = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
baglam.load_cert_chain("sertifika.pem", "anahtar.pem")
sunucu = HTTPServer(("127.0.0.1", 8443), Isleyici)
sunucu.socket = baglam.wrap_socket(sunucu.socket, server_side=True)
sunucu.serve_forever()
```

Sertifika, yukarıda üretilen `sertifika.pem` dosyasıdır. İstek şu komutla yapılır;
`--resolve` ad çözümlemenin yerine geçer, `--cacert` sertifikayı güven çıpası yapar:

{/* run: skip */}
```sh
curl -sv --cacert sertifika.pem --resolve ornek.test:8443:127.0.0.1 \
  -A "ornek-istemci" https://ornek.test:8443/
```

İstemci tarafındaki iz (kısaltılmış; çıkarılan satırlar aşağıda anlatılıyor):

```
* Added ornek.test:8443:127.0.0.1 to DNS cache
* Hostname ornek.test was found in DNS cache
*   Trying 127.0.0.1:8443...
* Connected to ornek.test (127.0.0.1) port 8443
*  CAfile: sertifika.pem
*  CApath: none
* Server certificate:
*  subject: CN=ornek.test
*  subjectAltName: host "ornek.test" matched cert's "ornek.test"
*  issuer: CN=ornek.test
*  SSL certificate verify ok.
* using HTTP/1.x
> GET / HTTP/1.1
> Host: ornek.test:8443
> User-Agent: ornek-istemci
> Accept: */*
> 
< HTTP/1.1 200 OK
< Content-Type: text/html; charset=utf-8
< Content-Length: 73
< 
* Connection #0 to host ornek.test left intact
<!doctype html>
<html lang="tr"><body><h1>Ornek Sayfa</h1></body></html>
```

Bu çıktıdan üç satır türü çıkarılmıştır: sertifikanın geçerlilik tarihleri, iki tarafın
anlaştığı şifreleme takımı ve el sıkışmanın ara adımlarını gösteren satırlar. Tarihler
sertifikanın ne zaman üretildiğine, şifreleme takımı ise tarafların yeteneklerine bağlıdır;
ikisi de makineden makineye değişir. Yukarıdaki satırlar bu kurulumda değişmeyenlerdir.

Sunucunun kaydı ise tek satırdır:

```
[sunucu] GET / Host=ornek.test:8443
```

İzin okunuşu şöyledir: ad bir adrese çevrildi (1–2), bağlantı kuruldu (3), sertifika
doğrulandı ve ad eşleşmesi sınandı (4), istek gönderildi (5), sunucu `Host` başlığına
bakarak yanıtladı (6), yanıt yorumlandı (7). Alt kaynak bulunmadığı için 8. adım tek bir
belgede kaldı.

#### Arızaların Belirtileri

Zinciri adımlara ayırmanın pratik değeri, bir sorunun hangi adımda olduğunu belirtiden
çıkarabilmektir. Her adımın kendine özgü bir başarısızlık biçimi vardır.

| Belirti | Kusurlu aşama | Nedeni |
|---|---|---|
| Ad çözümlenemiyor | 2 | Kayıt yok, yetkili sunucu yanıtsız veya olumsuz yanıt önbellekte |
| Ad eski bir adresi gösteriyor | 2 | Önbellekteki kaydın yaşam süresi dolmadı |
| Bağlantı reddedildi | 3 | Adres doğru, o bağlantı noktasında dinleyen süreç yok |
| Bağlantı zaman aşımına uğradı | 3 | Paketler hedefe varmıyor veya yanıt dönmüyor |
| Sertifika doğrulanamadı | 4 | İmza zinciri güven çıpasına ulaşmıyor |
| Sertifikadaki ad eşleşmiyor | 4 | Sertifika başka bir ad için düzenlenmiş |
| Beklenmeyen site geldi | 6 | `Host` başlığına karşılık gelen site tanımlı değil |
| `4xx` durum kodu | 6 | İstek kusurlu: yol, yöntem veya yetki |
| `5xx` durum kodu | 6 | İstek geçerli, sunucu yerine getiremedi |
| Sayfa geliyor ama biçimsiz | 8 | Alt kaynak isteklerinden biri başarısız |

Bu tablonun kullanımı sırayı izlemektir: bir belirti gözlendiğinde, ondan önceki tüm
aşamaların başarılı olduğu bilinir. Sertifika hatası alınıyorsa ad çözümlenmiş ve bağlantı
kurulmuş demektir; `5xx` alınıyorsa güvenli kanal ve istek dahil her şey çalışmıştır. Bu
daraltma yöntemi Linux Ağ Yönetimi ve Sorun Giderme kursundaki katmanlı tanı yöntemiyle
aynı akıl yürütmedir.

Bu ayrımın en sık karıştırılan iki noktası şunlardır. **Bağlantının reddedilmesi ile zaman
aşımı farklı şeylerdir**: reddedilme, hedefin ulaşılabildiğini ve açıkça yanıt verdiğini
gösterir; zaman aşımında hedeften hiçbir şey dönmemiştir. **Ad çözümleme sorunları ile
sunucu sorunları farklı katmanlardadır**: adın çözümlenmesi sunucunun çalıştığını
göstermez, yalnızca kaydın var olduğunu gösterir.

#### Zincirin Değişmeyenleri

Kurs boyunca kurulan yapıda tekrar eden üç ilke vardır ve bunlar sonraki kursların da
zeminidir.

**Dolaylılık.** Ad adresi, adres konumu, sertifika anahtarı gösterir. Her katman, altındaki
katmanın değişmesine izin verirken üstündeki için sabit kalır.

**Katmanların birbirini bilmemesi.** Ağ, taşıdığı paketin içeriğini bilmez; HTTP, altında
şifreleme olup olmadığını bilmez; TLS, taşıdığı verinin HTTP olduğunu bilmez. Bu ayrım,
bir katmanın diğerlerine dokunmadan değiştirilmesini sağlar.

**Zor güvencelerin uçlara bırakılması.** Ağ Nedir dersinde kurulan bu ilke zincir boyunca
tekrarlanır: sıra düzeltme, önbellek tutarlılığı, kimlik doğrulama ve durum yönetimi hep
uçlarda yapılır. Ara düğümler sade tutulur.

#### Özet

- Bir istek dokuz aşamada yürütülür ve her aşama bir sonrakine yalnızca tek bir şey
  devrederek öncesini unutur.
- Konak adı, adres çözümlendikten sonra `Host` başlığıyla geri döner; sanal barındırma bunu
  zorunlu kılar.
- Zincirin tamamı yerel olarak kurulabilir ve tek bir izde gözlenebilir.
- İzdeki sertifika tarihleri ve şifreleme takımı gibi alanlar kuruluma bağlıdır; yapısal
  satırlar değişmez.
- Her aşamanın kendine özgü bir arıza belirtisi vardır; belirti gözlendiğinde ondan önceki
  aşamaların başarılı olduğu bilinir.
- Dolaylılık, katmanların birbirini bilmemesi ve güvencelerin uçlara bırakılması, zincir
  boyunca tekrarlanan üç tasarım ilkesidir.

#### Kurs Kapanışı

Bu kurs, adres satırına yazılan bir adın ekrandaki bir sayfaya dönüşmesini uçtan uca kurdu.
Ağların paket anahtarlama üzerine neden kurulduğu, adreslerin neden hiyerarşik olduğu,
adların neden ayrı bir katman gerektirdiği, alan adı sisteminin önbelleklemeyle nasıl
ölçeklendiği, HTTP'nin neden durumsuz tasarlandığı ve TLS'in hangi üç sözü verdiği — hepsi
tek bir örnek isteğin parçaları olarak ele alındı.

Kurs boyunca kasıtlı olarak açık bırakılan bir soru vardır. Paketlerin sırasının
düzeltilmesi, kaybolanların yeniden istenmesi ve gönderim hızının ağın taşıyabileceğine
uyarlanması hep "uçlarda yapılır" denerek geçildi; bunu yapan protokolün kendisi
tanımlanmadı. Aynı biçimde, bağlantının kurulmasından söz edildi ancak bağlantının ne
olduğu, hangi katmanda durduğu ve hangi durumlarda bağlantısız çalışmanın tercih edildiği
söylenmedi.

Ağ Modelleri ve Protokoller kursu bu boşluğu doldurur. Katmanlı modelleri tanımlar ve bu
kursta sezgisel olarak kullanılan ayrımları — hangi işin hangi katmana ait olduğunu —
sistemli bir çerçeveye oturtur. Adreslemeyi bu kursta anılan önek hesabının ötesine
taşıyarak alt ağ tasarımını kurar. Güvenilir ve güvenilmez taşıma arasındaki seçimi,
uygulamanın gereksinimi üzerinden gerekçelendirir. Bu kursta "sonraki kursun konusudur"
denerek bırakılan her nokta orada karşılanır.