Learn Rust Coding · Lezione

API REST con Actix-web/Rocket

Sviluppi API RESTful utilizzando un moderno framework web Rust come Actix-web o Rocket, gestendo route, richieste e risposte.

Lezione 1 di 311 passaggi

API REST con Actix-web/Rocket è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 1 di 3. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Learn Rust Coding, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn Rust Coding include 3 lezioni in totale.

Che cosa sono le API REST?

REST, ovvero REpresentational State Transfer, è uno stile architetturale per le applicazioni in rete. Definisce un insieme di principi che regolano il modo in cui i servizi web devono comunicare.

Lo si può considerare come un insieme di linee guida per creare servizi web stateless e memorizzabili nella cache, che usano i metodi HTTP standard per interagire con le risorse.

Risorse: qualsiasi elemento a cui si può assegnare un nome, come un utente, un prodotto o un ordine.
URI: identificatori univoci delle risorse (ad esempio /users/123).
Metodi HTTP: azioni standard eseguite sulle risorse (GET, POST, PUT, DELETE).

Perché usare Rust per i servizi web?

Rust offre vantaggi specifici nello sviluppo di servizi web, risultando una scelta eccellente per API affidabili e ad alte prestazioni:

Prestazioni: le astrazioni a costo zero di Rust producono codice altamente efficiente, spesso paragonabile a quello C/C++.
Sicurezza della memoria: il sistema di ownership previene bug comuni come il dereferenziamento di puntatori nulli e le race condition, rendendo i servizi più robusti.
Concorrenza: il modello async/await di Rust, insieme alle sue garanzie di sicurezza, permette di creare servizi web concorrenti senza timore.
Affidabilità: il sistema di tipi forte e i controlli in fase di compilazione individuano molti errori in anticipo.

Conoscere Actix-web

Per creare servizi web in Rust, si usano spesso i framework. Actix-web è un framework web per Rust potente, pragmatico ed estremamente veloce.

È basato su Actix, un framework basato sul modello degli attori, ma non è necessario conoscere gli attori per usare Actix-web in modo efficace. È progettato per le operazioni asincrone, quindi è ideale per attività vincolate dall'I/O, come la gestione di molte richieste API concorrenti.

Actix-web fornisce strumenti per il routing, la gestione delle richieste e delle risposte, il middleware e molto altro, semplificando la creazione di API complesse.

Configurazione del progetto e dipendenze

Per iniziare, creeremo un nuovo progetto Rust e aggiungeremo le dipendenze necessarie. Useremo actix-web per il framework e serde per serializzare e deserializzare i dati JSON.

Per prima cosa, crei un nuovo progetto:

cargo new my_rest_api --bin

Quindi aggiunga queste righe al file Cargo.toml, nella sezione [dependencies]:

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

Il primo server Actix-web

Scriviamo un server Actix-web minimale. Questo codice configura la struttura di base per ascoltare le richieste HTTP in arrivo sulla porta 8080. Non gestisce ancora percorsi specifici, ma costituisce il punto di partenza.

La macro #[actix_web::main] rende la nostra async fn main compatibile con il runtime di 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
}

Definire una route GET

Ora aggiungiamo una route semplice al server. Una route associa il percorso e il metodo di una richiesta HTTP in arrivo (ad esempio GET /hello) a una specifica funzione handler.

La nostra funzione handler hello_world restituirà semplicemente una stringa. web::get().to() registra questo handler per le richieste GET al percorso /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
}

Parametri del percorso per route dinamiche

Spesso le API devono gestire parti dinamiche dell'URL, come un ID o un nome. Actix-web usa i parametri del percorso per acquisire questi valori.

Definiamo un segnaposto nella route (ad esempio /{name}). Nell'handler usiamo web::Path<String> (o qualsiasi altro tipo deserializzabile) per estrarre il valore.

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
}

Gestire richieste POST e JSON

Per creare o aggiornare risorse, usiamo richieste POST o PUT, spesso inviando i dati nel corpo della richiesta in formato JSON.

Actix-web semplifica la gestione del JSON con web::Json<T>. Definiamo una struct Rust che corrisponde alla struttura JSON prevista, deriviamo Deserialize da serde e Actix-web analizza automaticamente il JSON in arrivo trasformandolo nella nostra struct.

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
}

Creare una semplice API con stato

Uniamo quanto appreso per creare una piccola API che gestisce in memoria un elenco di utenti. Useremo web::Data per condividere lo stato specifico dell'applicazione (il nostro elenco di utenti) tra gli handler.

std::sync::Mutex serve a consentire in sicurezza l'accesso modificabile alla nostra Vec<User> da più richieste concorrenti. Avremo endpoint per GET /users e 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
}

Verifica rapida sui concetti delle API

Ha imparato a configurare un server Actix-web di base e a gestire diversi tipi di richieste HTTP. Verifichiamo la sua comprensione!

Rispondi nella lezione interattiva

Riepilogo e prossimi passi

Ottimo lavoro! Ha mosso i primi passi nella creazione di API RESTful con Rust e Actix-web.

Abbiamo esaminato i fondamenti delle API REST e i motivi per cui Rust è una scelta eccellente.
Ha imparato a configurare un progetto Actix-web di base.
Abbiamo visto come definire route GET e POST.
Ha imparato a estrarre i parametri del percorso e a gestire i payload JSON.
Infine, ha creato una semplice API che gestisce lo stato in memoria usando web::Data.

Ora approfondirà l'integrazione con i database e la gestione robusta degli errori, per creare servizi web ancora più potenti e pronti per la produzione!

Gratis per iniziare

Impara Rust con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 39
Lezioni: 144

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «API REST con Actix-web/Rocket» è gratuita?

Sì — il testo completo di «API REST con Actix-web/Rocket» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Learn Rust Coding, passa a CoddyKit PRO. Il corso Learn Rust Coding include 3 lezioni in totale.

Cosa imparerò in «API REST con Actix-web/Rocket»?

Sviluppi API RESTful utilizzando un moderno framework web Rust come Actix-web o Rocket, gestendo route, richieste e risposte. Eserciti Learn Rust Coding con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Learn Rust Coding?

Non è richiesta alcuna esperienza precedente. Learn Rust Coding su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 3.

Quanto tempo richiede la lezione «API REST con Actix-web/Rocket»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Learn Rust Coding?

Sì. Ogni lezione Learn Rust Coding include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

API REST con Actix-web/Rocket
Integrazione con i database (SQLx/Diesel)
Autenticazione e autorizzazione

← Torna a Learn Rust Coding