Comment tester et déboguer des points de terminaison d'API dans FastAPI

Lors de la création d'une application web avec FastAPI, l'un des aspects les plus cruciaux est de garantir que les points de terminaison de l'API fonctionnent correctement, c'est-à-dire que les actions effectuées par ces points de terminaison respectent les attentes de l'utilisateur. Dans cet objectif, les tests d'intégration jouent un rôle central. En l'absence de tests rigoureux, il serait difficile de garantir que l'API répond comme prévu dans des conditions variées. Examinons comment créer, tester et déboguer efficacement des points de terminaison dans FastAPI à l'aide de l'exemple suivant.

Pour commencer, nous devons créer une structure de données à valider avec un schéma de Pydantic. Le schéma suivant définit un modèle de données représentant un article avec deux attributs essentiels : un nom et une couleur.

python
Copy code
from pydantic import BaseModel

class ItemSchema(BaseModel):
    name: str
    color: str

Ensuite, nous allons créer un point de terminaison pour ajouter un article à la base de données. Ce point de terminaison utilise la méthode POST et retourne l'ID de l'article après l'avoir ajouté. La fonction add_item envoie l'article dans la base de données et renvoie l'identifiant de l'élément une fois que l'ajout est effectué avec succès.

python
Copy code
from fastapi import Depends, Request, HTTPException, status

from sqlalchemy.orm import Session
@app.post("/item", response_model=int, status_code=status.HTTP_201_CREATED)
def add_item(item: ItemSchema, db_session: Session = Depends(get_db_session)):
    db_item = Item(name=item.name, color=item.color)
    db_session.add(db_item)
    db_session.commit()
    db_session.refresh(db_item)
    return db_item.id

Pour récupérer un article à partir de la base de données en utilisant son ID, un autre point de terminaison GET est créé. Ce point de terminaison prend un item_id et tente de trouver l'article correspondant dans la base de données. Si aucun article n'est trouvé, il renvoie une erreur 404.

python
Copy code
@app.get("/item/{item_id}", response_model=ItemSchema)

def get_item(item_id: int, db_session: Session = Depends(get_db_session)):
    item_db = db_session.query(Item).filter(Item.id == item_id).first()
    if item_db is None:
        raise HTTPException(status_code=404, detail="Item not found")
    return item_db

Si un article avec cet ID existe dans la base de données, il est renvoyé sous forme de réponse. Sinon, un code d'erreur 404 est retourné, ce qui signifie que l'article n'a pas été trouvé.

Pour ce faire, nous devons définir un moteur de base de données en mémoire et un sessionmaker pour la base de données de test. L'exemple suivant montre comment configurer la base de données SQLite en mémoire pour les tests :

python
Copy code
from sqlalchemy.pool import StaticPool
from sqlalchemy import create_engine
engine = create_engine(
    "sqlite:///:memory:",
    connect_args={"check_same_thread": False},
    poolclass=StaticPool,
)
Base.metadata.create_all(bind=engine)

Une fois l'environnement de test prêt, nous devons définir une fonction de session pour récupérer une session de base de données dédiée aux tests :

python
Copy code
from sqlalchemy.orm import sessionmaker

TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

Dans le fichier conftest.py, une fixture peut être créée pour gérer cette session de base de données de test. Cette fixture crée une session de test avant chaque test et la ferme après l'exécution du test :

python
Copy code
@pytest.fixture
def test_db_session():
    db = TestingSessionLocal()
    try:
        yield db
    finally:
        db.close()

python
Copy code
def test_client_can_add_read_the_item_from_database(test_client, test_db_session):
    response = test_client.get("/item/1")
    assert response.status_code == 404

    response = test_client.post("/item", json={"name": "ball", "color": "red"})

    assert response.status_code == 201
    item_id = response.json()
    item = test_db_session.query(Item).filter(Item.id == item_id).first()
    assert item is not None
    response = test_client.get(f"item/{item_id}")
    assert response.status_code == 200
    assert response.json() == {"name": "ball", "color": "red"}

Une fois que vous avez vos tests en place, vous pouvez utiliser des outils comme pytest pour exécuter vos tests et vous assurer que tout fonctionne comme prévu. pytest vous permet d'exécuter des tests individuellement ou par groupe en utilisant des marqueurs. Par exemple, vous pouvez marquer les tests d'intégration et les exécuter spécifiquement avec la commande suivante :

