20 FastAPI 性能优化

在构建生产情况中的 FastAPI 应用时，性能是一个非常重要的考量因素。随着用户量的增加，应用的性能瓶颈会逐渐袒暴露来。为了解决这些题目，可以通过异步操作、调优启动时间和响应时间、以及使用缓存来提高应用的性能。
1. 使用异步操作提高并发性能

FastAPI 本身是基于 ASGI（Asynchronous Server Gateway Interface）的，这意味着它可以很好地支持异步操作，并可以或许有效地处置惩罚高并发哀求。通过使用异步操作，可以显著提高应用的并发能力，尤其是在处置惩罚 IO 麋集型使命时。
1.1 异步视图函数

FastAPI 提供了原生支持异步视图函数。你可以使用 async 和 await 关键字来界说异步函数，如许在执行耗时的 IO 操作（如数据库查询、外部 API 调用等）时，FastAPI 会主动释放线程，允许其他哀求处置惩罚。
示例：异步处置惩罚数据库查询

1. from fastapi import FastAPI
2. import asyncio
4. app = FastAPI()
6. # 模拟一个耗时的异步操作
7. async def get_data_from_database():
8.     await asyncio.sleep(2)  # 模拟延迟
9.     return {"data": "sample data"}
11. @app.get("/data")
12. async def get_data():
13.     data = await get_data_from_database()
14.     return data

复制代码

代码解析：

• async def get_data_from_database()：界说了一个异步的数据库查询函数，使用 await 来模仿延迟。
  
• async def get_data()：处置惩罚哀求的视图函数，它也是异步的，可以通过 await 调用异步数据库查询。
  

1.2 异步使命的优势

使用异步操作后，FastAPI 可以处置惩罚更多的并发哀求，因为它不会被单个长时间运行的操作壅闭。异步 I/O 操作使得在等待外部资源时，应用可以继续处置惩罚其他哀求，极大地提高了应用的并发性能。

• 异步数据库查询：如果你使用的是像 SQLAlchemy 或 Tortoise ORM 如许的支持异步的数据库库，可以显著提高数据库操作的服从。
  
• 异步外部 API 调用：如果你的应用需要调用外部 API，异步调用可以使得应用在等待外部响应时，继续处置惩罚其他哀求。
  

1.3 异步文件 I/O 操作

雷同地，异步操尴尬刁难于文件 I/O 也是有效的，尤其是在处置惩罚大型文件时。使用 aiofiles 库可以实现异步文件操作。

2. pip install aiofiles
3. python复制编辑import aiofiles
5. @app.get("/read-file")
6. async def read_file():
7.     async with aiofiles.open("large_file.txt", mode='r') as file:
8.         content = await file.read()
9.     return {"file_content": content}

复制代码

1.4 使用异步的 WebSocket 处置惩罚高并发

如果你需要支持 WebSocket，可以使用 FastAPI 的异步 WebSocket 端点，来处置惩罚实时双向通讯。

1. from fastapi import WebSocket, FastAPI
3. app = FastAPI()
5. @app.websocket("/ws")
6. async def websocket_endpoint(websocket: WebSocket):
7.     await websocket.accept()
8.     while True:
9.         data = await websocket.receive_text()
10.         await websocket.send_text(f"Message text was: {data}")

复制代码

2. 调优 FastAPI 应用的启动时间和响应时间

2.1 启动时间优化

在 FastAPI 中，启动时间通常与应用初始化、依靠注入、数据库连接等因素干系。为了优化启动时间，可以考虑以下方法：

• 淘汰启动时的计算量：避免在启动时进行复杂的计算使命或加载大量数据。尽量将这些操作推迟到哀求处置惩罚时进行。
  
• 延迟加载依靠：如果你的应用依靠于一些外部资源（如数据库、缓存等），可以考虑在首次哀求时再加载这些资源，而不是在应用启动时就加载。
  
• 优化依靠注入：避免在应用启动时加载不须要的资源或进行不须要的依靠注入操作。
  

示例：延迟加载数据库连接

