Consultez les connecteurs compatibles avec Application Integration.

Tâche Cloud Functions

La tâche Cloud Function vous permet de configurer et d'exécuter des fonctions Cloud Run à partir de votre intégration. Les fonctions Cloud Run représentent l'évolution de Cloud Functions. Elles offrent un modèle de programmation basé sur les événements avec un contrôle et une évolutivité améliorés, en exploitant la plate-forme sans serveur Cloud Run. Les fonctions Cloud Run fournissent une solution sans serveur unique pour tous les types de charges de travail.

La tâche Cloud Function est compatible avec les versions suivantes de fonctions Cloud Run:

Pour en savoir plus sur les différences entre les versions des fonctions Cloud Run, consultez le guide de comparaison des fonctions Cloud Functions.

Avant de commencer

Assurez-vous d'effectuer les tâches suivantes dans votre projet Google Cloud avant de configurer la tâche Cloud Functions.

  1. Pour vous connecter à une fonction Cloud, assurez-vous d'avoir créé un profil OAuth 2.0 ou d'avoir associé un compte de service géré par l'utilisateur à votre intégration:
    • Si un compte de service est associé à votre intégration, attribuez le rôle IAM Demandeur Cloud Functions à ce compte de service.

      Pour en savoir plus sur l'attribution d'un rôle à un compte de service, consultez la page Gérer l'accès aux comptes de service.

    • La tâche Cloud Functions n'accepte que les profils d'authentification de type Jeton d'ID Google OIDC. Créez un profil d'authentification de type Jeton d'ID Google OIDC à l'aide du compte de service auquel le rôle IAM Demandeur Cloud Functions est attribué. Si votre tâche Cloud Functions ne nécessite pas d'authentification, le champ Profil d'authentification du volet de configuration de la tâche peut être vide.

    Si le profil d'ID OIDC et un compte de service géré par l'utilisateur sont tous deux configurés pour votre intégration, le profil d'ID OIDC est utilisé par défaut pour l'authentification. Lorsqu'aucun des deux n'est configuré, le compte de service par défaut (service-PROJECT_NUMBER@gcp-sa-integrations.iam.gserviceaccount.com) est utilisé pour appeler la tâche Cloud Functions.

  2. Assurez-vous que VPC Service Controls n'est pas configuré pour Application Integration dans votre Google Cloud projet.

Configurer la tâche Cloud Functions

Pour configurer la tâche Cloud Functions dans votre intégration, procédez comme suit :

  1. Dans le menu de navigation, cliquez sur Intégrations.

    La liste des intégrations disponibles s'affiche dans l'UI Application Integration.

  2. Sélectionnez une intégration existante ou cliquez sur Créer une intégration.

    Si vous créez une intégration, saisissez un nom et une description dans la boîte de dialogue de création, puis cliquez sur Créer.

  3. Dans le menu déroulant Tâches, cliquez sur Fonction Cloud pour la placer dans l'éditeur d'intégrations.
  4. Cliquez sur l'élément Cloud Function dans l'éditeur pour ouvrir le volet de configuration, puis cliquez sur Configuration de la fonction Cloud.
  5. Si vous êtes invité à accorder des autorisations au compte de service, cliquez sur Accorder.

    L'Application Integration accorde automatiquement les autorisations requises au compte de service.

  6. Dans le volet Configuration de la fonction Cloud, sélectionnez l'une des options suivantes :
    • Associer une fonction existante:sélectionnez cette option pour associer une fonction existante à votre intégration. Vous pouvez associer Cloud Functions (1re génération) et les fonctions Cloud créées avec l'API Cloud Functions v2 à partir de votre intégration.
      • Dans le champ URL du déclencheur de la fonction Cloud, saisissez l'URL du déclencheur de la fonction existante.

        L'URL doit respecter l'un des formats suivants:

        # For Cloud Functions (1st gen)
        https://REGION_NAME-PROJECT_ID.cloudfunctions.net/FUNCTION_NAME
        # For Cloud Run functions created using the Cloud Functions v2 API
        https://FUNCTION_NAME-PROJECT_ID.REGION_NAME.run.app

    • Créer une fonction:sélectionnez cette option pour créer une fonction pour l'intégration.
      1. Dans le champ Nom de la fonction, saisissez un nom unique pour les nouvelles fonctions Cloud Run.
      2. Dans le menu déroulant Région, sélectionnez la région dans laquelle les fonctions Cloud Run sont déployées.
      3. Dans le menu déroulant Version de la fonction, sélectionnez la version de Cloud Run Functions souhaitée :
        • Cloud Functions (1re génération) : ancienne version des fonctions Cloud Run, anciennement appelées Cloud Functions (1re génération), qui utilise le format de point de terminaison .cloudfunctions.net.
        • Cloud Functions (dernière génération) : il s'agit de la dernière version des fonctions Cloud Run, créées à l'aide de l'API Cloud Functions v2. Basé sur Cloud Run et Eventarc, il prend en charge les délais avant expiration des requêtes étendus (jusqu'à 60 minutes), offre une simultanéité accrue et utilise les formats de point de terminaison .cloudfunctions.net et .run.app.
        • Pour en savoir plus sur les différences entre les deux versions, consultez Comparer Cloud Functions.
  7. Cliquez sur Enregistrer.
  8. La configuration d'une tâche Cloud Functions dans Application Integration permet de créer des fonctions Cloud Run de base déclenchées par HTTP dans votre projet Google Cloud.

