Pourquoi Deployer FastAPI sur DigitalOcean ?
Deployer FastAPI sur DigitalOcean est une excellente solution pour plusieurs raisons pratiques et techniques.
Dans un contexte professionnel, les développeurs ont souvent besoin de déployer leurs applications web rapidement et efficacement, surtout lorsqu'elles sont construites avec des frameworks comme FastAPI qui offrent des avantages tels que la rapidité d'exécution, le développement asynchrone et une API intuitive.
Un cas concret serait un service de gestionnaire de tâches où les utilisateurs peuvent créer, lire, mettre à jour et supprimer des tâches en temps réel. Un tel service nécessite une haute disponibilité et une performance optimale, ce qui est parfaitement assuré par DigitalOcean.
Prerequis
- Connaissance approfondie de Python
- Familiarité avec FastAPI
- Compréhension des bases du déploiement web
- Installation de Docker (pour les applications conteneurisées)
- Un compte DigitalOcean
Concepts fondamentaux
1. Infrastructure as Code (IaC)
L'Infrastructure as Code permet de définir et de gérer l'infrastructure logicielle en tant que code source. Cela permet une meilleure gestion des ressources, la versionnage, la collaboration et le déploiement.
Code IaC :
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
async def read_root():
return {"message": "Bienvenue sur votre application FastAPI"}
2. Dockerfile
Un Dockerfile est un script qui contient toutes les instructions nécessaires pour créer une image Docker.
Dockerfile :
## Utilisation d'une image Python officielle comme base
FROM python:3.9-slim
## Copie du fichier requirements.txt dans le conteneur
COPY requirements.txt .
## Installation des dépendances
RUN pip install -r requirements.txt
## Copie de l'application FastAPI dans le conteneur
COPY . /app
WORKDIR /app
## Commande pour exécuter l'application
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
3. DigitalOcean Droplet
Un Droplet est un serveur virtuel sur DigitalOcean. Il peut être configuré pour exécuter n'importe quel système d'exploitation et héberger n'importe quelle application.
Commande pour créer un Droplet avec l'API :
doctl compute droplet create my-fastapi-app --image ubuntu-20-04-x64 --size s-1vcpu-1gb --region fra1 --ssh-keys $(doctl auth list | awk '/^ID/ {print $2}')
Mise en pratique : Projet fil rouge
Étape 1 : Création du projet
Créez un nouveau répertoire pour votre projet et initialisez-le avec git.
mkdir fastapi-app && cd fastapi-app
git init
Étape 2 : Installation des dépendances
Créer un fichier requirements.txt et y ajouter FastAPI, Uvicorn et Docker.
requirements.txt :
fastapi==0.78.0
uvicorn[standard]==0.15.3
docker-py==4.4.4
Étape 3 : Création du code FastAPI
Créez un fichier main.py avec le code suivant :
main.py :
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
async def read_root():
return {"message": "Bienvenue sur votre application FastAPI"}
Étape 4 : Création du Dockerfile
Créez un fichier Dockerfile avec le code suivant :
Dockerfile :
FROM python:3.9-slim
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . /app
WORKDIR /app
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
Étape 5 : Construction de l'image Docker
Construisez l'image Docker à partir du Dockerfile.
docker build -t my-fastapi-app .
Étape 6 : Exécution de l'application Docker
Exécutez votre application FastAPI dans un conteneur Docker.
docker run -d -p 8000:8000 --name fastapi-app-container my-fastapi-app
Étape 7 : Vérification du déploiement
Accédez à http://<votre-IP>:8000 dans votre navigateur pour vérifier que l'application est bien déployée.
Erreurs frequentes et debugging
Erreur 1 : docker build échoue avec error loading manifest: not found
Code incorrect :
docker build -t my-fastapi-app .
Correction : Assurez-vous que votre Dockerfile est bien présent dans le répertoire courant et qu'il n'y a pas d'erreurs syntaxiques.
Erreur 2 : uvicorn ne démarre pas avec une erreur ModuleNotFoundError
Code incorrect :
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
async def read_root():
return {"message": "Bienvenue sur votre application FastAPI"}
Correction :
Assurez-vous que toutes les dépendances nécessaires sont installées dans le requirements.txt et que le fichier est correctement nommé.
Pour aller plus loin
1. Utilisation de Docker Compose pour la gestion des services
Docker Compose permet de définir et de gérer plusieurs conteneurs en un seul fichier, simplifiant la gestion de l'infrastructure.
docker-compose.yml :
version: '3'
services:
web:
build: .
ports:
- "8000:8000"
volumes:
- .:/app
2. Intégration avec DigitalOcean Kubernetes (DOCS)
Pour une application plus complexe, il peut être utile d'utiliser DigitalOcean Kubernetes pour automatiser le déploiement et la gestion des conteneurs.
3. Utilisation de FastAPI avec OAuth 2.0
FastAPI offre des fonctionnalités intégrées pour gérer l'authentification et l'autorisation, y compris OAuth 2.0. Cela peut être utilisé pour sécuriser votre API.
Défi pratique : Créez une application FastAPI qui utilise OAuth 2.0 pour protéger les endpoints. Utilisez DigitalOcean Kubernetes pour déployer et mettre à l'échelle cette application.