ടൊർണാഡോ ഡോക്യുമെൻ്റേഷൻ: ലോകമെമ്പാടുമുള്ള ഡെവലപ്പർമാർക്കുള്ള ഒരു സമഗ്ര ഗൈഡ്

ടൊർണാഡോ ഒരു പൈത്തൺ വെബ് ഫ്രെയിംവർക്കും അസിൻക്രണസ് നെറ്റ്‌വർക്കിംഗ് ലൈബ്രറിയുമാണ്, ഇത് യഥാർത്ഥത്തിൽ ഫ്രണ്ട്ഫീഡിൽ വികസിപ്പിച്ചെടുത്തതാണ്. ലോംഗ്-പോളിംഗ്, വെബ്സോക്കറ്റുകൾ, ഓരോ ഉപയോക്താവിനും ദീർഘകാല കണക്ഷൻ ആവശ്യമുള്ള മറ്റ് ആപ്ലിക്കേഷനുകൾ എന്നിവയ്ക്ക് ഇത് പ്രത്യേകിച്ചും അനുയോജ്യമാണ്. ഇതിൻ്റെ നോൺ-ബ്ലോക്കിംഗ് നെറ്റ്‌വർക്ക് I/O ഇതിനെ അങ്ങേയറ്റം സ്കെയിലബിൾ ആക്കുകയും ഉയർന്ന പ്രകടനമുള്ള വെബ് ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്നതിനുള്ള ശക്തമായ ഒരു തിരഞ്ഞെടുപ്പാക്കി മാറ്റുകയും ചെയ്യുന്നു. ഈ സമഗ്രമായ ഗൈഡ് ടൊർണാഡോയുടെ പ്രധാന ആശയങ്ങളിലൂടെ നിങ്ങളെ കൊണ്ടുപോകുകയും ആരംഭിക്കുന്നതിനായി പ്രായോഗിക ഉദാഹരണങ്ങൾ നൽകുകയും ചെയ്യും.

എന്താണ് ടൊർണാഡോ?

അടിസ്ഥാനപരമായി, ടൊർണാഡോ ഒരു വെബ് ഫ്രെയിംവർക്കും അസിൻക്രണസ് നെറ്റ്വർക്കിംഗ് ലൈബ്രറിയുമാണ്. പരമ്പരാഗത സിൻക്രണസ് വെബ് ഫ്രെയിംവർക്കുകളിൽ നിന്ന് വ്യത്യസ്തമായി, ടൊർണാഡോ ഒരു സിംഗിൾ-ത്രെഡഡ്, ഇവൻ്റ്-ലൂപ്പ് അടിസ്ഥാനമാക്കിയുള്ള ആർക്കിടെക്ചർ ഉപയോഗിക്കുന്നു. ഓരോ കണക്ഷനും ഒരു ത്രെഡ് ആവശ്യമില്ലാതെ തന്നെ നിരവധി കോൺകറൻ്റ് കണക്ഷനുകൾ കൈകാര്യം ചെയ്യാൻ ഇതിന് കഴിയുമെന്നാണ് ഇതിനർത്ഥം, ഇത് കൂടുതൽ കാര്യക്ഷമവും സ്കെയിലബിളുമാക്കുന്നു.

ടൊർണാഡോയുടെ പ്രധാന സവിശേഷതകൾ:

അസിൻക്രണസ് നെറ്റ്‌വർക്കിംഗ്: ടൊർണാഡോയുടെ കാതൽ അസിൻക്രണസ് I/O-യ്ക്ക് ചുറ്റുമാണ് നിർമ്മിച്ചിരിക്കുന്നത്, ഇത് ആയിരക്കണക്കിന് കോൺകറൻ്റ് കണക്ഷനുകൾ കാര്യക്ഷമമായി കൈകാര്യം ചെയ്യാൻ അനുവദിക്കുന്നു.
വെബ് ഫ്രെയിംവർക്ക്: അഭ്യർത്ഥന ഹാൻഡ്‌ലറുകൾ, റൂട്ടിംഗ്, ടെംപ്ലേറ്റിംഗ്, ഓതൻ്റിക്കേഷൻ തുടങ്ങിയ സവിശേഷതകൾ ഇതിൽ ഉൾപ്പെടുന്നു, ഇത് ഒരു സമ്പൂർണ്ണ വെബ് ഫ്രെയിംവർക്കാക്കി മാറ്റുന്നു.
വെബ്സോക്കറ്റ് പിന്തുണ: ടൊർണാഡോ വെബ്സോക്കറ്റുകൾക്ക് മികച്ച പിന്തുണ നൽകുന്നു, ഇത് സെർവറും ക്ലയിൻ്റുകളും തമ്മിലുള്ള തത്സമയ ആശയവിനിമയം സാധ്യമാക്കുന്നു.
ഭാരം കുറഞ്ഞതും വേഗതയേറിയതും: പ്രകടനത്തിനായി രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്ന ടൊർണാഡോ ഭാരം കുറഞ്ഞതും കാര്യക്ഷമവുമാണ്, ഓവർഹെഡ് കുറയ്ക്കുകയും ത്രൂപുട്ട് വർദ്ധിപ്പിക്കുകയും ചെയ്യുന്നു.
ഉപയോഗിക്കാൻ എളുപ്പമാണ്: അതിൻ്റെ നൂതന സവിശേഷതകൾക്കിടയിലും, വ്യക്തവും നന്നായി ഡോക്യുമെൻ്റ് ചെയ്തതുമായ API ഉപയോഗിച്ച് ടൊർണാഡോ പഠിക്കാനും ഉപയോഗിക്കാനും താരതമ്യേന എളുപ്പമാണ്.

നിങ്ങളുടെ ടൊർണാഡോ എൻവയോൺമെൻ്റ് സജ്ജീകരിക്കുന്നു

ടൊർണാഡോ ഡെവലപ്‌മെൻ്റിലേക്ക് കടക്കുന്നതിന് മുമ്പ്, നിങ്ങളുടെ എൻവയോൺമെൻ്റ് സജ്ജീകരിക്കേണ്ടതുണ്ട്. അതിനുള്ള ഘട്ടം ഘട്ടമായുള്ള ഒരു ഗൈഡ് ഇതാ:

