Configuration de l'accès anonyme

Vue d'ensemble (Overview)

L'accès anonyme vous permet d'intégrer des agents conversationnels pour les utilisateurs qui ne disposent pas de comptes UiPath. Cela est utile pour les applications destinées aux clients, les portails publics ou tout scénario dans lequel vous souhaitez que les utilisateurs interagissent avec votre agent sans avoir besoin de l'authentification UiPath.

L'accès anonyme nécessite :

1. Une application externe confidentielle configurée dans UiPath Admin
2. Un point de terminaison de jeton hébergé par votre organisation pour gérer l'authentification
3. Une URL d’agent intégrée configurée avec les paramètres d’authentification

Avertissement :

Les applications externes à l'échelle de l'application confidentielle permettent un accès anonyme sans authentification de l'utilisateur. Configurez avec soin les autorisations afin d'empêcher l'accès involontaire aux données. Nous vous recommandons fortement de garder les agents anonymes derrière votre propre portail ou de vous connecter pour atténuer les abus.

Utilisateurs concernés : les utilisateurs qui doivent accéder aux agents conversationnels sans compte Automation Cloud.

Prérequis

Avant de commencer, vérifiez que vous avez :

• Un agent conversationnel publié dans Orchestrator.
• Accès pour l'administrateur de l'organisation au portail d'administration UiPath.
• Infrastructure pour héberger une fonction sans serveur ou un point de terminaison d'API (par exemple, AWS Lambda, Fonctions Azure, Fonctions Cloud.

Étape 1 : Créez l'application externe

1. Depuis la page d'accueil UiPath, accédez à Admin.
2. Sélectionnez External Apps.
3. Sélectionnez Ajouter une application.
4. Remplissez les détails de l'application :
   • Nom de l'application: donnez un nom descriptif à l'application.
   • Type d'application: sélectionnez Application confidentielle.
5. Ajoutez les étendues suivantes en tant qu’étendues d’application:

API	Portée
Accès à l'API Orchestrator	OR.Jobs
Accès à l'API Orchestrator	OR.Execution
Accès à l'API Orchestrator	OR.Users
Accès à l'API Orchestrator	OR.Folders
Accès à l'API Traçages	Traces.Api
Agents conversationnels	ConversationalAgents

