Dokumentasi Tornado: Panduan Komprehensif untuk Pengembang di Seluruh Dunia

Tornado adalah kerangka kerja web Python dan pustaka jaringan asinkron, yang awalnya dikembangkan di FriendFeed. Ini sangat cocok untuk polling-panjang, WebSocket, dan aplikasi lain yang memerlukan koneksi berdurasi panjang ke setiap pengguna. I/O jaringannya yang non-blocking membuatnya sangat skalabel dan menjadi pilihan yang kuat untuk membangun aplikasi web berkinerja tinggi. Panduan komprehensif ini akan memandu Anda melalui konsep inti Tornado dan memberikan contoh praktis untuk memulai.

Apa itu Tornado?

Pada intinya, Tornado adalah kerangka kerja web dan pustaka jaringan asinkron. Berbeda dengan kerangka kerja web sinkron tradisional, Tornado menggunakan arsitektur berbasis event-loop tunggal. Ini berarti Tornado dapat menangani banyak koneksi bersamaan tanpa memerlukan satu thread per koneksi, membuatnya lebih efisien dan skalabel.

Fitur Utama Tornado:

• Jaringan Asinkron: Inti Tornado dibangun di sekitar I/O asinkron, memungkinkannya menangani ribuan koneksi bersamaan secara efisien.
• Kerangka Kerja Web: Ini mencakup fitur-fitur seperti request handler, routing, templating, dan autentikasi, menjadikannya kerangka kerja web yang lengkap.
• Dukungan WebSocket: Tornado memberikan dukungan yang sangat baik untuk WebSocket, memungkinkan komunikasi real-time antara server dan klien.
• Ringan dan Cepat: Didesain untuk kinerja, Tornado ringan dan efisien, meminimalkan overhead dan memaksimalkan throughput.
• Mudah Digunakan: Meskipun memiliki fitur-fitur canggih, Tornado relatif mudah dipelajari dan digunakan, dengan API yang jelas dan terdokumentasi dengan baik.

Menyiapkan Lingkungan Tornado Anda

Sebelum terjun ke pengembangan Tornado, Anda perlu menyiapkan lingkungan Anda. Berikut adalah panduan langkah demi langkah:

1. Instal Python: Pastikan Anda telah menginstal Python 3.6 atau lebih tinggi. Anda dapat mengunduhnya dari situs web resmi Python (python.org).
2. Buat Lingkungan Virtual (Disarankan): Gunakan venv atau virtualenv untuk membuat lingkungan terisolasi untuk proyek Anda:

               python3 -m venv myenv
   source myenv/bin/activate  # Di Linux/macOS
   myenv\Scripts\activate  # Di Windows
               
   
                 
                   Copy
                 
               
             

3. Instal Tornado: Instal Tornado menggunakan pip:

               pip install tornado
               
   
                 
                   Copy
                 
               
             

Aplikasi Tornado Pertama Anda

Mari kita buat aplikasi "Hello, World!" sederhana dengan Tornado. Buat file bernama app.py dan tambahkan kode berikut:

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

              
                Copy
              
            
          

Sekarang, jalankan aplikasi dari terminal Anda:

            python app.py
            

              
                Copy
              
            
          

Buka browser web Anda dan navigasikan ke http://localhost:8888. Anda akan melihat pesan "Hello, World!".

Penjelasan:

• tornado.ioloop: Event loop inti yang menangani operasi asinkron.
• tornado.web: Menyediakan komponen kerangka kerja web, seperti request handler dan routing.
• MainHandler: Sebuah request handler yang mendefinisikan cara menangani permintaan HTTP yang masuk. Metode get() dipanggil untuk permintaan GET.
• tornado.web.Application: Membuat aplikasi Tornado, memetakan pola URL ke request handler.
• app.listen(8888): Memulai server, mendengarkan koneksi masuk pada port 8888.
• tornado.ioloop.IOLoop.current().start(): Memulai event loop, yang memproses permintaan masuk dan menangani operasi asinkron.

Request Handler dan Routing

Request handler adalah fondasi dari aplikasi web Tornado. Mereka mendefinisikan cara menangani permintaan HTTP yang masuk berdasarkan URL. Routing memetakan URL ke request handler tertentu.

Mendefinisikan Request Handler:

Untuk membuat request handler, buat subkelas dari tornado.web.RequestHandler dan implementasikan metode HTTP yang sesuai (get, post, put, delete, dll.).

            class MyHandler(tornado.web.RequestHandler):
 def get(self):
  self.write("Ini adalah permintaan GET.")

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

              
                Copy
              
            
          

Routing:

Routing dikonfigurasi saat membuat tornado.web.Application. Anda menyediakan daftar tuple, di mana setiap tuple berisi pola URL dan request handler yang sesuai.

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

              
                Copy
              
            
          