പൈത്തൺ ഇൻസ്റ്റാൾ ചെയ്യുക: പൈത്തൺ 3.6 അല്ലെങ്കിൽ അതിലും ഉയർന്ന പതിപ്പ് ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക. ഔദ്യോഗിക പൈത്തൺ വെബ്സൈറ്റിൽ (python.org) നിന്ന് നിങ്ങൾക്ക് ഇത് ഡൗൺലോഡ് ചെയ്യാം.
ഒരു വെർച്വൽ എൻവയോൺമെൻ്റ് ഉണ്ടാക്കുക (ശുപാർശ ചെയ്യുന്നത്): നിങ്ങളുടെ പ്രോജക്റ്റിനായി ഒരു ഐസൊലേറ്റഡ് എൻവയോൺമെൻ്റ് ഉണ്ടാക്കാൻ venv അല്ലെങ്കിൽ virtualenv ഉപയോഗിക്കുക:
```
python3 -m venv myenv
source myenv/bin/activate  # ലിനക്സ്/മാക്ഒഎസിൽ
myenv\Scripts\activate  # വിൻഡോസിൽ
```
ടൊർണാഡോ ഇൻസ്റ്റാൾ ചെയ്യുക: pip ഉപയോഗിച്ച് ടൊർണാഡോ ഇൻസ്റ്റാൾ ചെയ്യുക:
```
pip install tornado
```

നിങ്ങളുടെ ആദ്യത്തെ ടൊർണാഡോ ആപ്ലിക്കേഷൻ

നമുക്ക് ടൊർണാഡോ ഉപയോഗിച്ച് ഒരു ലളിതമായ "ഹലോ, വേൾഡ്!" ആപ്ലിക്കേഷൻ ഉണ്ടാക്കാം. app.py എന്ന പേരിൽ ഒരു ഫയൽ ഉണ്ടാക്കി താഴെ പറയുന്ന കോഡ് ചേർക്കുക:

import tornado.ioloop
import tornado.web

class MainHandler(tornado.web.RequestHandler):
 def get(self):
  self.write("ഹലോ, വേൾഡ്!")

def make_app():
 return tornado.web.Application([
  (r"/", MainHandler),
 ])

if __name__ == "__main__":
 app = make_app()
 app.listen(8888)
 tornado.ioloop.IOLoop.current().start()

ഇനി, നിങ്ങളുടെ ടെർമിനലിൽ നിന്ന് ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കുക:

python app.py

നിങ്ങളുടെ വെബ് ബ്രൗസർ തുറന്ന് http://localhost:8888 എന്നതിലേക്ക് പോകുക. നിങ്ങൾക്ക് "ഹലോ, വേൾഡ്!" എന്ന സന്ദേശം കാണാൻ കഴിയും.

വിശദീകരണം:

tornado.ioloop: അസിൻക്രണസ് പ്രവർത്തനങ്ങൾ കൈകാര്യം ചെയ്യുന്ന പ്രധാന ഇവൻ്റ് ലൂപ്പ്.
tornado.web: റിക്വസ്റ്റ് ഹാൻഡ്‌ലറുകളും റൂട്ടിംഗും പോലുള്ള വെബ് ഫ്രെയിംവർക്ക് ഘടകങ്ങൾ നൽകുന്നു.
MainHandler: വരുന്ന HTTP അഭ്യർത്ഥനകൾ എങ്ങനെ കൈകാര്യം ചെയ്യണമെന്ന് നിർവചിക്കുന്ന ഒരു റിക്വസ്റ്റ് ഹാൻഡ്‌ലർ. GET അഭ്യർത്ഥനകൾക്കായി get() മെത്തേഡ് വിളിക്കപ്പെടുന്നു.
tornado.web.Application: URL പാറ്റേണുകളെ റിക്വസ്റ്റ് ഹാൻഡ്‌ലറുകളിലേക്ക് മാപ്പ് ചെയ്തുകൊണ്ട് ടൊർണാഡോ ആപ്ലിക്കേഷൻ ഉണ്ടാക്കുന്നു.
app.listen(8888): പോർട്ട് 8888-ൽ വരുന്ന കണക്ഷനുകൾക്കായി കാത്തിരുന്ന് സെർവർ ആരംഭിക്കുന്നു.
tornado.ioloop.IOLoop.current().start(): ഇവൻ്റ് ലൂപ്പ് ആരംഭിക്കുന്നു, ഇത് വരുന്ന അഭ്യർത്ഥനകൾ പ്രോസസ്സ് ചെയ്യുകയും അസിൻക്രണസ് പ്രവർത്തനങ്ങൾ കൈകാര്യം ചെയ്യുകയും ചെയ്യുന്നു.

റിക്വസ്റ്റ് ഹാൻഡ്‌ലറുകളും റൂട്ടിംഗും

റിക്വസ്റ്റ് ഹാൻഡ്‌ലറുകളാണ് ടൊർണാഡോ വെബ് ആപ്ലിക്കേഷനുകളുടെ അടിസ്ഥാനം. URL-നെ അടിസ്ഥാനമാക്കി വരുന്ന HTTP അഭ്യർത്ഥനകൾ എങ്ങനെ കൈകാര്യം ചെയ്യണമെന്ന് അവ നിർവചിക്കുന്നു. റൂട്ടിംഗ് URL-കളെ നിർദ്ദിഷ്ട റിക്വസ്റ്റ് ഹാൻഡ്‌ലറുകളിലേക്ക് മാപ്പ് ചെയ്യുന്നു.

റിക്വസ്റ്റ് ഹാൻഡ്‌ലറുകൾ നിർവചിക്കുന്നു:

ഒരു റിക്വസ്റ്റ് ഹാൻഡ്‌ലർ ഉണ്ടാക്കാൻ, tornado.web.RequestHandler സബ്ക്ലാസ് ചെയ്യുകയും ഉചിതമായ HTTP മെത്തേഡുകൾ (get, post, put, delete, തുടങ്ങിയവ) നടപ്പിലാക്കുകയും ചെയ്യുക.

