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

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

एचटीटीपी के अतिरिक्त विकल्प

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

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

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

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

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

कुछ क्रॉस-ऑरिजिन अनुरोधों को अनुमति देने के लिए, लेकिन सभी को नहीं, उन डोमेन या रेगुलर एक्सप्रेशन की सूची पास की जा सकती है जिन्हें अनुमति दी जानी चाहिए. उदाहरण के लिए, अगर आपके पास 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 Hosting के साथ इंटिग्रेट करना

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