Pola URL:

Pola URL adalah ekspresi reguler. Anda dapat menggunakan grup ekspresi reguler untuk menangkap bagian dari URL dan meneruskannya sebagai argumen ke metode request handler.

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

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

              
                Copy
              
            
          

Dalam contoh ini, /user/([0-9]+) cocok dengan URL seperti /user/123. Bagian ([0-9]+) menangkap satu atau lebih digit dan meneruskannya sebagai argumen user_id ke metode get dari UserHandler.

Templating

Tornado menyertakan mesin templating yang sederhana dan efisien. Template digunakan untuk menghasilkan HTML secara dinamis, memisahkan logika presentasi dari logika aplikasi.

Membuat Template:

Template biasanya disimpan dalam file terpisah (misalnya, index.html). Berikut adalah contoh sederhana:

            <!DOCTYPE html>
<html>
<head>
 <title>Situs Web Saya</title>
</head>
<body>
 <h1>Selamat datang, {{ name }}!</h1>
 <p>Hari ini adalah {{ today }}.</p>
</body>
</html>
            

              
                Copy
              
            
          

{{ name }} dan {{ today }} adalah placeholder yang akan diganti dengan nilai aktual saat template dirender.

Merender Template:

Untuk merender template, gunakan metode render() di request handler Anda:

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

              
                Copy
              
            
          

Pastikan pengaturan template_path dikonfigurasi dengan benar dalam pengaturan aplikasi Anda. Secara default, Tornado mencari template di direktori bernama templates di direktori yang sama dengan file aplikasi Anda.

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

              
                Copy
              
            
          

Sintaks Template:

Template Tornado mendukung berbagai fitur, termasuk:

• Variabel: {{ variable }}
• Alur Kontrol: {% if condition %} ... {% else %} ... {% end %}, {% for item in items %} ... {% end %}
• Fungsi: {{ function(argument) }}
• Includes: {% include "another_template.html" %}
• Escaping: Tornado secara otomatis melakukan escape entitas HTML untuk mencegah serangan cross-site scripting (XSS). Anda dapat menonaktifkan escaping menggunakan {% raw variable %}.

Operasi Asinkron

Kekuatan Tornado terletak pada kemampuan asinkronnya. Operasi asinkron memungkinkan aplikasi Anda untuk melakukan I/O non-blocking, meningkatkan kinerja dan skalabilitas. Ini sangat berguna untuk tugas-tugas yang melibatkan menunggu sumber daya eksternal, seperti kueri database atau permintaan jaringan.

@tornado.gen.coroutine:

Dekorator @tornado.gen.coroutine memungkinkan Anda menulis kode asinkron menggunakan kata kunci yield. Ini membuat kode asinkron terlihat dan berperilaku lebih seperti kode sinkron, meningkatkan keterbacaan dan pemeliharaan.

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

              
                Copy
              
            
          

Dalam contoh ini, http_client.fetch() adalah operasi asinkron yang mengembalikan Future. Kata kunci yield menangguhkan eksekusi coroutine hingga Future diselesaikan. Setelah Future diselesaikan, coroutine dilanjutkan dan badan respons ditulis ke klien.

tornado.concurrent.Future:

Sebuah Future merepresentasikan hasil dari operasi asinkron yang mungkin belum tersedia. Anda dapat menggunakan objek Future untuk merangkai operasi asinkron bersama-sama dan menangani kesalahan.

tornado.ioloop.IOLoop:

IOLoop adalah jantung dari mesin asinkron Tornado. Ia memonitor deskriptor file dan soket untuk event dan mengirimkannya ke handler yang sesuai. Anda biasanya tidak perlu berinteraksi langsung dengan IOLoop, tetapi penting untuk memahami perannya dalam menangani operasi asinkron.

WebSocket

Tornado memberikan dukungan yang sangat baik untuk WebSocket, memungkinkan komunikasi real-time antara server dan klien. WebSocket ideal untuk aplikasi yang memerlukan komunikasi dua arah dengan latensi rendah, seperti aplikasi obrolan, game online, dan dasbor real-time.

Membuat Handler WebSocket:

Untuk membuat handler WebSocket, buat subkelas dari tornado.websocket.WebSocketHandler dan implementasikan metode berikut:

• open(): Dipanggil saat koneksi WebSocket baru dibuat.
• on_message(message): Dipanggil saat pesan diterima dari klien.
• on_close(): Dipanggil saat koneksi WebSocket ditutup.

            import tornado.websocket

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

 def on_message(self, message):
  self.write_message(f"Anda mengirim: {message}")

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

 def check_origin(self, origin):
  return True # Mengizinkan koneksi WebSocket lintas-asal
            

              
                Copy
              
            
          

Mengintegrasikan WebSocket ke dalam Aplikasi Anda:

Tambahkan handler WebSocket ke konfigurasi routing aplikasi Anda:

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

              
                Copy
              
            
          

Implementasi Sisi Klien:

Di sisi klien, Anda dapat menggunakan JavaScript untuk membuat koneksi WebSocket dan mengirim/menerima pesan:

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

websocket.onopen = () => {
 console.log("Koneksi WebSocket dibuat");
 websocket.send("Halo dari klien!");
};

websocket.onmessage = (event) => {
 console.log("Pesan diterima:", event.data);
};

websocket.onclose = () => {
 console.log("Koneksi WebSocket ditutup");
};
            

              
                Copy
              
            
          

Autentikasi dan Keamanan

Keamanan adalah aspek penting dari pengembangan aplikasi web. Tornado menyediakan beberapa fitur untuk membantu Anda mengamankan aplikasi Anda, termasuk autentikasi, otorisasi, dan perlindungan terhadap kerentanan web umum.

Autentikasi:

Autentikasi adalah proses verifikasi identitas pengguna. Tornado menyediakan dukungan bawaan untuk berbagai skema autentikasi, termasuk:

• Autentikasi berbasis cookie: Simpan kredensial pengguna dalam cookie.
• Autentikasi pihak ketiga (OAuth): Integrasikan dengan platform media sosial populer seperti Google, Facebook, dan Twitter.
• Kunci API: Gunakan kunci API untuk mengautentikasi permintaan API.

Otorisasi:

Otorisasi adalah proses menentukan apakah pengguna memiliki izin untuk mengakses sumber daya tertentu. Anda dapat mengimplementasikan logika otorisasi di request handler Anda untuk membatasi akses berdasarkan peran atau izin pengguna.

Praktik Terbaik Keamanan:

• Perlindungan Cross-Site Scripting (XSS): Tornado secara otomatis melakukan escape entitas HTML untuk mencegah serangan XSS. Selalu gunakan metode render() untuk merender template dan hindari menghasilkan HTML secara langsung di request handler Anda.
• Perlindungan Cross-Site Request Forgery (CSRF): Aktifkan perlindungan CSRF di pengaturan aplikasi Anda untuk mencegah serangan CSRF.
• HTTPS: Selalu gunakan HTTPS untuk mengenkripsi komunikasi antara server dan klien.
• Validasi Input: Validasi semua input pengguna untuk mencegah serangan injeksi dan kerentanan lainnya.
• Audit Keamanan Reguler: Lakukan audit keamanan secara teratur untuk mengidentifikasi dan mengatasi potensi kerentanan.

Deployment

Mendeploy aplikasi Tornado melibatkan beberapa langkah, termasuk mengkonfigurasi server web, menyiapkan manajer proses, dan mengoptimalkan kinerja.

Server Web:

Anda dapat mendeploy Tornado di belakang server web seperti Nginx atau Apache. Server web bertindak sebagai reverse proxy, meneruskan permintaan masuk ke aplikasi Tornado.

Manajer Proses:

Manajer proses seperti Supervisor atau systemd dapat digunakan untuk mengelola proses Tornado, memastikan bahwa proses tersebut secara otomatis dimulai ulang jika mogok.

Optimisasi Kinerja:

• Gunakan Event Loop yang Siap Produksi: Gunakan event loop yang siap produksi seperti uvloop untuk kinerja yang lebih baik.
• Aktifkan Kompresi gzip: Aktifkan kompresi gzip untuk mengurangi ukuran respons HTTP.
• Cache File Statis: Cache file statis untuk mengurangi beban pada server.
• Pantau Kinerja: Pantau kinerja aplikasi Anda menggunakan alat seperti New Relic atau Prometheus.

Internasionalisasi (i18n) dan Lokalisasi (l10n)

Saat membangun aplikasi untuk audiens global, penting untuk mempertimbangkan internasionalisasi (i18n) dan lokalisasi (l10n). i18n adalah proses merancang aplikasi agar dapat diadaptasi ke berbagai bahasa dan wilayah tanpa perubahan rekayasa. l10n adalah proses mengadaptasi aplikasi yang telah diinternasionalisasi untuk bahasa atau wilayah tertentu dengan menambahkan komponen spesifik lokal dan menerjemahkan teks.

Tornado dan i18n/l10n

Tornado sendiri tidak memiliki pustaka i18n/l10n bawaan. Namun, Anda dapat dengan mudah mengintegrasikan pustaka Python standar seperti `gettext` atau kerangka kerja yang lebih canggih seperti Babel untuk menangani i18n/l10n dalam aplikasi Tornado Anda.

Contoh menggunakan `gettext`:

1. **Siapkan lokal Anda:** Buat direktori untuk setiap bahasa yang ingin Anda dukung, berisi katalog pesan (biasanya file `.mo`).

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

              
                Copy
              
            
          

