หน้านี้ได้รับการแปลโดย Cloud Translation API

เรียกใช้ฟังก์ชันจากแอปของคุณ

SDK ของไคลเอ็นต์ Cloud Functions for Firebase ช่วยให้คุณเรียกใช้ฟังก์ชันจากแอป Firebase ได้โดยตรง หากต้องการเรียกใช้ฟังก์ชันจากแอปด้วยวิธีนี้ ให้เขียนและติดตั้งใช้งานฟังก์ชันที่เรียกใช้ HTTP ใน Cloud Functions แล้วเพิ่มตรรกะไคลเอ็นต์เพื่อเรียกใช้ฟังก์ชันจากแอป

โปรดทราบว่าฟังก์ชันที่เรียกใช้ได้ของ HTTP จะคล้ายกับแต่ไม่เหมือนกับฟังก์ชัน HTTP หากต้องการใช้ฟังก์ชันที่เรียก HTTP ได้ คุณต้องใช้ SDK ไคลเอ็นต์สําหรับแพลตฟอร์มของคุณร่วมกับ API แบ็กเอนด์ (หรือติดตั้งใช้งานโปรโตคอล) ฟังก์ชันเรียกใช้ได้มีความแตกต่างที่สำคัญจากฟังก์ชัน HTTP ดังนี้

เมื่อใช้รายการที่เรียกใช้ได้ ระบบจะรวมโทเค็น Firebase Authentication, โทเค็น FCM และโทเค็น App Check (หากมี) ไว้ในคําขอโดยอัตโนมัติ
ทริกเกอร์จะแปลงค่าออบเจ็กต์ JSON ให้เป็นรูปแบบเดิมของเนื้อหาคําขอและตรวจสอบโทเค็นการตรวจสอบสิทธิ์โดยอัตโนมัติ

Firebase SDK สําหรับ Cloud Functions รุ่นที่ 2 ขึ้นไปทํางานร่วมกับไคลเอ็นต์ Firebase SDK เวอร์ชันขั้นต่ำต่อไปนี้เพื่อรองรับฟังก์ชันที่เรียกใช้ได้ของ HTTPS

Firebase SDK สําหรับแพลตฟอร์ม Apple 11.5.0
Firebase SDK สำหรับ Android 21.1.0
Firebase Modular Web SDK v. 9.7.0

หากต้องการเพิ่มฟังก์ชันการทำงานที่คล้ายกันลงในแอปที่สร้างบนแพลตฟอร์มที่ไม่รองรับ ให้ดูข้อกำหนดโปรโตคอลสำหรับ https.onCall ส่วนที่เหลือของคู่มือนี้จะแสดงวิธีการเขียน ติดตั้งใช้งาน และเรียกใช้ฟังก์ชันที่เรียก HTTP ได้สำหรับแพลตฟอร์ม Apple, Android, เว็บ, C++ และ Unity

เขียนและติดตั้งใช้งานฟังก์ชันที่เรียกใช้ได้

ตัวอย่างโค้ดในส่วนนี้อิงตามตัวอย่างการเริ่มต้นใช้งานอย่างรวดเร็วที่สมบูรณ์ซึ่งสาธิตวิธีส่งคําขอไปยังฟังก์ชันฝั่งเซิร์ฟเวอร์และรับคําตอบโดยใช้ SDK ฝั่งไคลเอ็นต์อย่างใดอย่างหนึ่ง หากต้องการเริ่มต้นใช้งาน ให้นําเข้าข้อบังคับต่อไปนี้

Node.js

// Dependencies for callable functions.
const {onCall, HttpsError} = require("firebase-functions/v2/https");
const {logger} = require("firebase-functions/v2");

// Dependencies for the addMessage function.
const {getDatabase} = require("firebase-admin/database");
const sanitizer = require("./sanitizer");index.js

Python

# Dependencies for callable functions.
from firebase_functions import https_fn, options

# Dependencies for writing to Realtime Database.
from firebase_admin import db, initialize_appmain.py

ใช้ตัวแฮนเดิลคําขอสําหรับแพลตฟอร์มของคุณ (functions.https.onCall) หรือ on_call) เพื่อสร้างฟังก์ชันที่เรียกใช้ได้ของ HTTPS เมธอดนี้ใช้พารามิเตอร์คำขอ ดังนี้

Node.js

// Saves a message to the Firebase Realtime Database but sanitizes the
// text by removing swearwords.
exports.addmessage = onCall((request) => {
  // ...
});index.js

Python

@https_fn.on_call()
def addmessage(req: https_fn.CallableRequest) -> Any:
    """Saves a message to the Firebase Realtime Database but sanitizes the text
    by removing swear words."""main.py

