Rollen & Berechtigungen

Benutzerrollen definieren Zugriffslevel und Fähigkeiten innerhalb von mindzieStudio. Jedem Benutzer wird eine einzelne Rolle zugewiesen, die seine Berechtigungen auf der gesamten Plattform bestimmt.

Wenn Sie einen roleName-Wert an die API senden, verwenden Sie die exakten Zeichenfolgen, die in der Spalte API role name unten angegeben sind.

Verfügbare Rollen

Rolle (Anzeige)	API role name	Umfang	Beschreibung
Server Administrator	`TenantAdmin`	System	Höchstes Zugriffslevel. Voller Zugriff auf alle Mandanten und den Server.
Administrator	`Administrator`	Mandant	Volle administrative Befugnis innerhalb eines Mandanten.
IT Admin	`ITAdmin`	Mandant	Integrationen, Verbindungen und globale API-Schlüssel.
Analyst	`Analyst`	Projekt	Analysen, Dashboards und Untersuchungen erstellen und verwalten.
Developer	`Developer`	Projekt	Integrationen entwickeln, Aktionen und Apps verwalten, Ausnahme-Details anzeigen.
User	`User`	Nur Lesen	Dashboards und Analysen anzeigen; Inhalte nicht ändern.

Hinweis zur Benennung. Die API-Rollenbezeichnung TenantAdmin ist die Rolle mit dem höchsten Privileg in mindzieStudio — trotz des Namens umfasst sie serverweiten Zugriff (Verwaltung aller Mandanten, aller Benutzer, Serveradministration). Um Verwirrung zu vermeiden, wird sie auf dieser Seite auch als Server Administrator bezeichnet. Beim Zuweisen der Rolle über die API senden Sie TenantAdmin.

Rollendetails

Server Administrator (`TenantAdmin`)

Das höchste Privilegienlevel in mindzieStudio.

Fähigkeiten:

Zugriff und Verwaltung aller Mandanten und Projekte
Mandanten erstellen, ändern und löschen
Verwaltung aller Benutzer im System
Zugriff auf den Bereich der Serveradministration (Server-Speicher, Sicherungen, Ausführungen)
Rollen anderer übernehmen für Support und Tests
Globale API-Schlüssel erstellen
Alle Fähigkeiten aller anderen Rollen

Anwendungsfälle:

Plattformbesitzer
Vertrauenswürdige Betreiber, die die Bereitstellung verwalten

Administrator

Volle administrative Befugnis innerhalb eines Mandanten, ohne serverweiten Zugriff.

Fähigkeiten:

Benutzer im Mandanten verwalten — erstellen, bearbeiten, deaktivieren, Passwörter zurücksetzen
Rollen innerhalb des Mandanten zuweisen
Analysevorlagen verwalten
Alle Projekte, Dashboards, Datensätze, Untersuchungen und Apps im Mandanten verwalten
Mandanten-API-Schlüssel erstellen
Keine Mandanten erstellen oder löschen
Kein Zugriff auf den Bereich der Serveradministration

Anwendungsfälle:

Abteilungsleiter
Kundenadministratoren, die ihren eigenen Mandanten verwalten

IT Admin (`ITAdmin`)

Technischer Konfigurationszugang mit Schwerpunkt auf Integrationen und Dateninfrastruktur.

Fähigkeiten:

Integrationen, Verbindungen und Datenquellen konfigurieren
Daten- und ETL-Prozesse verwalten
Globale API-Schlüssel erstellen
Begrenzte Autorisierungsrechte — erstellt keine Dashboards oder Analysen

Anwendungsfälle:

IT-Personal, das Quellsysteme verbindet
Betreiber, die Zugangsdaten und ETL verwalten

Analyst

Standard-Benutzerrolle für Prozess-Mining-Analysen.

Fähigkeiten:

Untersuchungen und Notebooks erstellen und verwalten
Datensätze hochladen und konfigurieren
Dashboards und Berichte erstellen
Notebooks und Blöcke ausführen
Aktionen und Apps verwalten
Analyseergebnisse exportieren

Anwendungsfälle:

Prozessanalysten
Data Scientists
Business-Analysten

Developer

Zugriff auf Entwicklungstools und APIs.

Fähigkeiten:

Nutzung von Entwicklungstools und Plattform-APIs
Eigene Integrationen und Erweiterungen entwickeln
Aktionen und Apps verwalten
Ausnahme-Details zur Fehlerbehebung anzeigen
Analysen und Dashboards erstellen und verwalten

Anwendungsfälle:

Techniker, die Integrationen bauen
Automatisierungs- und API-Nutzer

User

Nur-Lese-Zugriff zum Konsumieren von Dashboards und Analysen.

Fähigkeiten:

Geteilte Dashboards anzeigen
Veröffentliche Analysen anzeigen
Benachrichtigungen ansehen
Sichtbare Daten exportieren
Keine inhaltlichen Änderungen möglich

Anwendungsfälle:

Führungskräfte
Stakeholder
Externe Prüfer

Rollen-Hierarchie

Server Administrator  (TenantAdmin)
    |
    +-- Administrator
            |
            +-- Analyst, Developer, IT Admin
                    |
                    +-- User

TenantAdmin hat den breitesten Zugriff (alle Mandanten, Serveradministration). Administrator hat volle Befugnisse innerhalb seines Mandanten. Die übrigen Rollen sind auf Projektebene oder nur lesend beschränkt.

Service-Konten

Service-Konten sind spezielle Benutzerkonten, die für API-Integrationen und automatisierte Workflows vorgesehen sind.

Anforderungen

Nur die Rollen Server Administrator (TenantAdmin) und Administrator sind berechtigt
Service-Konten müssen einen Heimat-Mandanten zugewiesen bekommen
Service-Konten können sich über die API ohne Benutzer-Login authentifizieren

