Tornado dokumentācija: Visaptverošs ceļvedis izstrādātājiem visā pasaulē

Tornado ir Python tīmekļa ietvars un asinhronās tīklošanas bibliotēka, kas sākotnēji izstrādāta FriendFeed. Tā ir īpaši piemērota ilgstošai aptaujai (long-polling), WebSockets un citām lietojumprogrammām, kurām nepieciešams ilgstošs savienojums ar katru lietotāju. Tā nebloķējošā tīkla I/O padara to ārkārtīgi mērogojamu un jaudīgu izvēli augstas veiktspējas tīmekļa lietojumprogrammu izveidei. Šis visaptverošais ceļvedis iepazīstinās jūs ar Tornado pamatjēdzieniem un sniegs praktiskus piemērus, lai jūs varētu sākt darbu.

Kas ir Tornado?

Būtībā Tornado ir tīmekļa ietvars un asinhronās tīklošanas bibliotēka. Atšķirībā no tradicionālajiem sinhronajiem tīmekļa ietvariem, Tornado izmanto viena pavediena, uz notikumu cilpas balstītu arhitektūru. Tas nozīmē, ka tas var apstrādāt daudzus vienlaicīgus savienojumus, neprasot pavedienu katram savienojumam, padarot to efektīvāku un mērogojamāku.

Galvenās Tornado funkcijas:

• Asinhronā tīklošana: Tornado kodols ir veidots ap asinhrono I/O, kas ļauj efektīvi apstrādāt tūkstošiem vienlaicīgu savienojumu.
• Tīmekļa ietvars: Tas ietver tādas funkcijas kā pieprasījumu apstrādātāji, maršrutēšana, veidņu izmantošana un autentifikācija, padarot to par pilnīgu tīmekļa ietvaru.
• WebSocket atbalsts: Tornado nodrošina lielisku atbalstu WebSockets, ļaujot reāllaikā sazināties starp serveri un klientiem.
• Viegls un ātrs: Izstrādāts veiktspējai, Tornado ir viegls un efektīvs, samazinot pieskaitāmās izmaksas un maksimizējot caurlaides spēju.
• Viegli lietojams: Neskatoties uz tā progresīvajām funkcijām, Tornado ir salīdzinoši viegli apgūstams un lietojams, ar skaidru un labi dokumentētu API.

Tornado vides iestatīšana

Pirms sākt Tornado izstrādi, jums ir jāiestata sava vide. Šeit ir soli pa solim ceļvedis:

1. Instalējiet Python: Pārliecinieties, ka jums ir instalēta Python 3.6 vai jaunāka versija. Jūs to varat lejupielādēt no oficiālās Python vietnes (python.org).
2. Izveidojiet virtuālo vidi (ieteicams): Izmantojiet venv vai virtualenv, lai izveidotu izolētu vidi savam projektam:

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

3. Instalējiet Tornado: Instalējiet Tornado, izmantojot pip:

   pip install tornado

Jūsu pirmā Tornado lietojumprogramma

Izveidosim vienkāršu "Hello, World!" lietojumprogrammu ar Tornado. Izveidojiet failu ar nosaukumu app.py un pievienojiet šādu kodu:

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()

Tagad palaidiet lietojumprogrammu no sava termināļa:

python app.py

Atveriet savu tīmekļa pārlūku un dodieties uz http://localhost:8888. Jums vajadzētu redzēt ziņojumu "Hello, World!".

Paskaidrojums:

• tornado.ioloop: Galvenā notikumu cilpa, kas apstrādā asinhronās operācijas.
• tornado.web: Nodrošina tīmekļa ietvara komponentes, piemēram, pieprasījumu apstrādātājus un maršrutēšanu.
• MainHandler: Pieprasījumu apstrādātājs, kas definē, kā apstrādāt ienākošos HTTP pieprasījumus. Metode get() tiek izsaukta GET pieprasījumiem.
• tornado.web.Application: Izveido Tornado lietojumprogrammu, piesaistot URL modeļus pieprasījumu apstrādātājiem.
• app.listen(8888): Palaiž serveri, kas klausās ienākošos savienojumus uz 8888. porta.
• tornado.ioloop.IOLoop.current().start(): Palaiž notikumu cilpu, kas apstrādā ienākošos pieprasījumus un asinhronās operācijas.

