Learn Rust Coding · Ders

Proje Kurulumu

API'yi yapılandırın

Proje Kurulumu, CoddyKit'te ücretsiz bir Learn Rust Coding dersidir. Bu, 4 dersinin 1. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Learn Rust Coding öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Learn Rust Coding kursu toplamda 4 dersten oluşur.

Rust ile REST API Oluşturma

Bu kursta Rust ile küçük bir REST API oluşturacaksınız. Tokio (eşzamansız çalışma zamanı) ve Tower (ara yazılım) üzerine kurulmuş Axum web çatısını kullanıyoruz. Kullanımı kolay, tür güvenli ve üretimde yaygın olarak kullanılan bir çatıdır.

Bu ilk ders, sonraki derslerin rotalar, modeller, veritabanı ve testler ekleyebilmesi için proje yapısını kurar.

Projeyi Oluşturma

Cargo ile başlayın. İkili proje size bir src/main.rs giriş noktası sağlar:

cargo new rest_api klasörü oluşturur.
cd rest_api bu klasöre geçer.
cargo run derler ve çalıştırır.

Bunlar çalıştırılabilir Rust parçacıkları değil, kabuk ve cargo komutlarıdır.

// terminal
// cargo new rest_api
// cd rest_api
// cargo run

Bağımlılıkları Ekleme

Bir Axum API'si için Cargo.toml dosyasında birkaç paket gerekir:

Yönlendirme ve işleyiciler için axum.
Eşzamansız çalışma zamanı için tokio.
JSON serileştirme için serde.

// Cargo.toml
// [dependencies]
// axum = "0.7"
// tokio = { version = "1", features = ["full"] }
// serde = { version = "1", features = ["derive"] }
// serde_json = "1"

Eşzamansız Çalışma Zamanı

Web sunucuları birçok bağlantıyı eşzamanlı olarak işler; bu nedenle Axum eşzamansızdır. #[tokio::main] özniteliği, Tokio çalışma zamanını başlatarak eşzamansız bir main işlevini gerçek bir giriş noktasına dönüştürür. Her işleyici, engellemesiz G/Ç için .await kullanabilir.

// src/main.rs
use tokio;

#[tokio::main]
async fn main() {
    println!("runtime started");
}

En Basit Sunucu

En küçük Axum app'i bir Router oluşturur, bir TCP dinleyicisine bağlanır ve hizmet verir. Tek bir rota, GET / yolunu bir dize döndüren işleyiciye eşler. İşleyiciler, IntoResponse uygulayan bir şey döndüren eşzamansız işlevlerden ibarettir.

use axum::{routing::get, Router};

#[tokio::main]
async fn main() {
    let app = Router::new().route("/", get(root));
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

async fn root() -> &'static str {
    "Hello, API!"
}

Yönlendirme Nasıl Çalışır

Bir Router, bir yolu ve HTTP yöntemini bir işleyiciye eşler. Uç noktaları kaydetmek için .route(path, method(handler)) çağrılarını zincirleyin. get, post, put ve delete gibi yöntem yardımcıları axum::routing içinden gelir. Aynı yol üzerinde yöntemleri birleştirebilirsiniz.

use axum::{routing::{get, post}, Router};

async fn list() -> &'static str { "list" }
async fn create() -> &'static str { "created" }

fn build_router() -> Router {
    Router::new()
        .route("/items", get(list).post(create))
        .route("/health", get(|| async { "ok" }))
}

Önerilen Modül Düzeni

API büyüdükçe kodu tek bir devasa main.rs yerine modüllere ayırın:

main.rs — başlangıç ve sunucu bağlantıları.
routes.rs — yönlendirici tanımı.
handlers.rs — istek işleyicileri.
models.rs — veri yapıları.

Bu ayrım her dosyanın odaklanmış ve test edilebilir kalmasını sağlar.

// src/main.rs
mod routes;
mod handlers;
mod models;

#[tokio::main]
async fn main() {
    let app = routes::build();
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

Paylaşılan Uygulama Durumu

Çoğu API'nin veritabanı havuzu veya bellekteki depo gibi paylaşılan bir duruma ihtiyacı vardır. Axum bu durumu yönlendiricideki .with_state(state) ile tutar. İşleyiciler bu durumu State çıkarıcısı aracılığıyla alır. Durum Clone olmalıdır; değiştirilebilir verileri bir kilit ve Arc içine sarın.

use axum::{routing::get, Router, extract::State};
use std::sync::{Arc, Mutex};

type Db = Arc<Mutex<Vec<String>>>;

async fn count(State(db): State<Db>) -> String {
    let n = db.lock().unwrap().len();
    format!("{} items", n)
}

fn build(db: Db) -> Router {
    Router::new().route("/count", get(count)).with_state(db)
}

JSON Döndürme

JSON göndermek için serileştirilebilir bir değeri axum::Json içine sarın. Yapılarınızda serde ile Serialize türetildiğinde Axum doğru içerik türünü ve gövdeyi otomatik olarak ayarlar.

use axum::Json;
use serde::Serialize;

#[derive(Serialize)]
struct Status {
    service: String,
    healthy: bool,
}

async fn health() -> Json<Status> {
    Json(Status { service: "api".into(), healthy: true })
}

Yapılandırma ve Portlar

Portu sabit kodlamak tanıtımlar için uygundur; ancak gerçek hizmetler yapılandırmayı ortamdan okur. Bir varsayılan değerle birlikte std::env::var kullanın. Böylece yeniden derlemeden bağlanma adresini değiştirebilir ve kapsayıcılarla uyumlu çalışabilirsiniz.

use std::env;

async fn main_inner() {
    let port = env::var("PORT").unwrap_or_else(|_| "3000".to_string());
    let addr = format!("0.0.0.0:{}", port);
    println!("binding to {}", addr);
    // bind and serve with addr ...
}

Kurulumu Birleştirme

Tam bir başlangıç kurulumu her şeyi birbirine bağlar: yönlendiriciyi rotalar ve paylaşılan durumla oluşturun, portu okuyun, bir dinleyiciye bağlanın ve hizmet verin. Bu iskelet hazır olduğunda sonraki dersler gerçek uç noktalar, modeller ve kalıcılık ekler.

use axum::{routing::get, Router};
use std::sync::{Arc, Mutex};

#[tokio::main]
async fn main() {
    let db = Arc::new(Mutex::new(Vec::<String>::new()));
    let app = Router::new()
        .route("/health", get(|| async { "ok" }))
        .with_state(db);
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000")
        .await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

Hızlı Kontrol

Proje kurulumu konusundaki anlayışınızı test edin.

Özet

Bir Rust REST API projesi kurdunuz:

cargo new kullanın ve axum, tokio ile serde ekleyin.
#[tokio::main] eşzamansız çalışma zamanını sağlar.
Bir Router, yolları ve yöntemleri eşzamansız işleyicilere eşler.
Verileri .with_state ve State çıkarıcısıyla paylaşın.
Kodu rota, işleyici ve model modüllerine ayırın; portu ortamdan okuyun.

Sıkça Sorulan Sorular

“Proje Kurulumu” dersi ücretsiz mi?

Evet — “Proje Kurulumu” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Learn Rust Coding kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Learn Rust Coding kursu toplamda 4 dersten oluşur.

“Proje Kurulumu” dersinde ne öğreneceğim?

API'yi yapılandırın Learn Rust Coding ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Learn Rust Coding öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Learn Rust Coding, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 1. dersidir.

“Proje Kurulumu” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Learn Rust Coding dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Learn Rust Coding dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← Learn Rust Coding Sayfasına Dön