ऑराबेस लोगो
aurabaseडॉक्स
डॉक्स›Edge Functions›How an invocation works

आह्वान कैसे काम करता है

सीमाओं, त्रुटि कोड और आपके द्वारा देखे गए समय को समझाने के लिए एक कॉल के माध्यम से चलें।

8 मि॰ पढ़ें·स्तर विकसित·12 अक्टू॰ 2026 पर संशोधित
यह अंग्रेजी पाठ फ़्रेंच मूल से स्वचालित रूप से उत्पन्न हुआ था और अभी तक इसकी समीक्षा नहीं की गई है।
यह पृष्ठ स्वचालित रूप से अनुवादित किया गया था. अंग्रेजी संस्करण प्रामाणिक है.
#
पथ

1. कॉल का पथ

एक आह्वानtext
your code ── invoke('hello') ──▶ gateway (data plane)
                                   • checks the key and the user's token
                                   • finds the project from the host
                                   • adds x-aura-role, x-aura-user-id, x-aura-project-id
                                   │  message bus (request / reply)
                                   ▼
                           functions service
                                   • access policy: only invoke is public
                                   • reads the function, reserves one invocation of the plan quota
                                   │  HTTP
                                   ▼
                            edge runtime
                                   • loads code, limits and variables
                                   • starts an isolated V8 worker
                                   • rebuilds the request you described
                                   ▼
                             your function ── Response ──▶ back along the same path

गेटवे और फ़ंक्शन सेवा एक संदेश बस पर बात करते हैं। उस बस में एक संदेश की आकार सीमा होती है, यही कारण है कि लगभग 256 KiB से ऊपर का अनुरोध या प्रतिक्रिया नहीं होती है: सीमाएँ देखें।

#
क्रम

2. रनटाइम के अंदर

  • प्रति कॉल एक कर्मचारी। एज रनटाइम प्रत्येक इनवोकेशन के लिए मेमोरी सीमा और फ़ंक्शन के टाइमआउट के साथ एक नया पृथक V8 वर्कर शुरू करता है। एक कॉल से दूसरे कॉल तक मेमोरी में कुछ भी नहीं बचता: स्थिति को एक वेरिएबल में न रखें। अपने डेटाबेस या संग्रहण का उपयोग करें.
  • कोड कुछ सेकंड के लिए कैश हो जाता है। रनटाइम किसी फ़ंक्शन के कोड और सीमाओं को 5 सेकंड तक रखता है और जब आप तैनात करते हैं तो उन्हें हटा देता है। प्रत्येक कॉल पर वेरिएबल पढ़े जाते हैं.
  • आपका अनुरोध फिर से बनाया गया है। रनटाइम आपके द्वारा वर्णित अनुरोध बनाता है (method, path, headers, body) और इसे आपके Deno.serve हैंडलर को सौंप देता है। इसलिए एक फ़ंक्शन किसी भी HTTP सर्वर की तरह व्यवहार करता है।
  • रनटाइम टाइमआउट लागू करता है। जब timeout_secs समाप्त हो जाता है, तो यह कार्यकर्ता को रद्द कर देता है; उस देरी के बाद कॉल करने वाले को एक त्रुटि दिखाई देती है।
  • WASM फ़ंक्शन मेमोरी, समय और निर्देशों की सीमा के साथ, सेवा के अंदर ही चलते हैं। एक WASM फ़ंक्शन लॉग लाइनों की रिपोर्ट कर सकता है, जो प्रतिक्रिया के logs फ़ील्ड में दिखाई देती हैं; एक Deno फ़ंक्शन नहीं कर सकता.
#
जवाब

3. लिफाफा और कच्चा मोड

सेवा के पास आपके फ़ंक्शन का उत्तर लौटाने के दो तरीके हैं, जिन्हें X-Aurabase-Invoke-Mode अनुरोध शीर्षलेख द्वारा चुना गया है।

