एचटीटीपी अनुरोधों के ज़रिए कॉल फ़ंक्शन

अनुरोध मैनेजर की मदद से, एचटीटीपी अनुरोध के ज़रिए फ़ंक्शन को ट्रिगर किया जा सकता है. इसकी मदद से, इन एचटीटीपी तरीकों का इस्तेमाल करके फ़ंक्शन को शुरू किया जा सकता है: GET, POST, PUT, DELETE, और OPTIONS.

एचटीटीपी के अन्य विकल्प

विकल्प	ब्यौरा
`region`	एचटीटीपी फ़ंक्शन, एक या एक से ज़्यादा इलाकों की जानकारी दे सकते हैं. एक से ज़्यादा क्षेत्रों की जानकारी देने पर, हर क्षेत्र के लिए एक अलग फ़ंक्शन इंस्टेंस डिप्लॉय किया जाएगा.
`timeoutSeconds` (Python के लिए `timeout_sec`)	एचटीटीपी फ़ंक्शन में, ज़्यादा से ज़्यादा एक घंटे का टाइम आउट तय किया जा सकता है.
`cors`	एचटीटीपी फ़ंक्शन में सीओआरएस नीतियां तय की जा सकती हैं. सभी ऑरिजिन को अनुमति देने के लिए, इसे `true` पर सेट किया जा सकता है. इसके अलावा, अनुमति वाले ऑरिजिन की जानकारी देने के लिए, `string`, `regex` या `array` पर सेट किया जा सकता है. अगर साफ़ तौर पर सेट नहीं किया जाता है, तो डिफ़ॉल्ट रूप से गलत/कोई सीओआरएस नीति नहीं होती.

सीओआरएस (क्रॉस-ऑरिजिन रिसॉर्स शेयरिंग) कॉन्फ़िगर करना

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

request has been blocked by CORS policy: No 'Access-Control-Allow-Origin' header is present on the requested resource.

अपने फ़ंक्शन के लिए, cors विकल्प को false पर सेट करके भी सीओआरएस को साफ़ तौर पर बंद किया जा सकता है.

कुछ क्रॉस-ऑरिजिन अनुरोधों को अनुमति देने के लिए, उन खास डोमेन या रेगुलर एक्सप्रेशन की सूची दी जा सकती है जिन्हें अनुमति दी जानी चाहिए. उदाहरण के लिए, अगर firebase.com और flutter.com डोमेन पर आपका मालिकाना हक है और firebase.com के कई सबडोमेन हो सकते हैं, तो हो सकता है कि आप Node.js के लिए cors विकल्प को [/firebase\.com$/, 'flutter.com'] या Python के लिए [r'firebase\.com$', r'https://flutter\.com'] पर सेट करना चाहें:

Node.js

const { onRequest } = require("firebase-functions/v2/https");

exports.sayHello = onRequest(
  { cors: [/firebase\.com$/, "flutter.com"] },
  (req, res) => {
    res.status(200).send("Hello world!");
  }
);

Python

from firebase_functions import https_fn, options

@https_fn.on_request(
    cors=options.CorsOptions(
        cors_origins=[r"firebase\.com$", r"https://flutter\.com"],
        cors_methods=["get", "post"],
    )
)
def say_hello(req: https_fn.Request) -> https_fn.Response:
    return https_fn.Response("Hello world!")

अगर आपका फ़ंक्शन सार्वजनिक तौर पर उपलब्ध होना चाहिए, जैसे कि अगर वह किसी सार्वजनिक एपीआई या वेबसाइट को दिखा रहा है, तो cors नीति को true पर सेट करें.

एचटीटीपी अनुरोध की मदद से फ़ंक्शन को ट्रिगर करना

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

अनुरोध और रिस्पॉन्स ऑब्जेक्ट का इस्तेमाल करना

अनुरोध ऑब्जेक्ट की मदद से, क्लाइंट से भेजे गए एचटीटीपी अनुरोध की प्रॉपर्टी को ऐक्सेस किया जा सकता है. साथ ही, रिस्पॉन्स ऑब्जेक्ट की मदद से, क्लाइंट को रिस्पॉन्स भेजा जा सकता है.

Node.js

exports.date = onRequest(
    {timeoutSeconds: 1200, region: ["us-west1", "us-east1"]},
    (req, res) => {
// ...
});

Python

@https_fn.on_request(cors=options.CorsOptions(cors_origins="*", cors_methods=["get", "post"]))
def date(req: https_fn.Request) -> https_fn.Response:
    """Get the server's local date and time."""main.py

