Comment déployer une application FastAPI ?

Si les fournisseurs d’hébergement sont nombreux, seuls quelques-uns proposent une interface CGI (Common Gateway Interface) ou le module mod_wsgi pour prendre en charge l’hébergement Python. Mais parmi les développeurs qui ont répondu à l’enquête Stack Overflow Developer Survey 2023, la conteneurisation avec Docker prend la tête pour le développement et le déploiement d’applications.

Pour les applications Python développées à l’aide d’un framework comme FastAPI, le déploiement via un Container-as-a-Service (CaaS) est aussi simple que de pousser votre code sur GitHub. Dans ce blog, vous apprendrez à dockeriser votre application FastAPI et à la déployer via un CaaS.

Principaux enseignements

• Docker et FastAPI forment un duo solide ; ils permettent des déploiements rationalisés et packagés avec les dépendances incluses.

• FastAPI excelle dans les opérations asynchrones, la validation des données et OpenAPI, mais ne bénéficie pas du soutien de la communauté et de la compatibilité.

• Back4app facilite le déploiement de FastAPI, en se synchronisant avec GitHub pour des mises à jour automatiques, et en offrant une configuration de base de données en nuage.

Qu’est-ce que FastAPI ?

FastAPI est un framework web Python open-source léger pour le développement d’API RESTful. Lancé en 2018, il prend en charge le modèle Pydantic et Starlette, ce qui le place au même niveau de performance que Node.js et Golang. Le framework est également personnalisable, ce qui vous permet de concevoir votre base de code de manière flexible.

Grâce à la prise en charge du schéma JSON et de l’indication de type dans les versions 3.6 et ultérieures de Python, le modèle Pydantic permet à FastAPI d’analyser facilement les données et de les valider au moment de l’exécution.

Le cadre Starlette introduit l’interface ASGI (Asynchronous Server Gateway Interface) dans FastAPI ; cela vous permet d’effectuer des opérations asynchrones dans les API RESTful de Python et d’exécuter votre code sur le serveur ASGI d’Uvicorn.

À l’instar de Nodemon dans Node.js, le serveur Uvicorn écoute les modifications apportées aux itinéraires de l’API et relance l’exécution à chaque mise à jour.

Bien que seulement 7,42% des développeurs ayant répondu à l’enquête 2023 Stack Overflow Developer Survey aient indiqué qu’ils utilisaient FastAPI, GitHub estime le nombre total d’utilisateurs à 203k. Avec plus de 498 contributeurs et 190 versions au moment de la rédaction, FastAPI reçoit des mises à jour et des correctifs réguliers.

Cependant, mettre FastAPI au même niveau de performance que Golang et Node.js est toujours un débat parmi les développeurs.

Alors que d’autres sont d’accord, certains maintiennent que bien qu’il s’agisse d’une amélioration significative pour le développement web en Python, FastAPI n’est toujours pas comparable à la performance de l’un ou l’autre.

Avantages de FastAPI

• Support des opérations asynchrones: Outre les opérations synchrones par défaut de Python, FastAPI prend en charge les déclarations de fonctions utilisant async/await. Grâce à Starlette, qui confère également la prise en charge de WebSocket. Cela ajoute de la concurrence à votre programme, permettant à votre application d’effectuer d’autres opérations en attendant des opérations plus lentes comme les requêtes de base de données.

• Support pour la validation des données: En utilisant le Pydantic BaseModel, FastAPI exploite les indices de type de données de Python pour maintenir la rigueur lors de l’analyse des données. Cela empêche le mauvais type de données d’entrer dans la base de données. Ainsi, contrairement aux modèles dynamiques nécessitant des bibliothèques de validation supplémentaires, la validation du modèle est simple et facilement disponible dans FastAPI.

• Entièrement normalisé: FastAPI est conforme à la spécification OpenAPI pour le service d’API HTTP sur le web, ce qui permet aux applications grand public et aux clients de comprendre facilement l’API qu’ils souhaitent utiliser. Sous le capot, elle utilise également la déclaration JSON Schema pour s’assurer que les données soumises par les utilisateurs sont valides avant de les soumettre à la base de données.

• Flexibilité: Contrairement à Django, FastAPI ne limite pas le développeur à une norme architecturale de base de code particulière. Au lieu de cela, il laisse cette décision au développeur. Ainsi, vous pouvez concevoir votre base de code avec des conventions de nommage flexibles et déclarer les paramètres généraux de l’application et les suites de tests unitaires en cours de route. La modularisation du code et la séparation des préoccupations (SOC) sont également simples.
  
  Et si vous utilisez la programmation orientée objet (POO), ce que nous recommandons, vous pouvez facilement composer vos modèles dans vos classes d’extrémité. Au fur et à mesure que vous construisez, l’ajout de points d’extrémité d’API à vos itinéraires est également simple.

