Deployer FastAPI sur Azure

Pourquoi Déployer FastAPI sur Azure ?

FastAPI est un framework moderne et performant pour construire des APIs rapides en Python. Cependant, son déploiement peut être complexe pour certains développeurs. Azure propose une solution complète pour déployer des applications Python, y compris FastAPI. Ce tutoriel vous guide à travers le processus de déploiement d'une application FastAPI sur Azure.

Contexte Réel

En tant que développeur backend, avoir la possibilité de déployer votre application sur une plateforme cloud renforce la scalabilité et la disponibilité. Azure offre des services robustes pour héberger des applications Python, y compris FastAPI.

Cas d'Usage Concret

Imaginez que vous développez une application de gestion de tâches pour une entreprise. Vous avez besoin d'une API pour créer, lire, mettre à jour et supprimer des tâches. En déployant cette API sur Azure, vous pouvez assurer sa disponibilité 24/7 et l'échellez en fonction du nombre d'utilisateurs.

Prerequis

• Connaissance de base de Python (3.6+)
• Connaissance de FastAPI
• Un compte Azure
• Visual Studio Code (ou un éditeur de code favori)
• Git

Concepts Fondamentaux

1. Azure App Service

Azure App Service est une plateforme PaaS pour le déploiement et l'hébergement des applications web, des API et des microservices.

## Installer Azure CLI
az login

2. Azure Storage

Azure Storage offre un service de stockage objet réellement durant la durée du cycle de vie de vos données.

from azure.storage.blob import BlobServiceClient

## Connexion au compte de stockage
blob_service_client = BlobServiceClient.from_connection_string("your_connection_string")

3. Azure Container Registry (ACR)

Azure Container Registry est un service pour stocker des images Docker privées et sécurisées.

## Créer une instance d'ACR
az acr create --resource-group your_resource_group --name your_acr_name --sku Basic

4. Azure Kubernetes Service (AKS)

Azure Kubernetes Service permet de déployer, gérer et mettre à l'échelle des applications sur un cluster Kubernetes managé.

## Créer un cluster AKS
az aks create --resource-group your_resource_group --name your_aks_name --node-count 1 --generate-ssh-keys

Mise en Pratique : Projet Fil Rouge

Nous allons créer une application FastAPI simple qui permet de gérer des tâches. Voici les étapes pour construire cette application.

Étape 1: Créer un Nouveau Projet FastAPI

## Créer un nouveau projet FastAPI
mkdir task_manager && cd task_manager
python -m venv venv
source venv/bin/activate  # Sur Windows utilisez `venv\Scripts\activate`
pip install fastapi uvicorn

Étape 2: Créer les Fichiers du Projet

## Structure du projet
mkdir app
touch app/main.py
touch requirements.txt
touch .env

Étape 3: Configurer requirements.txt

fastapi
uvicorn
python-dotenv

Étape 4: Écrire le Code de l'API

## app/main.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from dotenv import load_dotenv
import os

load_dotenv()

app = FastAPI()

tasks = []

class Task(BaseModel):
    id: int
    title: str
    description: str

@app.post("/tasks/", response_model=Task)
async def create_task(task: Task):
    task.id = len(tasks) + 1
    tasks.append(task)
    return task

@app.get("/tasks/{task_id}", response_model=Task)
async def read_task(task_id: int):
    for task in tasks:
        if task.id == task_id:
            return task
    raise HTTPException(status_code=404, detail="Task not found")

@app.put("/tasks/{task_id}", response_model=Task)
async def update_task(task_id: int, task_update: Task):
    for i, task in enumerate(tasks):
        if task.id == task_id:
            tasks[i] = task_update
            return tasks[i]
    raise HTTPException(status_code=404, detail="Task not found")

@app.delete("/tasks/{task_id}")
async def delete_task(task_id: int):
    global tasks
    tasks = [task for task in tasks if task.id != task_id]
    return {"message": "Task deleted"}

Étape 5: Lancer l'API Localement

## Lancer l'application FastAPI
uvicorn app.main:app --reload

Étape 6: Créer un Dockerfile

## Dockerfile
FROM python:3.9-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . .

CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

Étape 7: Construire et Pusher l'Image Docker vers ACR

## Connexion à ACR
az acr login --name your_acr_name

## Construire l'image Docker
docker build -t your_acr_name/task-manager .

## Tagger l'image avec le nom complet du référentiel
docker tag task-manager your_acr_name.azurecr.io/task-manager:latest

## Pusher l'image vers ACR
docker push your_acr_name.azurecr.io/task-manager:latest

Étape 8: Déployer l'Image sur AKS

## Créer un déploiement dans AKS
az aks create --resource-group your_resource_group --name your_aks_name --node-count 1 --generate-ssh-keys

## Exposer le service via une IP publique
kubectl apply -f deployment.yaml

## Vérifier les nœuds et services
kubectl get nodes
kubectl get svc

Erreurs Frequentes et Debugging

1. Erreur: ModuleNotFoundError

Vous recevez cette erreur lorsque Python ne trouve pas un module que vous essayez d'importer.

## Code incorrect
from some_module import SomeClass

## Code correct
try:
    from some_module import SomeClass
except ModuleNotFoundError:
    print("Module not found. Please install it.")

2. Erreur: ConnectionRefusedError

Vous recevez cette erreur lorsque votre application ne peut pas se connecter à une base de données ou un service externe.

## Code incorrect
import requests

response = requests.get("http://localhost:5000")

## Code correct
import time

while True:
    try:
        response = requests.get("http://localhost:5000")
        break
    except ConnectionRefusedError:
        print("Service not available. Retrying...")
        time.sleep(2)

3. Erreur: KeyError

Vous recevez cette erreur lorsque vous essayez d'accéder à une clé qui n'existe pas dans un dictionnaire.

## Code incorrect
user_info = {"name": "John"}
print(user_info["age"])

## Code correct
if "age" in user_info:
    print(user_info["age"])
else:
    print("Age not found")

Pour Aller Plus loin

1. Authentification et Sécurité avec OAuth2

Azure Active Directory offre des services d'authentification et de gestion des identités.

Documentation Azure AD

2. Utilisation de Redis pour le Caching

Redis est une base de données en mémoire qui peut être utilisée comme cache pour améliorer les performances de votre application.

Documentation Redis sur Azure

3. Intégration avec Azure Functions

Azure Functions permet d'exécuter du code en réponse à des événements sans avoir à gérer l'hébergement.

Documentation Azure Functions

Défi Pratique

1. Ajoutez une fonctionnalité pour importer des tâches à partir d'un fichier CSV.
2. Utilisez Azure Storage pour stocker les fichiers importés.
3. Mettez en place un système de logging pour suivre les opérations de l'API.

En suivant ce tutoriel, vous devriez être capable de déployer une application FastAPI sur Azure et la rendre disponible en ligne.