Résumez cet article avec :

Dans ce didacticiel complet, nous vous expliquerons étape par étape le processus de création d'une API de suppression d'arrière-plan entièrement fonctionnelle à l'aide de API rapide, l'un des frameworks Web les plus rapides et les plus modernes pour créer des API avec Python.

Pour permettre la suppression effective de l'arrière-plan, nous allons intégrer Eden Ai, une plateforme qui regroupe plusieurs services d'IA au sein d'une seule API.

Pour une explication plus approfondie, n'oubliez pas de regarder notre tutoriel Youtube sur la suppression de l'arrière-plan, où nous fournissons une description détaillée de chaque étape.

En suivant la vidéo, vous aurez une compréhension complète du processus, en vous assurant de ne manquer aucun détail important.

Que vous soyez novice en matière d'API Python, de suppression d'arrière-plan ou de FastAPI, ce guide pratique est pratique et convivial pour les débutants.

‍

Ce que vous allez construire

À la fin de ce didacticiel, vous disposerez d'une API fonctionnelle qui :

Accepte une image via URL ou téléchargement de fichier.
Envoie l'image au terminal de suppression de l'arrière-plan d'eDenai.
Renvoie une version base64 de l'image avec l'arrière-plan supprimé (adaptée à l'affichage dans un frontend)

Prérequis

Avant de commencer, assurez-vous de disposer des outils et des connaissances suivants :

Python 3.7 et versions ultérieures: Requis pour la compatibilité avec FastAPI et d'autres bibliothèques.
pépin: le gestionnaire de paquets de Python pour l'installation de bibliothèques.
Clé API eDenai: vous devez créer un compte sur edenai.co et récupérez votre clé API.
Connaissances de base de Python: En particulier en ce qui concerne les fonctions et le JSON.

‍

Qu'est-ce que API de suppression de l'arrière-plan?

Les IA d'Eden API de suppression de l'arrière-plan utilise l'IA pour supprimer automatiquement l'arrière-plan des images, isolant ainsi le sujet principal.

Il prend en charge plusieurs fournisseurs (tels que PhotoRoom et Sentisight) via une API unique et unifiée, ce qui facilite l'intégration et le basculement entre les services.

Les cas d'utilisation courants incluent le commerce électronique, le design et les réseaux sociaux, qui aident les utilisateurs à créer des visuels nets et professionnels sans modification manuelle.

‍

Guide étape par étape

Étape 1 : Configuration du projet

Commencez par créer un dossier dédié et configurez un environnement virtuel Python (meilleure pratique pour les projets Python).


mkdir background_removal_api
cd background_removal_api
python -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate

Un environnement virtuel garantit que les dépendances de votre projet n'interfèrent pas avec les packages à l'échelle du système.

mkdir et cd se créent et se déplacent dans le dossier de votre projet.
python -m venv venv initialise un environnement virtuel pour isoler les dépendances de votre projet.
source venv/bin/activate active l'environnement virtuel afin que tous les packages installés soient limités à ce projet.

‍

Ensuite, installez les dépendances requises :


pip install fastapi uvicorn python-dotenv requests python-multipart

Voici ce que fait chaque bibliothèque :

fastapi : Le framework Web pour créer votre API.
Luvicorne : Un serveur ASGI pour exécuter votre application FastAPI.
Python point V : Charge les variables d'environnement (comme votre clé API) à partir d'un fichier .env.
demandes : Envoie des requêtes HTTP à l'API d'eDenai.
Python en plusieurs parties : Permet à FastAPI de gérer les téléchargements de fichiers.

‍

Créez un fichier .env dans le répertoire racine et stockez votre clé d'API eDenai en toute sécurité :


EDEN_AI_API_KEY=your_edenai_api_key_here

Ne téléchargez jamais ce fichier sur le système de contrôle de version (comme GitHub) ! Il contient vos informations d'identification API privées.

‍

Étape 2 : Création du fichier API

Créez un fichier nommé main.py et collez-y le code FastAPI complet.


from fastapi import FastAPI, File, UploadFile, HTTPException, Form
from fastapi.responses import JSONResponse
from fastapi.middleware.cors import CORSMiddleware
import requests
import tempfile
import os
from dotenv import load_dotenv
from typing import Optional, List
from pydantic import BaseModel

# Initialize FastAPI app
app = FastAPI(title="Background Removal API")

# Load environment variables
load_dotenv()

# Enable CORS (important if using with frontend apps)
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  
    allow_credentials=True,
    allow_methods=["*"],  
    allow_headers=["*"],  
)