Modèle de fonction Cloud

Les exemples suivants montrent comment utiliser la tâche Cloud Functions dans votre intégration pour différentes langues.

Python

Lorsque vous configurez une fonction Cloud dans une fonction Cloud Run existante, assurez-vous que les fichiers source main.py, task.py et requirements.txt de la fonction sont au format suivant:

task.py

      # Sample Code:
      # print(event.get('task_string_key'))
      # event.set('task_int_array_key', [456, 789]);
      # event.log('some logging')

      def run(event):
        """Actual cloud function custom logic.
        Args:
          event : event object in main.py that contains all parameters.
        """
        return
    

main.py

      """Un-editable platform wrapper which invokes user code."""
    import traceback

    from flask import json
    from flask import jsonify
    from task import run

    VALUE_NAME = [
        'stringValue', 'intValue', 'doubleValue', 'booleanValue', 'protoValue'
    ]
    ARRAY_VALUE_NAME = {
        'stringArray': 'stringValues',
        'intArray': 'intValues',
        'doubleArray': 'doubleValues',
        'booleanArray': 'booleanValues',
        'protoArray': 'protoValues'
    }
    VALUE_TYPE_URL = 'type.googleapis.com/google.protobuf.Value'
    CLOUD_FUNCTION_EXCEPTION_KEY = 'CloudFunctionException'
    CLOUD_FUNCTION_LOGGING_KEY = 'CloudFunctionLogging'


    class _Event(object):
      """Event object."""

      def __init__(self, json_payload):
        self._event_params = json_payload.get('eventParameters', dict())
        self._task_params = json_payload.get('taskParameters', dict())
        self._log = []
        print('Event param is ' + str(self._event_params))
        print('Task param is ' + str(self._task_params))

      def set(self, key, value):
        """Set the event parameters key-value.

        Args:
          key: parameter key.
          value: parameter value.
        """
        new_param = self._create_param(key, value)
        param = self._get_param_by_key(key)
        if param is None:
          if 'parameters' not in self._event_params:
            self._event_params['parameters'] = []
          self._event_params['parameters'].append(new_param)
        else:
          param['value'] = new_param['value']

      def _create_param(self, key, value):
        """Create a new parameter with given key value pair.

        Args:
          key: parameter key.
          value: parameter value.

        Returns:
          parameter.
        """
        new_param = {}
        new_param['key'] = key
        if isinstance(value, str):
          new_param['value'] = {'stringValue': value}
        elif isinstance(value, int):
          new_param['value'] = {'intValue': value}
        elif isinstance(value, float):
          new_param['value'] = {'doubleValue': value}
        elif isinstance(value, bool):
          new_param['value'] = {'booleanValue': value}
        elif isinstance(value, dict):
          if 'type@' in value:
            new_param['value'] = {'protoValue': value}
          else:
            new_param['value'] = {
                'protoValue': {
                    '@type': 'type.googleapis.com/google.protobuf.Value',
                    'value': value
                }
            }
        elif isinstance(value, list):
          if not value:
            raise RuntimeError('Cannot create a param with empty list')
          if any(not isinstance(val, type(value[0])) for val in value):
            print('Not all elements in the list have the same type')
            new_param['value'] = {
                'protoValue': {
                    '@type': 'type.googleapis.com/google.protobuf.Value',
                    'value': value
                }
            }
          elif isinstance(value[0], str):
            new_param['value'] = {'stringArray': {'stringValues': value}}
          elif isinstance(value[0], int):
            new_param['value'] = {'intArray': {'intValues': value}}
          elif isinstance(value[0], float):
            new_param['value'] = {'doubleArray': {'doubleValues': value}}
          elif isinstance(value[0], bool):
            new_param['value'] = {'booleanArray': {'booleanValues': value}}
          elif isinstance(value[0], dict):
            if all('@type' in val and val['@type'] == value[0]['@type']
                   for val in value):
              new_param['value'] = {'protoArray': {'protoValues': value}}
            else:
              new_param['value'] = {
                  'protoValue': {
                      '@type': 'type.googleapis.com/google.protobuf.Value',
                      'value': value
                  }
              }
          else:
            raise RuntimeError('The type ' + type(value[0]) +
                               ' in the list is not supported')
        else:
          raise RuntimeError('Value ' + str(value) + ' has the type ' +
                             type(value) + ' that is not supported')
        return new_param

      def get(self, key):
        """Get the event parameter value for specified key.

        Args:
          key: parameter key.

        Returns:
          Parameter value.
        """
        param = self._get_param_by_key(key)
        if param is None:
          raise RuntimeError('Can not find param with key ' + key)
        return self._get_param_value(param)

      def _get_param_by_key(self, key):
        """Get the parameter for specified key.

        Args:
          key: parameter key.

        Returns:
          Parameter.
        """
        param = self._get_param_by_key_from_params(key, self._task_params)
        if param is None:
          return self._get_param_by_key_from_params(key, self._event_params)
        value = self._get_param_value(param)
        if isinstance(value, str) and len(value) > 2 and value.startswith(
            '$') and value.endswith('$'):
          return self._get_param_by_key_from_params(value[1:-1], self._event_params)
        return param

      def _get_param_by_key_from_params(self, key, params):
        """Get the parameter for specified key from event parameters.

        Args:
          key: parameter key.
          params: event parameters.

        Returns:
          Parameter.
        """
        if not isinstance(params, dict) or 'parameters' not in params:
          return None
        for param in params['parameters']:
          if param['key'] == key:
            return param
        return None

      def _get_param_value(self, param):
        """Get the parameter value for specified parameter.

        Args:
          param: parameter.

        Returns:
          Parameter value.
        """
        value = param['value']
        if len(value) != 1:
          raise RuntimeError('param does not have size of 1')
        for value_name in VALUE_NAME:
          if value_name in value:
            if value_name == 'protoValue' and value[value_name][
                '@type'] == VALUE_TYPE_URL:
              return value[value_name]['value']
            return value[value_name]
        for array_value_name in ARRAY_VALUE_NAME:
          if array_value_name in value:
            return value[array_value_name][ARRAY_VALUE_NAME[array_value_name]]
        raise RuntimeError('Cannot get value from param ' + str(param))

      def set_error(self):
        """Set the cloud function error to event parameters in order for user to see on IP."""

        self.set(CLOUD_FUNCTION_EXCEPTION_KEY, traceback.format_exc())

      def log(self, message):
        self._log.append(str(message))

      def get_response(self):
        """Get the response that can be returned to IP.

        Returns:
          The response text or any set of values that can be turned into a
          Response object using
          `make_response
          <http://flask.pocoo.org/docs/1.0/api/#flask.Flask.make_response>`.
        """
        if self._log:
          self.set(CLOUD_FUNCTION_LOGGING_KEY, self._log)
        res = {
            'eventParameters': self._event_params,
        }
        return jsonify(**json.loads(json.htmlsafe_dumps(res)))


    def execute_function(request):
      """Entry point of the cloud function.

      Args:
        request (flask.Request): HTTP request object.

      Returns:
        The response text or any set of values that can be turned into a
        Response object using
        `make_response
        <http://flask.pocoo.org/docs/1.0/api/#flask.Flask.make_response>`.
      """
      try:
        request_json = request.get_json(silent=True)
        event = _Event(request_json)
        run(event)
      except:
        event.set_error()
      return event.get_response()

    

