Tornado Dokumentáció: Átfogó Útmutató Fejlesztőknek Világszerte

A Tornado egy Python web keretrendszer és aszinkron hálózati könyvtár, amelyet eredetileg a FriendFeed-nél fejlesztettek ki. Különösen alkalmas long-polling, WebSockets és egyéb olyan alkalmazásokhoz, amelyek hosszan tartó kapcsolatot igényelnek minden egyes felhasználóval. A nem-blokkoló hálózati I/O rendkívül skálázhatóvá és hatékony választássá teszi nagy teljesítményű webalkalmazások építéséhez. Ez az átfogó útmutató végigvezeti Önt a Tornado alapvető koncepcióin, és gyakorlati példákkal segíti az elindulást.

Mi az a Tornado?

Lényegében a Tornado egy web keretrendszer és aszinkron hálózati könyvtár. A hagyományos szinkron web keretrendszerekkel ellentétben a Tornado egy egy szálon futó, eseményhurok-alapú architektúrát használ. Ez azt jelenti, hogy képes sok párhuzamos kapcsolatot kezelni anélkül, hogy kapcsolatonként egy szálra lenne szükség, ami hatékonyabbá és skálázhatóbbá teszi.

A Tornado Főbb Jellemzői:

Aszinkron Hálózatkezelés: A Tornado magja az aszinkron I/O köré épül, lehetővé téve, hogy hatékonyan kezeljen több ezer párhuzamos kapcsolatot.
Web Keretrendszer: Olyan funkciókat tartalmaz, mint a kéréskezelők, útválasztás, sablonkezelés és hitelesítés, ami teljes értékű web keretrendszerré teszi.
WebSocket Támogatás: A Tornado kiváló támogatást nyújt a WebSockets számára, lehetővé téve a valós idejű kommunikációt a szerver és a kliensek között.
Könnyű és Gyors: A teljesítményre tervezett Tornado könnyű és hatékony, minimalizálja a terhelést és maximalizálja az áteresztőképességet.
Könnyen Használható: Fejlett funkciói ellenére a Tornado viszonylag könnyen megtanulható és használható, tiszta és jól dokumentált API-val rendelkezik.

A Tornado Környezet Beállítása

Mielőtt belevágna a Tornado fejlesztésbe, be kell állítania a környezetét. Itt van egy lépésről-lépésre útmutató:

Telepítse a Pythont: Győződjön meg róla, hogy a Python 3.6 vagy újabb verziója van telepítve. Letöltheti a hivatalos Python webhelyről (python.org).
Hozzon létre egy virtuális környezetet (Ajánlott): Használja a venv vagy virtualenv parancsot egy izolált környezet létrehozásához a projektje számára:
```
python3 -m venv myenv
source myenv/bin/activate  # Linux/macOS esetén
myenv\Scripts\activate  # Windows esetén
```
Telepítse a Tornadót: Telepítse a Tornadót a pip segítségével:
```
pip install tornado
```

Az Első Tornado Alkalmazásod

Hozzuk létre egy egyszerű "Hello, World!" alkalmazást a Tornadóval. Hozz létre egy app.py nevű fájlt, és add hozzá a következő kódot:

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

Most futtassa az alkalmazást a terminálból:

python app.py

Nyissa meg a webböngészőjét, és navigáljon a http://localhost:8888 címre. Látnia kell a "Hello, World!" üzenetet.

Magyarázat:

tornado.ioloop: Az alap eseményhurok, amely az aszinkron műveleteket kezeli.
tornado.web: Biztosítja a web keretrendszer komponenseit, mint például a kéréskezelőket és az útválasztást.
MainHandler: Egy kéréskezelő, amely meghatározza, hogyan kell kezelni a bejövő HTTP kéréseket. A get() metódus a GET kérések esetén hívódik meg.
tornado.web.Application: Létrehozza a Tornado alkalmazást, összerendelve az URL mintákat a kéréskezelőkkel.
app.listen(8888): Elindítja a szervert, amely a 8888-as porton figyeli a bejövő kapcsolatokat.
tornado.ioloop.IOLoop.current().start(): Elindítja az eseményhurkot, amely feldolgozza a bejövő kéréseket és kezeli az aszinkron műveleteket.

