Mikroapps

Konfigurieren von Benutzeranbietern

Durch das Konfigurieren von Benutzeranbietern müssen Benutzergruppen, die in Ihrem SoR (System of Record) bei der Identitätsanbieterkonfiguration erstellt und in den zugehörigen Einstellungen gewartet werden, nicht repliziert und synchronisiert werden und lassen sich damit leichter verwalten.

Mikroappadministratoren können mithilfe konfigurierter Benutzeranbieter Daten zu Benutzern und Benutzergruppen aus Ihrem SoR erfassen und anhand dieser Daten Mikroappabonnements in allen Integrationen verwalten. Um Benutzeranbieter zu konfigurieren, muss das SoR Ihrer Anwendung APIs bereitstellen, mit denen Benutzer/Benutzergruppen verfügbar gemacht werden, z. B. ServiceNow, Salesforce, Jira usw.

Erstellen eines Benutzeranbieters

Sie können einen neuen Benutzeranbieter entweder manuell erstellen oder einen bereits konfigurierten Benutzeranbieter importieren.

Führen Sie folgende Schritte aus:

  1. Wählen Sie auf der Seite Mikroappintegrationen in der oberen Leiste die Registerkarte Benutzeranbieter aus.

    Registerkarte Benutzeranbieter

  2. Wählen Sie einen Benutzeranbietertyp aus. Wählen Sie Neuen Benutzeranbieter über den HTTP-Webdienst erstellen, um den Benutzeranbieter manuell zu konfigurieren. Sie können auch die Option Zuvor konfigurierten Benutzeranbieter importieren wählen. Weitere Informationen zum Importieren finden Sie unter Import.
  3. Geben Sie unter Benutzeranbietername einen Namen für die Verbindung ein.
  4. Geben Sie die Basis-URL für den Benutzeranbieter an.
  5. Wählen Sie ein Symbol für die Integration aus der Symbolbibliothek aus oder lassen Sie das Standardsymbol.
  6. Wählen Sie die Authentifizierungsmethode für die Dienstauthentifizierung aus und füllen Sie alle erforderlichen Details basierend auf der von Ihnen verwendeten Authentifizierungsmethode aus. Weitere Informationen zu Authentifizierungsmethoden finden Sie unter Einrichten der Dienstauthentifizierung.
  7. (Optional) Aktivieren Sie bei Bedarf Anforderungsratenlimit aktivieren und geben Sie Werte für Anzahl der Anforderungen und Zeitintervall ein.
  8. (Optional) Geben Sie ggf. einen Wert für Anforderungstimeout ein.
  9. Wählen Sie Hinzufügen aus, um die Erstellung des Benutzeranbieters abzuschließen.

    Konfigurationsbildschirm für Benutzeranbieter

    Importieren Sie zum Abschluss ein Skript.

Skript importieren

Wenn Sie in Mikroapps die Funktion Benutzeranbieterskript verwenden, müssen Sie ein Skript hochladen, um die Einrichtung des Benutzeranbieters abzuschließen. Nachstehend finden Sie Skriptanforderungen und ein JavaScript-Modell. Weitere Informationen finden Sie unter Vorbereiten des Skripts. Allgemeine Informationen zum Skripting finden Sie unter HTTP-Integrationsskripting.

Nachdem Sie mit dem zuvor beschriebenen Verfahren den Benutzeranbieter hinzugefügt haben, wird die Seite mit einer Ansicht Ihrer Benutzeranbieter geöffnet. Befolgen Sie diese Schritte, um das Skript hinzuzufügen.

  1. Wählen Sie unter Status die Option Script hinzufügen aus.
  2. Wählen Sie Skript importieren.
  3. Ziehen Sie Ihr Skript auf das Popupfenster zum Importieren oder suchen Sie nach der Datei. Das Skript muss eine JS-Datei sein, die nicht größer als 1 MB ist.

    Das Skript wird analysiert und validiert.

  4. Wählen Sie zum Abschluss Importieren aus.

    Sie können Skriptdetails unter Skripthandler in der Ansicht Benutzeranbieterskript des Benutzeranbieters anzeigen. Um Anfragen des Skripts anzuzeigen, wählen Sie das Menü neben dem Benutzeranbietereintrag aus und wählen Sie Protokoll synchronisieren aus.

Beim Zuweisen von Abonnenten ist Ihr neuer Benutzeranbieter jetzt verfügbar. Weitere Informationen finden Sie unter Verwalten von Abonnenten.

Benutzeranbieter in Abonnements

Vorbereiten des Skripts

