Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Cloud Function-Aufgabe

Mit der Aufgabe Cloud Functions können Sie Cloud Run-Funktionen aus Ihrer Integration heraus konfigurieren und ausführen. Cloud Run-Funktionen sind die nächste Generation von Cloud Functions und bieten ein ereignisgesteuertes Programmiermodell mit verbesserter Steuerung und Skalierbarkeit, das die serverlose Cloud Run-Plattform nutzt. Cloud Run-Funktionen bieten eine einzige serverlose Lösung für alle Arten von Arbeitslasten.

Die Cloud Functions-Aufgabe unterstützt die folgenden Versionen von Cloud Run-Funktionen:

Cloud Functions (1. Generation)
Cloud Run-Funktionen, die mit der Cloud Functions v2 API erstellt wurden

Ausführliche Informationen zu den Unterschieden zwischen den Versionen von Cloud Run-Funktionen finden Sie im Leitfaden zum Vergleich von Cloud Functions.

Hinweis

Führen Sie folgende Aufgaben in Ihrem Google Cloud-Projekt aus, bevor Sie die Aufgabe Cloud Functions konfigurieren.

Wenn Sie eine Verbindung zu Cloud Function herstellen möchten, müssen Sie entweder ein OAuth 2.0-Profil erstellt oder ein nutzerverwaltetes Dienstkonto an Ihre Integration angehängt haben:

Wenn Ihre Integration ein Dienstkonto hat, weisen Sie diesem Dienstkonto die IAM-Rolle Cloud Functions-Aufrufer zu.
Informationen zum Zuweisen von Rollen zu einem Dienstkonto finden Sie unter Zugriff auf Dienstkonten verwalten.
Die Aufgabe Cloud Functions unterstützt nur Authentifizierungsprofile vom Typ OIDC-ID-Token von Google. Erstellen Sie mithilfe des Dienstkontos ein Authentifizierungsprofil vom Typ OIDC-ID-Token von Google mit der zugewiesenen IAM-Rolle Cloud Functions-Aufrufer. Wenn für die Aufgabe Cloud Functions keine Authentifizierung erforderlich ist, kann das Feld Authentifizierungsprofil im Konfigurationsbereich der Aufgabe leer bleiben.

Wenn für Ihre Integration sowohl ein OIDC-ID-Profil als auch ein nutzerverwaltetes Dienstkonto konfiguriert sind, wird standardmäßig das OIDC-ID-Profil zur Authentifizierung verwendet. Wenn weder das OIDC-ID-Profil noch das nutzerverwaltete Dienstkonto konfiguriert ist, wird die Aufgabe Cloud Functions mit dem Standarddienstkonto (service-PROJECT_NUMBER@gcp-sa-integrations.iam.gserviceaccount.com) aufgerufen.

Achten Sie darauf, dass VPC Service Controls nicht für Application Integration in Ihrem Google Cloud Projekt eingerichtet ist.
Warnung: Cloud Functions funktioniert nicht oder funktioniert nicht mehr, wenn VPC Service Controls für Application Integration in Ihrem Google Cloud Projekt eingerichtet ist.

Cloud Function-Aufgabe konfigurieren

Führen Sie folgende Schritte aus, um die Aufgabe Cloud Functions in Ihrer Einbindung zu konfigurieren:

Klicken Sie im Navigationsmenü auf Integrationen.
Dadurch wird die Liste der verfügbaren Integrationen in der Application Integration-UI geöffnet.
Wählen Sie eine vorhandene Integration aus oder klicken Sie auf Integration erstellen.
Wenn Sie eine neue Integration erstellen, geben Sie im Dialogfeld „Erstellen“ einen Namen und eine Beschreibung ein und klicken Sie auf Erstellen.
Klicken Sie im Drop-down-Menü Aufgaben auf Cloud Functions, um die Aufgabe im Integrationseditor zu platzieren.
Klicken Sie auf das Element Cloud Functions im Designer, um den Konfigurationsbereich zu öffnen, und klicken Sie dann auf Cloud Functions konfigurieren.
Wenn Sie aufgefordert werden, dem Dienstkonto Berechtigungen zu erteilen, klicken Sie auf Erteilen.
Application Integration erteilt dem Dienstkonto automatisch die erforderlichen Berechtigungen.
Wählen Sie im Bereich Cloud Functions-Konfiguration eine der folgenden Optionen aus:
- Vorhandene Funktion verknüpfen:Wählen Sie diese Option aus, um eine vorhandene Funktion mit Ihrer Integration zu verknüpfen. Sie können Cloud Functions (1. Generation) und Cloud Functions, die mit der Cloud Functions v2 API erstellt wurden, mit Ihrer Integration verknüpfen.
  - Geben Sie im Feld Cloud Functions-Trigger-URL die Trigger-URL der vorhandenen Funktion ein.
    Die URL muss eines der folgenden Formate haben:
```
# 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
```
  Wichtig: Die Quelldateien für die vorhandene Cloud Functions-Funktion müssen dem Format entsprechen, das in der Vorlage für die Cloud Functions-Funktion angegeben ist.
- Neue Funktion erstellen:Wählen Sie diese Option aus, um eine neue Funktion für die Integration zu erstellen.
  1. Geben Sie im Feld Funktionsname einen eindeutigen Namen für die neuen Cloud Run-Funktionen ein.
  2. Wählen Sie im Drop-down-Menü Region die Region aus, in der die Cloud Run-Funktionen bereitgestellt werden.
  3. Wählen Sie im Drop-down-Menü Funktionsversion die gewünschte Version der Cloud Run-Funktionen aus:
    - Cloud Functions (1. Generation) : Dies ist die Legacy-Version von Cloud Run-Funktionen, früher Cloud Functions (1. Generation), die das Endpunktformat .cloudfunctions.net verwendet.
    - Cloud Functions (neueste Generation) : Dies ist die neueste Version von Cloud Run-Funktionen, die mit der Cloud Functions v2 API erstellt wurde. Sie basiert auf Cloud Run und Eventarc, unterstützt längere Zeitüberschreitungen für Anfragen (bis zu 60 Minuten), bietet eine höhere Nebenläufigkeit und verwendet sowohl das Endpunktformat .cloudfunctions.net als auch .run.app.
Klicken Sie auf Speichern.

Beim Konfigurieren einer Aufgabe Cloud Functions in Application Integration wird eine grundlegende HTTP- ausgelöste Cloud Run-Funktion in Ihrem Google Cloud-Projekt erstellt.

Vorlage für die Cloud Functions-Funktion

Die folgenden Beispiele zeigen, wie Sie die Aufgabe Cloud Functions in Ihrer Integration für verschiedene Sprachen verwenden.

Python

Achten Sie beim Konfigurieren der Cloud Functions-Funktion mit einer vorhandenen Cloud Run-Funktion darauf, dass die Quelldateien main.py, task.py und requirements.txt der Funktion das folgende Format haben:

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

Weitere Informationen zum Antwortformat finden Sie unter ValueType.

Java

Das folgende Beispiel zeigt, wie Sie die Aufgabe Cloud Functions in Ihrer Integration verwenden. Achten Sie darauf, dass die Antwort dem unterstützten JSON-Format entspricht, wie im Beispiel beschrieben:

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

Weitere Informationen zum Antwortformat finden Sie unter ValueType.

JavaScript

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

Weitere Informationen zum Antwortformat finden Sie unter ValueType.

PHP

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

Weitere Informationen zum Antwortformat finden Sie unter ValueType.

Cloud Function Funktion-Aufgabe bearbeiten

Application Integration leitet Sie je nach Versionstyp zur entsprechenden Google Cloud Konsolenseite weiter, um die Cloud Run-Funktionen zu bearbeiten.

Cloud Functions (1. Generation)

Führen Sie die folgenden Schritte aus, um eine Cloud Function-Aufgabe zu bearbeiten, die mit der Version Cloud Functions (1. Generation) konfiguriert wurde:

