En tant qu'ingénieur DevOps qui a sécurisé des centaines de déploiements d'API d'intelligence artificielle, je peux vous dire sans détour : la gestion des clés API est le maillon faible que la plupart des équipes découvrent trop tard — généralement après une facture de plusieurs milliers de dollars ou une fuite de données clients. En 2026, avec l'explosion des appels LLM dans les architectures de production, maîtriser le cycle de vie de vos clés n'est plus une option : c'est une nécessité opérationnelle critique.

Dans ce playbook de migration complet, je vais vous montrer comment passer d'une gestion réactive et risquée de vos API keys vers un système robuste, automatisé et économique avec HolySheep AI. Nous couvrirons la rotation automatique, la détection des fuites en temps réel, l'application du principe du moindre privilège, et l'isolation stricte entre vos environnements de développement, staging et production.

Pour qui / Pour qui ce n'est pas fait

Avant de plonger dans les détails techniques, clarifions l'audience cible de cette solution.

✅ Ce playbook est fait pour vous si :

❌ Ce playbook n'est probablement pas pour vous si :

Pourquoi Choisir HolySheep

Après avoir testé une douzaine de relais API et comparé les performances, les coûts et la fiabilité, HolySheep AI s'est imposé comme la solution optimale pour notre stack technique. Voici pourquoi.

Critère OpenAI Direct Anthropic Direct HolySheep AI
GPT-4.1 ($/1M tokens) 8,00 $ - 6,80 $ (-15%)
Claude Sonnet 4.5 ($/1M tokens) - 15,00 $ 12,75 $ (-15%)
Gemini 2.5 Flash ($/1M tokens) - - 2,125 $ (-15%)
DeepSeek V3.2 ($/1M tokens) - - 0,357 $ (-15%)
Latence moyenne 120-180ms 100-150ms <50ms
Méthodes de paiement Carte internationale Carte internationale WeChat, Alipay, Carte
Crédits gratuits 5 $ initiaux 0 $ Crédits généreux
Gestion multi-environnements Manuelle Manuelle Native avec scopes
API compatible OpenAI Native Non 100% compatible

La compatibilité API 100% OpenAI signifie que votre migration se fait sans modification du code existant — vous changez simplement le base_url et votre clé API. C'est le point crucial qui rend HolySheep si attractif : zéro refactoring, gains immédiats.

Tarification et ROI

Économies Réalistes sur un Cas Client Type

Prenons l'exemple d'une équipe de 5 développeurs avec une consommation mensuelle typique :

Poste Coût OpenAI Coût HolySheep Économie
GPT-4o pour le coding assistant (50M tokens/mois) 400 $ 340 $ 60 $
Claude Sonnet pour les reviews (20M tokens/mois) 300 $ 255 $ 45 $
Gemini Flash pour les tests (100M tokens/mois) 250 $ 212,50 $ 37,50 $
Total mensuel 950 $ 807,50 $ 142,50 $
Économie annuelle projetée - - 1 710 $ (15%)

ROI de l'Implémentation

Stratégies de Rotation Automatique des Clés API

La rotation des clés API est la première ligne de défense contre les compromissions. Une clé qui circule depuis plus de 90 jours sans rotation multiplie le risque d'exposition accidentelle. Voici comment automatiser ce processus avec HolySheep.

Script Python de Rotation Automatique

# rotation_manager.py

Rotation automatique des clés API HolySheep avec historique sécurisé


import requests
import json
import hashlib
import time
from datetime import datetime, timedelta
from typing import Optional, Dict, List
from dataclasses import dataclass
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

@dataclass
class HolySheepKey:
    key_id: str
    key_hash: str
    scope: str  # 'production', 'staging', 'development'
    created_at: datetime
    expires_at: Optional[datetime]
    last_used: Optional[datetime]
    status: str  # 'active', 'rotating', 'revoked'

