Maksimumkan Kecekapan FastAPI Anda: Pelaksanaan Caching dan Penguncian yang Sangat Pantas dengan py-cachify

Dalam dunia pembangunan web yang pantas, prestasi adalah yang terpenting. Mekanisme caching yang cekap boleh meningkatkan responsif API anda dengan ketara dengan mengurangkan pengiraan berlebihan dan pertanyaan pangkalan data. Dalam artikel ini, kami akan meneroka cara untuk menyepadukan perpustakaan py-cachify ke dalam aplikasi FastAPI menggunakan SQLModel dan Redis untuk melaksanakan kawalan caching dan concurrency.

Jadual Kandungan:

• Pengenalan
• Persediaan Projek
• Mencipta Model Pangkalan Data dengan SQLModel
• Membina Titik Tamat FastAPI
• Caching Keputusan Titik Akhir
• Mengunci Pelaksanaan Titik Tamat Kemas Kini
• Menjalankan Aplikasi
• Kesimpulan

pengenalan

Caching ialah teknik yang berkuasa untuk meningkatkan prestasi aplikasi web dengan menyimpan hasil operasi yang mahal dan menyediakannya daripada storan akses pantas. Dengan py-cachify, kami boleh menambah caching dengan lancar pada aplikasi FastAPI kami, menggunakan Redis untuk storan. Selain itu, py-cachify menyediakan alat untuk kawalan serentak, menghalang keadaan perlumbaan semasa operasi kritikal.

Dalam tutorial ini, kami akan meneruskan penyediaan perpustakaan py-cachify dalam aplikasi FastAPI dengan SQLModel untuk ORM dan Redis untuk caching.

Persediaan Projek

Mari mulakan dengan menyediakan persekitaran projek kami.

Prasyarat

• Python 3.12
• Puisi (anda boleh menggunakan mana-mana pengurus pakej yang anda suka)
• Pelayan Redis berjalan secara setempat atau boleh diakses dari jauh

Pasang Ketergantungan

Mulakan projek baharu melalui puisi:

# create new project
poetry new --name app py-cachify-fastapi-demo

# enter the directory
cd py-cachify-fastapi-demo

# point poetry to use python3.12
poetry env use python3.12

# add dependencies
poetry add "fastapi[standard]" sqlmodel aiosqlite redis py-cachify

• FastAPI: Rangka kerja web untuk membina API kami.
• SQLModel aiosqlite: Menggabungkan SQLAlchemy dan Pydantic untuk ORM dan pengesahan data.
• Redis: Pelanggan Python untuk berinteraksi dengan Redis.
• py-cachify: Caching dan mengunci utiliti.

Memulakan py-cachify

Sebelum kami boleh menggunakan py-cachify, kami perlu memulakannya dengan pelanggan Redis kami. Kami akan melakukan ini menggunakan parameter jangka hayat FastAPI.

# app/main.py
from contextlib import asynccontextmanager
from fastapi import FastAPI
from py_cachify import init_cachify
from redis.asyncio import from_url


@asynccontextmanager
async def lifespan(_: FastAPI):
    init_cachify(
        # Replace with your redis url if it differs
        async_client=from_url('redis://localhost:6379/0'),
    )
    yield


app = FastAPI(lifespan=lifespan)

Di dalam jangka hayat, kami:

• Buat pelanggan Redis tak segerak.
• Mulakan py-cachify dengan pelanggan ini.

Mencipta Model Pangkalan Data dengan SQLModel

Kami akan mencipta model Pengguna yang mudah untuk berinteraksi dengan pangkalan data kami.

# app/db.py
from sqlmodel import Field, SQLModel


class User(SQLModel, table=True):
    id: int | None = Field(default=None, primary_key=True)
    name: str
    email: str

Sediakan enjin pangkalan data dan buat jadual dalam fungsi jangka hayat:

# app/db.py

# Adjust imports
from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine


# Add the following at the end of the file
sqlite_file_name = 'database.db'
sqlite_url = f'sqlite+aiosqlite:///{sqlite_file_name}'
engine = create_async_engine(sqlite_url, echo=True)
session_maker = async_sessionmaker(engine)


# app/main.py
# Adjust imports and lifespan function
from sqlmodel import SQLModel

from .db import engine


@asynccontextmanager
async def lifespan(_: FastAPI):
    init_cachify(
        async_client=from_url('redis://localhost:6379/0'),
    )
    # Create SQL Model tables
    async with engine.begin() as conn:
        await conn.run_sync(SQLModel.metadata.create_all)

    yield

Nota: Kami menggunakan SQLite untuk kesederhanaan, tetapi anda boleh menggunakan mana-mana pangkalan data yang disokong oleh SQLAlchemy.

Membina Titik Akhir FastAPI

Mari kita buat titik akhir untuk berinteraksi dengan model Pengguna kami.

# create new project
poetry new --name app py-cachify-fastapi-demo

# enter the directory
cd py-cachify-fastapi-demo

# point poetry to use python3.12
poetry env use python3.12