Pieprasījumu apstrādātāji un maršrutēšana

Pieprasījumu apstrādātāji ir Tornado tīmekļa lietojumprogrammu pamats. Tie definē, kā apstrādāt ienākošos HTTP pieprasījumus, pamatojoties uz URL. Maršrutēšana piesaista URL konkrētiem pieprasījumu apstrādātājiem.

Pieprasījumu apstrādātāju definēšana:

Lai izveidotu pieprasījumu apstrādātāju, izveidojiet apakšklasi no tornado.web.RequestHandler un implementējiet atbilstošās HTTP metodes (get, post, put, delete utt.).

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}")

Maršrutēšana:

Maršrutēšana tiek konfigurēta, veidojot tornado.web.Application. Jūs nodrošināt sarakstu ar kortežiem, kur katrs kortežs satur URL modeli un atbilstošo pieprasījumu apstrādātāju.

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

URL modeļi:

URL modeļi ir regulārās izteiksmes. Jūs varat izmantot regulāro izteiksmju grupas, lai notvertu daļas no URL un nodotu tās kā argumentus pieprasījumu apstrādātāja metodēm.

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),
])

Šajā piemērā /user/([0-9]+) atbilst URL, piemēram, /user/123. Daļa ([0-9]+) notver vienu vai vairākus ciparus un nodod tos kā user_id argumentu UserHandler klases get metodei.

Veidņu izmantošana

Tornado ietver vienkāršu un efektīvu veidņu dzinēju. Veidnes tiek izmantotas, lai dinamiski ģenerētu HTML, atdalot prezentācijas loģiku no lietojumprogrammas loģikas.

Veidņu izveide:

Veidnes parasti tiek glabātas atsevišķos failos (piemēram, index.html). Šeit ir vienkāršs piemērs:

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

{{ name }} un {{ today }} ir vietturi, kas tiks aizstāti ar faktiskajām vērtībām, kad veidne tiks renderēta.

Veidņu renderēšana:

Lai renderētu veidni, izmantojiet render() metodi savā pieprasījumu apstrādātājā:

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

Pārliecinieties, ka template_path iestatījums ir pareizi konfigurēts jūsu lietojumprogrammas iestatījumos. Pēc noklusējuma Tornado meklē veidnes direktorijā ar nosaukumu templates tajā pašā direktorijā, kur atrodas jūsu lietojumprogrammas fails.

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

Veidņu sintakse:

Tornado veidnes atbalsta dažādas funkcijas, tostarp:

• Mainīgie: {{ variable }}
• Vadības plūsma: {% if condition %} ... {% else %} ... {% end %}, {% for item in items %} ... {% end %}
• Funkcijas: {{ function(argument) }}
• Iekļaušana: {% include "another_template.html" %}
• Aizsardzība (Escaping): Tornado automātiski aizsargā HTML entītijas, lai novērstu starpvietņu skriptošanas (XSS) uzbrukumus. Jūs varat atspējot aizsardzību, izmantojot {% raw variable %}.

Asinhronās operācijas

Tornado spēks slēpjas tā asinhronajās spējās. Asinhronās operācijas ļauj jūsu lietojumprogrammai veikt nebloķējošu I/O, uzlabojot veiktspēju un mērogojamību. Tas ir īpaši noderīgi uzdevumiem, kas saistīti ar gaidīšanu uz ārējiem resursiem, piemēram, datu bāzes vaicājumiem vai tīkla pieprasījumiem.

@tornado.gen.coroutine:

Dekorators @tornado.gen.coroutine ļauj rakstīt asinhronu kodu, izmantojot atslēgvārdu yield. Tas padara asinhrono kodu līdzīgāku sinhronajam kodam pēc izskata un uzvedības, uzlabojot lasāmību un uzturēšanu.

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'))

