Consultez la liste des connecteurs compatibles avec Application Integration.

Tâche Mappage de données

La tâche Mappage de données vous permet d'effectuer des attributions de variables dans votre intégration, d'obtenir et de définir les propriétés des objets JSON, et d'appliquer des fonctions de transformation imbriquées aux valeurs. Ces variables peuvent être des variables d'intégration ou des variables de tâches.

Vous pouvez par exemple attribuer des valeurs de la variable d'intégration X à la variable de tâche Y, ou de la variable de tâche Y à la variable d'intégration X. Pour en savoir plus sur les variables dans Application Integration, consultez la section Utiliser des variables dans Application Integration.

Configurer la tâche Mappage de données

Pour configurer une tâche Mappage de données, procédez comme suit :

Dans la console Google Cloud, accédez à la page Application Integration.
Accéder à Application Integration
Dans le menu de navigation, cliquez sur Integrations (Intégrations).
La page Intégrations s'affiche. Elle liste toutes les intégrations disponibles dans le projet Google Cloud.
Sélectionnez une intégration existante ou cliquez sur Créer une intégration pour en créer une.
Si vous créez une intégration:
1. Saisissez un nom et une description dans le volet Créer une intégration.
2. Sélectionnez une région pour l'intégration.
  Remarque : Le menu déroulant Régions ne répertorie que les régions provisionnées dans votre projet Google Cloud. Pour provisionner une nouvelle région, cliquez sur Activer la région. Pour en savoir plus, consultez la section Activer une nouvelle région.
3. Sélectionnez un compte de service pour l'intégration. Vous pouvez modifier ou mettre à jour les détails du compte de service d'une intégration à tout moment depuis le volet Résumé de l'intégration de dans la barre d'outils d'intégration.
  Remarque:L'option permettant de sélectionner un compte de service ne s'affiche que si vous avez activé la gouvernance de l'intégration pour la région sélectionnée.
4. Cliquez sur Créer.
La page de l'éditeur d'intégration s'affiche.
Dans la barre de navigation de l'éditeur d'intégration, cliquez sur Tasks (Tâches) pour afficher la liste des tâches disponibles.
Cliquez sur l'élément Mappage de données et placez-le dans l'éditeur d'intégrations.
Cliquez sur l'élément Mappage de données dans le concepteur pour afficher le volet de configuration de la tâche Mappage de données.
Cliquez sur Ouvrir l'éditeur de mappage de données pour afficher les valeurs par défaut de la tâche et ajouter un mappage. Pour connaître la procédure détaillée d'ajout d'un mappage, consultez la section Ajouter un mappage.
Pour en savoir plus sur la mise en page de l'éditeur de mappage de données, consultez la page Présentation du mappage des données.

Ajouter un mappage

Pour ajouter un mappage, procédez comme suit :

Dans le volet de configuration de la tâche Mappage des données, cliquez sur Ouvrir l'éditeur de mappage de données.
Configurez l'entrée de mappage :
Entrée : source de l'entrée de mappage de données. La source peut être une valeur littérale, une fonction de base ou une variable d'entrée, avec des fonctions de mappage.
1. Faites glisser une variable ou son sous-champ de la liste Variables vers la ligne Entrée. Pour afficher les sous-champs disponibles pour une variable, cliquez sur (Développer) à côté de cette variable dans la liste Variables.
2. Vous pouvez également cliquer sur Variable ou valeur dans la ligne Entrée, puis procéder comme suit :
  - Sélectionnez Variable pour rechercher et utiliser une variable existante. Pour créer une variable, cliquez sur + Ajouter une variable, puis saisissez le nom et le type de données de la nouvelle variable.
  - Sélectionnez Valeur pour saisir une valeur littérale de type string, integer, double ou Boolean).
  - Sélectionnez Fonction pour rechercher et utiliser une fonction de base.
    Une fonction de base permet de récupérer ou de générer des valeurs lors de l'exécution d'une intégration. Par exemple, vous pouvez générer un UUID aléatoire ou récupérer la région d'intégration actuelle. Pour en savoir plus sur les fonctions de base compatibles, consultez la page Fonctions de base compatibles.
  - Cliquez sur Enregistrer.