लिफ़ाफ़ा (डिफ़ॉल्ट)कच्चा (raw)
HTTP स्थितिहमेशा 200फ़ंक्शन की अपनी स्थिति
शरीर{ data: { status, headers, body, logs, duration_ms }, meta }फ़ंक्शन के बाइट्स
सामग्रीJSON या UTF-8 टेक्स्टबाइनरी सहित कुछ भी
द्वारा उपयोग किया जाता हैresponseType: 'json', स्टूडियो'text', 'blob', 'arrayBuffer', प्रत्यक्ष HTTP

लिफाफा मौजूद है ताकि एक JSON प्रतिक्रिया कॉल की स्थिति, हेडर और अवधि बता सके। इसकी सीमा यह है कि बाइट्स JSON में यात्रा नहीं कर सकते: यही कारण है कि बाइनरी प्रतिक्रिया को कच्चे मोड की आवश्यकता होती है। SDK responseType से मोड चुनता है।

रॉ मोड में सेवा आपके फ़ंक्शन के उत्तरों में x-aurabase-invoke-origin: function जोड़ती है। एक त्रुटि जो गेटवे या रनटाइम से आती है, वह नहीं होती है। इस प्रकार SDK FunctionsHttpError (आपके फ़ंक्शन का उत्तर दिया गया) को FunctionsRelayError (प्लेटफ़ॉर्म विफल) से अलग करता है।

#
समय

4. समय, पैमाइश और विफलताएँ

तीन टाइमआउट नेस्ट किए गए हैं ताकि कोई भी इसके अंदर वाले से पहले समाप्त न हो:

टाइमआउट, बाहर से अंदर तकtext
gateway 380 s  ⊃  message bus 370 s  ⊃  function timeout_secs (≤ 300 s) + margin

सेवा timeout_secs प्लस मार्जिन के लिए रनटाइम की प्रतीक्षा करती है। क्योंकि रनटाइम timeout_secs पर वर्कर को रद्द कर देता है, आप आम तौर पर उस समय फ़ंक्शन से एक त्रुटि देखते हैं, और 504 TIMEOUT केवल तभी देखते हैं जब रनटाइम स्वयं उत्तर देना बंद कर देता है। इसलिए 504 का अर्थ है कि फ़ंक्शन प्रारंभ किया गया था और इसका प्रभाव हो सकता है: किसी गैर-निष्क्रिय कॉल को आँख बंद करके न दोहराएं।

पैमाइश और कोटा:

  1. कॉल से पहले, सेवा योजना कोटा से एक आमंत्रण आरक्षित रखती है। यदि कोटा समाप्त हो जाता है, तो कॉल 403 के साथ यहीं रुक जाती है।
  2. कॉल के बाद, यह आह्वान और उसकी अवधि को मिलीसेकंड में रिकॉर्ड करता है।
  3. यदि आपके फ़ंक्शन का उत्तर देने से पहले कॉल विफल हो जाती है, तो आरक्षण जारी कर दिया जाता है और कुछ भी नहीं गिना जाता है।
#
नतीजे

5. आपके कोड का अनुसरण क्या है

  • प्रत्येक कॉल को छोटा और स्टेटलेस रखें। लंबे समय तक काम करने के लिए, एक नौकरी कतार में रखें।
  • अनुरोध और प्रतिक्रियाएँ छोटी रखें; फ़ाइलों को स्टोरेज में रखें और एक संदर्भ पास करें।
  • कार्यों को निष्क्रिय बनाएं: एक पुन: प्रयास किया गया कार्य, एक नेटवर्क त्रुटि के बाद एक ग्राहक पुनः प्रयास या डुप्लिकेट क्रॉन डिलीवरी आपके कोड को दो बार चला सकता है।
  • प्लेटफ़ॉर्म के पहचान हेडर पर अधिकृत करें, क्योंकि ये एकमात्र मूल्य हैं जिन्हें कॉल करने वाला नहीं बना सकता है। सुरक्षा देखें।
  • अपनी खुद की विलंबता को मापें: प्रत्येक कॉल एक कार्यकर्ता की शुरुआत के लिए भुगतान करती है। एक न्यूनतम फ़ंक्शन ने स्थानीय स्टैक पर duration_ms: 74 की सूचना दी।