La creación de API de forma rápida y eficiente es un aspecto fundamental del desarrollo de software moderno. Sin embargo, debido a motivos como el procesamiento de datos, llamadas de servicios de terceros o cálculos complejos, a menudo se encuentran puntos finales de API que tardan mucho en ejecutarse. Ante situaciones como esta, es fundamental garantizar que estas tareas de larga duración no degraden la experiencia del usuario ni el rendimiento del sistema. Esta publicación de blog tiene como objetivo guiarlo sobre cómo administrar tareas de larga duración en FastAPI.
Desafíos de los puntos finales API de larga duración
- Experiencia del usuario: tiempos de respuesta prolongados pueden resultar en una mala experiencia del usuario.
- Utilización de recursos: las tareas de larga duración pueden consumir grandes cantidades de recursos del sistema, lo que puede afectar
- Desempeño en otras tareas.
- Manejo de errores: las tareas que tardan mucho en ejecutarse son más propensas a errores y requieren un mecanismo sólido de manejo de errores.
Mejores prácticas para gestionar tareas de larga duración
punto final asíncrono
Puede definir puntos finales asincrónicos en FastAPI utilizando la sintaxis async def de Python, que facilita las operaciones vinculadas de E/S.
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
async def read_root():
# 执行一个长时间运行的任务
return {"message": "done"}
Tarea en segundo plano
FastAPI le permite ejecutar tareas en segundo plano que pueden continuar procesándose después de que se haya enviado la respuesta.
from fastapi import BackgroundTasks, FastAPI
app = FastAPI()
def long_running_task():
# 执行一个长时间运行的任务
pass
@app.get("/")
async def read_root(background_tasks: BackgroundTasks):
background_tasks.add_task(long_running_task)
return {"message": "任务正在后台运行"}
Cola de tareas distribuida usando Celery
Para tareas particularmente largas, puede descargarlas a una cola de tareas como Celery.
from fastapi import FastAPI
from celery import Celery
app = FastAPI()
celery_app = Celery('tasks', broker='pyamqp://guest@localhost//')
@celery_app.task
def long_running_task():
# 执行一个长时间运行的任务
pass
@app.get("/")
def read_root():
long_running_task.apply_async()
return {"message": "任务正在后台运行"}
Notificar a los usuarios de las políticas
Una vez que una tarea se descarga o se vuelve asíncrona, es necesario notificar al usuario su estado de finalización. A continuación se presentan algunas estrategias para lograr este objetivo:
- Sondeo
En este enfoque, el cliente recibe inicialmente un ID de tarea y luego sondea repetidamente un punto final para verificar el estado de la tarea.
Servidor:
from fastapi import FastAPI
from some_task_queue import some_task_queue
app = FastAPI()
@app.post("/start_task/")
def start_task():
task_id = some_task_queue.enqueue("long_running_task")
return {"task_id": task_id}
@app.get("/get_result/{task_id}")
def get_result(task_id: str):
result = some_task_queue.get_result(task_id)
return {"result": result}
Cliente:
async function startAndPollTask() {
const response = await fetch('/start_task/');
const task = await response.json();
let result;
do {
const resultResponse = await fetch(`/get_result/${task.task_id}`);
result = await resultResponse.json();
if (result.is_done) {
break;
}
await new Promise(resolve => setTimeout(resolve, 2000));
} while(true);
console.log("Final result:", result);
}
- Webhooks
Aquí, el cliente proporciona una URL de devolución de llamada y el servidor puede PUBLICAR los resultados en esta URL una vez completada la tarea.
Servidor:
from fastapi import FastAPI, BackgroundTasks
import requests
app = FastAPI()
def long_running_task(callback_url):
# 执行长时间的任务
result = "some_result"
requests.post(callback_url, json={"result": result})
@app.post("/start_task/")
async def start_task(background_tasks: BackgroundTasks, callback_url: str):
background_tasks.add_task(long_running_task, callback_url)
return {"status": "任务已开始"}
```
3. WebSockets
您可以在客户端和服务器之间建立WebSocket连接，以在任务完成时发送结果。
服务端：
desde fastapi importar FastAPI, WebSocket
aplicación = FastAPI()
@app.websocket(“/ws/”)
async def websocket_endpoint(websocket: WebSocket):
await websocket.accept()
# Resultado de la tarea de larga duración
= “some_result”
await websocket.send_json({“resultado”: resultado})
客户端：
const socket = nuevo WebSocket('ws://localhost:8000/ws/');
socket.addEventListener('mensaje', función(evento) { resultado const = JSON.parse(event.data); console.log(“Resultado recibido:”, resultado); });
4. 服务器推送事件（SSE）
SSE允许服务器通过单个HTTP连接发送更新和最终结果。
服务端：
desde fastapi importar FastAPI
desde fastapi.responses importar StreamingResponse
aplicación = FastAPI()
@app.get("/task_status/")
def get_status():
def event_stream(): # Resultado
de la tarea de larga duración = "some_result" produce f"datos: {resultado}\n\n" return StreamingResponse(event_stream() , media_type="text/event-stream") ``` Cliente:
const eventSource = new EventSource('/task_status/');
eventSource.onmessage = function(event) {
const result = event.data;
console.log("Received result:", result);
};
en conclusión
Las tareas de larga duración pueden plantear desafíos en el diseño de API, pero FastAPI proporciona varias funciones y trucos para manejarlas de manera eficiente. Ya sea programación asincrónica, tareas en segundo plano o estrategias avanzadas como Celery, Webhooks y WebSockets, puede elegir el enfoque adecuado según las necesidades de su API. Si sigue estas mejores prácticas y estrategias, podrá garantizar que las tareas de larga duración se gestionen de forma eficaz sin comprometer la experiencia del usuario ni el rendimiento del sistema.
leer
Libros recomendados sobre IA
La IA cambia cada día que pasa, pero no se pueden construir edificios altos sin una buena base. ¿Estás interesado en conocer los principios y prácticas de la inteligencia artificial? ¡No busque más! Nuestro libro sobre principios y prácticas de la IA es el recurso perfecto para cualquiera que quiera aprender más sobre el mundo de la IA. Escrita por destacados expertos en el campo, esta guía completa cubre todo, desde los conceptos básicos del aprendizaje automático hasta técnicas avanzadas para construir sistemas inteligentes. Ya sea usted un principiante o un practicante de IA experimentado, este libro puede satisfacer sus necesidades. Entonces, ¿por qué esperar?