requirements.txt

    # Function dependencies, for example:
    # package>=version
    

Pour en savoir plus sur le format de réponse, consultez ValueType.

Java

L'exemple suivant montre comment utiliser la tâche Cloud Function dans votre intégration. Assurez-vous que la réponse respecte le format JSON compatible, comme décrit dans l'exemple:

private static final Gson gson = new Gson();

@Override
public void service(HttpRequest request, HttpResponse response) throws Exception {
  JsonObject body = gson.fromJson(request.getReader(), JsonObject.class);

  JsonArray resParams = new JsonArray();
  for (JsonElement param: body.getAsJsonObject("eventParameters").getAsJsonArray("parameters")) {
    if (param.getAsJsonObject().get("key").getAsString().equals("input")) {
      JsonObject newParam= new JsonObject();
      newParam.addProperty("key", "input");
      JsonObject value = new JsonObject();
      value.addProperty("stringValue","2");
      newParam.add("value", value);
      resParams.add(newParam);
    } else {
      resParams.add(param);
    }
  }
  JsonObject parameters = new JsonObject();
  parameters.add("parameters", resParams);
  JsonObject res = new JsonObject();
  res.add("eventParameters", parameters);
  System.out.println(res);
  BufferedWriter writer = response.getWriter();
  writer.write(res.toString());
}

