HTTP utilizza un'architettura client-server per il trasferimento di informazioni e dati. Una delle caratteristiche dei linguaggi di programmazione lato server come Rust è lo sviluppo di server e app client per l'interazione con i servizi basati su HTTP.

Rust è adatto alla creazione di server HTTP grazie alle sue caratteristiche di sicurezza, prestazioni e affidabilità. Le casse di terze parti di Rust come Actix e Rocket sono popolari per la creazione di server Web sofisticati in grado di gestire un traffico elevato.

Perché dovresti usare Rust per lo sviluppo di server Web HTTP?

Rust ha guadagnato popolarità per lo sviluppo di server Web poiché alcune delle caratteristiche del linguaggio sono esattamente i requisiti per la creazione della maggior parte dei server Web.

L'uso di Rust assicura che la tua applicazione si ridimensioni in modo efficiente, rendendo il linguaggio ideale per la creazione di app ad alte prestazioni. Ecco i motivi specifici per considerare l'utilizzo di Rust per il tuo server web e altre applicazioni lato server.

Le alte prestazioni di Rust

Le alte prestazioni sono uno dei motivi per cui Rust è una scelta eccellente per la creazione di server Web HTTP. Rust fornisce un accesso di basso livello alle risorse di sistema, inclusa la memoria e la CPU, consentendo di scrivere codice che viene eseguito più velocemente con meno risorse rispetto ad altri linguaggi lato server.

Inoltre, il sistema di proprietà di Rust elimina la necessità della raccolta dei rifiuti in fase di compilazione, che è uno dei motivi per cui alcuni linguaggi lato server sono lenti.

Sicurezza e protezione

Il sistema proprietario di gestione della memoria di Rust rende il linguaggio sicuro per lo sviluppo di server web. Non si verificano riferimenti a puntatori nulli o penzolanti che possono causare perdite di memoria e altre vulnerabilità di sicurezza.

Il sistema di proprietà di Rust previene questi errori comuni per proteggere il tuo server e le tue app. Rust si concentra anche sulla prevenzione di buffer overflow e altri errori relativi alla memoria.

Concorrenza

La concorrenza è la capacità di eseguire più unità di un programma in modo non ordinato senza influire sull'output. L'output di un programma concorrente dovrebbe essere lo stesso dell'output di un programma asincrono.

La concorrenza può influire in modo significativo sulle prestazioni dell'applicazione poiché i server devono gestire più richieste contemporaneamente. Rust fornisce supporto per la coesistenza con un modello di threading leggero.

Il vantaggio della programmazione concorrente in Rust è che il sistema di proprietà consente di scrivere codice thread-safe senza la necessità di blocchi e altre primitive di sincronizzazione.

La libreria standard di Rust e pacchetti di terze parti nell'ecosistema Rust fornire strumenti moderni per l'efficacia sviluppo di server web.

Cargo, il gestore di pacchetti di Rust, semplifica la gestione delle dipendenze e crea processi. Inoltre, Rust ha un eccellente supporto IDE con strumenti come Rust Analyzer che forniscono il completamento del codice senza interruzioni, l'evidenziazione degli errori e altre funzionalità.

Panoramica delle librerie Actix e Rocket

La libreria standard di Rust ha la maggior parte dell'utilità di cui avrai bisogno per creare server web. Librerie di terze parti come Razzo E Actix semplifica la creazione di applicazioni lato server con Rust.

Actix E Razzo sono popolari framework web di Rust, ma le librerie differiscono per design e caratteristiche.

Rocket è un framework web di alto livello che privilegia la produttività e la facilità d'uso. Rocket fornisce molte astrazioni e zucchero di sintassi per la creazione di app Web in Rust. Rocket è anche famoso per la sua forte tipizzazione e il design intuitivo dell'API.

Puoi aggiungere Rocket come dipendenza del progetto nel tuo Cargo.toml file per iniziare a creare app web in Rust:

[dipendenze]
razzo = "0.4.11"

D'altra parte, Actix-web è un framework di basso livello che privilegia le prestazioni e la scalabilità. Actix sfrutta un modello di concorrenza basato su attori e fornisce I/O non bloccanti che rendono il pacchetto ideale per la creazione di applicazioni Web performanti.

Aggiungere Actix come dipendenza del progetto nel file dipendenze sezione del tuo Cargo.toml file:

[dipendenze]
actix-web = "4.3.1"

La scelta di una libreria per il tuo progetto dipenderà dalle specifiche del tuo progetto, dalle caratteristiche della libreria e dalla tua esperienza con Rust e HTTP.

Costruire un semplice server Web in Rust

Dopo aver creato un progetto Rust e aver aggiunto uno qualsiasi dei framework Rocket o Actix alle dipendenze del tuo progetto nel file Cargo.toml file, sei pronto per iniziare a costruire un server web in Rust.

Costruire un semplice server Web con Actix

Puoi utilizzare un serializzatore per le richieste durante la creazione di servizi web in Rust.

