M

MLOG

O'zbek

Tornado — Python veb-freymvorki va asinxron tarmoq kutubxonasini chuqur o‘rganing. Kengaytiriladigan, yuqori unumli ilovalar yaratishni o‘rganing.

Tornado Hujjatlari: Dunyo bo'ylab dasturchilar uchun keng qamrovli qo'llanma

Tornado — bu dastlab FriendFeed'da ishlab chiqilgan Python veb-freymvorki va asinxron tarmoq kutubxonasi. U ayniqsa uzoq so'rovlar (long-polling), WebSockets va har bir foydalanuvchi bilan uzoq muddatli aloqani talab qiladigan boshqa ilovalar uchun juda mos keladi. Uning bloklanmaydigan tarmoq I/O (kiritish/chiqarish) xususiyati uni juda kengaytiriluvchan va yuqori unumdorlikdagi veb-ilovalarni yaratish uchun kuchli tanlovga aylantiradi. Ushbu keng qamrovli qo'llanma sizni Tornado'ning asosiy tushunchalari bilan tanishtiradi va boshlashingiz uchun amaliy misollar taqdim etadi.

Tornado nima?

Asosan, Tornado — bu veb-freymvork va asinxron tarmoq kutubxonasi. An'anaviy sinxron veb-freymvorklardan farqli o'laroq, Tornado yagona oqimli, hodisalar tsikliga asoslangan arxitekturadan foydalanadi. Bu shuni anglatadiki, u har bir ulanish uchun alohida oqim talab qilmasdan ko'plab bir vaqtning o'zida ulanishlarni boshqara oladi, bu esa uni yanada samarali va kengaytiriluvchan qiladi.

Tornado'ning asosiy xususiyatlari:

Tornado muhitini sozlash

Tornado dasturlashiga sho'ng'ishdan oldin, siz o'z muhitingizni sozlashingiz kerak bo'ladi. Mana bosqichma-bosqich qo'llanma:

  1. Python o'rnatish: Sizda Python 3.6 yoki undan yuqori versiyasi o'rnatilganligiga ishonch hosil qiling. Uni rasmiy Python veb-saytidan (python.org) yuklab olishingiz mumkin.
  2. Virtual muhit yaratish (Tavsiya etiladi): Loyihangiz uchun izolyatsiya qilingan muhit yaratish uchun venv yoki virtualenv dan foydalaning: 
    python3 -m venv myenv
source myenv/bin/activate  # Linux/macOS uchun
myenv\Scripts\activate  # Windows uchun
  3. Tornado o'rnatish: pip yordamida Tornado'ni o'rnating: 
    pip install tornado

Sizning birinchi Tornado ilovangiz

Keling, Tornado yordamida oddiy "Hello, World!" ilovasini yaratamiz. app.py nomli fayl yarating va quyidagi kodni qo'shing:

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

Endi, ilovani terminalingizdan ishga tushiring:

python app.py

Veb-brauzeringizni oching va http://localhost:8888 manziliga o'ting. Siz "Hello, World!" xabarini ko'rishingiz kerak.

Tushuntirish:

So'rovlarni qayta ishlovchilar va marshrutlash

So'rovlarni qayta ishlovchilar Tornado veb-ilovalarining asosidir. Ular URL manziliga qarab kiruvchi HTTP so'rovlarini qanday boshqarishni belgilaydi. Marshrutlash URL manzillarini ma'lum so'rovlarni qayta ishlovchilarga bog'laydi.

So'rovlarni qayta ishlovchilarni aniqlash:

So'rovni qayta ishlovchi yaratish uchun, tornado.web.RequestHandler dan voris oling va tegishli HTTP usullarini (get, post, put, delete va hokazo) amalga oshiring.

class MyHandler(tornado.web.RequestHandler):
 def get(self):
  self.write("Bu GET so'rovi.")

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

Marshrutlash:

Marshrutlash tornado.web.Application yaratilayotganda sozlanadi. Siz kortejlar ro'yxatini taqdim etasiz, bu erda har bir kortej URL naqshini va unga mos keladigan so'rovni qayta ishlovchini o'z ichiga oladi.

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

