Starter erstellen

In diesem Dokument wird erklärt, wie Sie einen Auslöser erstellen, mit dem Ihre App oder Ihr Dienst Google Workspace Studio benachrichtigen kann, wenn ein Ereignis eintritt, und die Ausführung eines Flows initiieren kann. In der API werden Auslöser als workflowTriggers bezeichnet.

Ein Auslöser startet einen Flow, während ein Schritt eine einzelne Aufgabe in der Abfolge von Aufgaben ist, aus denen ein Flow besteht. Wenn Sie einen Auslöser erstellen, können Nutzer automatisierte Flows einrichten, die auf Echtzeitereignisse aus Ihrer App oder Ihrem Dienst reagieren.

Zum Erstellen eines Auslösers müssen Sie ihn in der Manifestdatei des Add‑ons deklarieren und Lifecycle-Callbacks in Google Apps Script implementieren oder den Auslöser auslösen, indem Sie Nutzlasten an den Google Workspace Studio API-Endpunkt senden.

Vorbereitung

API aktivieren

Aktivieren Sie in Ihrem Google Cloud-Projekt die Google Workspace Studio API:

API aktivieren

Zu einem Standard-Google Cloud-Projekt wechseln (nur Google Apps Script)

Standardmäßig verwenden Apps Script-Projekte ein Standard-Cloud-Projekt, in dem APIs nicht aktiviert und OAuth-Zustimmungsbildschirme nicht konfiguriert werden können. Wenn Sie Ihren Auslöser mit Apps Script erstellen, müssen Sie zu einem Standard-Google Cloud-Projekt wechseln:

  1. Klicken Sie im Apps Script-Editor auf die Projekteinstellungen .
  2. Klicken Sie unter Google Cloud Platform-Projekt (GCP) auf Projekt wechseln.
  3. Geben Sie Ihre Standard-Cloud-Projektnummer ein und klicken Sie auf Projekt festlegen.
  4. Nachdem Sie das Projekt gewechselt haben, autorisieren Sie Ihr Script noch einmal, indem Sie eine beliebige Funktion im Editor ausführen und die angeforderten Berechtigungen erteilen.

Weitere Informationen finden Sie unter Zu einem Standard-Google Cloud-Projekt wechseln.

OAuth-Zustimmungsbildschirm konfigurieren

Um mit dem Workspace Studio API-Endpunkt zu kommunizieren, muss sich Ihre App oder Ihr Dienst mit OAuth 2.0 authentifizieren. Konfigurieren Sie den OAuth-Zustimmungsbildschirm Ihres Projekts und fügen Sie den folgenden dedizierten OAuth-Bereich hinzu:

https://www.googleapis.com/auth/workspace.studio.trigger

Mit diesem Bereich wird die App autorisiert, die Workspace Studio API aufzurufen und Flows auszulösen, die der Nutzer für diesen Auslöser konfiguriert hat.

Weitere Informationen finden Sie unter OAuth-Zustimmungsbildschirm konfigurieren und Bereiche auswählen.

Offlinezugriff und Aktualisierungstokens

Da Auslöser Workspace Studio asynchron benachrichtigen, wenn ein Ereignis im externen Dienst eintritt – was Stunden, Tage oder Monate nach der Konfiguration eines Flows durch einen Nutzer geschehen kann –, muss Ihr Dienst beim Aufrufen des API-Endpunkts ein gültiges OAuth 2.0-Zugriffstoken bereitstellen.

Das von Google im Add‑on-Ereignisobjekt bereitgestellte Zugriffstoken (z. B. bei der Auslöserkonfiguration oder bei Lifecycle-Callback-Anfragen) ist kurzlebig und nur eine Stunde lang gültig. Es reicht nicht aus, um Auslöserereignisse in Zukunft asynchron auszulösen. Wenn Ihr Dienst die Workspace Studio API im Laufe der Zeit aufrufen soll, benötigt er ein Aktualisierungstoken für den Offlinezugriff, um bei Bedarf neue Zugriffstokens zu generieren.

