M

MLOG

Español

Una exploración profunda de Tornado, un framework web de Python y librería de redes asíncronas. Aprenda a construir aplicaciones escalables y de alto rendimiento con explicaciones detalladas, ejemplos y mejores prácticas.

Documentación de Tornado: Una Guía Completa para Desarrolladores de Todo el Mundo

Tornado es un framework web de Python y una librería de redes asíncronas, desarrollado originalmente en FriendFeed. Es particularmente adecuado para sondeos largos (long-polling), WebSockets y otras aplicaciones que requieren una conexión de larga duración para cada usuario. Su E/S (Entrada/Salida) de red sin bloqueo lo hace extremadamente escalable y una opción potente para construir aplicaciones web de alto rendimiento. Esta guía completa le guiará a través de los conceptos centrales de Tornado y le proporcionará ejemplos prácticos para empezar.

¿Qué es Tornado?

En esencia, Tornado es un framework web y una librería de redes asíncronas. A diferencia de los frameworks web síncronos tradicionales, Tornado utiliza una arquitectura de un solo hilo basada en un bucle de eventos. Esto significa que puede manejar muchas conexiones concurrentes sin requerir un hilo por conexión, lo que lo hace más eficiente y escalable.

Características Clave de Tornado:

Configurando su Entorno de Tornado

Antes de sumergirse en el desarrollo con Tornado, necesitará configurar su entorno. Aquí tiene una guía paso a paso:

  1. Instalar Python: Asegúrese de tener instalado Python 3.6 o superior. Puede descargarlo desde el sitio web oficial de Python (python.org).
  2. Crear un Entorno Virtual (Recomendado): Use venv o virtualenv para crear un entorno aislado para su proyecto: 
    python3 -m venv myenv
source myenv/bin/activate  # En Linux/macOS
myenv\Scripts\activate  # En Windows
  3. Instalar Tornado: Instale Tornado usando pip: 
    pip install tornado

Su Primera Aplicación con Tornado

Vamos a crear una aplicación simple "¡Hola, Mundo!" con Tornado. Cree un archivo llamado app.py y añada el siguiente código:

import tornado.ioloop
import tornado.web

class MainHandler(tornado.web.RequestHandler):
 def get(self):
  self.write("¡Hola, Mundo!")

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

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

Ahora, ejecute la aplicación desde su terminal:

python app.py

Abra su navegador web y navegue a http://localhost:8888. Debería ver el mensaje "¡Hola, Mundo!".

Explicación:

Manejadores de Solicitudes y Enrutamiento

Los manejadores de solicitudes son la base de las aplicaciones web de Tornado. Definen cómo manejar las peticiones HTTP entrantes según la URL. El enrutamiento asigna las URL a manejadores de solicitudes específicos.

Definiendo Manejadores de Solicitudes:

Para crear un manejador de solicitudes, herede de tornado.web.RequestHandler e implemente los métodos HTTP apropiados (get, post, put, delete, etc.).

class MyHandler(tornado.web.RequestHandler):
 def get(self):
  self.write("Esta es una petición GET.")

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

Enrutamiento:

El enrutamiento se configura al crear la tornado.web.Application. Se proporciona una lista de tuplas, donde cada tupla contiene un patrón de URL y el manejador de solicitudes correspondiente.

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

Patrones de URL:

Los patrones de URL son expresiones regulares. Puede usar grupos de expresiones regulares para capturar partes de la URL y pasarlas como argumentos a los métodos del manejador de solicitudes.

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

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

En este ejemplo, /user/([0-9]+) coincide con URLs como /user/123. La parte ([0-9]+) captura uno o más dígitos y los pasa como el argumento user_id al método get del UserHandler.

Plantillas

Tornado incluye un motor de plantillas simple y eficiente. Las plantillas se utilizan para generar HTML dinámicamente, separando la lógica de presentación de la lógica de la aplicación.

Creando Plantillas:

Las plantillas se almacenan típicamente en archivos separados (p. ej., index.html). Aquí hay un ejemplo simple:

<!DOCTYPE html>
<html>
<head>
 <title>Mi Sitio Web</title>
