Validation de la clé management

Vérifier l’intégrité de vos clés

La validation des clés de gestion (management keys) est la première ligne de défense de votre infrastructure API. Avant toute opération critique — déploiement, rotation, modification de facturation — vérifiez que votre clé est valide et que ses permissions sont correctes.

Endpoint de validation

GET /auth/management-keys/validation

curl "https://management-api.x.ai/auth/management-keys/validation" \
  -H "Authorization: Bearer $MANAGEMENT_API_KEY"

La réponse confirme que la clé est active et retourne les informations associées : équipe, permissions, date de création et éventuellement date d’expiration.

Cas d’erreur

• 401 Unauthorized : la clé est invalide, expirée ou a été supprimée
• 403 Forbidden : la clé est valide mais n’a pas les permissions nécessaires pour l’opération demandée

Intégration dans vos scripts

Vérification au démarrage

Ajoutez une validation de clé au démarrage de vos applications ou scripts :

import requests
import sys

MANAGEMENT_API = "https://management-api.x.ai"
MGMT_KEY = "xai-mgmt-..."

def validate_management_key():
    """Vérifie que la clé de gestion est valide."""
    try:
        response = requests.get(
            f"{MANAGEMENT_API}/auth/management-keys/validation",
            headers={"Authorization": f"Bearer {MGMT_KEY}"},
            timeout=10
        )
        if response.status_code == 200:
            print("Clé de gestion valide")
            return True
        elif response.status_code == 401:
            print("ERREUR : clé de gestion invalide ou expirée")
            return False
        else:
            print(f"ERREUR : statut inattendu {response.status_code}")
            return False
    except requests.exceptions.RequestException as e:
        print(f"ERREUR de connexion : {e}")
        return False

if not validate_management_key():
    sys.exit(1)

Healthcheck périodique

Intégrez la validation dans votre monitoring pour détecter immédiatement une clé expirée :

#!/bin/bash
# healthcheck-xai.sh — à exécuter toutes les heures via cron

STATUS=$(curl -s -o /dev/null -w "%{http_code}" \
  "https://management-api.x.ai/auth/management-keys/validation" \
  -H "Authorization: Bearer $MANAGEMENT_API_KEY")

if [ "$STATUS" != "200" ]; then
    echo "ALERTE : clé management xAI invalide (HTTP $STATUS)"
    # Envoyer une alerte (PagerDuty, Slack, email)
fi

Audit des clés d’inférence

Combinez la validation de votre clé management avec un audit de toutes les clés d’inférence de votre équipe :

import requests
from datetime import datetime

MANAGEMENT_API = "https://management-api.x.ai"
MGMT_KEY = "xai-mgmt-..."
TEAM_ID = "team-..."

def audit_api_keys():
    """Audite toutes les clés API de l'équipe."""
    response = requests.get(
        f"{MANAGEMENT_API}/auth/teams/{TEAM_ID}/api-keys",
        headers={"Authorization": f"Bearer {MGMT_KEY}"}
    )
    keys = response.json().get("apiKeys", [])

    print(f"=== Audit des clés API — {datetime.now().strftime('%d/%m/%Y %H:%M')} ===")
    print(f"Nombre total de clés : {len(keys)}")

    for key in keys:
        name = key.get("name", "Sans nom")
        acls = key.get("acls", [])
        expire = key.get("expireTime", "Jamais")
        created = key.get("createdAt", "N/A")

        # Alertes
        warnings = []

        # Clé avec accès wildcard
        if "api-key:endpoint:*" in acls and "api-key:model:*" in acls:
            warnings.append("ACCÈS TOTAL (wildcards)")

        # Clé sans expiration
        if expire == "Jamais" or not expire:
            warnings.append("PAS D'EXPIRATION")

        # Clé sans limites de débit
        if not key.get("qps") and not key.get("qpm"):
            warnings.append("PAS DE LIMITES DE DÉBIT")

        status = " | ".join(warnings) if warnings else "OK"
        print(f"  [{name}] ACLs: {len(acls)} | Expire: {expire} | {status}")

audit_api_keys()

Checklist de sécurité des clés

Clés de gestion (management keys)

• Validez régulièrement avec GET /auth/management-keys/validation
• Stockez dans un coffre-fort (jamais en clair dans le code)
• Limitez l’accès aux seuls administrateurs de l’infrastructure
• Mettez en place un healthcheck automatique

Clés d’inférence (API keys)

• Chaque application doit avoir sa propre clé (pas de clé partagée)
• Utilisez des ACLs restrictives (pas de wildcard en production)
• Définissez des limites de débit adaptées à l’usage réel
• Configurez une date d’expiration pour les clés temporaires
• Auditez régulièrement les clés via le script ci-dessus

Principe de séparation des responsabilités

Maintenez une séparation claire entre les clés :

Chaque clé a un périmètre défini. Si un développeur quitte l’équipe, seule sa clé dev est supprimée — les autres restent intactes.

Points clés à retenir

• GET /auth/management-keys/validation vérifie la validité de votre clé de gestion
• Intégrez la validation au démarrage de vos scripts et dans votre monitoring
• Auditez régulièrement toutes les clés pour détecter les accès trop larges
• Séparez les clés par environnement et par responsabilité
• Alertez immédiatement en cas de clé invalide (expirée ou supprimée)