class MyHandler(tornado.web.RequestHandler):
 def get(self):
  self.write("ഇതൊരു GET അഭ്യർത്ഥനയാണ്.")

 def post(self):
  data = self.request.body.decode('utf-8')
  self.write(f"ലഭിച്ച POST ഡാറ്റ: {data}")

റൂട്ടിംഗ്:

tornado.web.Application ഉണ്ടാക്കുമ്പോൾ റൂട്ടിംഗ് കോൺഫിഗർ ചെയ്യപ്പെടുന്നു. നിങ്ങൾ ട്യൂപ്പിളുകളുടെ ഒരു ലിസ്റ്റ് നൽകുന്നു, ഓരോ ട്യൂപ്പിളിലും ഒരു URL പാറ്റേണും അതിനനുസരിച്ചുള്ള റിക്വസ്റ്റ് ഹാൻഡ്‌ലറും അടങ്ങിയിരിക്കുന്നു.

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

URL പാറ്റേണുകൾ:

URL പാറ്റേണുകൾ റെഗുലർ എക്സ്പ്രഷനുകളാണ്. URL-ന്റെ ഭാഗങ്ങൾ പിടിച്ചെടുക്കാനും അവയെ റിക്വസ്റ്റ് ഹാൻഡ്‌ലർ മെത്തേഡുകളിലേക്ക് ആർഗ്യുമെൻ്റുകളായി കൈമാറാനും നിങ്ങൾക്ക് റെഗുലർ എക്സ്പ്രഷൻ ഗ്രൂപ്പുകൾ ഉപയോഗിക്കാം.

class UserHandler(tornado.web.RequestHandler):
 def get(self, user_id):
  self.write(f"ഉപയോക്തൃ ഐഡി: {user_id}")

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

ഈ ഉദാഹരണത്തിൽ, /user/([0-9]+) എന്നത് /user/123 പോലുള്ള URL-കളുമായി പൊരുത്തപ്പെടുന്നു. ([0-9]+) എന്ന ഭാഗം ഒന്നോ അതിലധികമോ അക്കങ്ങളെ പിടിച്ചെടുക്കുകയും അവയെ UserHandler-ന്റെ get മെത്തേഡിലേക്ക് user_id ആർഗ്യുമെൻ്റായി കൈമാറുകയും ചെയ്യുന്നു.

ടെംപ്ലേറ്റിംഗ്

ടൊർണാഡോയിൽ ലളിതവും കാര്യക്ഷമവുമായ ഒരു ടെംപ്ലേറ്റിംഗ് എഞ്ചിൻ ഉൾപ്പെടുന്നു. അവതരണ ലോജിക്കിനെ ആപ്ലിക്കേഷൻ ലോജിക്കിൽ നിന്ന് വേർതിരിച്ച്, ഡൈനാമിക് ആയി HTML ഉണ്ടാക്കാൻ ടെംപ്ലേറ്റുകൾ ഉപയോഗിക്കുന്നു.

ടെംപ്ലേറ്റുകൾ ഉണ്ടാക്കുന്നു:

ടെംപ്ലേറ്റുകൾ സാധാരണയായി പ്രത്യേക ഫയലുകളിലാണ് (ഉദാഹരണത്തിന്, index.html) സൂക്ഷിക്കുന്നത്. ഒരു ലളിതമായ ഉദാഹരണം ഇതാ:

<!DOCTYPE html>
<html>
<head>
 <title>എൻ്റെ വെബ്സൈറ്റ്</title>
</head>
<body>
 <h1>സ്വാഗതം, {{ name }}!</h1>
 <p>ഇന്ന് {{ today }}.</p>
</body>
</html>

{{ name }}, {{ today }} എന്നിവ പ്ലേസ്ഹോൾഡറുകളാണ്, ടെംപ്ലേറ്റ് റെൻഡർ ചെയ്യുമ്പോൾ അവയുടെ സ്ഥാനത്ത് യഥാർത്ഥ മൂല്യങ്ങൾ വരും.

ടെംപ്ലേറ്റുകൾ റെൻഡർ ചെയ്യുന്നു:

ഒരു ടെംപ്ലേറ്റ് റെൻഡർ ചെയ്യുന്നതിന്, നിങ്ങളുടെ റിക്വസ്റ്റ് ഹാൻഡ്‌ലറിൽ render() മെത്തേഡ് ഉപയോഗിക്കുക:

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

നിങ്ങളുടെ ആപ്ലിക്കേഷൻ ക്രമീകരണങ്ങളിൽ template_path ശരിയായി ക്രമീകരിച്ചിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക. ഡിഫോൾട്ടായി, നിങ്ങളുടെ ആപ്ലിക്കേഷൻ ഫയലിൻ്റെ അതേ ഡയറക്ടറിയിലുള്ള templates എന്ന ഡയറക്ടറിയിലാണ് ടൊർണാഡോ ടെംപ്ലേറ്റുകൾക്കായി തിരയുന്നത്.

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

ടെംപ്ലേറ്റ് സിൻടാക്സ്:

ടൊർണാഡോ ടെംപ്ലേറ്റുകൾ വിവിധ സവിശേഷതകളെ പിന്തുണയ്ക്കുന്നു, അവയിൽ ഉൾപ്പെടുന്നവ:

വേരിയബിളുകൾ: {{ variable }}
കൺട്രോൾ ഫ്ലോ: {% if condition %} ... {% else %} ... {% end %}, {% for item in items %} ... {% end %}
ഫംഗ്ഷനുകൾ: {{ function(argument) }}
ഇൻക്ലൂഡുകൾ: {% include "another_template.html" %}
എസ്കേപ്പിംഗ്: ക്രോസ്-സൈറ്റ് സ്ക്രിപ്റ്റിംഗ് (XSS) ആക്രമണങ്ങൾ തടയാൻ ടൊർണാഡോ യാന്ത്രികമായി HTML എൻ്റിറ്റികളെ എസ്കേപ്പ് ചെയ്യുന്നു. {% raw variable %} ഉപയോഗിച്ച് നിങ്ങൾക്ക് എസ്കേപ്പിംഗ് പ്രവർത്തനരഹിതമാക്കാം.

അസിൻക്രണസ് ഓപ്പറേഷൻസ്