• La courbe d’apprentissage est facile: Malgré une communauté d’utilisateurs plus réduite que celle de frameworks comme Flask et Django, FastAPI se distingue par sa documentation et ses tutoriels très complets. Avec un bagage de développement, en particulier en Python ou en JavaScript, vous pouvez facilement le prendre en main. Sa simplicité et sa flexibilité contribuent à accélérer les processus de développement.

Limites

• Faible soutien de la communauté: FastAPI n’a pas beaucoup d’utilisateurs comme Django ou Flask. Elle est encore relativement nouvelle. Le soutien de la communauté est donc plus faible, ce qui peut être un défi, en particulier pour les nouveaux développeurs.

• Compatibilité de version limitée: FastAPI ne prend en charge que les versions ultérieures de Python, à partir de Python 3.6. Par conséquent, les machines ou serveurs utilisant des versions de Python antérieures à la version 3.6 doivent être mis à jour pour installer et exécuter FastAPI avec succès.

Options de déploiement de FastAPI

L’infrastructure en tant que service (IaaS) et le conteneur en tant que service (CaaS) sont des infrastructures en nuage évolutives pour le déploiement d’applications.

Bien que vous puissiez déployer une application FastAPI via un serveur privé virtuel (VPS) ou un hébergement partagé, aucun n’est aussi évolutif qu’un IaaS ou un CaaS.

IaaS

Un IaaS est une plateforme qui fournit des ressources informatiques à la demande dans le nuage. Elle fournit toutes les ressources virtualisées nécessaires à la mise en place d’un serveur de déploiement pour votre application, généralement sur la base d’un paiement à l’utilisation.

Outre l’infrastructure informatique, l’IaaS comprend le stockage et d’autres ressources réseau telles que les équilibreurs de charge, les VPN, les pare-feu, la gestion des DNS, etc. Vous êtes responsable de la gestion de votre environnement informatique et pouvez personnaliser ou faire évoluer ses ressources en fonction des besoins de votre application.

CaaS

Un CaaS est une plateforme en tant que service (PaaS) qui vous permet de déployer votre application dans le nuage sous forme de conteneurs. Contrairement à un IaaS, un CaaS gère toutes les bases de calcul nécessaires à l’hébergement de votre application sous le capot.

Il s’agit notamment de l’environnement d’exécution des conteneurs, de l’orchestration, du stockage, de l’équilibrage de la charge, etc. Ainsi, vous pouvez vous concentrer sur la création de votre application plutôt que de vous préoccuper de la gestion de l’infrastructure.

Comme vous déployez votre application sous forme de conteneur, l’intégration CI/CD est simple et ne nécessite aucune configuration technique. Les mises en service et les mises à jour de l’application sont ainsi plus rapides.

Processus de déploiement de l’API FAST

Nous allons passer en revue le processus de déploiement étape par étape, en commençant par les prérequis. Mais comme nous allons déployer notre application FastAPI en utilisant les conteneurs Back4App, voyons rapidement ce qu’ils sont avant de continuer.

Aperçu des conteneurs Back4app

Back4App Containers est une plateforme cloud qui vous permet de déployer rapidement des applications dockerisées dans le cloud. La plateforme se synchronise avec votre dépôt GitHub et met automatiquement à jour votre déploiement chaque fois que vous poussez une version. Elle permet ainsi d’éliminer les mises à jour manuelles des conteneurs et les temps d’arrêt des serveurs.

Avec Back4App Containers, vous n’avez qu’à pousser votre code et les versions ultérieures sur GitHub depuis votre machine locale, et la plateforme gère l’orchestration de l’image du conteneur sous le capot. Back4App propose également un suivi des déploiements en temps réel et une journalisation en temps réel.

Vous pouvez ainsi retracer les étapes du déploiement et déterminer le point de défaillance, s’il y en a un. Et si votre application se bloque à l’exécution, ce qui peut arriver pour un langage interprété comme Python, la journalisation en temps réel vous aide à tracer les erreurs dans la console pour les corriger rapidement.

Voici les principales caractéristiques de Back4App :

• Synchronisez facilement votre application Back4App avec votre dépôt de code sur GitHub.

