HTTP maakt gebruik van een client-serverarchitectuur voor informatie- en gegevensoverdracht. Een van de kenmerken van programmeertalen aan de serverzijde, zoals Rust, is het ontwikkelen van servers en client-apps voor interactie met op HTTP gebaseerde services.

Rust is geschikt voor het bouwen van HTTP-servers vanwege de veiligheids-, prestatie- en betrouwbaarheidsfuncties. De kratten van derden van Rust, zoals Actix en Rocket, zijn populair voor het bouwen van geavanceerde webservers die veel verkeer aankunnen.

Waarom zou u Rust gebruiken voor de ontwikkeling van HTTP-webservers?

Rust is populair geworden voor de ontwikkeling van webservers, omdat sommige functies van de taal precies de vereisten zijn voor het bouwen van de meeste webservers.

Het gebruik van Rust zorgt ervoor dat uw applicatie efficiënt schaalt, waardoor de taal ideaal is voor het bouwen van krachtige apps. Hier zijn specifieke redenen om te overwegen Rust te gebruiken voor uw webserver en andere server-side applicaties.

Rust's hoge prestaties

Hoge prestaties zijn een van de redenen waarom Rust een uitstekende keuze is voor het bouwen van HTTP-webservers. Rust biedt toegang op laag niveau tot systeembronnen, inclusief het geheugen en de CPU, waardoor u code kunt schrijven die sneller werkt met minder bronnen dan andere server-side talen.

Bovendien elimineert het eigendomssysteem van Rust de noodzaak van afvalverzameling tijdens het compileren, wat een van de redenen is waarom sommige server-side talen traag zijn.

Veiligheid en beveiliging

Het eigendomssysteem van Rust voor geheugenbeheer maakt de taal veilig voor de ontwikkeling van webservers. U ervaart geen null- of loshangende pointerreferenties die kunnen leiden tot geheugenlekken en andere beveiligingsproblemen.

Het eigendomssysteem van Rust voorkomt deze veelvoorkomende fouten om uw server en apps veilig te houden. Rust richt zich ook op het voorkomen van bufferoverflows en andere geheugengerelateerde fouten.

gelijktijdigheid

Gelijktijdigheid is de mogelijkheid om meerdere eenheden van een programma op een niet-geordende manier uit te voeren zonder de uitvoer te beïnvloeden. De uitvoer van een gelijktijdig programma moet hetzelfde zijn als de uitvoer van een asynchroon programma.

Gelijktijdigheid kan de prestaties van uw applicatie aanzienlijk beïnvloeden, aangezien servers meerdere verzoeken tegelijk moeten afhandelen. Rust biedt ondersteuning voor coëxistentie met een lichtgewicht draadmodel.

De saus van gelijktijdig programmeren in Rust is dat het eigendomssysteem je in staat stelt thread-safe code te schrijven zonder dat je sloten en andere synchronisatie-primitieven nodig hebt.

De Rust Standaard Bibliotheek en pakketten van derden in het Rust-ecosysteem bieden moderne tooling voor effectief ontwikkeling van webservers.

Cargo, de pakketbeheerder van Rust, vereenvoudigt afhankelijkheidsbeheer en bouwt processen. Bovendien heeft Rust uitstekende IDE-ondersteuning met tools zoals Rust Analyzer die naadloze codeaanvulling, foutmarkering en andere functies bieden.

Overzicht van de Actix- en Rocket-bibliotheken

Rust's Standard Library heeft het grootste deel van het hulpprogramma dat u nodig heeft om webservers te bouwen. Bibliotheken van derden zoals Raket En Actix vereenvoudig het bouwen van server-side applicaties met Rust.

Actix En Raket zijn populaire Rust-webframeworks, maar de bibliotheken verschillen qua ontwerp en functies.

Rocket is een webframework van hoog niveau dat prioriteit geeft aan productiviteit en gebruiksgemak. Rocket biedt veel abstracties en syntaxissuiker voor het bouwen van web-apps in Rust. Rocket is ook populair vanwege zijn krachtige typwerk en intuïtieve API-ontwerp.

U kunt Rocket toevoegen als een projectafhankelijkheid in uw Cargo.toml bestand om aan de slag te gaan met het bouwen van web-apps in Rust:

[afhankelijkheden]
raket = "0.4.11"

Aan de andere kant is Actix-web een low-level framework dat prioriteit geeft aan prestaties en schaalbaarheid. Actix maakt gebruik van een op actoren gebaseerd gelijktijdigheidsmodel en biedt niet-blokkerende I/O, waardoor het pakket ideaal is voor het bouwen van performante webapplicaties.

Voeg Actix toe als projectafhankelijkheid in het afhankelijkheden gedeelte van uw Cargo.toml bestand:

[afhankelijkheden]
actix-web = "4.3.1"

Het kiezen van een bibliotheek voor uw project hangt af van de specificaties van uw project, de functies van de bibliotheek en uw ervaring met Rust en HTTP.

Een eenvoudige webserver bouwen in Rust

Na het maken van een Rust-project en het toevoegen van een van de Rocket- of Actix-frameworks aan de afhankelijkheden van uw project in de Cargo.toml bestand, ben je klaar om te beginnen met het bouwen van een webserver in Rust.

Een eenvoudige webserver bouwen met Actix

U kunt een serializer gebruiken voor verzoeken bij het bouwen van webservices in Rust.

