Learn Rust Coding · Ders

Actix-web/Rocket ile REST API'leri

Actix-web veya Rocket gibi modern bir Rust web çatısı kullanarak yolları, istekleri ve yanıtları işleyen RESTful API'ler geliştirin.

1. ders / 311 adım

Actix-web/Rocket ile REST API'leri, CoddyKit'te ücretsiz bir Learn Rust Coding dersidir. Bu, 3 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 3 dersten oluşur.

REST API'leri nedir?

REST veya REpresentational State Transfer, ağ bağlantılı uygulamalar için bir mimari tarzdır. Web hizmetlerinin nasıl iletişim kurması gerektiğine ilişkin bir dizi ilke tanımlar.

Bunu, durum bilgisi tutmayan, önbelleğe alınabilen ve kaynaklarla etkileşim kurmak için standart HTTP yöntemlerini kullanan web hizmetleri oluşturmaya yönelik bir dizi kılavuz olarak düşünebilirsiniz.

Kaynaklar: Kullanıcı, product veya sipariş gibi adlandırılabilen her şey.
URI'ler: Kaynaklar için benzersiz tanımlayıcılar (örneğin, /users/123).
HTTP Yöntemleri: Kaynaklar üzerinde gerçekleştirilen standart eylemler (GET, POST, PUT, DELETE).

Web Hizmetleri İçin Neden Rust?

Rust, web hizmeti geliştirmeye özgü avantajlar sunarak yüksek performanslı ve güvenilir API'ler için güçlü bir seçenek hâline gelir:

Performans: Rust'un sıfır maliyetli soyutlamaları, genellikle C/C++ ile karşılaştırılabilir düzeyde yüksek verimli kod anlamına gelir.
Bellek Güvenliği: Sahiplik sistemi, boş işaretçi başvurusu kaldırma ve veri yarışları gibi yaygın hataları önleyerek daha sağlam hizmetler ortaya çıkarır.
Eşzamanlılık: Rust'un async/await modeli, güvenlik garantileriyle birlikte eşzamanlı web hizmetleri oluşturmayı 'endişesiz' hâle getirir.
Güvenilirlik: Güçlü tür sistemi ve derleme zamanı denetimleri birçok hatayı erkenden yakalar.

Actix-web ile Tanışın

Rust'ta web hizmetleri oluşturmak için genellikle çerçeveler kullanırız. Actix-web, Rust için güçlü, pratik ve son derece hızlı bir web çerçevesidir.

Bir aktör çerçevesi olan Actix üzerine kuruludur; ancak Actix-web'i etkili bir şekilde kullanmak için aktörleri anlamanız gerekmez. Eşzamansız işlemler için tasarlanmıştır ve bu nedenle çok sayıda eşzamanlı API isteğini işleme gibi G/Ç ağırlıklı görevler için idealdir.

Actix-web; yönlendirme, istek/yanıt işleme, ara yazılım ve çok daha fazlası için araçlar sunarak karmaşık API'lerin oluşturulmasını kolaylaştırır.

Proje Kurulumu ve Bağımlılıklar

Başlangıç olarak yeni bir Rust projesi oluşturacak ve gerekli bağımlılıkları ekleyeceğiz. Çerçeve olarak actix-web kullanacağız; JSON verilerini serileştirmek ve seri durumdan çıkarmak için de serde kullanacağız.

Öncelikle yeni bir proje oluşturun:

cargo new my_rest_api --bin

Ardından, [dependencies] bölümünün altında yer alan Cargo.toml dosyanıza şu satırları ekleyin:

[dependencies]
actix-web = "4"
serde = { version = "1.0", features = ["derive"] }

İlk Actix-web Sunucunuz

Basit bir Actix-web sunucusu yazalım. Bu kod, 8080 numaralı bağlantı noktasındaki gelen HTTP isteklerini dinlemek için temel yapıyı oluşturur. Henüz belirli yolları işlemez ancak temel oluşturur.

#[actix_web::main] makrosu, async fn main işlevimizi Actix-web çalışma zamanıyla uyumlu hâle getirir.

use actix_web::{App, HttpServer};

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    HttpServer::new(|| {
        // Our application instance, where we'll add routes
        App::new()
    })
    .bind(("127.0.0.1", 8080))? // Bind to an IP address and port
    .run() // Start the server
    .await // Await its completion
}

GET Yolu Tanımlama

Şimdi sunucumuza basit bir yol ekleyelim. Yol, gelen bir HTTP isteğinin yolunu ve yöntemini (örneğin GET /hello) belirli bir işleyici işlevine eşler.

hello_world işleyici işlevimiz basitçe bir dize döndürür. web::get().to(), bu işleyiciyi /hello yoluna gelen GET istekleri için kaydeder.

use actix_web::{web, App, HttpServer, Responder};