URL naqshlari:

URL naqshlari muntazam ifodalardir. Siz URL ning qismlarini ushlash va ularni so'rovni qayta ishlovchi usullariga argument sifatida uzatish uchun muntazam ifoda guruhlaridan foydalanishingiz mumkin.

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

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

Ushbu misolda, /user/([0-9]+) /user/123 kabi URL'larga mos keladi. ([0-9]+) qismi bir yoki bir nechta raqamni ushlaydi va ularni UserHandlerning get usuliga user_id argumenti sifatida uzatadi.

Andozalash (Templating)

Tornado oddiy va samarali andozalash mexanizmini o'z ichiga oladi. Andozalar taqdimot mantig'ini dastur mantig'idan ajratib, HTMLni dinamik ravishda yaratish uchun ishlatiladi.

Andozalarni yaratish:

Andozalar odatda alohida fayllarda (masalan, index.html) saqlanadi. Mana oddiy misol:

<!DOCTYPE html>
<html>
<head>
 <title>Mening veb-saytim</title>
</head>
<body>
 <h1>Xush kelibsiz, {{ name }}!</h1>
 <p>Bugun {{ today }}.</p>
</body>
</html>

{{ name }} va {{ today }} andoza render qilinganda haqiqiy qiymatlar bilan almashtiriladigan joy egalaridir.

Andozalarni render qilish:

Andozani render qilish uchun so'rovni qayta ishlovchingizda render() usulidan foydalaning:

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

Ilova sozlamalarida template_path sozlamasi to'g'ri sozlanganligiga ishonch hosil qiling. Odatiy bo'lib, Tornado andozalarni dastur faylingiz bilan bir xil katalogdagi templates nomli papkadan qidiradi.

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

Andoza sintaksisi:

Tornado andozalari turli xususiyatlarni qo'llab-quvvatlaydi, jumladan:

Asinxron operatsiyalar

Tornado'ning kuchi uning asinxron imkoniyatlarida yotadi. Asinxron operatsiyalar ilovangizga bloklanmaydigan I/O ni amalga oshirishga imkon beradi, bu esa unumdorlik va kengaytiriluvchanlikni oshiradi. Bu, ayniqsa, ma'lumotlar bazasi so'rovlari yoki tarmoq so'rovlari kabi tashqi resurslarni kutishni o'z ichiga olgan vazifalar uchun foydalidir.

@tornado.gen.coroutine:

@tornado.gen.coroutine dekoratori sizga yield kalit so'zi yordamida asinxron kod yozishga imkon beradi. Bu asinxron kodni sinxron kod kabi ko'rinishiga va ishlashiga olib keladi, bu esa o'qilishi va saqlanishini yaxshilaydi.

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

Ushbu misolda http_client.fetch() Future obyektini qaytaradigan asinxron operatsiyadir. yield kalit so'zi Future hal etilguncha korutin (coroutine) bajarilishini to'xtatib turadi. Future hal etilgandan so'ng, korutin davom etadi va javob tanasi mijozga yoziladi.

tornado.concurrent.Future:

Future hali mavjud bo'lmasligi mumkin bo'lgan asinxron operatsiya natijasini ifodalaydi. Siz Future obyektlaridan asinxron operatsiyalarni bir-biriga bog'lash va xatoliklarni qayta ishlash uchun foydalanishingiz mumkin.

tornado.ioloop.IOLoop:

IOLoop — Tornado'ning asinxron mexanizmining yuragi. U fayl deskriptorlari va soketlarni hodisalar uchun kuzatib boradi va ularni tegishli qayta ishlovchilarga yuboradi. Odatda siz IOLoop bilan to'g'ridan-to'g'ri ishlashingiz shart emas, lekin uning asinxron operatsiyalarni boshqarishdagi rolini tushunish muhimdir.

WebSockets

Tornado WebSockets uchun ajoyib yordam taqdim etadi, bu esa server va mijozlar o'rtasida real vaqtda aloqa o'rnatish imkonini beradi. WebSockets chat ilovalari, onlayn o'yinlar va real vaqtdagi boshqaruv panellari kabi ikki tomonlama, past kechikishli aloqani talab qiladigan ilovalar uchun idealdir.

