M

MLOG

Română

O explorare aprofundată a lui Tornado, un framework web Python și bibliotecă de rețea asincronă. Învățați cum să construiți aplicații scalabile, de înaltă performanță, cu explicații detaliate, exemple și bune practici.

Documentație Tornado: Un Ghid Complet pentru Dezvoltatori din Lumea Întreagă

Tornado este un framework web Python și o bibliotecă de rețea asincronă, dezvoltată inițial la FriendFeed. Este deosebit de potrivit pentru long-polling, WebSockets și alte aplicații care necesită o conexiune de lungă durată pentru fiecare utilizator. I/O-ul său de rețea non-blocking îl face extrem de scalabil și o alegere puternică pentru construirea de aplicații web de înaltă performanță. Acest ghid complet vă va prezenta conceptele de bază ale lui Tornado și vă va oferi exemple practice pentru a începe.

Ce este Tornado?

În esență, Tornado este un framework web și o bibliotecă de rețea asincronă. Spre deosebire de framework-urile web sincrone tradiționale, Tornado folosește o arhitectură bazată pe o singură buclă de evenimente (event-loop) și un singur fir de execuție. Acest lucru înseamnă că poate gestiona multe conexiuni concurente fără a necesita un fir de execuție per conexiune, făcându-l mai eficient și mai scalabil.

Caracteristici Cheie ale Tornado:

Configurarea Mediului Tornado

Înainte de a vă scufunda în dezvoltarea cu Tornado, va trebui să vă configurați mediul. Iată un ghid pas cu pas:

  1. Instalați Python: Asigurați-vă că aveți instalat Python 3.6 sau o versiune mai recentă. Îl puteți descărca de pe site-ul oficial Python (python.org).
  2. Creați un Mediu Virtual (Recomandat): Folosiți venv sau virtualenv pentru a crea un mediu izolat pentru proiectul dumneavoastră: 
    python3 -m venv myenv
source myenv/bin/activate  # Pe Linux/macOS
myenv\Scripts\activate  # Pe Windows
  3. Instalați Tornado: Instalați Tornado folosind pip: 
    pip install tornado

Prima Dumneavoastră Aplicație Tornado

Să creăm o aplicație simplă "Hello, World!" cu Tornado. Creați un fișier numit app.py și adăugați următorul cod:

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

Acum, rulați aplicația din terminal:

python app.py

Deschideți browserul web și navigați la http://localhost:8888. Ar trebui să vedeți mesajul "Hello, World!".

Explicație:

Handlere de Cereri și Rutare

Handlerele de cereri sunt fundamentul aplicațiilor web Tornado. Ele definesc cum să se gestioneze cererile HTTP primite în funcție de URL. Rutarea mapează URL-urile la handlerele de cereri specifice.

Definirea Handlerelor de Cereri:

Pentru a crea un handler de cereri, moșteniți clasa tornado.web.RequestHandler și implementați metodele HTTP corespunzătoare (get, post, put, delete, etc.).

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

Rutare:

Rutarea este configurată la crearea tornado.web.Application. Furnizați o listă de tupluri, unde fiecare tuplu conține un model URL și handler-ul de cereri corespunzător.

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

Modele URL:

Modelele URL sunt expresii regulate. Puteți utiliza grupuri de expresii regulate pentru a captura părți ale URL-ului și a le transmite ca argumente metodelor handler-ului de cereri.

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

În acest exemplu, /user/([0-9]+) se potrivește cu URL-uri precum /user/123. Partea ([0-9]+) capturează una sau mai multe cifre și le transmite ca argument user_id metodei get a UserHandler.

Utilizarea Șabloanelor (Templating)

Tornado include un motor de șabloane simplu și eficient. Șabloanele sunt folosite pentru a genera HTML dinamic, separând logica de prezentare de logica aplicației.

Crearea Șabloanelor:

Șabloanele sunt de obicei stocate în fișiere separate (de ex., index.html). Iată un exemplu simplu:

<!DOCTYPE html>
<html>
<head>
 <title>Site-ul Meu</title>
