Diese Seite wurde von der Cloud Translation API übersetzt.

Unterstützte Connectors für Application Integration

Cloud Functions Funktion-Aufgabe

Mit der Cloud Functions-Aufgabe 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. Sie bieten ein ereignisgesteuertes Programmiermodell mit verbesserter Steuerung und Skalierbarkeit und nutzen die serverlose Cloud Run-Plattform. Cloud Run Functions bietet eine einzige serverlose Lösung für alle Arten von Arbeitslasten.

Der Cloud Functions-Task unterstützt die folgenden Versionen von Cloud Run Functions:

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

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

Hinweise

Führen Sie folgende Aufgaben in Ihrem Google Cloud-Projekt aus, bevor Sie die Cloud Functions-Aufgabe 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 Cloud Functions-Aufgabe 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 Cloud Functions-Aufgabe keine Authentifizierung erforderlich ist, kann das Feld Authentifizierungsprofil im Konfigurationsbereich der Aufgabe leer bleiben.

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

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

Cloud Functions-Aufgabe konfigurieren

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

Klicken Sie im Navigationsmenü auf Integrationen.
Dadurch wird die Liste der verfügbaren Integrationen in der Application Integration-Benutzeroberfläche 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 Cloud Functions-Element 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 Gewähren.
Application Integration gewährt 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, über Ihre Integration verknüpfen.
  - Geben Sie im Feld Cloud Functions-Trigger-URL die Trigger-URL der vorhandenen Funktion ein.
    Die URL sollte 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-Funktion bereitgestellt wird.
  3. Wählen Sie im Drop-down-Menü Funktionsversion die gewünschte Cloud Run Functions-Version aus:
    - Cloud Functions (1. Generation): Dies ist die Legacy-Version von Cloud Run Functions, früher Cloud Functions (1. Generation), die das Endpunktformat .cloudfunctions.net verwendet.
    - Cloud Functions (Latest Gen): Dies ist die neueste Version von Cloud Run-Funktionen, die mit der Cloud Functions v2 API erstellt wurden. Es 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 .cloudfunctions.net- als auch .run.app-Endpunktformate.
Klicken Sie auf Speichern.

Beim Konfigurieren einer Cloud Functions-Aufgabe 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 Cloud Functions-Aufgabe in Ihrer Einbindung 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

Im folgenden Beispiel wird gezeigt, wie Sie die Cloud Functions-Aufgabe 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 Functions 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)

So bearbeiten Sie eine Cloud Function-Aufgabe, die mit der Version von Cloud Functions (1. Generation) konfiguriert wurde:

Klicken Sie im Konfigurationsbereich der Aufgabe auf Cloud Functions öffnen.
Sie werden in Ihrem Google Cloud consolezur 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 Function 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-Funktionen

So bearbeiten Sie eine Cloud Function-Aufgabe, die mit der Version „Cloud Functions (Latest Gen)“ konfiguriert wurde:

Klicken Sie im Konfigurationsbereich der Aufgabe auf Cloud Functions öffnen.
Sie werden in Google Cloud consolezur Seite Cloud Run Functions > Dienstdetails weitergeleitet.
Klicken Sie auf dem Tab Quelle auf Quelle bearbeiten, um die Quellcodedateien der Cloud Run-Funktionen zu bearbeiten.
Cloud Run Functions-Funktionen enthalten 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 Cloud Functions-Aufgabe übergeben. Der Aufgabenparameter ist ein Schlüssel/Wert-Paar, wobei Schlüssel 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 Functions-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 Aufgabe „Cloud Functions-Funktion“ ist vom Produkt Google Cloud Functions abhängig. Da diese Abhängigkeit außerhalb von Application Integration liegt, sind alle Ausführungen von active-Integrationen, die aufgrund des Fehlers in Cloud Function-Aufgabe fehlschlagen, von den Nutzungsbedingungen des Service Level Agreement (SLA) für Application Integration ausgeschlossen.

Kontingente und Limits

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

Cloud Functions Funktion-Aufgabe

Hinweise

Cloud Functions-Aufgabe konfigurieren

Vorlage für die Cloud Functions-Funktion

Python

task.py

main.py

requirements.txt

Java

JavaScript

PHP

Cloud Functions Funktion-Aufgabe bearbeiten

Cloud Functions (1. Generation)

Cloud Run-Funktionen

Auf Integrationsvariablen zugreifen

Fehlerbehebungsstrategie

SLA-Ausschlüsse

Kontingente und Limits

Nächste Schritte