Esta página foi traduzida pela API Cloud Translation.

Consulte os conetores suportados para a solução Application Integration.

Tarefa da função do Cloud

A tarefa Função do Google Cloud permite-lhe configurar e executar funções do Cloud Run a partir da sua integração. As funções do Cloud Run representam a próxima evolução do Cloud Functions, oferecendo um modelo de programação orientado por eventos com controlo e escalabilidade melhorados, tirando partido da plataforma sem servidor do Cloud Run. As funções do Cloud Run oferecem uma solução sem servidor única para todos os tipos de carga de trabalho.

A tarefa da função da nuvem suporta as seguintes versões das funções do Cloud Run:

Cloud Functions (1.ª geração)
Funções do Cloud Run criadas com a API Cloud Functions v2

Para obter informações detalhadas sobre as diferenças entre as versões das funções do Cloud Run, consulte o guia de comparação do Cloud Functions.

Antes de começar

Certifique-se de que realiza as seguintes tarefas no seu projeto do Google Cloud antes de configurar a tarefa Cloud Function.

Para estabelecer ligação à Cloud Function, certifique-se de que criou um perfil OAuth 2.0 ou anexou uma conta de serviço gerida pelo utilizador à sua integração:

Se a sua integração tiver uma conta de serviço anexada, atribua a função do IAM Cloud Function Invoker a essa conta de serviço.
Para obter informações sobre a atribuição de funções a uma conta de serviço, consulte o artigo Faça a gestão do acesso às contas de serviço.
A tarefa Cloud Function só suporta perfis de autenticação do tipo token de ID OIDC da Google. Crie um perfil de autenticação do tipo Token de ID do Google OIDC com a conta de serviço com a função IAM Cloud Functions Invoker atribuída. Se a tarefa da função na nuvem não exigir autenticação, o campo Perfil de autenticação no painel de configuração da tarefa pode ser deixado vazio.

Se a sua integração tiver um perfil de ID OIDC e uma conta de serviço gerida pelo utilizador configurados, o perfil de ID OIDC é usado por predefinição para a autenticação. Se não estiver configurado nenhum perfil de ID OIDC nem conta de serviço gerida pelo utilizador, é usada a conta de serviço predefinida (service-PROJECT_NUMBER@gcp-sa-integrations.iam.gserviceaccount.com) para chamar a tarefa Cloud Function.

Certifique-se de que o VPC Service Controls não está configurado para a integração de aplicações no seu Google Cloud projeto.
Aviso: a função do Google Cloud não funciona ou deixa de funcionar se o VPC Service Controls estiver configurado para a integração de aplicações no seu Google Cloud projeto.

Configure a tarefa da função do Google Cloud

Para configurar a tarefa Cloud Function na sua integração, siga estes passos:

No menu de navegação, clique em Integrações.
Esta ação abre a lista de integrações disponíveis na IU de integração de aplicações.
Selecione uma integração existente ou clique em Criar integração.
Se estiver a criar uma nova integração, introduza um nome e uma descrição na caixa de diálogo de criação e clique em Criar.
No menu pendente Tarefas, clique em Função na nuvem para a colocar no editor de integração.
Clique no elemento Função do Google Cloud no criador para abrir o painel de configuração e, de seguida, clique em Configurar função do Google Cloud.
Se lhe for pedido que conceda autorizações à conta de serviço, clique em Conceder.
A integração de aplicações concede automaticamente as autorizações necessárias à conta de serviço.
No painel Configuração da função do Google Cloud, selecione uma das seguintes opções:
- Associar função existente: selecione esta opção para associar uma função existente à sua integração. Pode associar o Cloud Functions (1.ª geração) e o Cloud Functions criado com a API Cloud Functions v2 a partir da sua integração.
  - No campo URL do acionador do Cloud Functions, introduza o URL do acionador da função existente.
    O URL deve seguir um dos seguintes formatos:
```
# 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
```
  Importante: certifique-se de que os ficheiros de origem da função do Cloud existente cumprem o formato especificado no modelo de função do Cloud.
- Criar nova função: selecione esta opção para criar uma nova função para a integração.
  1. No campo Nome da função, introduza um nome exclusivo para as novas funções do Cloud Run.
  2. No menu pendente Região, selecione a região onde as funções do Cloud Run estão implementadas.
  3. No menu pendente Versão da função, selecione a versão das funções do Cloud Run pretendida:
    - Cloud Functions (1.ª geração): esta é a versão antiga das funções do Cloud Run, anteriormente conhecidas como Cloud Functions (1.ª geração), que usa o formato de ponto final .cloudfunctions.net.
    - Cloud Functions (última geração): esta é a versão mais recente das funções do Cloud Run, criadas com a API Cloud Functions v2. Criada no Cloud Run e no Eventarc, suporta limites de tempo de pedido alargados (até 60 minutos), oferece maior concorrência e usa os formatos de ponto final .cloudfunctions.net e .run.app.
Clique em Guardar.

A configuração de uma tarefa do Cloud Functions na integração de aplicações cria funções básicas do Cloud Run acionadas por HTTP no seu projeto do Google Cloud.

Modelo de função do Cloud

Os seguintes exemplos mostram como usar a tarefa Cloud Function na sua integração para diferentes idiomas.

Python

