Rôles et Permissions

Les rôles utilisateur définissent les niveaux d'accès et les capacités au sein de mindzieStudio. Chaque utilisateur se voit attribuer un rôle unique qui détermine ses autorisations sur la plateforme.

Lorsque vous envoyez une valeur roleName à l'API, utilisez exactement les chaînes indiquées dans la colonne API role name ci-dessous.

Rôles disponibles

Rôle (affichage)	Nom de rôle API	Portée	Description
Administrateur Serveur	`TenantAdmin`	Système	Niveau d'accès le plus élevé. Portée complète sur tous les locataires et le serveur.
Administrateur	`Administrator`	Locataire	Autorité administrative complète au sein d'un locataire.
Administrateur IT	`ITAdmin`	Locataire	Intégrations, connexions, et clés API globales.
Analyste	`Analyst`	Projet	Créer et gérer analyses, tableaux de bord, et enquêtes.
Développeur	`Developer`	Projet	Construire des intégrations, gérer actions et applications, consulter le détail des exceptions.
Utilisateur	`User`	Lecture seule	Consulter tableaux de bord et analyses ; ne peut pas modifier le contenu.

Note sur la terminologie. Le nom de rôle API TenantAdmin est le rôle avec les privilèges les plus élevés dans mindzieStudio — malgré son nom, il dispose d'une portée serveur entière (gérer tous les locataires, gérer tous les utilisateurs, administration du serveur). Pour plus de clarté, cette page le désigne également comme Administrateur Serveur. Lors de l'attribution via l'API, envoyez TenantAdmin.

Détails des rôles

Administrateur Serveur (`TenantAdmin`)

Le niveau de privilège le plus élevé dans mindzieStudio.

Capacités :

Accéder et gérer tous les locataires et projets
Créer, modifier et supprimer des locataires
Gérer tous les utilisateurs du système
Ouvrir la zone d’administration du serveur (mémoire serveur, sauvegardes, exécutions)
Se faire passer pour d’autres rôles pour support et tests
Créer des clés API globales
Toutes les capacités des autres rôles

Cas d’utilisation :

Propriétaires de la plateforme
Opérateurs de confiance assurant la maintenance du déploiement

Administrateur

Autorité administrative complète au sein d’un locataire, sans portée serveur.

Capacités :

Gérer les utilisateurs dans le locataire — créer, modifier, désactiver, réinitialiser les mots de passe
Attribuer des rôles dans le locataire
Gérer les modèles d’analyse
Gérer tous les projets, tableaux de bord, jeux de données, enquêtes et applications du locataire
Créer des clés API de locataire
Ne peut pas créer ou supprimer des locataires
Ne peut pas accéder à la zone d’administration du serveur

Cas d’utilisation :

Chefs de département
Administrateurs clients gérant leur propre locataire

Administrateur IT (`ITAdmin`)

Accès technique centré sur les intégrations et l’infrastructure de données.

Capacités :

Configurer intégrations, connexions et sources de données
Gérer les données et opérations ETL
Créer des clés API globales
Accès limité à la création — ne construit pas de tableaux de bord ou d’analyses

Cas d’utilisation :

Personnel IT connectant les systèmes sources
Opérateurs gérant identifiants et ETL

Analyste

Rôle utilisateur standard pour l’analyse de process mining.

Capacités :

Créer et gérer enquêtes et notebooks
Importer et configurer jeux de données
Créer tableaux de bord et rapports
Exécuter notebooks et blocs
Gérer actions et applications
Exporter les résultats d’analyses

Cas d’utilisation :

Analystes de processus
Data scientists
Analystes métier

Développeur

Accès aux outils de développement et APIs.

Capacités :

Utiliser outils de développement et APIs de la plateforme
Construire intégrations et extensions personnalisées
Gérer actions et applications
Consulter le détail des exceptions pour débogage
Créer et gérer analyses et tableaux de bord

Cas d’utilisation :

Ingénieurs développant intégrations
Automatisation et consommateurs d’API

Utilisateur

Accès en lecture seule pour consulter tableaux de bord et analyses.

Capacités :

Voir tableaux de bord partagés
Voir analyses publiées
Voir alertes
Exporter les données visibles
Ne peut modifier aucun contenu

Cas d’utilisation :

Cadres dirigeants
Parties prenantes
Examinateurs externes

Hiérarchie des rôles

Administrateur Serveur  (TenantAdmin)
    |
    +-- Administrateur
            |
            +-- Analyste, Développeur, Administrateur IT
                    |
                    +-- Utilisateur