Berücksichtigen Sie bei der Vorbereitung Ihres Skripts Folgendes:

  • Das Importskript muss mit dem Laden der integrierten Bibliothek “microapp-user-groups” beginnen. Diese Bibliothek definiert die Objekte, die in der Datenbank gespeichert werden müssen: const { User, Group, UserGroupMapping } = library.load("microapp-user-groups");
  • Objekte haben folgende Struktur/Eigenschaften:

    • User(accountName, displayName, email, domain, userPrincipalName, userId) E-Mail-Adressen müssen innerhalb des Benutzeranbieters eindeutig sein.
    • Group(accountName, displayName, domain, userPrincipalName, groupId, parentGroupId) Die Gruppenhierarchie wird auch mit parentGroupId definiert.
    • UserGroupMapping(userId, groupId) Ordnet Benutzer den Gruppen zu.
  • Alle Eigenschaften sind der Datentyp STRING.
  • user.email muss mit der E-Mail eines bei Citrix Workspace angemeldeten Benutzers übereinstimmen.

Modellskript

Verwenden Sie den folgenden JavaScript-Code als Modell.

Hinweis

Das folgende Modell wurde speziell für das SoR von ServiceNow geschrieben. Dieses Skript ist nicht mit anderen Diensten kompatibel.

    const { User, Group, UserGroupMapping } = library.load("microapp-user-groups");

    function fullSync(params) {
      fullSyncUsers(params);
      fullSyncGroups(params);
      fullSyncUserGroupMapping(params);
    }

    function fullSyncUsers({ client, dataStore }) {
      let offset = 0;
      do {
        const response = client.fetchSync(
          `/api/now/table/sys_user?sysparm_fields=sys_domain_path%2Cname%2C%20sys_id%2Cuser_name%2Cemail&sysparm_query=emailISNOTEMPTY^active%3Dtrue&sysparm_limit=100&sysparm_offset=${offset}`
        );
        if (!response.ok) {
          console.log("Error status:", response.status, response.statusText);
          console.log("Error body:", response.textSync());
          throw new Error("Network response was not ok");
        }
        console.log("fetch done");

        const users = response.jsonSync().result;
        console.log("users");

        users.map((user) =>
          console.log(
            user.user_name,
            user.name,
            user.email,
            user.sys_domain_path,
            user.name,
            user.sys_id
          )
        );
        dataStore.save(
          User.tableModel,
          users.map(
            (user) =>
              new User(
                user.user_name,
                user.name,
                user.email,
                user.sys_domain_path,
                user.user_name,
                user.sys_id
              )
          )
        );

        offset = offset + 100;
        console.log(`offset: ${offset}`);
      } while (offset < 300);
    }

    function fullSyncGroups({ client, dataStore }) {
      let offset = 0;
      do {
        const response = client.fetchSync(
          `/api/now/table/sys_user_group?sysparm_query=active%3Dtrue&sysparm_limit=100&sysparm_offset=${offset}`
        );
        if (!response.ok) {
          console.log("Error status:", response.status, response.statusText);
          console.log("Error body:", response.textSync());
          throw new Error("Network response was not ok");
        }

        const groups = response.jsonSync().result;
        groups.map((group) =>
          console.log(
            group.name,
            group.name,
            "/",
            group.name,
            group.sys_id,
            group.parent.value
          )
        );
        dataStore.save(
          Group.tableModel,
          groups.map(
            (group) =>
              new Group(
                group.name,
                group.name,
                "/",
                group.name,
                group.sys_id,
                group.parent.value
              )
          )
        );
        offset = offset + 100;
        console.log(`offset: ${offset}`);
      } while (offset < 400);
    }

    function fullSyncUserGroupMapping({ client, dataStore }) {
      let offset = 0;
      do {
        const response = client.fetchSync(
          `/api/now/table/sys_user_grmember?&sysparm_limit=100&sysparm_offset=${offset}`
        );
        if (!response.ok) {
          console.log("Error status:", response.status, response.statusText);
          console.log("Error body:", response.textSync());
          throw new Error("Network response was not ok");
        }

        const mappings = response.jsonSync().result;
        mappings.map((mapping) =>
          console.log(mapping.user.value, mapping.group.value)
        );
        dataStore.save(
          UserGroupMapping.tableModel,
          mappings.map(
            (mapping) =>
              new UserGroupMapping(mapping.user.value, mapping.group.value)
          )
        );
        offset = offset + 100;
        console.log(`offset: ${offset}`);
      } while (offset < 400);
    }

    integration.define({
      synchronizations: [
        {
          name: "snowUserGroups", // Logical name
          fullSyncFunction: fullSync,
        },
      ],
      model: {
        tables: [User.tableModel, Group.tableModel, UserGroupMapping.tableModel],
      },
    });
<!--NeedCopy-->
Konfigurieren von Benutzeranbietern