$ Rust ile Yüksek Performanslı Web Sunucusu: HTTP ve HTTPS İsteklerini Karşılama

Apache veya Nginx gibi geleneksel web sunucularına bir alternatif olarak, Rust'ın sunduğu güvenlik ve performans avantajlarını kullanarak kendi web sunucumuzu yazabiliriz. Bu makalede, tokio, hyper ve rustls gibi modern kütüphanelerle hem güvensiz HTTP (port 80) hem de güvenli HTTPS (port 443) trafiğini nasıl yöneteceğimizi inceleyeceğiz.

Neden Kendi Web Sunucumuzu Rust ile Yazalım?

Performans: Rust, C/C++ ile rekabet eden, inanılmaz derecede yüksek bir performans sunar. Bellek yönetimi üzerindeki tam kontrol, gereksiz yükleri ortadan kaldırır.
Güvenlik: Rust'ın derleyicisi, bellek sızıntıları, veri yarışları ve diğer yaygın güvenlik açıklarını daha kod derlenirken yakalar. Bu, özellikle internete açık bir sunucu için paha biçilmez bir özelliktir.
Eşzamanlılık (Concurrency): Rust'ın sahiplik modeli, binlerce isteği aynı anda güvenli bir şekilde yönetmeyi kolaylaştırır. async/await sözdizimi ile modern ve verimli asenkron kod yazmak mümkündür.

Gerekli Kütüphaneler (Crates)

Projemizin temelini oluşturacak olan kütüphaneler şunlardır:

tokio: Rust için asenkron bir çalışma zamanı (runtime). Ağ uygulamaları için temel oluşturur.
hyper: Hızlı ve doğru bir HTTP istemci ve sunucu kütüphanesi.
rustls ve tokio-rustls: TLS (HTTPS'in arkasındaki teknoloji) için modern ve güvenli bir kütüphane.

Temel Sunucu Yapısı

Konsept olarak, sunucumuz iki ana görevi eş zamanlı olarak çalıştıracaktır. tokio::join! makrosu, hem HTTP hem de HTTPS sunucularını aynı anda başlatmamızı sağlar. Gelen tüm HTTP istekleri, kalıcı olarak HTTPS adresine yönlendirilirken, HTTPS sunucusu asıl içeriği sunacaktır.

use hyper::server::conn::http1;
use hyper::service::service_fn;
use hyper::{Request, Response, Body, StatusCode, header};
use tokio::net::{TcpListener};
use std::net::SocketAddr;
use std::sync::Arc;
use tokio_rustls::TlsAcceptor;
// Diğer gerekli `use` bildirimleri...

// Tüm istekleri işleyecek ana fonksiyon
async fn handle_request(req: Request<Body>) -> Result<Response<Body>, Infallible> {
    // Burada gelen isteğe göre cevap oluşturulur.
    // Örnek olarak "Merhaba Dünya" döndürelim.
    Ok(Response::new(Body::from("Merhaba, virtualscrap.com!")))
}

// HTTP isteklerini HTTPS'e yönlendiren fonksiyon
async fn redirect_to_https(req: Request<Body>) -> Result<Response<Body>, Infallible> {
    let host = req.headers().get(header::HOST).unwrap().to_str().unwrap();
    let uri = format!("https://{}/", host);
    
    let mut res = Response::new(Body::from("HTTPS'e yönlendiriliyorsunuz..."));
    *res.status_mut() = StatusCode::PERMANENT_REDIRECT;
    res.headers_mut().insert(header::LOCATION, uri.parse().unwrap());
    Ok(res)
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    // --- HTTPS Sunucusu Kurulumu (Port 443) ---
    // SSL sertifikalarını ve özel anahtarı yükle (örn: cert.pem, key.pem)
    // let tls_acceptor = ... (Sertifika yükleme kodları)

    let https_addr = SocketAddr::from(([0, 0, 0, 0], 443));
    let https_listener = TcpListener::bind(https_addr).await?;
    let https_server = async {
        loop {
            let (stream, _) = https_listener.accept().await.unwrap();
            // let stream = tls_acceptor.accept(stream).await.unwrap();
            // http1::Builder::new().serve_connection(stream, service_fn(handle_request)).await.unwrap();
        }
    };
    
    // --- HTTP Sunucusu Kurulumu (Port 80) ---
    let http_addr = SocketAddr::from(([0, 0, 0, 0], 80));
    let http_listener = TcpListener::bind(http_addr).await?;
    let http_server = async {
        loop {
            let (stream, _) = http_listener.accept().await.unwrap();
            // http1::Builder::new().serve_connection(stream, service_fn(redirect_to_https)).await.unwrap();
        }
    };

    println!("Sunucu 80 (HTTP) ve 443 (HTTPS) portlarında başlatıldı.");
    
    // İki sunucuyu da aynı anda çalıştır
    tokio::join!(http_server, https_server);
    
    Ok(())
}

Sonuç

Bu örnek, Rust'ın ağ programlama için ne kadar esnek ve güçlü olduğunu göstermektedir. Kod, konsepti anlatmak için basitleştirilmiştir (sertifika yükleme ve hata yönetimi gibi detaylar çıkarılmıştır), ancak temel mantık aynıdır. Rust ile, modern web'in gerektirdiği performans ve güvenlik standartlarını karşılayan, son derece verimli sunucular inşa etmek mümkündür.