Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Validierung des Verwaltungsschlüssels

Lektion 13 von 14 Aktualisiert am 29. Juli 2026 Entwickler
Auf dieser Seite
  1. Integrität Ihrer Schlüssel verifizieren
  2. Validierungsendpunkt
  3. Integration in Ihre Skripte
  4. Prüfung der Inferenzschlüssel
  5. Checkliste für die Sicherheit von Schlüsseln
  6. Prinzip der Aufgabentrennung
  7. Kernaussagen

Integrität Ihrer Schlüssel verifizieren

Die Validierung des Verwaltungsschlüssels ist die erste Verteidigungslinie Ihrer API-Infrastruktur. Bevor jede kritische Operation – Bereitstellung, Rotation, Änderungen an der Abrechnung – ausgeführt wird, müssen Sie sicherstellen, dass Ihr Schlüssel gültig ist und die Berechtigungen korrekt sind.

Validierungsendpunkt

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

Die Antwort bestätigt, dass der Schlüssel aktiv ist, und gibt das Team, die Berechtigungen und die zugehörigen Daten zurück. Übersehen Sie das Ablaufdatum nicht: Dies ist die einzige Information, die es Ihnen ermöglicht, einen Ausfall vorherzusehen, anstatt ihn zu erleiden, da ein abgelaufener Schlüssel Sie nicht warnt – er gibt lediglich einen 401-Fehler bei der ersten darauf folgenden Anforderung zurück.

Fehlerfälle

  • 401 Unauthorized: Der Schlüssel ist ungültig, abgelaufen oder wurde gelöscht
  • 403 Forbidden: Der Schlüssel ist gültig, verfügt aber nicht über die für die angeforderte Operation notwendigen Berechtigungen

Integration in Ihre Skripte

Validierung beim Start

Die Validierung beim Start verschiebt den Fehlerfall dort, wo er am geringsten kostet. Ohne diese Prüfung manifestiert sich ein ungültiger Schlüssel erst bei der ersten nützlichen Anforderung – also mitten in der Verarbeitung, manchmal nachdem bereits mehrere Schritte ausgeführt wurden. Mit dieser Prüfung stoppt das Skript nach drei Sekunden mit einer Meldung, die die Ursache benennt.

import requests
import sys

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

def validate_management_key():
    """Checks that the management key is valid."""
    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("Management key valid")
            return True
        elif response.status_code == 401:
            print("ERROR: Management key invalid or expired")
            return False
        else:
            print(f"ERROR: Unexpected status {response.status_code}")
            return False
    except requests.exceptions.RequestException as e:
        print(f"CONNECTION ERROR: {e}")
        return False

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

Periodischer Gesundheitscheck

Der periodische Gesundheitscheck deckt ab, was die Validierung beim Start verpasst: langlaufende Dienste, die vor Wochen gestartet wurden, deren Schlüssel im Laufe der Zeit ablaufen oder widerrufen werden könnten. Eine stündliche Prüfung reicht aus – der Endpunkt ist leichtgewichtig und verbraucht keine Inferenz-Token.

#!/bin/bash
# healthcheck-xai.sh — run every hour 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 "ALERT: xAI management key invalid (HTTP $STATUS)"
    # Send an alert (PagerDuty, Slack, email)
fi

Prüfung der Inferenzschlüssel

Die regelmäßige Prüfung beantwortet drei Fragen, für die kein Alarm selbst sorgen wird: Welche Schlüssel tragen immer noch einen Wildcard-Zugriff, welche haben keine Rate Limits und welche wurden seit Monaten nicht verwendet. Die ersten beiden sind Risiken, das dritte eine Gelegenheit zur Bereinigung – und alle drei werden in einem Durchgang abgedeckt.

import requests
from datetime import datetime

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

def audit_api_keys():
    """Audits all API keys for the team."""
    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"=== API Key Audit — {datetime.now().strftime('%d/%m/%Y %H:%M')} ===")
    print(f"Total number of keys: {len(keys)}")

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

        # Alerts
        warnings = []

        # Key with wildcard access
        if "api-key:endpoint:*" in acls and "api-key:model:*" in acls:
            warnings.append("TOTAL ACCESS (wildcards)")

        # Key without expiration
        if expire == "Never" or not expire:
            warnings.append("NO EXPIRATION")

        # Key without rate limits
        if not key.get("qps") and not key.get("qpm"):
            warnings.append("NO RATE LIMITS")

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

audit_api_keys()

Checkliste für die Sicherheit von Schlüsseln

Verwaltungsschlüssel

Verwaltungsschlüssel steuern alles andere – ihre Kompromittierung gewährt Zugriff auf die Erstellung, Änderung und Löschung aller Inferenzschlüssel. Sie verlangen daher die strengste Behandlung: ausschließliche Speicherung in einem Vault, niemals als Klartext in Code oder versionierter Konfiguration; Zugriff nur für Infrastrukturbetreiber, nicht für Anwendungsentwickler; und regelmäßige Validierung über GET /auth/management-keys/validation, idealerweise automatisiert als Gesundheitscheck – ein abgelaufener Verwaltungsschlüssel, der entdeckt wird, wenn Sie ihn dringend benötigen, ist das schlimmste operative Szenario.

Inferenzschlüssel (API-Schlüssel)

Für Inferenzschlüssel lautet das leitende Prinzip die Isolation: Jede Anwendung erhält ihren eigenen Schlüssel, niemals einen Schlüssel, der zwischen Diensten geteilt wird – andernfalls bricht das Rotieren eines kompromittierten Schlüssels alle Dienste auf einmal, und Analysen erlauben keine Zuordnung des Verbrauchs. Jeder Schlüssel trägt restriktive ACLs, die auf den tatsächlichen Einsatz abgestimmt sind (keine Wildcards in der Produktion), Rate Limits, die auf den erwarteten Datenverkehr ausgelegt sind, und ein Ablaufdatum, wenn der Einsatz vorübergehend ist – ein POC, der zwei Wochen dauern soll, benötigt keinen ewigen Schlüssel. Die regelmäßige Prüfung über das obige Skript schließt den Kreis: Es enthüllt vergessene, überprivilegierte oder ablaufende Schlüssel, bevor sie zu Problemen werden.

Prinzip der Aufgabentrennung

Halten Sie eine klare Trennung zwischen Schlüsseln aufrecht:

TypVerwendungWer hat Zugriff
VerwaltungsschlüsselAdministration, Abrechnung, AnalysenInfrastrukturbetreiber
ProduktionsschlüsselAPI-Aufrufe in der ProduktionProduktionsanwendung
Staging-SchlüsselTests vor der ProduktionEntwicklungsteam
EntwicklungsschlüsselLokale EntwicklungEinzelner Entwickler

Jeder Schlüssel hat einen definierten Geltungsbereich. Wenn ein Entwickler das Team verlässt, wird nur sein Entwicklungsschlüssel gelöscht – die anderen bleiben intakt.

Kernaussagen

  • GET /auth/management-keys/validation prüft die Gültigkeit Ihres Verwaltungsschlüssels
  • Integrieren Sie die Validierung in den Start Ihrer Skripte und in die Überwachung
  • Prüfen Sie regelmäßig alle Schlüssel, um übermäßige Zugriffsrechte zu erkennen
  • Trennen Sie Schlüssel nach Umgebung und Verantwortung
  • Alarmieren Sie sofort bei einem ungültigen Schlüssel (abgelaufen oder gelöscht)