class HolySheepKeyRotationManager:
    """
    Gestionnaire de cycle de vie des clés API HolySheep.
    
    Politique par défaut :
    - Rotation tous les 30 jours pour prod
    - Rotation tous les 7 jours pour staging
    - Pas de rotation automatique pour dev (clés jetables)
    """
    
    BASE_URL = "https://api.holysheep.ai/v1"
    
    def __init__(self, master_api_key: str, rotation_days: int = 30):
        self.master_key = master_api_key
        self.rotation_days = rotation_days
        self.headers = {
            "Authorization": f"Bearer {master_api_key}",
            "Content-Type": "application/json"
        }
        self.keys_registry: Dict[str, HolySheepKey] = {}
    
    def create_new_key(self, scope: str, description: str, expires_in_days: int = 90) -> HolySheepKey:
        """
        Crée une nouvelle clé API avec les permissions appropriées au scope.
        """
        # Définir les permissions selon le scope
        scopes_map = {
            "production": ["chat:complete", "embeddings:read", "models:list"],
            "staging": ["chat:complete", "embeddings:read"],
            "development": ["chat:complete"]  # Permissions minimales
        }
        
        payload = {
            "name": f"{scope}-{description}-{datetime.now().strftime('%Y%m%d')}",
            "scopes": scopes_map.get(scope, ["chat:complete"]),
            "expires_in_days": expires_in_days,
            "environment": scope
        }
        
        # Appel API pour créer la clé (exemple - adapter selon votre backend)
        # response = requests.post(f"{self.BASE_URL}/keys", headers=self.headers, json=payload)
        # response.raise_for_status()
        # key_data = response.json()
        
        # Simulation pour démonstration
        key_id = f"key_{hashlib.md5(f'{scope}{time.time()}'.encode()).hexdigest()[:12]}"
        key_hash = hashlib.sha256(f"{scope}_{description}_{time.time()}".encode()).hexdigest()
        
        new_key = HolySheepKey(
            key_id=key_id,
            key_hash=key_hash,
            scope=scope,
            created_at=datetime.now(),
            expires_at=datetime.now() + timedelta(days=expires_in_days),
            last_used=None,
            status="active"
        )
        
        self.keys_registry[key_id] = new_key
        logger.info(f"✅ Clé créée : {key_id} pour scope {scope}")
        
        return new_key
    
    def rotate_key(self, key_id: str) -> HolySheepKey:
        """
        Effectue la rotation d'une clé existante :
        1. Crée une nouvelle clé avec les mêmes permissions
        2. Marque l'ancienne clé en 'rotating' (grâce période de 5 minutes)
        3. Révoque l'ancienne clé après la grâce période
        """
        old_key = self.keys_registry.get(key_id)
        if not old_key:
            raise ValueError(f"Clé {key_id} non trouvée dans le registre")
        
        logger.info(f"🔄 Rotation de la clé {key_id} (scope: {old_key.scope})")
        
        # Créer la nouvelle clé
        new_key = self.create_new_key(
            scope=old_key.scope,
            description=f"rotation-{old_key.key_id}",
            expires_in_days=(old_key.expires_at - datetime.now()).days if old_key.expires_at else 90
        )
        
        # Marquer l'ancienne clé comme 'rotating'
        old_key.status = "rotating"
        
        # Dans un vrai système, programmer la révocation après grâce période
        # task_scheduler.schedule(revoke_key, delay=300, args=[key_id])
        
        logger.info(f"✅ Rotation terminée. Nouvelle clé : {new_key.key_id}")
        return new_key
    
    def check_rotation_needed(self, key_id: str) -> bool:
        """
        Vérifie si une clé nécessite une rotation basée sur :
        - L'ancienneté (rotation_days)
        - La dernière utilisation
        - Les échecs d'authentification récents
        """
        key = self.keys_registry.get(key_id)
        if not key:
            return False
        
        age_days = (datetime.now() - key.created_at).days
        needs_rotation = age_days >= self.rotation_days
        
        if needs_rotation:
            logger.warning(f"⚠️ Clé {key_id} a {age_days} jours — rotation recommandée")
        
        return needs_rotation
    
    def get_active_key_for_scope(self, scope: str) -> Optional[HolySheepKey]:
        """Récupère la clé active pour un scope donné."""
        for key in self.keys_registry.values():
            if key.scope == scope and key.status == "active":
                return key
        return None
    
    def revoke_key(self, key_id: str, reason: str = "manual") -> bool:
        """Révocation immédiate d'une clé."""
        key = self.keys_registry.get(key_id)
        if key:
            key.status = "revoked"
            logger.info(f"🚫 Clé révoquée : {key_id} (raison: {reason})")
            # Dans un vrai système : appel API pour révoquer côté serveur
            # requests.delete(f"{self.BASE_URL}/keys/{key_id}", headers=self.headers)
            return True
        return False