Kéréskezelők és Útválasztás

A kéréskezelők a Tornado webalkalmazások alapjai. Meghatározzák, hogyan kell kezelni a bejövő HTTP kéréseket az URL alapján. Az útválasztás (routing) az URL-eket rendeli a megfelelő kéréskezelőkhöz.

Kéréskezelők Definálása:

Egy kéréskezelő létrehozásához származtasson egy osztályt a tornado.web.RequestHandler-ből, és implementálja a megfelelő HTTP metódusokat (get, post, put, delete, stb.).

class MyHandler(tornado.web.RequestHandler):
 def get(self):
  self.write("Ez egy GET kérés.")

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

Útválasztás:

Az útválasztás a tornado.web.Application létrehozásakor van konfigurálva. Egy tuple-ökből álló listát kell megadnia, ahol minden tuple egy URL mintát és a hozzá tartozó kéréskezelőt tartalmazza.

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

URL Minták:

Az URL minták reguláris kifejezések. Használhat reguláris kifejezés csoportokat az URL részeinek rögzítésére és argumentumként való átadására a kéréskezelő metódusainak.

class UserHandler(tornado.web.RequestHandler):
 def get(self, user_id):
  self.write(f"Felhasználói azonosító: {user_id}")

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

Ebben a példában a /user/([0-9]+) olyan URL-ekre illeszkedik, mint a /user/123. A ([0-9]+) rész egy vagy több számjegyet rögzít, és ezeket user_id argumentumként adja át a UserHandler get metódusának.

Sablonkezelés

A Tornado egy egyszerű és hatékony sablonkezelő motort tartalmaz. A sablonokat dinamikus HTML generálására használják, elválasztva a megjelenítési logikát az alkalmazás logikájától.

Sablonok Létrehozása:

A sablonokat általában különálló fájlokban tárolják (pl. index.html). Itt van egy egyszerű példa:

<!DOCTYPE html>
<html>
<head>
 <title>Weboldalam</title>
</head>
<body>
 <h1>Üdvözöllek, {{ name }}!</h1>
 <p>A mai nap {{ today }}.</p>
</body>
</html>

A {{ name }} és {{ today }} helykitöltők, amelyek a sablon renderelésekor valós értékekkel lesznek helyettesítve.

Sablonok Renderelése:

Egy sablon rendereléséhez használja a render() metódust a kéréskezelőjében:

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

Győződjön meg róla, hogy a template_path beállítás helyesen van konfigurálva az alkalmazás beállításaiban. Alapértelmezés szerint a Tornado a sablonokat egy templates nevű könyvtárban keresi, ugyanabban a könyvtárban, ahol az alkalmazásfájl található.

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

Sablon Szintaxis:

A Tornado sablonok különböző funkciókat támogatnak, többek között:

Változók: {{ variable }}
Vezérlési Szerkezetek: {% if condition %} ... {% else %} ... {% end %}, {% for item in items %} ... {% end %}
Függvények: {{ function(argument) }}
Beillesztések: {% include "another_template.html" %}
Escapelés: A Tornado automatikusan escapeli a HTML entitásokat a cross-site scripting (XSS) támadások megelőzése érdekében. Az escapelést a {% raw variable %} használatával tilthatja le.

Aszinkron Műveletek

A Tornado erőssége az aszinkron képességeiben rejlik. Az aszinkron műveletek lehetővé teszik az alkalmazás számára, hogy nem-blokkoló I/O műveleteket végezzen, javítva a teljesítményt és a skálázhatóságot. Ez különösen hasznos olyan feladatoknál, amelyek külső erőforrásokra való várakozással járnak, mint például adatbázis-lekérdezések vagy hálózati kérések.

`@tornado.gen.coroutine`:

A @tornado.gen.coroutine dekorátor lehetővé teszi, hogy aszinkron kódot írjon a yield kulcsszó használatával. Ezáltal az aszinkron kód kinézete és viselkedése jobban hasonlít a szinkron kódra, javítva az olvashatóságot és a karbantarthatóságot.

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