Quando configurar a função do Cloud com funções do Cloud Run existentes, certifique-se de que os ficheiros de origem main.py, task.py e requirements.txt da função estão no seguinte formato:

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(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

Para mais informações sobre o formato de resposta, consulte ValueType.

Java

O exemplo seguinte mostra como usar a tarefa Cloud Function na sua integração. Certifique-se de que a resposta segue o formato JSON suportado, conforme descrito no exemplo:

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());
}

Para mais informações sobre o formato de resposta, consulte ValueType.

JavaScript

O exemplo seguinte mostra como usar a tarefa Cloud Function na sua integração. Certifique-se de que a resposta segue o formato JSON suportado, conforme descrito no exemplo:

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));
});

Para mais informações sobre o formato de resposta, consulte ValueType.

PHP

O exemplo seguinte mostra como usar a tarefa Cloud Function na sua integração. Certifique-se de que a resposta segue o formato JSON suportado, conforme descrito no exemplo:

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

Para mais informações sobre o formato de resposta, consulte ValueType.

Edite uma tarefa da Cloud Functions

A integração de aplicações direciona para a página da consola Google Cloud adequada para editar as funções do Cloud Run com base no tipo de versão.

Cloud Functions (1.ª geração)

Para editar uma tarefa da Cloud Functions configurada através da versão da Cloud Functions (1.ª geração), siga estes passos:

No painel de configuração da tarefa, clique em Abrir função do Google Cloud.
É direcionado para a página Cloud Functions (1.ª geração) > Detalhes da função no seu Google Cloud console.
Clique em Edit.
Na página Editar função, o passo Configuração permite-lhe editar as definições de configuração predefinidas da função do Google Cloud. Consulte o artigo Configurar o Cloud Functions para mais informações.
Clique em Seguinte para avançar para o passo Código e editar o código-fonte da Cloud Function.
Por predefinição, a Cloud Function contém os seguintes ficheiros de origem:
- main.py : este ficheiro contém o código de inicialização para executar a função na nuvem a partir da sua integração.
  Atenção: não edite nem modifique o ficheiro main.py.
- task.py : este ficheiro contém o código executável da função do Google Cloud. Escreva o seu script dentro da função run(event). Esta função é chamada quando a tarefa da função do Cloud é executada. O objeto event do ficheiro main.py contém todos os parâmetros da tarefa.
  Consulte o artigo Aceda às variáveis de integração para ver informações sobre como usar as variáveis definidas ao nível da integração no seu script.
Clique em Implementar.

Funções do Cloud Run

Para editar uma tarefa da Cloud Functions configurada com a versão da Cloud Functions (Latest Gen), siga estes passos:

No painel de configuração da tarefa, clique em Abrir função do Google Cloud.
É redirecionado para a página Funções do Cloud Run > Detalhes do serviço no seu Google Cloud console.
No separador Origem, clique em Editar origem para editar os ficheiros de código-fonte das funções do Cloud Run.
Por predefinição, as funções do Cloud Run contêm os seguintes ficheiros de origem:
- main.py : este ficheiro contém o código de inicialização para executar as Cloud Functions a partir da sua integração.
  Atenção: não edite nem modifique o ficheiro main.py.
- task.py: este ficheiro contém o código executável das Cloud Functions. Escreva o seu script dentro da função run(event). Esta função é chamada quando a tarefa das funções do Cloud Run é executada. O objeto event do ficheiro main.py contém todos os parâmetros da tarefa.
  Consulte o artigo Aceda às variáveis de integração para ver informações sobre como usar as variáveis definidas ao nível da integração no seu script.
Clique em Guardar e voltar a implementar.

Aceda às variáveis de integração

Para aceder a uma variável de integração na sua função do Google Cloud, transmita a variável como um parâmetro de tarefa para a tarefa função do Google Cloud. O parâmetro task é um par de chave-valor em que Key é o nome da variável de referência usada no ficheiro de origem da função na nuvem e Value é o nome da variável de integração correspondente para a qual a variável de referência aponta. Pode adicionar um ou mais parâmetros de tarefas na secção Parâmetros de tarefas do painel de configuração de tarefas.

Os seguintes métodos são usados para aceder às variáveis de integração a partir da sua função do Google Cloud:

set: escreve o valor numa variável.
get: lê o valor de uma variável.

Por exemplo, se tiver uma variável de integração denominada EmployeeName que quer usar no ficheiro de origem da função na nuvem, defina os seguintes parâmetros da tarefa:

Chave: EmployeeKey
Valor: EmployeeName

O exemplo de script seguinte mostra a utilização das funções set e get para aceder às variáveis de integração definidas.

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

Estratégia de processamento de erros

Uma estratégia de processamento de erros para uma tarefa especifica a ação a realizar se a tarefa falhar devido a um erro temporário. Para obter informações sobre como usar uma estratégia de processamento de erros e conhecer os diferentes tipos de estratégias de processamento de erros, consulte o artigo Estratégias de processamento de erros.

Exclusões do SLA

A tarefa da função do Cloud tem uma dependência do produto Google Cloud Functions. Uma vez que esta dependência é externa à integração de aplicações, todas as execuções de integrações active que falham devido à falha na tarefa da função do Google Cloud são excluídas dos termos e condições do contrato de nível de serviço (SLA) da integração de aplicações.

Quotas e limites

Para ver informações sobre as quotas e os limites das funções do Cloud Run e do Cloud Functions (1.ª geração), consulte o artigo Comparação da configuração.

O que se segue?

Saiba mais sobre todas as tarefas e acionadores.
Saiba como testar e publicar uma integração .

Saiba mais acerca do processamento de erros.
Saiba mais sobre os registos de execução da integração.