Nous commencerons par découvrir les principales fonctionnalités de FastAPI et ses cas d'utilisation clés. Ensuite, nous exécuterons notre première application et la mettrons à l'essai ! Enfin, nous verrons en détail comment prendre en charge les opérations GET et POST avec des paramètres de requête, puis nous créerons et testerons ces points de terminaison.

Pourquoi choisir FastAPI?

Première application

FastAPI ou Django

Opérations GET

Bonjour le monde

Bonjour qui?

Opérations POST

Modèle Pydantic

Opération POST en action

Notions de base de FastAPI

Nous commencerons par apprendre à prendre en charge les opérations PUT et DELETE avec FastAPI. Puis nous verrons comment traiter différents types d'erreurs et toujours retourner un code d'état approprié dans la réponse. Enfin, nous apprendrons à utiliser async pour permettre des requêtes concurrentes capables de gérer une charge plus élevée.

Opérations PUT et DELETE

Opération PUT en action

Opération DELETE en action

Gestion des erreurs

Classification des codes d'état

Gérer une erreur côté client

Utiliser async pour exécuter des tâches en parallèle

Quand devrait-on utiliser async ?

Opération DELETE asynchrone

Sujets avancés de FastAPI

Nous commencerons par apprendre à écrire des tests système pour valider des points de terminaison FastAPI individuels. Ensuite, nous construirons une API JSON CRUD complète pour gérer le cycle de vie des objets via HTTP. Enfin, nous verrons comment tester différents points de terminaison de l'application ensemble au moyen de tests fonctionnels manuels.

Tests automatisés avec FastAPI

Options

Tests unitaires

Tests système

Tests unitaires vs tests système

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional

# define model Item
class Item(BaseModel):
    name: str
    quantity: Optional[int] = 0

app = FastAPI()

items = {"scissors": Item(name="scissors", quantity=100)}


@app.get("/items")
def read(name: str):
    if name not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    return items[name]

# Import TestClient
from fastapi.testclient import ____
from main import app

# Create test client with application context
client = TestClient(____)

def test_main():
    response = client.get("/items?name=scissors")
    assert response.status_code == 200
    assert response.json() == {"name": "scissors",
                               "quantity": ____}

# Import TestClient
from fastapi.testclient import TestClient
from main import app

# Create test client with application context
client = TestClient(app)

def test_main():
    response = client.get("/items?name=scissors")
    assert response.status_code == 200
    assert response.json() == {"name": "scissors",
                               "quantity": 100}

Essai système

Créer une API JSON CRUD

Créer

Lire

Mettre à jour

Opérations HTTP et étapes CRUD

Réponse à l'opération DELETE

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional

# define model Item
class Item(BaseModel):
    name: str
    quantity: Optional[int] = 0

app = FastAPI()

items = {}


@app.____("/items")
def create(item: Item):
    name = item.name
    if name in items:
        raise HTTPException(status_code=409, detail="Item exists")
    items[name] = item
    return {"message": f"Added {name} to items."}
  
@app.____("/items")
def read(name: str):
    if name not in items:
        raise HTTPException(status_code=____, detail="Item not found")
    return items[name]  
  
@app.____("/items")
def update(item: Item):
    name = item.name
    if name not in items:
        raise HTTPException(status_code=____, detail="Item not found")
    items[name] = item
    return {"message": f"Updated {name}."}
  
@app.delete("/items")
def delete(item: Item):
    name = item.name
    if name not in items:
        raise HTTPException(status_code=____, detail="Item not found")
    del items[name]
    return {"message": f"Deleted {name}."}

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional

# define model Item
class Item(BaseModel):
    name: str
    quantity: Optional[int] = 0

app = FastAPI()

items = {}


@app.post("/items")
def create(item: Item):
    name = item.name
    if name in items:
        raise HTTPException(status_code=409, detail="Item exists")
    items[name] = item
    return {"message": f"Added {name} to items."}
  
@app.get("/items")
def read(name: str):
    if name not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    return items[name]  
  
@app.put("/items")
def update(item: Item):
    name = item.name
    if name not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    items[name] = item
    return {"message": f"Updated {name}."}
  
@app.delete("/items")
def delete(item: Item):
    name = item.name
    if name not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    del items[name]
    return {"message": f"Deleted {name}."}

API JSON CRUD complète

Rédiger un test fonctionnel manuel

Tests fonctionnels

Tests système vs tests fonctionnels

import requests

ENDPOINT = "http://localhost:8000/items"

# Create item "rock" without providing quantity
r = requests.post(ENDPOINT, json={"name": "rock"})
assert r.status_code == ____
assert r.json()["message"] == "Added rock to items."

