Souveräner Cloud : OVH, Scaleway, Outscale für RAG

Für europäische Unternehmen garantiert das Hosten eines RAG-Systems in einer souveränen Cloud die DSGVO-Konformität und schützt vor extraterritorialen Gesetzen (Cloud Act). Dieses Handbuch vergleicht die Optionen und erklärt, wie man deployt.

Warum ein souveräner Cloud ?

Comparatif des providers

OVH

DEVELOPERyaml
# RAG-Bereitstellung auf 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
# Verwenden der Scaleway LLM-API
from scaleway import Client
from scaleway.inference import InferenceV1Beta1API

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

# Inferenz auf gehostetem Modell
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
# Auf einer GPU-Instanz bei 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

# OpenAI-kompatible API
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]):
        # Inhalt verschlüsseln
        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)

        # Ergebnisse entschlüsseln
        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