Tornado dokumentatsioon: põhjalik juhend arendajatele üle maailma

Tornado on Pythoni veebiraamistik ja asünkroonne võrguteek, mis algselt arendati FriendFeedis. See sobib eriti hästi pikaajalist küsitlust (long-polling), WebSocketeid ja muid rakendusi nõudvatele lahendustele, mis vajavad pikaajalist ühendust iga kasutajaga. Selle mitteblokeeriv võrgu I/O muudab selle erakordselt skaleeritavaks ja võimsaks valikuks suure jõudlusega veebirakenduste ehitamiseks. See põhjalik juhend juhatab teid läbi Tornado põhikontseptsioonide ja pakub praktilisi näiteid alustamiseks.

Mis on Tornado?

Oma olemuselt on Tornado veebiraamistik ja asünkroonne võrguteek. Erinevalt traditsioonilistest sünkroonsetest veebiraamistikest kasutab Tornado ühelõimelist, sündmusteahelal (event-loop) põhinevat arhitektuuri. See tähendab, et see suudab hallata paljusid samaaegseid ühendusi, ilma et oleks vaja ühte lõime ühenduse kohta, muutes selle tõhusamaks ja skaleeritavamaks.

Tornado põhifunktsioonid:

• Asünkroonne võrgundus: Tornado tuum on ehitatud asünkroonse I/O ümber, mis võimaldab tal tõhusalt hallata tuhandeid samaaegseid ühendusi.
• Veebiraamistik: See sisaldab funktsioone nagu päringukäsitlejad, marsruutimine, mallide kasutamine ja autentimine, tehes sellest täieliku veebiraamistiku.
• WebSocketi tugi: Tornado pakub suurepärast tuge WebSocketidele, võimaldades reaalajas suhtlust serveri ja klientide vahel.
• Kerge ja kiire: Jõudlusele orienteeritud Tornado on kerge ja tõhus, minimeerides üldkulusid ja maksimeerides läbilaskevõimet.
• Lihtne kasutada: Vaatamata oma täiustatud funktsioonidele on Tornado suhteliselt lihtne õppida ja kasutada, selge ja hästi dokumenteeritud API-ga.

Tornado keskkonna seadistamine

Enne Tornado arendusse sukeldumist peate oma keskkonna seadistama. Siin on samm-sammuline juhend:

1. Installige Python: Veenduge, et teil on installitud Python 3.6 või uuem. Saate selle alla laadida ametlikult Pythoni veebisaidilt (python.org).
2. Looge virtuaalne keskkond (soovitatav): Kasutage venv või virtualenv, et luua oma projektile eraldatud keskkond:

               python3 -m venv myenv
   source myenv/bin/activate  # On Linux/macOS
   myenv\Scripts\activate  # On Windows
               
   
                 
                   Copy
                 
               
             

3. Installige Tornado: Installige Tornado pip-i abil:

               pip install tornado
               
   
                 
                   Copy
                 
               
             

Sinu esimene Tornado rakendus

Loome lihtsa "Hello, World!" rakenduse Tornadoga. Looge fail nimega app.py ja lisage järgmine kood:

            import tornado.ioloop
import tornado.web

class MainHandler(tornado.web.RequestHandler):
 def get(self):
  self.write("Hello, World!")

def make_app():
 return tornado.web.Application([
  (r"/", MainHandler),
 ])

if __name__ == "__main__":
 app = make_app()
 app.listen(8888)
 tornado.ioloop.IOLoop.current().start()
            

              
                Copy
              
            
          

Nüüd käivitage rakendus oma terminalist:

            python app.py
            

              
                Copy
              
            
          

Avage oma veebibrauser ja navigeerige aadressile http://localhost:8888. Peaksite nägema "Hello, World!" sõnumit.

Selgitus:

• tornado.ioloop: Põhiline sündmusteahel, mis haldab asünkroonseid operatsioone.
• tornado.web: Pakub veebiraamistiku komponente, nagu päringukäsitlejad ja marsruutimine.
• MainHandler: Päringukäsitleja, mis määratleb, kuidas käsitleda saabuvaid HTTP-päringuid. get() meetodit kutsutakse GET-päringute jaoks.
• tornado.web.Application: Loob Tornado rakenduse, kaardistades URL-mustrid päringukäsitlejatele.
• app.listen(8888): Käivitab serveri, mis kuulab saabuvaid ühendusi pordil 8888.
• tornado.ioloop.IOLoop.current().start(): Käivitab sündmusteahela, mis töötleb saabuvaid päringuid ja haldab asünkroonseid operatsioone.

