M

MLOG

Slovenčina

Hĺbkový pohľad na Tornado, Python webový framework. Naučte sa tvoriť škálovateľné, výkonné aplikácie s podrobnými príkladmi a osvedčenými postupmi.

Dokumentácia k Tornadu: Komplexný sprievodca pre vývojárov z celého sveta

Tornado je Python webový framework a asynchrónna sieťová knižnica, pôvodne vyvinutá vo FriendFeed. Je obzvlášť vhodný pre long-polling, WebSockets a ďalšie aplikácie, ktoré vyžadujú dlhotrvajúce spojenie s každým používateľom. Jeho neblokujúce sieťové I/O ho robí extrémne škálovateľným a výkonnou voľbou pre vytváranie vysoko výkonných webových aplikácií. Tento komplexný sprievodca vás prevedie základnými konceptmi Tornada a poskytne praktické príklady, aby ste mohli začať.

Čo je Tornado?

Vo svojej podstate je Tornado webový framework a asynchrónna sieťová knižnica. Na rozdiel od tradičných synchrónnych webových frameworkov, Tornado používa architektúru založenú na jedinom vlákne a slučke udalostí. To znamená, že dokáže spracovať mnoho súbežných pripojení bez potreby jedného vlákna na pripojenie, čo ho robí efektívnejším a škálovateľnejším.

Kľúčové vlastnosti Tornada:

Nastavenie vášho prostredia pre Tornado

Predtým, ako sa ponoríte do vývoja s Tornadom, musíte si nastaviť svoje prostredie. Tu je podrobný sprievodca:

  1. Nainštalujte Python: Uistite sa, že máte nainštalovaný Python 3.6 alebo novší. Môžete si ho stiahnuť z oficiálnej webovej stránky Pythonu (python.org).
  2. Vytvorte virtuálne prostredie (odporúčané): Použite venv alebo virtualenv na vytvorenie izolovaného prostredia pre váš projekt: 
    python3 -m venv myenv
source myenv/bin/activate  # Na Linux/macOS
myenv\Scripts\activate  # Na Windowse
  3. Nainštalujte Tornado: Nainštalujte Tornado pomocou pip: 
    pip install tornado

Vaša prvá aplikácia v Tornade

Vytvorme jednoduchú "Hello, World!" aplikáciu s Tornadom. Vytvorte súbor s názvom app.py a pridajte nasledujúci kód:

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

Teraz spustite aplikáciu z vášho terminálu:

python app.py

Otvorte si webový prehliadač a prejdite na http://localhost:8888. Mali by ste vidieť správu "Hello, World!".

Vysvetlenie:

Obsluha požiadaviek a smerovanie (Routing)

Obsluha požiadaviek je základom webových aplikácií v Tornade. Definuje, ako spracovať prichádzajúce HTTP požiadavky na základe URL. Smerovanie mapuje URL na konkrétnu obsluhu požiadaviek.

Definovanie obsluhy požiadaviek:

Na vytvorenie obsluhy požiadaviek vytvorte podtriedu tornado.web.RequestHandler a implementujte príslušné HTTP metódy (get, post, put, delete atď.).

class MyHandler(tornado.web.RequestHandler):
 def get(self):
  self.write("Toto je GET požiadavka.")

 def post(self):
  data = self.request.body.decode('utf-8')
  self.write(f"Prijaté POST dáta: {data}")

Smerovanie:

Smerovanie sa konfiguruje pri vytváraní tornado.web.Application. Poskytnete zoznam n-tíc, kde každá n-tica obsahuje vzor URL a príslušnú obsluhu požiadaviek.

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

Vzory URL:

Vzory URL sú regulárne výrazy. Môžete použiť skupiny regulárnych výrazov na zachytenie častí URL a ich odovzdanie ako argumenty metódam obsluhy požiadaviek.

class UserHandler(tornado.web.RequestHandler):
 def get(self, user_id):
  self.write(f"ID používateľa: {user_id}")

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

V tomto príklade /user/([0-9]+) zodpovedá URL adresám ako /user/123. Časť ([0-9]+) zachytí jednu alebo viac číslic a odovzdá ich ako argument user_id metóde get handlera UserHandler.

Šablónovanie

Tornado obsahuje jednoduchý a efektívny šablónovací systém. Šablóny sa používajú na dynamické generovanie HTML, čím sa oddeľuje prezentačná logika od logiky aplikácie.

Vytváranie šablón:

Šablóny sa zvyčajne ukladajú do samostatných súborov (napr. index.html). Tu je jednoduchý príklad:

<!DOCTYPE html>
<html>
<head>
 <title>Moja webstránka</title>
