HTTP bruger en klient-server-arkitektur til information og dataoverførsel. En af funktionerne ved programmeringssprog på serversiden som Rust er at udvikle servere og klientapps til at interagere med HTTP-baserede tjenester.

Rust er velegnet til at bygge HTTP-servere på grund af dets sikkerhed, ydeevne og pålidelighed. Rusts tredjepartskasser som Actix og Rocket er populære til at bygge sofistikerede webservere, der kan håndtere høj trafik.

Hvorfor skal du bruge Rust til HTTP-webserverudvikling?

Rust har vundet popularitet til udvikling af webservere, da nogle af sprogets funktioner er præcis kravene til at bygge de fleste webservere.

Brug af Rust sikrer, at din applikation skaleres effektivt, hvilket gør sproget ideelt til at bygge højtydende apps. Her er specifikke grunde til at overveje at bruge Rust til din webserver og andre server-side applikationer.

Rusts høje ydeevne

Høj ydeevne er en af ​​grundene til, at Rust gør et fremragende valg til at bygge HTTP-webservere. Rust giver adgang på lavt niveau til systemressourcer, inklusive hukommelsen og CPU, så du kan skrive kode, der kører hurtigere med færre ressourcer end andre sprog på serversiden.

Derudover eliminerer Rusts ejerskabssystem behovet for affaldsindsamling på kompileringstidspunktet, hvilket er en af ​​grundene til, at nogle sprog på serversiden er langsomme.

Sikkerhed og sikkerhed

Rusts ejerskabssystem for hukommelsesstyring gør sproget sikkert til udvikling af webservere. Du oplever ikke nul eller dinglende pointereferencer, der kan føre til hukommelseslækager og andre sikkerhedssårbarheder.

Rusts ejerskabssystem forhindrer disse almindelige fejl for at holde din server og apps sikre. Rust fokuserer også på at forhindre bufferoverløb og andre hukommelsesrelaterede fejl.

Samtidighed

Samtidighed er evnen til at køre flere enheder af et program på en ude af rækkefølge uden at påvirke outputtet. Outputtet af et samtidig program skal være det samme som et asynkront programs output.

Samtidighed kan påvirke din applikations ydeevne betydeligt, da servere skal håndtere flere anmodninger samtidigt. Rust giver støtte til sameksistens med en let gevindmodel.

Saucen ved samtidig programmering i Rust er, at ejerskabssystemet giver dig mulighed for at skrive trådsikker kode uden behov for låse og andre synkroniseringsprimitiver.

Ruststandardbiblioteket og tredjepartspakker i Rust-økosystemet give moderne værktøj til effektiv udvikling af webservere.

Cargo, Rusts pakkeansvarlige, forenkler afhængighedsstyring og opbygger processer. Derudover har Rust fremragende IDE-understøttelse med værktøjer som Rust Analyzer, der giver problemfri kodefuldførelse, fejlfremhævning og andre funktioner.

Oversigt over Actix- og Rocket-bibliotekerne

Rusts standardbibliotek har det meste af de værktøjer, du skal bruge til at bygge webservere. Tredjepartsbiblioteker som Raket og Actix forenkle bygning af server-side applikationer med Rust.

Actix og Raket er populære Rust-webrammer, men bibliotekerne er forskellige i design og funktioner.

Rocket er en webramme på højt niveau, der prioriterer produktivitet og brugervenlighed. Rocket giver en masse abstraktioner og syntakssukker til at bygge webapps i Rust. Rocket er også populær for dets stærke skrivning og intuitive API-design.

Du kan tilføje Rocket som en projektafhængighed i din Cargo.toml fil for at komme i gang med at bygge webapps i Rust:

[afhængigheder]
raket = "0.4.11"

På den anden side er Actix-web en ramme på lavt niveau, der prioriterer ydeevne og skalerbarhed. Actix udnytter en aktørbaseret samtidighedsmodel og giver ikke-blokerende I/O, der gør pakken ideel til at bygge effektive webapplikationer.

Tilføj Actix som en projektafhængighed i afhængigheder afsnit af din Cargo.toml fil:

[afhængigheder]
actix-web = "4.3.1"

At vælge et bibliotek til dit projekt vil afhænge af dit projekts specifikationer, bibliotekets funktioner og din erfaring med Rust og HTTP.

Opbygning af en simpel webserver i Rust

Efter at have oprettet et Rust-projekt og tilføjet nogen af ​​Rocket- eller Actix-rammerne til dit projekts afhængigheder i Cargo.toml fil, er du klar til at begynde at bygge en webserver i Rust.

Opbygning af en simpel webserver med Actix

Du kan bruge en serializer til anmodninger, når du bygger webtjenester i Rust.

