Hoe om 'n Rust -webdiens te bou sonder om 'n webraamwerk te gebruik

Blog

By die bou van webdienste is eenvoudiger beter. Leer hoe u 'n Rust -webdiens kan bou sonder om 'n webraamwerk te gebruik.



Volgens my ervaring is eenvoudiger beter as ek webdienste bou. Dit is aanloklik om 'n volledige, swaargewig webraamwerk in te neem, in te sit en die konvensie-oor-konfigurasie-benadering te gebruik om dinge net te doen. Baie ontwikkelaars het hierdie benadering suksesvol gebruik, ek ingesluit.

Ek het egter na 'n rukkie opgemerk dat die verborge kompleksiteit - wat groot is - 'n paar nadele het. Hierdie nadele kan wissel van verswakte prestasie, tot tydverdwaalde ontfoutingskwessies in die groot netwerk van oorganklike afhanklikhede, tot eenvoudig nie weet wat aan die gang is nie. Dit is ook nie optimaal om alles van nuuts af te skryf nie. Dit is uiters tydrowend, en daar is potensiaal om foute by elke stap in te voer.



Ek sê nie dat wyd gebruikte open source webraamwerke foutloos is nie-verre daarvan. Maar daar is ten minste meer oë op hulle en meer belanghebbendes vind foute aktief en herstel dit.

Na my mening is daar 'n gelukkige medium. Die doel is om die kompleksiteit laag te hou, terwyl u die meeste gemak en ontwikkelingssnelheid behou wat u kry as u alles in een afhanklikheid het.



Hierdie lieflike plek kan vir verskillende mense anders wees, afhangende van u ervaring, sal dit verskil waarna u gemaklik is om self te skryf of 'n mikro -afhanklikheid te gebruik. Maar die algemene benadering - om verskeie, klein (er) biblioteke te neem en 'n minimale stelsel daaruit te bou - het in die verlede vir my goed gewerk. Een voordeel is dat die afhanklikes klein genoeg is, sodat u eintlik op die ou end na hul bewaarplek kan gaan om dit te lees, te verstaan ​​en, indien nodig, dit reg te stel. Boonop het u 'n beter oorsig van wat in die kodebasis is (dit wil sê wat verkeerd kan gaan) en wat nie, wat moeilik is met groot raamwerke. Dit stel u in staat om die stelsel eintlik aan te pas by die probleem wat u oplos.

U kan API's op basisvlak presies definieer soos u dit nodig het om u stelsel te bou sonder om die raamwerk te beveg om dinge gedoen te kry. Dit verg 'n sekere vlak van ervaring om reg te kom, maar as u bereid is om tyd te spandeer om met raamwerke te worstel, is dit beslis die moeite werd.

In hierdie handleiding wys ons u hoe u 'n Rust -webdiens kan bou sonder om 'n webraamwerk te gebruik.

Ons sal egter nie alles van nuuts af bou nie. Vir ons HTTP -bediener gebruik ons hiper , wat die tokyo looptyd daaronder. Nie een van hierdie biblioteke is die maklikste of die minste opsie nie, maar albei word wyd gebruik en die konsepte wat hier beskryf word, is van toepassing ongeag die biblioteke wat gebruik word.

Ons bou 'n basiese webbediener met 'n ietwat buigsame routing -API en 'n paar voorbeeldhanteerders om dit te wys. Ons voltooide produk is geensins gereed om te gebruik soos dit is nie, maar teen die einde van die handleiding behoort u 'n duidelike idee te hê van hoe u dit kan uitbrei om daar te kom.

wat is aeon muntstuk

Stel op

Om dit te volg, benodig u 'n onlangse Rust -installasie (1.39+) en 'n instrument om HTTP -versoeke, soos cURL, te stuur.

Skep eers 'n nuwe Rust -projek.

cargo new rust-minimal-web-example cd rust-minimal-web-example

Wysig dan die | _+_ | lêer en voeg die volgende afhanklikhede by.

Cargo.toml

Dit is 'n hele paar afhanklikhede vir 'n minimale webtoepassing. Wat gaan daarmee aan?

Aangesien ons nie 'n volledige webraamwerk gebruik nie, maar ons probeer om ons eie stelsel te bou wat uit verskeie mikrobiblioteke bestaan, is die algehele kompleksiteit steeds laer, selfs al styg die aantal direkte afhanklikhede.

Dit is nie noodwendig die aantal direkte afhanklikhede waaroor ons bekommerd is nie, maar die aantal oorganklike afhanklikhede en die hoeveelheid kode wat dit aan mekaar plak.

Aangesien ons | _+_ | As 'n asynchroniese HTTP -bediener benodig ons ook 'n asynchroniseringstyd. In hierdie voorbeeld gebruik ons ​​| _+_ |, maar ons kan ook 'n ligter oplossing gebruik, soos smol .

Die | _+_ | en | _+_ | afhanklikes is nodig vir die hantering van inkomende JSON. Ons kan waarskynlik wegkom met die gebruik nanoserde ook as ons alles wil minimaliseer. Die | _+_ | krat is 'n baie klein, ligte router wat paaie kan hanteer met parameters soos | _+_ | ook.

