Intégration avec Exchange auto-hébergée

Configurez et déployez l'image Exchange Sync App Docker pour intégrer un serveur Exchange auto-hébergé avec Communications Mining sur Automation Cloud.

Avertissement :

Microsoft retirera les Web Exchange Services (EWS) pour Exchange Online le 1er octobre 2026 (annonce Microsoft). Le serveur Exchange Server local n'est pas affecté et continue de fonctionner normalement. Si votre intégration auto-hébergée se connecte à Exchange Online, nous vous recommandons de basculer vers l'API Microsoft Graph avant cette date. Pour connaître les étapes de migration, reportez-vous au guide de migration de l’API EWS vers Microsoft Graph.

L'application de synchronisation Exchange est livrée sous forme d'image Docker. Les sections suivantes expliquent comment configurer et déployer l'appareil.

S'authentifier auprès de Communications Mining

Lorsque l'application de synchronisation Exchange est téléchargée vers Communications Mining, elle a besoin d'informations d'identification pour l'API Communications Mining, qu'elle utilise pour lire sa configuration et écrire des e-mails dans des compartiments. Ces informations d’identification sont distinctes de celles que l’appareil utilise pour accéder à votre serveur Exchange et fonctionnent avec chaque type d’authentification Exchange décrit dans la section Configuration.

Configurez exactement l'un des éléments suivants. L'appareil s'arrête au démarrage si vous configurez les deux.

InformationsIdentification	De quoi il s'agit
Jeton API	Un jeton d'API de développement, émis à un utilisateur nommé. Pour en obtenir une, consultez Utilisation de l'API.
Application externe	Une application externe UiPath utilisant le flux d’informations d’identification client OAuth 2.0. Recommandé pour une intégration Unattended. Vérifiez S’authentifier avec une application externe.

Les deux sont fournis à l'appareil de la même manière: définissez une variable d'environnement ou pointez un paramètre sur un fichier contenant le secret. Lorsque les deux sont définis, le fichier l'emporte.

InformationsIdentification	Variable d'environnement	Paramètre Fichier
Jeton API	REINFER_API_TOKEN	--reinfer-api-token-path
Clé secrète d’application d’application externe	REINFER_EXTERNAL_APPLICATION_CLIENT_SECRET	--external-application-client-secret-path

Les exemples sous Déploiement utilisent les variables d'environnement, renseignées à partir d'une clé secrète Kubernetes. Si vous renforcez le déploiement, utilisez plutôt les paramètres de fichier: l’environnement d’un conteneur est lisible via /proc/<pid>/environ et docker inspect, tandis qu’un fichier monté peut être limité à l’aide d’autorisations de fichier.

Quel que soit votre choix, il doit disposer des autorisations Compartiment - Écrire et Compartiment - Ajouter sur chaque projet dans lequel l’appareil se synchronise. Si vous stockez la configuration dans Communications Mining, elle a également besoin de Configuration de l'appareil - Lecture du projet nommé par --remote-config-owner. Un jeton d'API porte les autorisations de l'utilisateur auquel il a été émis. Pour les rôles qui portent ces autorisations et comment créer un rôle personnalisé, vérifiez Gestion de l'accès.

Remarque :

Les déploiements de stockage local et de Stockage Blob Azure n'ont pas besoin d'informations d'identification Communications Mining.

S’authentifier avec une application externe

Créez l’application et accordez-lui l’accès comme décrit dans l’authentification avec des applications externes, en sélectionnant les étendues qui y sont répertoriées sous Étendue(s) d’application plutôt que Étendue(s) utilisateur.

Configurez ensuite l'appareil avec les paramètres d'application externes décrits dans les paramètres d'application. Notez les éléments suivants:

• --reinfer-api-endpoint doit être votre point de terminaison de l'API du locataire Automation Cloud, sous la forme https://cloud.uipath.com/<org>/<tenant>/reinfer_/api/. Le jeton d’accès est émis par votre organisation Automation Cloud et n’est accepté que là-bas.
• L’URL du jeton doit être une URL https, car la clé secrète de l’application est envoyée dans le corps de la requête. L’appareil refuse de démarrer sinon.

L’appareil renouvelle le jeton d’accès à son expiration. Si le point de terminaison de l’identité est inaccessible ou comporte des erreurs, l’interrogation affectée est ignorée et réessayée. Les informations d’identification rejetées sont une erreur de configuration: l’appareil enregistre l’échec et s’arrête, sauf si vous l’exécutez avec --restart-on-unrecoverable-errors, auquel cas il redémarre toutes les quelques secondes et réessaie indéfiniment.