bash
Copy code
$ pytest --m integration -vv

Cela permet de filtrer les tests marqués comme "intégration" et de les exécuter spécifiquement, ce qui peut être utile pour effectuer des tests ciblés.

Enfin, une fois vos tests en place, vous pouvez vérifier la couverture de vos tests pour vous assurer que tous les points de terminaison sont bien couverts. Cela permet de s'assurer que votre API fonctionne correctement et que les tests couvrent toutes les fonctionnalités importantes de l'application.

Comment optimiser les performances des requêtes et sécuriser les données dans MongoDB avec FastAPI

Dans le développement d'applications utilisant MongoDB comme base de données, la gestion des relations entre les collections et l'optimisation des performances des requêtes sont des éléments cruciaux. MongoDB, contrairement aux bases de données relationnelles, permet de stocker les données de manière flexible, mais cette flexibilité implique des défis en termes d'efficacité des requêtes, notamment lorsqu'il s'agit de traiter de grandes quantités de données. L'indexation et la gestion sécurisée des données sont des pratiques essentielles pour garantir des performances optimales et la protection des informations sensibles.

L'optimisation des requêtes avec des index est un concept fondamental dans MongoDB. Un index est une structure de données permettant un accès rapide aux éléments recherchés dans une grande base de données. L'absence d'index appropriés peut entraîner des temps de réponse lents, surtout lorsque la collection de données devient volumineuse. En créant des index spécifiques, la base de données peut réduire considérablement le temps nécessaire pour exécuter des requêtes complexes, tout en facilitant la recherche, l'application de contraintes d'unicité, ainsi que l'exécution de requêtes triées ou de recherches textuelles.

Prenons l'exemple d'une recherche de chansons publiées une certaine année. Il est possible de créer un point de terminaison dédié dans FastAPI pour effectuer cette recherche, comme suit : @app.get("/songs/year"). Le code permet de filtrer les chansons par année de sortie en utilisant une requête sur le champ release_year du document. Pour accélérer cette recherche, il est possible de créer un index dédié sur ce champ. Cela se fait dans le gestionnaire de contexte lifespan du serveur, lors de son démarrage, en utilisant la méthode create_index sur le champ release_year. Une fois l'index créé, MongoDB l'utilisera automatiquement pour exécuter la requête plus rapidement.

Cependant, ces optimisations de requêtes ne sont pas seulement utiles pour améliorer la performance de l'application. Les index sont également essentiels pour la gestion de données sensibles dans MongoDB. La création d'index appropriés permet de garantir que les données sensibles, comme les informations sur les artistes ou les albums, sont bien protégées et accessibles uniquement à des fins spécifiques. La possibilité de créer des index composes ou sur des champs géospatiaux (comme les index 2D) ajoute une couche de flexibilité supplémentaire, selon les besoins spécifiques de l'application.

Il est aussi recommandé de toujours vérifier que les index sont bien utilisés lors des requêtes, en utilisant la méthode explain() sur les requêtes MongoDB. Cela permet de s'assurer que les index créés sont effectivement utilisés pour accélérer les recherches et réduire la charge sur la base de données. En analysant le résultat de explain(), on peut voir quel index a été utilisé, ce qui est crucial pour optimiser les performances sur des ensembles de données volumineux.

Pour protéger les données sensibles, MongoDB propose des méthodes de gestion avancées, comme l'agrégation des données, qui permet de masquer certaines informations ou de les combiner de manière sécurisée pour une utilisation dans l'application. Par exemple, dans le cadre d'une application de streaming musical, certaines informations relatives aux utilisateurs ou aux playlists pourraient être agrégées de manière sécurisée afin de ne pas exposer directement des données sensibles comme les identifiants ou les données personnelles.

Dans le contexte de l'application FastAPI, la mise en œuvre de ces pratiques est facilitée par l'intégration transparente de MongoDB. En utilisant les index de manière stratégique et en appliquant des mécanismes de recherche optimisés, il est possible de garantir à la fois des performances exceptionnelles et une sécurité renforcée des données. La gestion des index est essentielle non seulement pour les requêtes courantes, mais aussi pour les recherches textuelles et les exigences spécifiques liées à la protection des données.

