स्टार्टर बनाना

इस दस्तावेज़ में, स्टार्टर बनाने का तरीका बताया गया है. इससे आपका ऐप्लिकेशन या सेवा, Google Workspace Studio को किसी इवेंट के होने पर सूचना दे सकती है और फ़्लो को शुरू कर सकती है. एपीआई में, स्टार्टर को workflowTriggers कहा जाता है.

स्टार्टर, फ़्लो शुरू करता है. वहीं, स्टेप, टास्क के क्रम में मौजूद एक टास्क होता है. टास्क का यह क्रम, फ़्लो में शामिल होता है. स्टार्टर बनाने से, उपयोगकर्ताओं को ऐसे ऑटोमेटेड फ़्लो सेट अप करने की सुविधा मिलती है जो आपके ऐप्लिकेशन या सेवा से रीयल-टाइम इवेंट पर प्रतिक्रिया देते हैं.

स्टार्टर बनाने के लिए, ऐड-ऑन की मेनिफ़ेस्ट फ़ाइल में स्टार्टर का एलान करना होता है. साथ ही, Google Apps Script में लाइफ़साइकल कॉलबैक लागू करने होते हैं. इसके अलावा, Google Workspace Studio API एंडपॉइंट पर पेलोड पोस्ट करके भी स्टार्टर को ट्रिगर किया जा सकता है.

ज़रूरी शर्तें और OAuth की अनुमति

Workspace Studio API एंडपॉइंट से कम्यूनिकेट करने के लिए, आपके ऐप्लिकेशन या सेवा को OAuth 2.0 का इस्तेमाल करके पुष्टि करनी होगी. अनुमति देते समय, ऐप्लिकेशन को उपयोगकर्ताओं से OAuth के इस स्कोप का अनुरोध करना होगा:

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

इस स्कोप से ऐप्लिकेशन को Workspace Studio API को कॉल करने और उन फ़्लो को शुरू करने की अनुमति मिलती है जिन्हें उपयोगकर्ता ने उस स्टार्टर के लिए कॉन्फ़िगर किया है.

ऑफ़लाइन ऐक्सेस और रीफ़्रेश टोकन

स्टार्टर, बाहरी सेवा में कोई इवेंट होने पर Workspace Studio को एसिंक्रोनस तरीके से सूचना देते हैं. यह सूचना, उपयोगकर्ता के फ़्लो कॉन्फ़िगर करने के कुछ घंटों, दिनों या महीनों बाद मिल सकती है. इसलिए, एपीआई एंडपॉइंट को कॉल करते समय, आपकी सेवा को मान्य OAuth 2.0 ऐक्सेस टोकन देना होगा.

Google, ऐड-ऑन इवेंट ऑब्जेक्ट में ऐक्सेस टोकन उपलब्ध कराता है. जैसे, स्टार्टर कॉन्फ़िगरेशन या लाइफ़साइकल कॉलबैक अनुरोधों के दौरान. यह टोकन कम समय के लिए उपलब्ध होता है और सिर्फ़ एक घंटे के लिए मान्य होता है. यह आने वाले समय में, स्टार्टर इवेंट को एसिंक्रोनस तरीके से ट्रिगर करने के लिए काफ़ी नहीं है. Workspace Studio API को समय-समय पर कॉल करने के लिए, आपकी सेवा को ऑफ़लाइन रीफ़्रेश टोकन की ज़रूरत होती है. इससे, मांग पर नए ऐक्सेस टोकन जनरेट किए जा सकते हैं.

