HTTP utilizează o arhitectură client-server pentru transferul de informații și date. Una dintre caracteristicile limbajelor de programare pe server, cum ar fi Rust, este dezvoltarea de servere și aplicații client pentru a interacționa cu serviciile bazate pe HTTP.

Rust este potrivit pentru construirea de servere HTTP datorită caracteristicilor sale de siguranță, performanță și fiabilitate. Lăzile terțe ale Rust, cum ar fi Actix și Rocket, sunt populare pentru construirea de servere web sofisticate care pot gestiona trafic ridicat.

De ce ar trebui să utilizați Rust pentru dezvoltarea serverului web HTTP?

Rust a câștigat popularitate pentru dezvoltarea serverelor web, deoarece unele dintre caracteristicile limbajului sunt exact cerințele pentru construirea majorității serverelor web.

Utilizarea Rust asigură scalarea eficientă a aplicației dvs., făcând limbajul ideal pentru construirea de aplicații de înaltă performanță. Iată motivele specifice pentru a lua în considerare utilizarea Rust pentru serverul dvs. web și alte aplicații de pe server.

Performanța înaltă a lui Rust

Performanța ridicată este unul dintre motivele pentru care Rust face o alegere excelentă pentru construirea de servere web HTTP. Rust oferă acces la nivel scăzut la resursele de sistem, inclusiv la memorie și CPU, permițându-vă să scrieți cod care rulează mai rapid, cu mai puține resurse decât alte limbi de pe partea de server.

În plus, sistemul de proprietate al lui Rust elimină nevoia de colectare a gunoiului în timpul compilării, ceea ce este unul dintre motivele pentru care unele limbaje de pe server sunt lente.

Siguranță și securitate

Sistemul de gestionare a memoriei al Rust face ca limbajul să fie sigur pentru dezvoltarea serverului web. Nu întâmpinați referințe de pointer nule sau suspendate care pot duce la scurgeri de memorie și alte vulnerabilități de securitate.

Sistemul de proprietate al lui Rust previne aceste erori comune pentru a vă menține serverul și aplicațiile în siguranță. Rust se concentrează, de asemenea, pe prevenirea depășirilor de buffer și a altor erori legate de memorie.

Concurență

Concurența este capacitatea de a rula mai multe unități ale unui program într-o manieră nerespectată fără a afecta rezultatul. Ieșirea unui program concurent ar trebui să fie aceeași cu cea a unui program asincron.

Concurența poate afecta semnificativ performanța aplicației dvs., deoarece serverele trebuie să gestioneze mai multe solicitări simultan. Rust oferă suport pentru coexistență cu un model ușor de filet.

Sosul programării concurente în Rust este că sistemul de proprietate vă permite să scrieți cod sigur fără a fi nevoie de blocări și alte primitive de sincronizare.

Biblioteca Rust Standard și pachete terțe în ecosistemul Rust furniza instrumente moderne pentru eficient dezvoltare server web.

Cargo, managerul de pachete de la Rust, simplifică gestionarea dependenței și construiește procese. În plus, Rust are un excelent suport IDE cu instrumente precum Rust Analyzer, care oferă completarea fără probleme a codului, evidențierea erorilor și alte caracteristici.

Prezentare generală a bibliotecilor Actix și Rocket

Biblioteca standard a Rust are cea mai mare parte a utilitarului de care veți avea nevoie pentru a construi servere web. Biblioteci terță parte, cum ar fi Rachetă și Actix simplificați construirea de aplicații pe server cu Rust.

Actix și Rachetă sunt cadre web Rust populare, dar bibliotecile diferă ca design și caracteristici.

Rocket este un cadru web de nivel înalt care prioritizează productivitatea și ușurința în utilizare. Rocket oferă o mulțime de abstracții și zahăr de sintaxă pentru construirea de aplicații web în Rust. Rocket este, de asemenea, popular pentru tastarea sa puternică și designul API intuitiv.

Puteți adăuga Rocket ca dependență de proiect în dvs Marfă.toml fișier pentru a începe să construiți aplicații web în Rust:

[dependențe]
rachetă = "0.4.11"

Pe de altă parte, Actix-web este un cadru de nivel scăzut care prioritizează performanța și scalabilitatea. Actix folosește un model de concurență bazat pe actor și oferă I/O non-blocante, ceea ce face ca pachetul să fie ideal pentru construirea de aplicații web performante.

Adăugați Actix ca dependență de proiect în dependențe secțiunea dvs Marfă.toml fişier:

[dependențe]
actix-web = "4.3.1"

Alegerea unei biblioteci pentru proiectul dvs. va depinde de specificațiile proiectului dvs., de caracteristicile bibliotecii și de experiența dvs. cu Rust și HTTP.

Construirea unui server web simplu în Rust

După ce ai creat un proiect Rust și a adăugat oricare dintre cadrele Rocket sau Actix la dependențele proiectului tău în Marfă.toml fișier, sunteți gata să începeți să construiți un server web în Rust.

Construirea unui server web simplu cu Actix