# add dependencies
poetry add "fastapi[standard]" sqlmodel aiosqlite redis py-cachify

Caching Keputusan Titik Akhir

Sekarang, mari kita cache hasil titik akhir read_user untuk mengelakkan pertanyaan pangkalan data yang tidak perlu.

Kod titik akhir akan kelihatan seperti ini:

# app/main.py
from contextlib import asynccontextmanager
from fastapi import FastAPI
from py_cachify import init_cachify
from redis.asyncio import from_url


@asynccontextmanager
async def lifespan(_: FastAPI):
    init_cachify(
        # Replace with your redis url if it differs
        async_client=from_url('redis://localhost:6379/0'),
    )
    yield


app = FastAPI(lifespan=lifespan)

Dengan penghias @cached:

• Kami menentukan kunci unik menggunakan user_id.
• Tetapkan TTL (masa untuk hidup) kepada 5 minit (300 saat).
• Panggilan berikutnya ke titik akhir ini dengan user_id yang sama dalam masa 5 minit akan mengembalikan hasil cache.

Menetapkan Semula Cache pada Kemas Kini

Apabila data pengguna dikemas kini, kami perlu menetapkan semula cache untuk memastikan pelanggan menerima maklumat terkini. Untuk merealisasikannya, mari ubah suai titik akhir pengguna_update.

# app/db.py
from sqlmodel import Field, SQLModel


class User(SQLModel, table=True):
    id: int | None = Field(default=None, primary_key=True)
    name: str
    email: str

Dengan memanggil read_user.reset(user_id=user_id), kami:

• Kosongkan data cache untuk user_id tertentu.
• Pastikan permintaan GET berikutnya mengambil data baharu daripada pangkalan data.

Di bawahnya, penghias cache membungkus fungsi anda secara dinamik, sambil menambahkan kaedah .set semula. Kaedah ini meniru tandatangan fungsi dan taip, dengan cara ini ia akan sama ada segerak atau tidak segerak bergantung pada fungsi asal dan akan menerima hujah yang sama.

Kaedah .reset menggunakan logik penjanaan kunci yang sama yang ditakrifkan dalam penghias cache untuk mengenal pasti entri cache mana yang akan dibatalkan. Contohnya, jika corak kunci caching anda ialah user-{user_id}, panggilan await read_user.reset(user_id=123) secara khusus akan menyasarkan dan memadamkan entri cache untuk user_id=123.

Mengunci Pelaksanaan Titik Akhir Kemas Kini

Untuk mengelakkan keadaan perlumbaan semasa kemas kini, kami akan menggunakan penghias sekali untuk mengunci pelaksanaan titik akhir kemas kini.

# app/db.py

# Adjust imports
from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine


# Add the following at the end of the file
sqlite_file_name = 'database.db'
sqlite_url = f'sqlite+aiosqlite:///{sqlite_file_name}'
engine = create_async_engine(sqlite_url, echo=True)
session_maker = async_sessionmaker(engine)


# app/main.py
# Adjust imports and lifespan function
from sqlmodel import SQLModel

from .db import engine


@asynccontextmanager
async def lifespan(_: FastAPI):
    init_cachify(
        async_client=from_url('redis://localhost:6379/0'),
    )
    # Create SQL Model tables
    async with engine.begin() as conn:
        await conn.run_sync(SQLModel.metadata.create_all)

    yield

Dengan sekali:

• Kami mengunci fungsi berdasarkan user_id.
• Jika permintaan lain cuba mengemas kini pengguna yang sama secara serentak, ia akan segera mengembalikan respons dengan 226 IM Digunakan kod status.
• Ini menghalang kemas kini serentak yang boleh mengakibatkan data tidak konsisten.

Secara pilihan, anda boleh mengkonfigurasi @sekali untuk menaikkan pengecualian atau mengembalikan nilai tertentu jika kunci sudah diperoleh.

Menjalankan Aplikasi

Kini tiba masanya untuk menjalankan dan menguji apl kami!

1) Mulakan Pelayan Redis:

Pastikan pelayan Redis anda berjalan secara setempat atau boleh diakses dari jauh. Anda boleh memulakan pelayan Redis tempatan menggunakan Docker:

# app/main.py

# Adjust imports
from fastapi import Depends, FastAPI
from sqlalchemy.ext.asyncio import AsyncSession

from .db import User, engine, session_maker


# Database session dependency
async def get_session():
    async with session_maker() as session:
        yield session


app = FastAPI(lifespan=lifespan)


@app.post('/users/')
async def create_user(user: User, session: AsyncSession = Depends(get_session)) -> User:
    session.add(user)
    await session.commit()
    await session.refresh(user)
    return user


@app.get('/users/{user_id}')
async def read_user(user_id: int, session: AsyncSession = Depends(get_session)) -> User | None:
    return await session.get(User, user_id)


@app.put('/users/{user_id}')
async def update_user(user_id: int, new_user: User, session: AsyncSession = Depends(get_session)) -> User | None:
    user = await session.get(User, user_id)
    if not user:
        return None

    user.name = new_user.name
    user.email = new_user.email

    session.add(user)
    await session.commit()
    await session.refresh(user)

    return user