WebSocket qayta ishlovchisini yaratish:

WebSocket qayta ishlovchisini yaratish uchun tornado.websocket.WebSocketHandler dan voris oling va quyidagi usullarni amalga oshiring:

import tornado.websocket

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

 def on_message(self, message):
  self.write_message(f"Siz yubordingiz: {message}")

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

 def check_origin(self, origin):
  return True # Turli manbalardan WebSocket ulanishlarini yoqish

WebSockets'ni ilovangizga integratsiya qilish:

WebSocket qayta ishlovchisini ilovangizning marshrutlash konfiguratsiyasiga qo'shing:

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

Mijoz tomonidagi amalga oshirish:

Mijoz tomonida siz JavaScript yordamida WebSocket ulanishini o'rnatishingiz va xabarlarni yuborishingiz/qabul qilishingiz mumkin:

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

websocket.onopen = () => {
 console.log("WebSocket ulanishi o'rnatildi");
 websocket.send("Mijozdan salom!");
};

websocket.onmessage = (event) => {
 console.log("Xabar qabul qilindi:", event.data);
};

websocket.onclose = () => {
 console.log("WebSocket ulanishi yopildi");
};

Autentifikatsiya va Xavfsizlik

Xavfsizlik veb-ilovalarni ishlab chiqishning muhim jihatidir. Tornado ilovalaringizni himoya qilishga yordam beradigan bir nechta xususiyatlarni taqdim etadi, jumladan autentifikatsiya, avtorizatsiya va umumiy veb zaifliklaridan himoya.

Autentifikatsiya:

Autentifikatsiya — bu foydalanuvchining shaxsini tekshirish jarayoni. Tornado turli xil autentifikatsiya sxemalarini, jumladan, quyidagilarni o'rnatilgan holda qo'llab-quvvatlaydi:

Avtorizatsiya:

Avtorizatsiya — bu foydalanuvchining ma'lum bir resursga kirish huquqiga ega yoki ega emasligini aniqlash jarayoni. Siz foydalanuvchi rollari yoki ruxsatlariga asoslanib kirishni cheklash uchun so'rovlarni qayta ishlovchilaringizda avtorizatsiya mantig'ini amalga oshirishingiz mumkin.

Xavfsizlik bo'yicha ilg'or tajribalar:

Joylashtirish (Deployment)

Tornado ilovasini joylashtirish bir necha bosqichlarni o'z ichiga oladi, jumladan veb-serverni sozlash, jarayonlar menejerini o'rnatish va unumdorlikni optimallashtirish.

Veb-server:

Siz Tornado'ni Nginx yoki Apache kabi veb-server orqasida joylashtirishingiz mumkin. Veb-server teskari proksi sifatida ishlaydi va kiruvchi so'rovlarni Tornado ilovasiga yo'naltiradi.

Jarayonlar menejeri:

Supervisor yoki systemd kabi jarayonlar menejeri Tornado jarayonini boshqarish uchun ishlatilishi mumkin, bu esa uning ishdan chiqqan taqdirda avtomatik ravishda qayta ishga tushirilishini ta'minlaydi.

Unumdorlikni optimallashtirish:

Internatsionalizatsiya (i18n) va Lokalizatsiya (l10n)

Global auditoriya uchun ilovalar yaratishda internatsionalizatsiya (i18n) va lokalizatsiyani (l10n) hisobga olish muhim. i18n — bu ilovani muhandislik o'zgarishlarisiz turli tillar va mintaqalarga moslashtirish mumkin bo'lgan tarzda loyihalash jarayoni. l10n — bu mahalliy komponentlarni qo'shish va matnni tarjima qilish orqali internatsionallashtirilgan ilovani ma'lum bir til yoki mintaqa uchun moslashtirish jarayoni.

Tornado va i18n/l10n