Wie Sie die Autorisierung handhaben und ein Aktualisierungstoken erhalten, hängt von der Laufzeit Ihres Add‑ons ab:

  • HTTP-Add‑ons (alternative Laufzeiten): Bei HTTP Add‑ons muss Ihr Backend-Dienst einen separaten OAuth 2.0-Autorisierungsablauf implementieren, der unabhängig von der integrierten Add‑on-Autorisierung ist, um Offlinezugriff anzufordern (access_type=offline) und ein Aktualisierungstoken zu erhalten.

    Sie können Nutzer auffordern, diese Verbindung zu autorisieren, indem Sie eine Anmelde- oder Autorisierungskarte anzeigen, wenn der Nutzer den Auslöser in Workspace Studio konfiguriert. Weitere Informationen zum Zurückgeben von Autorisierungskarten und zum Umgang mit dem OAuth-Ablauf finden Sie unter Google Workspace-Add‑on mit einem Drittanbieterdienst verbinden (Google Workspace als Drittanbieterdienst behandeln, mit dem Sie eine Verbindung herstellen).

    Ihr Backend-Dienst muss das Aktualisierungstoken sicher speichern (z. B. in der Datenbank Ihres Dienstes neben der triggerId) und es verwenden, um ein neues Zugriffstoken abzurufen, wenn ein Ereignis eintritt, bevor Anfragen an die notifyUri des Auslösers oder den API-Endpunkt triggers.fire gesendet werden.

  • Google Apps Script-Add‑ons: Bei Google Apps Script-basierten Add‑ons, die geplante (zeitgesteuerte) Auslöser verwenden, um nach Ereignissen zu suchen, ist die Implementierung eines unabhängigen OAuth-Ablaufs nicht erforderlich. Da geplante Auslöser direkt in der Google Apps Script-Laufzeitumgebung ausgeführt werden, verwaltet und aktualisiert Google Apps Script die OAuth-Tokens automatisch mit den im Manifest deklarierten Bereichen. Sie können ein OAuth-Zugriffstoken mit ScriptApp.getOAuthToken() abrufen.

Auslöser in der Manifestdatei definieren

Wenn Sie einen Auslöser definieren möchten, fügen Sie ihn in der Manifestdatei Ihres Add‑ons (appsscript.json) im Block addOns.studio.flows.workflowElements hinzu. Diese Konfiguration ist sowohl für Apps Script- als auch für HTTP-Laufzeiten (alternative Laufzeiten) erforderlich. Konfigurieren Sie das Element als workflowTrigger anstelle von workflowAction (das beim Definieren eines Schritts verwendet wird). Weitere Informationen finden Sie unter Manifeststruktur für Google Workspace-Add‑ons.

Geben Sie im Block workflowTrigger Folgendes an:

  • inputs: Variablen, die der Nutzer auf der Konfigurationskarte konfiguriert (z. B. Projektname, Ressourcenfilter usw.).
  • outputs: Variablen, die vom Auslöser an nachfolgende Schritte im Flow zurückgegeben werden können.
  • onConfigFunction: Der Name der Callback-Funktion, die die Benutzeroberfläche für die Konfiguration anzeigt.
  • onManageFunction: Der Name der Callback-Funktion, die von Google aufgerufen wird, um die Erstellung und Löschung von Auslöserabos zu verarbeiten.

Das folgende Codebeispiel zeigt eine Beispielmanifestdefinition für einen Ereignisauslöser:

JSON

{
  "timeZone": "America/Los_Angeles",
  "exceptionLogging": "STACKDRIVER",
  "runtimeVersion": "V8",
  "oauthScopes": [
    "https://www.googleapis.com/auth/script.external_request",
    "https://www.googleapis.com/auth/workspace.studio.trigger"
  ],
  "urlFetchWhitelist": [
    "https://workspacestudio.googleapis.com/"
  ],
  "addOns": {
    "common": {
      "name": "Trigger App",
      "logoUrl": "https://fonts.gstatic.com/s/i/short-term/release/googlesymbols/start/default/24px.svg",
      "useLocaleFromApp": true
    },
    "studio": {
      "flows": {
        "workflowElements": [
          {
            "id": "triggerDemo",
            "state": "ACTIVE",
            "name": "Event Trigger",
            "description": "Fires when a event occurs in the app.",
            "workflowTrigger": {
              "inputs": [
                {
                  "id": "projectId",
                  "description": "The project identifier to watch.",
                  "cardinality": "SINGLE",
                  "dataType": {
                    "basicType": "STRING"
                  }
                }
              ],
              "outputs": [
                {
                  "id": "eventName",
                  "description": "The name of the triggered event.",
                  "cardinality": "SINGLE",
                  "dataType": {
                    "basicType": "STRING"
                  }
                },
                {
                  "id": "eventMessage",
                  "description": "Detailed event message description.",
                  "cardinality": "SINGLE",
                  "dataType": {
                    "basicType": "STRING"
                  }
                }
              ],
              "onConfigFunction": "onConfigTrigger",
              "onManageFunction": "onManageTrigger"
            }
          }
        ]
      }
    }
  }
}