2) Jalankan Aplikasi FastAPI:

Dengan semua yang disediakan, anda boleh melancarkan aplikasi FastAPI anda menggunakan Puisi. Navigasi ke direktori akar projek anda dan laksanakan arahan berikut:

# app/main.py

# Add the import
from py_cachify import cached


@app.get('/users/{user_id}')
@cached('read_user-{user_id}', ttl=300)  # New decorator
async def read_user(user_id: int, session: AsyncSession = Depends(get_session)) -> User | None:
    return await session.get(User, user_id)

3) Menguji dan Bermain dengan Caching dan Mengunci:

Caching: Tambahkan kelewatan (cth., menggunakan asyncio.sleep) dalam fungsi read_user untuk mensimulasikan pengiraan yang berjalan lama. Perhatikan bagaimana masa tindak balas bertambah baik secara drastik sebaik sahaja keputusan dicache.

Contoh:

# create new project
poetry new --name app py-cachify-fastapi-demo

# enter the directory
cd py-cachify-fastapi-demo

# point poetry to use python3.12
poetry env use python3.12

# add dependencies
poetry add "fastapi[standard]" sqlmodel aiosqlite redis py-cachify

Keselarasan dan Penguncian: Begitu juga, perkenalkan kelewatan dalam fungsi kemas kini_pengguna untuk memerhatikan gelagat kunci apabila percubaan kemas kini serentak dibuat.

Contoh:

# app/main.py
from contextlib import asynccontextmanager
from fastapi import FastAPI
from py_cachify import init_cachify
from redis.asyncio import from_url


@asynccontextmanager
async def lifespan(_: FastAPI):
    init_cachify(
        # Replace with your redis url if it differs
        async_client=from_url('redis://localhost:6379/0'),
    )
    yield


app = FastAPI(lifespan=lifespan)

Kelewatan ini boleh membantu anda melihat keberkesanan mekanisme caching dan penguncian dalam tindakan, kerana bacaan berikutnya seharusnya lebih cepat disebabkan oleh caching, dan penulisan serentak ke sumber yang sama harus diurus dengan berkesan melalui penguncian.

Kini, anda boleh menguji titik akhir anda menggunakan alat seperti Posmen atau dengan pergi ke http://127.0.0.1:8000/docs (apabila apl sedang berjalan!), dan memerhatikan peningkatan prestasi dan kawalan serentak dalam tindakan.

Selamat mencuba dengan apl FastAPI anda yang dipertingkatkan!

Kesimpulan

Dengan menyepadukan py-cachify ke dalam aplikasi FastAPI kami, kami telah membuka kunci banyak manfaat yang meningkatkan prestasi dan kebolehpercayaan API kami.

Mari kita imbas semula beberapa kekuatan utama:

• Prestasi Dipertingkat: Caching panggilan fungsi berulang mengurangkan pengiraan berlebihan dan hits pangkalan data, meningkatkan masa tindak balas secara drastik.
• Kawalan Concurrency: Dengan mekanisme penguncian terbina dalam, py-cachify menghalang keadaan perlumbaan dan memastikan ketekalan data — penting untuk aplikasi dengan akses serentak yang tinggi.
• Fleksibiliti: Sama ada anda bekerja dengan operasi segerak atau tak segerak, py-cachify menyesuaikan diri dengan lancar, menjadikannya pilihan yang serba boleh untuk aplikasi web moden.
• Kemudahan Penggunaan: Pustaka disepadukan dengan lancar dengan rangka kerja Python yang popular seperti FastAPI, membolehkan anda bermula dengan geseran yang minimum.
• Anotasi Jenis Penuh: py-cachify beranotasi taip sepenuhnya, membantu dalam penulisan kod yang lebih baik dan lebih boleh diselenggara dengan usaha yang minimum.
• Persediaan Minimum: Seperti yang ditunjukkan dalam tutorial ini, menambah py-cachify memerlukan hanya beberapa baris tambahan di atas persediaan sedia ada anda untuk memanfaatkan keupayaannya sepenuhnya.

Bagi mereka yang ingin meneroka lebih lanjut, lihat repositori GitHub py-cachify dan dokumentasi rasmi untuk mendapatkan panduan, tutorial dan contoh yang lebih mendalam.

Anda boleh mengakses kod penuh untuk tutorial ini di GitHub di sini. Jangan ragu untuk mengklonkan repositori dan bermain-main dengan pelaksanaan yang sesuai dengan keperluan projek anda.

Jika anda mendapati py-cachify bermanfaat, pertimbangkan untuk menyokong projek dengan memberikannya bintang di GitHub! Sokongan anda membantu memacu peningkatan lanjut dan ciri baharu.

Selamat mengekod!

Atas ialah kandungan terperinci Maksimumkan Kecekapan FastAPI Anda: Pelaksanaan Caching dan Penguncian yang Sangat Pantas dengan py-cachify. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!