Tornado o'zida o'rnatilgan i18n/l10n kutubxonalariga ega emas. Biroq, siz Tornado ilovangizda i18n/l10n ni boshqarish uchun `gettext` kabi standart Python kutubxonalarini yoki Babel kabi murakkabroq freymvorklarni osongina integratsiya qilishingiz mumkin.

`gettext` yordamida misol:

1. **Lokal sozlamalaringizni o'rnating:** Qo'llab-quvvatlamoqchi bo'lgan har bir til uchun papkalar yarating, ular xabarlar kataloglarini (odatda `.mo` fayllari) o'z ichiga oladi.

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

2. **Tarjima qilinadigan satrlarni ajratib oling:** Python kodingizdan tarjima qilinadigan satrlarni `.po` fayliga (Portable Object) ajratib olish uchun `xgettext` kabi vositadan foydalaning. Bu fayl asl satrlarni va tarjimalar uchun joy egalarini o'z ichiga oladi.

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

3. **Satrlarni tarjima qiling:** Har bir til uchun `.po` fayllaridagi satrlarni tarjima qiling.

4. **Tarjimalarni kompilyatsiya qiling:** `.po` fayllarini `gettext` tomonidan ish vaqtida ishlatiladigan `.mo` fayllariga (Machine Object) kompilyatsiya qiling.

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

5. **Tornado ilovangizga integratsiya qiling:**

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:
  # Lokal tizim tomonidan qo'llab-quvvatlanmagan holatlarni qayta ishlash
  print(f"Lokal {self.get_user_locale().code} qo'llab-quvvatlanmadi")

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

 def get_current_user_locale(self):
  # Foydalanuvchi lokalini aniqlash mantig'i (masalan, Accept-Language sarlavhasidan, foydalanuvchi sozlamalaridan va hokazo)
  # Bu soddalashtirilgan misol - sizga yanada mustahkamroq yechim kerak bo'ladi
  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. **Andozalaringizni o'zgartiring:** Andozalaringizda tarjima uchun satrlarni belgilash uchun `_()` funksiyasidan (`gettext.gettext` ga bog'langan) foydalaning.

<h1>{{ _("Veb-saytimizga xush kelibsiz!") }}</h1>
<p>{{ _("Bu tarjima qilingan paragraf.") }}</p>

Global auditoriya uchun muhim mulohazalar:

Murakkab mavzular

Maxsus xatolik sahifalari:

Xatolik yuz berganda Tornado ko'rsatadigan xatolik sahifalarini sozlashingiz mumkin. Bu sizga yanada qulay foydalanuvchi tajribasini taqdim etish va nosozliklarni tuzatish ma'lumotlarini kiritish imkonini beradi.

Maxsus sozlamalar:

Siz ilova konfiguratsiyasida maxsus sozlamalarni aniqlashingiz va ularga so'rovlarni qayta ishlovchilaringizda kirishingiz mumkin. Bu ma'lumotlar bazasiga ulanish satrlari yoki API kalitlari kabi dasturga xos parametrlarni saqlash uchun foydalidir.

Sinovdan o'tkazish:

Tornado ilovalaringizning to'g'ri va xavfsiz ishlashini ta'minlash uchun ularni sinchkovlik bilan sinab ko'ring. Ilovangizning barcha jihatlarini qamrab olish uchun birlik testlari, integratsiya testlari va uchdan-uchga testlardan foydalaning.

Xulosa

Tornado — bu kengaytiriladigan, yuqori unumdorlikdagi veb-ilovalarni yaratish uchun juda mos keladigan kuchli va ko'p qirrali veb-freymvork. Uning asinxron arxitekturasi, WebSocket'ni qo'llab-quvvatlashi va foydalanish oson bo'lgan API uni dunyo bo'ylab dasturchilar orasida mashhur tanlovga aylantiradi. Ushbu keng qamrovli qo'llanmadagi ko'rsatmalar va misollarga amal qilib, siz o'zingizning Tornado ilovalaringizni yaratishni boshlashingiz va uning ko'plab xususiyatlaridan foydalanishingiz mumkin.

Eng so'nggi ma'lumotlar va ilg'or tajribalar uchun rasmiy Tornado hujjatlariga murojaat qilishni unutmang. Dasturlashda omad!