Päringukäsitlejad ja marsruutimine

Päringukäsitlejad on Tornado veebirakenduste alus. Nad määratlevad, kuidas käsitleda saabuvaid HTTP-päringuid vastavalt URL-ile. Marsruutimine kaardistab URL-id konkreetsetele päringukäsitlejatele.

Päringukäsitlejate määratlemine:

Päringukäsitleja loomiseks pärinege klassist tornado.web.RequestHandler ja implementeerige vastavad HTTP-meetodid (get, post, put, delete jne).

            class MyHandler(tornado.web.RequestHandler):
 def get(self):
  self.write("This is a GET request.")

 def post(self):
  data = self.request.body.decode('utf-8')
  self.write(f"Received POST data: {data}")
            

              
                Copy
              
            
          

Marsruutimine:

Marsruutimine konfigureeritakse tornado.web.Application'i loomisel. Pakute nimekirja ennikutest, kus iga ennik sisaldab URL-mustrit ja vastavat päringukäsitlejat.

            app = tornado.web.Application([
 (r"/", MainHandler),
 (r"/myhandler", MyHandler),
])
            

              
                Copy
              
            
          

URL-mustrid:

URL-mustrid on regulaaravaldised. Saate kasutada regulaaravaldiste gruppe, et püüda kinni URL-i osi ja edastada need argumentidena päringukäsitleja meetoditele.

            class UserHandler(tornado.web.RequestHandler):
 def get(self, user_id):
  self.write(f"User ID: {user_id}")

app = tornado.web.Application([
 (r"/user/([0-9]+)", UserHandler),
])
            

              
                Copy
              
            
          

Selles näites vastab /user/([0-9]+) URL-idele nagu /user/123. Osa ([0-9]+) püüab kinni ühe või mitu numbrit ja edastab need user_id argumendina UserHandler'i get meetodile.

Mallide kasutamine

Tornado sisaldab lihtsat ja tõhusat mallimootorit. Malle kasutatakse dünaamiliselt HTML-i genereerimiseks, eraldades esitlusloogika rakenduse loogikast.

Mallide loomine:

Mallid salvestatakse tavaliselt eraldi failidesse (nt index.html). Siin on lihtne näide:

            <!DOCTYPE html>
<html>
<head>
 <title>My Website</title>
</head>
<body>
 <h1>Welcome, {{ name }}!</h1>
 <p>Today is {{ today }}.</p>
</body>
</html>
            

              
                Copy
              
            
          

{{ name }} ja {{ today }} on kohatäited, mis asendatakse tegelike väärtustega malli renderdamisel.

Mallide renderdamine:

Malli renderdamiseks kasutage oma päringukäsitlejas meetodit render():

            class TemplateHandler(tornado.web.RequestHandler):
 def get(self):
  name = "John Doe"
  today = "2023-10-27"
  self.render("index.html", name=name, today=today)
            

              
                Copy
              
            
          

Veenduge, et template_path seade on teie rakenduse seadetes õigesti konfigureeritud. Vaikimisi otsib Tornado malle kaustast nimega templates, mis asub samas kaustas teie rakenduse failiga.

            app = tornado.web.Application([
 (r"/template", TemplateHandler),
], template_path="templates")
            

              
                Copy
              
            
          

Malli süntaks:

Tornado mallid toetavad erinevaid funktsioone, sealhulgas:

• Muutujad: {{ variable }}
• Juhtvood: {% if condition %} ... {% else %} ... {% end %}, {% for item in items %} ... {% end %}
• Funktsioonid: {{ function(argument) }}
• Kaasamised: {% include "another_template.html" %}
• Väljapääsemine (Escaping): Tornado pääseb automaatselt HTML-entiteetidest, et vältida saidiülest skriptimist (XSS). Saate väljapääsemise keelata kasutades {% raw variable %}.

Asünkroonsed operatsioonid

Tornado tugevus peitub selle asünkroonsetes võimetes. Asünkroonsed operatsioonid võimaldavad teie rakendusel teostada mitteblokeerivat I/O-d, parandades jõudlust ja skaleeritavust. See on eriti kasulik ülesannete puhul, mis hõlmavad väliste ressursside ootamist, nagu andmebaasipäringud või võrgupäringud.

@tornado.gen.coroutine:

Dekoraator @tornado.gen.coroutine võimaldab teil kirjutada asünkroonset koodi, kasutades yield-võtmesõna. See muudab asünkroonse koodi sünkroonse koodi sarnaseks, parandades loetavust ja hooldatavust.

            import tornado.gen