अनुमति को मैनेज करने और रीफ़्रेश टोकन पाने का तरीका, आपके ऐड-ऑन के रनटाइम पर निर्भर करता है:

  • एचटीटीपी ऐड-ऑन (वैकल्पिक रनटाइम): एचटीटीपी ऐड-ऑन के लिए, आपकी बैकएंड सेवा को एक अलग OAuth 2.0 ऑथराइज़ेशन फ़्लो लागू करना होगा. यह ऐड-ऑन के लिए, पहले से मौजूद ऑथराइज़ेशन से अलग होगा. इससे ऑफ़लाइन ऐक्सेस (access_type=offline) का अनुरोध किया जा सकेगा और रीफ़्रेश टोकन मिल पाएगा.

    उपयोगकर्ताओं को इस कनेक्शन को अनुमति देने के लिए कहा जा सकता है. इसके लिए, Workspace Studio में स्टार्टर को कॉन्फ़िगर करते समय, साइन इन करने या अनुमति देने वाला कार्ड दिखाएं. ऑथराइज़ेशन कार्ड वापस करने और OAuth फ़्लो को मैनेज करने के बारे में ज़्यादा जानने के लिए, अपने Google Workspace ऐड-ऑन को तीसरे पक्ष की सेवा से कनेक्ट करना लेख पढ़ें. इसमें Google Workspace को तीसरे पक्ष की सेवा के तौर पर माना गया है.

    आपकी बैकएंड सेवा को रीफ़्रेश टोकन को सुरक्षित तरीके से सेव करना होगा. उदाहरण के लिए, इसे अपनी सेवा के डेटाबेस में triggerId के साथ सेव करें. साथ ही, इसका इस्तेमाल नया ऐक्सेस टोकन पाने के लिए करें. ऐसा तब करें, जब कोई इवेंट notifyUri या triggers.fire एपीआई एंडपॉइंट को अनुरोध भेजने से पहले होता है.

  • Google Apps Script ऐड-ऑन: Google Apps Script पर आधारित ऐड-ऑन, इवेंट के लिए पोल करने के लिए शेड्यूल किए गए (समय के हिसाब से ट्रिगर होने वाले) ट्रिगर का इस्तेमाल करते हैं. ऐसे में, वे स्वतंत्र OAuth फ़्लो को लागू करने से बच सकते हैं. शेड्यूल किए गए ट्रिगर, Google Apps Script के रनटाइम एनवायरमेंट में सीधे तौर पर काम करते हैं. इसलिए, Google Apps Script, मेनिफ़ेस्ट में बताए गए स्कोप का इस्तेमाल करके, OAuth टोकन को अपने-आप मैनेज और रीफ़्रेश करता है.

मेनिफ़ेस्ट फ़ाइल में स्टार्टर तय करना

स्टार्टर तय करने के लिए, उसे अपने ऐड-ऑन की मेनिफ़ेस्ट फ़ाइल (appsscript.json) में addOns.studio.flows.workflowElements ब्लॉक के अंदर जोड़ें. यह कॉन्फ़िगरेशन, Apps Script और एचटीटीपी रनटाइम (वैकल्पिक रनटाइम), दोनों के लिए ज़रूरी है. एलिमेंट को workflowAction के बजाय workflowTrigger के तौर पर कॉन्फ़िगर करें. workflowAction का इस्तेमाल तब किया जाता है, जब किसी चरण को तय किया जाता है. ज़्यादा जानकारी के लिए, Google Workspace ऐड-ऑन के लिए मेनिफ़ेस्ट का स्ट्रक्चर लेख पढ़ें.

workflowTrigger ब्लॉक में, यह जानकारी दें:

  • inputs: वे वैरिएबल जिन्हें उपयोगकर्ता कॉन्फ़िगरेशन कार्ड पर कॉन्फ़िगर करता है. जैसे, प्रोजेक्ट का नाम, संसाधन फ़िल्टर वगैरह.
  • outputs: ये ऐसे वैरिएबल होते हैं जिन्हें फ़्लो में शामिल शुरुआती चरण से बाद के चरणों में भेजा जा सकता है.
  • onConfigFunction: यह उस कॉलबैक फ़ंक्शन का नाम है जो उपयोगकर्ता को कॉन्फ़िगरेशन इंटरफ़ेस दिखाता है.
  • onManageFunction: यह उस कॉलबैक फ़ंक्शन का नाम है जिसे Google, स्टार्टर सदस्यता बनाने और मिटाने के लिए इस्तेमाल करता है.

यहां दिए गए कोड सैंपल में, इवेंट स्टार्टर के लिए मेनिफ़ेस्ट की परिभाषा का उदाहरण दिखाया गया है:

JSON

{
  "timeZone": "America/Los_Angeles",
  "exceptionLogging": "STACKDRIVER",
  "runtimeVersion": "V8",
  "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"
            }
          }
        ]
      }
    }
  }
}

स्टार्टर सदस्यता के लाइफ़साइकल को मैनेज करना