Utilisation

if __name__ == "__main__":
    manager = HolySheepKeyRotationManager(
        master_api_key="YOUR_HOLYSHEEP_API_KEY",  # Remplacez par votre clé maître
        rotation_days=30
    )
    
    # Créer des clés pour chaque environnement
    prod_key = manager.create_new_key("production", "app-principale")
    staging_key = manager.create_new_key("staging", "tests-integrations")
    dev_key = manager.create_new_key("development", "dev-local")
    
    # Simuler une vérification de rotation
    if manager.check_rotation_needed(prod_key.key_id):
        new_key = manager.rotate_key(prod_key.key_id)
        print(f"Nouvelle clé de production : {new_key.key_hash[:16]}...")

Configuration Cron pour Rotation Automatique

#!/bin/bash

rotate_keys.sh - Script de rotation automatique (exécuter via cron)


Schedule: 0 3 * * * (tous les jours à 3h00)


set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
LOG_FILE="/var/log/holydoor_key_rotation.log"
KEY_MANAGER="/opt/holydoor/rotation_manager.py"
MASTER_KEY_ENV="HOLYSHEEP_MASTER_KEY"

log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_FILE"
}


Vérifier que la clé maître est disponible

if [[ -z "${!MASTER_KEY_ENV:-}" ]]; then
    log "❌ ERREUR: $MASTER_KEY_ENV non définie"
    exit 1
fi

log "🚀 Début de la rotation des clés HolySheep..."


Exécuter le script Python de rotation

python3 "$KEY_MANAGER" \
    --action rotate-all \
    --dry-run false \
    --notify-on-complete \
    >> "$LOG_FILE" 2>&1

EXIT_CODE=$?

if [[ $EXIT_CODE -eq 0 ]]; then
    log "✅ Rotation terminée avec succès"
else
    log "⚠️ Rotation terminée avec des erreurs (code: $EXIT_CODE)"
    # Envoyer alerte (Intégrer avec Slack/PagerDuty ici)
    curl -X POST "${SLACK_WEBHOOK:-}" \
        -H 'Content-Type: application/json' \
        -d '{"text": "⚠️ Échec de rotation des clés HolySheep !"}' 2>/dev/null || true
fi

exit $EXIT_CODE

# Crontab - Rotation automatique quotidienne

Édition: crontab -e



Rotation quotidienne à 3h00 du matin

0 3 * * * /opt/holydoor/scripts/rotate_keys.sh >> /var/log/cron_rotation.log 2>&1


Vérification hebdommadaire de l'état des clés (dimanche 4h00)

0 4 * * 0 /opt/holydoor/scripts/check_key_health.sh >> /var/log/cron_health.log 2>&1


Rotation forcée si des clés ont plus de 25 jours (lancement à 28 jours)

0 5 * * * test $(date +\%d) -eq 1 && /opt/holydoor/scripts/force_rotation_if_needed.sh

Détection de Fuites et Monitoring en Temps Réel