3. Cliquez sur + (Ajouter une fonction) sur toute variable d'entrée, valeur ou fonction de base dans la ligne Entrée afin d'ajouter une fonction de mappage à partir de la liste des fonctions de mappage disponibles. Une fonction de mappage peut avoir un ou plusieurs paramètres. Chaque paramètre peut avoir une valeur, une variable ou une fonction de base, suivie d'une chaîne de fonctions de mappage.
  - Pour ajouter une fonction imbriquée, cliquez sur + (Ajouter une fonction) à côté du paramètre de la fonction. De même, pour retirer ou supprimer la dernière fonction ajoutée, cliquez sur - (Supprimer la fonction précédente).
  - Pour ajouter, supprimer ou modifier une fonction au sein d'une expression de mappage, cliquez sur une fonction et sélectionnez respectivement Ajouter une fonction, Supprimer la fonction ou Modifier la fonction dans le menu déroulant.
  - Pour supprimer une variable dans une expression de mappage, cliquez sur (Supprimer) à côté de la ligne de cette variable.
  - Pour supprimer la totalité de la ligne Entrée, cliquez sur (Effacer) sur la ligne.
Configurez le résultat du mappage :
Résultat : variable cible pour le résultat du mappage de données Les variables cibles peuvent être utilisées pour le mappage dans les lignes d'entrée suivantes.
1. Faites glisser une variable de la liste Variables vers la ligne Sortie. Si la variable n'est pas disponible, cliquez sur Créer une variable pour configurer le nom et le type de données de la nouvelle variable. Vous pouvez également cliquer sur la variable de sortie et choisir d'utiliser cette variable en tant que sortie de l'intégration ou en tant qu'entrée d'une autre intégration.
2. Pour supprimer la variable de sortie, cliquez sur (Effacer).
(Facultatif) Pour supprimer une ligne de mappage, cliquez sur (Supprimer ce mappage).
Fermez l'éditeur de mappage de données une fois le mappage terminé. Toutes les modifications seront enregistrées automatiquement.

Le mappage de données finalisé peut être visualisé dans le volet de configuration de la tâche Mappage de données, comme illustré dans la figure ci-dessous :

image montrant un éditeur de mappage de données

Types de données et fonctions de mappage compatibles

Apigee Integration accepte les types de données suivants pour les variables de la tâche Mappage de données :

Chaîne et tableau de chaînes
Entier et tableau d'entiers
Double et tableau de doubles
Booléen et tableau de booléens
JSON

Le tableau suivant regroupe les fonctions de mappage de données disponibles pour chaque type de données.

Data type	Fonctions de mappage compatibles
Booléen	AND, EQUALS, NAND, NOR, NOT, OR, TO_JSON, TO_STRING, XNOR, XOR
Tableau booléen	APPEND, APPEND_ALL, CONTAINS, FILTER, FOR_EACH, GET, REMOVE, REMOVE_AT, SET, SIZE, TO_JSON, TO_SET
Double	ADD, DIVIDE, CEIL, EQUALS, EXPONENT, GREATER_THAN, GREATER_THAN_EQUAL_TO, FLOOR, LESS_THAN, LESS_THAN_EQUAL_TO, MOD, MULTIPLY, ROUND, SUBTRACT, TO_JSON, TO_STRING
Double tableau	APPEND, APPEND_ALL, AVG, CONTAINS, FILTER, FOR_EACH, GET, MAX, MIN, REMOVE, REMOVE_AT, SET, SIZE, SUM, TO_JSON, TO_SET
Integer	ADD, DIVIDE, EPOCH_TO_HUMAN_READABLE_TIME, EQUALS, EXPONENT, GREATER_THAN, GREATER_THAN_EQUAL_TO, LESS_THAN, LESS_THAN_EQUAL_TO, MOD, MULTIPLY, SUBTRACT, TO_DOUBLE, TO_JSON, TO_STRING
Tableau d'entiers	APPEND, APPEND_ALL, AVG, CONTAINS, FILTER, FOR_EACH, GET, MAX, MIN, REMOVE, REMOVE_AT, SET, SIZE, SUM, TO_JSON, TO_SET
JSON	APPEND_ELEMENT, FLATTEN, FILTER, FOR_EACH, GET_ELEMENT, GET_PROPERTY, MERGE, REMOVE_PROPERTY, RESOLVE_TEMPLATE, SET1EAN_PROPERTY, TO_BOOLEAN TO_BOOLEAN_ARRAY TO_DOUBLE TO_DOUBLE_ARRAY TO_INT TO_INT_ARRAY TO_STRING TO_STRING_ARRAY
Chaîne	CONCAT, CONTAINS, DECODE_BASE64_STRING, EQUALS, EQUALS_IGNORE_CASE, LENGTH, REPLACE_ALL, RESOLVE_TEMPLATE, SPLIT, SUBSTRING, TO_BASE_64, TO_BOOLEAN, TO_DOUBLE, TO_INT, TO_JSON, TO_LOWERCASE, TO_UPPERCASE
Tableau de chaînes.	APPEND, APPEND_ALL, CONTAINS, FILTER, FOR_EACH, GET, REMOVE, REMOVE_AT, SET, SIZE, TO_JSON, TO_SET