Šajā piemērā http_client.fetch() ir asinhrona operācija, kas atgriež Future objektu. Atslēgvārds yield aptur korutīnas izpildi, līdz Future ir atrisināts. Kad Future ir atrisināts, korutīna atsāk darbu un atbildes ķermenis tiek rakstīts klientam.

tornado.concurrent.Future:

Future objekts attēlo asinhronas operācijas rezultātu, kas, iespējams, vēl nav pieejams. Jūs varat izmantot Future objektus, lai saķēdētu asinhronas operācijas un apstrādātu kļūdas.

tornado.ioloop.IOLoop:

IOLoop ir Tornado asinhronā dzinēja sirds. Tā pārrauga failu deskriptorus un kontaktligzdas, gaidot notikumus, un nosūta tos atbilstošajiem apstrādātājiem. Parasti jums nav nepieciešams tieši mijiedarboties ar IOLoop, bet ir svarīgi saprast tā lomu asinhrono operāciju apstrādē.

WebSockets

Tornado nodrošina lielisku atbalstu WebSockets, ļaujot reāllaikā sazināties starp serveri un klientiem. WebSockets ir ideāli piemēroti lietojumprogrammām, kurām nepieciešama divvirzienu, zema latentuma komunikācija, piemēram, tērzēšanas lietojumprogrammām, tiešsaistes spēlēm un reāllaika informācijas paneļiem.

WebSocket apstrādātāja izveide:

Lai izveidotu WebSocket apstrādātāju, izveidojiet apakšklasi no tornado.websocket.WebSocketHandler un implementējiet šādas metodes:

• open(): Tiek izsaukta, kad tiek izveidots jauns WebSocket savienojums.
• on_message(message): Tiek izsaukta, kad no klienta tiek saņemts ziņojums.
• on_close(): Tiek izsaukta, kad WebSocket savienojums tiek aizvērts.

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 # Atļaut starpdomēnu WebSocket savienojumus

WebSockets integrēšana jūsu lietojumprogrammā:

Pievienojiet WebSocket apstrādātāju savas lietojumprogrammas maršrutēšanas konfigurācijai:

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

Klienta puses implementācija:

Klienta pusē varat izmantot JavaScript, lai izveidotu WebSocket savienojumu un sūtītu/saņemtu ziņojumus:

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");
};

Autentifikācija un drošība

Drošība ir būtisks tīmekļa lietojumprogrammu izstrādes aspekts. Tornado nodrošina vairākas funkcijas, kas palīdz aizsargāt jūsu lietojumprogrammas, tostarp autentifikāciju, autorizāciju un aizsardzību pret izplatītām tīmekļa ievainojamībām.

Autentifikācija:

Autentifikācija ir process, kurā tiek pārbaudīta lietotāja identitāte. Tornado nodrošina iebūvētu atbalstu dažādām autentifikācijas shēmām, tostarp:

• Uz sīkfailiem balstīta autentifikācija: Glabājiet lietotāja akreditācijas datus sīkfailos.
• Trešo pušu autentifikācija (OAuth): Integrējieties ar populārām sociālo mediju platformām, piemēram, Google, Facebook un Twitter.
• API atslēgas: Izmantojiet API atslēgas API pieprasījumu autentificēšanai.

Autorizācija:

Autorizācija ir process, kurā tiek noteikts, vai lietotājam ir atļauja piekļūt konkrētam resursam. Jūs varat implementēt autorizācijas loģiku savos pieprasījumu apstrādātājos, lai ierobežotu piekļuvi, pamatojoties uz lietotāju lomām vai atļaujām.

Drošības labākā prakse:

• Aizsardzība pret starpvietņu skriptošanu (XSS): Tornado automātiski aizsargā HTML entītijas, lai novērstu XSS uzbrukumus. Vienmēr izmantojiet render() metodi, lai renderētu veidnes, un izvairieties no HTML ģenerēšanas tieši savos pieprasījumu apstrādātājos.
• Aizsardzība pret starpvietņu pieprasījumu viltošanu (CSRF): Iespējojiet CSRF aizsardzību savas lietojumprogrammas iestatījumos, lai novērstu CSRF uzbrukumus.
• HTTPS: Vienmēr izmantojiet HTTPS, lai šifrētu komunikāciju starp serveri un klientiem.
• Ievades validācija: Validējiet visu lietotāja ievadi, lai novērstu injekcijas uzbrukumus un citas ievainojamības.
• Regulāri drošības auditi: Veiciet regulārus drošības auditus, lai identificētu un novērstu potenciālās ievainojamības.

Izvietošana

Tornado lietojumprogrammas izvietošana ietver vairākus soļus, tostarp tīmekļa servera konfigurēšanu, procesu pārvaldnieka iestatīšanu un veiktspējas optimizēšanu.

Tīmekļa serveris:

Jūs varat izvietot Tornado aiz tīmekļa servera, piemēram, Nginx vai Apache. Tīmekļa serveris darbojas kā reversais starpniekserveris, pārsūtot ienākošos pieprasījumus uz Tornado lietojumprogrammu.

Procesu pārvaldnieks:

Procesu pārvaldnieku, piemēram, Supervisor vai systemd, var izmantot, lai pārvaldītu Tornado procesu, nodrošinot, ka tas tiek automātiski restartēts, ja tas avarē.

Veiktspējas optimizācija:

• Izmantojiet ražošanai gatavu notikumu cilpu: Izmantojiet ražošanai gatavu notikumu cilpu, piemēram, uvloop, lai uzlabotu veiktspēju.
• Iespējojiet gzip saspiešanu: Iespējojiet gzip saspiešanu, lai samazinātu HTTP atbilžu izmēru.
• Kešojiet statiskos failus: Kešojiet statiskos failus, lai samazinātu slodzi uz serveri.
• Pārraugiet veiktspēju: Pārraugiet savas lietojumprogrammas veiktspēju, izmantojot rīkus, piemēram, New Relic vai Prometheus.

Internacionalizācija (i18n) un lokalizācija (l10n)

Veidojot lietojumprogrammas globālai auditorijai, ir svarīgi apsvērt internacionalizāciju (i18n) un lokalizāciju (l10n). i18n ir process, kurā lietojumprogramma tiek izstrādāta tā, lai to varētu pielāgot dažādām valodām un reģioniem bez inženierijas izmaiņām. l10n ir process, kurā internacionalizēta lietojumprogramma tiek pielāgota konkrētai valodai vai reģionam, pievienojot lokālei specifiskas komponentes un tulkojot tekstu.

Tornado un i18n/l10n

Tornado pašam nav iebūvētu i18n/l10n bibliotēku. Tomēr jūs varat viegli integrēt standarta Python bibliotēkas, piemēram, `gettext` vai sarežģītākus ietvarus, piemēram, Babel, lai apstrādātu i18n/l10n jūsu Tornado lietojumprogrammā.

Piemērs ar gettext:

1. **Iestatiet savas lokāles:** Izveidojiet direktorijas katrai valodai, kuru vēlaties atbalstīt, un kurās būs ziņojumu katalogi (parasti `.mo` faili).

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

2. **Iegūstiet tulkojamās virknes:** Izmantojiet rīku, piemēram, `xgettext`, lai no sava Python koda iegūtu tulkojamās virknes `.po` failā (Portable Object). Šis fails saturēs oriģinālās virknes un vietturus tulkojumiem.

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

3. **Tulkojiet virknes:** Tulkojiet virknes `.po` failos katrai valodai.

4. **Kompilējiet tulkojumus:** Kompilējiet `.po` failus `.mo` failos (Machine Object), kurus `gettext` izmanto izpildes laikā.

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

5. **Integrējiet savā Tornado lietojumprogrammā:**

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)

