Deployer FastAPI avec Docker

Pourquoi Deployer FastAPI avec Docker ?

Deployer FastAPI avec Docker est une pratique essentielle pour plusieurs raisons pratiques au quotidien d'un développeur. En utilisant Docker, vous pouvez :

• Gagner en rapidité : L'installation et le démarrage de l'environnement de développement sont facilités grâce à des images pré-construites.
• Améliorer la portabilité : Les applications Docker peuvent être exécutées sur n'importe quel système qui supporte Docker, indépendamment des dépendances locales.
• Assurer la cohérence : L'environnement de développement est identique à celui de production, réduisant les erreurs liées aux différences d'environnement.

Un cas concret serait une application de gestionnaire de tâches. Vous pouvez développer et déployer cette application avec Docker pour s'assurer que le même environnement sera utilisé dans le développement, la test et la production.

Prerequis

Pour suivre ce tutoriel, vous devez avoir les connaissances et les outils suivants :

• Python 3.8+ : Pour exécuter FastAPI.
• Docker Desktop : Pour créer et gérer des conteneurs Docker.
• Un éditeur de texte : Pour écrire le code (Visual Studio Code recommandé).

Concepts fondamentaux

1. Dockerfile

Le Dockerfile est un fichier textuel qui contient toutes les instructions nécessaires pour construire une image Docker.

## Utilisation d'une image Python officielle comme base
FROM python:3.9-slim

## Définition du répertoire de travail dans le conteneur
WORKDIR /app

## Copie des fichiers du répertoire local vers le répertoire de travail du conteneur
COPY . /app

## Installation des dépendances du projet
RUN pip install --no-cache-dir -r requirements.txt

## Définition du port sur lequel l'application va écouter
EXPOSE 8000

## Commande pour exécuter l'application
CMD ["uvicorn", "main:app", "--host", "0.0.0.0"]

2. requirements.txt

Ce fichier liste toutes les dépendances nécessaires à votre application.

fastapi
uvicorn

3. main.py

C'est le point d'entrée de votre application FastAPI.

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Bienvenue sur mon API FastAPI"}

Mise en pratique : projet fil rouge

Nous allons créer un simple gestionnaire de tâches avec FastAPI et Docker.

Étape 1 : Créer le projet

mkdir fastapi-todo
cd fastapi-todo

Étape 2 : Créer le fichier requirements.txt

fastapi
uvicorn
python-multipart

Étape 3 : Créer les fichiers FastAPI

Créez un fichier main.py avec le contenu suivant :

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import List, Optional

app = FastAPI()

## Modèle de données pour une tâche
class Task(BaseModel):
    id: int
    title: str
    description: Optional[str] = None
    completed: bool = False

## Base de données in-memory
tasks_db = []

## Route pour obtenir toutes les tâches
@app.get("/tasks", response_model=List[Task])
def get_tasks():
    return tasks_db

## Route pour ajouter une nouvelle tâche
@app.post("/tasks/", response_model=Task)
def create_task(task: Task):
    task.id = len(tasks_db) + 1
    tasks_db.append(task)
    return task

## Route pour mettre à jour une tâche
@app.put("/tasks/{task_id}", response_model=Task)
def update_task(task_id: int, task: Task):
    for i, t in enumerate(tasks_db):
        if t.id == task_id:
            tasks_db[i] = task
            return task
    raise HTTPException(status_code=404, detail="Tâche non trouvée")

## Route pour supprimer une tâche
@app.delete("/tasks/{task_id}", response_model=dict)
def delete_task(task_id: int):
    global tasks_db
    tasks_db = [t for t in tasks_db if t.id != task_id]
    return {"message": "Tâche supprimée"}

Étape 4 : Créer le fichier Dockerfile

FROM python:3.9-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 8000

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

Étape 5 : Construire l'image Docker

docker build -t fastapi-todo .

Étape 6 : Exécuter le conteneur

docker run -d --name fastapi-todo-container -p 8000:8000 fastapi-todo

Étape 7 : Tester l'application

Ouvrez un navigateur et accédez à http://localhost:8000/docs. Vous devriez voir l'interface de documentation Swagger pour votre API.

Erreurs frequentes et debugging

1. Erreur : ModuleNotFoundError

   ModuleNotFoundError: No module named 'uvicorn'
   

   Correction :

   RUN pip install --no-cache-dir -r requirements.txt
   

2. Erreur : Port already in use

   docker run -d --name fastapi-todo-container -p 8000:8000 fastapi-todo
   Error response from daemon: driver failed programming external connectivity on endpoint fastapi-todo-container (421b5c37e9a63f5e5cb9d2f93e8e3b7c6e0f5c6a0e1c7c9b6e8f5e9d4b6c7d8e): Error starting userland proxy: listen tcp 0.0.0.0:8000: bind: address already in use
   

   Correction :

   Assurez-vous que le port 8000 n'est pas déjà utilisé sur votre système.

3. Erreur : AttributeError: 'Task' object has no attribute 'id'

   task.id = len(tasks_db) + 1
   

   Correction :

   Assurez-vous que la classe Task est correctement définie et qu'elle a bien un attribut id.

Pour aller plus loin

1. Utiliser Docker Compose pour gérer plusieurs services.
2. Ajouter des volumes pour rendre votre application persistante.
3. Configurer l'authentification avec OAuth ou JWT.

Défi pratique

Créez une API de blog simple avec FastAPI et Docker. Implémentez les routes suivantes :

• GET /posts : Obtenir tous les articles
• POST /posts : Créer un nouvel article
• PUT /posts/{post_id} : Mettre à jour un article existant
• DELETE /posts/{post_id} : Supprimer un article

Références

• FastAPI Documentation
• Docker Documentation
• Docker Compose Documentation

En suivant ce tutoriel, vous devriez être capable de déployer un application FastAPI avec Docker et comprendre les concepts fondamentaux du déploiement Docker.