Bina aplikasi web tak segerak berprestasi tinggi menggunakan FastAPI

Gunakan FastAPI untuk membina aplikasi web tak segerak berprestasi tinggi

Dengan perkembangan pesat Internet, prestasi dan kecekapan aplikasi web telah menjadi salah satu tumpuan pengguna. Rangka kerja web tradisional selalunya tidak cekap apabila mengendalikan sejumlah besar permintaan dan tidak dapat memenuhi keperluan serentak yang tinggi. Untuk meningkatkan prestasi dan kecekapan aplikasi web, FastAPI wujud.

FastAPI ialah rangka kerja web berasaskan Python moden yang mengekalkan kesederhanaan dan kemudahan penggunaan sambil menyampaikan prestasi cemerlang. FastAPI mengguna pakai model pengaturcaraan tak segerak dan menggunakan coroutine Python dan mekanisme IO tak segerak untuk membolehkan aplikasi mengendalikan sebilangan besar permintaan serentak dengan cekap. Berikut akan memperkenalkan cara menggunakan FastAPI untuk membina aplikasi web tak segerak berprestasi tinggi.

1. Pasang FastAPI

Pertama, anda perlu memasang FastAPI menggunakan arahan pip:

pip install fastapi

2. Tulis kod

Seterusnya, buat fail Python, seperti mainrr.py:, dan tulis kod berikut

Kod di atas mencipta aplikasi Dibuat FastAPI dan menentukan laluan permintaan GET, "/" mewakili direktori akar. Apabila mengakses direktori akar, respons JSON yang mengandungi "Hello, World!"

Jalankan aplikasi

Gunakan uvicorn untuk menjalankan aplikasi FastAPI:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
    return {"message": "Hello, World!"}

Kini, aplikasi FastAPI sedang berjalan. Buka pelayar dan lawati http://localhost:8000, dan anda akan melihat "Hello, World!"

Tulis fungsi pemprosesan tak segerak

FastAPI menyokong menggunakan fungsi pemprosesan tak segerak untuk mengendalikan permintaan. Berikut ialah contoh menggunakan fungsi pemprosesan tak segerak:

uvicorn main:app --reload

Dalam kod di atas, kami mentakrifkan tugas tak segerak background_task(), yang akan mencetak "Menjalankan tugas latar belakang..." setiap saat. Dalam fungsi pengendali laluan akar "/", kami menggunakan asyncio.create_task() untuk mencipta tugasan latar belakang. Dengan cara ini, apabila direktori root diakses, pelaksanaan background_task() akan dimulakan pada masa yang sama.

Memproses parameter permintaan

FastAPI menyokong parameter lulus melalui parameter laluan URL, parameter pertanyaan, badan permintaan, dll., yang sangat fleksibel. Berikut ialah contoh menggunakan parameter laluan URL dan parameter pertanyaan:

from fastapi import FastAPI
import asyncio

app = FastAPI()

async def background_task():
    while True:
        print("Running background task...")
        await asyncio.sleep(1)

@app.get("/")
async def root():
    asyncio.create_task(background_task())
    return {"message": "Hello, World!"}

Dalam kod di atas, kami mentakrifkan laluan permintaan GET dengan parameter laluan item_id dan parameter pertanyaan q. Apabila mengakses, sebagai contoh, /items/42?q=test, respons berikut akan dikembalikan:

from fastapi import FastAPI

app = FastAPI()

@app.get("/items/{item_id}")
async def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

Operasi pangkalan data tak segerak

FastAPI sememangnya menyokong operasi tak segerak dan boleh berinteraksi dengan pangkalan data tak segerak dengan mudah. Berikut ialah contoh menggunakan operasi pangkalan data tak segerak:

{
    "item_id": 42,
    "q": "test"
}

Dalam kod di atas, kami menggunakan perpustakaan pangkalan data untuk mencipta sambungan pangkalan data SQLite dan melaksanakan operasi sambungan dan pemotongan apabila aplikasi dimulakan dan dimatikan. Dalam fungsi pengendali laluan akar, kami melaksanakan pertanyaan SELECT dan mengembalikan hasilnya.

Kerahkan aplikasi

Gunakan alatan seperti uvicorn, Gunicorn, dll. untuk menggunakan aplikasi FastAPI ke persekitaran pengeluaran. Contohnya, gunakan Gunicorn untuk menggunakan aplikasi FastAPI:

from fastapi import FastAPI
from databases import Database

app = FastAPI()
database = Database("sqlite:///test.db")

@app.on_event("startup")
async def startup():
    await database.connect()

@app.on_event("shutdown")
async def shutdown():
    await database.disconnect()

@app.get("/")
async def root():
    query = "SELECT * FROM items"
    items = await database.fetch_all(query)
    return {"items": items}

Arahan di atas akan memulakan 4 proses dan menggunakan UvicornWorker untuk mengendalikan permintaan.

Ringkasan

FastAPI ialah rangka kerja web moden yang sangat berkuasa yang boleh membantu kami membina aplikasi web tak segerak berprestasi tinggi. Dengan memanfaatkan ciri pengaturcaraan tak segerak Python, kami boleh mengendalikan sejumlah besar permintaan serentak dan mencapai operasi pangkalan data yang cekap. Sama ada anda sedang membangunkan projek peribadi atau membina aplikasi peringkat perusahaan, FastAPI ialah pilihan yang patut dicuba.

Atas ialah kandungan terperinci Bina aplikasi web tak segerak berprestasi tinggi menggunakan FastAPI. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!