Construire des APIs Performantes avec FastAPI et Docker (2023)

Dans le monde du développement logiciel, la création d'interfaces de programmation d'applications (API) performantes est cruciale pour rendre votre logiciel accessible à un large éventail d'utilisateurs. FastAPI émerge comme un cadre moderne en Python, basé sur Pydantic et Starlette, offrant des fonctionnalités exceptionnelles pour le développement rapide d'API robustes et performantes.

Les Fonctionnalités Exceptionnelles de FastAPI

FastAPI se distingue par ses fonctionnalités impressionnantes, toutes répertoriées sur le site officiel du framework. Cependant, l'aspect qui retient particulièrement l'attention est la documentation interactive automatique de l'API, rendue disponible par Swagger UI et ReDoc.

Création d'un Projet FastAPI

Pour commencer avec FastAPI, la première étape consiste à créer un environnement virtuel isolé pour votre projet. Utilisez les commandes suivantes pour créer l'environnement et installer FastAPI ainsi que le serveur ASGI Uvicorn, essentiel pour la production.

$ python3 -m venv env
$ source env/bin/activate
$ pip install fastapi
$ pip install "uvicorn[standard]"

Structure du Projet

Organisez votre projet avec une structure de répertoires recommandée, comprenant un répertoire d'application avec un fichier __init__.py et main.py. Cette structure garantit une base solide pour l'expansion future de votre application.

Première API avec FastAPI

Créez votre première API en définissant une route racine dans le fichier main.py. Utilisez Uvicorn pour exécuter le serveur et vérifiez la sortie sur .

# main.py
from fastapi import FastAPI

app = FastAPI()

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

Développement d'une API CRUD

FastAPI facilite la création d'une API CRUD (Create, Read, Update, Delete). Commencez par définir une base de données fictive sous forme d'une liste de dictionnaires, représentant des publications.

# Dummy in-memory posts
posts = [
    {"title": "title of post 1", "content": "content of post 1", "id": 1, "published": True, "rating": 8},
    {"title": "title of post 2", "content": "content of post 2", "id": 2, "published": True, "rating": 6.5}
]

Obtenir Toutes les Publications

Définissez une route pour récupérer toutes les publications de la base de données.

@app.get("/posts")
def get_posts():
    return {"data": posts}

Ajouter une Nouvelle Publication

Créez une route pour ajouter une nouvelle publication en utilisant un modèle Pydantic pour valider les données de la requête.

from pydantic import BaseModel, Optional

class Post(BaseModel):
    title: str
    content: str
    published: bool = True
    rating: Optional[int] = None

@app.post("/posts")
def create_post(post: Post):
    last_id = int(posts[-1]['id'])
    payload = post.dict()
    payload["id"] = last_id + 1
    posts.append(payload)
    return {"data": payload}

Autres Opérations CRUD

Définissez des routes pour obtenir une seule publication par son ID, obtenir la dernière publication, mettre à jour une publication par son ID, et supprimer une publication par son ID. Utilisez les réponses appropriées pour gérer les cas d'erreur.

Dockerisation de l'Application FastAPI

Docker simplifie le déploiement d'une application avec toutes ses dépendances, variables d'environnement et configurations. Créez un fichier Dockerfile à la racine du projet avec les instructions suivantes.

FROM python:3.6
WORKDIR /fastapi
COPY requirements.txt /fastapi
RUN pip install -r requirements.txt
COPY ./app /fastapi/app
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "80"]

Construisez et exécutez le conteneur Docker avec les commandes suivantes.

$ docker build -t fastapi_learn .
$ docker run -d -p 8000:80 fastapi_learn

Votre application FastAPI est maintenant prête à être déployée avec Docker.

Conclusion

FastAPI offre une approche moderne et performante pour le développement d'API en Python. En combinant les fonctionnalités puissantes de FastAPI avec la dockerisation de l'application, vous pouvez créer et déployer des API robustes de manière efficace. Ce guide constitue une introduction solide, mais il existe de nombreuses possibilités d'exploration et d'optimisation pour des cas d'utilisation plus avancés.

Avec FastAPI et Docker, vous pouvez développer des API performantes et les déployer de manière efficace. Suivez ces étapes pour créer une base solide et explorez les fonctionnalités avancées pour répondre à vos besoins spécifiques. Bon codage!