Ebben a példában a http_client.fetch() egy aszinkron művelet, amely egy Future-t ad vissza. A yield kulcsszó felfüggeszti a korutin végrehajtását, amíg a Future meg nem oldódik. Amint a Future megoldódik, a korutin folytatódik, és a válasz törzse kiírásra kerül a kliensnek.

`tornado.concurrent.Future`:

A Future egy olyan aszinkron művelet eredményét képviseli, amely még nem feltétlenül áll rendelkezésre. A Future objektumokkal láncba fűzheti az aszinkron műveleteket és kezelheti a hibákat.

`tornado.ioloop.IOLoop`:

Az IOLoop a Tornado aszinkron motorjának szíve. Figyeli a fájlleírókat és a socketeket az eseményekre, és továbbítja őket a megfelelő kezelőknek. Általában nem kell közvetlenül interakcióba lépnie az IOLoop-pal, de fontos megérteni a szerepét az aszinkron műveletek kezelésében.

WebSockets

A Tornado kiváló támogatást nyújt a WebSockets számára, lehetővé téve a valós idejű kommunikációt a szerver és a kliensek között. A WebSockets ideális olyan alkalmazásokhoz, amelyek kétirányú, alacsony késleltetésű kommunikációt igényelnek, mint például chat alkalmazások, online játékok és valós idejű műszerfalak.

WebSocket Kezelő Létrehozása:

Egy WebSocket kezelő létrehozásához származtasson egy osztályt a tornado.websocket.WebSocketHandler-ből, és implementálja a következő metódusokat:

open(): Akkor hívódik meg, amikor egy új WebSocket kapcsolat létrejön.
on_message(message): Akkor hívódik meg, amikor egy üzenet érkezik a klienstől.
on_close(): Akkor hívódik meg, amikor a WebSocket kapcsolat lezárul.

import tornado.websocket

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

 def on_message(self, message):
  self.write_message(f"Ezt küldted: {message}")

 def on_close(self):
  print("WebSocket lezárva")

 def check_origin(self, origin):
  return True # Engedélyezi a cross-origin WebSocket kapcsolatokat

WebSockets Integrálása az Alkalmazásba:

Adja hozzá a WebSocket kezelőt az alkalmazás útválasztási konfigurációjához:

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

Kliensoldali Implementáció:

A kliensoldalon JavaScript segítségével hozhat létre WebSocket kapcsolatot és küldhet/fogadhat üzeneteket:

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

websocket.onopen = () => {
 console.log("WebSocket kapcsolat létrehozva");
 websocket.send("Helló a klienstől!");
};

websocket.onmessage = (event) => {
 console.log("Fogadott üzenet:", event.data);
};

websocket.onclose = () => {
 console.log("WebSocket kapcsolat lezárva");
};

Hitelesítés és Biztonság

A biztonság a webalkalmazás-fejlesztés kritikus aspektusa. A Tornado számos funkciót kínál az alkalmazások biztonságossá tételéhez, beleértve a hitelesítést, az engedélyezést és a gyakori webes sebezhetőségek elleni védelmet.

Hitelesítés:

A hitelesítés a felhasználó személyazonosságának ellenőrzési folyamata. A Tornado beépített támogatást nyújt különböző hitelesítési sémákhoz, beleértve:

Cookie-alapú hitelesítés: A felhasználói hitelesítő adatok cookie-kban való tárolása.
Harmadik féltől származó hitelesítés (OAuth): Integráció népszerű közösségi média platformokkal, mint a Google, Facebook és Twitter.
API kulcsok: API kulcsok használata az API kérések hitelesítéséhez.

Engedélyezés:

Az engedélyezés (authorization) annak meghatározása, hogy egy felhasználónak van-e engedélye egy adott erőforrás eléréséhez. Az engedélyezési logikát a kéréskezelőkben implementálhatja, hogy korlátozza a hozzáférést a felhasználói szerepkörök vagy engedélyek alapján.