</head>
<body>
 <h1>Bun venit, {{ name }}!</h1>
 <p>Astăzi este {{ today }}.</p>
</body>
</html>

{{ name }} și {{ today }} sunt substituenți care vor fi înlocuiți cu valori reale atunci când șablonul este redat.

Redarea Șabloanelor:

Pentru a reda un șablon, folosiți metoda render() în handler-ul de cereri:

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

Asigurați-vă că setarea template_path este configurată corect în setările aplicației. În mod implicit, Tornado caută șabloanele într-un director numit templates în același director cu fișierul aplicației.

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

Sintaxa Șabloanelor:

Șabloanele Tornado suportă diverse caracteristici, inclusiv:

Operațiuni Asincrone

Forța lui Tornado constă în capacitățile sale asincrone. Operațiunile asincrone permit aplicației dumneavoastră să efectueze I/O non-blocking, îmbunătățind performanța și scalabilitatea. Acest lucru este deosebit de util pentru sarcini care implică așteptarea resurselor externe, cum ar fi interogările la baza de date sau cererile de rețea.

@tornado.gen.coroutine:

Decoratorul @tornado.gen.coroutine vă permite să scrieți cod asincron folosind cuvântul cheie yield. Acest lucru face ca codul asincron să arate și să se comporte mai mult ca un cod sincron, îmbunătățind lizibilitatea și mentenabilitatea.

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

În acest exemplu, http_client.fetch() este o operațiune asincronă care returnează un Future. Cuvântul cheie yield suspendă execuția corutinei până când Future este rezolvat. Odată ce Future este rezolvat, corutina își reia execuția și corpul răspunsului este scris clientului.

tornado.concurrent.Future:

Un Future reprezintă rezultatul unei operațiuni asincrone care s-ar putea să nu fie încă disponibil. Puteți folosi obiecte Future pentru a înlănțui operațiuni asincrone și a gestiona erorile.

tornado.ioloop.IOLoop:

IOLoop este inima motorului asincron al lui Tornado. Acesta monitorizează descriptorii de fișiere și socket-urile pentru evenimente și le distribuie handler-elor corespunzătoare. De obicei, nu este necesar să interacționați direct cu IOLoop, dar este important să înțelegeți rolul său în gestionarea operațiunilor asincrone.

WebSockets

Tornado oferă suport excelent pentru WebSockets, permițând comunicarea în timp real între server și clienți. WebSockets sunt ideale pentru aplicații care necesită comunicare bidirecțională, cu latență redusă, cum ar fi aplicațiile de chat, jocurile online și dashboard-urile în timp real.

Crearea unui Handler WebSocket:

Pentru a crea un handler WebSocket, moșteniți clasa tornado.websocket.WebSocketHandler și implementați următoarele metode:

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 # Activează conexiunile WebSocket cross-origin

Integrarea WebSockets în Aplicația Dumneavoastră:

Adăugați handler-ul WebSocket la configurația de rutare a aplicației:

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

Implementarea pe Partea Client:

Pe partea client, puteți folosi JavaScript pentru a stabili o conexiune WebSocket și a trimite/primi mesaje:

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

Autentificare și Securitate

Securitatea este un aspect critic al dezvoltării aplicațiilor web. Tornado oferă mai multe caracteristici pentru a vă ajuta să securizați aplicațiile, inclusiv autentificare, autorizare și protecție împotriva vulnerabilităților web comune.

Autentificare:

Autentificarea este procesul de verificare a identității unui utilizator. Tornado oferă suport încorporat pentru diverse scheme de autentificare, inclusiv:

Autorizare:

Autorizarea este procesul de a determina dacă un utilizator are permisiunea de a accesa o anumită resursă. Puteți implementa logica de autorizare în handlerele de cereri pentru a restricționa accesul pe baza rolurilor sau permisiunilor utilizatorului.

Bune Practici de Securitate:

Implementare (Deployment)

Implementarea unei aplicații Tornado implică mai mulți pași, inclusiv configurarea unui server web, setarea unui manager de procese și optimizarea performanței.