พารามิเตอร์ request มีข้อมูลที่ส่งมาจากแอปไคลเอ็นต์ รวมถึงบริบทเพิ่มเติม เช่น สถานะการตรวจสอบสิทธิ์ สําหรับฟังก์ชันที่เรียกใช้ได้ซึ่งบันทึก SMS ไปยัง Realtime Database เช่น data อาจมีข้อความพร้อมกับข้อมูลการตรวจสอบสิทธิ์ใน auth

Node.js

// Message text passed from the client.
const text = request.data.text;
// Authentication / user information is automatically added to the request.
const uid = request.auth.uid;
const name = request.auth.token.name || null;
const picture = request.auth.token.picture || null;
const email = request.auth.token.email || null;index.js

Python

# Message text passed from the client.
text = req.data["text"]main.py
# Authentication / user information is automatically added to the request.
uid = req.auth.uid
name = req.auth.token.get("name", "")
picture = req.auth.token.get("picture", "")
email = req.auth.token.get("email", "")main.py

ระยะห่างระหว่างตำแหน่งของฟังก์ชันที่เรียกใช้ได้กับตำแหน่งของไคลเอ็นต์ที่เรียกอาจทำให้เกิดเวลาในการตอบสนองของเครือข่าย หากต้องการเพิ่มประสิทธิภาพ ให้พิจารณาระบุตำแหน่งฟังก์ชันตามความเหมาะสม และตรวจสอบว่าได้ปรับตำแหน่งของฟังก์ชันที่เรียกใช้ได้ให้สอดคล้องกับตำแหน่งที่ตั้งไว้เมื่อคุณเริ่มต้น SDK ฝั่งไคลเอ็นต์

คุณแนบการรับรอง App Check เพื่อช่วยปกป้องทรัพยากรแบ็กเอนด์จากการละเมิด เช่น การฉ้อโกงผ่านการเรียกเก็บเงินหรือฟิชชิงได้ (ไม่บังคับ) ดูหัวข้อเปิดใช้การบังคับใช้ App Check สำหรับ Cloud Functions

การส่งผลลัพธ์กลับ

หากต้องการส่งข้อมูลกลับไปยังไคลเอ็นต์ ให้แสดงผลข้อมูลที่เข้ารหัส JSON ได้ เช่น หากต้องการแสดงผลลัพธ์ของการดำเนินการบวก ให้ทำดังนี้

Node.js

// returning result.
return {
  firstNumber: firstNumber,
  secondNumber: secondNumber,
  operator: "+",
  operationResult: firstNumber + secondNumber,
};index.js

Python

return {
    "firstNumber": first_number,
    "secondNumber": second_number,
    "operator": "+",
    "operationResult": first_number + second_number
}main.py

ระบบจะส่งข้อความที่ผ่านการกรองจากตัวอย่างข้อความไปยังทั้งไคลเอ็นต์และ Realtime Database ใน Node.js การดำเนินการนี้ทำได้แบบไม่สอดคล้องกันโดยใช้สัญญา JavaScript

Node.js

// Saving the new message to the Realtime Database.
const sanitizedMessage = sanitizer.sanitizeText(text); // Sanitize message.

return getDatabase().ref("/messages").push({
  text: sanitizedMessage,
  author: {uid, name, picture, email},
}).then(() => {
  logger.info("New Message written");
  // Returning the sanitized message to the client.
  return {text: sanitizedMessage};
})index.js

Python

# Saving the new message to the Realtime Database.
sanitized_message = sanitize_text(text)  # Sanitize message.
db.reference("/messages").push({  # type: ignore
    "text": sanitized_message,
    "author": {
        "uid": uid,
        "name": name,
        "picture": picture,
        "email": email
    }
})
print("New message written")

# Returning the sanitized message to the client.
return {"text": sanitized_message}main.py

กำหนดค่า CORS (กลไกการแชร์ทรัพยากรข้ามโดเมน)

ใช้ตัวเลือก cors เพื่อควบคุมต้นทางที่เข้าถึงฟังก์ชันได้

โดยค่าเริ่มต้น ฟังก์ชันที่เรียกใช้ได้จะกําหนดค่า CORS ให้อนุญาตคําขอจากต้นทางทั้งหมด หากต้องการอนุญาตคําขอข้ามแหล่งที่มาบางรายการ แต่ไม่ใช่ทั้งหมด ให้ส่งรายการโดเมนหรือนิพจน์ทั่วไปที่เจาะจงซึ่งควรอนุญาต เช่น

Node.js

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

exports.getGreeting = onCall(
  { cors: [/firebase\.com$/, "https://flutter.com"] },
  (request) => {
    return "Hello, world!";
  }
);

