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

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

इस गाइड में यह मान लिया गया है कि आपने Node.js और Python के लिए, हमारी 'शुरू करने के लिए गाइड' में बताई गई सेटअप से जुड़ी टास्क पूरी कर ली हैं. इसके अलावा, यह भी मान लिया गया है कि आपने एक्सपेरिमेंटल Dart SDK के लिए सेटअप से जुड़ी टास्क पूरी कर ली हैं.

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

विकल्प	ब्यौरा
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 के कई सबडोमेन हो सकते हैं, तो cors विकल्प को इस तरह सेट किया जा सकता है:

Node.js

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

exports.sayHello = onRequest(
  { cors: [/firebase\.com$/, "https://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!")

Dart (एक्सपेरिमेंटल)

import 'package:firebase_functions/firebase_functions.dart';

void main(List<String> args) {
  fireUp(args, (firebase) {
    firebase.https.onRequest(
      name: 'sayHello',
      options: const HttpsOptions(
        cors: Cors([RegExp(r'^https:\/\/firebase\.com$'), 'https://flutter.com']),
      ),
      (request) async => Response(200, body: 'Hello world!'),
    );
  });
}

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

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

अपने प्लैटफ़ॉर्म के लिए अनुरोध हैंडलर का इस्तेमाल करके, ऐसा फ़ंक्शन बनाएं जो एचटीटीपी इवेंट को हैंडल करता हो. इस सेक्शन में दिए गए उदाहरण, "टाइम सर्वर" के सैंपल पर आधारित हैं. यह सैंपल, फ़ंक्शन के एंडपॉइंट पर एचटीटीपी 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

Dart (एक्सपेरिमेंटल)

void main(List<String> args) async {
  await fireUp(args, (firebase) {
    firebase.https.onRequest(name: 'date', (request) async {
server.dart

अहम जानकारी: पक्का करें कि सभी एचटीटीपी फ़ंक्शन सही तरीके से खत्म हों. फ़ंक्शन को सही तरीके से खत्म करके, लंबे समय तक चलने वाले फ़ंक्शन के लिए लगने वाले ज़्यादा शुल्क से बचा जा सकता है.

मौजूदा 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 ऐप्लिकेशन राउटिंग के साथ, आपके तय किए गए ऐप्लिकेशन में, यूआरएल पाथ में फ़ंक्शन का नाम प्रीफ़िक्स के तौर पर जोड़ा जाता है.

ध्यान दें: एक्सपेरिमेंटल Dart SDK की मदद से, फ़ंक्शन को कॉल करने वाले यूआरएल का फ़ॉर्मैट अलग होता है: https://<function-name>-<random-hash>.<region>.run.app.

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

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 None
main.py

Dart (एक्सपेरिमेंटल)

var format = request.url.queryParameters['format'];
final bodyString = await request.readAsString();
try {
  if (bodyString.isNotEmpty) {
    final body = jsonDecode(bodyString) as Map<String, dynamic>;
    format = body['format'] as String?;
  }
} catch (e) {
  return Response.badRequest(body: 'invalid JSON');
}
server.dart

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

सर्वर का समय फ़ेच करने और उसे फ़ॉर्मैट करने के बाद, 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

Dart (एक्सपेरिमेंटल)

final formattedDate = DateFormat(format).format(DateTime.now());
print('Sending formatted date: $formattedDate');
return Response.ok(formattedDate);
server.dart

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

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