Lebenszyklus des Auslöserabos verarbeiten

Wenn ein Nutzer einen Flow konfiguriert und aktiviert, der Ihren Auslöser enthält, oder wenn der Flow deaktiviert oder gelöscht wird, ruft Google Ihr Add‑on mit der Callback-Funktion onManageFunction auf, die im Manifest deklariert ist.

Das Lifecycle-Event-Objekt

Die Callback-Funktion empfängt ein WorkflowEventObject mit dem Aktionskontext. Für Auslöser umfasst dies Folgendes:

  • Auslösererstellung (event.workflow.triggerCreation): Wird ausgelöst, wenn der Flow veröffentlicht oder aktiviert wird.

    • triggerId: Ein eindeutiger UUID-String, der diese Auslöserregistrierungsinstanz identifiziert.

    • notifyUri: Die eindeutige REST API-Endpunkt-URL, die mit dieser Auslöserregistrierung verknüpft ist (z. B. https://workspacestudio.googleapis.com/v1/triggers/YOUR_TRIGGER_ID:fire). Wenn notifyUri in der Ereignisnutzlast fehlt, erstellen Sie die Endpunkt URL direkt mit der triggerId: https://workspacestudio.googleapis.com/v1/triggers/{triggerId}:fire.

    • inputs: Die vom Nutzer auf der Karte konfigurierten Variableneingaben.

  • Auslöserlöschung (event.workflow.triggerDeletion): Wird ausgelöst, wenn der Auslöser aus dem Flow entfernt wird oder wenn der gesamte Flow deaktiviert oder gelöscht wird.

    • triggerId: Der eindeutige UUID-String der Aboinstanz, die bereinigt werden soll.

Lebenszyklus des Abos für alternative Laufzeiten (HTTP API)

Bei Add‑ons, die mit alternativen Laufzeiten erstellt wurden, werden Benachrichtigungen zum Lebenszyklus des Abos mit HTTP-POST-Anfragen an die konfigurierte HTTP-Endpunkt-URL des Add‑ons gesendet. Der Aktionsname wird von der Callback-Funktion onManageFunction angegeben. Die Nutzlast entspricht der JSON-Darstellung des WorkflowEventObject.

Weitere Informationen zu alternativen Laufzeiten finden Sie unter Google Workspace-Add‑on mit HTTP-Endpunkten erstellen.

Lifecycle-Callbacks in Apps Script implementieren

Das folgende Apps Script-Beispiel zeigt, wie Sie die Benutzeroberflächenkarte konfigurieren, Lifecycle-Ereignisse für Abos mit onManageTrigger verarbeiten und die Auslöseranfrage an Google zurücksenden, wenn ein Ereignis eintritt.

Apps Script

/**
 * Generates and returns the user configuration card to collect inputs.
 */
function onConfigTrigger() {
  const projectInput = CardService.newTextInput()
    .setFieldName("projectId")
    .setTitle("Project ID")
    .setHint("Enter the project identifier to watch");

  const section = CardService.newCardSection()
    .setHeader("Configure Event Trigger")
    .addWidget(projectInput);

  const card = CardService.newCardBuilder()
    .addSection(section)
    .build();

  return card;
}

/**
 * Handles subscription lifecycle events sent from Google Workspace Studio.
 *
 * @param {Object} event The Workspace Studio event object.
 */
function onManageTrigger(event) {
  const triggerCreation = event.workflow.triggerCreation;
  const triggerDeletion = event.workflow.triggerDeletion;

  if (triggerCreation) {
    const triggerId = triggerCreation.triggerId;
    // Fall back to constructing the endpoint URL if notifyUri is omitted.
    const notifyUri = triggerCreation.notifyUri ||
        ("https://workspacestudio.googleapis.com/v1/triggers/" +
         triggerId + ":fire");
    const inputs = triggerCreation.inputs;

    // Extract input values configured by the user.
    const projectId = inputs["projectId"].stringValues[0];

    // Tip: In Apps Script, use PropertiesService to persist triggerId and notifyUri:
    // const props = PropertiesService.getUserProperties();
    // props.setProperty("notifyUri", notifyUri);
    // props.setProperty("triggerId", triggerId);
    //
    // TODO: Save triggerId, notifyUri, and projectId in your database/service.
    // Your backend service listens for events related to 'projectId'
    // and calls notifyUri when those events occur.
    console.log("Trigger subscription created: " + triggerId +
                ", Notify URI: " + notifyUri +
                ", Match Project: " + projectId);

  } else if (triggerDeletion) {
    const triggerId = triggerDeletion.triggerId;

    // In Apps Script, clean up stored properties:
    // PropertiesService.getUserProperties().deleteProperty("notifyUri");
    // PropertiesService.getUserProperties().deleteProperty("triggerId");
    //
    // TODO: Remove references to triggerId from your database and stop
    // sending future event notifications to the associated notifyUri.
    console.log("Trigger subscription deleted: " + triggerId);
  }
}

/**
 * Mock function showing how your backend service fires the trigger.
 * This logic runs on your service when a watched event occurs.
 *
 * @param {string} notifyUri The stored notifyUri associated with the trigger.
 * @param {string} triggerId The stored triggerId.
 * @param {string} [userAccessToken] The OAuth 2.0 access token for the user.
 *     In Apps Script, defaults to ScriptApp.getOAuthToken().
 */
function simulateEventFire(notifyUri, triggerId, userAccessToken) {
  // In Apps Script, obtain the OAuth token using ScriptApp.getOAuthToken().
  const token = userAccessToken || ScriptApp.getOAuthToken();
  // A unique UUID version 4 is recommended as the requestId for idempotency.
  const requestId = Utilities.getUuid();

  const payload = {
    "name": "triggers/" + triggerId,
    "outputs": {
      "eventName": { "stringValues": ["EventOccurred"] },
      "eventMessage": { "stringValues": ["Hello from the service!"] }
    },
    "requestId": requestId
  };

  const options = {
    "method": "POST",
    "contentType": "application/json",
    "headers": {
      "Authorization": "Bearer " + token
    },
    "payload": JSON.stringify(payload),
    "muteHttpExceptions": true
  };

  const response = UrlFetchApp.fetch(notifyUri, options);
  const responseCode = response.getResponseCode();

  if (responseCode === 200) {
    console.log("Trigger successfully fired!");
  } else if (responseCode === 404) {
    // 404 means the trigger registration is invalid or deleted.
    console.log("Trigger not found. Stop sending events for this trigger.");
    // TODO: Clean up the trigger from your backend database.
  } else if (responseCode === 429 || responseCode >= 500) {
    console.log("Temporary error (" + responseCode + "). Retry using exponential backoff.");
  } else {
    console.log("Failed to fire trigger. HTTP Code: " + responseCode + " - " + response.getContentText());
  }
}

Workspace Studio API verwenden

Mit der Workspace Studio API (workspacestudio.googleapis.com) können Sie Google programmatisch über Auslöserereignisse benachrichtigen.

Die Endpunkte befinden sich unter dem Basispfad: https://workspacestudio.googleapis.com/v1.

Auslöserereignis benachrichtigen

Löst einen Auslöser mit der triggers.fire Methode aus, um die Ausführung eines Flows zu initiieren.

  • HTTP-Methode: POST
  • Pfad: /v1/triggers/{triggerId}:fire, wobei {triggerId} die eindeutige Kennung ist, die bei der Erstellung des Auslöserabos abgerufen wurde.
  • OAuth-Bereich: https://www.googleapis.com/auth/workspace.studio.trigger

Das folgende Codebeispiel zeigt, wie Sie einen Auslöser in der Anfrage auslösen.

Ersuchen

{
  "name": "triggers/TRIGGER_ID",
  "outputs": {
    "eventName": {
      "stringValues": [
        "EventOccurred"
      ]
    },
    "eventMessage": {
      "stringValues": [
        "Hello from the service!"
      ]
    }
  },
  "log": {
    "textFormatElements": [
      {
        "text": "An event occurred in the app."
      }
    ]
  },
  "requestId": "UNIQUE_REQUEST_ID"
}
  • name (String, erforderlich): Der Ressourcenname des Auslösers im Format triggers/{triggerId}.
  • outputs (Map, optional): Eine Map mit Ausgabevariablen des Auslösers, die die Ereignisdaten darstellen. Jeder Wert ist ein VariableData-Objekt, das typisierte Listen unterstützt (z. B. stringValues, booleanValues, integerValues).
  • log (Objekt, optional): Eine TextFormat-Markup-Darstellung, die in den Aktivitätsprotokollen der Ausführung von Workspace Studio angezeigt wird.
  • requestId (String, optional): Eine eindeutige Kennung (UUID v4 empfohlen) mit bis zu 36 ASCII-Zeichen, um die Idempotenz der API bei Wiederholungen zu gewährleisten.

Antwort

Bei Erfolg gibt die Antwort ein leeres JSON-Objekt {} zurück.

Workspace Studio API-Kontingente

Der Traffic, der an den Dienst workspacestudio.googleapis.com gesendet wird, ist begrenzt, um eine Systemüberlastung zu vermeiden, eine faire Nutzung der Ressourcen zu fördern und die allgemeine Leistung von Google Workspace zu schützen.

Es gelten die folgenden Kontingente:

Kontingenttyp Quota
Pro Minute und Projekt 1.000 Auslöseranfragen
Pro Minute und Nutzer 100 Auslöseranfragen

Die Kontingenttypen sind:

  • Pro Minute und Projekt: Begrenzt die kumulative Anzahl der Auslöserereignisse, die von einem einzelnen Google Cloud-Projekt eines Entwicklers ausgelöst werden, auf 1.000 Anfragen pro Minute für alle Nutzer, die die Auslöser ausführen.
  • Pro Minute und Nutzer: Begrenzt die kumulativen Auslöser aufrufe eines einzelnen Endnutzers in einem bestimmten Cloud-Projekt auf 100 Anfragen pro Minute.

Zeitbasierte Kontingentfehler verarbeiten

Wenn Sie diese Kontingente überschreiten, gibt die API den HTTP-Fehlercode 429 Too Many Requests (oder 429 Resource Exhausted) zurück, der angibt, dass das Ratenkontingent überschritten wurde.

Um diese Fehler zu beheben, sollte Ihr Code die Ausnahme abfangen und eine Strategie für den abgeschnittenen exponentiellen Backoff verwenden. Bei exponentiellen Backoff-Wiederholungen werden fehlgeschlagene Anfragen mit immer längeren Verzögerungen zwischen den Versuchen wiederholt, einschließlich zufälligem Jitter (Neuberechnung einer zufälligen Verzögerung bei jeder Iteration), um zu verhindern, dass mehrere Clients synchronisiert werden und gleichzeitig wiederholt werden:

  1. Senden Sie eine Anfrage an die Workspace Studio API.
  2. Wenn die Anfrage mit einem 429-Fehler fehlschlägt, warten Sie 1 second + random_number_milliseconds und versuchen Sie es noch einmal.
  3. Wenn der Vorgang wieder fehlschlägt, warten Sie 2 seconds + random_number_milliseconds und versuchen Sie es noch einmal.
  4. Wenn der Vorgang wieder fehlschlägt, warten Sie 4 seconds + random_number_milliseconds und versuchen Sie es noch einmal.
  5. Setzen Sie diese Schleife fort und verdoppeln Sie die Verzögerung bis zu einem maximum_backoff-Schwellenwert (in der Regel 32 oder 64 Sekunden).
  6. Sobald Sie die maximale Backoff-Dauer erreicht haben, versuchen Sie es mit dieser konstanten Verzögerung noch einmal, bis das maximale Limit für Wiederholungen erreicht ist. Beenden Sie den Vorgang und protokollieren Sie den Fehler.

Best Practices

Beachten Sie beim Entwerfen und Implementieren eines Auslösers die folgenden Best Practices:

Einzelne Ereignisse anstelle von Batchlisten ausgeben

Konfigurieren Sie Ihren Auslöser so, dass er für jedes einzelne Ereignis ein einzelnes Ereignis ausgibt (z. B. ein aktualisierter Datensatz, eine neue Nachricht oder eine zugewiesene Aufgabe), anstatt ein einzelnes Ereignis auszugeben, das einen Batch oder eine Liste von Elementen enthält:

  • Konsistenz mit integrierten Auslösern: In Workspace Studio werden integrierte Google Workspace-Auslöser (z. B. Empfang einer E‑Mail in Gmail oder Beitritt eines Nutzers zu einem Bereich in Google Chat) durch ein einzelnes Ereignis ausgelöst. Die Ausgabe von Ereignissen mit einzelnen Elementen entspricht diesem Verhalten und bietet Nutzern eine konsistente, vorhersehbare Erfahrung bei allen Auslösern.
  • Einfachere Flow-Konfiguration: Nachfolgende Schritte in einem Flow verarbeiten in der Regel jeweils ein Element. Wenn Ereignisse mit einzelnen Elementen ausgegeben werden, können Nutzer Variablen direkt zuordnen, ohne komplexe Schritte zum Durchlaufen von Arrays oder zum Parsen von Listen hinzufügen zu müssen.
  • Polling und Batchänderungen einzeln verarbeiten: Wenn Ihr Backend-Dienst eine externe API abfragt und mehrere geänderte Elemente innerhalb eines einzelnen Polling-Intervalls erkennt, lösen Sie für jedes Element ein einzelnes Auslöserereignis aus, anstatt sie in einem Batchereignis zu bündeln.
  • Ereignisrate und Kontingente verwalten: Da das Auslösen einzelner Ereignisse für mehrere geänderte Elemente zu einem plötzlichen Anstieg von Anfragen führen kann, muss Ihr Dienst die Workspace Studio API-Kontingente einhalten (z. B. das Limit von 100 Anfragen pro Minute und Nutzer). Wenn ein Polling-Zyklus eine große Anzahl von Elementen ergibt (z. B. mehr als 100 geänderte Datensätze), verteilen oder drosseln Sie die Ereignisübermittlung im Laufe der Zeit, um 429 Too Many Requests-Fehler zu vermeiden.

Kernverhalten und Grenzfälle

Bei der Integration von Auslösern müssen Entwickler bestimmte Fehlerverhalten und Laufzeitfunktionen berücksichtigen:

  • Keine Unterstützung für Testläufe: Workspace Studio unterstützt keine Test läufe für Auslöser.
  • Idempotenz und Wiedergabe verhindern: Obwohl nicht unbedingt erforderlich, sollten Sie eine eindeutige requestId (z. B. eine UUID) in Ihre HTTP- oder Apps Script-Nutzlast einfügen. Durch die Angabe einer requestId wird die Idempotenz gewährleistet, da die API doppelte Benachrichtigungen erkennen und ignorieren kann. So wird verhindert, dass der Flow mehrmals für ein einzelnes Ereignis ausgeführt wird.

  • Deaktivierte und wieder aktivierte Flows: Wenn ein Flow, der Ihren Auslöser enthält, in Workspace Studio deaktiviert wird, sendet Google ein triggerDeletion Lifecycle-Ereignis an Ihren onManageFunction Callback. In addition, any calls to the associated FireTrigger method return a 404 Not Found error return code (Requested entity was not found.). Your service should react to 404 errors by stopping future event notification deliveries for that starter instance ID.

    Wenn ein Nutzer den Flow später wieder aktiviert, initiiert Google einen neuen Lebenszyklus für das Abo, indem der onManageFunction-Callback mit einem neuen triggerCreation-Ereignis aufgerufen wird, das eine neue triggerId und notifyUri enthält. Die vorherige triggerId wird dauerhaft deaktiviert und nicht wieder aktiviert. Ihr Dienst sollte daher nicht prüfen, ob eine alte Auslöserinstanz wieder aktiviert wurde. Weitere Informationen finden Sie unter Lebenszyklus des Auslöserabos verarbeiten.

  • Idempotente Löschung des Abos: Die onManageFunction Callback Funktion muss Löschanträge für Auslöser von Google idempotent verarbeiten. Wenn Google den Lösch-Hook mehrmals für dieselbe triggerId aufruft (z. B. bei Wiederholungen aufgrund vorübergehender Verbindungsverluste), sollte die Funktion erfolgreich zurückgegeben werden.

  • Flow-Kontingente: Neben den Workspace Studio API-Kontingenten unterliegen Nutzer Flows zusätzlichen internen Kontingent kontrollen. Häufige Schleifen oder ein übermäßiges Ereignisvolumen können Sicherheitsgrenzwerte überschreiten, was zur automatischen Deaktivierung des Flows führt.

  • Berechtigung verweigert (403) beim Auslösen des Auslösers: Wenn Aufrufe des triggers.fire Endpunkts 403 PERMISSION_DENIED mit dem SERVICE_DISABLED Fehlerstatus zurückgeben, prüfen Sie Folgendes:

    • Die Google Workspace Studio API ist in Ihrem Google Cloud-Projekt aktiviert.
    • Wenn Sie Google Apps Script verwenden, ist Ihr Projekt mit einem Standard-Cloud-Projekt und nicht mit dem Standard-Apps Script-Cloud-Projekt verknüpft.
    • Das OAuth-Zugriffstoken enthält den Bereich https://www.googleapis.com/auth/workspace.studio.trigger.