Biztonsági Bevált Gyakorlatok:

Cross-Site Scripting (XSS) Védelem: A Tornado automatikusan escapeli a HTML entitásokat az XSS támadások megelőzése érdekében. Mindig használja a render() metódust a sablonok rendereléséhez, és kerülje a HTML közvetlen generálását a kéréskezelőkben.
Cross-Site Request Forgery (CSRF) Védelem: Engedélyezze a CSRF védelmet az alkalmazás beállításaiban a CSRF támadások megelőzése érdekében.
HTTPS: Mindig használjon HTTPS-t a szerver és a kliensek közötti kommunikáció titkosításához.
Bemeneti Adatok Validálása: Validáljon minden felhasználói bemenetet az injekciós támadások és egyéb sebezhetőségek megelőzése érdekében.
Rendszeres Biztonsági Auditok: Végezzen rendszeres biztonsági auditokat a lehetséges sebezhetőségek azonosítása és kezelése érdekében.

Telepítés (Deployment)

Egy Tornado alkalmazás telepítése több lépésből áll, beleértve egy webszerver konfigurálását, egy folyamatkezelő beállítását és a teljesítmény optimalizálását.

Webszerver:

A Tornadót egy webszerver, mint például az Nginx vagy az Apache mögött is telepítheti. A webszerver fordított proxyként (reverse proxy) működik, továbbítva a bejövő kéréseket a Tornado alkalmazásnak.

Folyamatkezelő:

Egy folyamatkezelő, mint a Supervisor vagy a systemd, használható a Tornado folyamat kezelésére, biztosítva, hogy automatikusan újrainduljon, ha összeomlik.

Teljesítményoptimalizálás:

Használjon Termelési Környezetre Kész Eseményhurkot: Használjon egy termelési környezetre kész eseményhurkot, mint a uvloop a jobb teljesítmény érdekében.
Engedélyezze a gzip Tömörítést: Engedélyezze a gzip tömörítést a HTTP válaszok méretének csökkentése érdekében.
Gyorsítótárazza a Statikus Fájlokat: Gyorsítótárazza a statikus fájlokat a szerver terhelésének csökkentése érdekében.
Figyelje a Teljesítményt: Figyelje az alkalmazás teljesítményét olyan eszközökkel, mint a New Relic vagy a Prometheus.

Nemzetköziesítés (i18n) és Lokalizáció (l10n)

Globális közönségnek szánt alkalmazások építésekor fontos figyelembe venni a nemzetköziesítést (i18n) és a lokalizációt (l10n). Az i18n az alkalmazás olyan tervezési folyamata, amely lehetővé teszi, hogy mérnöki változtatások nélkül adaptálható legyen különböző nyelvekhez és régiókhoz. Az l10n az a folyamat, amely során egy nemzetköziesített alkalmazást egy adott nyelvhez vagy régióhoz igazítanak, helyspecifikus komponensek hozzáadásával és a szöveg lefordításával.

Tornado és i18n/l10n

A Tornado önmagában nem rendelkezik beépített i18n/l10n könyvtárakkal. Azonban könnyedén integrálhatók a szabványos Python könyvtárak, mint a `gettext`, vagy kifinomultabb keretrendszerek, mint a Babel, az i18n/l10n kezelésére a Tornado alkalmazásán belül.

Példa a `gettext` használatával:

1. **Állítsa be a területi beállításokat (locales):** Hozzon létre könyvtárakat minden támogatni kívánt nyelvhez, amelyek üzenetkatalógusokat (általában `.mo` fájlokat) tartalmaznak.

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

2. **Fordítandó szövegrészek kinyerése:** Használjon egy olyan eszközt, mint az `xgettext`, hogy kinyerje a lefordítandó szövegrészeket a Python kódjából egy `.po` (Portable Object) fájlba. Ez a fájl tartalmazza az eredeti szövegeket és a fordítások helyőrzőit.

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

3. **Fordítsa le a szövegrészeket:** Fordítsa le a szövegeket a `.po` fájlokban minden nyelvhez.