Configuration

Étant donné que l' application de synchronisation Exchange nécessite la présence d'un fichier de configuration JSON au démarrage, cette section explique le contenu du fichier. Reportez-vous à la section Déploiement pour savoir comment rendre le fichier de configuration disponible pour l'application de synchronisation Exchange.

OAuth 2.0

Si vous utilisez le type d'authentification OAuth 2.0, vous pouvez utiliser l'API Graph ou l'API EWS. Les deux vous permettent de vous authentifier avec la clé secrète du client ou avec le certificat client.

Le flux d'octroi de jeton utilisé est le flux d'informations d'identification du client.

API Graph avec clé secrète de client

{
  "microsoft_api": "graph",
  "auth_oauth_authority": "https://login.microsoftonline.com/<tenant_id>/",
  "auth_oauth_client_id": "<client_id>",
  "auth_oauth_client_secret": "<client_secret>",
  "mailboxes": {
    "[e-mail]": {
      "bucket": {
        "owner": "project-name",
        "name": "bucket-name"
      },
      "start_from": "bucket",
      "start_timestamp": "2020-01-01T00:00:00+00:00"
    },
    "[e-mail]": {
      "bucket": {
        "owner": "project-name",
        "name": "bucket-name"
      },
      "start_from": "bucket",
      "start_timestamp": "2020-01-01T00:00:00+00:00"
    }
  }
}

API Graph avec certificat client

{
  "microsoft_api": "graph",
  "auth_oauth_authority": "https://login.microsoftonline.com/<tenant_id>/",
  "auth_oauth_client_id": "<client_id>",
  "auth_oauth_client_credential_private_key": "<private_key>",
  "mailboxes": {
    "[e-mail]": {
      "bucket": {
        "owner": "project-name",
        "name": "bucket-name"
      },
      "start_from": "bucket",
      "start_timestamp": "2020-01-01T00:00:00+00:00"
    },
    "[e-mail]": {
      "bucket": {
        "owner": "project-name",
        "name": "bucket-name"
      },
      "start_from": "bucket",
      "start_timestamp": "2020-01-01T00:00:00+00:00"
    }
  }
}

API EWS avec clé secrète de client

{
  "ews_endpoint": "https://outlook.office365.com/EWS/Exchange.asmx",
  "auth_type": "oauth2",
  "auth_oauth_authority": "https://login.microsoftonline.com/<tenant_id>/",
  "auth_oauth_client_id": "<client_id>",
  "auth_oauth_client_secret": "<client_secret>",
  "access_type": "impersonation",
  "mailboxes": {
    "[e-mail]": {
      "bucket": {
        "owner": "project-name",
        "name": "bucket-name"
      },
      "start_from": "bucket",
      "start_timestamp": "2020-01-01T00:00:00+00:00"
    },
    "[e-mail]": {
      "bucket": {
        "owner": "project-name",
        "name": "bucket-name"
      },
      "start_from": "bucket",
      "start_timestamp": "2020-01-01T00:00:00+00:00"
    }
  }
}

API EWS avec certificat client

{
  "ews_endpoint": "https://outlook.office365.com/EWS/Exchange.asmx",
  "auth_type": "oauth2",
  "auth_oauth_authority": "https://login.microsoftonline.com/<tenant_id>/",
  "auth_oauth_client_id": "<client_id>",
  "auth_oauth_client_credential_private_key": "<private_key>",
  "auth_oauth_client_credential_thumbprint": "<thumbprint>",
  "access_type": "impersonation",
  "mailboxes": {
    "[e-mail]": {
      "bucket": {
        "owner": "project-name",
        "name": "bucket-name"
      },
      "start_from": "bucket",
      "start_timestamp": "2020-01-01T00:00:00+00:00"
    },
    "[e-mail]": {
      "bucket": {
        "owner": "project-name",
        "name": "bucket-name"
      },
      "start_from": "bucket",
      "start_timestamp": "2020-01-01T00:00:00+00:00"
    }
  }
}

NTLM

Si vous utilisez l'authentification NTLM, elle ne peut être utilisée qu'avec l'API EWS.

