Exécuter Tesseract comme API
ou service auto-hébergé.

pip install fastapi uvicorn python-multipart pytesseract pillow
# installez d'abord le moteur + les packs de langues (voir le guide d'installation)
uvicorn app:app --host 0.0.0.0 --port 8000

Puis appelez-le : curl -F "file=@facture.png" "http://localhost:8000/ocr?lang=fra". Tesseract s'installe selon le guide d'installation.

Une intention principale par endpoint. Gardez /ocr pour le texte et ajoutez des endpoints distincts pour les PDF et les données de mise en page.

import asyncio, io
from concurrent.futures import ProcessPoolExecutor
from fastapi import FastAPI, File, UploadFile, HTTPException, Query
from PIL import Image
import pytesseract

app = FastAPI(title="Tesseract OCR API")
pool = ProcessPoolExecutor(max_workers=4)
MAX_BYTES = 10 * 1024 * 1024  # 10 Mo
LANGS = {"eng", "deu", "fra", "spa"}

def _ocr(data: bytes, lang: str) -> str:
    image = Image.open(io.BytesIO(data))
    return pytesseract.image_to_string(image, lang=lang)

@app.get("/health")
def health():
    return {"status": "ok"}

@app.post("/ocr")
async def ocr(file: UploadFile = File(...), lang: str = Query("fra")):
    if lang not in LANGS:
        raise HTTPException(400, "Langue non prise en charge")
    data = await file.read()
    if len(data) > MAX_BYTES:
        raise HTTPException(413, "Fichier trop volumineux")
    loop = asyncio.get_running_loop()
    try:
        text = await asyncio.wait_for(loop.run_in_executor(pool, _ocr, data, lang), timeout=30)
    except asyncio.TimeoutError:
        raise HTTPException(504, "Délai d'OCR dépassé")
    return {"text": text, "lang": lang}

Points clés : liste blanche de langues, appliquez une limite d'octets avant de décoder, exécutez l'OCR dans un pool de processus et bornez le temps réel. Voir le guide Python pour l'API pytesseract complète.

FROM python:3.12-slim
RUN apt-get update && apt-get install -y --no-install-recommends \
      tesseract-ocr tesseract-ocr-eng tesseract-ocr-fra \
      libgl1 libglib2.0-0 && rm -rf /var/lib/apt/lists/*
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app.py .
EXPOSE 8000
HEALTHCHECK CMD python -c "import urllib.request;urllib.request.urlopen('http://localhost:8000/health')"
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "2"]

N'ajoutez que les packs de langues nécessaires pour garder l'image petite. Le guide d'installation couvre Docker et l'emplacement de tessdata plus en détail.

• Pool de processus ou sous-processus de la CLI : le GIL de Python empêche un pool de threads d'accélérer l'OCR. Utilisez ProcessPoolExecutor ou un pool de sous-processus tesseract.
• Workers vs répliques : exécutez quelques workers uvicorn par conteneur et mettez à l'échelle des répliques horizontalement derrière un load balancer.
• Files d'attente : pour les pics ou les documents longs, acceptez l'upload, renvoyez un ID de tâche et traitez depuis une file (Celery, RQ ou un broker).
• Contre-pression : limitez la file et rejetez avec 429 en cas de saturation plutôt que de laisser la latence s'envoler.
• Limites de ressources : fixez CPU/mémoire par worker et définissez un timeout d'OCR pour qu'une mauvaise image ne bloque pas une réplique.

• Aucune sortie de données : les images restent dans votre réseau — important pour les documents juridiques, médicaux et financiers.
• Validez l'entrée : vérifiez le type MIME et les magic bytes, pas seulement l'extension ; décodez dans un try/except.
• Limitez les ressources : taille maximale d'upload, timeout par requête et plafond de mémoire contre les bombes de décompression.
• Authentifiez : placez une clé d'API ou une passerelle devant ; les endpoints OCR sont coûteux à abuser.
• Supprimez les métadonnées : si vous conservez des fichiers, retirez l'EXIF et supprimez les originaux régulièrement.

• Runtimes de conteneurs : Cloud Run, les images de conteneur AWS Lambda et Fly.io exécutent une image Tesseract sans gérer de serveurs.
• Démarrages à froid : une image Tesseract avec packs de langues est volumineuse, donc les démarrages à froid sont lents — gardez une instance chaude pour le trafic sensible à la latence.
• Limites : augmentez la mémoire et le timeout ; un petit timeout par défaut tuera les documents volumineux.
• Disque éphémère : n'écrivez des fichiers temporaires que dans /tmp ; considérez le système de fichiers comme jetable.

De nombreuses équipes auto-hébergent Tesseract pour les volumes élevés et les données sensibles et ne recourent à une API managée que pour la minorité difficile de documents.