import tornado.httpclient

class AsyncHandler(tornado.web.RequestHandler):
 @tornado.gen.coroutine
 def get(self):
  http_client = tornado.httpclient.AsyncHTTPClient()
  response = yield http_client.fetch("http://example.com")
  self.write(response.body.decode('utf-8'))
            

              
                Copy
              
            
          

Selles näites on http_client.fetch() asünkroonne operatsioon, mis tagastab Future'i. Võtmesõna yield peatab korutiini täitmise, kuni Future on lahendatud. Kui Future on lahendatud, jätkab korutiin tööd ja vastuse keha kirjutatakse kliendile.

tornado.concurrent.Future:

Future esindab asünkroonse operatsiooni tulemust, mis ei pruugi veel saadaval olla. Saate kasutada Future objekte asünkroonsete operatsioonide aheldamiseks ja vigade käsitlemiseks.

tornado.ioloop.IOLoop:

IOLoop on Tornado asünkroonse mootori süda. See jälgib failikirjeldajaid ja sokleid sündmuste osas ning edastab need vastavatele käsitlejatele. Tavaliselt ei pea te IOLoop'iga otse suhtlema, kuid on oluline mõista selle rolli asünkroonsete operatsioonide käsitlemisel.

WebSocketid

Tornado pakub suurepärast tuge WebSocketidele, võimaldades reaalajas suhtlust serveri ja klientide vahel. WebSocketid on ideaalsed rakendustele, mis nõuavad kahesuunalist ja madala latentsusega suhtlust, nagu vestlusrakendused, online-mängud ja reaalajas armatuurlauad.

WebSocketi käsitleja loomine:

WebSocketi käsitleja loomiseks pärinege klassist tornado.websocket.WebSocketHandler ja implementeerige järgmised meetodid:

• open(): Kutsutakse, kui luuakse uus WebSocketi ühendus.
• on_message(message): Kutsutakse, kui kliendilt saadakse sõnum.
• on_close(): Kutsutakse, kui WebSocketi ühendus suletakse.

            import tornado.websocket

class WebSocketHandler(tornado.websocket.WebSocketHandler):
 def open(self):
  print("WebSocket opened")

 def on_message(self, message):
  self.write_message(f"You sent: {message}")

 def on_close(self):
  print("WebSocket closed")

 def check_origin(self, origin):
  return True # Enable cross-origin WebSocket connections
            

              
                Copy
              
            
          

WebSocketide integreerimine oma rakendusse:

Lisage WebSocketi käsitleja oma rakenduse marsruutimiskonfiguratsiooni:

            app = tornado.web.Application([
 (r"/ws", WebSocketHandler),
])
            

              
                Copy
              
            
          

Kliendipoolne implementatsioon:

Kliendi poolel saate kasutada JavaScripti WebSocketi ühenduse loomiseks ja sõnumite saatmiseks/vastuvõtmiseks:

            const websocket = new WebSocket("ws://localhost:8888/ws");

websocket.onopen = () => {
 console.log("WebSocket connection established");
 websocket.send("Hello from the client!");
};

websocket.onmessage = (event) => {
 console.log("Received message:", event.data);
};

websocket.onclose = () => {
 console.log("WebSocket connection closed");
};
            

              
                Copy
              
            
          

Autentimine ja turvalisus

Turvalisus on veebirakenduste arendamise kriitiline aspekt. Tornado pakub mitmeid funktsioone, mis aitavad teil oma rakendusi turvata, sealhulgas autentimine, autoriseerimine ja kaitse levinud veebihaavatavuste vastu.

Autentimine:

Autentimine on kasutaja identiteedi kontrollimise protsess. Tornado pakub sisseehitatud tuge erinevatele autentimisskeemidele, sealhulgas:

• Küpsistepõhine autentimine: Kasutajaandmete salvestamine küpsistesse.
• Kolmanda osapoole autentimine (OAuth): Integreerimine populaarsete sotsiaalmeediaplatvormidega nagu Google, Facebook ja Twitter.
• API võtmed: API võtmete kasutamine API-päringute autentimiseks.

Autoriseerimine:

Autoriseerimine on protsess, mille käigus tehakse kindlaks, kas kasutajal on luba konkreetsele ressursile juurde pääseda. Saate oma päringukäsitlejates implementeerida autoriseerimisloogikat, et piirata juurdepääsu vastavalt kasutaja rollidele või õigustele.

