AI Governance : étendre la couverture avec Jamf Extender

Qu'est-ce que l'AI Governance ?

L'AI Governance comble l'écart entre « nous avons autorisé l'IA » et « nous pouvons prouver qu'elle est correctement configurée sur l'ensemble du parc ». Proposée via Jamf for Mac, elle offre aux équipes informatiques et de sécurité deux capacités intégrées : AI Visibility fournit un inventaire quasi en temps réel des outils IA en cours d'exécution, de ce qu'ils font et de ce à quoi ils se connectent. AI Policies traduit les contrôles d'entreprise de chaque outil IA en choix en langage clair et les délivre sous forme de réglages gérés appliqués par l'OS. Ensemble, elles répondent aux trois questions que posent les auditeurs et la direction : qu'est-ce qui s'exécute, est-ce correctement configuré, et pouvez-vous le prouver.

En savoir plus sur l'AI Governance

Ce qu'apporte Jamf Extender

• Export de politiques Windows : Téléchargez les politiques d'AI Governance sous forme de paquets prêts à déployer pour les importer dans n'importe quelle solution MDM ou UEM, ce qui facilite l'application des configurations d'outils IA sur les terminaux Windows aux côtés de votre parc macOS et mobile.

• Visibilité de l'état de blocage en temps réel : Voyez d'un coup d'œil quels outils IA sont déjà bloqués avant de déployer. Des indicateurs d'état verts affichent la couverture actuelle, vous aidant à éviter le travail inutile et à comprendre instantanément votre posture d'application.

• Flux de déploiement simplifié : Déployez des Custom Prevent Lists (contrôles de terminaux) et des blocages de domaines (contrôles réseau) vers l'outillage de sécurité de Jamf directement depuis le tableau de bord AI Visibility, sans changer de portail ni créer manuellement de listes.

• Détection automatique des doublons : L'extension ignore intelligemment les identifiants de signature et les domaines déjà bloqués, vous fournissant un résumé de déploiement clair et évitant les entrées en double inutiles.

• Orchestration inter-portails : Jamf Extender achemine automatiquement les déploiements vers les bons portails Jamf Cloud en fonction de la configuration de votre Portal Group Jamf Extender, éliminant les recherches manuelles et les erreurs de configuration.

Qui en profite le plus :

Les organisations gérant plusieurs environnements (production, préproduction, développement) ou celles qui ajustent fréquemment leurs politiques d'AI Governance apprécieront la visibilité et la rapidité de déploiement. Les équipes qui souhaitent une confirmation en temps réel de leur posture d'application sur l'ensemble des outils de sécurité Jamf trouveront les indicateurs d'état intégrés particulièrement précieux.

Aperçu

Ce guide vous montre comment utiliser Jamf Extender avec l'AI Governance dans Jamf Account. Jamf Extender ajoute des capacités au tableau de bord AI Visibility pour visualiser l'utilisation des outils IA et déployer des blocages de terminaux et réseau supplémentaires pour les outils IA identifiés dans votre environnement. Jamf Extender ajoute également une option de téléchargement directement dans le générateur AI Policies, vous permettant d'exporter n'importe quelle politique sous forme de paquet prêt à déployer pour les terminaux Windows, via l'import dans le MDM ou l'UEM de votre choix.

Ce que vous allez accomplir :

1. Visualiser l'utilisation des outils IA dans AI Visibility de Jamf Account
2. Déployer des Custom Prevent Lists (Jamf Protect) et des Custom Domain Blocks (Security Cloud)
3. Vérifier et gérer les blocages d'AI Governance
4. (Optionnel) Déployer la configuration de politique d'AI Governance vers les terminaux Windows

Temps requis : 2 à 5 minutes par déploiement

Prérequis

✅ Jamf Extender installé et configuré (voir Configuration de Jamf Extender ci-dessous)
✅ Portal Groups configurés reliant Jamf Pro à Protect et/ou Security Cloud
✅ Accès administrateur à :