Klicken Sie im Konfigurationsbereich der Aufgabe auf Cloud Functions öffnen.
Sie werden in Ihrem Google Cloud consoleProjekt zur Seite Cloud Functions (1. Generation) > Funktionsdetails weitergeleitet.
Klicken Sie auf Bearbeiten.
Auf der Seite Funktion bearbeiten können Sie im Schritt Konfiguration die Standardkonfigurationseinstellungen der Cloud Functions-Funktion bearbeiten. Weitere Informationen finden Sie unter Cloud Functions konfigurieren.
Klicken Sie auf Weiter , um zum Schritt Code zu gelangen und den Quellcode der Cloud Functions-Funktion zu bearbeiten.
Eine Cloud Functions-Funktion enthält standardmäßig folgende Quelldateien:
- main.py : Diese Datei enthält den Initialisierungscode zum Ausführen der Cloud Functions-Funktion aus Ihrer Einbindung.
  Achtung:Bearbeiten oder ändern Sie die Datei main.py nie.
- task.py : Diese Datei enthält den ausführbaren Code der Cloud Functions-Funktion. Schreiben Sie das Skript in die Funktion run(event). Diese Funktion wird aufgerufen, wenn die Cloud Functions-Aufgabe ausgeführt wird. Das Objekt event aus der Datei main.py enthält alle Aufgabenparameter.
  Informationen zur Verwendung der auf der Integrationsebene Ihres Skripts definierten Variablen finden Sie unter Zugriffsintegrationsvariablen.
Klicken Sie auf Bereitstellen.

Cloud Run Functions

Führen Sie die folgenden Schritte aus, um eine Cloud Function-Aufgabe zu bearbeiten, die mit der Version Cloud Functions (neueste Generation) konfiguriert wurde:

Klicken Sie im Konfigurationsbereich der Aufgabe auf Cloud Functions öffnen.
Sie werden in Ihrem Google Cloud consoleProjekt zur Seite Cloud Run-Funktionen > Dienstdetails weitergeleitet.
Klicken Sie auf dem Tab Quelle auf Quelle bearbeiten, um die Quellcodedateien der Cloud Run-Funktionen zu bearbeiten.
Eine Cloud Run-Funktion enthält standardmäßig folgende Quelldateien:
- main.py : Diese Datei enthält den Initialisierungscode zum Ausführen der Cloud Functions-Funktion aus Ihrer Einbindung.
  Achtung:Bearbeiten oder ändern Sie die Datei main.py nie.
- task.py: Diese Datei enthält den ausführbaren Code der Cloud Functions-Funktion. Schreiben Sie das Skript in die Funktion run(event). Diese Funktion wird aufgerufen, wenn die Cloud Run-Funktionen-Aufgabe ausgeführt wird. Das Objekt event aus der Datei main.py enthält alle Aufgabenparameter.
  Informationen zur Verwendung der auf der Integrationsebene Ihres Skripts definierten Variablen finden Sie unter Zugriffsintegrationsvariablen.
Klicken Sie auf Speichern und wieder bereitstellen.

Auf Integrationsvariablen zugreifen

Für den Zugriff auf eine Integrationsvariable in Ihrer Cloud Function müssen Sie die Variable als Aufgabenparameter an die Aufgabe Cloud Functions übergeben. Der Aufgabenparameter ist ein Schlüssel/Wert-Paar, wobei Key der Name der in Ihrer Cloud Function-Quelldatei verwendeten Referenzvariable und Wert der entsprechende Name der Integrationsvariable ist, auf die die Referenzvariable zeigt. Sie können einen oder mehrere Aufgabenparameter im Abschnitt Aufgabenparameter des Aufgabenkonfigurationsbereichs hinzufügen.

Die folgenden Methoden werden verwendet, um von Ihrer Cloud Functions-Funktion auf Integrationsvariablen zuzugreifen:

set: Legt den Wert auf eine Variable fest.
get: Ruft den Wert einer Variablen ab.