Pour en savoir plus sur le format de réponse, consultez ValueType.

JavaScript

L'exemple suivant montre comment utiliser la tâche Cloud Function dans votre intégration. Assurez-vous que la réponse respecte le format JSON compatible, comme décrit dans l'exemple:

const functions = require('@google-cloud/functions-framework');

functions.http('execute_function', (req, res) => {
  console.log(JSON.stringify(req.body));
  let response = {"eventParameters":{"parameters":[{"key":"input","value":{"stringValue":"2"}}]}};
  res.send(JSON.stringify(response));
});

Pour en savoir plus sur le format de réponse, consultez ValueType.

PHP

L'exemple suivant montre comment utiliser la tâche Cloud Function dans votre intégration. Assurez-vous que la réponse respecte le format JSON compatible, comme décrit dans l'exemple:

use Psr\Http\Message\ServerRequestInterface;
function execute_function(ServerRequestInterface $request)
{
  return '{"eventParameters":{"parameters":[{"key":"input","value":{"stringValue":"2"}}]}}';
}

Pour en savoir plus sur le format de réponse, consultez ValueType.

Modifier une tâche Cloud Functions

L'Application Integration vous redirige vers la page de console appropriée pour modifier les fonctions Cloud Run en fonction du type de version. Google Cloud

Cloud Functions (1st gen)