6. Cliquez sur Ajouter (une URL de redirection n'est pas nécessaire pour ce client).
7. Une fenêtre contextuelle affiche l’ ID de l’application et la clé secrète de l’application.

Important :

Copiez la clé secrète de l'application et stockez-la en toute sécurité. Vous ne pourrez plus l'afficher à nouveau après la fermeture de cette fenêtre, et vous en aurez besoin lors de la création du point de terminaison du jeton.

Remarque :

Si vous ajoutez des étendues en tant qu'étendues d'utilisateur au lieu d'étendues d'application, l'application de chat va demander à l'utilisateur de se connecter, contrairement à l'objectif de l'accès anonyme.

Étape 2 : Configurez les autorisations de l'application externe

Après avoir créé l’application externe, configurez ses autorisations afin de contrôler les ressources auxquelles l’agent anonyme peut accéder.

Attribuer un accès au niveau du locataire

1. Accédez à Orchestrator.
2. Sélectionnez Locataire en haut à gauche.
3. Sélectionnez Gérer l'accès dans la barre d'outils.
4. Sélectionnez Applications externes.
5. Sélectionnez Attribuer une application externe.
6. Recherchez et sélectionnez l'application externe que vous avez créée.
7. Sous Rôles supplémentaires, sélectionnez les rôles requis :
   • Minimum requis : Automation User.
   • Ajoutez des rôles supplémentaires uniquement dans la mesure nécessaire à votre cas d'utilisation.
8. Sélectionnez Attribuer.

Attribuer un accès au niveau du dossier

1. Accédez à Dossiers dans Orchestrator.
2. Pour chaque dossier auquel l'agent doit accéder :
   1. Sélectionnez le dossier.
   2. Sélectionnez Attribuer un(e) compte/groupe/application externe.
   3. Sélectionnez votre application externe dans la liste déroulante.
   4. Attribuez les rôles nécessaires.
   5. Sélectionnez Attribuer.

Remarque :

L’application externe est limitée à toutes les ressources pour lesquelles elle ne dispose pas d’autorisations explicites. Assurez-vous que l’application a accès à tous les contextes, outils et ressources dont l’agent conversationnel a besoin.

Étape 3 : Créez un point de terminaison de jeton

Un point de terminaison de jeton est requis, car l'agent conversationnel intégré ne peut pas stocker en toute sécurité les clés secrètes du client. Votre point de terminaison de jeton s'authentifie auprès d'UiPath à l'aide des informations d'identification du client et renvoie un jeton d'accès à l'agent intégré.

Architecture recommandée

Nous recommandons une architecture sans serveur pour le point de terminaison du jeton :

• Faible coût: par exemple, la tarification AWS Lambda pour 3 000 000 réponses/mois est d’environ 0,40 $ USD.
• Maintenance minimale: Aucun serveur à gérer.
• Mise à l'échelle facile: gère automatiquement les pics de trafic.

Considérations de sécurité

Avertissement :

La clé secrète du client est très sensible. S'il est exposé par inadvertance, supprimez immédiatement la clé secrète et générez-en une nouvelle dans les paramètres de l'application externe .

Assurez-vous de l'implémentation de votre point de terminaison de jeton :

• Stocke la clé secrète du client en toute sécurité
• Valide les sources de la demande afin d’empêcher tout accès non autorisé
• Utilise HTTPS pour toutes les communications

Exemple d'implémentation

Le code JavaScript suivant peut être adapté à votre plate-forme sans serveur. Le corps de la réponse doit renvoyer {access_token: <token>}:

// Whitelist: Configure allowed origins for your deployment
const ALLOWED_ORIGINS = [
  'https://cloud.uipath.com/*',
  // Add your application domains here
];

function matchesOriginPattern(origin, pattern) {
  try {
    const originUrl = new URL(origin);
    const originBase = `${originUrl.protocol}//${originUrl.host}`;

    if (pattern.includes('*')) {
      const regexPattern = pattern
        .replace(/[.+?^${}()|[\]\\]/g, '\\$&')
        .replace(/\*/g, '.*');
      const regex = new RegExp(`^${regexPattern}$`);
      return regex.test(originBase);
    } else {
      return originBase.startsWith(pattern);
    }
  } catch (e) {
    return false;
  }
}

function checkOrigin(req) {
  const origin = req.headers.origin || req.headers.referer;

  if (!origin) {
    const host = req.headers.host;
    if (host && (host.includes('localhost') || host.includes('127.0.0.1'))) {
      return true;
    }
    return false;
  }

  return ALLOWED_ORIGINS.some(pattern => matchesOriginPattern(origin, pattern));
}

async function getClientAccessToken() {
  const clientId = process.env.CLIENT_ID;
  const clientSecret = process.env.CLIENT_SECRET;
  const scope = 'OR.Default ConversationalAgents Traces.Api';

  const params = new URLSearchParams({
    grant_type: 'client_credentials',
    client_id: clientId,
    client_secret: clientSecret,
    scope: scope
  });

  const response = await fetch('https://cloud.uipath.com/identity_/connect/token', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/x-www-form-urlencoded',
    },
    body: params.toString()
  });

  if (!response.ok) {
    const errorText = await response.text();
    throw new Error(`Token request failed: ${response.status} ${errorText}`);
  }

  const data = await response.json();
  return data.access_token;
}

export async function token(context, req) {
  if (!checkOrigin(req)) {
    context.res = {
      status: 403,
      headers: { 'Content-Type': 'application/json' },
      body: { error: 'Origin not allowed' }
    };
    return;
  }

  try {
    const accessToken = await getClientAccessToken();
    context.res = {
      status: 200,
      headers: { 'Content-Type': 'application/json' },
      body: { access_token: accessToken }
    };
  } catch (error) {
    console.error('Error fetching access token:', error);
    context.res = {
      status: 500,
      headers: { 'Content-Type': 'application/json' },
      body: { error: 'Failed to fetch access token' }
    };
  }
}