{
  "host": "https://exchange-server.example.com",
  "port": 443,
  "auth_type": "ntlm",
  "auth_user": "[e-mail]",
  "access_type": "delegate",
  "mailboxes": {
    "[e-mail]": {
      "bucket": {
        "owner": "project-name",
        "name": "bucket-name"
      },
      "start_from": "bucket",
      "start_timestamp": "2020-01-01T00:00:00+00:00"
    },
    "[e-mail]": {
      "bucket": {
        "owner": "project-name",
        "name": "bucket-name"
      },
      "start_from": "bucket",
      "start_timestamp": "2020-01-01T00:00:00+00:00"
    }
  }
}

Tout d'abord, remplacez les valeurs factices dans host, port et auth_user par leurs valeurs réelles, et modifiez access_type si nécessaire. Pour obtenir la description de ces paramètres et de leurs valeurs autorisées, consultez la référence de configuration.

Ensuite, fournissez le mot de passe de l’utilisateur du service à l’application Exchange Sync en tant que variable d’environnement REINFER_EWS_AUTH_PASS . Pour plus de détails, consultez la section Déploiement .

La liste complète des variables d'environnement que vous pouvez définir pour remplacer les valeurs dans la configuration est la suivante :

Nom	DESCRIPTION
REINFER_EWS_AUTH_USER	Utilisateur du serveur Exchange
REINFER_EWS_AUTH_PASS	Mot de passe du serveur Exchange
REINFER_EWS_ACCESS_TYPE	Type d'accès : « délégué » ou « emprunt d'identité »
REINFER_EWS_HOST	Hôte du serveur Exchange
REINFER_EWS_PORT	Port du serveur Exchange

Configuration de la boîte aux lettres

Vous pouvez spécifier une ou plusieurs boîtes aux lettres dans votre configuration. Pour chaque boîte aux lettres, vous devez fournir l'adresse de la boîte aux lettres et spécifier les paramètres suivants :

Nom	DESCRIPTION
bucket.owner	Projet du compartiment dans lequel la boîte aux lettres doit être synchronisée.
bucket.name	Nom du compartiment dans lequel la boîte aux lettres doit être synchronisée.
start_from	S'il faut démarrer à partir de la dernière heure synchronisée ("compartiment") ou ignorer la dernière heure synchronisée et toujours démarrer à partir de start_timestamp ("config"). Doit être défini sur "compartiment" pour un fonctionnement normal, mais "config" peut être utile dans certains cas lors du débogage.
start_timestamp	Horodatage à partir duquel démarrer la synchronisation des e-mails. Si ceci n’est pas défini, tous les e-mails seront synchronisés.

La configuration utilise les valeurs par défaut pour un certain nombre de paramètres tels que la fréquence d'interrogation ou la taille du lot. Pour personnaliser davantage votre configuration, consultez la référence de configuration.

Compartiments

L’intégration Exchange synchronise les données d’e-mail brutes dans les compartiments Communications Mining™. Comme pour les autres ressources Communications Mining, un compartiment est créé dans un projet, ce qui vous permet de contrôler l’accès au compartiment.

Remarque :

Pour lire à partir d’un compartiment, télécharger dans un compartiment ou gérer des compartiments, vous devez avoir attribué les autorisations respectives dans le projet dans lequel se trouve le compartiment.

Déploiement

Vous pouvez déployer l'application de synchronisation Exchange avec Kubernetes ou avec Docker.

Le déploiement avec Kubernetes vous permet d'exécuter plusieurs instances de l'application de synchronisation Exchange, chaque instance gérant un sous-ensemble de boîtes aux lettres à synchroniser.

Avec Kubernetes

L'utilisation de Kubernetes est un moyen populaire d'exécuter et de gérer des applications conteneurisées. Cette section explique comment déployer l’application de synchronisation Exchange à l’aide de Kubernetes.

Prérequis

• connaissances de base de Kubernetes. Pour commencer à utiliser Kubernetes, consultez Déployer dans Kubernetes.
• ont kubectl installé.

kind: StatefulSet
metadata:
  name: uipath-exchange-sync-app
  labels:
    app: uipath-exchange-sync-app
