क्लाउड टास्क के साथ कतारबद्ध कार्य

कार्य कतार फ़ंक्शन आपके ऐप को आपके मुख्य एप्लिकेशन प्रवाह के बाहर, समय लेने वाली, संसाधन-गहन, या बैंडविड्थ-सीमित कार्यों को अतुल्यकालिक रूप से चलाने में मदद करने के लिए Google क्लाउड कार्य का लाभ उठाते हैं।

उदाहरण के लिए, कल्पना करें कि आप छवि फ़ाइलों के एक बड़े सेट का बैकअप बनाना चाहते हैं जो वर्तमान में एक दर सीमा के साथ एपीआई पर होस्ट किए गए हैं। उस एपीआई का एक जिम्मेदार उपभोक्ता बनने के लिए, आपको उनकी दर सीमाओं का सम्मान करना होगा। साथ ही, इस तरह का लंबे समय तक चलने वाला काम टाइमआउट और मेमोरी सीमाओं के कारण विफलता की चपेट में आ सकता है।

इस जटिलता को कम करने के लिए, आप एक कार्य कतार फ़ंक्शन लिख सकते हैं जो scheduleTime और dispatchDeadline जैसे बुनियादी कार्य विकल्प सेट करता है, और फिर फ़ंक्शन को क्लाउड टास्क में एक कतार में सौंप देता है। क्लाउड टास्क वातावरण विशेष रूप से इस प्रकार के संचालन के लिए प्रभावी भीड़ नियंत्रण और पुनः प्रयास नीतियों को सुनिश्चित करने के लिए डिज़ाइन किया गया है।

फायरबेस v3.20.1 और उच्चतर के लिए क्लाउड फ़ंक्शंस के लिए फायरबेस एसडीके, कार्य कतार कार्यों का समर्थन करने के लिए फायरबेस एडमिन एसडीके v10.2.0 और उच्चतर के साथ इंटरऑपरेट करता है।

फायरबेस के साथ कार्य कतार फ़ंक्शन का उपयोग करने से क्लाउड कार्य प्रसंस्करण के लिए शुल्क लग सकता है। अधिक जानकारी के लिए क्लाउड टास्क मूल्य निर्धारण देखें।

कार्य कतार फ़ंक्शन बनाएं

कार्य कतार फ़ंक्शंस का उपयोग करने के लिए, इस वर्कफ़्लो का पालन करें:

1. क्लाउड फ़ंक्शंस के लिए फायरबेस एसडीके का उपयोग करके एक कार्य कतार फ़ंक्शन लिखें।
2. HTTP अनुरोध के साथ ट्रिगर करके अपने फ़ंक्शन का परीक्षण करें।
3. अपने फ़ंक्शन को फायरबेस सीएलआई के साथ परिनियोजित करें। पहली बार आपके कार्य कतार फ़ंक्शन को तैनात करते समय, सीएलआई आपके स्रोत कोड में निर्दिष्ट विकल्पों (दर सीमित करना और पुनः प्रयास करना) के साथ क्लाउड कार्यों में एक कार्य कतार बनाएगा।
4. यदि आवश्यक हो तो निष्पादन शेड्यूल सेट करने के लिए मापदंडों के साथ गुजरते हुए, नव निर्मित कार्य कतार में कार्य जोड़ें। आप एडमिन एसडीके का उपयोग करके कोड लिखकर और इसे फायरबेस के लिए क्लाउड फ़ंक्शंस पर तैनात करके इसे प्राप्त कर सकते हैं।

कार्य कतार फ़ंक्शन लिखें

इस अनुभाग में कोड नमूने एक ऐप पर आधारित हैं जो एक ऐसी सेवा स्थापित करता है जो नासा के दिन के खगोल विज्ञान चित्र से सभी छवियों का बैकअप लेती है। आरंभ करने के लिए, आवश्यक मॉड्यूल आयात करें:

// Dependencies for task queue functions.
const {onTaskDispatched} = require("firebase-functions/v2/tasks");
const {onRequest, HttpsError} = require("firebase-functions/v2/https");
const {getFunctions} = require("firebase-admin/functions");
const {logger} = require("firebase-functions/v2");

// Dependencies for image backup.
const path = require("path");
const fetch = require("node-fetch");
const {initializeApp} = require("firebase-admin/app");
const {getStorage} = require("firebase-admin/storage");
const {GoogleAuth} = require("google-auth-library");
index.js

# Dependencies for task queue functions.
from google.cloud import tasks_v2
import requests
from firebase_functions.options import RetryConfig, RateLimits, SupportedRegion