# Load your EdenAI API key from the .env
EDENAI_API_KEY = os.getenv('EDEN_AI_API_KEY')
EDENAI_API_ENDPOINT = "https://api.edenai.run/v2/image/background_removal"

‍

Étape 3 : Ajouter le modèle pour la saisie d'URL

Ce modèle est utilisé pour définir ce à quoi nous nous attendons lorsqu'un utilisateur envoie un Basé sur une URL demande de suppression de l'arrière-plan :


class ImageURL(BaseModel):
    file_url: str
    providers: List[str]
    fallback_providers: Optional[List[str]] = None
    response_as_dict: Optional[bool] = True
    attributes_as_list: Optional[bool] = False
    show_base_64: Optional[bool] = True
    show_original_response: Optional[bool] = False
    provider_params: Optional[dict] = None

‍

Étape 4 : Root Route (bilan de santé)

Cet itinéraire de base ne fait que confirmer que l'API est en ligne :


@app.get("/")
def read_root():
    return {
        "message": "Background Removal API",
        "endpoints": ["/remove-bg/url", "/remove-bg/upload"]
    }

Il s'agit d'un simple point de terminaison GET permettant de confirmer que votre API est en cours d'exécution. Lorsque vous visitez l'URL racine, elle renvoie un message convivial.

‍

Étape 5 : Point de terminaison de suppression de l'arrière-plan basé sur une URL

Implémentez maintenant un point de terminaison qui reçoit une URL d'image et supprime l'arrière-plan via eDenai :


@app.post("/remove-bg/url")
async def remove_background_from_url(data: ImageURL):
    headers = {"Authorization": f"Bearer {EDENAI_API_KEY}"}
    
    json_payload = {
        "providers": ",".join(data.providers),
        "file_url": data.file_url,
        "response_as_dict": data.response_as_dict,
        "attributes_as_list": data.attributes_as_list,
        "show_base_64": data.show_base_64,
        "show_original_response": data.show_original_response
    }

    if data.fallback_providers:
        json_payload["fallback_providers"] = ",".join(data.fallback_providers)
    if data.provider_params:
        json_payload["provider_params"] = data.provider_params

    try:
        response = requests.post(EDENAI_API_ENDPOINT, json=json_payload, headers=headers)
        response.raise_for_status()
        return response.json()
        
    except requests.exceptions.HTTPError as e:
        error_detail = e.response.json() if e.response.content else str(e)
        raise HTTPException(status_code=e.response.status_code, detail=error_detail)
    except requests.exceptions.RequestException as e:
        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")

Qu'est-ce que cela fait :

Prend une charge utile JSON avec une URL d'image.
L'envoie à Edenai.
Renvoie les données d'image en base64.

Si la demande échoue (image non valide, par exemple), elle renvoie une erreur 500.

‍

Étape 6 : Point de terminaison de suppression de l'arrière-plan du téléchargement de fichiers

Ce terminal gère les images téléchargées directement sous forme de fichiers :