TenantAdmin a la portée la plus large (tous les locataires, administration du serveur). Administrateur dispose d’une autorité totale dans son locataire. Les autres rôles sont limités au niveau projet ou en lecture seule.

Comptes de service

Les comptes de service sont des comptes utilisateurs spéciaux conçus pour les intégrations API et flux automatisés.

Exigences

Seuls les rôles Administrateur Serveur (TenantAdmin) et Administrateur sont éligibles
Les comptes de service doivent avoir un locataire principal assigné
Les comptes de service peuvent s’authentifier via l’API sans connexion utilisateur

Configuration

Pour promouvoir un utilisateur en compte de service :

{
  "isServiceAccount": true,
  "homeTenantId": "12345678-1234-1234-1234-123456789012"
}

Pour rétrograder en utilisateur classique :

{
  "isServiceAccount": false
}

Le homeTenantId est automatiquement effacé lors de la rétrogradation.

Cas d’utilisation

Intégrations de pipeline CI/CD
Scripts automatisés d’import de données
Génération planifiée de rapports
Processus ETL
Systèmes de surveillance et alertes

Attribution des rôles

Lors de la création des utilisateurs

Spécifiez le rôle dans la requête de création :

{
  "email": "john.smith@example.com",
  "displayName": "John Smith",
  "roleName": "Analyst"
}

Lors de la mise à jour des utilisateurs

Modifiez le rôle avec une requête de mise à jour :

{
  "roleName": "TenantAdmin"
}

Envoyez le nom de rôle API exactement comme listé dans le tableau ci-dessus (TenantAdmin, Administrator, ITAdmin, Analyst, Developer ou User).

Types de clés API et rôles

Type de clé API	Rôles créateurs éligibles	Portée d'accès
Clé API globale	Administrateur Serveur (`TenantAdmin`), Administrateur IT (`ITAdmin`)	Tous les locataires, tous les points d’extrémité
Clé API locataire	Administrateur Serveur (`TenantAdmin`), Administrateur, Développeur	Un seul locataire uniquement

Points d’extrémité clés API globales

Seules les clés API globales peuvent accéder à :

/api/user - Gestion globale des utilisateurs
/api/tenant - Gestion des locataires
Opérations multi-locataires

Points d’extrémité clés API locataires

Les clés API locataires peuvent accéder à :

/api/tenant/{tenantId}/user - Gestion des utilisateurs du locataire
/api/{tenantId}/project - Opérations de projet
/api/{tenantId}/dataset - Opérations de jeu de données
Tous les autres points d’extrémité à portée locataire

Bonnes pratiques

Principe du moindre privilège

Attribuez le rôle minimum nécessaire à la fonction de travail de chaque utilisateur.

Cadre consultant les tableaux de bord     -> Utilisateur
Analyste réalisant des enquêtes            -> Analyste
Chef d’équipe gérant un locataire          -> Administrateur
Opérateur de plateforme gérant tous les locataires -> Administrateur Serveur (TenantAdmin)

Sécurité des comptes de service

Créez des comptes de service dédiés pour chaque intégration
Utilisez des noms d’affichage descriptifs (ex. : "Service Pipeline CI/CD")
Renouvelez régulièrement les clés API
Surveillez l’activité des comptes de service

Transitions de rôle

Lors de promotions, vérifiez que les utilisateurs comprennent leurs nouvelles responsabilités
Lors de rétrogradations, assurez-vous qu’ils peuvent terminer leur travail
Documentez les changements de rôle pour audit

Désactivation vs Suppression

Préférez désactiver les utilisateurs plutôt que de les supprimer pour préserver les traces d’audit
Les utilisateurs désactivés ne peuvent pas se connecter mais leur historique est conservé
Supprimez uniquement pour raisons de confidentialité des données

Exemples d’implémentation

Python

import requests

BASE_URL = 'https://your-mindzie-instance.com'