जब कोई उपयोगकर्ता, आपके स्टार्टर वाला फ़्लो कॉन्फ़िगर करता है और उसे चालू करता है या जब फ़्लो बंद कर दिया जाता है या मिटा दिया जाता है, तब Google आपके ऐड-ऑन को कॉल करता है. इसके लिए, वह मेनिफ़ेस्ट में बताए गए onManageFunction कॉलबैक फ़ंक्शन का इस्तेमाल करता है.

लाइफ़साइकल इवेंट ऑब्जेक्ट

कॉलबैक फ़ंक्शन को WorkflowEventObject मिलता है, जिसमें कार्रवाई का कॉन्टेक्स्ट होता है. शुरुआत में, इसमें ये शामिल हैं:

  • ट्रिगर बनाना (event.workflow.triggerCreation): यह तब ट्रिगर होता है, जब फ़्लो पब्लिश किया जाता है या चालू किया जाता है.

    • triggerId: यह यूयूआईडी स्ट्रिंग, इस स्टार्टर रजिस्ट्रेशन इंस्टेंस की पहचान करती है.

    • notifyUri: यह यूनीक REST API एंडपॉइंट यूआरएल है, जो इस स्टार्टर रजिस्ट्रेशन से जुड़ा है. उदाहरण के लिए, https://workspacestudio.googleapis.com/v1/triggers/YOUR_TRIGGER_ID:fire.

    • inputs: कार्ड से उपयोगकर्ता के कॉन्फ़िगर किए गए वैरिएबल इनपुट.

  • ट्रिगर हटाना (event.workflow.triggerDeletion): यह तब ट्रिगर होता है, जब फ़्लो से स्टार्टर को हटा दिया जाता है या जब पूरे फ़्लो को बंद कर दिया जाता है या मिटा दिया जाता है.

    • triggerId: सदस्यता के उस इंस्टेंस की यूनीक यूयूआईडी स्ट्रिंग जिसे मिटाना है.

वैकल्पिक रनटाइम (एचटीटीपी एपीआई) की सदस्यता का लाइफ़साइकल

वैकल्पिक रनटाइम का इस्तेमाल करके बनाए गए ऐड-ऑन के लिए, सदस्यता के लाइफ़साइकल की सूचनाएं, ऐड-ऑन के कॉन्फ़िगर किए गए एचटीटीपी एंडपॉइंट यूआरएल पर एचटीटीपी पोस्ट अनुरोधों का इस्तेमाल करके भेजी जाती हैं. इसमें onManageFunction कॉलबैक फ़ंक्शन से तय किए गए ऐक्शन का नाम शामिल होता है. पेलोड, WorkflowEventObject के JSON फ़ॉर्मैट से मेल खाता है.

वैकल्पिक रनटाइम के बारे में ज़्यादा जानने के लिए, एचटीटीपी एंडपॉइंट का इस्तेमाल करके, Google Workspace का ऐड-ऑन बनाना लेख पढ़ें.

Apps Script में लाइफ़साइकल कॉलबैक लागू करना

Apps Script के इस उदाहरण में बताया गया है कि यूज़र इंटरफ़ेस कार्ड को कैसे कॉन्फ़िगर करें, onManageTrigger का इस्तेमाल करके सदस्यता के लाइफ़साइकल इवेंट को कैसे मैनेज करें, और जब कोई इवेंट होता है, तो Google को स्टार्टर अनुरोध वापस कैसे भेजें.

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;
    const notifyUri = triggerCreation.notifyUri;
    const inputs = triggerCreation.inputs;

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

    // 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;

    // 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
 *     (obtained using your stored refresh token).
 */
function simulateEventFire(notifyUri, triggerId, userAccessToken) {
  // 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 " + userAccessToken
    },
    "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 का इस्तेमाल करना

Workspace Studio API (workspacestudio.googleapis.com) का इस्तेमाल करके, Google को प्रोग्राम के हिसाब से स्टार्टर इवेंट की सूचना दी जा सकती है.

एंडपॉइंट, इस बेस पाथ के तहत मौजूद होते हैं: https://workspacestudio.googleapis.com/v1.

स्टार्टर इवेंट की सूचना देता है

यह triggers.fire तरीके का इस्तेमाल करके, स्टार्टर को ट्रिगर करता है. इससे फ़्लो का एक्ज़ीक्यूशन शुरू होता है.

  • एचटीटीपी का तरीका: POST
  • पाथ: /v1/triggers/{triggerId}:fire (यहाँ {triggerId}, ट्रिगर की सदस्यता बनाते समय मिला यूनीक आइडेंटिफ़ायर है)
  • OAuth स्कोप: https://www.googleapis.com/auth/workspace.studio.trigger

