Cloud souverain : OVH, Scaleway, Outscale pour le RAG

Pour les entreprises europeennes, heberger un systeme RAG sur un cloud souverain garantit la conformite RGPD et protege contre les lois extraterritoriales (Cloud Act). Ce guide compare les options et explique comment deployer.

Pourquoi un cloud souverain ?

Comparatif des providers

OVH

DEVELOPERyaml
# Deploiement RAG sur OVH Kubernetes
apiVersion: apps/v1
kind: Deployment
metadata:
  name: rag-api
spec:
  replicas: 2
  template:
    spec:
      containers:
      - name: rag
        image: registry.ovh.net/myproject/rag-api:latest
        resources:
          limits:
            nvidia.com/gpu: 1

Scaleway

DEVELOPERpython
# Utiliser l'API LLM Scaleway
from scaleway import Client
from scaleway.inference import InferenceV1Beta1API

client = Client.from_config_file_and_env()
api = InferenceV1Beta1API(client)

# Inference sur modele heberge
response = api.run_inference(
    model_id="llama-3.1-70b",
    input_data={"prompt": "Reponds a cette question..."}
)

Outscale (3DS)

Architecture RAG souveraine

┌─────────────────────────────────────────────────────────────┐
│                 ARCHITECTURE RAG SOUVERAINE                  │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  ┌──────────────────────────────────────────────────────┐   │
│  │              Zone SecNumCloud / HDS                   │   │
│  ├──────────────────────────────────────────────────────┤   │
│  │                                                       │   │
│  │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  │   │
│  │  │  Frontend   │  │   API RAG   │  │  Worker     │  │   │
│  │  │  (Next.js)  │  │  (FastAPI)  │  │ (Celery)    │  │   │
│  │  └─────────────┘  └─────────────┘  └─────────────┘  │   │
│  │         │                │                │          │   │
│  │         └───────────┬────┴────────────────┘          │   │
│  │                     │                                 │   │
│  │  ┌─────────────┐   │    ┌─────────────────────────┐ │   │
│  │  │  PostgreSQL │◄──┼───▶│   Qdrant (vectors)      │ │   │
│  │  │   (meta)    │   │    │   Self-hosted           │ │   │
│  │  └─────────────┘   │    └─────────────────────────┘ │   │
│  │                     │                                 │   │
│  │                     ▼                                 │   │
│  │  ┌─────────────────────────────────────────────────┐ │   │
│  │  │              LLM Self-Hosted                     │ │   │
│  │  │   (vLLM + Llama 3.1 70B / Mistral Large)        │ │   │
│  │  │   ou API souveraine (Scaleway, Mistral)         │ │   │
│  │  └─────────────────────────────────────────────────┘ │   │
│  │                                                       │   │
│  └──────────────────────────────────────────────────────┘   │
│                                                              │
│  ┌──────────────────────────────────────────────────────┐   │
│  │              Object Storage (documents)               │   │
│  │              Chiffrement AES-256, BYOK               │   │
│  └──────────────────────────────────────────────────────┘   │
│                                                              │
└─────────────────────────────────────────────────────────────┘

LLMs souverains

Deploiement vLLM sur GPU souverain

DEVELOPERbash
# Sur une instance GPU OVH/Scaleway
docker run --gpus all \
  -p 8000:8000 \
  vllm/vllm-openai:latest \
  --model meta-llama/Meta-Llama-3.1-70B-Instruct \
  --tensor-parallel-size 4

# API compatible OpenAI
curl http://localhost:8000/v1/chat/completions \
  -d '{"model": "meta-llama/Meta-Llama-3.1-70B-Instruct", "messages": [...]}'

Chiffrement des donnees

DEVELOPERpython
from cryptography.fernet import Fernet

class EncryptedVectorStore:
    def __init__(self, key: bytes, vector_store):
        self.cipher = Fernet(key)
        self.store = vector_store

    def add_document(self, doc_id: str, content: str, embedding: List[float]):
        # Chiffrer le contenu
        encrypted_content = self.cipher.encrypt(content.encode())

        self.store.add(
            id=doc_id,
            vector=embedding,
            payload={"content": encrypted_content.decode()}
        )

    def search(self, query_embedding: List[float], k: int = 5) -> List[Dict]:
        results = self.store.search(query_embedding, k=k)

        # Dechiffrer les resultats
        for r in results:
            r["content"] = self.cipher.decrypt(r["content"].encode()).decode()

        return results

Checklist conformite

• Donnees stockees en France/UE
• Chiffrement at-rest et in-transit
• Logs d'acces (audit trail)
• Contrat DPA avec le provider
• Pas d'acces tiers (Cloud Act)
• Backup chiffre
• Politique de retention

Couts comparatifs

Integration avec Ailog

Ailog propose une option d'hebergement souverain :

• Hebergement France : OVH + Scaleway
• Donnees chiffrees : AES-256, BYOK disponible
• Pas de Cloud Act : Aucun acces US
• SecNumCloud : Sur demande

Demander un hebergement souverain

Guides connexes

• RGPD et chatbots
• AI Act implications
• Audit trail RAG