Konfiguration

Um einen Benutzer zu einem Service-Konto zu befördern:

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

Um ihn wieder zum normalen Benutzer herabzustufen:

{
  "isServiceAccount": false
}

Die homeTenantId wird beim Herabstufen automatisch gelöscht.

Anwendungsfälle

CI/CD-Pipeline-Integrationen
Automatisierte Datenimport-Skripte
Geplante Berichtserstellung
ETL-Prozesse
Überwachungs- und Alarmsysteme

Rollenzuweisung

Beim Erstellen von Benutzern

Geben Sie die Rolle in der Erstellungsanfrage an:

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

Beim Aktualisieren von Benutzern

Ändern Sie die Rolle mit einer Aktualisierungsanfrage:

{
  "roleName": "TenantAdmin"
}

Senden Sie den API-Rollennamen exakt so, wie in der obigen Tabelle aufgeführt (TenantAdmin, Administrator, ITAdmin, Analyst, Developer oder User).

API-Schlüsseltypen und Rollen

API-Schlüsseltyp	Berechtigte Erstellerrollen	Zugriffsbereich
Globaler API-Schlüssel	Server Administrator (`TenantAdmin`), IT Admin (`ITAdmin`)	Alle Mandanten, alle Endpunkte
Mandanten-API-Schlüssel	Server Administrator (`TenantAdmin`), Administrator, Developer	Nur einzelner Mandant

Endpunkte für globale API-Schlüssel

Nur globale API-Schlüssel können auf Folgendes zugreifen:

/api/user - Globale Benutzerverwaltung
/api/tenant - Mandantenverwaltung
Mandantenübergreifende Vorgänge

Endpunkte für Mandanten-API-Schlüssel

Mandanten-API-Schlüssel können auf Folgendes zugreifen:

/api/tenant/{tenantId}/user - Mandantenbenutzerverwaltung
/api/{tenantId}/project - Projektvorgänge
/api/{tenantId}/dataset - Datensatzvorgänge
Alle weiteren mandantenspezifischen Endpunkte

Best Practices

Prinzip der minimalen Rechte

Weisen Sie jedem Benutzer die jeweils minimal erforderliche Rolle für seine Aufgaben zu.

Führungskraft, die Dashboards ansieht     -> User
Analyst, der Untersuchungen durchführt   -> Analyst
Teamleiter, der einen Mandanten verwaltet -> Administrator
Plattformbetreiber, der alle Mandanten verwaltet -> Server Administrator (TenantAdmin)

Sicherheit von Service-Konten

Erstellen Sie dedizierte Service-Konten für jede Integration
Verwenden Sie beschreibende Anzeigenamen (z. B. "CI/CD Pipeline Service")
Rotieren Sie API-Schlüssel regelmäßig
Überwachen Sie Aktivitäten von Service-Konten

Rollenwechsel

Bei Beförderung sicherstellen, dass der Benutzer die neuen Verantwortlichkeiten versteht
Bei Herabstufung sicherstellen, dass der Benutzer seine Arbeit abschließen kann
Änderungen dokumentieren für Audit-Zwecke

Deaktivieren vs. Löschen

Deaktivieren von Benutzern bevorzugen, um Audit-Trails zu erhalten
Deaktivierte Benutzer können sich nicht anmelden, ihre Historie bleibt erhalten
Löschen nur bei zwingender Einhaltung von Datenschutzanforderungen

Implementierungsbeispiele

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):
        """Alle Benutzer mit einer bestimmten Rolle abrufen."""
        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):
        """Einen Benutzer zum Service-Konto befördern."""
        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):
        """Ein Service-Konto wieder zum regulären Benutzer herabstufen."""
        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):
        """Die Rolle eines Benutzers ändern. API-Rollennamen verwenden: 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):
        """Einen Benutzer deaktivieren."""
        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()

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

# Alle Server Administratoren (TenantAdmin-Rolle) auflisten
server_admins = manager.get_users_by_role('TenantAdmin')
print(f"Das System hat {server_admins['totalCount']} Server-Administratoren")

# Benutzer zum Service-Konto befördern
manager.promote_to_service_account(
    user_id='a1b2c3d4-e5f6-7890-abcd-ef1234567890',
    home_tenant_id='12345678-1234-1234-1234-123456789012'
)

# Einen Analysten zum Server Administrator befördern
manager.change_role(
    user_id='a1b2c3d4-e5f6-7890-abcd-ef1234567890',
    new_role='TenantAdmin'
)

# Einen Benutzer deaktivieren statt löschen
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) {
    // API-Rollennamen verwenden: 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();
  }
}

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

// Alle Analysten abrufen
const analysts = await manager.getUsersByRole('Analyst');
console.log(`${analysts.totalCount} Analysten im System`);

// Zum Server Administrator befördern
await manager.changeRole('user-id', 'TenantAdmin');

Rollen & Berechtigungen

Verfügbare Rollen

Rollendetails

Server Administrator (TenantAdmin)

Administrator

IT Admin (ITAdmin)

Analyst

Developer

User

Rollen-Hierarchie

Service-Konten

Anforderungen

Konfiguration

Anwendungsfälle

Rollenzuweisung

Beim Erstellen von Benutzern

Beim Aktualisieren von Benutzern

API-Schlüsseltypen und Rollen

Endpunkte für globale API-Schlüssel

Endpunkte für Mandanten-API-Schlüssel

Best Practices

Prinzip der minimalen Rechte

Sicherheit von Service-Konten

Rollenwechsel

Deaktivieren vs. Löschen

Implementierungsbeispiele

Python

JavaScript

Server Administrator (`TenantAdmin`)

IT Admin (`ITAdmin`)