HTTP bruker en klient-server-arkitektur for informasjon og dataoverføring. En av funksjonene til programmeringsspråk på serversiden som Rust er å utvikle servere og klientapper for samhandling med HTTP-baserte tjenester.

Rust er egnet for å bygge HTTP-servere på grunn av funksjonene for sikkerhet, ytelse og pålitelighet. Rusts tredjepartskasser som Actix og Rocket er populære for å bygge sofistikerte webservere som kan håndtere høy trafikk.

Hvorfor bør du bruke Rust for utvikling av HTTP Web Server?

Rust har høstet popularitet for webserverutvikling siden noen av språkets funksjoner er nøyaktig kravene for å bygge de fleste webservere.

Bruk av Rust sikrer at applikasjonen din skaleres effektivt, noe som gjør språket ideelt for å bygge apper med høy ytelse. Her er spesifikke grunner til å vurdere å bruke Rust for webserveren og andre serversideapplikasjoner.

Rusts høye ytelse

Høy ytelse er en av grunnene til at Rust gjør et utmerket valg for å bygge HTTP-nettservere. Rust gir tilgang på lavt nivå til systemressurser, inkludert minne og CPU, slik at du kan skrive kode som kjører raskere med færre ressurser enn andre serversidespråk.

I tillegg eliminerer Rust sitt eierskapssystem behovet for søppelinnsamling ved kompilering, noe som er en av grunnene til at enkelte serversidespråk er trege.

Trygghet og sikkerhet

Rusts eierskapssystem for minneadministrasjon gjør språket sikkert for utvikling av webservere. Du opplever ikke null eller dinglende pekerreferanser som kan føre til minnelekkasjer og andre sikkerhetssårbarheter.

Rust sitt eierskapssystem forhindrer disse vanlige feilene for å holde serveren og appene dine sikre. Rust fokuserer også på å forhindre bufferoverløp og andre minnerelaterte feil.

Samtidighet

Samtidighet er muligheten til å kjøre flere enheter av et program på en uordnet måte uten å påvirke produksjonen. Utgangen til et samtidig program skal være den samme som utgangen til et asynkront program.

Samtidig kan det påvirke ytelsen til applikasjonen din betydelig, siden servere må håndtere flere forespørsler samtidig. Rust gir støtte for sameksistens med en lett gjengemodell.

Sausen med samtidig programmering i Rust er at eierskapssystemet lar deg skrive trådsikker kode uten behov for låser og andre synkroniseringsprimitiver.

Rust Standard Library og tredjepartspakker i Rust-økosystemet gi moderne verktøy for effektiv utvikling av webserver.

Cargo, Rusts pakkeansvarlige, forenkler avhengighetshåndtering og bygger prosesser. I tillegg har Rust utmerket IDE-støtte med verktøy som Rust Analyzer som gir sømløs kodefullføring, feilutheving og andre funksjoner.

Oversikt over Actix- og Rocket-bibliotekene

Rusts standardbibliotek har det meste av verktøyet du trenger for å bygge webservere. Tredjepartsbiblioteker liker Rakett og Actix forenkle å bygge applikasjoner på serversiden med Rust.

Actix og Rakett er populære Rust-nettverk, men bibliotekene er forskjellige i design og funksjoner.

Rocket er et nettrammeverk på høyt nivå som prioriterer produktivitet og brukervennlighet. Rocket gir mange abstraksjoner og syntakssukker for å bygge nettapper i Rust. Rocket er også populær for sin sterke skriving og intuitive API-design.

Du kan legge til Rocket som en prosjektavhengighet i din Cargo.toml fil for å komme i gang med å bygge nettapper i Rust:

[avhengigheter]
rakett = "0.4.11"

På den annen side er Actix-web et rammeverk på lavt nivå som prioriterer ytelse og skalerbarhet. Actix utnytter en aktørbasert samtidighetsmodell og gir ikke-blokkerende I/O som gjør pakken ideell for å bygge effektive webapplikasjoner.

Legg til Actix som en prosjektavhengighet i avhengigheter delen av din Cargo.toml fil:

[avhengigheter]
actix-web = "4.3.1"

Å velge et bibliotek for prosjektet ditt vil avhenge av prosjektets spesifikasjoner, funksjonene til biblioteket og din erfaring med Rust og HTTP.

Bygge en enkel webserver i Rust

Etter å ha opprettet et Rust-prosjekt og lagt til noen av Rocket- eller Actix-rammeverket til prosjektets avhengigheter i Cargo.toml fil, er du klar til å begynne å bygge en webserver i Rust.

Bygge en enkel webserver med Actix

Du kan bruke en serializer for forespørsler når du bygger webtjenester i Rust.