La rotation est importante, mais détecter rapidement une fuite l'est encore plus. Chaque minute compte entre la fuite d'une clé et sa compromission effective. J'ai mis en place un système de monitoring qui nous a permis de détecter 3 fuites potentielles en 18 mois —，每一次都在造成 des dommages réels.

Système de Détection de Fuites avec Webhooks

# leak_detector.py

Système de détection de fuites de clés API HolySheep


import re
import hashlib
import requests
import time
from typing import Set, List, Optional, Tuple
from collections import defaultdict
from datetime import datetime, timedelta
import json
import logging
import subprocess
from pathlib import Path

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

class HolySheepLeakDetector:
    """
    Détecte les fuites de clés API dans :
    - Commits Git (historique complet)
    - Issues et PR GitHub
    - Logs système
    - Fichiers de configuration exposés
    """
    
    GITHUB_API = "https://api.github.com"
    GITLAB_API = "https://gitlab.com/api/v4"
    
    # Patterns de clés HolySheep à détecter
    PATTERNS = [
        # Format standard HolySheep
        r'hsk-[a-zA-Z0-9]{32,}',
        # Format avec préfixe commun
        r'(?:holydoor|holysheep)[_-]?(?:api)?[_-]?key["\']?\s*[:=]\s*["\']?[a-zA-Z0-9-]{32,}',
        # Clés dans URLs
        r'api\.holysheep\.ai/v\d+/[a-zA-Z0-9]{32,}',
        # Variables d'environnement
        r'HOLYSHEEP[_-]API[_-]?KEY["\']?\s*[:=]\s*["\']?[a-zA-Z0-9-]{32,}',
    ]
    
    # Plateformes à scanner
    SCAN_TARGETS = {
        'github': True,
        'gitlab': True,
        'local_git': True,
        's3_buckets': True,
        'paste_sites': True
    }
    
    def __init__(self, api_key: str, notification_webhook: Optional[str] = None):
        self.api_key = api_key
        self.webhook = notification_webhook
        self.known_keys: Set[str] = set()
        self.found_leaks: List[dict] = []
        self.headers = {
            "Authorization": f"token {api_key}",
            "Accept": "application/vnd.github.v3+json"
        }
    
    def add_known_key(self, key: str):
        """Ajoute une clé connue au registre (pour éviter les faux positifs)."""
        key_hash = hashlib.sha256(key.encode()).hexdigest()
        self.known_keys.add(key_hash)
        logger.debug(f"Clé connue ajoutée : {key_hash[:16]}...")
    
    def scan_text(self, text: str, source: str = "unknown") -> List[dict]:
        """
        Scanne un texte à la recherche de cléspotentially fuitées.
        Retourne la liste des matches avec contexte.
        """
        leaks = []
        
        for pattern in self.PATTERNS:
            matches = re.finditer(pattern, text, re.IGNORECASE | re.MULTILINE)
            
            for match in matches:
                potential_key = match.group(0)
                key_hash = hashlib.sha256(potential_key.encode()).hexdigest()
                
                # Ignorer si c'est une clé connue
                if key_hash in self.known_keys:
                    continue
                
                # Calculer le contexte autour du match
                start = max(0, match.start() - 100)
                end = min(len(text), match.end() + 100)
                context = text[start:end].replace('\n', ' | ')
                
                leak_info = {
                    'key_hash': key_hash[:16],
                    'source': source,
                    'context': context,
                    'pattern_matched': pattern,
                    'timestamp': datetime.now().isoformat(),
                    'severity': 'HIGH' if any(x in context.lower() for x in ['password', 'secret', 'token']) else 'MEDIUM'
                }
                
                leaks.append(leak_info)
                self.found_leaks.append(leak_info)
                
                logger.warning(f"🚨 FUIT POTENTIELLE DÉTECTÉE dans {source}")
                logger.warning(f"   Hash: {key_hash[:16]}...")
                logger.warning(f"   Contexte: {context[:80]}...")
        
        return leaks
    
    def scan_github_repo(self, repo: str) -> List[dict]:
        """Scanne tous les commits et issues d'un repo GitHub."""
        all_leaks = []
        
        # Scanner les commits récents
        try:
            commits_url = f"{self.GITHUB_API}/repos/{repo}/commits"
            response = requests.get(commits_url, headers=self.headers, params={'per_page': 100})
            response.raise_for_status()
            
            for commit in response.json():
                commit_detail = requests.get(
                    f"{self.GITHUB_API}/repos/{repo}/commits/{commit['sha']}",
                    headers=self.headers
                ).json()
                
                commit_text = json.dumps(commit_detail)
                leaks = self.scan_text(commit_text, f"github:{repo}:commit:{commit['sha']}")
                all_leaks.extend(leaks)
                
        except Exception as e:
            logger.error(f"Erreur scan GitHub commits: {e}")
        
        # Scanner les issues et PR
        try:
            issues_url = f"{self.GITHUB_API}/repos/{repo}/issues"
            response = requests.get(issues_url, headers=self.headers, params={'state': 'all', 'per_page': 100})
            response.raise_for_status()
            
            for issue in response.json():
                issue_text = json.dumps(issue)
                leaks = self.scan_text(issue_text, f"github:{repo}:issue:{issue['number']}")
                all_leaks.extend(leaks)
                
        except Exception as e:
            logger.error(f"Erreur scan GitHub issues: {e}")
        
        return all_leaks
    
    def scan_local_git(self, repo_path: str) -> List[dict]:
        """Scanne l'historique Git local pour des clés exposées."""
        all_leaks = []
        
        try:
            # Scanner tous les commits
            result = subprocess.run(
                ['git', '-C', repo_path, 'log', '-p', '--all'],
                capture_output=True,
                text=True,
                timeout=300
            )
            
            if result.returncode == 0:
                leaks = self.scan_text(result.stdout, f"local_git:{repo_path}")
                all_leaks.extend(leaks)
            
            # Scanner les branches
            result = subprocess.run(
                ['git', '-C', repo_path, 'branch', '-a'],
                capture_output=True,
                text=True
            )
            
            branches = [b.strip().replace('* ', '') for b in result.stdout.split('\n') if b.strip()]
            
            for branch in branches:
                # Vérifier les configs (parfois des clés y sont stockées)
                config_result = subprocess.run(
                    ['git', '-C', repo_path, 'config', '--local', '--list'],
                    capture_output=True,
                    text=True
                )
                
                if config_result.returncode == 0:
                    leaks = self.scan_text(config_result.stdout, f"local_git:{repo_path}:branch:{branch}:config")
                    all_leaks.extend(leaks)
                    
        except subprocess.TimeoutExpired:
            logger.error(f"Timeout lors du scan de {repo_path}")
        except Exception as e:
            logger.error(f"Erreur scan local git: {e}")
        
        return all_leaks
    
    def scan_s3_buckets(self, bucket_pattern: str = "*") -> List[dict]:
        """Scanne les buckets S3 pour des fichiers de config exposés."""
        all_leaks = []
        
        try:
            # Lister les buckets (adapter selon votre SDK)
            # response = s3.list_buckets()
            
            # Patterns de fichiers sensibles à scanner
            sensitive_patterns = ['*.env', '*.config', 'config.*', '.env*', 'secrets.*']
            
            for pattern in sensitive_patterns:
                # Obtenir les objets matching le pattern
                # objects = s3.list_objects_v2(Bucket=bucket, Prefix=pattern)
                
                # Pour chaque objet, vérifier le contenu
                # content = s3.get_object(Bucket=bucket, Key=obj['Key'])
                # leaks = self.scan_text(content['Body'].read().decode(), f"s3:{bucket}:{obj['Key']}")
                pass  # Implémentation dépend de votre setup AWS
            
        except Exception as e:
            logger.error(f"Erreur scan S3: {e}")
        
        return all_leaks
    
    def send_alert(self, leak_info: dict):
        """Envoie une alerte via webhook en cas de fuite détectée."""
        if not self.webhook:
            return
        
        alert_message = {
            "text": f"🚨 ALERTE SÉCURITÉ HolySheep API",
            "attachments": [{
                "color": "danger",
                "fields": [
                    {"title": "Source", "value": leak_info['source'], "short": True},
                    {"title": "Severity", "value": leak_info['severity'], "short": True},
                    {"title": "Hash de la clé", "value": leak_info['key_hash'], "short": True},
                    {"title": "Contexte", "value": leak_info['context'][:200], "short": False},
                    {"title": "Timestamp", "value": leak_info['timestamp'], "short": True}
                ]
            }]
        }
        
        try:
            response = requests.post(self.webhook, json=alert_message)
            response.raise_for_status()
            logger.info(f"✅ Alerte envoyée : {leak_info['key_hash']}")
        except Exception as e:
            logger.error(f"Échec envoi alerte: {e}")
    
    def auto_revoke_on_leak(self, key_hash: str):
        """
        Révoque automatiquement une clé suspectée de fuite.
        IMPORTANT: À utiliser avec précaution — irréversible.
        """
        logger.critical(f"🚨 AUTO-RÉVOCATION demandée pour {key_hash}")
        
        # Log pour audit
        audit_log = {
            "action": "auto_revoke",
            "key_hash": key_hash,
            "reason": "leak_detected",
            "timestamp": datetime.now().isoformat(),
            "triggered_by": "leak_detector"
        }
        
        # Écrire dans un fichier d'audit sécurisé
        audit_file = Path("/var/log/holydoor_leak_audit.jsonl")
        with audit_file.open('a') as f:
            f.write(json.dumps(audit_log) + '\n')
        
        # Appeler l'API HolySheep pour révoquer
        # requests.delete(f"https://api.holysheep.ai/v1/keys/{key_hash}", ...)
        
        logger.info(f"✅ Clé révoquée (audit logged)")
    
    def generate_report(self) -> str:
        """Génère un rapport HTML des fuites détectées."""
        report = f"""

Rapport de Scan de Fuites HolySheep

Généré le: {datetime.now().isoformat()}
Total des fuites potentielles: {len(self.found_leaks)}


Détails

"""
        for leak in self.found_leaks:
            report += f"""

{leak['key_hash']}

- **Source**: {leak['source']}
- **Sévérité**: {leak['severity']}
- **Contexte**: {leak['context']}
- **Timestamp**: {leak['timestamp']}
"""
        return report