Turvalisuse parimad tavad:

• Saidiülene skriptimine (XSS) kaitse: Tornado pääseb automaatselt HTML-entiteetidest, et vältida XSS-rünnakuid. Kasutage alati render() meetodit mallide renderdamiseks ja vältige HTML-i otse genereerimist oma päringukäsitlejates.
• Saidiülene päringu võltsimise (CSRF) kaitse: Lülitage oma rakenduse seadetes sisse CSRF-kaitse, et vältida CSRF-rünnakuid.
• HTTPS: Kasutage alati HTTPS-i, et krüpteerida suhtlust serveri ja klientide vahel.
• Sisendi valideerimine: Valideerige kogu kasutaja sisend, et vältida süstimisrünnakuid ja muid haavatavusi.
• Regulaarsed turvaauditid: Viige läbi regulaarseid turvaauditeid, et tuvastada ja lahendada potentsiaalseid haavatavusi.

Juurutamine

Tornado rakenduse juurutamine hõlmab mitmeid samme, sealhulgas veebiserveri konfigureerimine, protsessihalduri seadistamine ja jõudluse optimeerimine.

Veebiserver:

Saate Tornado juurutada veebiserveri, näiteks Nginxi või Apache'i taha. Veebiserver toimib pöördproksina, edastades sissetulevad päringud Tornado rakendusele.

Protsessihaldur:

Protsessihaldurit nagu Supervisor või systemd saab kasutada Tornado protsessi haldamiseks, tagades, et see taaskäivitatakse automaatselt, kui see kokku jookseb.

Jõudluse optimeerimine:

• Kasutage tootmisvalmis sündmusteahelat: Kasutage tootmisvalmis sündmusteahelat nagu uvloop parema jõudluse saavutamiseks.
• Lülitage sisse gzip-pakkimine: Lülitage sisse gzip-pakkimine, et vähendada HTTP-vastuste suurust.
• Vahemällu staatilised failid: Salvestage staatilised failid vahemällu, et vähendada serveri koormust.
• Jälgige jõudlust: Jälgige oma rakenduse jõudlust tööriistadega nagu New Relic või Prometheus.

Rahvusvahelistamine (i18n) ja lokaliseerimine (l10n)

Globaalsele publikule rakenduste loomisel on oluline arvestada rahvusvahelistamise (i18n) ja lokaliseerimisega (l10n). i18n on rakenduse disainimise protsess nii, et seda saaks kohandada erinevatele keeltele ja piirkondadele ilma tehniliste muudatusteta. l10n on rahvusvahelistatud rakenduse kohandamise protsess konkreetse keele või piirkonna jaoks, lisades lokaadipõhiseid komponente ja tõlkides teksti.

Tornado ja i18n/l10n

Tornadol endal ei ole sisseehitatud i18n/l10n teeke. Siiski saate hõlpsasti integreerida standardseid Pythoni teeke nagu `gettext` või keerukamaid raamistikke nagu Babel, et hallata i18n/l10n oma Tornado rakenduses.

Näide `gettext` kasutamisega:

1. **Seadistage oma lokaadid:** Looge iga keele jaoks, mida soovite toetada, kaustad, mis sisaldavad sõnumikatalooge (tavaliselt `.mo` failid).

            locales/
 en/LC_MESSAGES/messages.mo
 fr/LC_MESSAGES/messages.mo
 de/LC_MESSAGES/messages.mo
            

              
                Copy
              
            
          

2. **Ekstraheerige tõlgitavad stringid:** Kasutage tööriista nagu `xgettext`, et ekstraheerida tõlgitavad stringid oma Pythoni koodist `.po` (Portable Object) faili. See fail sisaldab algseid stringe ja kohatäiteid tõlgetele.

            xgettext -d messages -o locales/messages.po your_tornado_app.py
            

              
                Copy
              
            
          

3. **Tõlkige stringid:** Tõlkige `.po` failides olevad stringid iga keele jaoks.

4. **Kompileerige tõlked:** Kompileerige `.po` failid `.mo` (Machine Object) failideks, mida `gettext` kasutab käitusajal.

            msgfmt locales/fr/LC_MESSAGES/messages.po -o locales/fr/LC_MESSAGES/messages.mo
            

              
                Copy
              
            
          

5. **Integreerige oma Tornado rakendusse:**

            import gettext
import locale
import os
import tornado.web