Pour en savoir plus sur chacune des fonctions de mappage de données, consultez la documentation de référence sur les fonctions de mappage de données.

Fonctions de base compatibles

Le tableau suivant répertorie les fonctions de base de mappage de données disponibles :

Data type	Fonctions de base compatibles
Integer	NOW_IN_MILLIS
Tableau d'entiers	INT_LIST
Chaîne	GENERATE_UUID, GET_EXECUTION_ID, GET_INTEGRATION_NAME, GET_INTEGRATION_REGION, GET_PROJECT_ID

Pour en savoir plus sur chacune des fonctions de mappage de données de base, consultez la documentation de référence sur les fonctions de mappage de données.

Bonnes pratiques

La tâche Mappage de données peut être un moyen efficace de transformer et de transmettre des variables clés à diverses tâches de votre intégration. Voici quelques conseils à prendre en compte lorsque vous créez votre intégration :

Les mappages sont exécutés en séquence de haut en bas. En d'autres termes, si la variable d'entrée A est mappée à une variable de sortie B de la première ligne, la variable B est disponible pour le mappage dans les lignes suivantes.
Sur chaque ligne, le type de données de la ligne Entrée doit correspondre au type de données de la ligne Sortie. Pour caster des données entre différents types, utilisez des fonctions de transformation telles que TO_STRING et TO_INT.
Il n'existe aucune limitation quant à la longueur du chaînage de transformation. Toutefois, le débogage de longues transformations en chaîne peut s'avérer difficile. Nous vous recommandons de conserver les transformations d'entrée lisibles et de diviser les transformations complexes en plusieurs mappages.
Si un mappage nécessite une valeur de remplacement, définissez une valeur de remplacement pour le mappage. Si vous ne fournissez pas de valeur de remplacement, le mappage renvoie une erreur lorsque la valeur d'entrée ou la transformation renvoie null.
Lorsque vous supprimez une variable, veillez à supprimer tous les mappages qui la contiennent.

Pour en savoir plus sur les limites d'utilisation qui s'appliquent à la tâche Mappage des données, consultez la section Limites d'utilisation.

Points à prendre en compte

Pour les variables JSON, basée sur un schéma JSON, Application Integration interprète la propriété enfant de la variable comme un type JSON dans les cas suivants:

Si le type de la propriété enfant spécifie une valeur nulle. Exemple :

{
  "properties": {
    "PersonID": {
      "type": [
        "double",
        "null"
      ],
      "readOnly": false
    }
  }
}

Si le type de la propriété enfant spécifie plusieurs types de données. Exemple :

{
  "properties": {
    "PersonID": {
      "type": [
        "integer",
        "string",
        "number"
      ],
      "readOnly": false
    }
  }
}

Dans ces cas, à l'aide des fonctions de mappage de données, vous devez explicitement convertir les variables enfants vers le type souhaité.

Les exemples suivants illustrent les différents types de déclarations de propriété et montrent comment utiliser les fonctions de mappage de données pour obtenir le type souhaité :

Exemple 1

{
  "type": "object",
  "properties": {
    "dbIntegers": {
      "type": "array",
      "items": {
        "type": [
          "integer",
          "null"
        ]
      }
    },
    "dbBooleans": {
      "type": [
        "array"
      ],
      "items": {
        "type": "boolean"
      }
    }
  }
}

Application Integration interprète dbIntegers comme un type JSON et dbBooleans comme un type BOOLEAN_ARRAY.

Pour convertir dbIntegers, utilisez :

dbIntegers.TO_INT_ARRAY()

Exemple 2

{
  "type": "object",
  "properties": {
    "dbId": {
      "type": [
        "number",
        "null"
      ],
      "readOnly": false
    },
    "dbStatus": {
      "type": [
        "boolean",
        "null"
      ],
      "readOnly": false
    }
  }
}

Application Integration reconnaît à la fois dbId et dbStatus comme des types JSON, mais dbId est un paramètre qui peut accepter une seule valeur double ou une valeur nulle, et dbStatus est un paramètre qui accepte une seule valeur booléenne ou une valeur nulle.

Pour convertir dbId et dbStatus, utilisez :

dbId.TO_DOUBLE()

dbStatus.TO_BOOLEAN()

Exemple 3

{
  "type": "object",
  "properties": {
    "dbString": {
      "type": [
        "string"
      ],
      "readOnly": false
    }
  }
}

Application Integration reconnaît dbString en tant que type de chaîne.

Stratégie de traitement des erreurs

Une stratégie de traitement des erreurs d'une tâche spécifie l'action à effectuer si celle-ci échoue en raison d'une erreur temporaire. Pour en savoir plus sur l'utilisation et les différents types de stratégies de traitement des erreurs, consultez la page Stratégies de traitement des erreurs.