Serde er et populært Rust-bibliotek til serialisering og deserialisering af data mellem Rust-typer og dataformater som JSON, YAML og TOML. Serde giver en ramme til at definere datakonvertering mellem Rust-datastrukturer og tilsvarende repræsentationer i andre dataformater.

Her er direktivet for at tilføje Serde som en tredjepartspakke til dit projekt.

[afhængigheder]
serde = { version = "1.0.159", funktioner = ["aflede"] }

Når du har tilføjet Serde og Actix som projektafhængigheder, kan du skabe en grundlæggende webserver med Rust. Sådan kan du konfigurere en simpel Hej Verden! webserver, der skriver en streng til klienten med Actix:

Først skal du importere de nødvendige moduler og typer fra actix_web og serde kasser:

brug actix_web::{get, web, App, HttpResponse, HttpServer, Responder};
brug serde::{Deserialize, Serialize};

du vil bruge serde at serialisere en besked til klienten med en struktur. Serde vil konvertere strukturen til JSON for klienten. Her er strukturen for beskeden:

#[aflede (Debug, Serialize, Deserialize)]
strukturBesked {
 besked: Snor,
}

Du kan nu definere handlerfunktionen for slutpunktet. Øverst i din handlerfunktion kan du tilføje dekoratører til tilpasset adfærd:

#[få("/")]
asynkronfnHej() -> impl Svar {
 HttpResponse::Okay().json (Besked {
 besked: "Hej Verden!".to_owned(),
 })
}

Det Hej handlerfunktion håndterer GET-anmodninger. Funktionen returnerer en type, der implementerer Svar egenskab fra Actix pakke.

Det json metoden til HttpResponse:: Ok() type tager i en struct-instans, der Serde håndterer under emhætten og returnerer svaret til klienten.

Efter at have defineret slutpunktet, kan du starte en serverinstans og montere slutpunktet på en rute.

#[actix_web:: main]
asynkronfnvigtigste() -> std:: io::Resultat {
 HttpServer:: new(|| App:: new().service (hej))
 .binde("127.0.0.1:8080")?
 .løb()
 .vente
}

Det HttpServer:: ny funktion er en ny serverinstans. Det vigtigste funktionen starter, og serveren monterer Hej handlerfunktion med den nye app-instans. Det binde metoden binder serveren til den angivne URL, og løb funktion kører serveren.

Opbygning af en simpel webserver med Rocket

Rocket er minimalistisk, så du kan opsætte en simpel webserver uden andre afhængigheder end Raket kasse.

Sådan opsætter du en simpel server med en Hej Verden! endepunkt ved hjælp af Rocket:

Først skal du importere de nødvendige afhængigheder til din server.

#![funktion (proc_macro_hygiene, decl_macro)]
#[makro_brug]
eksternkasse raket;
// importerer fra Rocket-kassen
brug raket:: svar:: indhold;
brug raket:: Stat;

Det #![funktion (proc_macro_hygiene, decl_macro)] attribut aktiverer Rust-eksperimentelle funktioner til Rocket-rammen. Det #[makro_brug] attribut importerer makroer fra raket modul.

Her er en behandlerfunktion, der serverer HTML på anmodning:

#[få("/")]
fnHej Verden() -> indhold:: Html'statiskstr> {
 indhold:: Html("
Hej Verden!
")
}

Det Hej Verden funktion returnerer en HTML statisk streng med indhold:: Html fungere.

Her er en konfigurationsstrukturerklæring for serveren (Rocket framework-konvention):

strukturKonfig {
 Havn: u16,
}
#[få("/Havn")]
fnHavn(config: State) -> Snor {
format!("Server kører på port {}", config.port)
}

Når du kører serveren, kan du lave anmodninger til /port endepunkt for havnestatus.

Til sidst skal du oprette en serverinstans med antænde fungere. Tilføj konfigurationerne, monter ruterne, og start serveren:

fnvigtigste() {
lade config = Config { port: 8000 };
 raket:: antænde()
 .manage (config)
 .mount("/", ruter![hello_world, port])
 .start();
}

Det config variabel er en forekomst af Konfig struktur. Det antænde funktionen starter en serverinstans, den styre metode tilføjer konfigurationen til serveren, og montere metode monterer handlerfunktionen på basisruterne. Endelig lancering metoden starter serveren for at lytte på den angivne port.

Du kan bygge kraftfulde webapplikationer i rust med WASM

WebAssembly (WASM) er et binært instruktionsformat designet til udførelse på browsere og andre enheder. WASM leverer et lavniveau bytekodeformat, som programmeringssprog på højere niveau som Rust kan bruge som kompileringsmål.

Med WASM kan du kompilere din Rust-kode til et binært format, som de fleste populære browsere kan udføre. WASM åbner op for en verden af ​​muligheder for at bygge robuste webapplikationer i Rust, inklusive full-stack webapps.