</head>
<body>
 <h1>¡Bienvenido, {{ name }}!</h1>
 <p>Hoy es {{ today }}.</p>
</body>
</html>

{{ name }} y {{ today }} son marcadores de posición que serán reemplazados con valores reales cuando se renderice la plantilla.

Renderizando Plantillas:

Para renderizar una plantilla, use el método render() en su manejador de solicitudes:

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

Asegúrese de que la configuración template_path esté correctamente configurada en los ajustes de su aplicación. Por defecto, Tornado busca plantillas en un directorio llamado templates en el mismo directorio que su archivo de aplicación.

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

Sintaxis de Plantillas:

Las plantillas de Tornado admiten varias características, incluyendo:

Operaciones Asíncronas

La fortaleza de Tornado reside en sus capacidades asíncronas. Las operaciones asíncronas permiten que su aplicación realice E/S sin bloqueo, mejorando el rendimiento y la escalabilidad. Esto es particularmente útil para tareas que implican esperar recursos externos, como consultas a bases de datos o peticiones de red.

@tornado.gen.coroutine:

El decorador @tornado.gen.coroutine le permite escribir código asíncrono usando la palabra clave yield. Esto hace que el código asíncrono se vea y se comporte más como código síncrono, mejorando la legibilidad y la mantenibilidad.

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

En este ejemplo, http_client.fetch() es una operación asíncrona que devuelve un Future. La palabra clave yield suspende la ejecución de la corrutina hasta que el Future se resuelve. Una vez que el Future se resuelve, la corrutina se reanuda y el cuerpo de la respuesta se escribe en el cliente.

tornado.concurrent.Future:

Un Future representa el resultado de una operación asíncrona que puede no estar disponible todavía. Puede usar objetos Future para encadenar operaciones asíncronas y manejar errores.

tornado.ioloop.IOLoop:

El IOLoop es el corazón del motor asíncrono de Tornado. Monitorea descriptores de archivos y sockets en busca de eventos y los despacha a los manejadores apropiados. Generalmente, no necesita interactuar directamente con el IOLoop, pero es importante entender su rol en el manejo de operaciones asíncronas.

WebSockets

Tornado proporciona un excelente soporte para WebSockets, permitiendo la comunicación en tiempo real entre el servidor y los clientes. Los WebSockets son ideales para aplicaciones que requieren comunicación bidireccional de baja latencia, como aplicaciones de chat, juegos en línea y paneles de control en tiempo real.

Creando un Manejador de WebSocket:

Para crear un manejador de WebSocket, herede de tornado.websocket.WebSocketHandler e implemente los siguientes métodos:

import tornado.websocket

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

 def on_message(self, message):
  self.write_message(f"Usted envió: {message}")

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

 def check_origin(self, origin):
  return True # Habilitar conexiones WebSocket de origen cruzado

Integrando WebSockets en su Aplicación:

Añada el manejador de WebSocket a la configuración de enrutamiento de su aplicación:

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

Implementación del Lado del Cliente:

En el lado del cliente, puede usar JavaScript para establecer una conexión WebSocket y enviar/recibir mensajes:

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

websocket.onopen = () => {
 console.log("Conexión WebSocket establecida");
 websocket.send("¡Hola desde el cliente!");
};

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

websocket.onclose = () => {
 console.log("Conexión WebSocket cerrada");
};

Autenticación y Seguridad

La seguridad es un aspecto crítico del desarrollo de aplicaciones web. Tornado proporciona varias características para ayudarle a proteger sus aplicaciones, incluyendo autenticación, autorización y protección contra vulnerabilidades web comunes.

Autenticación:

La autenticación es el proceso de verificar la identidad de un usuario. Tornado proporciona soporte integrado para varios esquemas de autenticación, incluyendo:

Autorización:

La autorización es el proceso de determinar si un usuario tiene permiso para acceder a un recurso en particular. Puede implementar lógica de autorización en sus manejadores de solicitudes para restringir el acceso basado en roles o permisos de usuario.

Mejores Prácticas de Seguridad:

Despliegue