Wenn Sie beispielsweise eine Integrationsvariable mit dem Namen EmployeeName haben, die Sie in Ihrer Cloud Function-Quelldatei verwenden möchten, definieren Sie folgende Aufgabenparameter:

Key: EmployeeKey
Wert: EmployeeName

Das folgende Beispielskript zeigt die Verwendung von set- und get-Funktionen zum Zugriff auf definierte Integrationsvariablen.

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

Fehlerbehebungsstrategie

Eine Strategie zur Fehlerbehandlung für eine Aufgabe legt die Aktion fest, die ausgeführt werden soll, wenn die Aufgabe aufgrund eines temporären Fehlers fehlschlägt. Informationen zur Verwendung einer Fehlerbehandlungsstrategie und zu den verschiedenen Arten von Fehlerbehandlungsstrategien finden Sie unter Strategien zur Fehlerbehebung.

SLA-Ausschlüsse

Die Cloud Functions-Aufgabe ist von dem Google Cloud Functions Produkt abhängig. Da diese Abhängigkeit außerhalb von Application Integration liegt, sind alle Ausführungen von active Integrationen, die aufgrund eines Fehlers in der Cloud Function-Aufgabe fehlschlagen, von den Nutzungsbedingungen des Service Level Agreement (SLA) für Application Integration ausgeschlossen.

Kontingente und Limits

Die Aufgabe Cloud Functions hat ein Zeitlimit für die Ausführung von 2 Minuten (120 Sekunden). Wenn die aufgerufene Funktion länger als 2 Minuten benötigt, um die Ausführung abzuschließen und zu antworten, schlägt die Aufgabe mit einem Fehler wegen Zeitüberschreitung (TIMEOUT_WEB) fehl.

Achtung:Auch wenn für die zugrunde liegende Cloud Run-Funktion ein längeres Zeitlimit für Anfragen konfiguriert ist (z.B. bis zu 60 Minuten) oder Ihre Integration mit einer asynchronen (ASYNC) Ausführungsstrategie ausgeführt wird, wartet die Aufgabe Cloud Functions synchron auf die HTTP-Antwort und es kommt nach 2 Minuten zu einer Zeitüberschreitung.

Wenn für Ihre Arbeitslast Ausführungszeiten von mehr als 2 Minuten erforderlich sind, können Sie die folgenden Problemumgehungen in Betracht ziehen:

Asynchroner Trigger mit Pub/Sub:Verwenden Sie in Ihrer Integration eine Pub/Sub-Aufgabe oder einen Pub/Sub-Connector, um eine Ereignisnachricht zu veröffentlichen, und konfigurieren Sie Ihre Cloud Run-Funktionen so, dass sie asynchron über das Pub/Sub-Themenabo ausgelöst werden, um die Arbeitslast im Hintergrund zu verarbeiten.
Sofortige HTTP-Bestätigung und asynchroner Callback:Konfigurieren Sie Ihre HTTP-ausgelösten Cloud Run-Funktionen so, dass sie nach dem Empfang der Anfrage sofort eine HTTP-Antwort 200 OK zurückgeben, die zeitaufwendige Aufgabe asynchron im Hintergrund verarbeiten und optional einen Application Integration API-Triggerendpunkt aufrufen, um die nachfolgenden Integrationsschritte fortzusetzen, sobald die Verarbeitung abgeschlossen ist.

Informationen zu allgemeinen Kontingenten und Limits für Cloud Run-Funktionen und Cloud Functions (1. Generation) finden Sie unter Konfigurationsvergleich.

Cloud Function-Aufgabe

Hinweis

Cloud Function-Aufgabe konfigurieren

Vorlage für die Cloud Functions-Funktion

Python

task.py

main.py

requirements.txt

Java

JavaScript

PHP

Cloud Function Funktion-Aufgabe bearbeiten

Cloud Functions (1. Generation)

Cloud Run Functions

Auf Integrationsvariablen zugreifen

Fehlerbehebungsstrategie

SLA-Ausschlüsse

Kontingente und Limits

Nächste Schritte