• Jamf Account AI Governance
• Instance Jamf Protect (avec autorisations d'écriture pour les Custom Prevent Lists)
• Instance Jamf Security Cloud (facultatif, pour le blocage de domaines)

Name: Production Environment
Jamf Pro: https://myorg.jamfcloud.com
Security Cloud: Customer ID 12345
Jamf Protect: https://overview.protect.jamfcloud.com

Partie 1 : Tableau de bord et déploiement AI Visibility

Maintenant, place à la partie amusante ! Déployez les blocages d'AI Governance depuis Jamf Account.

Accéder à AI Visibility

1. Accédez à Jamf Account : account.jamf.com
2. Connectez-vous avec vos identifiants Jamf
3. Allez dans : AI Governance → AI Visibility
4. Sélectionnez votre environnement (si vous en gérez plusieurs)

Ce que vous verrez :

• Un décompte « N unique products in use »
• Des cartes de produit pour chaque outil IA détecté (par ex. Claude, Cursor, ChatGPT)
• Chaque carte affiche :
  • Le nom du produit et le bundle ID
  • Les lanceurs (identifiants de signature de l'app principale)
  • Les commandes (identifiants de signature des processus auxiliaires)
  • Le nombre d'événements sur la fenêtre temporelle sélectionnée

Comprendre les indicateurs d'état de blocage

Jamf Extender injecte des indicateurs d'état en temps réel montrant ce qui est déjà bloqué :

Avant de cliquer sur quoi que ce soit, recherchez :

• Pastille verte à côté des produits : « ✓ Block Configured in Protect »
• Pastille verte à côté des processus : « ✓ Block Configured »
• Pastille de résumé dans l'en-tête :
  • « ✓ All prevent lists configured (N) » — Tout est bloqué
  • « N of M signing IDs blocked in Protect » — Couverture partielle

Ces indicateurs apparaissent automatiquement — aucune configuration nécessaire. Ils vérifient votre instance Protect en temps réel. Ils peuvent prendre quelques instants pour s'afficher au premier chargement.

Déployer des blocages (tous les produits)

Pour bloquer tous les outils IA détectés sur la page :

1. Cliquez sur le bouton « Configure Additional Blocks »

   • Situé à GAUCHE du décompte « N unique products in use »
   • Couvre TOUS les produits de la page

2. Vérification des identifiants (se produit automatiquement) :

   • L'extension résout votre instance Protect à partir de l'UUID de l'environnement
   • Vérifie si les identifiants sont capables d'écriture (pas en lecture seule)
   • Si en lecture seule : affiche une erreur avec les instructions de configuration
   • Si prête : ouvre la fenêtre modale de déploiement

3. Sélectionnez ce qu'il faut bloquer :

   Custom Prevent Lists :

   • Les produits sont regroupés avec des cases à cocher
   • Chaque produit possède :
     • ☐ Une case pour le bundle ID du produit (par ex. com.anthropic.claudefordesktop)
     • ☐ Une case par identifiant de signature de lanceur/commande ✅ Points clés :
   • Cocher les cases d'en-tête cochera toutes les sous-cases
   • Les sous-cases sont INDÉPENDANTES
   • Rien n'est coché par défaut
   • Les identifiants déjà bloqués affichent un badge vert « Already blocked »

   Custom Domain Blocks :

   • (Si Security Cloud est configuré dans le Portal Group)
   • Chaque produit affiche ses domaines connus
   • Cochez les domaines à bloquer (par ex. claude.ai, claude.com)
   • Les blocages de domaines s'appliquent aux terminaux macOS, iOS, iPadOS, VisionOS, Android et Windows

4. Cliquez sur « Deploy »

5. Résultats :

   • Décompte de succès : « Created N Prevent Lists, Skipped M duplicates »
   • Toutes les entrées déjà existantes sont automatiquement ignorées
   • Les Prevent Lists sont immédiatement actives dans tous les Plans déployés

Des boutons seront présents sur l'écran final pour aller directement à Protect ou Security Cloud afin de voir les blocages ajoutés

Déployer des blocages (produit unique)

Pour bloquer un seul outil IA :

1. Trouvez la carte du produit (par ex. « Claude »)
2. Cliquez sur le lien « Block {Product} »
   • Situé dans le groupe de commandes de la carte (à côté de la sélection de plage de jours)
3. Suivez le même flux de déploiement que ci-dessus (limité à ce produit uniquement)

Des boutons seront présents sur l'écran final pour aller directement à Protect ou Security Cloud afin de voir les blocages ajoutés

Vérifier le déploiement

Dans Jamf Protect :

1. Allez dans : Configuration → Prevent Lists
2. Recherchez de nouvelles entrées nommées comme :
   • « Block AI Tool: com.anthropic.claudefordesktop »
   • « Block AI Tool: com.openai.chatgpt.atlas »
3. Chacune possède :
   • Type : Custom Prevent List

Dans Jamf Security Cloud :

1. Allez dans : Policies → Content filtering policy → Custom rules
2. Recherchez de nouveaux blocages de domaines personnalisés
3. Vérifiez que les domaines sont répertoriés et affectés aux groupes auxquels vous souhaitez qu'ils soient affectés

De retour dans AI Visibility :

• Actualisez la page
• Des badges verts « ✓ Block Configured » devraient apparaître à côté des éléments déployés

Bonnes pratiques

1. Utilisez des noms de Portal Group descriptifs

Bons noms : « Production », « Dev - US East », « QA Environment »
Mauvais noms : « Test », « Group 1 », « asdf »

Pourquoi : Vous aurez plusieurs Portal Groups si vous gérez plusieurs environnements.

2. Surveillez l'efficacité des Prevent Lists

Après le déploiement :

1. Dans Jamf Protect : Alerts → View All
2. Filtrez par : blocages Prevent List
3. Vérifiez que les outils IA sont réellement bloqués

Pourquoi : Cela valide que votre déploiement fonctionne en production.

3. Autoriser des exceptions

Pour autoriser un outil IA spécifique (par ex. Claude pour les développeurs) :

Option 1 - Ne pas déployer ses blocages :

• Ne cochez simplement pas ses cases lors du déploiement
• Les autres outils sont bloqués, celui-ci reste ouvert

Option 2 - Supprimer les Prevent Lists :

• Dans Jamf Protect : Configuration → Prevent Lists
• Trouvez la liste « Block AI Tool: com.anthropic.claudefordesktop »
• Supprimez-la
• L'outil est désormais autorisé
• Dans Jamf Security Cloud → Policies → Content filtering policy → Custom rules
• Supprimez toutes les règles qui ne sont plus nécessaires

Partie 2 : Déploiement de politiques IA Windows (optionnel)

Au-delà du blocage des outils IA au niveau réseau et processus, vous pouvez également déployer des configurations de politique directement vers les applications IA sur les terminaux Windows. Ceci est particulièrement utile pour les organisations qui ont besoin de :

• Configurer les outils IA avec des réglages approuvés par l'organisation (par ex. modèles approuvés, points de terminaison API, indicateurs de fonctionnalités)
• Appliquer des configurations cohérentes sur les parcs Windows via MDM
• Déployer Claude Code ou Claude Desktop avec des réglages gérés

Ce qui est déployé

Jamf Extender génère des paquets de déploiement Windows qui écrivent les configurations de politique dans le Registre Windows :

Claude Code :

• Chemin du registre : HKLM\SOFTWARE\Policies\ClaudeCode\Settings
• Format : Une seule chaîne JSON compressée contenant tous les réglages
• Déployé via : Script PowerShell qui valide et écrit la valeur de registre

Claude Desktop (Claude Cowork) :

• Chemin du registre : HKLM\SOFTWARE\Policies\Claude
• Format : Une valeur de registre par clé de réglage (par ex. model, temperature)
• Déployé via : Script PowerShell qui écrit des valeurs de chaîne individuelles

Exporter une politique pour Windows

1. Accédez à AI Policies :

   • Allez dans : AI Governance → AI Policies dans Jamf Account
   • Trouvez la politique que vous souhaitez déployer sur Windows

2. Exporter une politique unique :

   • Cliquez sur le menu à trois points (⋯) à côté de la politique
   • Sélectionnez « Export for Windows »
   • Le navigateur télécharge un fichier ZIP nommé comme : claude-code-windows-deploy.zip

3. Ou exporter toutes les politiques (en masse) :

   • Cliquez sur « Download Policies for Windows » dans la barre d'outils
   • Le navigateur télécharge : ai-policies-windows-deploy.zip
   • Contient des dossiers de déploiement distincts pour chaque politique

Comprendre la structure du paquet

Chaque export de politique contient :

claude-code-windows-deploy/
├── Deploy-ClaudeCode-Registry.ps1        # Device-side registry writer
├── intune/
│   ├── Provision-ClaudeCode-Intune.ps1   # Admin provisioner (PowerShell)
│   └── provision_claudecode_intune.py    # Admin provisioner (Python/MSAL)
├── metadata.json                          # Source policy details
└── README.txt                             # Setup instructions

Pour les politiques Claude Desktop, vous verrez également :

settings/settings.json                     # Reference copy of settings

Pour les exports en masse :

ai-policies-windows-deploy/
├── policy-1/                              # One folder per policy
│   ├── Deploy-ClaudeCode-Registry.ps1
│   └── intune/...
├── policy-2/
│   ├── Deploy-ClaudeDesktop-Registry.ps1
│   └── intune/...
├── all-policy-import/
│   ├── Import-All-AIPolicies-Intune.ps1   # Multi-policy provisioner
│   └── import_all_aipolicies_intune.py    # Multi-policy provisioner
└── metadata.json                          # Index of all policies

Option de déploiement 1 : n'importe quel MDM (exécution manuelle de script)

Les scripts côté appareil (Deploy-*.ps1) fonctionnent avec n'importe quel MDM capable d'exécuter des scripts PowerShell.

Étapes :

1. Extrayez le paquet ZIP
2. Examinez Deploy-ClaudeCode-Registry.ps1 ou Deploy-ClaudeDesktop-Registry.ps1
3. Importez le script dans votre MDM (Intune, Workspace ONE, etc.)
4. Affectez-le aux groupes d'appareils Windows
5. Le script s'exécute en tant que SYSTEM et écrit dans le registre

Ce que fait le script :

• Intègre le JSON de la politique directement dans le script
• Valide la syntaxe JSON avec ConvertFrom-Json (échoue rapidement en cas d'erreur)
• Crée la clé de registre si elle n'existe pas
• Écrit les réglages dans le chemin de registre approprié
• Se termine avec le code 0 (succès) ou 1 (échec)

Outils MDM pris en charge :

• Microsoft Intune (Platform Scripts)
• VMware Workspace ONE (Scripts & Sensors)
• Tout MDM capable d'exécuter PowerShell dans le contexte SYSTEM

Option de déploiement 2 : Microsoft Intune (provisionnement automatisé)

Les provisionneurs Intune automatisent le processus d'import des scripts vers Microsoft Intune via l'API Microsoft Graph.

Choisissez votre provisionneur :

Provisionneur PowerShell (Provision-*-Intune.ps1)

Prérequis :

• Machine Windows avec PowerShell 5.1+
• Module PowerShell Microsoft.Graph installé : Install-Module Microsoft.Graph
• Rôle Entra ID Global Administrator ou Intune Administrator

Étapes :

1. Extrayez le paquet ZIP
2. Accédez à : intune/
3. Clic droit sur Provision-ClaudeCode-Intune.ps1 → Run with PowerShell
4. Examinez l'invite de confirmation affichant :
   • Le nom et la version de la politique
   • Les autorisations Intune requises
   • Ce qui sera créé dans Intune
5. Tapez Y pour confirmer
6. Le navigateur s'ouvre pour une connexion Microsoft interactive (prend en charge la MFA)
7. Le script s'authentifie et importe le script côté appareil vers Intune
8. Le script affiche : L'ID du Platform Script Intune et une confirmation de succès

Étapes suivantes dans le portail Intune :

1. Allez dans : Devices → Scripts and remediations → Platform scripts
2. Trouvez votre script nouvellement créé (par ex. « Claude Code Policy v1 »)
3. Cliquez sur Assignments → Ajoutez des groupes d'appareils
4. Les appareils de ces groupes recevront la politique lors de leur prochain enregistrement

Provisionneur Python/MSAL (provision_*_intune.py)

Pourquoi utiliser Python ?

• Fonctionne sur Windows, macOS ou Linux
• Aucune inscription d'application requise
• Utilise le flux OAuth device-code (basé sur navigateur, fonctionne avec la MFA)
• Aucun secret à gérer

Prérequis :

pip install msal requests

Étapes :

1. Extrayez le paquet ZIP
2. Accédez à : intune/
3. Exécutez : python provision_claudecode_intune.py
4. Examinez l'invite de confirmation
5. Tapez yes pour confirmer
6. Le script affiche : « Go to https://microsoft.com/devicelogin and enter code: XXXXXX »
7. Ouvrez le navigateur, saisissez le code, connectez-vous avec un compte administrateur Intune
8. Le script termine l'import
9. Affectez aux groupes d'appareils dans le portail Intune (comme pour le flux PowerShell)

Avantages :

• Multiplateforme (aucun Windows requis)
• Aucune surcharge d'inscription d'application
• Authentification basée sur navigateur (flux MFA familier)
• Dépendances open source uniquement

Déploiement de politiques en masse (plusieurs politiques à la fois)

Pour les organisations gérant plusieurs politiques IA :

Utilisation du provisionneur multi-politiques :

1. Extrayez ai-policies-windows-deploy.zip
2. Accédez à : all-policy-import/
3. Exécutez soit :
   • PowerShell : Import-All-AIPolicies-Intune.ps1
   • Python : python import_all_aipolicies_intune.py
4. Un seul flux d'authentification importe toutes les politiques
5. Chaque politique devient un Platform Script Intune distinct

Résultat :

• Plusieurs scripts Intune créés en une seule exécution
• Chaque script peut être affecté à différents groupes d'appareils
• Utile pour déployer différentes configurations à différentes équipes (par ex. ingénierie vs marketing)

Vérifier le déploiement Windows

Sur un appareil de test :

1. Ouvrez l'Éditeur du Registre (regedit.exe)
2. Accédez à :
   • Claude Code : HKEY_LOCAL_MACHINE\SOFTWARE\Policies\ClaudeCode
   • Claude Desktop : HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Claude
3. Vérifiez que les valeurs de registre existent

Pour Claude Code :

• Recherchez une valeur nommée Settings (REG_SZ)
• La valeur contient du JSON compressé (sans sauts de ligne)

Pour Claude Desktop :

• Plusieurs valeurs, une par clé de réglage
• Chaque valeur est une chaîne (même pour les booléens/nombres)

4. Lancez l'application (Claude Code ou Claude Desktop)
5. Vérifiez que les réglages sont appliqués (par ex. sélection de modèle, points de terminaison API)

Dépannage :

• Si les valeurs de registre sont manquantes : Vérifiez les journaux d'exécution du script MDM
• Si l'app ignore les réglages : Assurez-vous que la version de l'app prend en charge les réglages gérés par registre
• Si le script échoue : Vérifiez metadata.json pour les erreurs de validation

Validation de schéma (Claude Code uniquement)

Les politiques Claude Code sont validées par rapport au schéma JSON officiel avant le déploiement :

La validation se produit à :

• L'exportation (dans Jamf Extender)
• L'exécution du script (le PowerShell côté appareil valide la syntaxe JSON)

Ce qui est validé :

• Les incompatibilités de type (par ex. chaîne alors qu'un booléen est attendu)
• Les valeurs d'énumération non valides (par ex. noms de modèles non pris en charge)
• Les clés de configuration inconnues
• Le nommage des variables d'environnement (doit être en majuscules, alphanumérique + traits de soulignement)

Les erreurs sont affichées :

• Dans le navigateur pendant l'export (bloque le téléchargement en cas d'erreurs critiques)
• Dans README.txt après l'export (avertissements uniquement)
• Dans la sortie du script PowerShell (échecs d'analyse JSON)

Claude Desktop :

• Aucun schéma publié (déployé tel quel)
• Les administrateurs sont responsables de la validation des réglages par rapport à la documentation de Claude Desktop

Bonnes pratiques de déploiement Windows

1. Testez avant la production

• Déployez d'abord sur un groupe d'appareils pilote
• Vérifiez que les valeurs de registre sont écrites correctement
• Testez le comportement de l'application avec les réglages gérés

2. Versionnez vos politiques

• La version de la politique est intégrée dans le nom du script Intune (par ex. « Claude Code Policy v2 »)
• La mise à jour d'une politique crée une nouvelle version
• Les anciennes versions restent dans Intune sauf suppression manuelle

3. Utilisez des noms de politique descriptifs

• Bon : « Claude Code - Engineering Team - GPT-4 Only »
• Mauvais : « Policy 1 », « Test », « asdf »
• Le nom de la politique apparaît dans la liste des Platform Scripts Intune

4. Gardez les identifiants sécurisés

• Les provisionneurs Intune utilisent une authentification interactive (aucun identifiant intégré)
• Les scripts côté appareil ne contiennent que le JSON de la politique (aucun secret)
• Ne validez jamais les paquets extraits dans un système de contrôle de version s'ils contiennent des réglages sensibles

5. Examinez avant le déploiement

• Vérifiez toujours README.txt dans le paquet
• Examinez les erreurs/avertissements de validation dans les métadonnées
• Testez la syntaxe du script PowerShell sur une machine de développement avant l'import MDM

Limitations du déploiement Windows

Ce que cela ne fait PAS :

• N'installe pas Claude Code ou Claude Desktop (nécessite un déploiement séparé)
• Ne bloque pas les outils IA au niveau processus (utilisez Jamf Protect pour cela)
• Ne fonctionne pas sur macOS (utilisez des profils MDM macOS ou des réglages basés sur fichiers)
• Ne se déploie pas sur les terminaux Linux

Registre uniquement :

• Les réglages basés sur fichiers (par ex. settings.json dans les répertoires d'apps) ne sont PAS écrits
• Les applications doivent lire depuis les emplacements de politique du registre
• Vérifiez que la version de votre app prend en charge les réglages gérés basés sur registre

Assistance et retours

• GitHub Issues : https://github.com/Jamf-Concepts/Jamf-Extender/issues
• Documentation : https://github.com/Jamf-Concepts/Jamf-Extender
• Questions : Ouvrez un ticket avec l'étiquette « question »

Si vous découvrez des identifiants de signature pour des outils inconnus :

1. Exécutez : codesign -dv /Applications/YourApp.app
2. Capturez : Bundle ID, Team ID, domaines
3. Soumettez un ticket GitHub avec le rapport de validation joint

Votre contribution aide toute la communauté Jamf !