# Dependencies for image backup.
from datetime import datetime, timedelta
import json
import pathlib
from urllib.parse import urlparse
from firebase_admin import initialize_app, storage, functions
from firebase_functions import https_fn, tasks_fn, params
import google.auth
from google.auth.transport.requests import AuthorizedSession
main.py

कार्य कतार फ़ंक्शन के लिए onTaskDispatched या on_task_dispatched का उपयोग करें। कार्य कतार फ़ंक्शन लिखते समय आप प्रति-कतार पुनः प्रयास और दर-सीमित कॉन्फ़िगरेशन सेट कर सकते हैं।

कार्य कतार फ़ंक्शन कॉन्फ़िगर करें

कार्य कतार फ़ंक्शन दर सीमा को सटीक रूप से नियंत्रित करने और कार्य कतार के व्यवहार को पुनः प्रयास करने के लिए कॉन्फ़िगरेशन सेटिंग्स के एक शक्तिशाली सेट के साथ आते हैं:

exports.backupapod = onTaskDispatched(
    {
      retryConfig: {
        maxAttempts: 5,
        minBackoffSeconds: 60,
      },
      rateLimits: {
        maxConcurrentDispatches: 6,
      },
    }, async (req) => {
index.js

@tasks_fn.on_task_dispatched(retry_config=RetryConfig(max_attempts=5, min_backoff_seconds=60),
                             rate_limits=RateLimits(max_concurrent_dispatches=10))
def backupapod(req: tasks_fn.CallableRequest) -> str:
    """Grabs Astronomy Photo of the Day (APOD) using NASA's API."""
main.py

• retryConfig.maxAttempts=5 : कार्य कतार में प्रत्येक कार्य स्वचालित रूप से 5 बार तक पुनः प्रयास किया जाता है। यह नेटवर्क त्रुटियों या किसी आश्रित, बाहरी सेवा की अस्थायी सेवा व्यवधान जैसी क्षणिक त्रुटियों को कम करने में मदद करता है।

• retryConfig.minBackoffSeconds=60 : प्रत्येक कार्य को प्रत्येक प्रयास के बाद कम से कम 60 सेकंड के अंतराल पर पुनः प्रयास किया जाता है। यह प्रत्येक प्रयास के बीच एक बड़ा बफर प्रदान करता है ताकि हम 5 पुनः प्रयास प्रयासों को जल्दी समाप्त करने में जल्दबाजी न करें।

• rateLimits.maxConcurrentDispatch=6 : एक निश्चित समय में अधिकतम 6 कार्य भेजे जाते हैं। यह अंतर्निहित फ़ंक्शन के लिए अनुरोधों की एक स्थिर धारा सुनिश्चित करने में मदद करता है और सक्रिय उदाहरणों और कोल्ड स्टार्ट की संख्या को कम करने में मदद करता है।

कार्य कतार फ़ंक्शन का परीक्षण करें

फायरबेस लोकल एमुलेटर सुइट में टास्क कतार फ़ंक्शन सरल HTTP फ़ंक्शन के रूप में प्रदर्शित होते हैं। आप JSON डेटा पेलोड के साथ HTTP POST अनुरोध भेजकर एक अनुकरणीय कार्य फ़ंक्शन का परीक्षण कर सकते हैं:

 # start the Local Emulator Suite
 firebase emulators:start

 # trigger the emulated task queue function
 curl \
  -X POST                                            # An HTTP POST request...
  -H "content-type: application/json" \              # ... with a JSON body
  http://localhost:$PORT/$PROJECT_ID/$REGION/$NAME \ # ... to function url
  -d '{"data": { ... some data .... }}'              # ... with JSON encoded data

कार्य कतार फ़ंक्शन परिनियोजित करें

फायरबेस सीएलआई का उपयोग करके कार्य कतार फ़ंक्शन को तैनात करें:

$ firebase deploy --only functions:backupapod

पहली बार किसी कार्य कतार फ़ंक्शन को तैनात करते समय, सीएलआई आपके स्रोत कोड में निर्दिष्ट विकल्पों (दर सीमित करना और पुनः प्रयास करना) के साथ क्लाउड कार्यों में एक कार्य कतार बनाता है।

यदि आप फ़ंक्शंस को तैनात करते समय अनुमति त्रुटियों का सामना करते हैं, तो सुनिश्चित करें कि परिनियोजन आदेश चलाने वाले उपयोगकर्ता को उचित IAM भूमिकाएँ सौंपी गई हैं।

कार्य कतार कार्यों को सूचीबद्ध करें

कार्य कतार कार्यों को किसी विश्वसनीय सर्वर वातावरण से क्लाउड कार्यों में सूचीबद्ध किया जा सकता है जैसे कि Node.js के लिए फायरबेस एडमिन एसडीके या पायथन के लिए Google क्लाउड लाइब्रेरी का उपयोग करके फायरबेस के लिए क्लाउड फ़ंक्शंस। यदि आप एडमिन एसडीके में नए हैं, तो आरंभ करने के लिए सर्वर में फायरबेस जोड़ें देखें।

एक विशिष्ट प्रवाह एक नया कार्य बनाता है, इसे क्लाउड कार्यों में सूचीबद्ध करता है, और कार्य के लिए कॉन्फ़िगरेशन सेट करता है:

exports.enqueuebackuptasks = onRequest(
    async (_request, response) => {
      const queue = getFunctions().taskQueue("backupapod");
      const targetUri = await getFunctionUrl("backupapod");

      const enqueues = [];
      for (let i = 0; i <= BACKUP_COUNT; i += 1) {
        const iteration = Math.floor(i / HOURLY_BATCH_SIZE);
        // Delay each batch by N * hour
        const scheduleDelaySeconds = iteration * (60 * 60);

        const backupDate = new Date(BACKUP_START_DATE);
        backupDate.setDate(BACKUP_START_DATE.getDate() + i);
        // Extract just the date portion (YYYY-MM-DD) as string.
        const date = backupDate.toISOString().substring(0, 10);
        enqueues.push(
            queue.enqueue({date}, {
              scheduleDelaySeconds,
              dispatchDeadlineSeconds: 60 * 5, // 5 minutes
              uri: targetUri,
            }),
        );
      }
      await Promise.all(enqueues);
      response.sendStatus(200);
    });
index.js

@https_fn.on_request()
def enqueuebackuptasks(_: https_fn.Request) -> https_fn.Response:
    """Adds backup tasks to a Cloud Tasks queue."""
    task_queue = functions.task_queue("backupapod")
    target_uri = get_function_url("backupapod")

    for i in range(BACKUP_COUNT):
        batch = i // HOURLY_BATCH_SIZE

        # Delay each batch by N hours
        schedule_delay = timedelta(hours=batch)
        schedule_time = datetime.now() + schedule_delay

        dispatch_deadline_seconds = 60 * 5  # 5 minutes

        backup_date = BACKUP_START_DATE + timedelta(days=i)
        body = {"data": {"date": backup_date.isoformat()[:10]}}
        task_options = functions.TaskOptions(schedule_time=schedule_time,
                                             dispatch_deadline_seconds=dispatch_deadline_seconds,
                                             uri=target_uri)
        task_queue.enqueue(body, task_options)
    return https_fn.Response(status=200, response=f"Enqueued {BACKUP_COUNT} tasks")
main.py

• नमूना कोड Nवें कार्य के लिए Nवें मिनट की देरी को जोड़कर कार्यों के निष्पादन को फैलाने का प्रयास करता है। इसका मतलब ~ 1 कार्य/मिनट ट्रिगर करना है। ध्यान दें कि यदि आप चाहते हैं कि क्लाउड टास्क किसी विशिष्ट समय पर किसी कार्य को ट्रिगर करे तो आप scheduleTime (नोड.जेएस) या schedule_time (पायथन) का भी उपयोग कर सकते हैं।

• नमूना कोड यह निर्धारित करता है कि क्लाउड कार्य किसी कार्य के पूरा होने के लिए कितना समय प्रतीक्षा करेगा। क्लाउड कार्य कतार के पुनः प्रयास कॉन्फ़िगरेशन के बाद या इस समय सीमा तक पहुंचने तक कार्य का पुनः प्रयास करेगा। नमूने में, कतार को कार्य को 5 बार तक पुनः प्रयास करने के लिए कॉन्फ़िगर किया गया है, लेकिन यदि पूरी प्रक्रिया (पुनः प्रयास प्रयासों सहित) में 5 मिनट से अधिक समय लगता है तो कार्य स्वचालित रूप से रद्द हो जाता है।

लक्ष्य यूआरआई पुनर्प्राप्त करें और शामिल करें

जिस तरह से क्लाउड टास्क अंतर्निहित कार्य कतार कार्यों के अनुरोधों को प्रमाणित करने के लिए प्रमाणीकरण टोकन बनाता है, आपको कार्यों को सूचीबद्ध करते समय फ़ंक्शन का क्लाउड रन यूआरएल निर्दिष्ट करना होगा। हम अनुशंसा करते हैं कि आप अपने फ़ंक्शन के लिए प्रोग्रामेटिक रूप से यूआरएल पुनः प्राप्त करें जैसा कि नीचे दिखाया गया है:

/**
 * Get the URL of a given v2 cloud function.
 *
 * @param {string} name the function's name
 * @param {string} location the function's location
 * @return {Promise<string>} The URL of the function
 */
async function getFunctionUrl(name, location="us-central1") {
  if (!auth) {
    auth = new GoogleAuth({
      scopes: "https://www.googleapis.com/auth/cloud-platform",
    });
  }
  const projectId = await auth.getProjectId();
  const url = "https://cloudfunctions.googleapis.com/v2beta/" +
    `projects/${projectId}/locations/${location}/functions/${name}`;

  const client = await auth.getClient();
  const res = await client.request({url});
  const uri = res.data?.serviceConfig?.uri;
  if (!uri) {
    throw new Error(`Unable to retreive uri for function at ${url}`);
  }
  return uri;
}
index.js

def get_function_url(name: str, location: str = SupportedRegion.US_CENTRAL1) -> str:
    """Get the URL of a given v2 cloud function.

    Params:
        name: the function's name
        location: the function's location

    Returns: The URL of the function
    """
    credentials, project_id = google.auth.default(
        scopes=["https://www.googleapis.com/auth/cloud-platform"])
    authed_session = AuthorizedSession(credentials)
    url = ("https://cloudfunctions.googleapis.com/v2beta/" +
           f"projects/{project_id}/locations/{location}/functions/{name}")
    response = authed_session.get(url)
    data = response.json()
    function_url = data["serviceConfig"]["uri"]
    return function_url
main.py

समस्या निवारण

क्लाउड कार्य लॉगिंग चालू करें

क्लाउड टास्क के लॉग में किसी कार्य से जुड़े अनुरोध की स्थिति जैसी उपयोगी नैदानिक ​​जानकारी होती है। डिफ़ॉल्ट रूप से, क्लाउड टास्क के लॉग बंद हो जाते हैं क्योंकि बड़ी मात्रा में लॉग संभावित रूप से आपके प्रोजेक्ट पर उत्पन्न हो सकते हैं। हम अनुशंसा करते हैं कि जब आप सक्रिय रूप से अपने कार्य कतार फ़ंक्शन को विकसित और डीबग कर रहे हों तो आप डिबग लॉग चालू करें। लॉगिंग चालू करना देखें।

आईएएम अनुमतियाँ

कार्यों को कतारबद्ध करते समय या जब क्लाउड कार्य आपके कार्य कतार कार्यों को लागू करने का प्रयास करते हैं तो आपको PERMISSION DENIED त्रुटियां दिखाई दे सकती हैं। सुनिश्चित करें कि आपके प्रोजेक्ट में निम्नलिखित IAM बाइंडिंग हैं:

• कार्यों को क्लाउड कार्यों में सूचीबद्ध करने के लिए उपयोग की जाने वाली पहचान के लिए cloudtasks.tasks.create IAM अनुमति की आवश्यकता होती है।

  नमूने में, यह ऐप इंजन डिफ़ॉल्ट सेवा खाता है

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member=serviceAccount:${PROJECT_ID}@appspot.gserviceaccount.com \
  --role=roles/cloudtasks.enqueuer

• क्लाउड कार्यों में कार्यों को सूचीबद्ध करने के लिए उपयोग की जाने वाली पहचान को क्लाउड कार्यों में किसी कार्य से जुड़े सेवा खाते का उपयोग करने की अनुमति की आवश्यकता होती है।

  नमूने में, यह ऐप इंजन डिफ़ॉल्ट सेवा खाता है।

ऐप इंजन डिफ़ॉल्ट सेवा खाते को ऐप इंजन डिफ़ॉल्ट सेवा खाते के उपयोगकर्ता के रूप में जोड़ने के निर्देशों के लिए Google क्लाउड IAM दस्तावेज़ देखें।

• कार्य कतार फ़ंक्शन को ट्रिगर करने के लिए उपयोग की जाने वाली पहचान को cloudfunctions.functions.invoke अनुमति की आवश्यकता होती है।

  नमूने में, यह ऐप इंजन डिफ़ॉल्ट सेवा खाता है

gcloud functions add-iam-policy-binding $FUNCTION_NAME \
  --region=us-central1 \
  --member=serviceAccount:${PROJECT_ID}@appspot.gserviceaccount.com \
  --role=roles/cloudfunctions.invoker