Execute o Tesseract como API
ou serviço auto-hospedado.

pip install fastapi uvicorn python-multipart pytesseract pillow
# instale primeiro o motor + os pacotes de idioma (ver o guia de instalação)
uvicorn app:app --host 0.0.0.0 --port 8000

Depois chame: curl -F "file=@fatura.png" "http://localhost:8000/ocr?lang=por". O Tesseract é instalado conforme o guia de instalação.

Uma intenção principal por endpoint. Mantenha /ocr retornando texto e adicione endpoints separados para PDFs e dados de layout em vez de sobrecarregar uma resposta.

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 MB
LANGS = {"eng", "deu", "fra", "por"}

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("por")):
    if lang not in LANGS:
        raise HTTPException(400, "Idioma não suportado")
    data = await file.read()
    if len(data) > MAX_BYTES:
        raise HTTPException(413, "Arquivo muito grande")
    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, "O OCR excedeu o tempo")
    return {"text": text, "lang": lang}

Detalhes-chave: lista de idiomas permitidos, aplique um limite de bytes antes de decodificar, execute o OCR em um pool de processos e limite o tempo de relógio. Veja o guia de Python para a API completa do pytesseract.

FROM python:3.12-slim
RUN apt-get update && apt-get install -y --no-install-recommends \
      tesseract-ocr tesseract-ocr-eng tesseract-ocr-por \
      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"]

Adicione apenas os pacotes de idioma necessários para manter a imagem pequena. O guia de instalação cobre Docker e a localização do tessdata com mais detalhes.

• Pool de processos ou subprocessos da CLI: o GIL do Python impede que um pool de threads acelere o OCR. Use ProcessPoolExecutor ou um pool de subprocessos do tesseract.
• Workers vs réplicas: execute alguns workers do uvicorn por contêiner e escale réplicas horizontalmente atrás de um balanceador.
• Filas: para picos ou documentos longos, aceite o upload, retorne um ID de tarefa e processe a partir de uma fila (Celery, RQ ou um broker).
• Contrapressão: limite a fila e rejeite com 429 quando saturada em vez de deixar a latência disparar.
• Limites de recursos: fixe CPU/memória por worker e defina um timeout de OCR para que uma imagem ruim não trave uma réplica.

• Sem saída de dados: as imagens permanecem dentro da sua rede — importante para documentos jurídicos, médicos e financeiros.
• Valide a entrada: verifique o tipo MIME e os bytes mágicos, não apenas a extensão; decodifique em try/except.
• Limite os recursos: tamanho máximo de upload, timeout por requisição e um teto de memória para resistir a bombas de descompactação.
• Autentique: coloque uma chave de API ou um gateway na frente; endpoints de OCR são caros de abusar.
• Remova metadados: se persistir arquivos, remova o EXIF e apague os originais periodicamente.

• Runtimes de contêiner: Cloud Run, imagens de contêiner do AWS Lambda e Fly.io executam uma imagem do Tesseract sem gerenciar servidores.
• Inicialização a frio: uma imagem do Tesseract com pacotes de idioma é grande, então as inicializações a frio são lentas — mantenha uma instância quente para tráfego sensível à latência.
• Limites: aumente memória e timeout; um timeout padrão pequeno matará documentos grandes.
• Disco efêmero: grave arquivos temporários apenas em /tmp; trate o sistema de arquivos como descartável.

Muitas equipes auto-hospedam o Tesseract para trabalhos de alto volume e sensíveis à privacidade e recorrem a uma API gerenciada apenas para a minoria difícil de documentos.