Learn Rust Coding · Lekcja

REST API z Actix-web/Rocket

Stworzą Państwo RESTful API z użyciem nowoczesnego web frameworka Rust, takiego jak Actix-web lub Rocket, obsługujące trasy, żądania i odpowiedzi.

REST API z Actix-web/Rocket to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 1 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Learn Rust Coding, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Learn Rust Coding zawiera 3 lekcji w sumie.

Czym są REST API?

REST, czyli REpresentational State Transfer, to styl architektoniczny przeznaczony dla aplikacji sieciowych. Określa zbiór zasad opisujących sposób komunikacji usług internetowych.

Można traktować go jako zbiór wytycznych dotyczących tworzenia usług internetowych, które są bezstanowe, mogą korzystać z pamięci podręcznej i używają standardowych metod HTTP do interakcji z zasobami.

Zasoby: Wszystko, co można nazwać, na przykład użytkownik, produkt lub zamówienie.
URI: Unikatowe identyfikatory zasobów (np. /users/123).
Metody HTTP: Standardowe działania wykonywane na zasobach (GET, POST, PUT, DELETE).

Dlaczego Rust do usług internetowych?

Rust oferuje wyjątkowe zalety w tworzeniu usług internetowych, dzięki czemu jest dobrym wyborem do budowania wydajnych i niezawodnych API:

Wydajność: Abstrakcje bez kosztu w czasie działania w Rust pozwalają tworzyć bardzo wydajny kod, często porównywalny z kodem w C/C++.
Bezpieczeństwo pamięci: System własności zapobiega typowym błędom, takim jak wyłuskanie pustego wskaźnika i wyścigi danych, co prowadzi do tworzenia bardziej niezawodnych usług.
Współbieżność: Model async/await języka Rust, połączony z gwarancjami bezpieczeństwa, ułatwia tworzenie współbieżnych usług internetowych bez obaw o bezpieczeństwo.
Niezawodność: Silny system typów i kontrole wykonywane podczas kompilacji pozwalają wcześnie wykrywać wiele błędów.

Poznaj Actix-web

Do tworzenia usług internetowych w Rust często używa się frameworków. Actix-web to wydajny, praktyczny i niezwykle szybki framework internetowy dla Rust.

Został zbudowany na bazie Actix, czyli frameworka aktorowego, ale do skutecznego używania Actix-web nie trzeba rozumieć modelu aktorów. Framework zaprojektowano z myślą o operacjach asynchronicznych, dzięki czemu idealnie nadaje się do zadań ograniczonych przez operacje wejścia-wyjścia, takich jak obsługa wielu współbieżnych żądań API.

Actix-web udostępnia narzędzia do routingu, obsługi żądań i odpowiedzi, middleware oraz wiele innych funkcji, upraszczając tworzenie złożonych API.

Konfiguracja projektu i zależności

Na początek utworzymy nowy projekt w Rust i dodamy niezbędne zależności. Użyjemy actix-web jako frameworka oraz serde do serializowania i deserializowania danych JSON.

Najpierw utwórz nowy projekt:

cargo new my_rest_api --bin

Następnie dodaj te wiersze do pliku Cargo.toml, w sekcji [dependencies]:

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

Twój pierwszy serwer Actix-web

Napiszmy minimalny serwer Actix-web. Ten kod konfiguruje podstawową strukturę nasłuchującą przychodzących żądań HTTP na porcie 8080. Serwer nie obsługuje jeszcze żadnych konkretnych tras, ale stanowi ich podstawę.

Makro #[actix_web::main] sprawia, że nasza funkcja async fn main jest zgodna ze środowiskiem uruchomieniowym Actix-web.

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
}

Definiowanie trasy GET

Dodajmy teraz do serwera prostą trasę. Trasa przypisuje ścieżkę i metodę przychodzącego żądania HTTP (np. GET /hello) do konkretnej funkcji obsługi.

Nasza funkcja obsługi hello_world po prostu zwróci ciąg znaków. web::get().to() rejestruje tę funkcję obsługi dla żądań GET kierowanych do ścieżki /hello.

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
}

Parametry ścieżki dla tras dynamicznych

API często musi obsługiwać dynamiczne części adresu URL, takie jak identyfikator lub nazwa. Actix-web używa parametrów ścieżki do przechwytywania tych wartości.

W trasie definiujemy symbol zastępczy (np. /{name}). W funkcji obsługi używamy web::Path<String> (lub dowolnego innego typu, który można deserializować), aby pobrać tę wartość.

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
}

Obsługa żądań POST i JSON

Do tworzenia lub aktualizowania zasobów używamy żądań POST lub PUT, często przesyłając dane w treści żądania jako JSON.

Actix-web ułatwia obsługę JSON za pomocą web::Json<T>. Definiujemy strukturę Rust struct odpowiadającą oczekiwanej strukturze JSON, implementujemy dla niej Deserialize z serde, a Actix-web automatycznie analizuje przychodzący JSON i przekształca go w naszą strukturę.

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
}

Tworzenie prostego API ze stanem

Połączmy zdobytą wiedzę, aby zbudować małe API zarządzające przechowywaną w pamięci listą użytkowników. Użyjemy web::Data, aby udostępnić stan właściwy dla aplikacji (naszą listę użytkowników) różnym funkcjom obsługi.

std::sync::Mutex służy do bezpiecznego zapewnienia mutowalnego dostępu do naszego Vec<User> z poziomu wielu współbieżnych żądań. Udostępnimy punkty końcowe GET /users i POST /users.

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
}

Szybki sprawdzian z podstaw API

Nauczyłeś się konfigurować podstawowy serwer Actix-web i obsługiwać różne żądania HTTP. Sprawdźmy, czy rozumiesz te zagadnienia!

Podsumowanie i dalsze kroki

Dobra robota! Wykonałeś pierwsze kroki w tworzeniu RESTful API za pomocą Rust i Actix-web.

Poznaliśmy podstawy REST API oraz powody, dla których Rust świetnie się do tego nadaje.
Nauczyłeś się konfigurować podstawowy projekt Actix-web.
Omówiliśmy definiowanie tras GET i POST.
Zobaczyłeś, jak pobierać parametry ścieżki i obsługiwać dane JSON.
Na koniec zbudowałeś proste API zarządzające stanem przechowywanym w pamięci za pomocą web::Data.

W następnej części dokładniej poznasz integrację z bazą danych i solidną obsługę błędów, aby tworzyć jeszcze bardziej zaawansowane i gotowe do wdrożenia usługi internetowe!

Często zadawane pytania

Czy lekcja „REST API z Actix-web/Rocket” jest bezpłatna?

Tak — pełny tekst „REST API z Actix-web/Rocket” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Learn Rust Coding, przejdź na CoddyKit PRO. Kurs Learn Rust Coding zawiera 3 lekcji w sumie.

Co nauczysz się w „REST API z Actix-web/Rocket”?

Stworzą Państwo RESTful API z użyciem nowoczesnego web frameworka Rust, takiego jak Actix-web lub Rocket, obsługujące trasy, żądania i odpowiedzi. Ćwiczysz Learn Rust Coding z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Learn Rust Coding?

Nie wymagamy żadnego doświadczenia. Learn Rust Coding w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 3.

Ile czasu zajmuje lekcja „REST API z Actix-web/Rocket”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Learn Rust Coding?

Tak. Każda lekcja Learn Rust Coding zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

REST API z Actix-web/Rocket
Integracja z bazami danych (SQLx/Diesel)
Uwierzytelnianie i autoryzacja

← Powrót do Learn Rust Coding