ടൊർണാഡോയുടെ ശക്തി അതിൻ്റെ അസിൻക്രണസ് കഴിവുകളിലാണ്. അസിൻക്രണസ് പ്രവർത്തനങ്ങൾ നിങ്ങളുടെ ആപ്ലിക്കേഷനെ നോൺ-ബ്ലോക്കിംഗ് I/O ചെയ്യാൻ അനുവദിക്കുന്നു, ഇത് പ്രകടനവും സ്കേലബിലിറ്റിയും മെച്ചപ്പെടുത്തുന്നു. ഡാറ്റാബേസ് ക്വറികൾ അല്ലെങ്കിൽ നെറ്റ്‌വർക്ക് അഭ്യർത്ഥനകൾ പോലുള്ള ബാഹ്യ ഉറവിടങ്ങൾക്കായി കാത്തിരിക്കുന്നത് ഉൾപ്പെടുന്ന ജോലികൾക്ക് ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്.

`@tornado.gen.coroutine`:

@tornado.gen.coroutine ഡെക്കറേറ്റർ yield കീവേഡ് ഉപയോഗിച്ച് അസിൻക്രണസ് കോഡ് എഴുതാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഇത് അസിൻക്രണസ് കോഡിനെ സിൻക്രണസ് കോഡ് പോലെ തോന്നിപ്പിക്കുകയും പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുന്നു, ഇത് വായനാക്ഷമതയും പരിപാലനക്ഷമതയും മെച്ചപ്പെടുത്തുന്നു.

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

ഈ ഉദാഹരണത്തിൽ, http_client.fetch() ഒരു Future തിരികെ നൽകുന്ന ഒരു അസിൻക്രണസ് പ്രവർത്തനമാണ്. yield കീവേഡ് Future പരിഹരിക്കപ്പെടുന്നതുവരെ കോറൂട്ടീനിൻ്റെ നിർവ്വഹണം താൽക്കാലികമായി നിർത്തുന്നു. Future പരിഹരിച്ചുകഴിഞ്ഞാൽ, കോറൂട്ടീൻ പുനരാരംഭിക്കുകയും പ്രതികരണ ബോഡി ക്ലയിൻ്റിലേക്ക് എഴുതുകയും ചെയ്യുന്നു.

`tornado.concurrent.Future`:

ഒരു Future ഇതുവരെ ലഭ്യമാകാത്ത ഒരു അസിൻക്രണസ് പ്രവർത്തനത്തിൻ്റെ ഫലത്തെ പ്രതിനിധീകരിക്കുന്നു. അസിൻക്രണസ് പ്രവർത്തനങ്ങൾ ഒരുമിച്ച് ബന്ധിപ്പിക്കാനും പിശകുകൾ കൈകാര്യം ചെയ്യാനും നിങ്ങൾക്ക് Future ഒബ്ജക്റ്റുകൾ ഉപയോഗിക്കാം.

`tornado.ioloop.IOLoop`:

IOLoop ടൊർണാഡോയുടെ അസിൻക്രണസ് എഞ്ചിൻ്റെ ഹൃദയമാണ്. ഇത് ഫയൽ ഡിസ്ക്രിപ്റ്ററുകളും സോക്കറ്റുകളും ഇവൻ്റുകൾക്കായി നിരീക്ഷിക്കുകയും അവയെ ഉചിതമായ ഹാൻഡ്‌ലറുകളിലേക്ക് അയയ്ക്കുകയും ചെയ്യുന്നു. സാധാരണയായി നിങ്ങൾ IOLoop-മായി നേരിട്ട് സംവദിക്കേണ്ടതില്ല, എന്നാൽ അസിൻക്രണസ് പ്രവർത്തനങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിൽ അതിൻ്റെ പങ്ക് മനസ്സിലാക്കേണ്ടത് പ്രധാനമാണ്.

വെബ്സോക്കറ്റുകൾ

ടൊർണാഡോ വെബ്സോക്കറ്റുകൾക്ക് മികച്ച പിന്തുണ നൽകുന്നു, ഇത് സെർവറും ക്ലയിൻ്റുകളും തമ്മിലുള്ള തത്സമയ ആശയവിനിമയം സാധ്യമാക്കുന്നു. ചാറ്റ് ആപ്ലിക്കേഷനുകൾ, ഓൺലൈൻ ഗെയിമുകൾ, തത്സമയ ഡാഷ്‌ബോർഡുകൾ തുടങ്ങിയ ദ്വിദിശയിലുള്ള, കുറഞ്ഞ ലേറ്റൻസി ആശയവിനിമയം ആവശ്യമുള്ള ആപ്ലിക്കേഷനുകൾക്ക് വെബ്സോക്കറ്റുകൾ അനുയോജ്യമാണ്.

ഒരു വെബ്സോക്കറ്റ് ഹാൻഡ്‌ലർ ഉണ്ടാക്കുന്നു:

ഒരു വെബ്സോക്കറ്റ് ഹാൻഡ്‌ലർ ഉണ്ടാക്കാൻ, tornado.websocket.WebSocketHandler സബ്ക്ലാസ് ചെയ്യുകയും ഇനിപ്പറയുന്ന മെത്തേഡുകൾ നടപ്പിലാക്കുകയും ചെയ്യുക:

open(): ഒരു പുതിയ വെബ്സോക്കറ്റ് കണക്ഷൻ സ്ഥാപിക്കുമ്പോൾ വിളിക്കപ്പെടുന്നു.
on_message(message): ക്ലയിൻ്റിൽ നിന്ന് ഒരു സന്ദേശം ലഭിക്കുമ്പോൾ വിളിക്കപ്പെടുന്നു.
on_close(): വെബ്സോക്കറ്റ് കണക്ഷൻ അടയ്ക്കുമ്പോൾ വിളിക്കപ്പെടുന്നു.

import tornado.websocket

class WebSocketHandler(tornado.websocket.WebSocketHandler):
 def open(self):
  print("വെബ്സോക്കറ്റ് തുറന്നു")

 def on_message(self, message):
  self.write_message(f"നിങ്ങൾ അയച്ചത്: {message}")

 def on_close(self):
  print("വെബ്സോക്കറ്റ് അടച്ചു")

 def check_origin(self, origin):
  return True # ക്രോസ്-ഒറിജിൻ വെബ്സോക്കറ്റ് കണക്ഷനുകൾ പ്രവർത്തനക്ഷമമാക്കുക