Desplegar una aplicación Tornado implica varios pasos, incluyendo la configuración de un servidor web, la configuración de un gestor de procesos y la optimización del rendimiento.

Servidor Web:

Puede desplegar Tornado detrás de un servidor web como Nginx o Apache. El servidor web actúa como un proxy inverso, reenviando las solicitudes entrantes a la aplicación Tornado.

Gestor de Procesos:

Un gestor de procesos como Supervisor o systemd puede usarse para gestionar el proceso de Tornado, asegurando que se reinicie automáticamente si falla.

Optimización del Rendimiento:

Internacionalización (i18n) y Localización (l10n)

Al construir aplicaciones para una audiencia global, es importante considerar la internacionalización (i18n) y la localización (l10n). i18n es el proceso de diseñar una aplicación para que pueda ser adaptada a varios idiomas y regiones sin cambios de ingeniería. l10n es el proceso de adaptar una aplicación internacionalizada para un idioma o región específica añadiendo componentes específicos de la configuración regional y traduciendo texto.

Tornado e i18n/l10n

Tornado en sí no tiene librerías de i18n/l10n incorporadas. Sin embargo, puede integrar fácilmente librerías estándar de Python como `gettext` o frameworks más sofisticados como Babel para manejar i18n/l10n dentro de su aplicación Tornado.

Ejemplo usando `gettext`:

1. **Configure sus 'locales':** Cree directorios para cada idioma que desee soportar, que contengan catálogos de mensajes (usualmente archivos `.mo`).

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

2. **Extraiga cadenas traducibles:** Use una herramienta como `xgettext` para extraer cadenas traducibles de su código Python a un archivo `.po` (Portable Object). Este archivo contendrá las cadenas originales y los marcadores de posición para las traducciones.

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

3. **Traduzca las cadenas:** Traduzca las cadenas en los archivos `.po` para cada idioma.

4. **Compile las traducciones:** Compile los archivos `.po` a archivos `.mo` (Machine Object) que son utilizados por `gettext` en tiempo de ejecución.

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

5. **Intégrelo en su aplicación 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:
  # Manejar casos donde el 'locale' no es soportado por el sistema
  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):
  # Lógica para determinar el 'locale' del usuario (p. ej., desde la cabecera Accept-Language, configuración de usuario, etc.)
  # Este es un ejemplo simplificado - necesitará una solución más robusta
  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. **Modifique sus plantillas:** Use la función `_()` (vinculada a `gettext.gettext`) para marcar cadenas para traducción en sus plantillas.

<h1>{{ _("¡Bienvenido a nuestro sitio web!") }}</h1>
<p>{{ _("Este es un párrafo traducido.") }}</p>

Consideraciones Importantes para Audiencias Globales:

Temas Avanzados

Páginas de Error Personalizadas:

Puede personalizar las páginas de error que Tornado muestra cuando ocurre un error. Esto le permite proporcionar una experiencia más amigable para el usuario e incluir información de depuración.

Configuraciones Personalizadas:

Puede definir configuraciones personalizadas en la configuración de su aplicación y acceder a ellas en sus manejadores de solicitudes. Esto es útil para almacenar parámetros específicos de la aplicación, como cadenas de conexión a bases de datos o claves de API.

Pruebas (Testing):

Pruebe exhaustivamente sus aplicaciones Tornado para asegurarse de que funcionan correctamente y de forma segura. Use pruebas unitarias, pruebas de integración y pruebas de extremo a extremo para cubrir todos los aspectos de su aplicación.

Conclusión

Tornado es un framework web potente y versátil que es muy adecuado para construir aplicaciones web escalables y de alto rendimiento. Su arquitectura asíncrona, soporte para WebSockets y API fácil de usar lo convierten en una opción popular para desarrolladores de todo el mundo. Siguiendo las directrices y ejemplos de esta guía completa, puede empezar a construir sus propias aplicaciones Tornado y aprovechar sus muchas características.

Recuerde consultar la documentación oficial de Tornado para obtener la información más actualizada y las mejores prácticas. ¡Feliz codificación!

Documentación de Tornado: Una Guía Completa para Desarrolladores de Todo el Mundo | MLOG