Server Web:

Puteți implementa Tornado în spatele unui server web precum Nginx sau Apache. Serverul web acționează ca un reverse proxy, redirecționând cererile primite către aplicația Tornado.

Manager de Procese:

Un manager de procese precum Supervisor sau systemd poate fi folosit pentru a gestiona procesul Tornado, asigurând că este repornit automat dacă se blochează.

Optimizarea Performanței:

Internaționalizare (i18n) și Localizare (l10n)

Atunci când construiți aplicații pentru un public global, este important să luați în considerare internaționalizarea (i18n) și localizarea (l10n). i18n este procesul de proiectare a unei aplicații astfel încât să poată fi adaptată la diverse limbi și regiuni fără modificări de inginerie. l10n este procesul de adaptare a unei aplicații internaționalizate pentru o anumită limbă sau regiune prin adăugarea de componente specifice locației și traducerea textului.

Tornado și i18n/l10n

Tornado în sine nu are biblioteci i18n/l10n încorporate. Cu toate acestea, puteți integra cu ușurință biblioteci standard Python precum `gettext` sau framework-uri mai sofisticate precum Babel pentru a gestiona i18n/l10n în cadrul aplicației dumneavoastră Tornado.

Exemplu folosind `gettext`:

1. **Configurați localele:** Creați directoare pentru fiecare limbă pe care doriți să o susțineți, care să conțină cataloage de mesaje (de obicei fișiere `.mo`).

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

2. **Extrageți șirurile de tradus:** Folosiți un instrument precum `xgettext` pentru a extrage șirurile de tradus din codul dumneavoastră Python într-un fișier `.po` (Portable Object). Acest fișier va conține șirurile originale și locurile pentru traduceri.

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

3. **Traduceți șirurile:** Traduceți șirurile din fișierele `.po` pentru fiecare limbă.

4. **Compilați traducerile:** Compilați fișierele `.po` în fișiere `.mo` (Machine Object) care sunt folosite de `gettext` la runtime.

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

5. **Integrați în aplicația 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:
  # Gestionați cazurile în care locale-ul nu este suportat de sistem
  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ă pentru a determina locale-ul utilizatorului (de ex., din header-ul Accept-Language, setările utilizatorului etc.)
  # Acesta este un exemplu simplificat - veți avea nevoie de o soluție mai robustă
  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. **Modificați șabloanele:** Folosiți funcția `_()` (legată de `gettext.gettext`) pentru a marca șirurile pentru traducere în șabloanele dumneavoastră.

<h1>{{ _("Bun venit pe site-ul nostru!") }}</h1>
<p>{{ _("Acesta este un paragraf tradus.") }}</p>

Considerații Importante pentru Publicul Global:

Subiecte Avansate

Pagini de Eroare Personalizate:

Puteți personaliza paginile de eroare pe care Tornado le afișează atunci când apare o eroare. Acest lucru vă permite să oferiți o experiență mai prietenoasă pentru utilizator și să includeți informații de depanare.

Setări Personalizate:

Puteți defini setări personalizate în configurația aplicației și le puteți accesa în handlerele de cereri. Acest lucru este util pentru stocarea parametrilor specifici aplicației, cum ar fi șirurile de conexiune la baza de date sau cheile API.

Testare:

Testați temeinic aplicațiile Tornado pentru a vă asigura că funcționează corect și în siguranță. Folosiți teste unitare, teste de integrare și teste end-to-end pentru a acoperi toate aspectele aplicației.

Concluzie

Tornado este un framework web puternic și versatil, foarte potrivit pentru construirea de aplicații web scalabile și de înaltă performanță. Arhitectura sa asincronă, suportul pentru WebSocket și API-ul ușor de utilizat îl fac o alegere populară pentru dezvoltatorii din întreaga lume. Urmând îndrumările și exemplele din acest ghid complet, puteți începe să construiți propriile aplicații Tornado și să profitați de numeroasele sale caracteristici.

Nu uitați să consultați documentația oficială Tornado pentru cele mai actualizate informații și bune practici. Spor la programat!