നിങ്ങളുടെ ആപ്ലിക്കേഷനിലേക്ക് വെബ്സോക്കറ്റുകൾ സംയോജിപ്പിക്കുന്നു:

നിങ്ങളുടെ ആപ്ലിക്കേഷൻ്റെ റൂട്ടിംഗ് കോൺഫിഗറേഷനിലേക്ക് വെബ്സോക്കറ്റ് ഹാൻഡ്‌ലർ ചേർക്കുക:

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

ക്ലയിൻ്റ്-സൈഡ് നടപ്പിലാക്കൽ:

ക്ലയിൻ്റ് ഭാഗത്ത്, ഒരു വെബ്സോക്കറ്റ് കണക്ഷൻ സ്ഥാപിക്കുന്നതിനും സന്ദേശങ്ങൾ അയക്കുന്നതിനും സ്വീകരിക്കുന്നതിനും നിങ്ങൾക്ക് ജാവാസ്ക്രിപ്റ്റ് ഉപയോഗിക്കാം:

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

websocket.onopen = () => {
 console.log("വെബ്സോക്കറ്റ് കണക്ഷൻ സ്ഥാപിച്ചു");
 websocket.send("ക്ലയിൻ്റിൽ നിന്നുള്ള ഹലോ!");
};

websocket.onmessage = (event) => {
 console.log("സന്ദേശം ലഭിച്ചു:", event.data);
};

websocket.onclose = () => {
 console.log("വെബ്സോക്കറ്റ് കണക്ഷൻ അടച്ചു");
};

ഓതൻ്റിക്കേഷനും സുരക്ഷയും

വെബ് ആപ്ലിക്കേഷൻ വികസനത്തിൻ്റെ ഒരു നിർണായക വശമാണ് സുരക്ഷ. ഓതൻ്റിക്കേഷൻ, ഓതറൈസേഷൻ, സാധാരണ വെബ് കേടുപാടുകൾക്കെതിരായ സംരക്ഷണം എന്നിവ ഉൾപ്പെടെ നിങ്ങളുടെ ആപ്ലിക്കേഷനുകൾ സുരക്ഷിതമാക്കാൻ സഹായിക്കുന്ന നിരവധി സവിശേഷതകൾ ടൊർണാഡോ നൽകുന്നു.

ഓതൻ്റിക്കേഷൻ:

ഒരു ഉപയോക്താവിൻ്റെ ഐഡൻ്റിറ്റി പരിശോധിക്കുന്ന പ്രക്രിയയാണ് ഓതൻ്റിക്കേഷൻ. ഇനിപ്പറയുന്നവ ഉൾപ്പെടെ വിവിധ ഓതൻ്റിക്കേഷൻ സ്കീമുകൾക്ക് ടൊർണാഡോ ബിൽറ്റ്-ഇൻ പിന്തുണ നൽകുന്നു:

കുക്കി അധിഷ്ഠിത ഓതൻ്റിക്കേഷൻ: ഉപയോക്തൃ ക്രെഡൻഷ്യലുകൾ കുക്കികളിൽ സൂക്ഷിക്കുക.
തേർഡ്-പാർട്ടി ഓതൻ്റിക്കേഷൻ (OAuth): ഗൂഗിൾ, ഫേസ്ബുക്ക്, ട്വിറ്റർ തുടങ്ങിയ ജനപ്രിയ സോഷ്യൽ മീഡിയ പ്ലാറ്റ്‌ഫോമുകളുമായി സംയോജിപ്പിക്കുക.
API കീകൾ: API അഭ്യർത്ഥനകൾ ഓതൻ്റിക്കേറ്റ് ചെയ്യുന്നതിന് API കീകൾ ഉപയോഗിക്കുക.

ഓതറൈസേഷൻ:

ഒരു ഉപയോക്താവിന് ഒരു പ്രത്യേക റിസോഴ്സ് ആക്സസ് ചെയ്യാൻ അനുവാദമുണ്ടോ എന്ന് നിർണ്ണയിക്കുന്ന പ്രക്രിയയാണ് ഓതറൈസേഷൻ. ഉപയോക്തൃ റോളുകൾ അല്ലെങ്കിൽ അനുമതികൾ അടിസ്ഥാനമാക്കി ആക്സസ് നിയന്ത്രിക്കുന്നതിന് നിങ്ങളുടെ റിക്വസ്റ്റ് ഹാൻഡ്‌ലറുകളിൽ ഓതറൈസേഷൻ ലോജിക് നടപ്പിലാക്കാൻ കഴിയും.

സുരക്ഷാ മികച്ച രീതികൾ:

ക്രോസ്-സൈറ്റ് സ്ക്രിപ്റ്റിംഗ് (XSS) സംരക്ഷണം: XSS ആക്രമണങ്ങൾ തടയാൻ ടൊർണാഡോ യാന്ത്രികമായി HTML എൻ്റിറ്റികളെ എസ്കേപ്പ് ചെയ്യുന്നു. ടെംപ്ലേറ്റുകൾ റെൻഡർ ചെയ്യുന്നതിന് എപ്പോഴും render() മെത്തേഡ് ഉപയോഗിക്കുക, നിങ്ങളുടെ റിക്വസ്റ്റ് ഹാൻഡ്‌ലറുകളിൽ നേരിട്ട് HTML ഉണ്ടാക്കുന്നത് ഒഴിവാക്കുക.
ക്രോസ്-സൈറ്റ് റിക്വസ്റ്റ് ഫോർജറി (CSRF) സംരക്ഷണം: CSRF ആക്രമണങ്ങൾ തടയാൻ നിങ്ങളുടെ ആപ്ലിക്കേഷൻ ക്രമീകരണങ്ങളിൽ CSRF സംരക്ഷണം പ്രവർത്തനക്ഷമമാക്കുക.
HTTPS: സെർവറും ക്ലയിൻ്റുകളും തമ്മിലുള്ള ആശയവിനിമയം എൻക്രിപ്റ്റ് ചെയ്യാൻ എപ്പോഴും HTTPS ഉപയോഗിക്കുക.
ഇൻപുട്ട് മൂല്യനിർണ്ണയം: ഇൻജെക്ഷൻ ആക്രമണങ്ങളും മറ്റ് കേടുപാടുകളും തടയാൻ എല്ലാ ഉപയോക്തൃ ഇൻപുട്ടുകളും സാധൂകരിക്കുക.
സ്ഥിരമായ സുരക്ഷാ ഓഡിറ്റുകൾ: സാധ്യതയുള്ള കേടുപാടുകൾ തിരിച്ചറിയുന്നതിനും പരിഹരിക്കുന്നതിനും പതിവായി സുരക്ഷാ ഓഡിറ്റുകൾ നടത്തുക.