• Déployez votre application sur le cloud via un conteneur Back4App en poussant votre code et les mises à jour ultérieures vers votre dépôt GitHub.

• Tout ce dont vous avez besoin est un fichier Docker. Back4App gère toutes les installations de dépendances pour vous.

• Cryptez facilement vos variables d’environnement lors du déploiement et des versions ultérieures.

• Contrôlez les déploiements en temps réel et gérez les retours en arrière.

• Surveillez l’historique de l’utilisation de vos applications à l’aide de journaux en temps réel.

• Déployer des applications mobiles et web dans le nuage

Télécharger et installer Python

Nous utiliserons Python 3.10.6 dans ce blog. Mais vous pouvez utiliser n’importe quelle version de Python qui n’est pas antérieure à la 3.6. Allez sur python.org pour télécharger et installer la dernière version de Python compatible avec votre système d’exploitation – si vous ne l’avez pas déjà fait. Sinon, ignorez cette section.

Une fois téléchargé, cliquez sur le fichier d’installation et suivez les instructions à l’écran pour installer Python sur votre machine locale.

Veillez à cocher l’option Add python.exe to PATH pour ajouter Python au chemin de votre variable système, ce qui le rend exécutable via la ligne de commande.

Si vous utilisez un Mac, il est déjà livré avec Python 2.7 par défaut. Vous pouvez le mettre à jour avec la dernière version en utilisant Homebrew via le terminal :

brew install python3

Exécutez la commande suivante dans votre terminal pour vérifier votre version de Python.

python --version

Activer un environnement virtuel Python et installer FastAPI

Ensuite, créez un nouveau répertoire de projet et ouvrez la ligne de commande vers ce dossier. Activez ensuite un environnement virtuel Python à l’aide de venv.

Ce paquetage est livré avec Python et ne nécessite aucune installation. Il vous permet de gérer les dépendances de Python de manière isolée plutôt que de les installer globalement.

Exécutez la commande suivante dans le terminal pour créer un environnement virtuel, en remplaçant env_name par le nom de votre environnement préféré.

py -m venv env_name

Exécutez la commande suivante pour activer l’environnement virtuel.

.\env_name\Scripts\activate

Installer FastAPI et Uvicorn

L’étape suivante consiste à installer le cadre FastAPI et le moteur d’exécution du serveur Uvicorn dans l’environnement virtuel actif. Pydantic et Starlette sont également installés.

Créez un fichier requirements.txt à la racine de votre projet et entrez les paquets à installer, comme indiqué ci-dessous.

fastapi
uvicorn

Vous trouverez ci-dessous la démonstration en VSCode. Vous pouvez ajouter d’autres dépendances à ce fichier si nécessaire.

Exécutez la commande suivante via le terminal pour installer les dépendances listées. Assurez-vous que l’environnement virtuel est toujours actif.

pip install install -r requirements.txt

La commande installe le paquet spécifié comme indiqué ci-dessous.

Une fois installé, mettez à jour le fichier requirements.txt à l’aide de la commande suivante :

pip freeze > requirements.txt

La commande ci-dessus remplace le fichier requirements.txt par les dépendances installées, y compris leurs numéros de version corrects. Veillez à effectuer cette opération chaque fois que vous installez une nouvelle dépendance dans votre environnement virtuel.

Le fichier requirements.txt se présente comme suit après la mise à jour :

Introduction du projet

Nous allons écrire une simple application FastAPI “Hello World” et la déployer en utilisant les conteneurs gratuits Back4App. Pas d’inquiétude si votre projet est complexe. Le déploiement se fait de la même manière et vous bénéficiez d’une disponibilité mensuelle gratuite.

Toutefois, si votre application traite de nombreuses demandes quotidiennement, vous souhaiterez peut-être procéder à une mise à niveau après le déploiement afin d’offrir à vos visiteurs une expérience utilisateur plus fluide sans aucun temps d’arrêt.

Code de l’application

Créez un nouveau répertoire routeur dans le dossier racine de votre projet et créez un fichier main.py dans ce répertoire. Ce fichier gère les points d’extrémité de l’API de votre application et le routeur. Passez à la section suivante si vous avez déjà un projet à déployer.

Voici le code “Hello World” :

from fastapi import FastAPI, APIRouter
import uvicorn

app = FastAPI()
class HelloWorld():
    def read_hello(self):
        return {"data": "Hello World"}
router = APIRouter()
router.add_api_route('/api/v2/hello-world', 
endpoint = HelloWorld().read_hello, methods=["GET"])
app.include_router(router)