Comment sécuriser les données sensibles dans MongoDB avec des techniques de masquage et des bonnes pratiques

Le masquage de données est une technique cruciale lorsque l’on expose des données sensibles à des tiers via une API. Dans le contexte des bases de données NoSQL comme MongoDB, cette méthode permet de protéger les informations personnelles tout en fournissant un accès aux données nécessaires à des fins commerciales ou de recherche, sans compromettre la confidentialité des utilisateurs. L’objectif de cette section est de présenter des stratégies pour sécuriser les données sensibles dans MongoDB, en appliquant des techniques de masquage de données efficaces et en suivant les meilleures pratiques en matière de sécurité des bases de données.

Dans ce contexte, l'une des premières étapes consiste à filtrer les utilisateurs n’ayant pas donné leur consentement pour le partage de leurs données comportementales. Cela peut être réalisé dans MongoDB en utilisant un pipeline d’agrégation avec une étape $redact. Ce processus permet de conserver les utilisateurs ayant consenti, tout en supprimant ceux ayant refusé, et ce, de manière efficace et précise. Le code suivant est un exemple d’agrégation visant à filtrer ces utilisateurs :

python
Copy code
pipeline_redact = {
    "$redact": {
        "$cond": {
            "if": {
                "$eq": ["$consent_to_share_data", True]
            },
            "then": "$$KEEP",
            "else": "$$PRUNE",
        }
    }
}

python
Copy code
pipeline_remove_email_and_name = {
    "$unset": ["email", "name"]
}

Pour garantir la confidentialité des informations comportementales, comme les dates des actions de l'utilisateur, on peut procéder à un masquage des données en modifiant les valeurs des dates, par exemple en obscurcissant les jours de la date. Cette transformation peut être effectuée à l’aide de la fonction $concat, combinée avec $substrCP pour isoler le mois et l’année de la date originale, et remplaçant le jour par un "XX" générique. L’agrégation suivante masque les jours des dates des actions :

python
Copy code
obfuscate_day_of_date = {

    "$concat": [
        {"$substrCP": ["$$action.date", 0, 7]},
        "-XX"
    ]
}

python
Copy code
rebuild_actions_elements = {
    "input": "$actions",
    "as": "action",
    "in": {
        "$mergeObjects": ["$$action", {"date": obfuscate_day_of_date}]
    }
}

Une fois ces étapes combinées, nous obtenons un pipeline complet permettant de masquer les données sensibles tout en exposant les informations non confidentielles pour un usage externe. Le pipeline final est défini comme suit :

python
Copy code
pipeline = [

    pipeline_redact,
    pipeline_remove_email_and_name,
    pipeline_set_actions,
]

Ce pipeline est utilisé pour créer une vue sécurisée des données sensibles dans MongoDB. Par exemple, en utilisant la commande suivante dans un script Python, vous pouvez créer cette vue dans votre base de données MongoDB, appelée users_data_view :

python
Copy code
if __name__ == "__main__":
    client["beat_streaming"].drop_collection("users_data_view")
    client["beat_streaming"].create_collection(
        "users_data_view", viewOn="users", pipeline=pipeline
    )

python
Copy code
@router.get("/users/actions")

async def get_users_with_actions(db=Depends(mongo_database)):

    users = [user async for user in db.users_data_view.find({}, {"_id": 0})]
    return users

Bien que le masquage des données soit une technique puissante, il est important de comprendre que ce n’est qu’un des nombreux moyens de sécuriser vos bases de données. D’autres mécanismes doivent être envisagés, tels que le chiffrement des données à la fois au repos et en transit, pour garantir une protection complète des informations sensibles. Le chiffrement à la fois au repos (données stockées sur disque) et en transit (données envoyées sur le réseau) est essentiel pour protéger vos données contre tout accès non autorisé, notamment dans un environnement de production où les risques sont plus élevés. En entreprise, MongoDB offre des solutions de chiffrement prêtes à l’emploi dans sa version entreprise, permettant aux architectes logiciels de choisir entre ces outils ou d’implémenter d’autres solutions selon les besoins spécifiques de leur infrastructure.