ഡിപ്ലോയ്മെൻ്റ്

ഒരു ടൊർണാഡോ ആപ്ലിക്കേഷൻ ഡിപ്ലോയ് ചെയ്യുന്നതിൽ ഒരു വെബ് സെർവർ കോൺഫിഗർ ചെയ്യുക, ഒരു പ്രോസസ്സ് മാനേജർ സജ്ജീകരിക്കുക, പ്രകടനം ഒപ്റ്റിമൈസ് ചെയ്യുക എന്നിവയുൾപ്പെടെ നിരവധി ഘട്ടങ്ങൾ ഉൾപ്പെടുന്നു.

വെബ് സെർവർ:

Nginx അല്ലെങ്കിൽ Apache പോലുള്ള ഒരു വെബ് സെർവറിന് പിന്നിൽ നിങ്ങൾക്ക് ടൊർണാഡോ ഡിപ്ലോയ് ചെയ്യാം. വെബ് സെർവർ ഒരു റിവേഴ്സ് പ്രോക്സിയായി പ്രവർത്തിക്കുന്നു, വരുന്ന അഭ്യർത്ഥനകൾ ടൊർണാഡോ ആപ്ലിക്കേഷനിലേക്ക് ഫോർവേഡ് ചെയ്യുന്നു.

പ്രോസസ്സ് മാനേജർ:

സൂപ്പർവൈസർ അല്ലെങ്കിൽ systemd പോലുള്ള ഒരു പ്രോസസ്സ് മാനേജർ ടൊർണാഡോ പ്രോസസ്സ് നിയന്ത്രിക്കാൻ ഉപയോഗിക്കാം, അത് തകരാറിലായാൽ യാന്ത്രികമായി പുനരാരംഭിക്കുമെന്ന് ഉറപ്പാക്കുന്നു.

പ്രകടന ഒപ്റ്റിമൈസേഷൻ:

പ്രൊഡക്ഷന്-തയ്യാറായ ഇവൻ്റ് ലൂപ്പ് ഉപയോഗിക്കുക: മെച്ചപ്പെട്ട പ്രകടനത്തിനായി uvloop പോലുള്ള പ്രൊഡക്ഷന്-തയ്യാറായ ഇവൻ്റ് ലൂപ്പ് ഉപയോഗിക്കുക.
gzip കംപ്രഷൻ പ്രവർത്തനക്ഷമമാക്കുക: HTTP പ്രതികരണങ്ങളുടെ വലുപ്പം കുറയ്ക്കുന്നതിന് gzip കംപ്രഷൻ പ്രവർത്തനക്ഷമമാക്കുക.
സ്റ്റാറ്റിക് ഫയലുകൾ കാഷെ ചെയ്യുക: സെർവറിലെ ലോഡ് കുറയ്ക്കാൻ സ്റ്റാറ്റിക് ഫയലുകൾ കാഷെ ചെയ്യുക.
പ്രകടനം നിരീക്ഷിക്കുക: ന്യൂ റെലിക് അല്ലെങ്കിൽ പ്രോമിത്യൂസ് പോലുള്ള ടൂളുകൾ ഉപയോഗിച്ച് നിങ്ങളുടെ ആപ്ലിക്കേഷൻ്റെ പ്രകടനം നിരീക്ഷിക്കുക.

അന്താരാഷ്ട്രവൽക്കരണവും (i18n) പ്രാദേശികവൽക്കരണവും (l10n)

ഒരു ആഗോള പ്രേക്ഷകർക്കായി ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുമ്പോൾ, അന്താരാഷ്ട്രവൽക്കരണവും (i18n) പ്രാദേശികവൽക്കരണവും (l10n) പരിഗണിക്കേണ്ടത് പ്രധാനമാണ്. എഞ്ചിനീയറിംഗ് മാറ്റങ്ങളില്ലാതെ വിവിധ ഭാഷകളിലേക്കും പ്രദേശങ്ങളിലേക്കും ഒരു ആപ്ലിക്കേഷൻ രൂപകൽപ്പന ചെയ്യുന്ന പ്രക്രിയയാണ് i18n. പ്രാദേശിക-നിർദ്ദിഷ്ട ഘടകങ്ങൾ ചേർത്തും വാചകം വിവർത്തനം ചെയ്തും ഒരു പ്രത്യേക ഭാഷയ്‌ക്കോ പ്രദേശത്തിനോ വേണ്ടി അന്താരാഷ്ട്രവൽക്കരിച്ച ആപ്ലിക്കേഷൻ പൊരുത്തപ്പെടുത്തുന്ന പ്രക്രിയയാണ് l10n.

ടൊർണാഡോയും i18n/l10n-ഉം

ടൊർണാഡോയ്ക്ക് അന്തർനിർമ്മിത i18n/l10n ലൈബ്രറികളില്ല. എന്നിരുന്നാലും, നിങ്ങളുടെ ടൊർണാഡോ ആപ്ലിക്കേഷനിൽ i18n/l10n കൈകാര്യം ചെയ്യുന്നതിന് `gettext` പോലുള്ള സ്റ്റാൻഡേർഡ് പൈത്തൺ ലൈബ്രറികളോ അല്ലെങ്കിൽ Babel പോലുള്ള കൂടുതൽ സങ്കീർണ്ണമായ ഫ്രെയിംവർക്കുകളോ എളുപ്പത്തിൽ സംയോജിപ്പിക്കാൻ കഴിയും.

