Nous commencerons par découvrir les principales fonctionnalités de FastAPI et ses cas d’usage. Ensuite, nous exécuterons notre première application et la testerons. 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 construirons et testerons ces endpoints.

Pourquoi FastAPI ?

Première application

FastAPI vs Django

Opérations GET

Bonjour tout le monde

Bonjour qui ?

Opérations POST

Modèle Pydantic

Opération POST en pratique

Notions de base de FastAPI

Nous commencerons par apprendre à gérer les opérations PUT et DELETE avec FastAPI. Puis nous verrons comment traiter différents types d’erreurs et toujours renvoyer un code d’état approprié dans la réponse. Pour finir, nous apprendrons à utiliser async pour permettre des requêtes concurrentes capables de supporter des charges plus élevées.

Opérations PUT et DELETE

from fastapi import FastAPI
from pydantic import BaseModel

# Define model Item
class Item(BaseModel):
    ____: str
    ____: str

# Define items at application start
items = {"bananas": "Yellow fruit."}

app = FastAPI()


@app.put("/items")
def update_item(item: Item):
    name = item.name
    # Update the description
    items[____] = item.____
    return item

from fastapi import FastAPI
from pydantic import BaseModel

# Define model Item
class Item(BaseModel):
    name: str
    description: str

# Define items at application startup
items = {"bananas": "Yellow fruit."}

app = FastAPI()


@app.put("/items")
def update_item(item: Item):
    name = item.name
    # Update the description
    items[name] = item.description
    return item

Mettre en pratique l’opération PUT

from fastapi import FastAPI
from pydantic import BaseModel

# Define model Item
class Item(BaseModel):
    ____: str

# Define items at application start
items = {"apples", "oranges", "bananas"}

app = FastAPI()


@app.delete("/items")
def delete_item(item: Item):
    name = item.name
    # Delete the item
    items.remove(____)
    return {}

from fastapi import FastAPI
from pydantic import BaseModel

# Define model Item
class Item(BaseModel):
    name: str

# Define items at application startup
items = {"apples", "oranges", "bananas"}

app = FastAPI()


@app.delete("/items")
def delete_item(item: Item):
    name = item.name
    # Delete the item
    items.remove(name)
    return {}

Opération DELETE en pratique

Gérer les erreurs

Options

Réussite

Pas une réussite

Classification des codes d’état

from fastapi import FastAPI, ____
from pydantic import BaseModel

# Define model Item
class Item(BaseModel):
    name: str

# Define items at application startup
items = {"apples", "oranges"}

app = FastAPI()


@app.delete("/items")
def delete_item(item: Item):
    name = item.name
    if name in items:
        items.remove(name)
    else:
        # Raise HTTPException with status code for "not found"
        raise ____(status_code=____, detail="Item not found.")
    return {}

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

# Define model Item
class Item(BaseModel):
    name: str

# Define items at application startup
items = {"apples", "oranges"}

app = FastAPI()


@app.delete("/items")
def delete_item(item: Item):
    name = item.name
    if name in items:
        items.remove(name)
    else:
        # Raise HTTPException with status code for "not found"
        raise HTTPException(status_code=404, detail="Item not found.")
    return {}

Gérer une erreur côté client

Utiliser async pour traiter des tâches en parallèle

Quand faut-il utiliser async ?

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

# Define model Item
class Item(BaseModel):
    name: str

app = FastAPI()

items = {"rock", "paper", "scissors"}


@app.delete("/items")
# Make asynchronous
____ def root(item: Item):
    name = item.name
    # Check if name is in items
    if ____ not in ____:
        # Return the status code for not found
        raise HTTPException(status_code=___, detail="Item not found.")
    items.remove(name)
    return {"message": "Item deleted"}

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

# Define model Item
class Item(BaseModel):
    name: str

app = FastAPI()

items = {"rock", "paper", "scissors"}


@app.delete("/items")
# Make asynchronous
async def root(item: Item):
    name = item.name
    # Check if name is in items
    if name not in items:
        # Return the status code for not found
        raise HTTPException(status_code=404, detail="Item not found.")
    items.remove(name)
    return {"message": "Item deleted"}

Opération DELETE asynchrone

Sujets avancés de FastAPI

Nous commencerons par apprendre à écrire des tests système pour valider des endpoints 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 le fonctionnement conjoint de différents endpoints de l’application avec des tests fonctionnels manuels.

Tests automatisés avec FastAPI

Tests unitaires vs tests système

Test système

Créer une API JSON CRUD

Opérations HTTP et étapes CRUD

Réponse à une opération DELETE

API JSON CRUD complète

Écrire un test fonctionnel manuel

Tests système vs tests fonctionnels

Test fonctionnel

Récapitulatif

Créer et tester une API JSON CRUD

Ce cours vous apprend à créer des applications web de niveau production avec FastAPI, un framework Python populaire pour construire 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 à renvoyer des codes d’état HTTP appropriés. Vous verrez aussi l’exécution asynchrone pour améliorer les performances et, à la fin, vous développerez une API CRUD et testerez les workflows avec le module requests de Python. Conçu pour des programmeurs Python expérimentés, ce cours vous donne les compétences pour gérer des données avec FastAPI et vous prépare à construire des pipelines robustes de gestion des données et de déploiement de modèles de Machine Learning.

<h2>Présentation de FastAPI et de ses applications</h2> Les API sont couramment utilisées pour gérer les données sur le Web, et FastAPI est un nouveau framework Web populaire permettant de 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 pipelines et de transactions de données contextuelles sur le Web.<br><br> <h2>Développement d'applications web de qualité production avec FastAPI</h2> Dans ce cours, vous apprendrez à développer des applications web de qualité professionnelle en utilisant vos compétences en Python avec le framework FastAPI. À la fin, vous maîtriserez 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êtes et de réponses. 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 (Créer, Lire, Mettre à jour, Supprimer) classique et dans le test des workflows à l'aide du module requests de Python.<br><br> <h2>Objectifs du cours et public cible</h2> Ce cours est destiné aux programmeurs Python expérimentés qui souhaitent développer des applications web gérant des données à l'aide de FastAPI. À l'issue de ce cours, vous disposerez des bases nécessaires pour créer des projets FastAPI adaptés à la gestion de données à haut débit et aux pipelines de modèles 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.

Classification des codes d’état

Exercice interactif pratique