Serde is een populaire Rust-bibliotheek voor het serialiseren en deserialiseren van gegevens tussen Rust-typen en gegevensindelingen zoals JSON, YAML en TOML. Serde biedt een raamwerk voor het definiëren van dataconversie tussen Rust-datastructuren en overeenkomstige representaties in andere dataformaten.

Hier is de richtlijn voor het toevoegen van Serde als een pakket van derden voor uw project.

[afhankelijkheden]
serde = { versie = "1.0.159", kenmerken = ["afleiden"] }

Nadat u Serde en Actix als projectafhankelijkheden hebt toegevoegd, kunt u met Rust een basiswebserver uitzetten. Hier leest u hoe u een eenvoudig kunt instellen Hallo Wereld! webserver die met Actix een string naar de client schrijft:

Importeer eerst de benodigde modules en typen uit het actix_web En serde kratten:

gebruik actix_web::{get, web, App, HttpResponse, HttpServer, Responder};
gebruik serde::{Deserialiseren, serialiseren};

Je zult gebruiken serde om een ​​bericht naar de client te serialiseren met een struct. Serde converteert de struct naar JSON voor de klant. Hier is de structuur voor het bericht:

#[afleiden (debuggen, serialiseren, deserialiseren)]
structuurBericht {
 bericht: Snaar,
}

U kunt nu de handlerfunctie voor het eindpunt definiëren. Bovenaan uw handlerfunctie kunt u decorateurs toevoegen voor aangepast gedrag:

#[krijgen("/")]
asynchroonfnHallo() -> impl Antwoorder {
 Http-antwoord::OK().json (Bericht {
 bericht: "Hallo Wereld!".naar_eigendom(),
 })
}

De Hallo handlerfunctie handelt GET-verzoeken af. De functie retourneert een type dat de Antwoorder eigenschap van de Actix pakket.

De json methode van de HttpReactie:: Ok() type neemt in een struct-instantie dat Serde behandelt onder de motorkap en geeft het antwoord terug aan de klant.

Nadat u het eindpunt hebt gedefinieerd, kunt u een serverinstantie starten en het eindpunt op een route koppelen.

#[actix_web:: hoofd]
asynchroonfnvoornaamst() -> standaard:: io::Resultaat {
 HttpServer:: nieuw(|| App:: nieuw().service (hallo))
 .binden("127.0.0.1:8080")?
 .loop()
 .wachten
}

De HttpServer:: nieuw functie is een nieuwe serverinstantie. De voornaamst functie start en de server koppelt de Hallo handlerfunctie met de nieuwe app-instantie. De binden methode bindt de server aan de opgegeven URL, en de loop functie voert de server uit.

Een eenvoudige webserver bouwen met Rocket

Rocket is minimalistisch, dus u kunt een eenvoudige webserver opzetten zonder andere afhankelijkheden dan de Raket krat.

Hier leest u hoe u een eenvoudige server opzet met een Hallo Wereld! eindpunt met behulp van Rocket:

Importeer eerst de benodigde afhankelijkheden voor uw server.

#![kenmerk (proc_macro_hygiene, decl_macro)]
#[macrogebruik]
externkrat raket;
// invoer uit de Rocket-krat
gebruik raket:: reactie:: inhoud;
gebruik raket:: Staat;

De #![kenmerk (proc_macro_hygiene, decl_macro)] attribuut maakt Rust-experimentele functies voor het Rocket-framework mogelijk. De #[macrogebruik] attribuut importeert macro's uit het raket moduul.

Hier is een handlerfunctie die op verzoek HTML bedient:

#[krijgen("/")]
fnHallo Wereld() -> inhoud:: Html'statischstr> {
 inhoud:: Html("
Hallo Wereld!
")
}

De Hallo Wereld functie retourneert een HTML statische string met de inhoud:: Html functie.

Hier is een configuratiestructuurverklaring voor de server (Rocket-raamwerkconventie):

structuurconfiguratie {
 haven: u16,
}
#[krijgen("/haven")]
fnhaven(configuratie: staat) -> Snaar {
formaat!("Server draait op poort {}", config.poort)
}

Wanneer u de server uitvoert, kunt u verzoeken indienen bij de /port eindpunt voor de poortstatus.

Ten slotte maakt u een serverinstantie met de aansteken functie. Voeg de configuraties toe, koppel de routes en start de server:

fnvoornaamst() {
laten config = Config { poort: 8000 };
 raket:: ontbranden()
 .beheren (configuratie)
 .mount("/", routes![hello_world, poort])
 .launch();
}

De configuratie variabele is een instantie van de configuratie structuur. De aansteken functie start een serverinstantie, de beheren methode voegt de configuratie toe aan de server, en de monteren methode koppelt de handlerfunctie aan de basisroutes. eindelijk, de launch methode start de server om te luisteren op de opgegeven poort.

U kunt met WASM krachtige webapplicaties in Rust bouwen

WebAssembly (WASM) is een binaire instructie-indeling die is ontworpen voor uitvoering op browsers en andere apparaten. WASM biedt een low-level bytecode-indeling die programmeertalen van een hoger niveau, zoals Rust, kunnen gebruiken als een compilatiedoel.

Met WASM kunt u uw Rust-code compileren naar een binair formaat dat door de meeste populaire browsers kan worden uitgevoerd. WASM opent een wereld aan mogelijkheden voor het bouwen van robuuste webapplicaties in Rust, inclusief full-stack webapps.