Bagaimana untuk Membangunkan Perkhidmatan API Berprestasi Tinggi Menggunakan FastAPI

FastAPI adalah satu rangka kerja Web moden dan cepat (berkesan) yang direka khusus untuk membangunkan API. Ia berdasarkan petunjuk jenis Python dan menyokong pengaturcaraan asinkron, membolehkan pembangun membina perkhidmatan API yang berprestasi tinggi, boleh didapati tinggi dan dengan latensi rendah. Artikel ini akan menerangkan secara terperinci bagaimana untuk menggunakan FastAPI untuk membangunkan perkhidmatan API berprestasi tinggi, kami akan menerangkan langkah demi langkah, membantu anda mencapai keseluruhan proses dari penyediaan persekitaran hingga penyebaran.

Langkah Pertama: Penyediaan Persekitaran

Anda perlu memastikan bahawa persekitaran pembangunan anda telah memasang Python 3.6+. Jika belum memasang, anda boleh melawat Laman Web Rasmi Python untuk memuat turun dan memasangnya.

Memasang FastAPI dan Uvicorn

FastAPI itu sendiri tidak menyediakan perkhidmatan, ia memerlukan pelayan ASGI untuk menyokongnya. Di sini kami menggunakan Uvicorn, sebuah pelayan ASGI berprestasi tinggi. Anda boleh menggunakan arahan berikut untuk memasang FastAPI dan Uvicorn:

pip install fastapi uvicorn

Langkah Kedua: Membangunkan API Asas

Mari kita buat aplikasi FastAPI yang mudah.

Membuat Fail Aplikasi

Dalam direktori projek anda, buat satu fail Python, contohnya main.py, dan kemudian tulis kod berikut:

from fastapi import FastAPI

app = FastAPI()

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

Dalam kod di atas, kami pertama sekali mengimport FastAPI dan mencipta satu instans app. Kemudian, kami mendefinisikan satu laluan GET yang akan mengembalikan satu respons JSON yang mudah apabila mengakses laluan akar /.

Memulakan Pelayan

Mulakan pelayan FastAPI anda dengan arahan berikut:

uvicorn main:app --reload

main: merujuk kepada nama fail, tanpa akhiran .py.
app: merujuk kepada instans FastAPI.
--reload: dalam mod pembangunan, pelayan akan dimulakan semula secara automatik apabila fail diubah.

Langkah Ketiga: Mendefinisikan Laluan dan Model Data

Untuk membina API yang kompleks, anda perlu menggunakan Pydantic untuk mendefinisikan model data.

Membuat Model Data

Tambahkan kandungan berikut dalam main.py:

from pydantic import BaseModel

class Item(BaseModel):
    name: str
    price: float
    is_available: bool = True

Kod ini menggunakan Pydantic untuk mencipta satu model data Item, yang mengandungi tiga atribut: nama produk, harga dan ketersediaan.

Menambah Laluan Baru

Seterusnya, kita boleh mendefinisikan satu laluan POST baru untuk menerima data jenis Item:

@app.post("/items/")
async def create_item(item: Item):
    return {"item_name": item.name, "item_price": item.price}

Dalam laluan ini, FastAPI akan secara automatik mengesahkan data yang diterima dan memetakan ia kepada model Item.

Langkah Keempat: Penjanaan Dokumen Automatik

Salah satu kelebihan terbesar FastAPI adalah ia boleh menjana dokumen API secara automatik. Anda boleh melihatnya dengan melayari alamat berikut:

Swagger UI: http://127.0.0.1:8000/docs
ReDoc: http://127.0.0.1:8000/redoc

Dalam dokumen yang dijana ini, anda boleh menguji API secara interaktif, melihat format permintaan dan respons untuk setiap laluan.

Langkah Kelima: Menambah Pengesahan

Dalam aplikasi sebenar, pengesahan adalah satu langkah penting. Mari kita tambah pengesahan berdasarkan peranan yang mudah.

Menambah Kebergantungan Keselamatan

Gunakan kaedah Depends FastAPI dan OAuth2PasswordBearer untuk melaksanakan pengesahan:

from fastapi import Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

async def fake_decode_token(token):
    return {"sub": token}

async def get_current_user(token: str = Depends(oauth2_scheme)):
    user = fake_decode_token(token)
    if user is None:
        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid authentication credentials")
    return user

Melindungi Laluan

Kemudian, anda boleh menambah pengesahan pada laluan yang perlu dilindungi:

@app.get("/users/me")
async def read_users_me(current_user: dict = Depends(get_current_user)):
    return current_user

Langkah Keenam: Penyebaran Aplikasi FastAPI

Apabila anda selesai dengan pembangunan, anda mungkin perlu menyebarkan aplikasi ke pelayan awan. Anda boleh memilih untuk menggunakan Docker untuk penyebaran.

Membuat Dockerfile

Dalam direktori projek, buat satu fail bernama Dockerfile, masukkan kandungan berikut:

FROM tiangolo/uvicorn-gunicorn-fastapi:python3.8

COPY ./app /app

Membangunkan Imej Docker

Dalam terminal anda, gunakan arahan berikut untuk membangunkan imej Docker:

docker build -t myfastapiapp .

Menjalankan Kontena Docker

Jalankan aplikasi FastAPI anda:

docker run -d --name fastapi -p 80:80 myfastapiapp

Kesimpulan

Dalam artikel ini, kami telah menerangkan secara terperinci bagaimana untuk menggunakan FastAPI untuk membangunkan perkhidmatan API berprestasi tinggi, dari penyediaan persekitaran hingga mencipta API asas, mendefinisikan laluan dan model data, serta menambah pengesahan dan penyebaran. FastAPI menyediakan banyak fungsi yang kuat, menjadikan pembinaan API moden menjadi mudah dan berkesan, anda boleh meneroka lebih banyak fungsi dan ciri melalui dokumentasi rasmi. Kami berharap artikel ini dapat membantu anda lebih cepat menguasai FastAPI dan meningkatkan kecekapan pembangunan projek anda!