หากต้องการห้ามคำขอข้ามต้นทาง ให้ตั้งค่านโยบาย cors เป็น false

จัดการข้อผิดพลาด

โปรดส่งคืนข้อผิดพลาดจากฟังก์ชันเรียกใช้โดยส่ง (หรือสำหรับ Node.js ที่ส่งคืน Promise ที่ปฏิเสธด้วย) อินสแตนซ์ของ functions.https.HttpsError หรือ https_fn.HttpsError เพื่อให้แน่ใจว่าไคลเอ็นต์จะได้รับรายละเอียดข้อผิดพลาดที่เป็นประโยชน์ ข้อผิดพลาดมีแอตทริบิวต์ code ซึ่งอาจเป็นค่าใดค่าหนึ่งตามที่ระบุไว้ใน gRPC รหัสสถานะ ข้อผิดพลาดยังมีสตริง message ด้วย ซึ่งค่าเริ่มต้นจะเป็นสตริงว่าง และยังอาจมีฟิลด์ details ที่ไม่บังคับซึ่งมีค่าที่กำหนดเองได้ หากฟังก์ชันแสดงข้อผิดพลาดอื่นที่ไม่ใช่ข้อผิดพลาด HTTPS ขึ้น ลูกค้าจะได้รับข้อผิดพลาดพร้อมข้อความ INTERNAL และรหัส internal แทน

ตัวอย่างเช่น ฟังก์ชันอาจแสดงข้อผิดพลาดในการตรวจสอบข้อมูลและการตรวจสอบสิทธิ์พร้อมข้อความแสดงข้อผิดพลาดเพื่อส่งกลับไปยังไคลเอ็นต์ที่เรียกใช้

Node.js

// Checking attribute.
if (!(typeof text === "string") || text.length === 0) {
  // Throwing an HttpsError so that the client gets the error details.
  throw new HttpsError("invalid-argument", "The function must be called " +
          "with one arguments \"text\" containing the message text to add.");
}
// Checking that the user is authenticated.
if (!request.auth) {
  // Throwing an HttpsError so that the client gets the error details.
  throw new HttpsError("failed-precondition", "The function must be " +
          "called while authenticated.");
}index.js

Python

# Checking attribute.
if not isinstance(text, str) or len(text) < 1:
    # Throwing an HttpsError so that the client gets the error details.
    raise https_fn.HttpsError(code=https_fn.FunctionsErrorCode.INVALID_ARGUMENT,
                              message=('The function must be called with one argument, "text",'
                                       " containing the message text to add."))

# Checking that the user is authenticated.
if req.auth is None:
    # Throwing an HttpsError so that the client gets the error details.
    raise https_fn.HttpsError(code=https_fn.FunctionsErrorCode.FAILED_PRECONDITION,
                              message="The function must be called while authenticated.")main.py

ทำให้ฟังก์ชันที่เรียกใช้ได้ใช้งานได้

หลังจากบันทึกฟังก์ชันที่เรียกใช้ได้ซึ่งเสร็จสมบูรณ์ภายใน index.js แล้ว ระบบจะติดตั้งใช้งานฟังก์ชันดังกล่าวพร้อมกับฟังก์ชันอื่นๆ ทั้งหมดเมื่อคุณเรียกใช้ firebase deploy หากต้องการทําให้ใช้งานได้เพียงรายการเดียว ให้ใช้อาร์กิวเมนต์ --only ตามที่แสดงเพื่อทําการปรับใช้บางส่วน

firebase deploy --only functions:addMessage

หากพบข้อผิดพลาดเกี่ยวกับสิทธิ์เมื่อทำให้ฟังก์ชันใช้งานได้ ให้ตรวจสอบว่าได้มอบหมายบทบาท IAM ที่เหมาะสมให้แก่ผู้ใช้ที่เรียกใช้คำสั่งทำให้ใช้งานได้

ตั้งค่าสภาพแวดล้อมการพัฒนาซอฟต์แวร์ไคลเอ็นต์

ตรวจสอบว่าคุณมีคุณสมบัติตรงตามข้อกําหนดเบื้องต้น จากนั้นเพิ่มไลบรารีไคลเอ็นต์และไลบรารี Dependencies ที่จําเป็นลงในแอป

iOS ขึ้นไป

ทําตามวิธีการเพื่อเพิ่ม Firebase ไปยังแอป Apple

ใช้ Swift Package Manager เพื่อติดตั้งและจัดการทรัพยากร Dependency ของ Firebase