@app.post("/remove-bg/upload")
async def remove_background_from_file(
    file: UploadFile = File(...),
    providers: str = Form(...),
    fallback_providers: Optional[str] = Form(None),
    response_as_dict: Optional[bool] = Form(True),
    attributes_as_list: Optional[bool] = Form(False),
    show_base_64: Optional[bool] = Form(True),
    show_original_response: Optional[bool] = Form(False)
):
    headers = {"Authorization": f"Bearer {EDENAI_API_KEY}"}
    temp_file = None
    file_content = await file.read()
    
    try:
        temp_fd, temp_path = tempfile.mkstemp(suffix=".tmp")
        temp_file = os.fdopen(temp_fd, "wb")
        temp_file.write(file_content)
        temp_file.close()
        
        data = {
            "providers": providers,
            "response_as_dict": str(response_as_dict).lower(),
            "attributes_as_list": str(attributes_as_list).lower(),
            "show_base_64": str(show_base_64).lower(),
            "show_original_response": str(show_original_response).lower()
        }

        if fallback_providers:
            data["fallback_providers"] = fallback_providers
        
        with open(temp_path, "rb") as f:
            files = {
                "file": (file.filename, f, file.content_type or "application/octet-stream")
            }
            response = requests.post(EDENAI_API_ENDPOINT, data=data, files=files, headers=headers)
        
        if response.status_code != 200:
            error_detail = response.json() if response.content else "Unknown error"
            raise HTTPException(status_code=response.status_code, detail=error_detail)
            
        return response.json()
        
    except requests.exceptions.RequestException as e:
        raise HTTPException(status_code=500, detail=f"Request error: {str(e)}")
    finally:
        if temp_file and not temp_file.closed:
            temp_file.close()
        if temp_path and os.path.exists(temp_path):
            try:
                os.unlink(temp_path)
            except Exception as e:
                print(f"Warning: Could not delete temporary file: {e}")

Qu'est-ce que cela fait :

Accepte un fichier image chargé.
L'enregistre temporairement sous le nom temp.png.
Envoie le fichier à eDenai pour traitement à l'aide de multipart/form-data.
Supprime ensuite le fichier temporaire pour nettoyer l'espace de stockage.
Renvoie l'image traitée sous forme de chaîne base64.

‍

Étape 7 : Exécutez votre API

Démarrez votre application FastAPI à l'aide d'Uvicorn :


uvicorn main:app --reload

Visitez http://127.0.0.1:8000 pour tester l'itinéraire du bilan de santé.

‍

Tester les points de terminaison

1. Test d'URL

Envoyez une requête POST à /remove-bg/url avec un corps JSON tel que :


{
  "file_url": "https://example.com/image.jpg",
  "providers": ["remove_bg"]
}

2. Test de téléchargement (par exemple, avec Postman ou un frontend)

Utilisez Postman ou un client frontal pour POST vers /remove-bg/file avec form-data :

fichier : télécharger un fichier image
fournisseurs : supprimer_bg

‍

Conseils et suggestions

eDenai prend en charge plusieurs fournisseurs de suppression d'arrière-plan. Vous pouvez spécifier fallback_providers pour garantir la fiabilité en cas de défaillance du serveur principal.

Le middleware CORS est activé par défaut pour toutes les origines, ce qui le rend convivial pour le front-end.

Sécurisez toujours vos fichiers .env en les ajoutant à .gitignore.

‍

Conclusion

En suivant ce didacticiel étape par étape, vous avez créé une API de suppression d'arrière-plan puissante et flexible à l'aide de FastAPI et eDenai.

Que vous travailliez sur une application Web, une application mobile ou un outil interne, cette API peut désormais gérer à la fois les URL des images et les téléchargements directs, renvoyant des images propres, codées en base64 et prêtes à être utilisées.

Vous avez également appris les meilleures pratiques en matière de variables d'environnement, d'intégration d'API et de conception de code modulaire.

À partir de là, vous pouvez étendre les fonctionnalités avec d'autres services d'IA d'eDenai, ajouter l'authentification des utilisateurs ou déployer votre API sur une plateforme cloud telle que Render, Vercel ou Railway.

‍

Ressources

Prêt à plonger plus profondément ? Nous avons tout ce dont vous avez besoin pour commencer.

Documentation sur la suppression de l'arrière-plan

Code complet - Github

Comment créer une API de suppression d'arrière-plan : un didacticiel étape par étape