4. **Fordítások lefordítása (compile):** Fordítsa le a `.po` fájlokat `.mo` (Machine Object) fájlokká, amelyeket a `gettext` futásidőben használ.

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

5. **Integrálás a Tornado alkalmazásba:**

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:
  # Kezelje azokat az eseteket, amikor a területi beállítást a rendszer nem támogatja
  print(f"A(z) {self.get_user_locale().code} területi beállítás nem támogatott")

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

 def get_current_user_locale(self):
  # Logika a felhasználó területi beállításának meghatározására (pl. Accept-Language fejlécből, felhasználói beállításokból stb.)
  # Ez egy egyszerűsített példa - egy robusztusabb megoldásra lesz szüksége
  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. **Módosítsa a sablonokat:** Használja a `_()` függvényt (amely a `gettext.gettext`-hez van kötve) a fordításra szánt szövegrészek megjelölésére a sablonokban.

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

Fontos szempontok globális közönség számára:

**Karakterkódolás:** Mindig használjon UTF-8 kódolást a karakterek széles skálájának támogatásához.
**Dátum és Idő Formázása:** Használjon területi beállításoknak megfelelő dátum- és időformázást. A Python `strftime` és `strptime` függvényei használhatók a területi beállításokkal.
**Számformázás:** Használjon területi beállításoknak megfelelő számformázást (pl. tizedes elválasztók, ezres elválasztók). A `locale` modul biztosít erre funkciókat.
**Pénznem Formázása:** Használjon területi beállításoknak megfelelő pénznemformázást. Fontolja meg egy olyan könyvtár használatát, mint a `Babel` a fejlettebb pénznemkezeléshez.
**Jobbról-Balra (RTL) Író Nyelvek:** Támogassa az RTL nyelveket, mint az arab és a héber. Ez magában foglalhatja a weboldal elrendezésének tükrözését.
**Fordítás Minősége:** Használjon professzionális fordítókat a pontos és kulturálisan megfelelő fordítások biztosításához. A gépi fordítás jó kiindulópont lehet, de gyakran emberi felülvizsgálatot igényel.
**Felhasználói Területi Beállítások Észlelése:** Implementáljon robusztus területi beállítások észlelését a felhasználói preferenciák, böngészőbeállítások vagy IP-cím alapján. Biztosítson lehetőséget a felhasználóknak, hogy manuálisan válasszák ki a preferált nyelvüket.
**Tesztelés:** Alaposan tesztelje az alkalmazást különböző területi beállításokkal, hogy minden helyesen jelenjen meg.

Haladó Témakörök

Egyéni Hibaoldalak:

Testreszabhatja azokat a hibaoldalakat, amelyeket a Tornado hiba esetén megjelenít. Ez lehetővé teszi, hogy felhasználóbarátabb élményt nyújtson és hibakeresési információkat tartalmazzon.

Egyéni Beállítások:

Definiálhat egyéni beállításokat az alkalmazás konfigurációjában, és hozzáférhet hozzájuk a kéréskezelőkben. Ez hasznos az alkalmazásspecifikus paraméterek, például adatbázis-kapcsolati karakterláncok vagy API-kulcsok tárolására.

Tesztelés:

Alaposan tesztelje a Tornado alkalmazásait, hogy biztosítsa azok helyes és biztonságos működését. Használjon egységteszteket, integrációs teszteket és végponttól-végpontig teszteket az alkalmazás minden aspektusának lefedésére.

Összegzés

A Tornado egy hatékony és sokoldalú web keretrendszer, amely kiválóan alkalmas skálázható, nagy teljesítményű webalkalmazások építésére. Az aszinkron architektúrája, a WebSocket támogatása és a könnyen használható API-ja népszerű választássá teszi a fejlesztők körében világszerte. Az ebben az átfogó útmutatóban található irányelvek és példák követésével elkezdheti saját Tornado alkalmazásainak építését, és kihasználhatja annak számos funkcióját.

Ne felejtse el a hivatalos Tornado dokumentációt konzultálni a legfrissebb információkért és bevált gyakorlatokért. Jó kódolást!