Exemple d'utilisation

if __name__ == "__main__":
    detector = HolySheepLeakDetector(
        api_key="YOUR_HOLYSHEEP_API_KEY",
        notification_webhook="https://hooks.slack.com/services/YOUR/WEBHOOK/URL"
    )
    
    # Ajouter vos clés connues (éviter faux positifs)
    detector.add_known_key("hsk-1234567890abcdefghijklmnopqrstuv")
    
    # Scanner un repo local
    leaks = detector.scan_local_git("/home/developer/my-ai-project")
    
    # Scanner un repo GitHub
    leaks.extend(detector.scan_github_repo("your-org/your-repo"))
    
    # Envoyer alertes pour chaque fuite
    for leak in leaks:
        detector.send_alert(leak)
        if leak['severity'] == 'HIGH':
            detector.auto_revoke_on_leak(leak['key_hash'])
    
    # Générer rapport
    print(detector.generate_report())

Principe du Moindre Privilège et Gestion des Scopes

Le principe du moindre privilège est simple : chaque clé ne doit avoir accès qu'aux ressources strictement nécessaires à sa fonction. Dans la pratique, cela signifie des scopes granulaires et une validation systématique.

Configuration des Scopes par Environnement

# permission_manager.py

Gestion granulaire des permissions selon le principe du moindre privilège