Pour modifier une tâche Cloud Functions configurée à l'aide de la version Cloud Functions (1re génération), procédez comme suit:

  1. Dans le volet de configuration de la tâche, cliquez sur Open Cloud Function (Ouvrir une fonction Cloud).

    Vous êtes redirigé vers la page Cloud Functions (1re génération) > Informations sur la fonction de votre Google Cloud console.

  2. Cliquez sur Modifier.
  3. Sur la page Modifier la fonction, l'étape Configuration vous permet de modifier les paramètres de configuration par défaut de la fonction Cloud. Pour en savoir plus, consultez la page Configurer Cloud Functions.
  4. Cliquez sur Suivant pour passer à l'étape Code et modifier le code source de la fonction Cloud.

    Par défaut, la fonction Cloud contient les fichiers sources suivants :

    • main.py : ce fichier contient le code d'initialisation permettant d'exécuter la fonction Cloud à partir de votre intégration.
    • task.py : ce fichier contient le code exécutable de la fonction Cloud. Écrivez votre script dans la fonction run(event). Cette fonction est appelée lors de l'exécution de la tâche Cloud Functions. L'objet event du fichier main.py contient tous les paramètres de la tâche.

      Consultez la section Accéder aux variables d'intégration pour en savoir plus sur l'utilisation des variables définies au niveau de l'intégration dans votre script.

  5. Cliquez sur Déployer.

Cloud Run Functions

Pour modifier une tâche Cloud Functions configurée à l'aide de la version Cloud Functions (dernière génération), procédez comme suit:

  1. Dans le volet de configuration de la tâche, cliquez sur Open Cloud Function (Ouvrir une fonction Cloud).

    Vous êtes redirigé vers la page Fonctions Cloud Run > Informations sur le service de votre Google Cloud console.

  2. Dans l'onglet Source, cliquez sur Modifier la source pour modifier les fichiers de code source des fonctions Cloud Run.

    Par défaut, les fonctions Cloud Run contiennent les fichiers sources suivants:

    • main.py : ce fichier contient le code d'initialisation permettant d'exécuter Cloud Functions à partir de votre intégration.
    • task.py: ce fichier contient le code exécutable des Cloud Functions. Écrivez votre script dans la fonction run(event). Cette fonction est appelée lors de l'exécution de la tâche de fonctions Cloud Run. L'objet event du fichier main.py contient tous les paramètres de la tâche.

      Consultez la section Accéder aux variables d'intégration pour en savoir plus sur l'utilisation des variables définies au niveau de l'intégration dans votre script.

  3. Cliquez sur Enregistrer et redéployer.

Accéder aux variables d'intégration

Pour accéder à une variable d'intégration dans votre fonction Cloud, transmettez-la en tant que paramètre de tâche à la tâche Cloud Function. Le paramètre de tâche est une paire clé-valeur où Key est le nom de la variable de référence utilisée dans le fichier source de votre fonction Cloud et Value est le nom de la variable d'intégration correspondante vers laquelle pointe la variable de référence. Vous pouvez ajouter un ou plusieurs paramètres de tâche dans la section Paramètres de tâche du volet de configuration de la tâche.

Les méthodes suivantes permettent d'accéder aux variables d'intégration à partir de votre fonction Cloud :

  • set : écrit la valeur dans une variable.
  • get : lit la valeur d'une variable.

Par exemple, si vous souhaitez utiliser une variable d'intégration nommée EmployeeName dans le fichier source de votre fonction Cloud, définissez les paramètres de tâche suivants :

  • Key (Clé) : EmployeeKey
  • Valeur : EmployeeName

L'exemple de script suivant montre comment utiliser des fonctions "set" et "get" pour accéder aux variables d'intégration définies.

def run(event):  
  # Read the integration variable EmployeeName using the reference variable EmployeeKey
  value = event.get('EmployeeKey');
  # Change the integration variable EmployeeName value using the reference variable EmployeeKey
  event.set('EmployeeKey' , 'XYZ');
  # The new value of the integration variable is retained throughout the Cloud Function task.
  return

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.

Exclusions du Contrat de niveau de service

La tâche Cloud Functions dépend du produit Google Cloud Functions. Étant donné que cette dépendance est externe à l'Application Integration, toutes les exécutions d'intégrations active qui échouent en raison de l'échec de la tâche de fonction cloud sont exclues des conditions d'utilisation du contrat de niveau de service (CLD) d'intégration d'applications.

Quotas et limites

Pour en savoir plus sur les quotas et les limites des fonctions Cloud Run et de Cloud Functions (1re génération), consultez la section Comparaison de la configuration.

Étapes suivantes