यहां दिए गए कोड सैंपल में, अनुरोध में स्टार्टर को ट्रिगर करने का तरीका बताया गया है.

अनुरोध

{
  "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 (स्ट्रिंग, ज़रूरी है): स्टार्टर का संसाधन नाम, जिसे triggers/{triggerId} के तौर पर फ़ॉर्मैट किया गया है.
  • outputs (map, ज़रूरी नहीं): यह स्टार्टर आउटपुट वैरिएबल का मैप है. यह इवेंट डेटा को दिखाता है. हर वैल्यू एक VariableData ऑब्जेक्ट होती है. यह टाइप की गई सूचियों के साथ काम करता है. जैसे, stringValues, booleanValues, integerValues.
  • log (object, optional): यह TextFormat मार्कअप का ऐसा ऑब्जेक्ट होता है जिसे Workspace Studio की गतिविधि के लॉग में दिखाया जाता है.
  • requestId (स्ट्रिंग, ज़रूरी नहीं): यह एक यूनीक आइडेंटिफ़ायर है. इसमें ज़्यादा से ज़्यादा 36 ASCII वर्ण हो सकते हैं. इससे यह पक्का किया जाता है कि फिर से कोशिश करने पर, एपीआई एक ही नतीजा दे. यूयूआईडी v4 का इस्तेमाल करने का सुझाव दिया जाता है.

जवाब

अनुरोध पूरा होने पर, जवाब के तौर पर खाली JSON ऑब्जेक्ट {} दिखता है.

Workspace Studio API के कोटे

workspacestudio.googleapis.com सेवा को भेजे जाने वाले ट्रैफ़िक को सीमित किया जाता है, ताकि सिस्टम पर ज़्यादा लोड न पड़े, संसाधनों का सही इस्तेमाल हो, और Google Workspace की परफ़ॉर्मेंस को सुरक्षित रखा जा सके.

ये कोटा लागू किए जाते हैं:

कोटा टाइप कोटा
हर प्रोजेक्ट के लिए, हर मिनट में किए जा सकने वाले अनुरोधों की संख्या शुरुआती तौर पर 1,000 अनुरोध
हर उपयोगकर्ता के लिए, हर मिनट में किए जा सकने वाले अनुरोधों की संख्या शुरुआती 100 अनुरोध

कोटा के टाइप ये हैं:

  • हर प्रोजेक्ट के लिए हर मिनट में: यह सीमा, किसी डेवलपर के Google Cloud प्रोजेक्ट से ट्रिगर किए गए स्टार्टर इवेंट की कुल संख्या पर लागू होती है. इसके तहत, स्टार्टर इवेंट ट्रिगर करने वाले सभी उपयोगकर्ताओं के लिए, हर मिनट में 1,000 अनुरोध किए जा सकते हैं.
  • हर उपयोगकर्ता के लिए, हर मिनट: यह सीमा, किसी भी एक असली उपयोगकर्ता के लिए है. इसके तहत, किसी दिए गए क्लाउड प्रोजेक्ट में, हर मिनट में 100 से ज़्यादा स्टार्टर शुरू करने के अनुरोध नहीं किए जा सकते.

समय के हिसाब से तय किए गए कोटे से जुड़ी गड़बड़ियों को ठीक करना

अगर इन कोटा की सीमाएं पार कर ली जाती हैं, तो एपीआई, एचटीटीपी 429 Too Many Requests (या 429 Resource Exhausted) गड़बड़ी कोड दिखाता है. इससे पता चलता है कि दर कोटा की सीमा पार कर ली गई है.

इन गड़बड़ियों को ठीक करने के लिए, आपके कोड को अपवाद का पता लगाना चाहिए. साथ ही, उसे ट्रंकेटेड एक्सपोनेंशियल बैकऑफ़ रणनीति का इस्तेमाल करना चाहिए. एक्सपोनेंशियल बैकऑफ़ की मदद से अनुरोधों को फिर से भेजने की कोशिश नहीं की जा सकी. इसमें अनुरोधों को फिर से भेजने के लिए, हर बार ज़्यादा समय लगता है. इसमें रैंडमाइज़्ड जिटर (हर बार रैंडमाइज़्ड समय की फिर से गिनती करना) भी शामिल है, ताकि कई क्लाइंट एक साथ सिंक न हो पाएं और एक ही समय पर अनुरोधों को फिर से न भेज पाएं:

  1. Workspace Studio API से अनुरोध करें.
  2. अगर अनुरोध पूरा नहीं होता है और 429 गड़बड़ी का मैसेज दिखता है, तो 1 second + random_number_milliseconds तक इंतज़ार करें और फिर से कोशिश करें.
  3. अगर पुष्टि फिर से नहीं होती है, तो 2 seconds + random_number_milliseconds इंतज़ार करें और फिर से कोशिश करें.
  4. अगर पुष्टि फिर से नहीं होती है, तो 4 seconds + random_number_milliseconds इंतज़ार करें और फिर से कोशिश करें.
  5. इस लूप को जारी रखें. इसमें हर बार, देरी को दोगुना करें. ऐसा तब तक करें, जब तक कि देरी maximum_backoff थ्रेशोल्ड (आम तौर पर 32 या 64 सेकंड) तक न पहुंच जाए.
  6. बैकऑफ़ की ज़्यादा से ज़्यादा अवधि पूरी होने के बाद, तय समय के लिए इंतज़ार करने की सुविधा का इस्तेमाल करके फिर से कोशिश करें. ऐसा तब तक करें, जब तक फिर से कोशिश करने की ज़्यादा से ज़्यादा सीमा पूरी न हो जाए. इसके बाद, प्रोसेस रोक दें और गड़बड़ी को लॉग करें.

सबसे सही तरीके

स्टार्टर को डिज़ाइन और लागू करते समय, इन सबसे सही तरीकों को ध्यान में रखें:

बैच सूचियों के बजाय, एक-एक इवेंट भेजना

अपने स्टार्टर को इस तरह से डिज़ाइन करें कि वह हर अलग इवेंट के लिए एक इवेंट जनरेट करे. जैसे, अपडेट किया गया एक रिकॉर्ड, पोस्ट किया गया नया मैसेज या असाइन किया गया टास्क. इसके बजाय, वह एक ऐसा इवेंट जनरेट करे जिसमें आइटम का बैच या सूची शामिल हो:

  • पहले से मौजूद स्टार्टर के साथ काम करना: Workspace Studio में, Google Workspace के पहले से मौजूद स्टार्टर (जैसे, Gmail में ईमेल पाना या Google Chat में किसी उपयोगकर्ता का स्पेस में शामिल होना) एक ही इवेंट पर ट्रिगर होते हैं. एक आइटम वाले इवेंट भेजने से, इस व्यवहार के साथ-साथ सभी स्टार्टर के उपयोगकर्ताओं को एक जैसा और अनुमानित अनुभव मिलता है.
  • फ़्लो को आसानी से कॉन्फ़िगर करना: फ़्लो में डाउनस्ट्रीम के चरण, आम तौर पर एक बार में एक आइटम प्रोसेस करते हैं. सिंगल-आइटम इवेंट को भेजने से, उपयोगकर्ता सीधे तौर पर वैरिएबल को मैप कर सकते हैं. इसके लिए, उन्हें ऐरे को दोहराने या सूचियों को पार्स करने के लिए मुश्किल चरणों को जोड़ने की ज़रूरत नहीं होती.
  • पोलिंग और बैच में किए गए बदलावों को अलग-अलग तरीके से हैंडल करें: अगर आपकी बैकएंड सेवा, किसी बाहरी एपीआई को पोल करती है और पोलिंग के एक इंटरवल के दौरान कई बदले हुए आइटम का पता लगाती है, तो उन्हें एक बैच इवेंट में बंडल करने के बजाय, हर आइटम के लिए अलग-अलग स्टार्टर इवेंट ट्रिगर करें.
  • इवेंट की दर और कोटा मैनेज करें: कई बदले गए आइटम के लिए अलग-अलग इवेंट ट्रिगर करने से, अनुरोधों की संख्या में अचानक बढ़ोतरी हो सकती है. इसलिए, पक्का करें कि आपकी सेवा, Workspace Studio API के कोटा के दायरे में हो. जैसे, हर उपयोगकर्ता के लिए हर मिनट में 100 अनुरोधों की सीमा. अगर किसी पोलिंग साइकल में बड़ी संख्या में आइटम मिलते हैं (उदाहरण के लिए, 100 से ज़्यादा बदले गए रिकॉर्ड), तो समय के साथ इवेंट डिसपैच की गति को कम करें या थ्रॉटल करें, ताकि 429 Too Many Requests गड़बड़ियों से बचा जा सके.

मुख्य व्यवहार और कभी-कभी होने वाले मामले

स्टार्टर को इंटिग्रेट करते समय, डेवलपर को गड़बड़ी से जुड़ी कुछ खास स्थितियों और रनटाइम सुविधाओं को मैनेज करना होगा:

  • टेस्ट रन की सुविधा उपलब्ध नहीं है: Workspace Studio के स्टार्टर वर्शन में, टेस्ट रन की सुविधा उपलब्ध नहीं है.
  • आईडेंपोटेंसी और रीप्ले से बचाव: हालांकि, यह ज़रूरी नहीं है, लेकिन आपको अपने एचटीटीपी या Apps Script के पेलोड में एक यूनीक requestId (जैसे, यूयूआईडी) शामिल करना चाहिए. requestId उपलब्ध कराने से, बार-बार एक ही डेटा भेजे जाने पर सिस्टम उसकी पहचान समान वर्शन के तौर पर करता है और डेटा में कोई बदलाव नहीं करता. इससे, एपीआई को डुप्लीकेट सूचनाओं का पता लगाने और उन्हें अनदेखा करने की अनुमति मिलती है. साथ ही, एक ही इवेंट के लिए फ़्लो को कई बार चलने से रोका जा सकता है.

  • बंद किए गए और फिर से चालू किए गए फ़्लो: जब Workspace Studio में, आपके स्टार्टर वाला कोई फ़्लो बंद कर दिया जाता है, तो Google आपके onManageFunction कॉलबैक को triggerDeletion लाइफ़साइकल इवेंट भेजता है. इसके अलावा, इससे जुड़े FireTrigger तरीके को कॉल करने पर, 404 Not Found गड़बड़ी का रिटर्न कोड (Requested entity was not found.) मिलता है. आपकी सेवा को 404 गड़बड़ियों पर प्रतिक्रिया देनी चाहिए. इसके लिए, उसे स्टार्टर इंस्टेंस आईडी के लिए, आने वाले समय में इवेंट की सूचनाएं भेजना बंद कर देना चाहिए.

    अगर कोई उपयोगकर्ता बाद में फ़्लो को फिर से चालू करता है, तो Google सदस्यता के नए लाइफ़साइकल को शुरू करता है. इसके लिए, वह आपके onManageFunction कॉलबैक को एक नए triggerCreation इवेंट के साथ शुरू करता है. इस इवेंट में एक नया triggerId और notifyUri होता है. पिछला triggerId हमेशा के लिए बंद कर दिया गया है और इसे फिर से चालू नहीं किया जा सकता. इसलिए, आपकी सेवा को यह पोल या जांच नहीं करनी चाहिए कि क्या पुराने ट्रिगर इंस्टेंस को फिर से चालू किया गया है. ज़्यादा जानकारी के लिए, स्टार्टर सदस्यता का लाइफ़साइकल मैनेज करना लेख पढ़ें.

  • सदस्यता को एक बार हटाने का अनुरोध: आपका onManageFunction कॉलबैक फ़ंक्शन, Google से मिले सदस्यता हटाने के अनुरोधों को एक बार में हैंडल कर सकता हो. अगर Google, एक ही triggerId के लिए मिटाने वाले हुक को कई बार कॉल करता है (उदाहरण के लिए, कनेक्शन के कुछ समय के लिए बंद होने की वजह से फिर से कोशिश करने के दौरान), तो फ़ंक्शन को सही तरीके से काम करना चाहिए.

  • फ़्लो कोटा: Workspace Studio API के कोटे के अलावा, उपयोगकर्ता फ़्लो पर अतिरिक्त इंटरनल कोटा कंट्रोल लागू होते हैं. ज़्यादा फ़्रीक्वेंसी वाले लूप या इवेंट की संख्या ज़्यादा होने पर, सुरक्षा थ्रेशोल्ड से ज़्यादा हो सकता है. इससे फ़्लो अपने-आप बंद हो जाता है.