`gettext` ഉപയോഗിച്ചുള്ള ഉദാഹരണം:

1. **നിങ്ങളുടെ ലോക്കേലുകൾ സജ്ജീകരിക്കുക:** നിങ്ങൾ പിന്തുണയ്ക്കാൻ ആഗ്രഹിക്കുന്ന ഓരോ ഭാഷയ്ക്കും ഡയറക്ടറികൾ ഉണ്ടാക്കുക, അതിൽ സന്ദേശ കാറ്റലോഗുകൾ (.mo ഫയലുകൾ) അടങ്ങിയിരിക്കും.

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

2. **വിവർത്തനം ചെയ്യാവുന്ന സ്ട്രിംഗുകൾ വേർതിരിച്ചെടുക്കുക:** നിങ്ങളുടെ പൈത്തൺ കോഡിൽ നിന്ന് വിവർത്തനം ചെയ്യാവുന്ന സ്ട്രിംഗുകൾ ഒരു .po ഫയലിലേക്ക് (പോർട്ടബിൾ ഒബ്ജക്റ്റ്) വേർതിരിച്ചെടുക്കാൻ `xgettext` പോലുള്ള ഒരു ഉപകരണം ഉപയോഗിക്കുക. ഈ ഫയലിൽ യഥാർത്ഥ സ്ട്രിംഗുകളും വിവർത്തനങ്ങൾക്കുള്ള പ്ലേസ്ഹോൾഡറുകളും അടങ്ങിയിരിക്കും.

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

3. **സ്ട്രിംഗുകൾ വിവർത്തനം ചെയ്യുക:** ഓരോ ഭാഷയ്ക്കും വേണ്ടിയുള്ള .po ഫയലുകളിലെ സ്ട്രിംഗുകൾ വിവർത്തനം ചെയ്യുക.

4. **വിവർത്തനങ്ങൾ കംപൈൽ ചെയ്യുക:** .po ഫയലുകളെ .mo ഫയലുകളിലേക്ക് (മെഷീൻ ഒബ്ജക്റ്റ്) കംപൈൽ ചെയ്യുക, ഇത് റൺടൈമിൽ `gettext` ഉപയോഗിക്കുന്നു.

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

5. **നിങ്ങളുടെ ടൊർണാഡോ ആപ്ലിക്കേഷനിൽ സംയോജിപ്പിക്കുക:**

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:
  # സിസ്റ്റം പിന്തുണയ്ക്കാത്ത ലോക്കേൽ കേസുകൾ കൈകാര്യം ചെയ്യുക
  print(f"ലോക്കേൽ {self.get_user_locale().code} പിന്തുണയ്ക്കുന്നില്ല")

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

 def get_current_user_locale(self):
  # ഉപയോക്താവിൻ്റെ ലോക്കേൽ നിർണ്ണയിക്കുന്നതിനുള്ള ലോജിക് (ഉദാ. Accept-Language ഹെഡർ, ഉപയോക്തൃ ക്രമീകരണങ്ങൾ മുതലായവയിൽ നിന്ന്)
  # ഇതൊരു ലളിതമായ ഉദാഹരണമാണ് - നിങ്ങൾക്ക് കൂടുതൽ ശക്തമായ ഒരു പരിഹാരം ആവശ്യമാണ്
  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. **നിങ്ങളുടെ ടെംപ്ലേറ്റുകൾ പരിഷ്കരിക്കുക:** നിങ്ങളുടെ ടെംപ്ലേറ്റുകളിൽ വിവർത്തനത്തിനായി സ്ട്രിംഗുകൾ അടയാളപ്പെടുത്തുന്നതിന് `_()` ഫംഗ്ഷൻ (gettext.gettext-ലേക്ക് ബന്ധിപ്പിച്ചത്) ഉപയോഗിക്കുക.

<h1>{{ _("ഞങ്ങളുടെ വെബ്സൈറ്റിലേക്ക് സ്വാഗതം!") }}</h1>
<p>{{ _("ഇതൊരു വിവർത്തനം ചെയ്ത ഖണ്ഡികയാണ്.") }}</p>

ആഗോള പ്രേക്ഷകർക്കുള്ള പ്രധാന പരിഗണനകൾ:

**പ്രതീക എൻകോഡിംഗ്:** വിശാലമായ പ്രതീകങ്ങളെ പിന്തുണയ്ക്കുന്നതിന് എപ്പോഴും UTF-8 എൻകോഡിംഗ് ഉപയോഗിക്കുക.
**തീയതിയും സമയവും ഫോർമാറ്റിംഗ്:** ലോക്കേൽ-നിർദ്ദിഷ്ട തീയതിയും സമയവും ഫോർമാറ്റിംഗ് ഉപയോഗിക്കുക. പൈത്തണിന്റെ `strftime`, `strptime` ഫംഗ്ഷനുകൾ ലോക്കേൽ ക്രമീകരണങ്ങൾക്കൊപ്പം ഉപയോഗിക്കാം.
**നമ്പർ ഫോർമാറ്റിംഗ്:** ലോക്കേൽ-നിർദ്ദിഷ്ട നമ്പർ ഫോർമാറ്റിംഗ് ഉപയോഗിക്കുക (ഉദാ. ദശാംശ വിഭജനങ്ങൾ, ആയിരക്കണക്കിന് വിഭജനങ്ങൾ). `locale` മൊഡ്യൂൾ ഇതിനുള്ള ഫംഗ്ഷനുകൾ നൽകുന്നു.
**കറൻസി ഫോർമാറ്റിംഗ്:** ലോക്കേൽ-നിർദ്ദിഷ്ട കറൻസി ഫോർമാറ്റിംഗ് ഉപയോഗിക്കുക. കൂടുതൽ വിപുലമായ കറൻസി കൈകാര്യം ചെയ്യുന്നതിനായി `Babel` പോലുള്ള ഒരു ലൈബ്രറി ഉപയോഗിക്കുന്നത് പരിഗണിക്കുക.
**വലത്തുനിന്ന്-ഇടത്തോട്ട് (RTL) ഭാഷകൾ:** അറബിക്, ഹീബ്രു പോലുള്ള RTL ഭാഷകളെ പിന്തുണയ്ക്കുക. ഇതിന് നിങ്ങളുടെ വെബ്സൈറ്റിന്റെ ലേഔട്ട് മിറർ ചെയ്യേണ്ടി വന്നേക്കാം.
**വിവർത്തനത്തിന്റെ ഗുണമേന്മ:** കൃത്യവും സാംസ്കാരികമായി ഉചിതവുമായ വിവർത്തനങ്ങൾ ഉറപ്പാക്കാൻ പ്രൊഫഷണൽ വിവർത്തകരെ ഉപയോഗിക്കുക. മെഷീൻ വിവർത്തനം ഒരു നല്ല തുടക്കമാകാം, പക്ഷേ അതിന് പലപ്പോഴും മനുഷ്യന്റെ അവലോകനം ആവശ്യമാണ്.
**ഉപയോക്തൃ ലോക്കേൽ കണ്ടെത്തൽ:** ഉപയോക്തൃ മുൻഗണനകൾ, ബ്രൗസർ ക്രമീകരണങ്ങൾ, അല്ലെങ്കിൽ IP വിലാസം എന്നിവ അടിസ്ഥാനമാക്കി ശക്തമായ ലോക്കേൽ കണ്ടെത്തൽ നടപ്പിലാക്കുക. ഉപയോക്താക്കൾക്ക് അവരുടെ ഇഷ്ടപ്പെട്ട ഭാഷ സ്വമേധയാ തിരഞ്ഞെടുക്കാൻ ഒരു മാർഗം നൽകുക.
**പരിശോധന:** എല്ലാം ശരിയായി പ്രദർശിപ്പിച്ചിട്ടുണ്ടെന്ന് ഉറപ്പാക്കാൻ വിവിധ ലോക്കേലുകൾ ഉപയോഗിച്ച് നിങ്ങളുടെ ആപ്ലിക്കേഷൻ സമഗ്രമായി പരിശോധിക്കുക.

