Fixation de la tâche de fond Fastapi 502 Erreur sur AWS Elastic Beanstalk

Traiter des tâches de fond à Fastapi sur le haricot élastique

Le déploiement d'une application FastAPI sur AWS Elastic Beanstalk peut être une expérience fluide - jusqu'à ce que vous rencontriez des problèmes comme une erreur de Bad Gateway 502. Un point de poitrine commun des développeurs de pondéores est de gérer les tâches de fond à long terme, ce qui peut déclencher des délais d'attente de passerelle. 🚀

Imaginez ceci: vous avez un point de terminaison API qui génère un fichier PDF en arrière-plan, prenant environ 30 secondes. Localement, tout fonctionne parfaitement. Mais une fois déployé sur Elastic Beanstalk, l'appel API échoue avec une erreur frustrante 502. Vous avez ajusté les délais d'attente Nginx et Gunicorn, mais le problème persiste.

Il s'agit d'un scénario classique où les paramètres d'infrastructure et la manipulation des tâches d'arrière-plan entrent en collision. AWS Elastic Beanstalk, par défaut, pourrait terminer les demandes avant la fin de la tâche d'arrière-plan. Comprendre pourquoi cela se produit et comment le contourner est la clé pour assurer un déploiement en douceur.

Dans cet article, nous explorerons pourquoi les tâches d'arrière-plan FastAPI provoquent 502 erreurs sur le beanstal élastique, comment configurer correctement les délais d'expiration et des solutions alternatives pour que votre API fonctionne parfaitement. Que vous ayez affaire à la génération de PDF, au traitement des données ou à toute tâche de longue date, ces informations vous aideront à résoudre efficacement le problème. ⚡

Optimisation des tâches de fond Fastapi sur AWS Elastic Beanstalk

Lors de l'exécution d'une application Fastapi sur AWS Elastic Beanstalk, la gestion efficace des tâches de fond à long terme est cruciale pour empêcher 502 mauvaises erreurs de passerelle. Le premier script que nous avons développé utilise Fastapi Antécédents fonctionnalité pour traiter la génération de pdf de manière asynchrone. Cela permet à l'API de renvoyer une réponse immédiatement pendant que la tâche continue en cours d'exécution en arrière-plan. Cependant, cette approche peut être problématique sur le haricot élastique en raison de la façon dont Gunicorn et Nginx gèrent les délais d'expiration des délais de demande.

Pour résoudre ce problème, nous avons introduit une solution plus robuste utilisant le céleri et redis. Dans cette configuration, le point de terminaison FastAPI envoie une tâche au céleri au lieu de le manipuler directement. Le céleri, exécutant un processus de travailleur séparé, ramasse la tâche et l'exécute de manière asynchrone sans bloquer l'application principale. Cela empêche les problèmes de délai d'expiration, car la demande d'API se termine instantanément tandis que le céleri gère le traitement indépendamment. Imaginez une boutique en ligne générant des factures en vrac - sans délégation de tâches appropriée, l'API aurait du mal à charger. 🚀

Une autre alternative que nous avons explorée est de tirer parti des SQ SQ (Service de file d'attente simple). Au lieu de s'appuyer sur une file d'attente de tâches interne, cette méthode pousse les travaux d'arrière-plan vers une file d'attente de messages gérée. Un service de travailleur externe interroge en continu SQS pour de nouvelles tâches et les traite de manière asynchrone. Ceci est particulièrement utile dans les applications très trafiques, comme une application de covoiturage où chaque conduite génère plusieurs tâches de traitement des données. En utilisant AWS SQS, nous découpons l'exécution de la tâche à partir de l'API, améliorant l'évolutivité et la fiabilité.

Enfin, du côté frontend, nous avons mis en œuvre un mécanisme de sondage pour vérifier l'état de la tâche. Étant donné que la tâche d'arrière-plan prend environ 30 secondes, le frontend doit demander périodiquement l'API pour vérifier si le PDF est prêt. Au lieu de submerger le serveur avec des demandes continues, nous avons implémenté une approche basée sur des intervalles qui récupère toutes les 5 secondes pour un nombre limité de tentatives. Cela garantit que le frontend reste réactif tout en évitant la charge d'API inutile. Avec cette stratégie, les utilisateurs demandant la génération de documents, tels que les rapports fiscaux, ne subiront pas des UIS insensibles en attente. 📄✅

from fastapi import FastAPI, BackgroundTasks
from celery import Celery
import time
app = FastAPI()
celery = Celery("tasks", broker="redis://localhost:6379/0")
@celery.task
def generate_pdf_task(order_id: str):
    print(f"Generating PDF for order {order_id}")
    time.sleep(30)  # Simulating long processing time
    return f"PDF generated for order {order_id}"
@app.post("/generate-pdf/{order_id}")
async def generate_pdf(order_id: str, background_tasks: BackgroundTasks):
    background_tasks.add_task(generate_pdf_task, order_id)
    return {"message": "PDF generation started"}

import boto3
from fastapi import FastAPI
app = FastAPI()
sqs = boto3.client('sqs', region_name='us-east-1')
queue_url = "https://sqs.us-east-1.amazonaws.com/your-account-id/your-queue-name"
@app.post("/generate-pdf/{order_id}")
async def generate_pdf(order_id: str):
    response = sqs.send_message(
        QueueUrl=queue_url,
        MessageBody=str(order_id)
    )
    return {"message": "PDF generation request sent", "message_id": response['MessageId']}

async function checkPdfStatus(orderId) {
    let attempts = 0;
    const maxAttempts = 5;
    while (attempts < maxAttempts) {
        const response = await fetch(`/get-pdf-url/${orderId}`);
        const data = await response.json();
        if (data.pdf_url) {
            console.log("PDF available at:", data.pdf_url);
            return;
        }
        attempts++;
        await new Promise(resolve => setTimeout(resolve, 5000));
    }
    console.log("PDF generation timed out.");
}

from fastapi.testclient import TestClient
from main import app
client = TestClient(app)
def test_generate_pdf():
    response = client.post("/generate-pdf/test_order")
    assert response.status_code == 200
    assert response.json() == {"message": "PDF generation started"}

Amélioration de la gestion des tâches de fond Fastapi avec WebSockets

Un défi avec des tâches de fond dans Fastapi fournit des mises à jour en temps réel aux utilisateurs sans compter sur un sondage inefficace. Une excellente alternative consiste à utiliser Sockets websockets, qui permettent une communication bidirectionnelle entre le client et le serveur. Au lieu d'interroger à plusieurs reprises un point de terminaison pour vérifier l'état d'une tâche, le backend peut envoyer des mises à jour chaque fois qu'il y a des progrès.

Avec WebSockets, lorsqu'un utilisateur demande une génération de PDF, le serveur reconnaît immédiatement la demande et commence à traiter en arrière-plan. Au fur et à mesure que la tâche progresse, les messages WebSocket peuvent informer le client des différentes étapes, telles que «traitement», «téléchargement» et «terminé». Cela réduit les appels d'API inutiles et améliore l'expérience utilisateur, en particulier dans des applications telles que la génération de factures du commerce électronique ou les téléchargements de rapports. 🚀

La mise en œuvre de Websockets dans Fastapi nécessite l'utilisation asyncio et le sockets websockets module. Une connexion WebSocket est établie lorsque le frontend écoute les mises à jour, et le backend pousse les messages en temps réel. Cette méthode est très efficace par rapport aux sondages traditionnels et est largement utilisé dans les applications nécessitant des mises à jour instantanées, telles que les tableaux de bord financiers et les outils d'édition collaboratifs.