Serde er et populært Rust-bibliotek for serialisering og deserialisering av data mellom Rust-typer og dataformater som JSON, YAML og TOML. Serde gir et rammeverk for å definere datakonvertering mellom Rust-datastrukturer og tilsvarende representasjoner i andre dataformater.

Her er direktivet for å legge til Serde som en tredjepartspakke for prosjektet ditt.

[avhengigheter]
serde = { versjon = "1.0.159", funksjoner = ["avlede"] }

Når du har lagt til Serde og Actix som prosjektavhengigheter, kan du lage en grunnleggende webserver med Rust. Slik kan du sette opp en enkel Hei Verden! webserver som skriver en streng til klienten med Actix:

Importer først de nødvendige modulene og typene fra actix_web og serde kasser:

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

du vil bruke serde å serialisere en melding til klienten med en struktur. Serde vil konvertere strukturen til JSON for klienten. Her er strukturen for meldingen:

#[avlede (feilsøke, serialisere, deserialisere)]
strukturBeskjed {
 beskjed: String,
}

Du kan nå definere behandlerfunksjonen for endepunktet. På toppen av behandlerfunksjonen kan du legge til dekoratører for tilpasset oppførsel:

#[få("/")]
asynkronfnHallo() -> impl Svar {
 HttpResponse::Ok().json (Melding {
 beskjed: "Hei Verden!".to_owned(),
 })
}

De Hallo handlerfunksjonen håndterer GET-forespørsler. Funksjonen returnerer en type som implementerer Svar egenskap fra Actix pakke.

De json metoden for HttpResponse:: Ok() type tar i en struct-forekomst som Serde håndterer under panseret og returnerer responsen til klienten.

Etter å ha definert endepunktet, kan du starte en serverforekomst og montere endepunktet på en rute.

#[actix_web:: main]
asynkronfnhoved-() -> std:: io::Resultat {
 HttpServer:: new(|| App:: new().service (hei))
 .binde("127.0.0.1:8080")?
 .løpe()
 .avvente
}

De HttpServer:: ny funksjon er en ny serverforekomst. De hoved- funksjonen starter, og serveren monterer Hallo behandlerfunksjon med den nye appforekomsten. De binde metoden binder serveren til den angitte URL-en, og løpe funksjonen kjører serveren.

Bygge en enkel webserver med Rocket

Rocket er minimalistisk, så du kan sette opp en enkel webserver uten andre avhengigheter enn Rakett kasse.

Slik setter du opp en enkel server med en Hei Verden! endepunkt ved hjelp av Rocket:

Først importerer du de nødvendige avhengighetene for serveren din.

#![funksjon (proc_macro_hygiene, decl_macro)]
#[makro_bruk]
eksternkasse rakett;
// importerer fra Rocket-kassen
bruk rakett:: respons:: innhold;
bruk rakett:: Stat;

De #![funksjon (proc_macro_hygiene, decl_macro)] attributt aktiverer Rust-eksperimentelle funksjoner for Rocket-rammeverket. De #[makro_bruk] attributt importerer makroer fra rakett modul.

Her er en behandlerfunksjon som serverer HTML på forespørsel:

#[få("/")]
fnHei Verden() -> innhold:: Html'statiskstr> {
 innhold:: Html("
Hei Verden!
")
}

De Hei Verden funksjonen returnerer en HTML statisk streng med innhold:: Html funksjon.

Her er en konfigurasjonsstrukturerklæring for serveren (Rocket framework-konvensjon):

strukturKonfig {
 havn: u16,
}
#[få("/havn")]
fnhavn(config: State) -> String {
format!("Tjener kjører på port {}", config.port)
}

Når du kjører serveren, kan du sende forespørsler til /port endepunkt for portstatus.

Til slutt vil du opprette en serverforekomst med antennes funksjon. Legg til konfigurasjonene, monter rutene og start serveren:

fnhoved-() {
la config = Config { port: 8000 };
 rakett:: ignite()
 .manage (config)
 .mount("/", ruter![hello_world, port])
 .start();
}

De konfig variabel er en forekomst av Konfig struktur. De antennes funksjonen starter en serverforekomst, den få til metoden legger til konfigurasjonen til serveren, og montere metoden monterer behandlerfunksjonen på basisrutene. Til slutt, den lansering metoden starter serveren for å lytte på den angitte porten.

Du kan bygge kraftige webapplikasjoner i rust med WASM

WebAssembly (WASM) er et binært instruksjonsformat designet for kjøring på nettlesere og andre enheter. WASM gir et lavnivå bytekodeformat som programmeringsspråk på høyere nivå som Rust kan bruke som et kompileringsmål.

Med WASM kan du kompilere Rust-koden til et binært format som de fleste populære nettlesere kan kjøre. WASM åpner for en verden av muligheter for å bygge robuste webapplikasjoner i Rust, inkludert fullstack webapper.