Variables de l'environnement

Configurez les variables d'environnement suivantes sur votre plate-forme sans serveur :

Variable	Description
CLIENT_ID	ID de l’application de l’étape 1
CLIENT_SECRET	Clé secrète de l’application de l’étape 1

La méthode exacte de définition des variables d’environnement dépend de votre plateforme d’hébergement.

Configuration des sources autorisées

Le tableau ALLOWED_ORIGINS offre une sécurité en rejetant les demandes de jeton provenant de sources non autorisées. Configurez cette liste pour inclure :

• https://cloud.uipath.com/* (requis pour l'agent intégré)
• https://staging.uipath.com si vous devez autoriser les requêtes provenant d’un environnement d’automatisation
• Le ou les domaines de votre application si les tests locaux ou à partir d'autres environnements sont effectués

Étape 4 : intégrer l'agent avec un accès anonyme

Une fois le point de terminaison du jeton configuré, intégrez l'agent conversationnel en utilisant le format d'URL suivant :

https://<cloud_env>.uipath.com/<organization>/<tenant>/autopilotforeveryone_/conversational-agents/?agentId=<agent_id>&externalAuth=true&authEndpoint=<token_endpoint_url>&externalUserId=<user_id>

Paramètres d’URL d’accès anonyme

Paramètre	Requis	Description
agentId	Oui (Yes)	L'ID de version de l'agent publié
externalAuth	Oui (Yes)	Définir sur true pour activer l’accès anonyme
authEndpoint	Oui (Yes)	URL de votre point de terminaison de jeton
externalUserId	Oui (Yes)	Identifiant unique pour l'utilisateur

Remarque :

externalUserId est une valeur que vous définissez et maintenez. Elle sépare et récupère l'historique de discussion des utilisateurs. Utilisez un ID utilisateur significatif si vous devez maintenir l'historique de discussion, ou un GUID aléatoire si la persistance de l'historique de discussion n'est pas requise.

Exemple d'URL intégrée

https://<cloud_env>.uipath.com/myorg/mytenant/autopilotforeveryone_/conversational-agents/?agentId=12345&externalAuth=true&authEndpoint=https://my-api.example.com/token&externalUserId=user-abc-123

Exemple HTML

<iframe
  src="https://<cloud_env>.uipath.com/myorg/mytenant/autopilotforeveryone_/conversational-agents/?agentId=12345&externalAuth=true&authEndpoint=https://my-api.example.com/token&externalUserId=user-abc-123"
  width="400"
  height="600"
  frameborder="0"
  allow="clipboard-write"
></iframe>

Remarque :

Si le paramètre externalAuth=true est manquant, l'agent intégré utilise le flux de redirection de connexion standard au lieu de l'accès anonyme.

Résolution des problèmes

Le point de terminaison du jeton renvoie 403

• Vérifiez que votre liste ALLOWED_ORIGINS comprend les domaines corrects.
• Vérifiez que l'en-tête de l'origine de la demande est envoyé correctement.
• Testez directement le point de terminaison pour isoler le problème.

Échec de la demande de jeton avec une erreur d'authentification

• Vérifiez que les variables d'environnement CLIENT_ID et CLIENT_SECRET sont correctement définies.
• Confirmez que l’application externe est toujours active dans UiPath Admin.
• Vérifiez que l'URL du point de terminaison du jeton dans le code pointe vers le bon environnement UiPath.

L’agent ne peut pas accéder aux ressources

• Examinez les rôles attribués à l'application externe dans Orchestrator.
• Vérifiez que les autorisations au niveau du dossier sont configurées pour tous les dossiers requis.
• Vérifiez que les étendues ajoutées à l’application externe correspondent à l’accès à l’API requis.

Historique de discussion non persistant

• Assurez-vous que vous utilisez un objet externalUserId cohérent pour le même utilisateur.
• Vérifiez que l’ID utilisateur est transmis correctement dans l’URL intégrée.

Prochaines étapes

• Intégration d'iFrame et d'Apps: documentation complète de l'intégration
• Licences: comprendre la consommation pour les utilisateurs anonymes