spec:
  podManagementPolicy: Parallel
  replicas: 1
  selector:
    matchLabels:
      app: uipath-exchange-sync-app
  serviceName: uipath-exchange-sync-app
  template:
    metadata:
      labels:
        app: uipath-exchange-sync-app
      name: uipath-exchange-sync-app
    spec:
      containers:
        - args:
            - "uipath-exchange-sync-app"
            - "--bind"
            - "0.0.0.0:8000"
            - "--reinfer-api-endpoint"
            - "https://cloud.uipath.com/<org>/<tenant>/reinfer_/api/"
            - "--shard-name"
            - "$(POD_NAME)"
            # This value should match `spec.replicas` above
            - "--total-shards"
            - "1"
            # To authenticate as an external application, uncomment these
            # and swap the REINFER_API_TOKEN block below
            # - "--external-application-token-url"
            # - "https://cloud.uipath.com/<org>/identity_/connect/token"
            # - "--external-application-client-id"
            # - "<app_id>"
          env:
            - name: REINFER_EWS_CONFIG
              value: "/mnt/config/example_exchange_sync_config"
            # Remove this block when authenticating as an external application
            - name: REINFER_API_TOKEN
              valueFrom:
                secretKeyRef:
                  key: reinfer-api-token
                  name: reinfer-credentials
            # Only needed when authenticating as an external application
            # - name: REINFER_EXTERNAL_APPLICATION_CLIENT_SECRET
            #   valueFrom:
            #     secretKeyRef:
            #       key: external-application-client-secret
            #       name: reinfer-credentials
            # Only needed when using EWS API
            - name: REINFER_EWS_AUTH_PASS
              valueFrom:
                secretKeyRef:
                  key: ews-auth-pass
                  name: reinfer-credentials
            - name: POD_NAME
              valueFrom:
                fieldRef:
                  fieldPath: metadata.name
          image: "registry.uipath.com/reinfer-ews:TAG"
          name: uipath-exchange-sync-app
          resources:
            requests:
              cpu: 0.05
              memory: 128Mi
          volumeMounts:
            - mountPath: /mnt/config
              name: config-vol
      volumes:
        - configMap:
            name: exchange-sync-config
            items:
              - key: example_exchange_sync_config
                path: example_exchange_sync_config
          name: config-vol

Avant de pouvoir déployer l’application de synchronisation Exchange à l’aide de ce fichier YAML, vous devez effectuer quelques étapes supplémentaires :

1. Remplacez cloud.uipath.com/<org>/<tenant>/reinfer_ par le point de terminaison de votre API de locataire.

2. Créez les clés secrètes comme suit :

   kubectl create secret generic reinfer-credentials \
     --from-literal=reinfer-api-token=<REINFER_TOKEN> \
     --from-literal=ews-auth-pass=<MSEXCHANGE_PASSWORD>
   

   Remarque :

   • Pour éviter de stocker les informations d'identification sous forme de texte clair dans notre fichier YAML, les variables d'environnement REINFER_TOKEN et REINFER_EWS_AUTH_PASS sont renseignées à partir des clés secrètes Kubernetes.
   • La clé secrète ews-auth-pass n'est nécessaire que lors de l'utilisation de l'API EWS.

   Pour vous authentifier en tant qu’application externe plutôt qu’avec un jeton d’API, stockez le secret de l’application sous la clé external-application-client-secret plutôt que reinfer-api-token, puis supprimez les marques de commentaire des lignes d’application externes dans le fichier YAML en remplaçant <org> et <app_id>.

3. Pour charger la configuration de l'appareil à partir d'un fichier local, montez ce fichier dans le pod en stockant les données dans un Kubernetes ConfigMap et en montant le ConfigMap sous la forme d'un volume.

4. Créez ConfigMap comme suit :

   kubectl create configmap exchange-sync-config \
     --from-file=example_exchange_sync_config=your-exchange-sync-config.json
   

   Remarque :

   Comme alternative au stockage local du fichier de configuration, vous pouvez le télécharger vers Communications Mining et laisser l'application de synchronisation Exchange le récupérer via l'API Communications Mining. Il est décrit dans Communications Mining. Si des fichiers de configuration locaux et distants sont spécifiés, l'appareil utilise le fichier de configuration local.

Vous pouvez maintenant créer votre StatefulSet et vérifier que tout est en cours d'exécution via les éléments suivants :

kubectl apply -f uipath-exchange-sync.yaml
kubectl get sts

Avec Docker

Vous pouvez également exécuter l’application Exchange Sync dans Docker. La commande suivante démarre l'appareil avec les mêmes paramètres que ceux utilisés dans la section Kubernetes :

EWS_CONFIG_DIR="location_of_your_self-hosted_appliance_config_directory"
REINFER_API_TOKEN="YOUR API TOKEN"
TAG=latest