class RoleManager:
    def __init__(self, global_api_key):
        self.headers = {
            'Authorization': f'Bearer {global_api_key}',
            'Content-Type': 'application/json'
        }

    def get_users_by_role(self, role_name):
        """Récupérer tous les utilisateurs avec un rôle spécifique."""
        url = f'{BASE_URL}/api/user'
        params = {'role': role_name, 'pageSize': 1000}
        response = requests.get(url, headers=self.headers, params=params)
        response.raise_for_status()
        return response.json()

    def promote_to_service_account(self, user_id, home_tenant_id):
        """Promouvoir un utilisateur en compte de service."""
        url = f'{BASE_URL}/api/user/{user_id}'
        payload = {
            'isServiceAccount': True,
            'homeTenantId': home_tenant_id
        }
        response = requests.put(url, json=payload, headers=self.headers)
        response.raise_for_status()
        return response.json()

    def demote_from_service_account(self, user_id):
        """Rétrograder un compte de service en utilisateur standard."""
        url = f'{BASE_URL}/api/user/{user_id}'
        payload = {'isServiceAccount': False}
        response = requests.put(url, json=payload, headers=self.headers)
        response.raise_for_status()
        return response.json()

    def change_role(self, user_id, new_role):
        """Modifier le rôle d’un utilisateur. Utilisez les noms de rôle API : TenantAdmin, Administrator, ITAdmin, Analyst, Developer, User."""
        url = f'{BASE_URL}/api/user/{user_id}'
        payload = {'roleName': new_role}
        response = requests.put(url, json=payload, headers=self.headers)
        response.raise_for_status()
        return response.json()

    def disable_user(self, user_id):
        """Désactiver un compte utilisateur."""
        url = f'{BASE_URL}/api/user/{user_id}'
        payload = {'disabled': True}
        response = requests.put(url, json=payload, headers=self.headers)
        response.raise_for_status()
        return response.json()

# Utilisation
manager = RoleManager('your-global-api-key')

# Liste de tous les administrateurs serveur (rôle TenantAdmin)
server_admins = manager.get_users_by_role('TenantAdmin')
print(f"Le système compte {server_admins['totalCount']} administrateurs serveur")

# Promouvoir un utilisateur en compte de service
manager.promote_to_service_account(
    user_id='a1b2c3d4-e5f6-7890-abcd-ef1234567890',
    home_tenant_id='12345678-1234-1234-1234-123456789012'
)

# Promouvoir un Analyste en Administrateur Serveur
manager.change_role(
    user_id='a1b2c3d4-e5f6-7890-abcd-ef1234567890',
    new_role='TenantAdmin'
)

# Désactiver un utilisateur au lieu de le supprimer
manager.disable_user('departing-user-id')

JavaScript

class RoleManager {
  constructor(globalApiKey) {
    this.headers = {
      'Authorization': `Bearer ${globalApiKey}`,
      'Content-Type': 'application/json'
    };
  }

  async getUsersByRole(roleName) {
    const url = `${BASE_URL}/api/user?role=${roleName}&pageSize=1000`;
    const response = await fetch(url, { headers: this.headers });
    return await response.json();
  }

  async promoteToServiceAccount(userId, homeTenantId) {
    const url = `${BASE_URL}/api/user/${userId}`;
    const response = await fetch(url, {
      method: 'PUT',
      headers: this.headers,
      body: JSON.stringify({
        isServiceAccount: true,
        homeTenantId
      })
    });
    return await response.json();
  }

  async changeRole(userId, newRole) {
    // Utilisez les noms de rôle API : TenantAdmin, Administrator, ITAdmin, Analyst, Developer, User
    const url = `${BASE_URL}/api/user/${userId}`;
    const response = await fetch(url, {
      method: 'PUT',
      headers: this.headers,
      body: JSON.stringify({ roleName: newRole })
    });
    return await response.json();
  }
}

// Utilisation
const manager = new RoleManager('your-global-api-key');

// Obtenir tous les analystes
const analysts = await manager.getUsersByRole('Analyst');
console.log(`${analysts.totalCount} analystes dans le système`);

// Promouvoir en Administrateur Serveur
await manager.changeRole('user-id', 'TenantAdmin');

Rôles et Permissions

Rôles disponibles

Détails des rôles

Administrateur Serveur (TenantAdmin)

Administrateur

Administrateur IT (ITAdmin)

Analyste

Développeur

Utilisateur

Hiérarchie des rôles

Comptes de service

Exigences

Configuration

Cas d’utilisation

Attribution des rôles

Lors de la création des utilisateurs

Lors de la mise à jour des utilisateurs

Types de clés API et rôles

Points d’extrémité clés API globales

Points d’extrémité clés API locataires

Bonnes pratiques

Principe du moindre privilège

Sécurité des comptes de service

Transitions de rôle

Désactivation vs Suppression

Exemples d’implémentation

Python

JavaScript

Administrateur Serveur (`TenantAdmin`)

Administrateur IT (`ITAdmin`)