6. **Modificējiet savas veidnes:** Izmantojiet funkciju `_()` (kas piesaistīta `gettext.gettext`), lai atzīmētu virknes tulkošanai savās veidnēs.

<h1>{{ _("Welcome to our website!") }}</h1>
<p>{{ _("This is a translated paragraph.") }}</p>

Svarīgi apsvērumi globālai auditorijai:

• **Rakstzīmju kodējums:** Vienmēr izmantojiet UTF-8 kodējumu, lai atbalstītu plašu rakstzīmju klāstu.
• **Datuma un laika formatēšana:** Izmantojiet lokālei specifisku datuma un laika formatēšanu. Python funkcijas `strftime` un `strptime` var izmantot ar lokāles iestatījumiem.
• **Skaitļu formatēšana:** Izmantojiet lokālei specifisku skaitļu formatēšanu (piemēram, decimālatdalītājus, tūkstošu atdalītājus). Modulis `locale` nodrošina funkcijas šim nolūkam.
• **Valūtas formatēšana:** Izmantojiet lokālei specifisku valūtas formatēšanu. Apsveriet iespēju izmantot bibliotēku, piemēram, `Babel`, lai veiktu sarežģītāku valūtas apstrādi.
• **No labās uz kreiso pusi (RTL) rakstāmās valodas:** Atbalstiet RTL valodas, piemēram, arābu un ebreju. Tas var ietvert jūsu vietnes izkārtojuma spoguļošanu.
• **Tulkojumu kvalitāte:** Izmantojiet profesionālus tulkotājus, lai nodrošinātu precīzus un kultūrai atbilstošus tulkojumus. Mašīntulkošana var būt labs sākumpunkts, bet bieži vien tai nepieciešama cilvēka pārbaude.
• **Lietotāja lokāles noteikšana:** Ieviesiet robustu lokāles noteikšanu, pamatojoties uz lietotāja preferencēm, pārlūka iestatījumiem vai IP adresi. Nodrošiniet veidu, kā lietotāji var manuāli izvēlēties savu vēlamo valodu.
• **Testēšana:** Rūpīgi pārbaudiet savu lietojumprogrammu ar dažādām lokālēm, lai nodrošinātu, ka viss tiek parādīts pareizi.

Padziļinātas tēmas

Pielāgotas kļūdu lapas:

Jūs varat pielāgot kļūdu lapas, kuras Tornado parāda, kad rodas kļūda. Tas ļauj jums nodrošināt lietotājam draudzīgāku pieredzi un iekļaut atkļūdošanas informāciju.

Pielāgoti iestatījumi:

Jūs varat definēt pielāgotus iestatījumus savas lietojumprogrammas konfigurācijā un piekļūt tiem savos pieprasījumu apstrādātājos. Tas ir noderīgi, lai glabātu lietojumprogrammai specifiskus parametrus, piemēram, datu bāzes savienojuma virknes vai API atslēgas.

Testēšana:

Rūpīgi pārbaudiet savas Tornado lietojumprogrammas, lai nodrošinātu, ka tās darbojas pareizi un droši. Izmantojiet vienību testus, integrācijas testus un gala-gala testus, lai aptvertu visus savas lietojumprogrammas aspektus.

Noslēgums

Tornado ir jaudīgs un daudzpusīgs tīmekļa ietvars, kas ir labi piemērots mērogojamu, augstas veiktspējas tīmekļa lietojumprogrammu izveidei. Tā asinhronā arhitektūra, WebSocket atbalsts un viegli lietojamā API padara to par populāru izvēli izstrādātājiem visā pasaulē. Ievērojot šajā visaptverošajā ceļvedī sniegtās vadlīnijas un piemērus, jūs varat sākt veidot savas Tornado lietojumprogrammas un izmantot tās daudzās iespējas.

Atcerieties konsultēties ar oficiālo Tornado dokumentāciju, lai iegūtu jaunāko informāciju un labāko praksi. Priecīgu kodēšanu!