sudo docker run \
  -v $EWS_CONFIG_DIR:/mnt/config \
  --env REINFER_EWS_CONFIG=/mnt/config/config.json \
  --env REINFER_API_TOKEN=$REINFER_API_TOKEN \
  registry.uipath.com/reinfer-ews:$TAG reinfer-ews \
  --reinfer-api-endpoint https://cloud.uipath.com/YourOrganizationName/TenantName/reinfer_/api/ \
  &> ews_$(date -Iseconds).log

• Remplacez cloud.uipath.com/<org>/<tenant>/reinfer_ par le point de terminaison de votre API de locataire.
• Remplacez your_exchange_sync_config.json par le nom de votre fichier JSON de configuration de l’application de synchronisation Exchange.

Pour vous authentifier en tant qu’application externe au lieu d’avec un jeton d’API, indiquez le secret de l’application à la place de REINFER_API_TOKEN et ajoutez les paramètres d’application externe:

EWS_CONFIG_DIR="location_of_your_self-hosted_appliance_config_directory"
REINFER_EXTERNAL_APPLICATION_CLIENT_SECRET="YOUR APP SECRET"
TAG=latest

sudo docker run \
  -v $EWS_CONFIG_DIR:/mnt/config \
  --env REINFER_EWS_CONFIG=/mnt/config/config.json \
  --env REINFER_EXTERNAL_APPLICATION_CLIENT_SECRET=$REINFER_EXTERNAL_APPLICATION_CLIENT_SECRET \
  registry.uipath.com/reinfer-ews:$TAG reinfer-ews \
  --reinfer-api-endpoint https://cloud.uipath.com/YourOrganizationName/TenantName/reinfer_/api/ \
  --external-application-token-url https://cloud.uipath.com/YourOrganizationName/identity_/connect/token \
  --external-application-client-id YourAppId \
  &> ews_$(date -Iseconds).log

Pour garder le secret hors de l’environnement du conteneur, écrivez-le dans un fichier, montant ce fichier en lecture seule et transmettez --external-application-client-secret-path au lieu de la variable d’environnement.

L'application de synchronisation Exchange exécute une synchronisation en continu des e-mails sur la plate-forme Communications Mining. Si vous l'arrêtez et le redémarrez, il reprend le dernier état de synchronisation de compartiment stocké.

Avec Docker (stockage local)

L’application de synchronisation Exchange peut enregistrer les e-mails extraits localement au lieu de les transmettre à la plate-forme Communications Mining™ via les éléments suivants :

EWS_LOCAL_DIR=
CONFIG_OWNER=
CONFIG_KEY=
TAG=

sudo docker run \
  -v $EWS_LOCAL_DIR:/mnt/ews \
  registry.uipath.com/reinfer-ews:$TAG \
  --local-files-prefix /mnt/ews \
  --remote-config-owner $CONFIG_OWNER --remote-config-key $CONFIG_KEY \
  &> ews_$(date -Iseconds).log

Vue d'ensemble (Overview)

• L'application de synchronisation Exchange s'attend à ce que la configuration se trouve dans $EWS_LOCAL_DIR/config/$CONFIG_OWNER/$CONFIG_KEY.json. Vous pouvez également fournir le chemin d'accès à la configuration en définissant la variable d'environnement $REINFER_EWS_CONFIG comme indiqué dans l'exemple précédent.
• L' application de synchronisation Exchange enregistre l'état de synchronisation au niveau du chemin d'accès $EWS_LOCAL_DIR/state. Si vous l'arrêtez et le redémarrez, il reprend le dernier état de synchronisation stocké.
• L'application de synchronisation Exchange enregistre les données dans $EWS_LOCAL_DIR/data.

Avec Docker (Stockage Blob Azure)

L’application de synchronisation Exchange peut enregistrer des e-mails extraits vers Azure Blob Storage au lieu de les transmettre à la plate-forme Communications Mining™ via les éléments suivants :

EWS_CONFIG_DIR=
AZ_STORAGE_ACCOUNT_NAME=
AZ_CONTAINER_NAME=
TAG=

sudo docker run \
  -v $EWS_CONFIG_DIR:/mnt/config \
  --env REINFER_EWS_CONFIG=/mnt/config/your_exchange_sync_config.json \
  registry.uipath.com/reinfer-ews:$TAG \
  --private-file-prefix az://$AZ_STORAGE_ACCOUNT_NAME/$AZ_CONTAINER_NAME \
  &> ews_$(date -Iseconds).log