1. from fastapi import FastAPI, Depends
3. app = FastAPI()
5. # 模拟一个数据库连接类
6. class Database:
7.     def __init__(self):
8.         self.connection = None
10.     def connect(self):
11.         self.connection = "Connected"
13.     def close(self):
14.         self.connection = None
16. # 延迟加载数据库连接
17. def get_database():
18.     db = Database()
19.     db.connect()  # 模拟连接
20.     yield db
21.     db.close()  # 关闭连接
23. @app.get("/items/")
24. async def read_items(db: Database = Depends(get_database)):
25.     return {"message": "Items fetched from DB", "connection": db.connection}

复制代码

2.2 响应时间优化

响应时间优化直接影响用户体验和应用的吞吐量。以下是几个常见的优化方式：

• 优化数据库查询：对于数据库查询，尽量使用索引，避免全表扫描，淘汰不须要的查询。可以使用异步数据库库（如 databases 和 Tortoise ORM）来加快查询。
  
• 淘汰不须要的数据：避免在响应中返回大量数据，只返回客户端需要的数据。可以使用分页、过滤和投影来优化数据返回。
  
• 非壅闭 I/O：尽量避免使用同步 I/O 操作，尤其是长时间壅闭的操作，比如文件读写、网络哀求等。可以使用异步 I/O 操作来解决这个题目。
  
• 批量操作：在可能的情况下，使用批量操作（例如批量数据库插入或更新），避免进行大量的单个操作。
  

3. 使用缓存提高性能

缓存是一种淘汰数据库查询和计算开销的常见技术。通过缓存，可以将频繁哀求的数据存储在内存中，避免重复的计算或数据库查询。
3.1 使用 Redis 缓存

Redis 是一种高效的内存键值存储体系，广泛用于缓存场景。你可以使用 aioredis 库与 Redis 配合使用异步缓存。
安装 Redis 和 aioredis：

1. pip install aioredis

复制代码

示例：使用 Redis 缓存数据

1. import aioredis
2. from fastapi import FastAPI
3. from pydantic import BaseModel
5. app = FastAPI()
7. # Redis 客户端配置
8. redis = aioredis.from_url("redis://localhost", encoding="utf-8", decode_responses=True)
10. class Item(BaseModel):
11.     name: str
12.     description: str
14. @app.get("/items/{item_id}")
15. async def read_item(item_id: int):
16.     # 尝试从缓存中获取数据
17.     cached_item = await redis.get(f"item:{item_id}")
18.     if cached_item:
19.         return {"item": cached_item, "source": "cache"}
20.    
21.     # 如果缓存中没有数据，查询数据库（模拟）
22.     item = {"item_id": item_id, "name": "Item", "description": "Description"}
23.    
24.     # 将查询到的数据缓存到 Redis
25.     await redis.set(f"item:{item_id}", str(item), ex=60)  # 缓存过期时间 60 秒
26.    
27.     return {"item": item, "source": "database"}

复制代码

代码解析：

• 使用 aioredis 与 Redis 连接。
  
• 实验从 Redis 中获取缓存的数据。如果缓存存在，就直接返回缓存数据。
  
• 如果缓存中没有数据，从数据库中查询并返回，并将数据存入缓存。
  

3.2 缓存响应数据

除了缓存单个数据，还可以考虑缓存整个响应（尤其是 GET 哀求），例如使用 FastAPI-Cache 库来缓存响应。

2. pip install fastapi-cache

复制代码

通过装饰器缓存 FastAPI 视图函数的响应：

1. from fastapi_cache.decorator import cacheable
2. from fastapi import FastAPI
4. app = FastAPI()
6. @app.get("/items/{item_id}")
7. @cacheable(expire=60)  # 缓存 60 秒
8. async def read_item(item_id: int):
9.     return {"item_id": item_id, "name": "Item", "description": "Description"}

复制代码

通过以下几种方式，你可以显著优化 FastAPI 应用的性能：

• 使用异步操作：通过 async 和 await 关键字优化数据库查询、文件操作和外部 API 调用等 I/O 麋集型使命，提高并发性能。
  
• 调优启动时间和响应时间：淘汰启动时的计算、优化依靠注入、精简数据库查询和数据返回，提高响应时间。
  
• 使用缓存：通过缓存频繁哀求的数据，淘汰数据库访问，提升响应速率。可以使用 Redis 或其他缓存技术来实现高效缓存。
  

这些优化步调可以帮助你构建高性能、高并发的 FastAPI 应用，提供更好的用户体验和更高的体系吞吐量。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。