2. **Ekstrak string yang dapat diterjemahkan:** Gunakan alat seperti `xgettext` untuk mengekstrak string yang dapat diterjemahkan dari kode Python Anda ke dalam file `.po` (Portable Object). File ini akan berisi string asli dan placeholder untuk terjemahan.

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

              
                Copy
              
            
          

3. **Terjemahkan string:** Terjemahkan string dalam file `.po` untuk setiap bahasa.

4. **Kompilasi terjemahan:** Kompilasi file `.po` menjadi file `.mo` (Machine Object) yang digunakan oleh `gettext` saat runtime.

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

              
                Copy
              
            
          

5. **Integrasikan ke dalam aplikasi Tornado Anda:**

            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:
  # Tangani kasus di mana lokal tidak didukung oleh sistem
  print(f"Lokal {self.get_user_locale().code} tidak didukung")

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

 def get_current_user_locale(self):
  # Logika untuk menentukan lokal pengguna (misalnya, dari header Accept-Language, pengaturan pengguna, dll.)
  # Ini adalah contoh yang disederhanakan - Anda akan memerlukan solusi yang lebih kuat
  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)

            

              
                Copy
              
            
          

6. **Ubah template Anda:** Gunakan fungsi `_()` (terikat pada `gettext.gettext`) untuk menandai string untuk terjemahan di template Anda.

            <h1>{{ _("Selamat datang di situs web kami!") }}</h1>
<p>{{ _("Ini adalah paragraf yang diterjemahkan.") }}</p>

            

              
                Copy
              
            
          

Pertimbangan Penting untuk Audiens Global:

• **Pengkodean Karakter:** Selalu gunakan pengkodean UTF-8 untuk mendukung berbagai macam karakter.
• **Format Tanggal dan Waktu:** Gunakan format tanggal dan waktu yang spesifik untuk lokal. Fungsi `strftime` dan `strptime` Python dapat digunakan dengan pengaturan lokal.
• **Format Angka:** Gunakan format angka yang spesifik untuk lokal (misalnya, pemisah desimal, pemisah ribuan). Modul `locale` menyediakan fungsi untuk ini.
• **Format Mata Uang:** Gunakan format mata uang yang spesifik untuk lokal. Pertimbangkan untuk menggunakan pustaka seperti `Babel` untuk penanganan mata uang yang lebih canggih.
• **Bahasa Kanan-ke-Kiri (RTL):** Dukung bahasa RTL seperti Arab dan Ibrani. Ini mungkin melibatkan pencerminan tata letak situs web Anda.
• **Kualitas Terjemahan:** Gunakan penerjemah profesional untuk memastikan terjemahan yang akurat dan sesuai dengan budaya. Terjemahan mesin bisa menjadi titik awal yang baik, tetapi seringkali memerlukan tinjauan manusia.
• **Deteksi Lokal Pengguna:** Terapkan deteksi lokal yang kuat berdasarkan preferensi pengguna, pengaturan browser, atau alamat IP. Sediakan cara bagi pengguna untuk memilih bahasa pilihan mereka secara manual.
• **Pengujian:** Uji aplikasi Anda secara menyeluruh dengan lokal yang berbeda untuk memastikan semuanya ditampilkan dengan benar.

Topik Lanjutan

Halaman Kesalahan Kustom:

Anda dapat menyesuaikan halaman kesalahan yang ditampilkan Tornado saat terjadi kesalahan. Ini memungkinkan Anda memberikan pengalaman yang lebih ramah pengguna dan menyertakan informasi debug.

Pengaturan Kustom:

Anda dapat mendefinisikan pengaturan kustom dalam konfigurasi aplikasi Anda dan mengaksesnya di request handler Anda. Ini berguna untuk menyimpan parameter spesifik aplikasi, seperti string koneksi database atau kunci API.

Pengujian:

Uji aplikasi Tornado Anda secara menyeluruh untuk memastikan aplikasi berfungsi dengan benar dan aman. Gunakan pengujian unit, pengujian integrasi, dan pengujian end-to-end untuk mencakup semua aspek aplikasi Anda.

Kesimpulan

Tornado adalah kerangka kerja web yang kuat dan serbaguna yang sangat cocok untuk membangun aplikasi web yang skalabel dan berkinerja tinggi. Arsitektur asinkronnya, dukungan WebSocket, dan API yang mudah digunakan menjadikannya pilihan populer bagi pengembang di seluruh dunia. Dengan mengikuti panduan dan contoh dalam panduan komprehensif ini, Anda dapat mulai membangun aplikasi Tornado Anda sendiri dan memanfaatkan banyak fiturnya.

Ingatlah untuk merujuk ke dokumentasi resmi Tornado untuk informasi terbaru dan praktik terbaik. Selamat membuat kode!