เริ่มต้นสร้างส่วนขยาย

หน้านี้จะแนะนําขั้นตอนที่จําเป็นในการสร้าง Firebase แบบง่าย ส่วนขยายที่คุณสามารถติดตั้งในโปรเจ็กต์หรือแชร์กับผู้อื่น ช่วงเวลานี้ ตัวอย่างง่ายๆ ของส่วนขยาย Firebase จะคอยดู Realtime Database สำหรับ ข้อความและแปลงเป็นตัวพิมพ์ใหญ่ได้

1. ตั้งค่าสภาพแวดล้อมและเริ่มต้นโปรเจ็กต์

คุณต้องตั้งค่าบิลด์ก่อนจึงจะเริ่มสร้างส่วนขยายได้ ด้วยเครื่องมือที่จำเป็น

  1. ติดตั้ง Node.js 16 ขึ้นไป วิธีหนึ่งในการติดตั้งโหนดคือการใช้ nvm (หรือ nvm-windows)

  2. ติดตั้งหรืออัปเดต Firebase CLI เป็นเวอร์ชันล่าสุด ถึง ติดตั้งหรืออัปเดตโดยใช้ npm ให้เรียกใช้คำสั่งนี้

    npm install -g firebase-tools

ตอนนี้ ให้ใช้ Firebase CLI เพื่อเริ่มต้นโปรเจ็กต์ส่วนขยายใหม่

  1. สร้างไดเรกทอรีสำหรับส่วนขยายและ cd ลงในไดเรกทอรีด้วยคำสั่งต่อไปนี้

    mkdir rtdb-uppercase-messages && cd rtdb-uppercase-messages

  2. เรียกใช้คำสั่ง ext:dev:init ของ Firebase CLI ดังนี้

    firebase ext:dev:init

    เมื่อได้รับข้อความแจ้ง ให้เลือก JavaScript เป็นภาษาสำหรับฟังก์ชัน (หมายเหตุ ที่คุณสามารถใช้ TypeScript เมื่อพัฒนาส่วนขยายของตัวเอง) และ เมื่อระบบขอให้ติดตั้งทรัพยากร Dependency ให้ตอบว่า "ใช่" (ยอมรับค่าเริ่มต้นสำหรับ ตัวเลือกอื่นๆ) คำสั่งนี้จะตั้งค่าโครงสร้างโค้ดเบสสำหรับ ส่วนขยายใหม่ ซึ่งคุณจะสามารถเริ่มพัฒนาส่วนขยายของคุณได้

2. ลองใช้ส่วนขยายตัวอย่างที่ใช้โปรแกรมจำลอง

เมื่อ Firebase CLI เริ่มต้นไดเรกทอรีส่วนขยายใหม่ จะมีการสร้าง ฟังก์ชันตัวอย่างแบบง่ายและไดเรกทอรี integration-tests ที่มีฟังก์ชัน ไฟล์ที่จำเป็นต่อการเรียกใช้ส่วนขยายโดยใช้ชุดโปรแกรมจำลอง Firebase

ลองเรียกใช้ส่วนขยายตัวอย่างในโปรแกรมจำลอง

  1. เปลี่ยนเป็นไดเรกทอรี integration-tests:

    cd functions/integration-tests

  2. เริ่มต้นโปรแกรมจำลองด้วยโปรเจ็กต์เดโม

    firebase emulators:start --project=demo-test

    โปรแกรมจำลองจะโหลดส่วนขยายลงใน "แบบจำลอง" ที่กำหนดไว้ล่วงหน้า โปรเจ็กต์ (demo-test) จนถึงขณะนี้ส่วนขยายประกอบด้วย HTTP เดียวที่ทริกเกอร์ greetTheWorld ซึ่งแสดงผล "สวัสดีโลก" ส่งข้อความเมื่อ เข้าถึงแล้ว

  3. ขณะที่โปรแกรมจำลองยังคงทำงานอยู่ ให้ลองใช้ greetTheWorld ของส่วนขยาย โดยไปที่ URL ที่พิมพ์ไว้เมื่อคุณเริ่มใช้งาน

    เบราว์เซอร์จะแสดงข้อความ "สวัสดีโลกจากทักทายโลก"

  4. ซอร์สโค้ดสำหรับฟังก์ชันนี้อยู่ใน functions ของส่วนขยาย ไดเรกทอรี เปิดซอร์สในตัวแก้ไขหรือ IDE ที่ต้องการ

    functions/index.js

    const functions = require("firebase-functions");

exports.greetTheWorld = functions.https.onRequest((req, res) => {
  // Here we reference a user-provided parameter
  // (its value is provided by the user during installation)
  const consumerProvidedGreeting = process.env.GREETING;

  // And here we reference an auto-populated parameter
  // (its value is provided by Firebase after installation)
  const instanceId = process.env.EXT_INSTANCE_ID;

  const greeting = `${consumerProvidedGreeting} World from ${instanceId}`;

  res.send(greeting);
});

  5. ขณะที่โปรแกรมจำลองกำลังทำงาน โปรแกรมจะโหลดการเปลี่ยนแปลงใดๆ ที่คุณแก้ไขโดยอัตโนมัติ กับโค้ดฟังก์ชัน ลองทำการเปลี่ยนแปลงเล็กๆ น้อยๆ กับ ฟังก์ชัน greetTheWorld:

    functions/index.js

    const greeting = `${consumerProvidedGreeting} everyone, from ${instanceId}`;

    บันทึกการเปลี่ยนแปลง โปรแกรมจำลองจะโหลดโค้ดซ้ำ และตอนนี้เมื่อคุณ ให้ไปที่ URL ของฟังก์ชัน คุณจะเห็นคำทักทายที่อัปเดต

3. เพิ่มข้อมูลพื้นฐานไปยัง extensions.yaml

คุณได้ตั้งค่าสภาพแวดล้อมในการพัฒนาซอฟต์แวร์แล้วและกำลังใช้ โปรแกรมจำลองส่วนขยาย คุณสามารถเริ่มเขียนส่วนขยายของตัวเองได้

ขั้นแรก ให้คุณแก้ไขข้อมูลเมตาของส่วนขยายที่กำหนดไว้ล่วงหน้าเพื่อแสดง ส่วนขยายที่คุณต้องการเขียนแทน greet-the-world ข้อมูลเมตานี้คือ ที่จัดเก็บไว้ในไฟล์ extension.yaml

  1. เปิด extension.yaml ในเครื่องมือแก้ไข แล้วแทนที่เนื้อหาทั้งหมดของ ที่มีข้อมูลต่อไปนี้

    name: rtdb-uppercase-messages
