HTTP använder en klient-server-arkitektur för information och dataöverföring. En av funktionerna i programmeringsspråk på serversidan som Rust är att utveckla servrar och klientappar för att interagera med HTTP-baserade tjänster.

Rust är lämplig för att bygga HTTP-servrar på grund av dess säkerhets-, prestanda- och tillförlitlighetsfunktioner. Rusts tredjepartslådor som Actix och Rocket är populära för att bygga sofistikerade webbservrar som kan hantera hög trafik.

Varför ska du använda Rust för utveckling av HTTP-webbserver?

Rust har fått popularitet för webbserverutveckling eftersom några av språkets funktioner är exakt kraven för att bygga de flesta webbservrar.

Att använda Rust säkerställer att din applikation skalas effektivt, vilket gör språket idealiskt för att bygga högpresterande appar. Här är specifika anledningar till att överväga att använda Rust för din webbserver och andra applikationer på serversidan.

Rosts höga prestanda

Hög prestanda är en av anledningarna till att Rust gör ett utmärkt val för att bygga HTTP-webbservrar. Rust ger åtkomst på låg nivå till systemresurser, inklusive minne och CPU, vilket gör att du kan skriva kod som körs snabbare med färre resurser än andra språk på serversidan.

Dessutom eliminerar Rusts ägarsystem behovet av sophämtning vid kompilering, vilket är en av anledningarna till att vissa språk på serversidan är långsamma.

Säkerhet och trygghet

Rusts ägandesystem för minneshantering gör språket säkert för webbserverutveckling. Du upplever inte noll eller dinglande pekarereferenser som kan leda till minnesläckor och andra säkerhetsbrister.

Rusts ägarsystem förhindrar dessa vanliga fel för att hålla din server och appar säkra. Rust fokuserar också på att förhindra buffertspill och andra minnesrelaterade fel.

Samtidighet

Samtidighet är möjligheten att köra flera enheter av ett program på ett ur funktion utan att påverka resultatet. Utdata från ett samtidigt program bör vara samma som ett asynkront programs utdata.

Samtidighet kan avsevärt påverka din applikations prestanda eftersom servrar måste hantera flera förfrågningar samtidigt. Rust ger stöd för samexistens med en lätt gängningsmodell.

Såsen med samtidig programmering i Rust är att ägarsystemet låter dig skriva trådsäker kod utan behov av lås och andra synkroniseringsprimitiver.

Rust Standard Library och tredjepartspaket i Rust-ekosystemet tillhandahålla moderna verktyg för effektiv webbserverutveckling.

Cargo, Rusts pakethanterare, förenklar beroendehantering och bygger processer. Dessutom har Rust utmärkt IDE-stöd med verktyg som Rust Analyzer som ger sömlös kodkomplettering, felmarkering och andra funktioner.

Översikt över Actix- och Rocket-biblioteken

Rusts standardbibliotek har det mesta av verktyget du behöver för att bygga webbservrar. Tredjepartsbibliotek som Raket och Actix förenkla att bygga applikationer på serversidan med Rust.

Actix och Raket är populära Rust webbramverk, men biblioteken skiljer sig åt i design och funktioner.

Rocket är ett webbramverk på hög nivå som prioriterar produktivitet och användarvänlighet. Rocket ger många abstraktioner och syntax socker för att bygga webbappar i Rust. Rocket är också populär för sin starka skrivning och intuitiva API-design.

Du kan lägga till Rocket som ett projektberoende i din Cargo.toml fil för att komma igång med att bygga webbappar i Rust:

[beroenden]
raket = "0.4.11"

Å andra sidan är Actix-web ett ramverk på låg nivå som prioriterar prestanda och skalbarhet. Actix utnyttjar en aktörsbaserad samtidighetsmodell och tillhandahåller icke-blockerande I/O som gör paketet idealiskt för att bygga effektiva webbapplikationer.

Lägg till Actix som ett projektberoende i beroenden avsnitt av din Cargo.toml fil:

[beroenden]
actix-web = "4.3.1"

Att välja ett bibliotek för ditt projekt beror på ditt projekts specifikationer, funktionerna i biblioteket och din erfarenhet av Rust och HTTP.

Bygga en enkel webbserver i Rust

Efter att ha skapat ett Rust-projekt och lagt till något av Rocket- eller Actix-ramverken till ditt projekts beroenden i Cargo.toml fil är du redo att börja bygga en webbserver i Rust.

Bygga en enkel webbserver med Actix

Du kan använda en serializer för förfrågningar när du bygger webbtjänster i Rust.

Serde är ett populärt Rust-bibliotek för att serialisera och deserialisera data mellan Rust-typer och dataformat som JSON, YAML och TOML. Serde tillhandahåller ett ramverk för att definiera datakonvertering mellan Rust-datastrukturer och motsvarande representationer i andra dataformat.

