Guia d'Inici Ràpid a FastAPI: Millors Pràctiques per Construir APIs d'Alta Rendiment

En el desenvolupament modern de backend, FastAPI està emergint gradualment com una opció popular per construir APIs d'alta rendiment. Aquesta guia us portarà a través de les característiques, avantatges de FastAPI, així com com començar ràpidament amb passos concrets, ajudant-vos a construir i desplegar APIs de manera més eficient en projectes reals.

Què és FastAPI?

FastAPI és un framework web modern i ràpid (d'alta rendiment), basat en les anotacions de tipus estàndard de Python. Permet als desenvolupadors crear APIs ràpides de manera senzilla, alhora que assegura una alta velocitat d'execució i una bona mantenibilitat. Les seves característiques principals inclouen:

• Alta rendiment: Basat en Starlette (per la part web) i Pydantic (per la part de dades), el rendiment és similar al de Node.js i Go.
• Generació automàtica de documentació: A través d'OpenAPI i JSON Schema, FastAPI pot generar automàticament documentació d'API interactiva.
• Fàcil d'usar: Utilitzant anotacions de tipus de Python, redueix errors comuns i millora l'eficiència dels desenvolupadors.
• Suport per programació asíncrona: Suporta async i await, millorant el rendiment en el maneig de moltes sol·licituds.

Avantatges de FastAPI

FastAPI té avantatges significatius en comparació amb frameworks tradicionals (com Django i Flask):

1. Desenvolupament ràpid: Gràcies a la documentació generada automàticament i la verificació de tipus, la velocitat de desenvolupament augmenta notablement.
2. Rendiment eficient: Adequat per a aplicacions amb alta concurrència, especialment amb càrregues altes.
3. Suport de tipus fort: Redueix efectivament els errors en temps d'execució mitjançant anotacions de tipus.
4. Bon suport per a proves: La injecció de dependències i el seu model de sol·licituds fan que les proves i la depuració siguin senzilles.

Començar ràpidament amb FastAPI

1. Preparació de l'entorn

Primer, assegureu-vos que teniu instal·lat Python 3.7 o superior. A continuació, podeu instal·lar FastAPI i el servidor ASGI Uvicorn amb la següent comanda:

pip install fastapi uvicorn

2. Crear una aplicació bàsica de FastAPI

A continuació, creeu una aplicació senzilla de FastAPI. A la vostra carpeta de treball, creeu un fitxer main.py amb el següent contingut:

from fastapi import FastAPI

app = FastAPI()

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

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

3. Executar l'aplicació

Utilitzeu Uvicorn per executar l'aplicació FastAPI:

uvicorn main:app --reload

Accediu a http://127.0.0.1:8000 al navegador, veureu la resposta {"Hello": "World"}. Alhora, accedint a http://127.0.0.1:8000/items/1?q=test retornarà {"item_id": 1, "query": "test"}.

4. Generació automàtica de documentació

FastAPI genera automàticament documentació per a cada ruta, podeu veure la documentació interactiva accedint als següents URL:

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

5. Models de dades i validació

FastAPI també suporta la creació de models de dades mitjançant Pydantic per validar el cos de la sol·licitud. Per exemple:

from pydantic import BaseModel

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

@app.post("/items/")
async def create_item(item: Item):
    return item

El fragment de codi anterior defineix un model de dades Item, FastAPI validarà automàticament les dades JSON que s'hi passin.

6. Programació asíncrona i sincrònica

FastAPI suporta la programació asíncrona, podeu definir funcions de ruta asíncrones utilitzant async def. Per exemple:

import asyncio

@app.get("/wait/")
async def wait_for_response():
    await asyncio.sleep(1)
    return {"message": "Waited for 1 second!"}

7. Desplegar l'aplicació FastAPI

Les aplicacions FastAPI es poden desplegar en diversos entorns, incloent Docker, Kubernetes, serveis al núvol, etc. Un exemple senzill de desplegament de FastAPI amb Docker:

# Dockerfile
FROM python:3.9

WORKDIR /app

COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . .

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

A continuació, genereu la imatge de Docker i executeu-la:

docker build -t myfastapiapp .
docker run -d -p 8000:8000 myfastapiapp

Podeu accedir a http://localhost:8000 per veure la vostra aplicació.

Millors pràctiques

1. Utilitzar anotacions de tipus: Sempre utilitzeu anotacions de tipus de Python per millorar la llegibilitat i mantenibilitat del codi.
2. Validació de paràmetres: Establiu una validació de paràmetres adequada segons les necessitats del negoci, assegurant que les dades passades a l'API siguin vàlides.
3. Gestió centralitzada d'excepcions: Definiu un maneig d'errors global per assegurar que l'API pugui gestionar correctament les excepcions.
4. Documentació i comentaris: Manteniu la documentació de l'API actualitzada, utilitzant comentaris i documentació per mantenir l'accessibilitat del codi.
5. Utilitzar middleware: Feu un ús raonable del middleware per a funcions com CORS, autenticació, etc.

Conclusió

FastAPI, com a potent eina per construir APIs modernes d'alta rendiment, és àmpliament ben rebut entre els desenvolupadors per la seva eficàcia i facilitat d'ús. Tant si sou principiants com si teniu experiència, podeu beneficiar-vos d'ella. En el desenvolupament real, combinar les millors pràctiques us permetrà construir i mantenir projectes de manera més eficient. Esperem que aquesta guia pugui proporcionar orientació i ajuda en el vostre viatge d'aprenentatge amb FastAPI!