</head>
<body>
 <h1>Vitaj, {{ name }}!</h1>
 <p>Dnes je {{ today }}.</p>
</body>
</html>

{{ name }} a {{ today }} sú zástupné symboly, ktoré budú pri vykresľovaní šablóny nahradené skutočnými hodnotami.

Vykresľovanie šablón:

Na vykreslenie šablóny použite metódu render() vo vašej obsluhe požiadaviek:

class TemplateHandler(tornado.web.RequestHandler):
 def get(self):
  name = "Ján Novák"
  today = "2023-10-27"
  self.render("index.html", name=name, today=today)

Uistite sa, že nastavenie template_path je správne nakonfigurované v nastaveniach vašej aplikácie. V predvolenom nastavení Tornado hľadá šablóny v adresári s názvom templates v tom istom adresári ako súbor vašej aplikácie.

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

Syntax šablón:

Šablóny v Tornade podporujú rôzne funkcie, vrátane:

Asynchrónne operácie

Sila Tornada spočíva v jeho asynchrónnych schopnostiach. Asynchrónne operácie umožňujú vašej aplikácii vykonávať neblokujúce I/O, čo zlepšuje výkon a škálovateľnosť. To je obzvlášť užitočné pre úlohy, ktoré zahŕňajú čakanie na externé zdroje, ako sú databázové dopyty alebo sieťové požiadavky.

@tornado.gen.coroutine:

Dekorátor @tornado.gen.coroutine vám umožňuje písať asynchrónny kód pomocou kľúčového slova yield. Vďaka tomu asynchrónny kód vyzerá a správa sa viac ako synchrónny kód, čo zlepšuje čitateľnosť a udržiavateľnosť.

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

V tomto príklade je http_client.fetch() asynchrónna operácia, ktorá vracia Future. Kľúčové slovo yield pozastaví vykonávanie korutiny, kým sa Future nevyrieši. Akonáhle je Future vyriešený, korutina pokračuje a telo odpovede sa zapíše klientovi.

tornado.concurrent.Future:

Future predstavuje výsledok asynchrónnej operácie, ktorá ešte nemusí byť dostupná. Môžete použiť objekty Future na reťazenie asynchrónnych operácií a spracovanie chýb.

tornado.ioloop.IOLoop:

IOLoop je srdcom asynchrónneho motora Tornada. Monitoruje súborové deskriptory a sokety na udalosti a posiela ich príslušným handlerom. Zvyčajne nemusíte priamo interagovať s IOLoop, ale je dôležité pochopiť jeho úlohu pri spracovaní asynchrónnych operácií.

WebSockets

Tornado poskytuje vynikajúcu podporu pre WebSockets, čo umožňuje komunikáciu v reálnom čase medzi serverom a klientmi. WebSockets sú ideálne pre aplikácie, ktoré vyžadujú obojsmernú komunikáciu s nízkou latenciou, ako sú chatovacie aplikácie, online hry a real-time dashboardy.

Vytvorenie WebSocket handlera:

Na vytvorenie WebSocket handlera vytvorte podtriedu tornado.websocket.WebSocketHandler a implementujte nasledujúce metódy:

import tornado.websocket

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

 def on_message(self, message):
  self.write_message(f"Poslali ste: {message}")

 def on_close(self):
  print("WebSocket zatvorený")

 def check_origin(self, origin):
  return True # Povolenie cross-origin WebSocket spojení

Integrácia WebSocketov do vašej aplikácie:

Pridajte WebSocket handler do konfiguračného smerovania vašej aplikácie:

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

Implementácia na strane klienta:

Na strane klienta môžete použiť JavaScript na nadviazanie WebSocket spojenia a posielanie/prijímanie správ:

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

websocket.onopen = () => {
 console.log("WebSocket spojenie nadviazané");
 websocket.send("Ahoj z klienta!");
};

websocket.onmessage = (event) => {
 console.log("Prijatá správa:", event.data);
};

websocket.onclose = () => {
 console.log("WebSocket spojenie zatvorené");
};

Autentifikácia a bezpečnosť

Bezpečnosť je kritickým aspektom vývoja webových aplikácií. Tornado poskytuje niekoľko funkcií, ktoré vám pomôžu zabezpečiť vaše aplikácie, vrátane autentifikácie, autorizácie a ochrany pred bežnými webovými zraniteľnosťami.

Autentifikácia:

Autentifikácia je proces overovania identity používateľa. Tornado poskytuje vstavanú podporu pre rôzne schémy autentifikácie, vrátane:

Autorizácia:

Autorizácia je proces určovania, či má používateľ povolenie na prístup k určitému zdroju. Môžete implementovať autorizačnú logiku vo vašich handeroch na obmedzenie prístupu na základe rolí alebo povolení používateľa.

