Deployer FastAPI sur Railway

Pourquoi Déployer FastAPI sur Railway ?

Déployer une application FastAPI sur Railway est un choix pratique pour les développeurs souhaitant bénéficier d'une plateforme de déploiement rapide et simple. En effet, Railway fournit un environnement de développement cloud prêt à l'emploi, qui permet aux développeurs de se concentrer sur le code plutôt que sur la configuration et le déploiement.

Un cas concret de déploiement FastAPI sur Railway est lorsque vous voulez créer une API pour votre application web ou mobile. En utilisant Railway, vous pouvez rapidement déployer cette API sans avoir à gérer les aspects techniques du hébergement et de la mise en production.

Prerequis

Pour suivre ce tutoriel, vous aurez besoin des éléments suivants :

• Connaissance de base de FastAPI
• Un compte GitHub (pour héberger votre code sur un dépôt)
• Un compte Railway (gratuit pour les projets open source)

Les outils que vous devrez installer sont :

• Python 3.7 ou plus récent
• Git
• Railway CLI

Concepts fondamentaux

1. Environnement de Développement Cloud

Un environnement de développement cloud est un service en ligne qui fournit des ressources informatiques (comme du stockage, du réseau et des serveurs) sur demande. Cela permet aux développeurs de se concentrer sur le code plutôt que sur la gestion des infrastructures.

2. Railway CLI

Railway Command Line Interface (CLI) est un outil qui vous permet d'interagir avec le service Railway depuis votre terminal. Il vous permet de créer, gérer et déployer vos applications.

## Installation de Railway CLI via npm
npm install -g @railway/cli

3. Déploiement Automatique

Le déploiement automatique est un processus qui permet d'automatiser le déploiement de votre application en réponse à des événements spécifiques, comme la création ou la mise à jour d'un commit sur un référentiel Git.

4. Variables d'Environnement

Les variables d'environnement sont des valeurs qui peuvent être utilisées dans votre code pour configurer le comportement de l'application. Elles permettent de séparer les configurations spécifiques aux environnements (production, développement) du code source.

## Utilisation de variables d'environnement en FastAPI
from fastapi import FastAPI, Depends
import os

app = FastAPI()

def get_db_url():
    return os.getenv("DATABASE_URL", "sqlite:///./test.db")

@app.get("/")
async def read_root(db_url=Depends(get_db_url)):
    return {"database_url": db_url}

Mise en pratique : Projet fil rouge

Nous allons créer une application simple d'un gestionnaire de tâches. Cette application permettra aux utilisateurs de créer, lire, mettre à jour et supprimer des tâches.

Étape 1 : Création du projet FastAPI

Créez un nouveau répertoire pour votre projet et initialisez-le avec Git :

mkdir task-manager-fastapi
cd task-manager-fastapi
git init

Créez un fichier main.py pour définir les routes de l'application :

## main.py
from fastapi import FastAPI, HTTPException, Depends
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

DATABASE_URL = "sqlite:///./tasks.db"
engine = create_engine(DATABASE_URL)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()

app = FastAPI()

class Task(Base):
    __tablename__ = "tasks"
    id = Column(Integer, primary_key=True, index=True)
    title = Column(String, index=True)
    description = Column(String)

## Création de la base de données
Base.metadata.create_all(bind=engine)

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

@app.post("/tasks/")
async def create_task(task: dict, db: Session = Depends(get_db)):
    new_task = Task(**task)
    db.add(new_task)
    db.commit()
    db.refresh(new_task)
    return new_task

@app.get("/tasks/{task_id}")
async def read_task(task_id: int, db: Session = Depends(get_db)):
    task = db.query(Task).filter(Task.id == task_id).first()
    if not task:
        raise HTTPException(status_code=404, detail="Task not found")
    return task

@app.put("/tasks/{task_id}")
async def update_task(task_id: int, task_updates: dict, db: Session = Depends(get_db)):
    task = db.query(Task).filter(Task.id == task_id).first()
    if not task:
        raise HTTPException(status_code=404, detail="Task not found")
    
    for key, value in task_updates.items():
        setattr(task, key, value)
    db.commit()
    db.refresh(task)
    return task

@app.delete("/tasks/{task_id}")
async def delete_task(task_id: int, db: Session = Depends(get_db)):
    task = db.query(Task).filter(Task.id == task_id).first()
    if not task:
        raise HTTPException(status_code=404, detail="Task not found")
    
    db.delete(task)
    db.commit()
    return {"message": "Task deleted"}

Étape 2 : Configuration de Railway

Connectez-vous à votre compte Railway via la CLI :

railway login

Créez un nouveau projet sur Railway :

railway init --template fastapi

Suivez les instructions pour connecter votre projet à un dépôt GitHub et configurer le déploiement automatique.

Étape 3 : Déploiement

Une fois que vous avez configuré le déploiement, vous pouvez déployer votre application en exécutant la commande suivante :

railway up

Railway détectera les fichiers nécessaires pour un projet FastAPI et déployera votre application. Vous verrez l'URL de votre application une fois le déploiement terminé.

Erreurs fréquentes et debugging

1. ModuleNotFoundError : Module non trouvé

## Mauvais
from sqlalchemy import create_engine, Column, Integer, String

## Correction
from sqlalchemy import create_engine, Column, Integer, String

2. DatabaseError : Erreur de connexion à la base de données

## Mauvais
DATABASE_URL = "sqlite:///./tasks.db"

## Correction
DATABASE_URL = os.getenv("DATABASE_URL", "sqlite:///./tasks.db")

3. HTTPException : Erreur HTTP non traitée

## Mauvais
if not task:
    raise Exception("Task not found")

## Correction
if not task:
    raise HTTPException(status_code=404, detail="Task not found")

Pour aller plus loin

1. Authentification et Sécurité

Ajoutez une authentification JWT pour sécuriser vos routes.

• Railway Auth

2. Tests unitaires

Écrivez des tests unitaires pour votre application.

• pytest FastAPI

3. Logging

Ajoutez un système de logging pour faciliter le débogage et la surveillance de l'application.

• Python logging

Défi pratique

Créez une application FastAPI qui permet d'uploader des fichiers sur un serveur. Utilisez les concepts suivants :

• Routing
• File upload
• Asynchronous programming
• Middleware

Partagez votre code sur GitHub et partagez le lien dans les commentaires pour obtenir des retours.