version: 0.0.1
specVersion: v1beta  # Firebase Extensions specification version; don't change

# Friendly display name for your extension (~3-5 words)
displayName: Convert messages to upper case

# Brief description of the task your extension performs (~1 sentence)
description: >-
  Converts messages in RTDB to upper case

author:
  authorName: Your Name
  url: https://your-site.example.com

license: Apache-2.0  # Required license

# Public URL for the source code of your extension
sourceUrl: https://github.com/your-name/your-repo

    ดูรูปแบบการตั้งชื่อที่ใช้ในช่อง name: Firebase อย่างเป็นทางการ ส่วนขยายจะตั้งชื่อด้วยคำนำหน้าที่แสดงถึงผลิตภัณฑ์ Firebase หลัก ส่วนขยายทำงาน ตามด้วยคำอธิบายว่าส่วนขยาย มี คุณควรใช้รูปแบบเดียวกันนี้ในส่วนขยายของตัวเอง

  2. เนื่องจากคุณได้เปลี่ยนชื่อส่วนขยาย คุณจึงควรอัปเดต การกำหนดค่าโปรแกรมจำลองด้วยชื่อใหม่:

    1. ในอีก functions/integration-tests/firebase.json ให้เปลี่ยน greet-the-world ไปยัง rtdb-uppercase-messages
    2. เปลี่ยนชื่อ functions/integration-tests/extensions/greet-the-world.env เป็น functions/integration-tests/extensions/rtdb-uppercase-messages.env.

ยังมีส่วนที่เหลือของส่วนขยาย greet-the-world อยู่ใน โค้ดส่วนขยายของคุณ แต่ตอนนี้ปล่อยไว้เท่านั้น คุณจะอัปเดตข้อมูลเหล่านี้ในอีก 2-3 วัน

4. เขียน Cloud Function และประกาศว่าเป็นทรัพยากรส่วนขยาย

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

  1. เปิดซอร์สโค้ดสำหรับฟังก์ชันของส่วนขยาย (ใน functions) ในตัวแก้ไขหรือ IDE ที่ต้องการ แทนที่ เนื้อหาต่อไปนี้ด้วย

    functions/index.js

    import { database, logger } from "firebase-functions/v1";

const app = initializeApp();

// Listens for new messages added to /messages/{pushId}/original and creates an
// uppercase version of the message to /messages/{pushId}/uppercase
// for all databases in 'us-central1'
export const makeuppercase = database
  .ref("/messages/{pushId}/uppercase")
  .onCreate(async (snapshot, context) => {
    // Grab the current value of what was written to the Realtime Database.
    const original = snapshot.val();

    // Convert it to upper case.
    logger.log("Uppercasing", context.params.pushId, original);
    const uppercase = original.toUpperCase();

    // Setting an "uppercase" sibling in the Realtime Database.
    const upperRef = snapshot.ref.parent.child("upper");
    await upperRef.set(uppercase);
});

    ฟังก์ชันเก่าที่คุณแทนที่นั้นเป็นฟังก์ชันที่ทริกเกอร์ HTTP ซึ่ง ทำงานเมื่อมีการเข้าถึงปลายทาง HTTP ฟังก์ชันใหม่จะทริกเกอร์โดย เหตุการณ์ฐานข้อมูลแบบเรียลไทม์: ระบบเฝ้าดูรายการใหม่ๆ ในเส้นทางเฉพาะ และเมื่อตรวจพบค่า ก็เขียนค่ากลับเป็นเวอร์ชันตัวพิมพ์ใหญ่ ไปยังฐานข้อมูล

    ไฟล์ใหม่นี้ใช้ไวยากรณ์ของโมดูล ECMAScript (import และ export) แทน CommonJS (require) หากต้องการใช้โมดูล ES ในโหนด ระบุ "type": "module" ใน functions/package.json:

    {
  "name": "rtdb-uppercase-messages",
  "main": "index.js",
  "type": "module",
  …
}

  2. ทุกฟังก์ชันในส่วนขยายของคุณต้องประกาศใน extension.yaml ส่วนขยายตัวอย่างประกาศว่า greetTheWorld เป็นเพียง Cloud Function ตอนนี้คุณได้แทนที่ด้วย makeuppercase แล้ว คุณยัง ต้องอัปเดตการประกาศ

    เปิด extension.yaml แล้วเพิ่มช่อง resources ดังนี้

    resources:
  - name: makeuppercase
    type: firebaseextensions.v1beta.function
    properties:
      eventTrigger:
        eventType: providers/google.firebase.database/eventTypes/ref.create
        # DATABASE_INSTANCE (project's default instance) is an auto-populated
        # parameter value. You can also specify an instance.
        resource: projects/_/instances/${DATABASE_INSTANCE}/refs/messages/{pushId}/original
      runtime: "nodejs18"

  3. เนื่องจากตอนนี้ส่วนขยายใช้ Realtime Database เป็นทริกเกอร์ คุณจึงต้อง เพื่ออัปเดตการกำหนดค่าโปรแกรมจำลองเพื่อเรียกใช้โปรแกรมจำลอง RTDB ควบคู่ไปกับ โปรแกรมจำลอง Cloud Functions:

    1. หากโปรแกรมจำลองยังคงทำงานอยู่ ให้หยุดโปรแกรมดังกล่าวโดยกด Ctrl-C

    2. จากไดเรกทอรี functions/integration-tests ให้เรียกใช้คำสั่งต่อไปนี้ คำสั่ง:

      firebase init emulators

      เมื่อระบบถาม ให้ข้ามการตั้งค่าโปรเจ็กต์เริ่มต้น แล้วเลือกฟังก์ชัน และโปรแกรมจำลองฐานข้อมูล ยอมรับพอร์ตเริ่มต้นและอนุญาตการตั้งค่า เพื่อดาวน์โหลดไฟล์ที่จำเป็น

    3. รีสตาร์ทโปรแกรมจำลอง

      firebase emulators:start --project=demo-test

  4. ลองใช้ส่วนขยายที่อัปเดตแล้วของคุณ:

    1. เปิด UI โปรแกรมจำลองฐานข้อมูลโดยใช้ลิงก์ที่โปรแกรมจำลองพิมพ์ ตอนที่เริ่มทำ

    2. แก้ไขโหนดรากของฐานข้อมูล

      • ฟิลด์: messages
      • ประเภท: json
      • ค่า: {"11": {"original": "recipe"}}

      หากตั้งค่าทุกอย่างถูกต้อง เมื่อคุณบันทึกการเปลี่ยนแปลงฐานข้อมูล ฟังก์ชัน makeuppercase ของส่วนขยายควรเรียกและเพิ่ม บันทึกไปยังข้อความ 11 ที่มีเนื้อหา "upper": "RECIPE" ลองดูสิ ที่บันทึกและแท็บฐานข้อมูลของ UI โปรแกรมจำลองเพื่อยืนยัน ผลลัพธ์ที่คาดหวัง

    3. ลองเพิ่มระดับย่อยในโหนด messages ({"original":"any text"}) เมื่อใดก็ตามที่คุณเพิ่มระเบียนใหม่ การตั้งค่า ส่วนขยายควรเพิ่มช่อง uppercase ที่มีตัวพิมพ์ใหญ่ เนื้อหาจากช่อง original