# Verify that item "rock" has quantity 0
r = requests.get(ENDPOINT + "?____=____")
assert r.status_code == 200
assert r.json()["quantity"] == 0

# Update item "rock" with quantity 100
r = requests.put(ENDPOINT, json={"name": "rock", "quantity": 100})
assert r.status_code == 200
assert r.json()["message"] == "Updated rock."

# Verify that item "rock" has quantity 100
r = requests.get(ENDPOINT + "?name=rock")
assert r.status_code == 200
assert r.json()["quantity"] == ____

# Delete item "rock"
r = requests.delete(ENDPOINT, json={____: ____})
assert r.status_code == 200
assert r.json()["message"] == "Deleted rock."

# Verify that item "rock" does not exist
r = requests.get(ENDPOINT + "?name=rock")
assert r.status_code == ____

print("Test complete.")

import requests

ENDPOINT = "http://localhost:8000/items"

# Create item "rock" without providing quantity
r = requests.post(ENDPOINT, json={"name": "rock"})
assert r.status_code == 200
assert r.json()["message"] == "Added rock to items."

# Verify that item "rock" has quantity 0
r = requests.get(ENDPOINT + "?name=rock")
assert r.status_code == 200
assert r.json()["quantity"] == 0

# Update item "rock" with quantity 100
r = requests.put(ENDPOINT, json={"name": "rock", "quantity": 100})
assert r.status_code == 200
assert r.json()["message"] == "Updated rock."

# Verify that item "rock" has quantity 100
r = requests.get(ENDPOINT + "?name=rock")
assert r.status_code == 200
assert r.json()["quantity"] == 100

# Delete item "rock"
r = requests.delete(ENDPOINT, json={"name": "rock"})
assert r.status_code == 200
assert r.json()["message"] == "Deleted rock."

# Verify that item "rock" does not exist
r = requests.get(ENDPOINT + "?name=rock")
assert r.status_code == 404

print("Test complete.")

Test fonctionnel

Conclusion

Créer et tester une API JSON CRUD

Ce cours vous apprend à créer des applications Web de qualité production avec FastAPI, un cadre Python populaire pour concevoir des API. Vous apprendrez à gérer les quatre opérations HTTP, à définir des schémas de requête et de réponse, à valider les requêtes d'API et à retourner les codes d'état HTTP appropriés. Vous verrez aussi l'exécution asynchrone pour améliorer les performances et, au terme du cours, vous développerez une API CRUD et testerez vos enchaînements avec le module requests de Python. Conçu pour des programmeurs Python d'expérience, ce cours vous donne les compétences pour gérer des données avec FastAPI et vous prépare à bâtir des pipelines robustes de gestion des données et de déploiement de modèles de ML.

<h2>Introduction à FastAPI et à ses applications</h2> Les API sont couramment utilisées pour gérer des données sur le Web, et FastAPI est un nouveau framework Web populaire pour créer des API avec Python. Les ingénieurs en données et en apprentissage automatique utilisent FastAPI pour créer des applications qui servent de transactions et de pipelines de données contextuels sur le Web.<br><br> <h2>Créer des applications Web de niveau production avec FastAPI</h2> Dans ce cours, vous apprendrez à créer des applications Web de niveau production en tirant parti de vos compétences en Python avec le framework FastAPI. À la fin, vous comprendrez les principaux cas d’utilisation de FastAPI par rapport aux autres frameworks Web Python. Vous apprendrez à créer des API en utilisant les quatre types d’opérations HTTP et à définir des schémas de requête et de réponse. De plus, vous validerez les requêtes API, répondrez avec les codes d’état HTTP et les messages appropriés, et exécuterez le code de manière asynchrone afin d’améliorer les performances de l’application. Un projet pratique vous guidera dans la création d’une API CRUD classique (Create, Read, Update, Delete) et dans le test des flux de travail à l’aide du module requests de Python.<br><br> <h2>Objectifs du cours et public cible</h2> Ce cours est conçu pour les programmeurs Python expérimentés qui souhaitent créer des applications Web qui gèrent des données à l’aide de FastAPI. À la fin de ce cours, vous aurez les bases nécessaires pour créer des projets FastAPI adaptés à la gestion de données à haut débit et aux pipelines de diffusion de modèles de ML.

Introduction to APIs in Python

Introduction to Object-Oriented Programming in Python

Créez des API robustes avec FastAPI, maîtrisez HTTP, validation et exécution asynchrone pour pipelines.

Opérations HTTP et étapes CRUD

Introduction à FastAPI

Exercice interactif pratique