Här är direktivet för att lägga till Serde som ett tredjepartspaket för ditt projekt.

[beroenden]
serde = { version = "1.0.159", funktioner = ["härleda"] }

När du har lagt till Serde och Actix som projektberoenden kan du skapa en grundläggande webbserver med Rust. Så här kan du ställa in en enkel Hej världen! webbserver som skriver en sträng till klienten med Actix:

Importera först de nödvändiga modulerna och typerna från actix_web och serde lådor:

använda sig av actix_web::{get, webb, App, HttpResponse, HttpServer, Responder};
använda sig av serde::{Deserialize, Serialize};

Du kommer att använda serde att serialisera ett meddelande till klienten med en struktur. Serde kommer att konvertera strukturen till JSON för klienten. Här är strukturen för meddelandet:

#[härleda (Debug, Serialize, Deserialize)]
strukturMeddelande {
 meddelande: Sträng,
}

Du kan nu definiera hanterarfunktionen för slutpunkten. Överst i din hanterarfunktion kan du lägga till dekoratörer för anpassade beteenden:

#[skaffa sig("/")]
asynkronfnHallå() -> impl Svara {
 HttpResponse::Ok().json (Meddelande {
 meddelande: "Hej världen!".to_owned(),
 })
}

De Hallå hanterarfunktionen hanterar GET-förfrågningar. Funktionen returnerar en typ som implementerar Svara egenskap från Actix paket.

De json metod för HttpResponse:: Ok() typ tar i en struct-instans som Serde hanterar under huven och returnerar svaret till klienten.

Efter att ha definierat slutpunkten kan du starta en serverinstans och montera slutpunkten på en rutt.

#[actix_web:: main]
asynkronfnhuvud() -> std:: io::Resultat {
 HttpServer:: new(|| App:: new().service (hej))
 .binda("127.0.0.1:8080")?
 .springa()
 .vänta
}

De HttpServer:: ny funktion är en ny serverinstans. De huvud funktionen startar och servern monterar Hallå hanterarfunktion med den nya appinstansen. De binda metod binder servern till den angivna URL: en, och springa funktionen kör servern.

Bygga en enkel webbserver med raket

Rocket är minimalistisk, så du kan ställa in en enkel webbserver utan några andra beroenden än Raket spjällåda.

Så här ställer du in en enkel server med en Hej världen! slutpunkt med Rocket:

Importera först de nödvändiga beroenden för din server.

#![funktion (proc_macro_hygiene, decl_macro)]
#[makro_use]
externspjällåda raket;
// importerar från Rocket-lådan
använda sig av rocket:: respons:: innehåll;
använda sig av raket:: Stat;

De #![funktion (proc_macro_hygiene, decl_macro)] attribut möjliggör Rust-experimentella funktioner för Rocket-ramverket. De #[makro_use] attribut importerar makron från raket modul.

Här är en hanterarfunktion som serverar HTML på begäran:

#[skaffa sig("/")]
fnHej världen() -> innehåll:: Html'statiskstr> {
 innehåll:: Html("
Hej världen!
")
}

De Hej världen funktion returnerar en statisk HTML-sträng med innehåll:: Html fungera.

Här är en konfigurationsstrukturdeklaration för servern (Rocket Framework Convention):

strukturKonfig {
 hamn: u16,
}
#[skaffa sig("/hamn")]
fnhamn(config: State) -> Sträng {
formatera!("Server körs på port {}", config.port)
}

När du kör servern kan du göra förfrågningar till /port slutpunkt för hamnstatus.

Slutligen skapar du en serverinstans med antända fungera. Lägg till konfigurationerna, montera rutterna och starta servern:

fnhuvud() {
låta config = Config { port: 8000 };
 raket:: antända()
 .manage (config)
 .montera("/", rutter![hello_world, port])
 .lansera();
}

De config variabel är en instans av Konfig struktur. De antända funktionen startar en serverinstans, den hantera metod lägger till konfigurationen till servern och montera metod monterar hanterarfunktionen på basrutterna. Slutligen, den lansera metoden startar servern för att lyssna på den angivna porten.

Du kan bygga kraftfulla webbapplikationer i rost med WASM

WebAssembly (WASM) är ett binärt instruktionsformat designat för exekvering på webbläsare och andra enheter. WASM tillhandahåller ett bytekodformat på låg nivå som programmeringsspråk på högre nivå som Rust kan använda som ett kompileringsmål.

Med WASM kan du kompilera din Rust-kod till ett binärt format som de flesta populära webbläsare kan köra. WASM öppnar upp en värld av möjligheter för att bygga robusta webbapplikationer i Rust, inklusive full-stack webbappar.