Puteți utiliza un serializator pentru solicitări atunci când construiți servicii web în Rust.

Serde este o bibliotecă Rust populară pentru serializarea și deserializarea datelor între tipurile Rust și formatele de date precum JSON, YAML și TOML. Serde oferă un cadru pentru definirea conversiei datelor între structurile de date Rust și reprezentările corespunzătoare în alte formate de date.

Iată directiva pentru adăugarea Serde ca pachet terță parte pentru proiectul dvs.

[dependențe]
serde = { versiunea = "1.0.159", caracteristici = ["deriva"] }

După ce ați adăugat Serde și Actix ca dependențe de proiect, puteți crea un server web de bază cu Rust. Iată cum puteți configura un simplu Salut Lume! server web care scrie un șir clientului cu Actix:

Mai întâi, importați modulele și tipurile necesare din actix_web și serde cutii:

utilizare actix_web::{get, web, App, HttpResponse, HttpServer, Responder};
utilizare serde::{Deserializare, Serializare};

Vei folosi serde pentru a serializa un mesaj către client cu o struct. Serde va converti structura în JSON pentru client. Iată structura mesajului:

#[derivare (depanare, serializare, deserializare)]
structMesaj {
 mesaj: Şir,
}

Acum puteți defini funcția de gestionare pentru punctul final. În partea de sus a funcției de gestionare, puteți adăuga decoratori pentru comportamente personalizate:

#[obține("/")]
asincronfnBuna ziua() -> impl Răspuns {
 HttpResponse::Bine().json (Mesajul {
 mesaj: "Salut Lume!".to_owned(),
 })
}

The Buna ziua funcția handler gestionează cererile GET. Funcția returnează un tip care implementează Răspuns trăsătură din Actix pachet.

The json metoda de HttpResponse:: Ok() type preia o instanță struct care Serde manere sub capota si returneaza raspunsul clientului.

După definirea punctului final, puteți porni o instanță de server și puteți monta punctul final pe o rută.

#[actix_web:: principal]
asincronfnprincipal() -> std:: io::Rezultat {
 HttpServer:: new(|| App:: new().service (bună ziua))
 .lega("127.0.0.1:8080")?
 .alerga()
 .asteapta
}

The HttpServer:: nou funcția este o instanță nouă de server. The principal funcția pornește și serverul montează Buna ziua funcția de gestionare cu noua instanță a aplicației. The lega metoda leagă serverul la adresa URL specificată și alerga funcția rulează serverul.

Construirea unui server web simplu cu Rocket

Rocket este minimalist, așa că puteți configura un server web simplu, fără alte dependențe decât cel Rachetă ladă.

Iată cum să configurați un server simplu cu un Salut Lume! punct final folosind Rocket:

Mai întâi, importați dependențele necesare pentru serverul dvs.

#![funcție (proc_macro_hygiene, decl_macro)]
#[macro_use]
externladă rachetă;
// importuri din cutia Rocket
utilizare racheta:: raspuns:: continut;
utilizare racheta:: Stat;

The #![funcție (proc_macro_hygiene, decl_macro)] Atributul activează caracteristicile experimentale Rust pentru cadrul Rocket. The #[macro_use] atributul importă macrocomenzi din rachetă modul.

Iată o funcție de gestionare care servește HTML la cerere:

#[obține("/")]
fnSalut Lume() -> conținut:: Html'staticstr> {
 continut:: HTML("
Salut Lume!
")
}

The Salut Lume funcția returnează un șir static HTML cu continut:: Html funcţie.

Iată o declarație a structurii de configurare pentru server (convenția cadru Rocket):

structConfig {
 port: u16,
}
#[obține("/port")]
fnport(config: stare) -> Şir {
format!(„Server rulează pe portul {}”, config.port)
}

Când rulați serverul, puteți face cereri către /port punctul final pentru starea portului.

În cele din urmă, veți crea o instanță de server cu aprinde funcţie. Adăugați configurațiile, montați rutele și lansați serverul:

fnprincipal() {
lăsa config = Config { port: 8000 };
 racheta:: aprinde()
 .manage (config)
 .montură("/", rute![hello_world, port])
 .lansa();
}

The config variabila este o instanță a Config struct. The aprinde funcția pornește o instanță de server, the administra metoda adaugă configurația la server și montură metoda montează funcția handler pe rutele de bază. În cele din urmă, cel lansa metoda lansează serverul pentru a asculta pe portul specificat.

Puteți construi aplicații web puternice în Rust cu WASM

WebAssembly (WASM) este un format de instrucțiuni binar conceput pentru execuție pe browsere și alte dispozitive. WASM oferă un format de cod de octet de nivel scăzut pe care limbajele de programare de nivel superior, cum ar fi Rust, îl pot folosi ca țintă de compilare.

Cu WASM, vă puteți compila codul Rust într-un format binar pe care îl pot executa majoritatea browserelor populare. WASM deschide o lume de posibilități pentru construirea de aplicații web robuste în Rust, inclusiv aplicații web full-stack.