Vue d'ensemble (Overview)

• Vous devez fournir le chemin d'accès à la configuration en définissant la variable d'environnement $REINFER_EWS_CONFIG .
• L'application de synchronisation Exchange s'authentifie par rapport à Azure Blob Storage à l'aide de l'une des méthodes DefaultAzureCredential. Veillez à utiliser une méthode pratique. Quelle que soit la méthode utilisée, assurez-vous d’accorder le rôle Contributeur de données d’objets blob de stockage à l’application de synchronisation Exchange.
• L' application de synchronisation Exchange enregistre l'état de synchronisation au niveau du chemin d'accès az://$AZ_STORAGE_ACCOUNT_NAME/$AZ_CONTAINER_NAME/state. Si vous l'arrêtez et le redémarrez, il reprend le dernier état de synchronisation stocké.
• L'application de synchronisation Exchange enregistre les données dans az://$AZ_STORAGE_ACCOUNT_NAME/$AZ_CONTAINER_NAME/data.

Configuration du magasin dans Communications Mining

Au lieu de fournir un fichier de configuration local à l’appareil comme vous l’avez fait si vous avez suivi le guide de déploiement de l’application de synchronisation Exchange, vous pouvez à la place gérer le fichier de configuration dans Communications Mining™.

Remarque :

Si des fichiers de configuration locaux et distants sont spécifiés, l'appareil utilisera par défaut le fichier de configuration local.

Tout d’abord, téléchargez votre fichier de configuration JSON sur Communications Mining :

curl -H "Authorization: Bearer $REINFER_TOKEN" \
  -H "Content-Type: multipart/form-data" \
  -F 'file=@your_exchange_sync_config.json' \
  -XPUT https://cloud.uipath.com/<org>/<tenant>/reinfer_/api/v1/appliance-configs/<project-name>/<config-name>

Pour afficher la configuration actuelle :

curl -H "Authorization: Bearer $REINFER_TOKEN" \
  -XGET https://cloud.uipath.com/<org>/<tenant>/reinfer_/api/v1/appliance-configs/<project-name>/<config-name>

Il s’agit d’appels administratifs ponctuels. Par conséquent, $REINFER_TOKEN ci-dessus est votre propre jeton d’API. Si votre organisation n'émet pas de jetons d'API personnels, obtenez un jeton d'accès via le flux d'informations d'identification client et utilisez-le à la place. Le téléchargement d'une configuration a besoin de l'autorisation Configuration de l'appareil - Écrire et l'affichage d'une configuration a besoin de l'autorisation Configuration de l'appareil - Lecture.

Ensuite, dans le fichier YAML kubernetes, définissez le paramètre --remote-config-owner sur le nom du projet et le paramètre --remote-config-key sur le nom de la configuration.

Référence (Reference)

Paramètres d’application

Le tableau suivant contient une liste des paramètres d'application disponibles. Pour en savoir plus sur l'exécution de l'application de synchronisation Exchange, consultez la section Déploiement .