เปิดโปรเจ็กต์แอปใน Xcode แล้วไปที่ไฟล์ > เพิ่มแพ็กเกจ
เมื่อได้รับข้อความแจ้ง ให้เพิ่มที่เก็บ Firebase SDK สำหรับแพลตฟอร์ม Apple ดังนี้

  https://github.com/firebase/firebase-ios-sdk.git

เลือกคลัง Cloud Functions
เพิ่ม Flag -ObjC ลงในส่วน Other Linker Flags ของการตั้งค่าบิลด์เป้าหมาย
เมื่อเสร็จแล้ว Xcode จะเริ่มจับคู่ข้อมูลและดาวน์โหลดทรัพยากร Dependency ในเบื้องหลังโดยอัตโนมัติ

Web

ทําตามวิธีการเพื่อเพิ่ม Firebase ลงในเว็บแอป อย่าลืมเรียกใช้คําสั่งต่อไปนี้จากเทอร์มินัล
```
npm install firebase@11.0.2 --save
```

กำหนดให้ทั้ง Firebase Core และ Cloud Functions ทำงานด้วยตนเองโดยทำดังนี้

 import { initializeApp } from 'firebase/app';
 import { getFunctions } from 'firebase/functions';

 const app = initializeApp({
     projectId: '### CLOUD FUNCTIONS PROJECT ID ###',
     apiKey: '### FIREBASE API KEY ###',
     authDomain: '### FIREBASE AUTH DOMAIN ###',
   });
 const functions = getFunctions(app);

Android

ทําตามวิธีการเพื่อเพิ่ม Firebase ลงในแอป Android
ในไฟล์ Gradle ของโมดูล (ระดับแอป) (โดยปกติจะเป็น <project>/<app-module>/build.gradle.kts หรือ <project>/<app-module>/build.gradle) ให้เพิ่มทรัพยากร Dependency สำหรับไลบรารี Cloud Functions สำหรับ Android เราขอแนะนำให้ใช้ Firebase Android BoM เพื่อควบคุมการกำหนดเวอร์ชันของไลบรารี
```
dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:33.6.0"))

    // Add the dependency for the Cloud Functions library
    // When using the BoM, you don't specify versions in Firebase library dependencies
    implementation("com.google.firebase:firebase-functions")
}
```
การใช้ Firebase Android BoM จะทำให้แอปใช้ไลบรารี Firebase Android เวอร์ชันที่เข้ากันได้อยู่เสมอ
(วิธีอื่น) เพิ่มไลบรารี Firebase ที่ต้องพึ่งพาโดยไม่ต้องใช้ BoM

หากเลือกไม่ใช้ Firebase BoM คุณต้องระบุเวอร์ชันของไลบรารี Firebase แต่ละเวอร์ชันในบรรทัดของ Dependency

โปรดทราบว่าหากคุณใช้ไลบรารี Firebase หลายรายการในแอป เราขอแนะนําอย่างยิ่งให้ใช้ BoM เพื่อจัดการเวอร์ชันของไลบรารี ซึ่งจะช่วยให้มั่นใจได้ว่าทุกเวอร์ชันจะใช้งานร่วมกันได้
```
dependencies {
    // Add the dependency for the Cloud Functions library
    // When NOT using the BoM, you must specify versions in Firebase library dependencies
    implementation("com.google.firebase:firebase-functions:21.1.0")
}
```
หากกำลังมองหาโมดูลไลบรารีสำหรับ Kotlin โดยเฉพาะ ตั้งแต่เดือนตุลาคม 2023 (Firebase BoM 32.5.0) เป็นต้นไป นักพัฒนาซอฟต์แวร์ทั้ง Kotlin และ Java จะใช้โมดูลไลบรารีหลักได้ (ดูรายละเอียดได้ในคําถามที่พบบ่อยเกี่ยวกับโครงการริเริ่มนี้)

เริ่มต้น SDK ของไคลเอ็นต์

เริ่มต้นอินสแตนซ์ของ Cloud Functions

Swift

lazy var functions = Functions.functions()CloudAddCell.swift

Objective-C

@property(strong, nonatomic) FIRFunctions *functions;
// ...
self.functions = [FIRFunctions functions];CloudAddCell.m

Web

const app = initializeApp({
  projectId: '### CLOUD FUNCTIONS PROJECT ID ###',
  apiKey: '### FIREBASE API KEY ###',
  authDomain: '### FIREBASE AUTH DOMAIN ###',
});
const functions = getFunctions(app);

Kotlin+KTX

private lateinit var functions: FirebaseFunctions
// ...
functions = Firebase.functionsMainActivity.kt

Java

private FirebaseFunctions mFunctions;
// ...
mFunctions = FirebaseFunctions.getInstance();MainActivity.java