A FASTAPI háttér -feladatának javítása 502 HIBA AWS Elastic Beanstalk -on

A háttérfeladatok kezelése a Fastapi -ban az Elasztikus Beanstalk -on

A FASTAPI alkalmazás telepítése az AWS Elastic Beanstalk -on sima élmény lehet - mindaddig, amíg olyan kérdésekbe kerül, mint egy 502 Bad Gateway hiba. Az egyik leggyakoribb fájdalomcsillapító fejlõdés a hosszú távú háttérfeladatok kezelése, amelyek kiválthatják az átjárási időtúllépést. 🚀

Képzelje el ezt: van egy API végpontja, amely PDF fájlt generál a háttérben, kb. 30 másodpercig. Helyileg minden tökéletesen működik. De miután az elasztikus Beanstalk -on telepítették, az API -hívás frusztráló 502 hibával kudarcot vall. Beállította az Nginx és a Gunicorn időtúllépéseit, de a probléma továbbra is fennáll.

Ez egy klasszikus forgatókönyv, ahol az infrastruktúra beállításai és a háttér -feladatkezelés ütköznek. Az AWS Elastic Beanstalk alapértelmezés szerint a háttér -feladat befejezése előtt felmondhatja a kéréseket. A zökkenőmentes telepítés biztosításához kulcsfontosságú annak megértése, hogy miért történik ez, és hogyan kell dolgozni, kulcsfontosságú.

Ebben a cikkben megvizsgáljuk, hogy a FASTAPI háttérfeladatok miért okoznak 502 hibát az Elastic Beanstalk -on, hogyan kell konfigurálni az időtúllépést, és alternatív megoldásokat, hogy az API zökkenőmentesen működjön. Függetlenül attól, hogy a PDF generációval, az adatfeldolgozással vagy a hosszú távú feladatokkal foglalkozik, ezek a betekintések segítenek a probléma hatékony kezelésében. ⚡

A FASTAPI háttérfeladatok optimalizálása az AWS Elastic Beanstalk -on

A FASTAPI alkalmazás futtatásakor AWS Elastic Beanstalk, a hosszú távú háttérfeladatok hatékony kezelése elengedhetetlen az 502 rossz átjáró hibák megelőzéséhez. Az első szkript, amelyet kifejlesztettünk, a FASTAPI -kat használja Háttérképek funkció a PDF generációjának feldolgozásához aszinkron módon. Ez lehetővé teszi az API -nak, hogy azonnal visszatérjen a válaszhoz, miközben a feladat a háttérben folytatódik. Ez a megközelítés azonban problematikus lehet az elasztikus beanstalk -on, mivel a Gunicorn és az Nginx hogyan kezeli a kérési időtúllépést.

A probléma megoldásához egy robusztusabb megoldást vezettünk be a zeller és a redis használatával. Ebben a beállításban a FASTAPI végpont egy feladatot küld a zellernek, ahelyett, hogy közvetlenül kezelné. A zeller, külön munkavállalói folyamatban futva, felveszi a feladatot, és aszinkron módon végrehajtja a fő alkalmazás blokkolása nélkül. Ez megakadályozza az időtúllépési problémákat, mivel az API kérése azonnal befejeződik, miközben a zeller önállóan kezeli a feldolgozást. Képzeljen el egy online áruházat, amely számlákat generál ömlesztve - a megfelelő feladat -delegálás nélkül az API terhelés alatt küzd. 🚀

Egy másik alternatíva, amelyet felfedeztünk, az AWS SQS (egyszerű sorszolgáltatás) kihasználása. Ahelyett, hogy egy belső feladatsorra támaszkodna, ez a módszer a háttér feladatokat egy kezelt üzenetsorba helyezi. Egy külső munkavállalói szolgáltatás folyamatosan szavaz az SQS -t az új feladatokhoz, és aszinkron módon feldolgozza őket. Ez különösen hasznos a nagy forgalmú alkalmazásokban, például egy lovaglásmegosztó alkalmazásban, ahol minden egyes út több adatfeldolgozási feladatot generál. Az AWS SQS használatával a feladat végrehajtását az API -ból decukuláljuk, javítva a méretezhetőséget és a megbízhatóságot.

Végül, az elülső oldalon bevezetett egy szavazó mechanizmust a feladat állapotának ellenőrzésére. Mivel a háttérfeladat kb. 30 másodpercig tart, az előlapnak rendszeresen lekérdeznie az API -t, hogy ellenőrizze, hogy a PDF készen áll -e. Ahelyett, hogy a szerver folyamatos kérésekkel elárasztaná, olyan intervallum-alapú megközelítést hajtottunk végre, amely öt másodpercenként újrakísérletet végez korlátozott számú kísérlethez. Ez biztosítja, hogy a frontend reagáló marad, miközben elkerüli a felesleges API -terhelést. Ezzel a stratégiával a dokumentumgenerálást kérő felhasználók, például az adójelentések, nem fognak megtapasztalni az UIS -t, miközben várakozás. 📄✅

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"}

A FASTAPI háttérképességének javítása a WebSockets segítségével

Egy kihívás a háttérfeladatokkal Fastapi valós idejű frissítéseket biztosít a felhasználók számára anélkül, hogy támaszkodna a nem hatékony szavazásra. Nagyszerű alternatíva a használata Weblokok, amelyek lehetővé teszik az ügyfél és a szerver közötti kétirányú kommunikációt. Ahelyett, hogy egy végpontot többször lekérdezne egy feladat állapotának ellenőrzésére, a háttérkép frissítéseket küldhet, amikor előrehaladás történik.

A WebSockets segítségével, amikor a felhasználó PDF generációt kér, a szerver azonnal elismeri a kérést, és elkezdi a feldolgozást a háttérben. A feladat előrehaladtával a WebSocket üzenetek tájékoztathatják az ügyfelet a különböző szakaszokról, például a „feldolgozás”, a „feltöltés” ​​és a „kitöltött”. Ez csökkenti a felesleges API-hívásokat, és javítja a felhasználói élményt, különösen olyan alkalmazásokban, mint az e-kereskedelem számla generálása vagy a jelentés letöltése. 🚀

A weblockák megvalósítása a FASTAPI -ban használja a használatát asyncio És a weblokok modul. A WebSocket kapcsolatot akkor hozták létre, amikor a Frontend hallgatja a frissítéseket, és a háttérkép valós idejű üzeneteket továbbít. Ez a módszer rendkívül hatékony a hagyományos szavazásokhoz képest, és széles körben használják az azonnali frissítéseket igénylő alkalmazásokban, például a pénzügyi műszerfalak és az együttműködési szerkesztési eszközök.