if __name__ == "__main__":
   uvicorn.run("main:app", host="127.0.0.1", port=8000, reload=True)

Pour lancer le serveur uvicorn et tester le point de terminaison de l’API hello-world, exécutez le fichier main.py via la ligne de commande :

python main.py

Ceci démarre le serveur de développement sur le port 8000 comme spécifié.

Comme il s’agit d’une requête GET, nous pouvons la tester directement sur n’importe quel navigateur web. Voici le résultat.

Dockeriser l’application

Ensuite, créez un Dockerfile dans le dossier racine de votre projet. Vous pouvez le faire en créant un nouveau fichier dans VS Code et en le nommant Dockerfile.

Une fois créé, tapez les commandes suivantes pour créer une image Docker :

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 8000
CMD ["uvicorn", "router.main:app", "--host", "0.0.0.0", "--port", "8000"]

Pousser vers GitHub

Rendez-vous sur votre compte GitHub et allez dans la rubrique Dépôts. Créez un nouveau dépôt en cliquant sur Nouveau en haut à droite.

Rendez-vous sur votre compte GitHub et allez dans la rubrique Dépôts. Créez un nouveau dépôt en cliquant sur Nouveau en haut à droite.

Si vous avez déjà poussé votre code sur GitHub, ajoutez le fichier Docker à la copie sur votre machine locale et repoussez vers votre dépôt.

Donnez un nom à votre référentiel et cliquez sur Créer un référentiel en bas à droite.

Ensuite, initialiser un référentiel local en utilisant la commande init comme indiqué :

git init

Ignorez le dossier venv et votre fichier .env en utilisant .gitignore pour éviter de les pousser dans votre dépôt. Pour ce faire, créez un fichier .gitignore dans le dossier racine de votre projet et entrez les dossiers et les fichiers que vous souhaitez ignorer, comme indiqué ci-dessous.

Exécutez les commandes suivantes dans votre terminal, l’une après l’autre, pour pousser votre code dans votre dépôt.

1. git add .
2. git commit -m "commit message"
3. git branch -m main
4. git remote add origin <URL of the created repository>
5. git push -u origin main

Déployer l’application avec un conteneur Back4App

Si vous ne l’avez pas encore fait, assurez-vous de créer un nouveau compte Back4App. Pour accélérer le processus, utilisez l’option de connexion Google ou GitHub .

Une fois connecté, cliquez sur le widget Construire une nouvelle application.

Allez à Conteneurs en tant que service.

Sur la page suivante, cliquez sur Import GitHub Repo. Accordez à GitHub la permission d’autoriser Back4App lorsque vous y êtes invité.

Sous Accès au référentiel, dans la fenêtre modale ouverte, cliquez sur Sélectionner les référentiels. Sélectionnez le référentiel contenant le projet que vous souhaitez déployer et cliquez sur Enregistrer.

Back4App synchronisera automatiquement le dépôt sélectionné. Une fois redirigé vers Back4App, cliquez sur Select à droite du dépôt GitHub ajouté. Ensuite, remplissez le champ App Name avec votre nom d’application préféré.

Si votre application FastAPI a des secrets masqués dans un fichier .env, cliquez sur Variables d’environnement pour saisir vos variables d’environnement. Cliquez sur Ajouter une variable et saisissez le nom de votre variable en utilisant des caractères majuscules.

Veillez à utiliser la même convention de dénomination que les variables du fichier .env de votre projet afin d’éviter les erreurs de nom.

Cette étape permet de crypter et d’ajouter vos valeurs variables à votre déploiement. Enfin, cliquez sur Create App pour déployer votre application FastAPI.

L’instance de déploiement de l’application FastAPI fonctionne comme indiqué ci-dessous.

Pour afficher la version en direct de votre application, cliquez sur l’URL dans la barre latérale de gauche. En allant sur https://testapp-omisolaidowu.b4a.run/api/v2/hello-world, dans ce cas, vous obtiendrez la réponse attendue.

Conclusion

Développer une application à l’aide de l’interface FastAPI de Python est une chose. Mais c’en est une autre de la déployer de manière transparente pour servir les clients.

En plus de permettre un déploiement plus rapide, le CaaS est moins technique. Vous avez vu comment déployer une application FastAPI, mais ce n’est pas tout.

Vous pouvez déployer l’application côté client sur une instance de conteneur séparée et vous connecter aux points d’extrémité FastAPI en utilisant l’URL générée comme URL de base.

Si vous avez aimé cet article, consultez notre tutoriel sur le déploiement d’une application Flask.