Header Ads Widget

Ticker

6/recent/ticker-posts

API asincrónicas que utilizan Flask, Celery y Redis



A medida que avanza nuestra tecnología, la complejidad también aumenta día a día. Una de esas nuevas complejidades es la gestión de tareas asincrónicas con API. Suponga que su aplicación requiere muchos cálculos de fondo. En lugar de hacer que un usuario espere frente a una IU vacía, los puntos finales de API asíncronos pueden realizar trabajos en segundo plano e informar al usuario cuando la tarea está completa.

Los procesos asincrónicos no solo mejoran la experiencia del usuario, sino que le permiten administrar bastante bien la carga del servidor. Imagine un escenario diferente que involucra una aplicación web gigante construida en una API REST estándar sin multi-threading, sin async y sin colas de tareas . Ahora bien, ¿qué sucede cuando la aplicación de repente tiene 50.000 usuarios, todos queriendo que el sistema lleve a cabo procesos largos y complejos? Sin la plomería adecuada, la aplicación podría experimentar fácilmente un tiempo de inactividad.

Al administrar la comunicación de forma asincrónica, puede mejorar la experiencia del usuario, programar trabajos y manejar una gran cantidad de solicitudes simultáneas. Por supuesto, las API asincrónicas no siempre son adecuadas para situaciones en tiempo real o cuando las tareas deben ejecutarse secuencialmente.

También puede ser un desafío desarrollar una API asincrónica. Entonces, ¿qué necesitamos para crear uno? Requerirá algo que pueda realizar múltiples subprocesos, poner en cola tareas y realizar alguna otra funcionalidad. Este tutorial demuestra cómo crear una API asincrónica con Flask y algunas tecnologías adicionales, como Celery, Redis, RabbitMQ y Python.

  • Apio : Apio es un administrador de tareas asincrónico que le permite ejecutar y administrar trabajos en una cola. Se utiliza principalmente para trabajos en tiempo real, pero también le permite programar trabajos. Hay tres componentes principales en Celery: trabajador, intermediario y cola de tareas.
  • RabbitMQ : RabbitMQ es un intermediario de mensajes que se utiliza para comunicarse entre los trabajadores de tareas y Celery. Esto también se puede usar de forma independiente para chatbots .

Ahora configuremos nuestra API asincrónica usando Flask:

Paso –1: requisitos previos:

  • Conocimiento de Python
  • RabbitMQ
  • Servidor Redis

Paso –2: Configuración del entorno e instalación del software

Ahora abra la terminal, creemos una nueva carpeta flaskelry, y ábrala:

mkdir flaskelry
cd flaskelry

Una vez que esté en la carpeta, inicie un entorno virtual:

virtualenv .

Una vez hecho esto, duplique las pestañas de la terminal dos veces. Deberá abrir tres pestañas separadas porque tendremos que ejecutar tres servidores diferentes.

Ahora instalemos nuestro primer reproductor principal, RabbitMQ:

brew update
brew install rabbitmq

Nota: el comando anterior solo funcionará en Mac. Si tiene otro sistema operativo, puede obtener RabbitMQ desde aquí .

Una vez hecho esto, instalemos Flask and Celery también:

python3 -m pip install celery
python3 -m pip install flask

Hemos terminado con la configuración, así que comencemos a codificar ahora:

Paso –2: configuración de la API

Ahora cree un archivo api.pyy pegue el siguiente código en el archivo:

from flask import Flask, request, jsonify
import json
import os
import sys
from celery import Celery, Task, current_app
import fns as cad

api = Flask(__name__)
celerymq = Celery('tasks', backend= 'rpc://', broker='pyamqp://guest@localhost//')
class CeleryApiTask(Task):
    def on_failure(self, exc, task_id, args, kwargs, einfo):
        print('{0!r} failed: {1!r}'.format(task_id, exc))
    def on_success(self, retval, task_id, args, kwargs):
        print('{0!r} success!: {1!r}'.format(task_id, retval))

@celerymq.task(base=CeleryApiTask)
def async_cron_alert():
    output = cad.alert_daily()
    return output

@api.before_request
def before_request():
    if request.method=='OPTIONS':
        return jsonify({}), 200
  
@api.errorhandler(500)
def internal_error(error):
    return jsonify({"msg": "Internal Server Error", "status": 500}), 500

@api.errorhandler(400)
def bad_request(error):
    return jsonify({"msg": "Bad Request", "status": 400}), 400

@api.errorhandler(404)
def not_found(error):
    return jsonify({"msg": "Not Found", "status": 404}), 404
    
@api.route("/api/cron_alert_daily/", methods=['GET'])
def route_alert_daily():
    task = async_cron_alert.delay()
    return jsonify({'msg': 'process started', 'task_id': task.id, 'status': 202}), 202
    
if __name__ == "__main__":
    api.run(host='0.0.0.0',port=8124)

Explicación del código:

Hemos importado todos los paquetes necesarios como Flask, Celery, Task, os, json, sys en las primeras cinco líneas. Después de eso, hemos creado una aplicación Flask e iniciado la conexión RabbitMQ con el apio.

Luego, hemos creado una clase que se utiliza para crear puestos de trabajo. Después de eso, hemos definido una función asíncrona async_cron_alert(), que es asíncrona.

Para manejar los errores del servidor, también hemos definido algunas error handler()funciones.

Finalmente, tenemos un punto final de API /api/cron_alert_daily/, que llama a la función asíncrona que creamos anteriormente y responde con 202.

Ahora cree un archivo más fns.py, y pegue el siguiente código:

import time

def alert_daily():
    time.sleep(50)
    return "New Job"

Explicación del código:

Este es un módulo muy simple que duerme durante 50 segundos.

Paso –3: prueba de la API

¿Recuerdas que te dijimos que duplicaras las pestañas de tu terminal? Los usaremos aquí. Ahora vaya a las otras dos pestañas y ejecute los siguientes comandos en cada terminal respectivamente:

En una pestaña, ejecute este comando:

/usr/local/sbin/rabbitmq-server

En otra pestaña, ejecute este comando:

source bin/activate
celery -A api worker --loglevel=INFO

Ahora vaya a la primera pestaña de terminal y use el siguiente comando para ejecutar el servidor Flask:

export FLASK_APP=api.py
flask run

Ahora, una vez que todo esté funcionando bien, abramos nuestra herramienta de prueba de API favorita y presionemos esta URL:

http://127.0.0.1:5000/api/cron_alert_daily

Si todo está bien, debería obtener una respuesta como esta:

{
    "msg": "process started",
    "status": 202,
    "task_id": "4845e5f9-7521-43f0-b457-b8b90c73827f"
}

TADA !!!! Tu API está lista ahora.

Ultimas palabras:

Puede utilizar esta API para crear puntos finales de API asincrónicos. No sugeriría crear puntos finales asíncronos para usar en todas partes. Quiero decir, hay situaciones en las que necesitas una respuesta instantánea de la API. Por ejemplo, no desea agregar un retraso en un formulario de inicio de sesión, ¿verdad?

El uso de Apio también puede ayudarlo a programar trabajos que puede usar en situaciones como el envío de correos electrónicos masivos. Puede crear una cola de tareas de correos electrónicos y enviar el correo electrónico uno por uno. Hay mucho que cubrir en las API asincrónicas, y esto es solo un punto de partida. Puede crear aplicaciones complejas muy fácilmente utilizando esta API una vez que haya entendido cómo funciona la API.

Publicar un comentario

0 Comentarios