Paramètre	Description
--reinfer-api-endpoint	Point de terminaison pour se connecter à l’API Reinfer. Doit se terminer par une barre oblique. Capture mutuellement exclusive avec --local-files-prefix
--reinfer-api-token-path	Chemin d’accès à un fichier contenant le jeton d’API Communications Mining, par exemple /mnt/api-token.txt . Prend la priorité sur la variable d'environnement REINFER_API_TOKEN, qui n'est lue que lorsqu'elle n'est pas définie. Vérifiez Authentification auprès de Communications Mining .
--external-application-token-url	Point de terminaison de jeton d’identité qui émet les jetons d’accès de l’application externe, par exemple https://cloud.uipath.com/<org>/identity_/connect/token . Doit être une URL https. Requis lors de l’authentification en tant qu’application externe.
--external-application-client-id	ID d’application de l’application externe UiPath sous laquelle s’authentifier, au lieu d’utiliser REINFER_API_TOKEN
--external-application-client-secret-path	Chemin d’accès à un fichier contenant la clé secrète de l’application de l’application externe (par exemple: /mnt/app-secret.txt ). Prend la priorité sur la variable d'environnement REINFER_EXTERNAL_APPLICATION_CLIENT_SECRET, qui n'est lue que lorsqu'elle n'est pas définie. Vérifiez Authentification auprès de Communications Mining .
--external-application-scope	Étendues pour demander le jeton d’accès de l’application externe. Ces derniers doivent également être accordés à l’application elle-même. La valeur par défaut est PM.User PM.User.Read Ixp.ApiAccess .
--local-files-prefix	Chemin d’accès pour stocker les e-mails synchronisés et l’état de synchronisation du compartiment. mutuellement exclusif avec --reinfer-api-endpoint et REINFER_API_TOKEN Les paramètres d’application externes sont ignorés dans ce mode.
--remote-config-owner	Projet qui possède le fichier de configuration de l'application de synchronisation Exchange à distance .
--remote-config-key	Nom du fichier de configuration de l'application de synchronisation Exchange distante .
--debug-level	Niveau de débogage, où : 0 signifie aucun débogage. 1 signifie débogage du service. 2 signifie un débogage complet. La valeur par défaut est 1.
--shard-name	Nom de la partition, qui est uipath-exchange-sync-app-N , pour extraire le numéro de partition. Lors de l'exécution dans Kubernetes, vous pouvez le définir sur le nom du pod.
--total-shards	Le nombre total d'instances dans le cluster de l'appareil. Lors de l'exécution dans Kubernetes, le paramètre doit être défini sur la même valeur que le nombre d'instances dans Ensembles d'états (StatefulSet).
--restart-on-unrecoverable-errors	Si cette option est activée, les échecs non récupérables permettront à l'ensemble du service de redémarrer sans planter.

Paramètres de configuration

Le tableau suivant présente une liste des paramètres de configuration disponibles. Pour en savoir plus sur l'écriture du fichier de configuration de l'application de synchronisation Exchange, consultez la section Configuration .

Nom	Description
host	Uniquement utilisé avec l'API EWS. Hôte du serveur Exchange. Peut être remplacée par la variable d'environnement REINFER_EWS_HOST .
port	Uniquement utilisé avec l'API EWS. Port du serveur Exchange. La valeur par défaut est 80. Vous pouvez le remplacer par la variable d'environnement REINFER_EWS_PORT .
auth_type	Uniquement utilisé avec l'API EWS. Seuls ntlm autorisés.
auth_user	Uniquement utilisé avec l'API EWS. Utilisateur du serveur Exchange. Vous pouvez le remplacer par la variable d'environnement REINFER_EWS_AUTH_USER .
auth_password	Uniquement utilisé avec l'API EWS. Mot de passe du serveur Exchange. Vous pouvez le remplacer par la variable d'environnement REINFER_EWS_AUTH_PASS .
access_type	Uniquement utilisé avec l'API EWS. Le type d'accès peut être delegate ou impersonation. La valeur par défaut est delegate. Vous pouvez le remplacer par la variable d'environnement REINFER_EWS_ACCESS_TYPE .
ews_ssl_verify	Uniquement utilisé avec l'API EWS. S'il est défini sur false, il ne vérifiera pas les certificats. La valeur par défaut est true.
poll_frequency	Temps d’attente entre les lots, en secondes. La valeur par défaut est 15.
poll_message_sleep	Le temps d'attente entre les e-mails individuels d'un lot, en secondes. La valeur par défaut est 0.1.
max_concurrent_uploads	Nombre de téléchargements simultanés vers Communications Mining, compris entre 0 et 32. La valeur par défaut est 8.
emails_per_folder	Nombre maximal d'e-mails à récupérer dans chaque dossier par lot, entre 1 et 100 000. La valeur par défaut est 2520. Ce paramètre permet à l'application de synchronisation Exchange de progresser dans tous les dossiers, même dans le cas où le dossier serait très volumineux.
reinfer_batch_size	Combien d'e-mails à récupérer par lot, entre 1 et 1 000. La valeur par défaut est 80.
mailboxes	Liste des boîtes aux lettres à récupérer. Pour plus de détails sur la configuration des boîtes aux lettres, consultez la section Configuration .
audit_email	Si vous avez configuré l'appareil avec une configuration à distance, Communications Mining envoie un e-mail à cette adresse chaque fois que la configuration est mise à jour. La valeur par défaut est None.
ews_ssl_ciphers	Uniquement utilisé avec l’API EWS. Faites en sorte que l’application de synchronisation Exchange utilise des chiffrements spécifiques. Les chiffrements doivent être une chaîne au format de la liste de chiffrement OpenSSL. La valeur par défaut est None.