Osvedčené postupy v oblasti bezpečnosti:

Nasadenie (Deployment)

Nasadenie aplikácie Tornado zahŕňa niekoľko krokov, vrátane konfigurácie webového servera, nastavenia správcu procesov a optimalizácie výkonu.

Webový server:

Môžete nasadiť Tornado za webovým serverom ako Nginx alebo Apache. Webový server funguje ako reverzný proxy, ktorý presmerováva prichádzajúce požiadavky na aplikáciu Tornado.

Správca procesov:

Správca procesov ako Supervisor alebo systemd môže byť použitý na správu procesu Tornado, zabezpečujúc, že sa automaticky reštartuje v prípade pádu.

Optimalizácia výkonu:

Internacionalizácia (i18n) a lokalizácia (l10n)

Pri vytváraní aplikácií pre globálne publikum je dôležité zvážiť internacionalizáciu (i18n) a lokalizáciu (l10n). i18n je proces navrhovania aplikácie tak, aby ju bolo možné prispôsobiť rôznym jazykom a regiónom bez technických zmien. l10n je proces prispôsobenia internacionalizovanej aplikácie pre konkrétny jazyk alebo región pridaním lokálnych komponentov a prekladom textu.

Tornado a i18n/l10n

Tornado samo o sebe nemá vstavané knižnice pre i18n/l10n. Avšak, môžete ľahko integrovať štandardné Python knižnice ako `gettext` alebo sofistikovanejšie frameworky ako Babel na spracovanie i18n/l10n vo vašej aplikácii Tornado.

Príklad použitia `gettext`:

1. **Nastavte svoje lokalizácie:** Vytvorte adresáre pre každý jazyk, ktorý chcete podporovať, obsahujúce katalógy správ (zvyčajne súbory `.mo`).

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

2. **Extrahujte preložiteľné reťazce:** Použite nástroj ako `xgettext` na extrahovanie preložiteľných reťazcov z vášho Python kódu do súboru `.po` (Portable Object). Tento súbor bude obsahovať pôvodné reťazce a miesta pre preklady.

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

3. **Preložte reťazce:** Preložte reťazce v `.po` súboroch pre každý jazyk.

4. **Skompilujte preklady:** Skompilujte `.po` súbory do súborov `.mo` (Machine Object), ktoré používa `gettext` za behu.

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

5. **Integrujte do vašej aplikácie Tornado:**

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:
   # Spracovanie prípadov, keď lokál nie je podporovaný systémom
   print(f"Lokál {self.get_user_locale().code} nie je podporovaný")

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

 def get_current_user_locale(self):
  # Logika na určenie lokálu používateľa (napr. z hlavičky Accept-Language, nastavení používateľa atď.)
  # Toto je zjednodušený príklad - budete potrebovať robustnejšie riešenie
  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. **Upravte svoje šablóny:** Použite funkciu `_()` (naviazanú na `gettext.gettext`) na označenie reťazcov pre preklad vo vašich šablónach.

<h1>{{ _("Vitajte na našej webstránke!") }}</h1>
<p>{{ _("Toto je preložený odsek.") }}</p>

Dôležité aspekty pre globálne publikum:

Pokročilé témy

Vlastné chybové stránky:

Môžete si prispôsobiť chybové stránky, ktoré Tornado zobrazí, keď nastane chyba. To vám umožní poskytnúť používateľsky prívetivejší zážitok a zahrnúť informácie na ladenie.

Vlastné nastavenia:

Môžete definovať vlastné nastavenia vo vašej konfigurácii aplikácie a pristupovať k nim vo vašich handeroch. To je užitočné pre ukladanie parametrov špecifických pre aplikáciu, ako sú reťazce pripojenia k databáze alebo API kľúče.

Testovanie:

Dôkladne testujte svoje aplikácie v Tornade, aby ste sa uistili, že fungujú správne a bezpečne. Používajte jednotkové testy, integračné testy a end-to-end testy na pokrytie všetkých aspektov vašej aplikácie.

Záver

Tornado je výkonný a všestranný webový framework, ktorý je veľmi vhodný na vytváranie škálovateľných a vysoko výkonných webových aplikácií. Jeho asynchrónna architektúra, podpora WebSocketov a ľahko použiteľné API ho robia populárnou voľbou pre vývojárov po celom svete. Dodržiavaním pokynov a príkladov v tomto komplexnom sprievodcovi môžete začať vytvárať vlastné aplikácie v Tornade a využívať jeho mnohé funkcie.

Nezabudnite sa obrátiť na oficiálnu dokumentáciu Tornada pre najaktuálnejšie informácie a osvedčené postupy. Príjemné kódovanie!