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.

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 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.

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 Cargo.toml fájl a webalkalmazások Rustban való építésének megkezdéséhez:

[függőségek]
rakéta = "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 webalkalmazások létrehozásához.

Adja hozzá az Actix-et projektfüggőségként a függőségek részed Cargo.toml fájl:

[függőségek]
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 Cargo.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.

[függőségek]
serde = { verzió = "1.0.159", funkciók = ["származik"] }

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 serde ládák:

használat actix_web::{get, web, App, HttpResponse, HttpServer, Responder};
használat serde::{Serialize, Serialize};

fogod használni serde 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:

#[származtatás (hibakeresés, sorozatosítás, szerializálás)]
structÜzenet {
 üzenet: Húr,
}

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:

#[kap("/")]
asyncfnHelló() -> impl Válasz {
 HttpResponse::Rendben().json (üzenet {
 üzenet: "Helló Világ!".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álaszadó tulajdonság a Actix csomag.

A json módszere a HttpResponse:: Rendben() típus olyan struct példányt vesz fel, amely Serde 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:: fő]
asyncfnfő-() -> std:: io::Eredmény {
 HttpServer:: new(|| App:: new().service (hello))
 .bind("127.0.0.1:8080")?
 .fuss()
 .várja
}

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.

#![funkció (proc_macro_hygiene, decl_macro)]
#[makró_használat]
külsőláda rakéta;
// import a rakétaládából
használat rakéta:: válasz:: tartalom;
használat rakéta:: Állam;

A #![funkció (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 modult.

Íme egy kezelő függvény, amely kérésre HTML-t szolgál ki:

#[kap("/")]
fnHelló Világ() -> tartalom:: Html'statikusstr> {
 tartalom:: Html("
Helló Világ!
")
}

A Helló Világ függvény egy statikus HTML-karakterláncot ad vissza a tartalom:: Html funkció.

Íme egy konfigurációs struktúra deklaráció a szerverhez (Rocket keretkonvenció):

structKonfig {
 kikötő: u16,
}
#[kap("/kikötő")]
fnkikötő(konfig: állapot) -> Húr {
formátum!("Szerver a(z) {} porton fut", config.port)
}

A szerver futtatásakor kéréseket intézhet a /port 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:

fnfő-() {
hagyja config = Config { port: 8000 };
 rakéta:: ignite()
 .manage (config)
 .hegy("/", útvonalak![hello_world, port])
 .dob();
}

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.