Serde è una popolare libreria Rust per serializzare e deserializzare dati tra tipi Rust e formati dati come JSON, YAML e TOML. Serde fornisce un framework per definire la conversione dei dati tra le strutture dati di Rust e le corrispondenti rappresentazioni in altri formati di dati.

Ecco la direttiva per aggiungere Serde come pacchetto di terze parti per il tuo progetto.

[dipendenze]
serde = { versione = "1.0.159", caratteristiche = ["derivare"] }

Dopo aver aggiunto Serde e Actix come dipendenze del progetto, puoi generare un server Web di base con Rust. Ecco come puoi impostare un semplice Ciao mondo! server web che scrive una stringa al client con Actix:

Innanzitutto, importa i moduli e i tipi necessari dal file actix_web E serde casse:

utilizzo actix_web::{get, web, App, HttpResponse, HttpServer, Responder};
utilizzo serde::{Deserializza, Serializza};

Userai serde per serializzare un messaggio al client con una struct. Serde convertirà la struttura in JSON per il client. Ecco la struttura per il messaggio:

#[derive (Debug, Serializza, Deserializza)]
structMessaggio {
 Messaggio: Corda,
}

È ora possibile definire la funzione del gestore per l'endpoint. Nella parte superiore della funzione del gestore, puoi aggiungere decoratori per comportamenti personalizzati:

#[Ottenere("/")]
asincronofnCiao() -> imp Risponditore {
 Risposta Http::OK().json (messaggio {
 Messaggio: "Ciao mondo!".a_posseduto(),
 })
}

IL Ciao la funzione gestore gestisce le richieste GET. La funzione restituisce un tipo che implementa il Risponditore tratto dal Actix pacchetto.

IL json metodo del HttpResponse:: Ok() type accetta un'istanza struct che Serde gestisce sotto il cofano e restituisce la risposta al cliente.

Dopo aver definito l'endpoint, puoi avviare un'istanza del server e montare l'endpoint su una route.

#[actix_web:: principale]
asincronofnprincipale() -> std:: io::Risultato {
 HttpServer:: new(|| App:: new().service (ciao))
 .legamento("127.0.0.1:8080")?
 .correre()
 .attendere
}

IL HttpServer:: nuovo function è una nuova istanza del server. IL principale la funzione viene avviata e il server monta il file Ciao funzione del gestore con la nuova istanza dell'app. IL legamento Il metodo associa il server all'URL specificato e il metodo correre la funzione esegue il server.

Costruire un semplice server Web con Rocket

Rocket è minimalista, quindi puoi configurare un semplice server Web senza dipendenze diverse da Razzo cassa.

Ecco come configurare un semplice server con a Ciao mondo! endpoint utilizzando Rocket:

Innanzitutto, importa le dipendenze necessarie per il tuo server.

#![funzione (proc_macro_hygiene, decl_macro)]
#[macro_uso]
esternocassa razzo;
// importazioni dalla cassa Rocket
utilizzo razzo:: risposta:: contenuto;
utilizzo razzo:: Stato;

IL #![funzione (proc_macro_hygiene, decl_macro)] L'attributo abilita le funzionalità sperimentali di Rust per il framework Rocket. IL #[macro_uso] L'attributo importa le macro dal file razzo modulo.

Ecco una funzione di gestione che serve HTML su richiesta:

#[Ottenere("/")]
fnCiao mondo() -> contenuto:: Html'staticostr> {
 contenuto:: Html("
Ciao mondo!
")
}

IL Ciao mondo La funzione restituisce una stringa statica HTML con l'estensione contenuto:: Html funzione.

Ecco una dichiarazione della struttura di configurazione per il server (convenzione del framework Rocket):

structConfigurazione {
 porta: u16,
}
#[Ottenere("/porta")]
fnporta(configurazione: Stato) -> Corda {
formato!("Server in esecuzione sulla porta {}", config.porta)
}

Quando esegui il server, puoi effettuare richieste al file /port endpoint per lo stato della porta.

Infine, creerai un'istanza del server con il file accendere funzione. Aggiungi le configurazioni, monta i percorsi e avvia il server:

fnprincipale() {
permettere config = Config { porta: 8000 };
 razzo:: ignite()
 .manage (configurazione)
 .montare("/", rotte![ciao_mondo, porto])
 .lancio();
}

IL config variabile è un'istanza di Configurazione struct. IL accendere La funzione avvia un'istanza del server, il maneggio Il metodo aggiunge la configurazione al server e il metodo montare Il metodo monta la funzione del gestore sulle route di base. Infine il lancio Il metodo avvia il server in ascolto sulla porta specificata.

Puoi creare potenti applicazioni Web in Rust con WASM

WebAssembly (WASM) è un formato di istruzioni binarie progettato per l'esecuzione su browser e altri dispositivi. WASM fornisce un formato bytecode di basso livello che i linguaggi di programmazione di livello superiore come Rust possono utilizzare come destinazione di compilazione.

Con WASM, puoi compilare il tuo codice Rust in un formato binario eseguibile dalla maggior parte dei browser più diffusi. WASM apre un mondo di possibilità per la creazione di solide applicazioni web in Rust, comprese le web app full-stack.