വിപുലമായ വിഷയങ്ങൾ

ഇഷ്‌ടാനുസൃത പിശക് പേജുകൾ:

ഒരു പിശക് സംഭവിക്കുമ്പോൾ ടൊർണാഡോ പ്രദർശിപ്പിക്കുന്ന പിശക് പേജുകൾ നിങ്ങൾക്ക് ഇഷ്‌ടാനുസൃതമാക്കാൻ കഴിയും. ഇത് കൂടുതൽ ഉപയോക്തൃ-സൗഹൃദ അനുഭവം നൽകാനും ഡീബഗ്ഗിംഗ് വിവരങ്ങൾ ഉൾപ്പെടുത്താനും നിങ്ങളെ അനുവദിക്കുന്നു.

ഇഷ്‌ടാനുസൃത ക്രമീകരണങ്ങൾ:

നിങ്ങളുടെ ആപ്ലിക്കേഷൻ കോൺഫിഗറേഷനിൽ നിങ്ങൾക്ക് ഇഷ്‌ടാനുസൃത ക്രമീകരണങ്ങൾ നിർവചിക്കാനും നിങ്ങളുടെ റിക്വസ്റ്റ് ഹാൻഡ്‌ലറുകളിൽ അവ ആക്‌സസ് ചെയ്യാനും കഴിയും. ഡാറ്റാബേസ് കണക്ഷൻ സ്ട്രിംഗുകൾ അല്ലെങ്കിൽ API കീകൾ പോലുള്ള ആപ്ലിക്കേഷൻ-നിർദ്ദിഷ്ട പാരാമീറ്ററുകൾ സംഭരിക്കുന്നതിന് ഇത് ഉപയോഗപ്രദമാണ്.

പരിശോധന:

നിങ്ങളുടെ ടൊർണാഡോ ആപ്ലിക്കേഷനുകൾ ശരിയായി പ്രവർത്തിക്കുന്നുണ്ടെന്നും സുരക്ഷിതമാണെന്നും ഉറപ്പാക്കാൻ സമഗ്രമായി പരിശോധിക്കുക. നിങ്ങളുടെ ആപ്ലിക്കേഷൻ്റെ എല്ലാ വശങ്ങളും ഉൾക്കൊള്ളുന്നതിന് യൂണിറ്റ് ടെസ്റ്റുകൾ, ഇൻ്റഗ്രേഷൻ ടെസ്റ്റുകൾ, എൻഡ്-ടു-എൻഡ് ടെസ്റ്റുകൾ എന്നിവ ഉപയോഗിക്കുക.

ഉപസംഹാരം

സ്കെയിലബിൾ, ഉയർന്ന പ്രകടനമുള്ള വെബ് ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്നതിന് അനുയോജ്യമായ ശക്തവും ബഹുമുഖവുമായ ഒരു വെബ് ഫ്രെയിംവർക്കാണ് ടൊർണാഡോ. അതിൻ്റെ അസിൻക്രണസ് ആർക്കിടെക്ചർ, വെബ്സോക്കറ്റ് പിന്തുണ, ഉപയോഗിക്കാൻ എളുപ്പമുള്ള API എന്നിവ ലോകമെമ്പാടുമുള്ള ഡെവലപ്പർമാർക്കിടയിൽ ഇതിനെ ഒരു ജനപ്രിയ തിരഞ്ഞെടുപ്പാക്കി മാറ്റുന്നു. ഈ സമഗ്രമായ ഗൈഡിലെ മാർഗ്ഗനിർദ്ദേശങ്ങളും ഉദാഹരണങ്ങളും പിന്തുടരുന്നതിലൂടെ, നിങ്ങൾക്ക് നിങ്ങളുടെ സ്വന്തം ടൊർണാഡോ ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കാൻ തുടങ്ങാനും അതിൻ്റെ നിരവധി സവിശേഷതകൾ പ്രയോജനപ്പെടുത്താനും കഴിയും.

ഏറ്റവും പുതിയ വിവരങ്ങൾക്കും മികച്ച രീതികൾക്കുമായി ഔദ്യോഗിക ടൊർണാഡോ ഡോക്യുമെൻ്റേഷൻ പരിശോധിക്കാൻ ഓർക്കുക. ഹാപ്പി കോഡിംഗ്!