Home-theater-designers
A HTTP ügyfél-szerver architektúrát használ az információ- és adatátvitelhez. A szerveroldali programozási nyelvek, például a Rust egyik jellemzője a HTTP-alapú szolgáltatásokkal való interakcióhoz szükséges szerverek és kliens alkalmazások fejlesztése.
A Rust biztonsága, teljesítménye és megbízhatósága miatt alkalmas HTTP szerverek építésére. A Rust harmadik féltől származó ládái, mint például az Actix és a Rocket, népszerűek a nagy forgalmat lebonyolító, kifinomult webszerverek építésében.
MAKEUSEOF A NAP VIDEÓJA GÖRGESS A TARTALOM FOLYTATÁSHOZ
Miért érdemes a Rust-ot használni a HTTP webszerver-fejlesztéshez?
A Rust népszerűvé vált a webszerver-fejlesztés terén, mivel a nyelv bizonyos funkciói pontosan megfelelnek a legtöbb webszerver felépítésének.
A Rust használatával az alkalmazás hatékonyan skálázható, így a nyelv ideális a nagy teljesítményű alkalmazások készítéséhez. Íme konkrét okok, amelyek miatt érdemes megfontolni a Rust használatát webszerveréhez és más szerveroldali alkalmazásokhoz.
Rust nagy teljesítménye
A nagy teljesítmény az egyik oka annak, hogy a Rust kiváló választás HTTP webszerverek építéséhez. A Rust alacsony szintű hozzáférést biztosít a rendszererőforrásokhoz, beleértve a memóriát és a CPU-t, így olyan kódot írhat, amely gyorsabban fut kevesebb erőforrással, mint a többi szerveroldali nyelv.
Ezenkívül a Rust tulajdonosi rendszere szükségtelenné teszi a szemétgyűjtést a fordítási időben, ami az egyik oka annak, hogy egyes szerveroldali nyelvek lassúak.
Biztonság és védelem
A Rust memóriakezelési tulajdoni rendszere biztonságossá teszi a nyelvet a webszerverek fejlesztéséhez. Nem tapasztal olyan nulla vagy lógó mutatóhivatkozásokat, amelyek memóriaszivárgáshoz és más biztonsági résekhez vezethetnek.
Rust tulajdonosi rendszere megakadályozza ezeket a gyakori hibákat a szerver és az alkalmazások biztonságának megőrzése érdekében. A Rust a puffertúlcsordulás és a memóriával kapcsolatos egyéb hibák megelőzésére is összpontosít.
Egyidejűség
A párhuzamosság az a képesség, hogy egy program több egységét rendellenesen lehessen futtatni anélkül, hogy a kimenetet befolyásolná. Egy párhuzamos program kimenetének meg kell egyeznie az aszinkron program kimenetével.
A párhuzamosság jelentősen befolyásolhatja az alkalmazás teljesítményét, mivel a szervereknek több kérést kell egyszerre kezelniük. A Rust támogatja az együttélést egy könnyű menetes modellel.
A Rust párhuzamos programozásának lényege, hogy a tulajdonosi rendszer lehetővé teszi, hogy szálbiztos kódot írjon anélkül, hogy zárolásra és egyéb szinkronizálási primitívekre lenne szüksége.
A rozsda modern szerszámokat biztosít
A Rust Standard Library és harmadik féltől származó csomagok a Rust ökoszisztémában korszerű eszközöket biztosít a hatékony webszerver fejlesztés .
hogyan kell telefonon játszani PC -n
A Cargo, a Rust csomagkezelője leegyszerűsíti a függőségkezelést és folyamatokat épít fel. Ezenkívül a Rust kiváló IDE-támogatással rendelkezik olyan eszközökkel, mint a Rust Analyzer, amelyek zökkenőmentes kódkiegészítést, hibakiemelést és egyéb funkciókat biztosítanak.
Az Actix és Rocket könyvtárak áttekintése
A Rust's Standard Library tartalmazza a webszerverek építéséhez szükséges segédprogramok nagy részét. A harmadik féltől származó könyvtárak például Rakéta és Actix egyszerűsítse a szerveroldali alkalmazások építését a Rust segítségével.
Actix és Rakéta népszerű Rust webes keretrendszerek, de a könyvtárak eltérnek a kialakításban és a funkciókban.
A Rocket egy magas szintű webes keretrendszer, amely a termelékenységet és a könnyű használhatóságot helyezi előtérbe. A Rocket sok absztrakciót és szintaktikai cukrot biztosít a webalkalmazások Rustban történő létrehozásához. A Rocket népszerű az erős gépelés és az intuitív API-kialakítás miatt is.
Hozzáadhatja a Rocketet projektfüggőségként az Önhöz töltés.toml fájl a webalkalmazások Rustban való építésének megkezdéséhez:
[dependencies]
rocket = "0.4.11"
Másrészt az Actix-web egy alacsony szintű keretrendszer, amely a teljesítményt és a méretezhetőséget helyezi előtérbe. Az Actix egy színész-alapú párhuzamossági modellt használ, és nem blokkoló I/O-t biztosít, amely ideálissá teszi a csomagot a hatékony webes alkalmazások létrehozásához.
Adja hozzá az Actix-et projektfüggőségként a függőségek részed töltés.toml fájl:
[dependencies]
actix-web = "4.3.1"
A projekt könyvtárának kiválasztása a projekt specifikációitól, a könyvtár jellemzőitől, valamint a Rust és a HTTP használatában szerzett tapasztalataitól függ.
Egyszerű webszerver építése Rustban
Miután létrehozott egy Rust projektet, és hozzáadta a Rocket vagy Actix keretrendszerek bármelyikét a projekt függőségeihez a töltés.toml fájlt, készen áll a webszerver felépítésére a Rustban.
Egyszerű webszerver építése az Actix segítségével
Használhat sorosítót a kérésekhez, amikor webszolgáltatásokat hoz létre a Rustban.
A Serde egy népszerű Rust könyvtár a Rust típusok és adatformátumok, például JSON, YAML és TOML közötti adatok sorosítására és deszerializálására. A Serde keretet biztosít az adatkonverzió meghatározásához a Rust adatstruktúrák és más adatformátumok megfelelő reprezentációi között.
Íme az irányelv a Serde harmadik féltől származó csomagként való hozzáadására a projekthez.
[dependencies]
serde = { version = "1.0.159" , features = ["derive"] }
Miután hozzáadta a Serde-t és az Actix-et projektfüggőségként, létrehozhat egy alapvető webszervert a Rust segítségével. Így állíthat be egy egyszerűt Helló Világ! webszerver, amely egy karakterláncot ír az ügyfélnek az Actix segítségével:
Először importálja a szükséges modulokat és típusokat a actix_web és mag ládák:
Hogyan lehet megtalálni a wifi jelszót androidon
use actix_web::{get, web, App, HttpResponse, HttpServer, Responder};
use serde::{Deserialize, Serialize};
fogod használni mag hogy egy üzenetet sorosítson a kliensnek egy struktúrával. A Serde a struktúrát JSON-ba konvertálja az ügyfél számára. Íme az üzenet szerkezete:
#[derive(Debug, Serialize, Deserialize)]
struct Message {
message: String,
}
Most már meghatározhatja a végpont kezelő funkcióját. A kezelő funkció tetején dekorátorokat adhat hozzá egyéni viselkedésekhez:
#[get("/")]
async fn hello() -> impl Responder {
HttpResponse::Ok().json(Message {
message: "Hello, World!".to_owned(),
})
}
A Helló kezelő függvény kezeli a GET kéréseket. A függvény olyan típust ad vissza, amely megvalósítja a Válasz tulajdonság a Actix csomag.
A json módszere a HttpResponse::Ok() típus olyan struct példányt vesz fel, amely Mag a motorháztető alatt kezeli, és visszaküldi a választ az ügyfélnek.
A végpont meghatározása után elindíthat egy kiszolgálópéldányt, és csatlakoztathatja a végpontot egy útvonalhoz.
#[actix_web::main]
async fn main() -> std::io::Result<()> {
HttpServer::new(|| App::new().service(hello))
.bind("127.0.0.1:8080")?
.run()
.await
}
A HttpServer::új függvény egy új szerverpéldány. A fő- funkció elindul, és a szerver felcsatolja a Helló kezelő funkciót az új alkalmazáspéldánnyal. A kötni metódus a kiszolgálót a megadott URL-hez köti, és a fuss funkció futtatja a szervert.
Egyszerű webszerver építése rakétával
A Rocket minimalista, így beállíthat egy egyszerű webszervert anélkül, hogy bármilyen függősége lenne, mint a Rakéta láda.
Így állíthat be egy egyszerű szervert a Helló Világ! végpont a Rocket használatával:
Először is importálja a szükséges függőségeket a kiszolgálóhoz.
#![feature(proc_macro_hygiene, decl_macro)]
#[macro_use]
extern crate rocket;
// imports from the Rocket crate
use rocket::response::content;
use rocket::State;
A #![feature(proc_macro_hygiene, decl_macro)] attribútum lehetővé teszi a Rust kísérleti funkciókat a Rocket keretrendszerhez. A #[makró_használat] attribútum makrókat importál a rakéta modul.
Íme egy kezelő függvény, amely kérésre HTML-t szolgál ki:
#[get("/")]
fn hello_world() -> content::Html<&'static str> {
content::Html("<h1>Hello, world!</h1>")
}
A Helló Világ függvény egy statikus HTML-karakterláncot ad vissza a tartalom::HTML funkció.
miért nem mondja az imessagem, hogy kézbesített
Íme egy konfigurációs struktúra deklaráció a szerverhez (Rocket keretkonvenció):
struct Config {
port: u16,
}
#[get("/port")]
fn port(config: State<Config>) -> String {
format!("Server running on port {}", config.port)
}
A szerver futtatásakor kéréseket intézhet a /kikötő végpont a port állapotához.
Végül létrehoz egy kiszolgálópéldányt a meggyullad funkció. Adja hozzá a konfigurációkat, csatolja az útvonalakat, és indítsa el a szervert:
fn main() {
let config = Config { port: 8000 };
rocket::ignite()
.manage(config)
.mount("/", routes![hello_world, port])
.launch();
}
A config változó a Konfig struct. A meggyullad függvény elindít egy szerverpéldányt, a kezelni metódus hozzáadja a konfigurációt a szerverhez, és a hegy metódus a kezelő funkciót az alapútvonalakra rögzíti. Végül a dob metódus elindítja a kiszolgálót, hogy figyeljen a megadott porton.
Hatékony webalkalmazásokat készíthet Rustban a WASM segítségével
A WebAssembly (WASM) egy bináris utasításformátum, amelyet böngészőkben és más eszközökön történő végrehajtásra terveztek. A WASM alacsony szintű bájtkód formátumot biztosít, amelyet a magasabb szintű programozási nyelvek, például a Rust használhatnak fordítási célként.
A WASM segítségével a Rust kódot olyan bináris formátumba fordíthatja, amelyet a legtöbb népszerű böngésző képes végrehajtani. A WASM a lehetőségek világát nyitja meg robusztus webalkalmazások készítéséhez a Rustban, beleértve a full-stack webalkalmazásokat is.