Vir die oorblywende biblioteke - naamlik | _+_ |, | _+_ | en | _+_ | - ons het hulle nodig om ons router te bou. Hulle is in elk geval heel waarskynlik oorganklike afhanklikhede van wat ons ook al gebruik, so hulle voeg geen gewig by nie en is nie besonder swaar nie. In die geval van | _+_ |, kan ons ook die futures-lite krat.

html -kode vir 'n webwerf vir aanlyn inkopies

Hanteerder API

Kom ons bou dit van onder na onder en kyk eers na die API wat ons vir ons hanteerders wil hê. Dan implementeer ons 'n router en sit ons uiteindelik alles bymekaar.

Ons maak drie hanteerders in hierdie voorbeeld:

  • | _+_ |, 'n basiese hanteerder wat 'n string terugstuur om aan te toon dat dit werk
  • | _+_ |, 'n hanteerder wat 'n JSON -vrag verwag, wat 'n fout terugstuur as dit nie geldig is nie
  • | _+_ |, 'n eenvoudige hanteerder om te wys hoe ons padparameters hanteer

Kom ons implementeer dit in | _+_ | om die API te sien wat ons vir hulle wil skep.

[dependencies] futures = { version = '0.3.6', default-features = false, features = ['async-await'] } hyper = '0.13' tokio = { version = '0.2', features = ['macros', 'rt-threaded'] } serde = {version = '1.0', features = ['derive'] } serde_json = '1.0' route-recognizer = '0.2' bytes = '0.5' async-trait = '0.1'

Die | _+_ | is baie eenvoudig, maar ons het reeds een belangrike konsep gesien: die | _+_ |. Om 'n versoektoestand (soos die liggaam, navraagparameters, opskrifte, ens.) Binne 'n hanteerder te gebruik, het ons 'n manier nodig om dit daar te kry.

waar kan ek serum koop?

Afhangende van hoe ons die stelsel wil ontwerp, wil ons ook sekere gedeelde stelsels ('n HTTP -kliënt of 'n databasisbewaarplek) aan hanteerders beskikbaar stel. In hierdie voorbeeld gebruik ons ​​'n | _+_ | beswaar maak teen hierdie dinge. In hierdie geval gee ons die inhoud van die | _+_ | terug veranderlike, wat 'n dummy -weergawe is van die werklike toepassingsstatus. Ons sal later kyk hoe dit geïmplementeer word, maar dit bevat elke bietjie inligting wat die hanteerder nodig het om sy werk te doen.

Vir die | _+_ |, sien ons reeds | _+_ | in aksie. Ons verwag 'n | _+_ | JSON -vrag in hierdie hanteerder, dus gebruik ons ​​die | _+_ | metode om die versoekliggaam na 'n | _+_ | te ontleed. As dit verkeerd gaan, gee ons eenvoudig 'n 400 -fout terug.

'N Interessante verskil tussen | _+_ | en | _+_ | is die tipe terugkeer. Ons wil waardes van verskillende tipes kan teruggee. In die mees basiese geval, a | _+_ |, of a | _+_ | sal so maak. In ander gevalle - soos in ons geval - wil ons 'n | _+_ | teruggee of 'n rou | _+_ |.

Die derde hanteerder, | _+_ |, wys hoe ons | _+_ | kan gebruik om by padparameters te kom, wat in die roete gedefinieer word. Alle hanteerders is | _+_ | funksies, maar ons kan ook 'n hanteerder skep met behulp van | _+_ | met die hand.

In | _+_ | kan ons die definisie vir die | _+_ | en 'n paar helper tipes.

hyper

Hier definieer ons | _+_ | om te tik en | _+_ |, wat 'n algemene tipe fout is, te vermy. In die praktyk wil ons waarskynlik 'n aangepaste fouttipe gebruik om foute in ons toepassing te versprei.

Vervolgens definieer ons ons | _+_ | struktuur. In hierdie voorbeeld hou dit eenvoudig die bogenoemde toedieningstoestand in. Hierdie | _+_ | kan byvoorbeeld ook gedeelde verwysings bevat na 'n kas, 'n databasisbewaarplek of ander toepassingsbrede wat u wil hê dat u hanteerders toegang tot het.

Die | _+_ | self is slegs 'n struktuur met die | _+_ |, die inkomende | _+_ |, die padparameters as daar is, en | _+_ |. Dit onthul een funksie genaamd | _+_ |, wat | _+_ | stel en probeer dit na die gegewe tipe ontleed.

Ons memoriseer | _+_ | hier, want dit is moontlik dat ons tydens die lewensiklus van die versoek verskeie kere toegang tot die liggaam wil hê. Op hierdie manier hoef ons dit net een keer te lees en op te slaan (byvoorbeeld in 'n middelware).

#rust #webontwikkeling #programmering #ontwikkelaar

blog.logrocket.com

Hoe om 'n Rust -webdiens te bou sonder om 'n webraamwerk te gebruik

Leer hoe u 'n Rust -webdiens kan bou sonder om 'n webraamwerk te gebruik. By die bou van webdienste is eenvoudiger beter.