मौजूदा Express या Flask ऐप्लिकेशन का इस्तेमाल करना

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

Node.js

const { onRequest } = require('firebase-functions/v2/https');

const express = require('express');
const app = express();

// Add middleware to authenticate requests
app.use(myMiddleware);

// build multiple CRUD interfaces:
app.get('/:id', (req, res) => res.send(Widgets.getById(req.params.id)));
app.post('/', (req, res) => res.send(Widgets.create()));
app.put('/:id', (req, res) => res.send(Widgets.update(req.params.id, req.body)));
app.delete('/:id', (req, res) => res.send(Widgets.delete(req.params.id)));
app.get('/', (req, res) => res.send(Widgets.list()));

// Expose Express API as a single Cloud Function:
exports.widgets = onRequest(app);

Python

from firebase_admin import initialize_app, db
from firebase_functions import https_fn
import flask

initialize_app()
app = flask.Flask(__name__)

# Build multiple CRUD interfaces:


@app.get("/widgets")
@app.get("/widgets/<id>")
def get_widget(id=None):
    if id is not None:
        return db.reference(f"/widgets/{id}").get()
    else:
        return db.reference("/widgets").get()


@app.post("/widgets")
def add_widget():
    new_widget = flask.request.get_data(as_text=True)
    db.reference("/widgets").push(new_widget)
    return flask.Response(status=201, response="Added widget")


# Expose Flask app as a single Cloud Function:


@https_fn.on_request()
def httpsflaskexample(req: https_fn.Request) -> https_fn.Response:
    with app.request_context(req.environ):
        return app.full_dispatch_request()main.py

एचटीटीपी फ़ंक्शन को कॉल करना

एचटीटीपी फ़ंक्शन को डिप्लॉय करने के बाद, उसे अपने यूनीक यूआरएल के ज़रिए शुरू किया जा सकता है. डिप्लॉयमेंट के बाद, सीएलआई से मिले सटीक यूआरएल आउटपुट का इस्तेमाल करें.

उदाहरण के लिए, date() को ट्रिगर करने के लिए यूआरएल कुछ ऐसा दिखता है:

https://us-central1-<project-id>.cloudfunctions.net/date

Express और Flask ऐप्लिकेशन रूटिंग की मदद से, फ़ंक्शन का नाम आपके तय किए गए ऐप्लिकेशन के यूआरएल पाथ में प्रीफ़िक्स के तौर पर जोड़ा जाता है.

अनुरोध से वैल्यू पढ़ना

date() फ़ंक्शन के उदाहरण में, फ़ंक्शन यूआरएल पैरामीटर और मुख्य हिस्से, दोनों में format वैल्यू की जांच करता है, ताकि इस्तेमाल करने के लिए तारीख/समय का फ़ॉर्मैट सेट किया जा सके:

Node.js

let format = req.query.format;
format = req.body.format;index.js

Python

format = req.args["format"] if "format" in req.args else Nonemain.py

एचटीटीपी फ़ंक्शन को खत्म करना

सर्वर टाइम को वापस लाने और फ़ॉर्मैट करने के बाद, date() फ़ंक्शन एचटीटीपी रिस्पॉन्स में नतीजा भेजकर काम पूरा करता है:

Node.js

एचटीटीपी फ़ंक्शन को हमेशा send(), redirect() या end() पर खत्म करें. ऐसा न करने पर, हो सकता है कि आपका फ़ंक्शन चलता रहे और सिस्टम उसे जबरन बंद कर दे. सिंक, एक साथ काम न करने वाले प्रोसेस, और प्रॉमिस भी देखें.

const formattedDate = moment().format(`${format}`);
logger.log("Sending formatted date:", formattedDate);
res.status(200).send(formattedDate);index.js

Python

formatted_date = datetime.now().strftime(format)
print(f"Sending Formatted date: {formatted_date}")
return https_fn.Response(formatted_date)main.py

Firebase होस्टिंग के साथ इंटिग्रेट करना

Firebase Hosting से एचटीटीपी फ़ंक्शन कनेक्ट किया जा सकता है. आपकी Firebase Hosting साइट पर किए गए अनुरोधों को, एचटीटीपी के खास फ़ंक्शन पर भेजा जा सकता है. इससे, एचटीटीपी फ़ंक्शन के साथ अपने कस्टम डोमेन का इस्तेमाल करने की सुविधा भी मिलती है. Cloud Functions को Firebase Hosting से कनेक्ट करने के बारे में ज़्यादा जानें.