ตอนนี้คุณมีส่วนขยายที่สมบูรณ์แต่เรียบง่าย ซึ่งทำงานบน RTDB อินสแตนซ์ ในส่วนต่อไป คุณจะได้ปรับแต่งส่วนขยายนี้ด้วย ฟีเจอร์เพิ่มเติม จากนั้น คุณจะได้รับส่วนขยายที่พร้อมสำหรับการเผยแพร่ สุดท้าย เรียนรู้วิธีเผยแพร่ส่วนขยายในฮับส่วนขยาย

5. ประกาศ API และบทบาท

Firebase ให้สิทธิ์แต่ละอินสแตนซ์ของส่วนขยายที่ติดตั้งในการเข้าถึง และข้อมูลของโปรเจ็กต์โดยใช้บัญชีบริการต่ออินสแตนซ์ แต่ละบัญชีจะมี สิทธิ์ขั้นต่ำที่จำเป็นต่อการดำเนินการ ด้วยเหตุนี้คุณจึงต้อง ประกาศบทบาท IAM ที่ส่วนขยายของคุณต้องการอย่างชัดแจ้ง เมื่อผู้ใช้ติดตั้ง ส่วนขยาย Firebase จะสร้างบัญชีบริการที่ได้รับบทบาทเหล่านี้และ จะใช้ในการเรียกใช้ส่วนขยาย

คุณไม่จำเป็นต้องประกาศบทบาทเพื่อเรียกเหตุการณ์ของผลิตภัณฑ์ แต่ต้องประกาศบทบาท คุณต้องประกาศบทบาทเพื่อโต้ตอบกับบทบาทนั้น เนื่องจากฟังก์ชันที่คุณ ในขั้นตอนสุดท้ายในการเขียน Realtime Database คุณจะต้องเพิ่ม การประกาศต่อไปนี้กับ extension.yaml:

roles:
  - role: firebasedatabase.admin
    reason: Allows the extension to write to RTDB.

ในทำนองเดียวกัน คุณประกาศ Google APIs ที่ส่วนขยายใช้ใน apis ด้วย เมื่อผู้ใช้ติดตั้งส่วนขยายของคุณ ระบบจะถามผู้ใช้ว่าต้องการ เพื่อเปิดใช้ API เหล่านี้สำหรับโปรเจ็กต์โดยอัตโนมัติ ซึ่งปกติแล้วจะเกิดขึ้นเฉพาะ จำเป็นสำหรับ Google API ที่ไม่ใช่ Firebase และไม่จำเป็นสำหรับคู่มือนี้

6. กำหนดพารามิเตอร์ที่ผู้ใช้กำหนดค่าได้

ฟังก์ชันที่คุณสร้างใน 2 ขั้นตอนสุดท้ายได้ดูตำแหน่ง RTDB ที่เจาะจง สำหรับข้อความขาเข้า บางครั้ง การดูสถานที่ใดสถานที่หนึ่งโดยเฉพาะ ที่คุณต้องการ เช่น เมื่อส่วนขยายทำงานบนโครงสร้างฐานข้อมูลที่คุณ ใช้เฉพาะสำหรับส่วนขยายของคุณเท่านั้น แต่โดยส่วนใหญ่แล้วคุณต้องการ ทำให้ผู้ใช้ที่ติดตั้งส่วนขยายของคุณใน โปรเจ็กต์ ด้วยวิธีนี้ ผู้ใช้สามารถใช้ประโยชน์จากส่วนขยายของคุณเพื่อทำงานร่วมกับ การตั้งค่าฐานข้อมูลที่มีอยู่