// A handler function that returns a simple string response
async fn hello_world() -> impl Responder {
    "Hello, Actix-web!"
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    HttpServer::new(|| {
        App::new()
            // Register our route: GET /hello maps to hello_world()
            .route("/hello", web::get().to(hello_world))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Dinamik Yollar için Yol Parametreleri

API'lerin URL'deki bir kimlik veya ad gibi dinamik bölümleri işlemesi çoğu zaman gerekir. Actix-web, bu değerleri yakalamak için yol parametrelerini kullanır.

Yolda bir yer tutucu tanımlarız (örneğin /{name}). İşleyicide, değeri çıkarmak için web::Path<String> (veya seri durumdan çıkarılabilen başka bir tür) kullanırız.

use actix_web::{web, App, HttpServer, Responder};

// Handler function with a path parameter 'name'
async fn greet_name(name: web::Path<String>) -> impl Responder {
    format!("Hello, {}!", name.into_inner())
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    HttpServer::new(|| {
        App::new()
            // Route with a dynamic path segment for a name
            .route("/greet/{name}", web::get().to(greet_name))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

POST İsteklerini ve JSON'u İşleme

Kaynak oluşturmak veya güncellemek için POST ya da PUT isteklerini kullanır, verileri çoğu zaman istek gövdesinde JSON olarak göndeririz.

Actix-web, JSON işlemeyi web::Json<T> ile kolaylaştırır. Beklediğimiz JSON yapısına uyan bir Rust struct tanımlar, serde'den Deserialize türetiriz ve Actix-web gelen JSON'u otomatik olarak yapımıza ayrıştırır.

use actix_web::{web, App, HttpServer, Responder};
use serde::{Deserialize, Serialize};

// Define a struct to represent our incoming JSON data
#[derive(Deserialize, Serialize)]
struct User {
    username: String,
    email: String,
}

// Handler for POST requests that accepts a JSON User object
async fn create_user(user: web::Json<User>) -> impl Responder {
    // In a real app, you'd save this user to a database
    format!("User created: {} ({})", user.username, user.email)
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    HttpServer::new(|| {
        App::new()
            // POST /users expects a JSON body and maps to create_user()
            .route("/users", web::post().to(create_user))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Durum Bilgisine Sahip Basit Bir API Oluşturma

Öğrendiklerimizi birleştirerek bellekteki bir kullanıcı listesini yöneten küçük bir API oluşturalım. Uygulamaya özgü durumu (kullanıcı listemizi) işleyiciler arasında paylaşmak için web::Data kullanacağız.

std::sync::Mutex, birden fazla eşzamanlı isteğin Vec<User> üzerinde güvenli biçimde değişiklik yapabilmesini sağlamak için kullanılır. GET /users ve POST /users uç noktalarımız olacak.

use actix_web::{web, App, HttpServer, Responder, HttpResponse};
use serde::{Deserialize, Serialize};
use std::sync::Mutex; // For shared mutable state

// Define a User struct that can be serialized/deserialized and cloned
#[derive(Deserialize, Serialize, Clone)]
struct User {
    id: u32,
    username: String,
    email: String,
}

// Application state to hold our users and track next ID
struct AppState {
    users: Mutex<Vec<User>>,
    next_id: Mutex<u32>,
}

// Handler to get all users
async fn get_users(data: web::Data<AppState>) -> impl Responder {
    let users = data.users.lock().unwrap(); // Acquire a lock
    web::Json(users.clone()) // Return users as JSON
}

// Handler to create a new user
async fn create_user(
    data: web::Data<AppState>,
    new_user: web::Json<User>,
) -> impl Responder {
    let mut users = data.users.lock().unwrap();
    let mut next_id = data.next_id.lock().unwrap();

    let user = User {
        id: *next_id,
        username: new_user.username.clone(),
        email: new_user.email.clone(),
    };
    users.push(user.clone());
    *next_id += 1; // Increment for the next user
    HttpResponse::Created().json(user) // Return 201 Created status and user
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    println!("Server running at http://127.0.0.1:8080");
    // Create shared application state
    let app_state = web::Data::new(AppState {
        users: Mutex::new(vec![]), // Initialize with an empty user list
        next_id: Mutex::new(1),    // Start IDs from 1
    });

    HttpServer::new(move || { // 'move' closure to capture app_state
        App::new()
            .app_data(app_state.clone()) // Register shared state with the app
            .route("/users", web::get().to(get_users))
            .route("/users", web::post().to(create_user))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

API Kavramlarını Hızlıca Yoklama

Temel bir Actix-web sunucusunu nasıl kuracağınızı ve farklı HTTP isteklerini nasıl işleyeceğinizi öğrendiniz. Anlayışınızı sınayalım!

İnteraktif derste cevapla

Özet ve Sonraki Adımlar

Tebrikler! Rust ve Actix-web ile RESTful API'ler oluşturmaya yönelik ilk adımlarınızı attınız.

REST API temellerini ve Rust'ın neden çok uygun bir seçenek olduğunu inceledik.
Temel bir Actix-web projesi kurmayı öğrendiniz.
GET ve POST yollarını tanımlamayı ele aldık.
Yol parametrelerini nasıl çıkaracağınızı ve JSON yüklerini nasıl işleyeceğinizi gördünüz.
Son olarak, web::Data kullanarak bellekteki durumu yöneten basit bir API oluşturdunuz.

Sırada, daha güçlü ve üretime hazır web hizmetleri oluşturmak için veritabanı tümleştirmesini ve sağlam hata işlemeyi daha ayrıntılı inceleyeceksiniz!

Başlamak ücretsiz

Yapay zeka eğitmeniyle Rust öğren — ücretsiz

Tarayıcında gerçek kod yaz ve çalıştır, 7/24 yapay zeka eğitmeninden anında yardım al; web'de ya da uygulamada kaldığın yerden devam et.

Kurslar: 39
Dersler: 144

Ücretsiz öğrenmeye başla Tüm kursu görüntüle

Sıkça Sorulan Sorular

“Actix-web/Rocket ile REST API'leri” dersi ücretsiz mi?

Evet — “Actix-web/Rocket ile REST API'leri” 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 3 dersten oluşur.

“Actix-web/Rocket ile REST API'leri” dersinde ne öğreneceğim?

Actix-web veya Rocket gibi modern bir Rust web çatısı kullanarak yolları, istekleri ve yanıtları işleyen RESTful API'ler geliştirin. 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, 3 dersinin 1. dersidir.

“Actix-web/Rocket ile REST API'leri” 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