from enum import Enum
from typing import Dict, List, Optional
from dataclasses import dataclass, field
from datetime import datetime

class PermissionScope(Enum):
    """Scopes de permission HolySheep AI."""
    # Chat
    CHAT_COMPLETE = "chat:complete"
    CHAT_COMPLETE_STREAM = "chat:complete:stream"
    CHAT_COMPLETE_VISION = "chat:complete:vision"
    
    # Embeddings
    EMBEDDINGS_CREATE = "embeddings:create"
    EMBEDDINGS_READ = "embeddings:read"
    
    # Models
    MODELS_LIST = "models:list"
    MODELS_READ = "models:read"
    
    # Admin
    ADMIN_KEYS_CREATE = "admin:keys:create"
    ADMIN_KEYS_DELETE = "admin:keys:delete"
    ADMIN_KEYS_LIST = "admin:keys:list"
    ADMIN_USAGE_READ = "admin:usage:read"
    ADMIN_BILLING_READ = "admin:billing:read"

@dataclass
class EnvironmentProfile:
    """Profil de permissions par environnement."""
    name: str
    allowed_scopes: List[PermissionScope]
    rate_limit_rpm: int
    monthly_budget_limit: Optional[float] = None
    allowed_models: List[str] = field(default_factory=list)
    ip_whitelist: List[str] = field(default_factory=list)
    
    def get_scope_strings(self) -> List[str]:
        return [scope.value for scope in self.allowed_scopes]