ทำให้เส้นทางที่ส่วนขยายใช้ค้นหาข้อความใหม่ที่ผู้ใช้กำหนดค่าได้

  1. ในไฟล์ extension.yaml ให้เพิ่มส่วน params ดังนี้

    - param: MESSAGE_PATH
  label: Message path
  description: >-
    What is the path at which the original text of a message can be found?
  type: string
  default: /messages/{pushId}/original
  required: true
  immutable: false

    การตั้งค่านี้กำหนดพารามิเตอร์สตริงใหม่ซึ่งผู้ใช้จะได้รับข้อความแจ้งให้ตั้งค่า ให้ผู้อ่านติดตั้งส่วนขยายของคุณ

  2. ยังอยู่ในไฟล์ extension.yaml ให้กลับไปที่makeuppercase แล้วเปลี่ยนช่อง resource เป็น

    resource: projects/_/instances/${DATABASE_INSTANCE}/refs/${param:MESSAGE_PATH}

    โทเค็น ${param:MESSAGE_PATH} คือการอ้างอิงถึงพารามิเตอร์ที่คุณเพิ่ง กำหนดไว้ เมื่อส่วนขยายทำงาน โทเค็นนี้จะถูกแทนที่ด้วยอะไรก็ได้ ค่าที่ผู้ใช้กำหนดค่าสำหรับพารามิเตอร์นั้น โดยมีผลลัพธ์ว่า ฟังก์ชัน makeuppercase จะฟังเส้นทางที่ผู้ใช้ระบุ คุณสามารถ ใช้ไวยากรณ์นี้เพื่ออ้างอิงพารามิเตอร์ที่กำหนดโดยผู้ใช้ไม่ว่าที่ใดก็ตามใน extension.yaml (และใน POSTINSTALL.md จะมีรายละเอียดเพิ่มเติมในภายหลัง)

  3. คุณยังเข้าถึงพารามิเตอร์ที่กำหนดโดยผู้ใช้จากโค้ดฟังก์ชันได้อีกด้วย

    ในฟังก์ชันที่คุณเขียนในส่วนสุดท้าย คุณได้ฮาร์ดโค้ดเส้นทางไปยัง คอยดูการเปลี่ยนแปลง เปลี่ยนคำจำกัดความของทริกเกอร์เพื่ออ้างอิงฟังก์ชัน ค่าที่ผู้ใช้กำหนดแทน

    functions/index.js

    export const makeuppercase = database.ref(process.env.MESSAGE_PATH).onCreate

    โปรดทราบว่าใน Firebase Extensions การเปลี่ยนแปลงนี้มีจุดประสงค์เพียง เอกสารประกอบ: เมื่อมีการทำให้ Cloud Function ใช้งานได้โดยเป็นส่วนหนึ่งของส่วนขยาย ใช้คำจำกัดความทริกเกอร์จากไฟล์ extension.yaml และละเว้น ที่ระบุในคำจำกัดความของฟังก์ชัน อย่างไรก็ตาม ก็เป็นความคิดที่ดี เพื่อจัดทำเอกสารเกี่ยวกับที่มาของค่านี้ในโค้ด

  4. คุณอาจผิดหวังกับการเปลี่ยนแปลงโค้ดที่ไม่มีรันไทม์ แต่สิ่งสำคัญที่ต้องเรียนรู้ก็คือ คุณสามารถเข้าถึง พารามิเตอร์ที่ผู้ใช้กำหนดในโค้ดฟังก์ชันและใช้เป็นค่าทั่วไป ในตรรกะของฟังก์ชัน ในส่วนของความสามารถนี้ ให้เพิ่มบันทึกต่อไปนี้ ที่แสดงให้เห็นว่า คุณกำลังเข้าถึงคุณค่าที่ กำหนดโดยผู้ใช้:

    functions/index.js

    export const makeuppercase = database.ref(process.env.MESSAGE_PATH).onCreate(
  async (snapshot, context) => {
    logger.log("Found new message at ", snapshot.ref);

    // Grab the current value of what was written to the Realtime Database.
    ...

  5. โดยปกติแล้ว ผู้ใช้จะได้รับแจ้งให้ระบุค่าสำหรับพารามิเตอร์เมื่อ ติดตั้งส่วนขยาย เมื่อคุณใช้โปรแกรมจำลองเพื่อ ทดสอบและพัฒนา แต่ไม่ต้องทำตามขั้นตอนการติดตั้ง คุณจึงใส่ค่า สำหรับพารามิเตอร์ที่กำหนดโดยผู้ใช้โดยใช้ไฟล์ env

    เปิด functions/integration-tests/extensions/rtdb-uppercase-messages.env และแทนที่คำจำกัดความของ GREETING ด้วยคำสั่งต่อไปนี้

    MESSAGE_PATH=/msgs/{pushId}/original

    โปรดสังเกตว่าเส้นทางด้านบนแตกต่างจากเส้นทางเริ่มต้น เส้นทางที่คุณกำหนดก่อนหน้านี้ นี่เป็นเพียงการพิสูจน์ให้ตนเองเห็นเมื่อคุณพยายาม ส่วนขยายที่อัปเดตซึ่งคำจำกัดความของคุณมีผล

  6. จากนั้นรีสตาร์ทโปรแกรมจำลองและไปที่ UI โปรแกรมจำลองฐานข้อมูลอีกครั้ง

    แก้ไขโหนดรากของฐานข้อมูลโดยใช้เส้นทางที่คุณกำหนดไว้ด้านบน ดังนี้

    • ฟิลด์: msgs
    • ประเภท: json
    • ค่า: {"11": {"original": "recipe"}}

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

7. มี Event Hook สำหรับตรรกะที่กำหนดโดยผู้ใช้

ในฐานะผู้เขียนส่วนขยาย คุณได้เห็นแล้วว่าผลิตภัณฑ์ Firebase จะทริกเกอร์ได้อย่างไรในฐานะผู้เขียนส่วนขยาย ตรรกะที่ได้จากส่วนขยาย: การสร้างระเบียนใหม่ใน Realtime Database ทริกเกอร์ฟังก์ชัน makeuppercase ส่วนขยายของคุณมีลักษณะที่คล้ายกัน ความสัมพันธ์กับผู้ใช้ที่ติดตั้งส่วนขยายของคุณ: ส่วนขยายสามารถ ทริกเกอร์ตรรกะที่ผู้ใช้กำหนด

ส่วนขยายอาจมีฮุกแบบซิงโครนัส ฮุกอะซิงโครนัส หรือทั้ง 2 อย่างก็ได้ ฮุกแบบซิงโครนัสช่วยให้ผู้ใช้มีวิธีการที่จะดำเนินงานที่บล็อกการดำเนินการ ฟังก์ชันหนึ่งของส่วนขยาย ซึ่งอาจเป็นประโยชน์ เช่น การให้ วิธีประมวลผลล่วงหน้าแบบกำหนดเองก่อนที่ส่วนขยายจะทำงาน

ในคู่มือนี้ คุณจะได้เพิ่มฮุกแบบไม่พร้อมกันลงในส่วนขยาย ซึ่งจะ ช่วยให้ผู้ใช้กำหนดขั้นตอนการประมวลผลของตนเองที่จะเรียกใช้หลังจากส่วนขยายของคุณได้ จะเขียนข้อความตัวพิมพ์ใหญ่ลงใน Realtime Database ใช้ฮุกแบบไม่พร้อมกัน Eventarc เพื่อทริกเกอร์ ฟังก์ชันที่ผู้ใช้กำหนด ส่วนขยายจะประกาศประเภทเหตุการณ์ที่เกิดขึ้น และ เมื่อผู้ใช้ติดตั้งส่วนขยาย ก็จะเลือกประเภทเหตุการณ์ที่ต้องการ สนใจ หากผู้ใช้เลือกเหตุการณ์อย่างน้อย 1 เหตุการณ์ Firebase จะจัดสรร ช่องทาง Eventarc สำหรับส่วนขยายซึ่งเป็นส่วนหนึ่งของกระบวนการติดตั้ง ผู้ใช้ สามารถนำฟังก์ชันระบบคลาวด์ของตัวเอง ที่รับฟังช่องทางนั้นไปใช้ และ เมื่อส่วนขยายเผยแพร่เหตุการณ์ใหม่

ทำตามขั้นตอนต่อไปนี้เพื่อเพิ่มฮุกอะซิงโครนัส:

  1. ในไฟล์ extension.yaml ให้เพิ่มส่วนต่อไปนี้ ซึ่งประกาศพารามิเตอร์ 1 ประเภทที่ส่วนขยายจะแสดง ได้แก่

    events:
  - type: test-publisher.rtdb-uppercase-messages.v1.complete
    description: >-
      Occurs when message uppercasing completes. The event subject will contain
      the RTDB URL of the uppercase message.

    ประเภทกิจกรรมต้องไม่ซ้ำกันทั้งหมด เพื่อสร้างเอกลักษณ์ ให้ตั้งชื่อ กิจกรรมของคุณโดยใช้รูปแบบต่อไปนี้ <publisher-id>.<extension-id>.<version>.<description>. (คุณไม่มี รหัสผู้เผยแพร่โฆษณา ดังนั้นให้ใช้ test-publisher ไปก่อน)

  2. ในตอนท้ายของฟังก์ชัน makeuppercase ให้เพิ่มโค้ดที่เผยแพร่ เหตุการณ์ของประเภทที่คุณเพิ่งประกาศ

    functions/index.js

    // Import the Eventarc library:
import { initializeApp } from "firebase-admin/app";
import { getEventarc } from "firebase-admin/eventarc";

const app = initializeApp();

// In makeuppercase, after upperRef.set(uppercase), add:

// Set eventChannel to a newly-initialized channel, or `undefined` if events
// aren't enabled.
const eventChannel =
  process.env.EVENTARC_CHANNEL &&
  getEventarc().channel(process.env.EVENTARC_CHANNEL, {
    allowedEventTypes: process.env.EXT_SELECTED_EVENTS,
  });

// If events are enabled, publish a `complete` event to the configured
// channel.
eventChannel &&
  eventChannel.publish({
    type: "test-publisher.rtdb-uppercase-messages.v1.complete",
    subject: upperRef.toString(),
    data: {
      "original": original,
      "uppercase": uppercase,
    },
  });

    โค้ดตัวอย่างนี้ใช้ประโยชน์จากข้อเท็จจริงที่ว่า EVENTARC_CHANNEL ระบบจะกำหนดตัวแปรสภาพแวดล้อมเฉพาะเมื่อผู้ใช้เปิดใช้อย่างน้อย 1 ตัว ประเภทเหตุการณ์ หากไม่ได้กำหนด EVENTARC_CHANNEL โค้ดจะไม่พยายาม เพื่อเผยแพร่เหตุการณ์

    คุณแนบข้อมูลเพิ่มเติมในเหตุการณ์ Eventarc ได้ ในตัวอย่างด้านบน เหตุการณ์มีช่อง subject ที่มีการอ้างอิงถึง ค่าที่สร้างใหม่ และเพย์โหลด data ที่มีค่าเดิมและ ข้อความตัวพิมพ์ใหญ่ ฟังก์ชันที่ผู้ใช้กำหนดซึ่งทริกเกอร์เหตุการณ์สามารถ ใช้ประโยชน์จากข้อมูลนี้

  3. โดยปกติแล้ว สภาพแวดล้อม EVENTARC_CHANNEL และ EXT_SELECTED_EVENTS ระบบจะกำหนดตัวแปรตามตัวเลือกที่ผู้ใช้เลือกในระหว่าง ของคุณ สำหรับการทดสอบด้วยโปรแกรมจำลอง ให้กำหนดตัวแปรเหล่านี้ด้วยตัวเอง ในไฟล์ rtdb-uppercase-messages.env:

    EVENTARC_CHANNEL=locations/us-central1/channels/firebase
EXT_SELECTED_EVENTS=test-publisher.rtdb-uppercase-messages.v1.complete

ตอนนี้คุณก็ได้ทำตามขั้นตอนที่จำเป็นในการเพิ่มเหตุการณ์อะซิงโครนัสเรียบร้อยแล้ว ดึงดูดส่วนขยายของคุณได้เลย

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

  1. เริ่มต้น Firebase ใหม่จากไดเรกทอรี functions/integration-tests โปรเจ็กต์:

    firebase init functions

    เมื่อได้รับข้อความแจ้ง ให้ปฏิเสธที่จะตั้งค่าโปรเจ็กต์เริ่มต้น แล้วเลือก JavaScript เป็น ภาษา Cloud Functions และติดตั้งการอ้างอิงที่จำเป็น ช่วงเวลานี้ โปรเจ็กต์แสดงถึงโปรเจ็กต์ของผู้ใช้ซึ่งติดตั้งส่วนขยายไว้

  2. แก้ไข integration-tests/functions/index.js และวางโค้ดต่อไปนี้

    import { logger } from "firebase-functions/v1";
import { onCustomEventPublished } from "firebase-functions/v2/eventarc";

import { initializeApp } from "firebase-admin/app";
import { getDatabase } from "firebase-admin/database";

const app = initializeApp();

export const extraemphasis = onCustomEventPublished(
  "test-publisher.rtdb-uppercase-messages.v1.complete",
  async (event) => {
    logger.info("Received makeuppercase completed event", event);

    const refUrl = event.subject;
    const ref = getDatabase().refFromURL(refUrl);
    const upper = (await ref.get()).val();
    return ref.set(`${upper}!!!`);
  }
);

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

  3. รีสตาร์ทโปรแกรมจำลอง โปรแกรมจำลองจะโหลดฟังก์ชันของส่วนขยายเป็น รวมถึงฟังก์ชันหลังการประมวลผล "ผู้ใช้" กำหนดไว้

  4. ไปที่ UI โปรแกรมจำลองฐานข้อมูล และแก้ไขโหนดรากของฐานข้อมูลโดยใช้ เส้นทางที่คุณกำหนดข้างต้น:

    • ฟิลด์:msgs
    • ประเภท: json
    • ค่า: {"11": {"original": "recipe"}}

    เมื่อบันทึกการเปลี่ยนแปลงฐานข้อมูล makeuppercaseของส่วนขยาย และฟังก์ชัน extraemphasis ของผู้ใช้ควรทริกเกอร์ตามลำดับ ซึ่งจะทำให้ฟิลด์ upper ได้รับค่า RECIPE!!!

8. เพิ่มเครื่องจัดการเหตุการณ์อายุการใช้งาน

ส่วนขยายที่คุณเขียนไว้จะประมวลผลข้อความตามที่สร้างขึ้น แต่ ถ้าผู้ใช้ของคุณมีฐานข้อมูลข้อความอยู่แล้วเมื่อติดตั้ง ในส่วนขยายใด Firebase Extensions มีฟีเจอร์ที่เรียกว่าฮุกเหตุการณ์เกี่ยวกับวงจร ซึ่ง ที่คุณสามารถใช้เพื่อทริกเกอร์การทำงานเมื่อมีการติดตั้ง อัปเดตส่วนขยาย หรือ กำหนดค่าใหม่หรือไม่ ในส่วนนี้ คุณจะใช้ฮุกเหตุการณ์เกี่ยวกับวงจรในการทดแทนข้อมูล ฐานข้อมูลข้อความที่มีอยู่ของโปรเจ็กต์ด้วยข้อความตัวพิมพ์ใหญ่เมื่อผู้ใช้ ติดตั้งส่วนขยาย

Firebase Extensions ใช้ Cloud Tasks เพื่อเรียกใช้เครื่องจัดการเหตุการณ์ตลอดอายุการใช้งานของคุณ คุณ กำหนดตัวแฮนเดิลเหตุการณ์โดยใช้ Cloud Functions เมื่อใดก็ตามที่อินสแตนซ์ ส่วนขยายจะไปถึงหนึ่งในเหตุการณ์ในวงจรที่รองรับหากคุณกำหนด ก็จะเพิ่มตัวจัดการไปยังคิว Cloud Tasks จากนั้น Cloud Tasks จะ เรียกใช้ตัวแฮนเดิลแบบไม่พร้อมกัน ขณะที่เครื่องจัดการเหตุการณ์อายุการใช้งานทำงานอยู่ คอนโซล Firebase จะรายงานให้ผู้ใช้ทราบว่าอินสแตนซ์ของส่วนขยายมีแอตทริบิวต์ กำลังดำเนินการประมวลผล ขึ้นอยู่กับฟังก์ชันของตัวแฮนเดิลที่จะรายงานการที่ต่อเนื่อง สถานะและงานที่ทำเสร็จแล้วให้กับผู้ใช้

ในการเพิ่มเครื่องจัดการเหตุการณ์อายุการใช้งานซึ่งจะทดแทนข้อความที่มีอยู่ ให้ทำ ดังต่อไปนี้:

  1. กำหนด Cloud Function ใหม่ที่ทริกเกอร์โดยเหตุการณ์ในคิวงาน ดังนี้

    functions/index.js

    import { tasks } from "firebase-functions/v1";

import { getDatabase } from "firebase-admin/database";
import { getExtensions } from "firebase-admin/extensions";
import { getFunctions } from "firebase-admin/functions";

export const backfilldata = tasks.taskQueue().onDispatch(async () => {
  const batch = await getDatabase()
    .ref(process.env.MESSAGE_PATH)
    .parent.parent.orderByChild("upper")
    .limitToFirst(20)
    .get();

  const promises = [];
  for (const key in batch.val()) {
    const msg = batch.child(key);
    if (msg.hasChild("original") && !msg.hasChild("upper")) {
      const upper = msg.child("original").val().toUpperCase();
      promises.push(msg.child("upper").ref.set(upper));
    }
  }
  await Promise.all(promises);

  if (promises.length > 0) {
    const queue = getFunctions().taskQueue(
      "backfilldata",
      process.env.EXT_INSTANCE_ID
    );
    return queue.enqueue({});
  } else {
    return getExtensions()
      .runtime()
      .setProcessingState("PROCESSING_COMPLETE", "Backfill complete.");
  }
});

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

  2. ในไฟล์ extension.yaml ให้ประกาศฟังก์ชันโฆษณาทดแทนเป็นส่วนขยาย ทรัพยากรที่มีพร็อพเพอร์ตี้ taskQueueTrigger:

    resources:
  - name: makeuppercase
    ...
  - name: backfilldata
    type: firebaseextensions.v1beta.function
    description: >-
      Backfill existing messages with uppercase versions
    properties:
      runtime: "nodejs18"
      taskQueueTrigger: {}

    แล้วประกาศฟังก์ชันเป็นตัวแฮนเดิลสําหรับวงจรการใช้งาน onInstall กิจกรรม:

    lifecycleEvents:
  onInstall:
    function: backfilldata
    processingMessage: Uppercasing existing messages

  3. ถึงแม้ว่าการทดแทนข้อความที่มีอยู่แล้วจะดี แต่ส่วนขยาย ก็ยังคงทำงานได้โดยไม่มีเครื่องมือนี้ ในสถานการณ์เช่นนี้ คุณควรวิ่ง เครื่องจัดการเหตุการณ์อายุการใช้งานจะไม่บังคับ

    ในการดำเนินการดังกล่าว ให้เพิ่มพารามิเตอร์ใหม่ลงใน extension.yaml:

    - param: DO_BACKFILL
  label: Backfill existing messages
  description: >-
    Generate uppercase versions of existing messages?
  type: select
  required: true
  options:
    - label: Yes
      value: true
    - label: No
      value: false

    จากนั้นที่จุดเริ่มต้นของฟังก์ชันโฆษณาทดแทน ให้ตรวจสอบค่าของฟิลด์ DO_BACKFILL และออกก่อนเวลาหากไม่ได้ตั้งค่าไว้:

    functions/index.js

    if (!process.env.DO_BACKFILL) {
  return getExtensions()
    .runtime()
    .setProcessingState("PROCESSING_COMPLETE", "Backfill skipped.");
}

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

ถึงตอนนี้ คุณได้ใช้โปรแกรมจำลองส่วนขยายเพื่อพัฒนาส่วนขยายและ ทดสอบการเปลี่ยนแปลงที่ดำเนินอยู่ แต่โปรแกรมจำลองส่วนขยายจะข้ามการติดตั้ง กระบวนการ ดังนั้นในการทดสอบเครื่องจัดการเหตุการณ์ onInstall คุณจะต้องติดตั้ง ในโครงการจริง ก็เหมือนกัน เนื่องจากการเพิ่ม ของฟีเจอร์โฆษณาทดแทนอัตโนมัตินี้ ตอนนี้ส่วนขยายบทแนะนำก็เสร็จสมบูรณ์โค้ดแล้ว

9. ทำให้ใช้งานได้ในโปรเจ็กต์ Firebase จริง

แม้ว่าโปรแกรมจำลองส่วนขยายจะเป็นเครื่องมือที่ดีเยี่ยมในการปรับเปลี่ยน ในระหว่างการพัฒนา ในบางครั้งคุณก็อาจจะลองใช้

เริ่มจากตั้งค่าโปรเจ็กต์ใหม่ที่เปิดใช้บริการบางอย่างก่อน

  1. ในคอนโซล Firebase ให้เพิ่ม
  2. อัปเกรดโปรเจ็กต์ ด้วยแพ็กเกจ Blaze แบบจ่ายเมื่อใช้ Cloud Functions for Firebase จำเป็นต้องใช้ มีบัญชีสำหรับการเรียกเก็บเงิน ดังนั้นคุณต้องมีบัญชีสำหรับการเรียกเก็บเงินด้วย ติดตั้งส่วนขยาย
  3. ในโปรเจ็กต์ใหม่ ให้เปิดใช้ฐานข้อมูลแบบเรียลไทม์
  4. เนื่องจากคุณต้องการทดสอบความสามารถของส่วนขยายในการทดแทนข้อมูลที่มีอยู่ ให้นำเข้าข้อมูลตัวอย่างบางส่วนไปยังอินสแตนซ์ฐานข้อมูลแบบเรียลไทม์ ดังนี้
    1. ดาวน์โหลดข้อมูล Seed RTDB บางส่วน
    2. ในหน้าฐานข้อมูลแบบเรียลไทม์ของคอนโซล Firebase ให้คลิก (เพิ่มเติม) > นำเข้า JSON แล้วเลือกไฟล์ที่คุณเพิ่งดาวน์โหลด

  5. หากต้องการเปิดฟังก์ชันโฆษณาทดแทนเพื่อใช้เมธอด orderByChild ให้กําหนดค่า ฐานข้อมูลที่จะจัดทำดัชนีข้อความในค่าของ upper:

    {
  "rules": {
    ".read": false,
    ".write": false,
    "messages": {
      ".indexOn": "upper"
    }
  }
}

ตอนนี้ให้ติดตั้งส่วนขยายจากแหล่งที่มาในเครื่องลงในโปรเจ็กต์ใหม่ด้วยคำสั่งต่อไปนี้

  1. สร้างไดเรกทอรีใหม่สำหรับโปรเจ็กต์ Firebase โดยใช้คำสั่งต่อไปนี้

    mkdir ~/extensions-live-test && cd ~/extensions-live-test

  2. เริ่มต้นโปรเจ็กต์ Firebase ในไดเรกทอรีที่ใช้งานอยู่ ดังนี้

    firebase init database

    เมื่อมีข้อความแจ้ง ให้เลือกโปรเจ็กต์ที่คุณเพิ่งสร้าง

  3. ติดตั้งส่วนขยายลงในโปรเจ็กต์ Firebase ในเครื่อง โดยทำดังนี้

    firebase ext:install /path/to/rtdb-uppercase-messages

    ในหน้านี้คุณจะเห็นว่าประสบการณ์ของผู้ใช้เป็นอย่างไรเมื่อติดตั้ง โดยใช้เครื่องมือ Firebase CLI ตรวจสอบว่าได้เลือก "ใช่" เมื่อ เครื่องมือกำหนดค่าจะถามว่าคุณต้องการทดแทนข้อมูลฐานข้อมูลที่มีอยู่หรือไม่

    หลังจากที่คุณเลือกตัวเลือกการกำหนดค่า Firebase CLI จะบันทึก ในไดเรกทอรี extensions และบันทึกแหล่งที่มาของส่วนขยาย ตำแหน่งในไฟล์ firebase.json บันทึก 2 รายการนี้เมื่อรวมกันแล้ว ซึ่งเรียกว่าไฟล์ Manifest ของส่วนขยาย ผู้ใช้สามารถใช้ไฟล์ Manifest เพื่อบันทึกไฟล์ กำหนดค่าส่วนขยายและทำให้ใช้งานได้ในโครงการอื่น

  4. ทำให้การกำหนดค่าส่วนขยายใช้งานได้กับโปรเจ็กต์ที่เผยแพร่อยู่ โดยทำดังนี้

    firebase deploy --only extensions

หากทุกอย่างเป็นไปด้วยดี Firebase CLI ควรอัปโหลดส่วนขยายไปยังโปรเจ็กต์ของคุณ แล้วติดตั้ง หลังจากการติดตั้งเสร็จสมบูรณ์ งานทดแทนจะทำงานและใน ในอีกไม่กี่นาที ฐานข้อมูลของคุณจะได้รับการอัปเดตด้วยข้อความตัวพิมพ์ใหญ่ เพิ่มบางส่วน โหนดใหม่ไปยังฐานข้อมูลข้อความและตรวจสอบว่าส่วนขยายใช้งานได้ เพื่อดูข้อความใหม่

10. เขียนเอกสารประกอบ

ก่อนแชร์ส่วนขยายกับผู้ใช้ อย่าลืมระบุให้เพียงพอ ในการทำงานให้สำเร็จลุล่วง

เมื่อคุณเริ่มต้นโปรเจ็กต์ส่วนขยาย Firebase CLI จะสร้างสตับ เอกสารขั้นต่ำที่จำเป็น อัปเดตไฟล์เหล่านี้ให้ถูกต้องแม่นยำ แสดงส่วนขยายที่คุณสร้างขึ้น

extensions.yaml

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

อย่างไรก็ตาม อย่ามองข้ามความสำคัญของเอกสารประกอบที่มีอยู่ในเอกสารนี้ นอกเหนือจากข้อมูลระบุตัวตนที่สำคัญของส่วนขยายแล้ว เช่น ชื่อ คำอธิบาย ผู้แต่ง ตำแหน่งที่เก็บอย่างเป็นทางการ - extension.yaml ไฟล์มีเอกสารที่แสดงต่อผู้ใช้สำหรับทรัพยากรทั้งหมดและที่ผู้ใช้กำหนดค่าได้ พารามิเตอร์ ข้อมูลนี้จะปรากฏต่อผู้ใช้ในคอนโซล Firebase Extensions Hub และ Firebase CLI

PREINSTALL.md

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

ข้อความของไฟล์นี้จะปรากฏต่อผู้ใช้ในฮับส่วนขยายและโดย คำสั่ง firebase ext:info

ต่อไปนี้คือตัวอย่างของไฟล์ PREINSTALL

Use this extension to automatically convert strings to upper case when added to
a specified Realtime Database path.

This extension expects a database layout like the following example:

    "messages": {
      MESSAGE_ID: {
        "original": MESSAGE_TEXT
      },
      MESSAGE_ID: {
        "original": MESSAGE_TEXT
      },
    }

When you create new string records, this extension creates a new sibling record
with upper-cased text:

    MESSAGE_ID: {
      "original": MESSAGE_TEXT,
      "upper": UPPERCASE_MESSAGE_TEXT,
    }

#### Additional setup

Before installing this extension, make sure that you've
[set up Realtime Database](https://firebase.google.com/docs/database/quickstart)
in your Firebase project.

#### Billing

To install an extension, your project must be on the
[Blaze (pay as you go) plan](https://firebase.google.com/pricing).

- This extension uses other Firebase and Google Cloud Platform services, which
  have associated charges if you exceed the service's no-cost tier:
  - Realtime Database
  - Cloud Functions (Node.js 10+ runtime)
    [See FAQs](https://firebase.google.com/support/faq#extensions-pricing)
- If you enable events,
  [Eventarc fees apply](https://cloud.google.com/eventarc/pricing).

POSTINSTALL.md

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

เนื้อหาของ POSTINSTALL.md จะแสดงในคอนโซล Firebase หลังจาก มีการกำหนดค่าและติดตั้งส่วนขยายแล้ว คุณสามารถอ้างอิงพารามิเตอร์ผู้ใช้ใน และจะถูกแทนที่ด้วยค่าที่กำหนดค่าไว้

ต่อไปนี้คือตัวอย่างไฟล์หลังการติดตั้งสำหรับส่วนขยายบทแนะนำ

### See it in action

You can test out this extension right away!

1.  Go to your
    [Realtime Database dashboard](https://console.firebase.google.com/project/${param:PROJECT_ID}/database/${param:PROJECT_ID}/data) in the Firebase console.

1.  Add a message string to a path that matches the pattern `${param:MESSAGE_PATH}`.

1.  In a few seconds, you'll see a sibling node named `upper` that contains the
    message in upper case.

### Using the extension

We recommend adding data by pushing -- for example,
`firebase.database().ref().push()` -- because pushing assigns an automatically
generated ID to the node in the database. During retrieval, these nodes are
guaranteed to be ordered by the time they were added. Learn more about reading
and writing data for your platform (iOS, Android, or Web) in the
[Realtime Database documentation](https://firebase.google.com/docs/database/).

### Monitoring

As a best practice, you can
[monitor the activity](https://firebase.google.com/docs/extensions/manage-installed-extensions#monitor)
of your installed extension, including checks on its health, usage, and logs.

CHANGELOG.md

คุณควรบันทึกการเปลี่ยนแปลงที่ทำกับส่วนขยายรุ่นต่างๆ ด้วย ในไฟล์ CHANGELOG.md

เนื่องจากส่วนขยายตัวอย่างยังไม่เคยมีการเผยแพร่มาก่อน บันทึกการเปลี่ยนแปลงจึง เพียงรายการเดียว ได้แก่

## Version 0.0.1

Initial release of the _Convert messages to upper case_ extension.

README.md

ส่วนขยายส่วนใหญ่ยังมีไฟล์ Readme ให้เพื่อประโยชน์สำหรับผู้ใช้ที่เข้าชมเว็บไซต์ ที่เก็บของส่วนขยาย คุณจะเขียนไฟล์นี้ด้วยตนเองหรือสร้าง "อ่านให้ฉันฟัง" ก็ได้ โดยใช้คำสั่ง

สำหรับคู่มือนี้ ให้ข้ามการเขียนไฟล์ Readme

เอกสารประกอบเพิ่มเติม

เอกสารที่กล่าวถึงข้างต้นเป็นชุดเอกสารขั้นต่ำที่คุณควร ให้แก่ผู้ใช้ ส่วนขยายจำนวนมากต้องใช้เอกสารประกอบที่ละเอียดมากขึ้นเพื่อให้ผู้ใช้ ได้สำเร็จ ในกรณีเช่นนี้ คุณควรเขียน และโฮสต์เอกสารดังกล่าวไว้ในที่ที่คุณจะแนะนำให้ผู้ใช้ไปได้

สำหรับคู่มือนี้ ให้ข้ามการเขียนเอกสารประกอบที่ครอบคลุมยิ่งขึ้น

11. เผยแพร่ในฮับส่วนขยาย

เมื่อส่วนขยายเสร็จสมบูรณ์และจัดทำเอกสารแล้ว คุณก็พร้อมที่จะแชร์ กับผู้คนทั่วโลกได้ในฮับส่วนขยาย เนื่องจากนี่เป็นเพียงบทแนะนำ โปรดอย่า ทำแบบนั้นได้จริงๆ เริ่มเขียนส่วนขยายของคุณเอง โดยใช้สิ่งที่คุณมี และในส่วนที่เหลือของเอกสาร สำหรับผู้เผยแพร่โฆษณา Firebase Extensions และโดยการตรวจสอบแหล่งที่มาของส่วนขยายอย่างเป็นทางการที่ Firebase เขียนขึ้น

เมื่อพร้อมที่จะเผยแพร่ผลงานในฮับส่วนขยายแล้ว ให้ทำดังนี้ ดังนี้

  1. หากคุณกำลังเผยแพร่ส่วนขยายแรก ลงทะเบียนเป็นผู้เผยแพร่ส่วนขยาย วันและเวลา ซึ่งคุณได้ลงทะเบียนเป็นผู้เผยแพร่ส่วนขยาย จะเป็นการสร้างรหัสผู้เผยแพร่โฆษณาที่ช่วยให้ ผู้ใช้ก็จะระบุได้อย่างรวดเร็วว่าคุณเป็นผู้เขียนส่วนขยาย

  2. โฮสต์ซอร์สโค้ดของส่วนขยายในตำแหน่งที่สาธารณะยืนยันได้ วันและเวลา โค้ดของคุณพร้อมใช้งานจากแหล่งที่มาที่ยืนยันได้ Firebase สามารถเผยแพร่ จากสถานที่ตั้งนี้ได้โดยตรง การทำเช่นนี้ช่วยให้มั่นใจได้ว่าคุณ เผยแพร่ส่วนขยายเวอร์ชันที่เผยแพร่อยู่ในปัจจุบัน และช่วยเหลือผู้ใช้ โดยอนุญาตให้ตรวจสอบโค้ดที่กำลังจะติดตั้งในโปรเจ็กต์

    ซึ่งในตอนนี้หมายความว่าการทำให้ส่วนขยายของคุณพร้อมใช้งานใน GitHub สาธารณะ ที่เก็บได้

  3. อัปโหลดส่วนขยายไปยังฮับส่วนขยายโดยใช้ firebase ext:dev:upload คำสั่ง

  4. ไปที่หน้าแดชบอร์ดของผู้เผยแพร่โฆษณาในคอนโซล Firebase ค้นหาส่วนขยาย ที่คุณเพิ่งอัปโหลดไป จากนั้นคลิก "เผยแพร่ไปยังฮับส่วนขยาย" การดำเนินการนี้ขอรับ รีวิวจากเจ้าหน้าที่ตรวจสอบ ซึ่งอาจใช้เวลา 2-3 วัน หากได้รับอนุมัติ พารามิเตอร์ ส่วนขยายจะได้รับการเผยแพร่ไปยังฮับส่วนขยาย หากถูกปฏิเสธ คุณจะได้รับ ข้อความอธิบายเหตุผล คุณสามารถแก้ไขปัญหาที่รายงานเข้ามา และ ส่งเข้ารับการตรวจสอบอีกครั้ง