class BaseHandler(tornado.web.RequestHandler):
 def initialize(self):
  try:
  locale.setlocale(locale.LC_ALL, self.get_user_locale().code)
  except locale.Error:
  # Handle cases where the locale is not supported by the system
  print(f"Locale {self.get_user_locale().code} not supported")

  translation = gettext.translation('messages', 'locales', languages=[self.get_user_locale().code])
  translation.install()
  self._ = translation.gettext

 def get_current_user_locale(self):
  # Logic to determine user's locale (e.g., from Accept-Language header, user settings, etc.)
  # This is a simplified example - you'll need a more robust solution
  accept_language = self.request.headers.get('Accept-Language', 'en')
  return tornado.locale.get(accept_language.split(',')[0].split(';')[0])

class MainHandler(BaseHandler):
 def get(self):
  self.render("index.html", _=self._)

settings = {
 "template_path": os.path.join(os.path.dirname(__file__), "templates"),
}

app = tornado.web.Application([
 (r"/", MainHandler),
], **settings)

            

              
                Copy
              
            
          

6. **Muutke oma malle:** Kasutage funktsiooni `_()` (seotud `gettext.gettext`-iga), et märkida stringid oma mallides tõlkimiseks.

            <h1>{{ _("Tere tulemast meie veebisaidile!") }}</h1>
<p>{{ _("See on tõlgitud lõik.") }}</p>

            

              
                Copy
              
            
          

Olulised kaalutlused globaalsele publikule:

• **Märgistikukodeering:** Kasutage alati UTF-8 kodeeringut, et toetada laia valikut märke.
• **Kuupäeva ja kellaaja vormindamine:** Kasutage lokaadipõhist kuupäeva ja kellaaja vormingut. Pythoni funktsioone `strftime` ja `strptime` saab kasutada lokaadi seadetega.
• **Numbrite vormindamine:** Kasutage lokaadipõhist numbrite vormingut (nt kümnendkoha eraldajad, tuhandete eraldajad). `locale` moodul pakub selleks funktsioone.
• **Valuuta vormindamine:** Kasutage lokaadipõhist valuuta vormingut. Kaaluge keerukama valuutakäsitluse jaoks teegi nagu `Babel` kasutamist.
• **Paremalt vasakule (RTL) keeled:** Toetage RTL-keeli nagu araabia ja heebrea keel. See võib hõlmata teie veebisaidi paigutuse peegeldamist.
• **Tõlkekvaliteet:** Kasutage professionaalseid tõlkijaid, et tagada täpsed ja kultuuriliselt sobivad tõlked. Masintõlge võib olla hea lähtepunkt, kuid see nõuab sageli inimülevaadet.
• **Kasutaja lokaadi tuvastamine:** Implementeerige robustne lokaadi tuvastamine, mis põhineb kasutaja eelistustel, brauseri seadetel või IP-aadressil. Pakkuge kasutajatele võimalust oma eelistatud keelt käsitsi valida.
• **Testimine:** Testige oma rakendust põhjalikult erinevate lokaatidega, et tagada kõige korrektne kuvamine.

Edasijõudnute teemad

Kohandatud vealehed:

Saate kohandada vealehti, mida Tornado kuvab vea ilmnemisel. See võimaldab teil pakkuda kasutajasõbralikumat kogemust ja lisada silumisteavet.

Kohandatud seaded:

Saate oma rakenduse konfiguratsioonis määratleda kohandatud seadeid ja neile oma päringukäsitlejates juurde pääseda. See on kasulik rakendusespetsiifiliste parameetrite, näiteks andmebaasi ühenduse stringide või API-võtmete salvestamiseks.

Testimine:

Testige oma Tornado rakendusi põhjalikult, et tagada nende korrektne ja turvaline toimimine. Kasutage ühikteste, integratsiooniteste ja otsast-lõpuni teste, et katta kõik oma rakenduse aspektid.

Kokkuvõte

Tornado on võimas ja mitmekülgne veebiraamistik, mis sobib hästi skaleeritavate ja suure jõudlusega veebirakenduste ehitamiseks. Selle asünkroonne arhitektuur, WebSocketi tugi ja lihtsasti kasutatav API teevad sellest populaarse valiku arendajatele üle maailma. Järgides selle põhjaliku juhendi juhiseid ja näiteid, saate alustada oma Tornado rakenduste ehitamist ja ära kasutada selle paljusid funktsioone.

Pidage meeles, et kõige ajakohasema teabe ja parimate tavade saamiseks konsulteerige ametliku Tornado dokumentatsiooniga. Head kodeerimist!