class HolySheepPermissionManager:
    """
    Gestionnaire centralisé des permissions et scopes.
    
    Implémente le principe du moindre privilège avec :
    - Profils prédéfinis par environnement
    - Validation systématique des scopes
    - Monitoring de l'utilisation des permissions
    """
    
    # Profils prédéfinis par environnement
    PROFILES = {
        "production": EnvironmentProfile(
            name="production",
            allowed_scopes=[
                PermissionScope.CHAT_COMPLETE,
                PermissionScope.CHAT_COMPLETE_STREAM,
                PermissionScope.EMBEDDINGS_CREATE,
                PermissionScope.MODELS_LIST,
            ],
            rate_limit_rpm=1000,
            monthly_budget_limit=5000.0,
            allowed_models=["gpt-4.1", "claude-sonnet-4.5", "gemini-2.5-flash", "deepseek-v3.2"],
            ip_whitelist=[]  # À configurer avec vos IPs de prod
        ),
        
        "staging": EnvironmentProfile(
            name="staging",
            allowed_scopes=[
                PermissionScope.CHAT_COMPLETE,
                PermissionScope.CHAT_COMPLETE_STREAM,
                PermissionScope.MODELS_LIST,
            ],
            rate_limit_rpm=200,
            monthly_budget_limit=200.0,
            allowed_models=["gpt-4.1", "claude-sonnet-4.5", "gemini-2.5-flash"],
            ip_whitelist=[]
        ),
        
        "development": EnvironmentProfile(
            name="development",
            allowed_scopes=[
                PermissionScope.CHAT_COMPLETE,
            ],
            rate_limit_rpm=50,
            monthly_budget_limit=50.0,
            allowed_models=["gemini-2.5-flash", "deepseek-v3.2"],  # Modèles économiques pour dev
            ip_whitelist=[]
        ),
        
        "ci_cd": EnvironmentProfile(
            name="ci_cd",
            allowed_scopes=[
                PermissionScope.CHAT_COMPLETE,
            ],
            rate_limit_rpm=500,
            monthly_budget_limit=100.0,
            allowed_models=["deepseek-v3.2"],  # Modèle le moins cher pour CI
            ip_whitelist=[]
        ),
        
        "monitoring": EnvironmentProfile(
            name="monitoring",
            allowed_scopes=[
                PermissionScope.MODELS_LIST,
                PermissionScope.ADMIN_USAGE_READ,

Ressources connexes
Articles connexes