Catch up on everything announced at Firebase Summit, and learn how Firebase can help you accelerate app development and run your app with confidence. Learn More

จัดการฟังก์ชั่น

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

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

ปรับใช้ฟังก์ชัน

ในการปรับใช้ฟังก์ชัน ให้รันคำสั่ง Firebase CLI นี้:

firebase deploy --only functions

โดยค่าเริ่มต้น Firebase CLI จะปรับใช้ฟังก์ชันทั้งหมดภายใน index.js พร้อมกัน หากโปรเจ็กต์ของคุณมีมากกว่า 5 ฟังก์ชัน เราขอแนะนำให้คุณใช้แฟล็ก --only ที่มีชื่อฟังก์ชันเฉพาะเพื่อปรับใช้เฉพาะฟังก์ชันที่คุณแก้ไข การปรับใช้ฟังก์ชันเฉพาะ ด้วยวิธีนี้จะช่วยเพิ่มความเร็วในกระบวนการปรับใช้และช่วยให้คุณหลีกเลี่ยงการใช้งานโควตาการปรับใช้ ตัวอย่างเช่น:

firebase deploy --only functions:addMessage,functions:makeUppercase

เมื่อปรับใช้ฟังก์ชันจำนวนมาก คุณอาจเกินโควต้ามาตรฐานและได้รับข้อความแสดงข้อผิดพลาด HTTP 429 หรือ 500 ในการแก้ปัญหานี้ ให้ปรับใช้ฟังก์ชันในกลุ่มที่มีไม่เกิน 10 คน

ดู ข้อมูลอ้างอิง Firebase CLI สำหรับรายการคำสั่งทั้งหมดที่มี

โดยค่าเริ่มต้น Firebase CLI จะค้นหาซอร์สโค้ดใน functions/ โฟลเดอร์ หากต้องการ คุณสามารถ จัดระเบียบฟังก์ชัน ในโค้ดเบสหรือไฟล์หลายชุดได้

ลบฟังก์ชัน

คุณสามารถลบฟังก์ชันที่ปรับใช้ก่อนหน้านี้ด้วยวิธีเหล่านี้:

  • อย่างชัดเจน ใน Firebase CLI ด้วย functions:delete
  • อย่างชัดเจน ใน Google Cloud Console
  • โดย ปริยาย โดยการลบฟังก์ชันออกจาก index.js ก่อนทำการปรับใช้

การดำเนินการลบทั้งหมดจะแจ้งให้คุณยืนยันก่อนที่จะลบฟังก์ชันออกจากการผลิต

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

# Delete all functions that match the specified name in all regions.
firebase functions:delete myFunction
# Delete a specified function running in a specific region.
firebase functions:delete myFunction --region us-east-1
# Delete more than one function
firebase functions:delete myFunction myOtherFunction
# Delete a specified functions group.
firebase functions:delete groupA
# Bypass the confirmation prompt.
firebase functions:delete myFunction --force

ด้วยการลบฟังก์ชันโดยปริยาย firebase deploy parses index.js และนำฟังก์ชันใดๆ ที่ถูกลบออกจากไฟล์ออกจากการผลิต

แก้ไขชื่อ ภูมิภาค หรือทริกเกอร์ของฟังก์ชัน

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

เปลี่ยนชื่อฟังก์ชัน

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

// before
const functions = require('firebase-functions');

exports.webhook = functions.https.onRequest((req, res) => {
    res.send("Hello");
});

// after
const functions = require('firebase-functions');

exports.webhookNew = functions.https.onRequest((req, res) => {
    res.send("Hello");
});

จากนั้นรันคำสั่งต่อไปนี้เพื่อปรับใช้ฟังก์ชันใหม่:

# Deploy new function called webhookNew
firebase deploy --only functions:webhookNew

# Wait until deployment is done; now both webhookNew and webhook are running

# Delete webhook
firebase functions:delete webhook

เปลี่ยนขอบเขตหรือภูมิภาคของฟังก์ชัน

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

  1. เปลี่ยนชื่อฟังก์ชัน และเปลี่ยนภูมิภาคหรือภูมิภาคตามต้องการ
  2. ปรับใช้ฟังก์ชันที่เปลี่ยนชื่อ ซึ่งส่งผลให้มีการเรียกใช้โค้ดเดียวกันชั่วคราวในทั้งสองชุดของภูมิภาค
  3. ลบฟังก์ชันก่อนหน้า

ตัวอย่างเช่น หากคุณมีฟังก์ชันที่เรียกว่า webhook ซึ่งขณะนี้อยู่ในขอบเขตฟังก์ชันเริ่มต้นของ us-central1 และคุณต้องการย้ายไปยัง asia-northeast1 คุณต้องแก้ไขซอร์สโค้ดของคุณเพื่อเปลี่ยนชื่อฟังก์ชันและแก้ไขพื้นที่ก่อน .

// before
const functions = require('firebase-functions');

exports.webhook = functions
    .https.onRequest((req, res) => {
            res.send("Hello");
    });

// after
const functions = require('firebase-functions');

exports.webhookAsia = functions
    .region('asia-northeast1')
    .https.onRequest((req, res) => {
            res.send("Hello");
    });

จากนั้นปรับใช้โดยเรียกใช้:

firebase deploy --only functions:webhookAsia

ขณะนี้มีสองฟังก์ชันที่เหมือนกันที่ทำงานอยู่: webhook กำลังทำงานใน us-central1 และ webhookAsia กำลังทำงานใน asia-northeast1

จากนั้นลบ webhook :

firebase functions:delete webhook

ขณะนี้มีฟังก์ชันเดียวคือ webhookAsia ซึ่งทำงานใน asia-northeast1

เปลี่ยนประเภททริกเกอร์ของฟังก์ชัน

เมื่อคุณพัฒนาการใช้งาน Cloud Functions for Firebase เมื่อเวลาผ่านไป คุณอาจต้องเปลี่ยนประเภททริกเกอร์ของฟังก์ชันด้วยเหตุผลหลายประการ ตัวอย่างเช่น คุณอาจต้องการ:

  • เปลี่ยนจากเหตุการณ์ onChange ที่เก็บข้อมูลดั้งเดิมเป็น onFinalize , onDelete , onArchive และ onMetadataUpdate (เรียนรู้เพิ่มเติมเกี่ยวกับสิ่งนี้ใน คู่มือการอัปเกรดเบต้าเป็น v1 หรือ v2 )
  • เปลี่ยนจากเหตุการณ์ Firebase Realtime Database หรือ Cloud Firestore ประเภทหนึ่งไปเป็นอีกประเภทหนึ่ง เช่น เหตุการณ์ onWrite ทั่วไปเป็นเหตุการณ์ onCreate แบบละเอียด

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

  1. แก้ไขซอร์สโค้ดเพื่อรวมฟังก์ชันใหม่กับประเภททริกเกอร์ที่ต้องการ
  2. ปรับใช้ฟังก์ชัน ซึ่งส่งผลให้มีการเรียกใช้ทั้งฟังก์ชันเก่าและใหม่ชั่วคราว
  3. ลบฟังก์ชันเก่าออกจากการใช้งานจริงอย่างชัดเจนโดยใช้ Firebase CLI

ตัวอย่างเช่น หากคุณมีฟังก์ชัน objectChanged ที่มีประเภทเหตุการณ์ onChange ดั้งเดิม และคุณต้องการเปลี่ยนเป็น onFinalize ก่อนอื่นให้เปลี่ยนชื่อฟังก์ชันและแก้ไขเพื่อให้มีประเภทเหตุการณ์ onFinalize

// before
const functions = require('firebase-functions');

exports.objectChanged = functions.storage.object().onChange((object) => {
    return console.log('File name is: ', object.name);
});

// after
const functions = require('firebase-functions');

exports.objectFinalized = functions.storage.object().onFinalize((object) => {
    return console.log('File name is: ', object.name);
});

จากนั้นรันคำสั่งต่อไปนี้เพื่อสร้างฟังก์ชันใหม่ก่อน ก่อนลบฟังก์ชันเก่า:

# Create new function objectFinalized
firebase deploy --only functions:objectFinalized

# Wait until deployment is done; now both objectChanged and objectFinalized are running

# Delete objectChanged
firebase functions:delete objectChanged

ตั้งค่าตัวเลือกรันไทม์

Cloud Functions for Firebase ให้คุณเลือกตัวเลือกรันไทม์ เช่น เวอร์ชันรันไทม์ Node.js และการหมดเวลาต่อฟังก์ชัน การจัดสรรหน่วยความจำ และอินสแตนซ์ของฟังก์ชันต่ำสุด/สูงสุด

ตามแนวทางปฏิบัติที่ดีที่สุด ควรตั้งค่าตัวเลือกเหล่านี้ (ยกเว้นเวอร์ชัน Node.js) บนออบเจ็กต์การกำหนดค่าภายในโค้ดฟังก์ชัน ออบเจ็กต์ RuntimeOptions นี้เป็นแหล่งที่มาของความจริงสำหรับตัวเลือกรันไทม์ของฟังก์ชัน และจะแทนที่ตัวเลือกที่ตั้งค่าไว้โดยใช้วิธีอื่น (เช่น ผ่านคอนโซล Google Cloud หรือ gcloud CLI)

หากเวิร์กโฟลว์การพัฒนาของคุณเกี่ยวข้องกับการตั้งค่าตัวเลือกรันไทม์ด้วยตนเองผ่านคอนโซล Google Cloud หรือ gcloud CLI และคุณ ไม่ ต้องการให้ค่าเหล่านี้ถูกแทนที่ในการปรับใช้แต่ละครั้ง ให้ตั้งค่าตัวเลือก preserveExternalChanges true ด้วยตัวเลือกนี้ที่ตั้งค่า true Firebase จะรวมตัวเลือกรันไทม์ที่ตั้งค่าไว้ในโค้ดของคุณเข้ากับการตั้งค่าของเวอร์ชันที่ใช้งานในปัจจุบันของฟังก์ชันของคุณโดยมีลำดับความสำคัญดังต่อไปนี้:

  1. ตัวเลือกถูกตั้งค่าในโค้ดฟังก์ชัน: แทนที่การเปลี่ยนแปลงภายนอก
  2. ตัวเลือกถูกตั้งค่าเป็น RESET_VALUE ในโค้ดฟังก์ชัน: แทนที่การเปลี่ยนแปลงภายนอกด้วยค่าเริ่มต้น
  3. ไม่ได้ตั้งค่าตัวเลือกในโค้ดฟังก์ชัน แต่มีการตั้งค่าในฟังก์ชันที่ใช้งานในปัจจุบัน: ใช้ตัวเลือกที่ระบุในฟังก์ชันที่ปรับใช้

การใช้ตัวเลือก preserveExternalChanges: true ไม่แนะนำ สำหรับสถานการณ์ส่วนใหญ่ เนื่องจากโค้ดของคุณจะไม่ใช่แหล่งความจริงทั้งหมดสำหรับตัวเลือกรันไทม์สำหรับฟังก์ชันของคุณอีกต่อไป หากคุณใช้งาน ให้ตรวจสอบคอนโซล Google Cloud หรือใช้ gcloud CLI เพื่อดูการกำหนดค่าทั้งหมดของฟังก์ชัน

ตั้งค่า Node.js เวอร์ชัน

Firebase SDK สำหรับ Cloud Functions 2.0.0 และสูงกว่าอนุญาตให้เลือกรันไทม์ Node.js คุณสามารถเลือกที่จะเรียกใช้ฟังก์ชันทั้งหมดในโปรเจ็กต์โดยเฉพาะบนสภาพแวดล้อมรันไทม์ที่สอดคล้องกับหนึ่งในเวอร์ชัน Node.js ที่รองรับเหล่านี้:

  • Node.js 16
  • Node.js 14

การตั้งค่าเวอร์ชัน Node.js:

ตั้งค่าเวอร์ชันในช่อง package.json engines สร้างขึ้นในไดเร็กทอรี functions/ ของคุณระหว่างการเริ่มต้น ตัวอย่างเช่น หากต้องการใช้เฉพาะเวอร์ชัน 16 ให้แก้ไขบรรทัดนี้ใน package.json :

  "engines": {"node": "16"}

ต้องระบุฟิลด์ engines ต้อง ระบุหนึ่งในเวอร์ชัน Node.js ที่รองรับเพื่อให้คุณปรับใช้และเรียกใช้ฟังก์ชันได้ firebase init functions ในปัจจุบันตั้งค่าฟิลด์นี้เป็น 16

อัปเกรดรันไทม์ Node.js ของคุณ

วิธีอัปเกรดรันไทม์ Node.js ของคุณ:

  1. ตรวจสอบให้แน่ใจว่าโครงการของคุณอยู่ใน แผนการกำหนดราคา Blaze
  2. ตรวจสอบให้แน่ใจว่าคุณใช้ Firebase CLI v9.17.0 หรือใหม่กว่า
  3. เปลี่ยนค่า package.json engines สร้างขึ้นในไดเร็กทอรี functions/ ของคุณในระหว่างการเริ่มต้น ตัวอย่างเช่น หากคุณกำลังอัปเกรดจากเวอร์ชัน 10 เป็นเวอร์ชัน 16 รายการควรมีลักษณะดังนี้: "engines": {"node": "16"}
  4. ทางเลือก ทดสอบการเปลี่ยนแปลงของคุณโดยใช้ Firebase Local Emulator Suite
  5. ปรับใช้ฟังก์ชันใหม่โดยใช้ Firebase CLI v9.17.0 หรือใหม่กว่า

ควบคุมพฤติกรรมการปรับขนาด

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

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

ลดจำนวนการสตาร์ทเย็น

ในการตั้งค่าจำนวนอินสแตนซ์ขั้นต่ำสำหรับฟังก์ชันในซอร์สโค้ด ให้ใช้เมธอด runWith เมธอดนี้ยอมรับอ็อบเจ็กต์ JSON ที่สอดคล้องกับอินเทอร์เฟซ RuntimeOptions ซึ่งกำหนดค่าสำหรับ minInstances ตัวอย่างเช่น ฟังก์ชันนี้จะตั้งค่าอินสแตนซ์อย่างน้อย 5 รายการเพื่อให้อบอุ่น:

exports.getAutocompleteResponse = functions
    .runWith({
      // Keep 5 instances warm for this latency-critical function
      minInstances: 5,
    })
    .https.onCall((data, context) => {
      // Autocomplete a user's search term
    });

ต่อไปนี้คือสิ่งที่ควรพิจารณาเมื่อตั้งค่า minInstances :

  • หาก Cloud Functions for Firebase ปรับขนาดแอปของคุณให้สูงกว่าการตั้งค่า minInstances คุณจะพบกับ Cold Start สำหรับแต่ละอินสแตนซ์ที่สูงกว่าเกณฑ์นั้น
  • การสตาร์ทแบบเย็นมีผลรุนแรงที่สุดกับแอปที่มีการจราจรติดขัด หากแอปของคุณมีทราฟฟิกที่แหลมคม และคุณตั้งค่า minInstances สูงพอที่จะทำให้การเริ่มเย็นลงในแต่ละการเข้าชมที่เพิ่มขึ้น คุณจะเห็นเวลาแฝงที่ลดลงอย่างมาก สำหรับแอปที่มีปริมาณการใช้งานคงที่ การสตาร์ทแบบเย็นจะไม่ส่งผลกระทบอย่างรุนแรงต่อประสิทธิภาพการทำงาน
  • การตั้งค่าอินสแตนซ์ขั้นต่ำอาจเหมาะสมสำหรับสภาพแวดล้อมการใช้งานจริง แต่โดยปกติควรหลีกเลี่ยงในสภาพแวดล้อมการทดสอบ หากต้องการปรับขนาดเป็นศูนย์ในโปรเจ็กต์ทดสอบของคุณ แต่ยังคงลดการเริ่มเย็นในโปรเจ็กต์ที่ใช้งานจริงของคุณ คุณสามารถตั้งค่า minInstances ตามตัวแปรสภาพแวดล้อม FIREBASE_CONFIG :

    // Get Firebase project id from `FIREBASE_CONFIG` environment variable
    const envProjectId = JSON.parse(process.env.FIREBASE_CONFIG).projectId;
    
    exports.renderProfilePage = functions
        .runWith({
          // Keep 5 instances warm for this latency-critical function
          // in production only. Default to 0 for test projects.
          minInstances: envProjectId === "my-production-project" ? 5 : 0,
        })
        .https.onRequest((req, res) => {
          // render some html
        });
    

จำกัดจำนวนอินสแตนซ์สูงสุดสำหรับฟังก์ชัน

ในการตั้งค่าอินสแตนซ์สูงสุดในซอร์สโค้ดของฟังก์ชัน ให้ใช้เมธอด runWith เมธอดนี้ยอมรับอ็อบเจ็กต์ JSON ที่สอดคล้องกับอินเทอร์เฟซ RuntimeOptions ซึ่งกำหนดค่าสำหรับ maxInstances ตัวอย่างเช่น ฟังก์ชันนี้กำหนดขีดจำกัด 100 อินสแตนซ์เพื่อไม่ให้เกินฐานข้อมูลดั้งเดิมที่สมมุติฐาน:

exports.mirrorOrdersToLegacyDatabase = functions
    .runWith({
      // Legacy database only supports 100 simultaneous connections
      maxInstances: 100,
    })
    .firestore.document("orders/{orderId}")
    .onWrite((change, context) => {
      // Connect to legacy database
    });

หากฟังก์ชัน HTTP ถูกปรับขนาดจนถึงขีดจำกัด maxInstances คำขอใหม่จะถูกจัดคิวเป็นเวลา 30 วินาที จากนั้นจึงปฏิเสธด้วยรหัสตอบกลับ 429 Too Many Requests หากไม่มีอินสแตนซ์พร้อมใช้งานในขณะนั้น

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับแนวทางปฏิบัติที่ดีที่สุดสำหรับการใช้การตั้งค่าอินสแตนซ์สูงสุด โปรดดู แนวทางปฏิบัติที่ดีที่สุดสำหรับการใช้ maxInstances

ตั้งค่าการหมดเวลาและการจัดสรรหน่วยความจำ

ในบางกรณี ฟังก์ชันของคุณอาจมีข้อกำหนดพิเศษสำหรับค่าระยะหมดเวลานานหรือการจัดสรรหน่วยความจำขนาดใหญ่ คุณตั้งค่าเหล่านี้ได้ใน Google Cloud Console หรือในซอร์สโค้ดของฟังก์ชัน (Firebase เท่านั้น)

ในการตั้งค่าการจัดสรรหน่วยความจำและการหมดเวลาในซอร์สโค้ดของฟังก์ชัน ให้ใช้พารามิเตอร์ runWith ที่แนะนำใน Firebase SDK สำหรับ Cloud Functions 2.0.0 ตัวเลือกรันไทม์นี้ยอมรับอ็อบเจ็กต์ JSON ที่สอดคล้องกับอินเทอร์เฟซ RuntimeOptions ซึ่งกำหนดค่าสำหรับ timeoutSeconds และ memory ตัวอย่างเช่น ฟังก์ชันการจัดเก็บข้อมูลนี้ใช้หน่วยความจำ 1GB และหมดเวลาหลังจาก 300 วินาที:

exports.convertLargeFile = functions
    .runWith({
      // Ensure the function has enough memory and time
      // to process large files
      timeoutSeconds: 300,
      memory: "1GB",
    })
    .storage.object()
    .onFinalize((object) => {
      // Do some complicated things that take a lot of memory and time
    });

ค่าสูงสุดสำหรับ timeoutSeconds คือ 540 หรือ 9 นาที จำนวนหน่วยความจำที่มอบให้กับฟังก์ชันสอดคล้องกับ CPU ที่จัดสรรสำหรับฟังก์ชัน ดังรายละเอียดในรายการค่าที่ถูกต้องสำหรับ memory :

  • 128MB — 200MHz
  • 256MB — 400MHz
  • 512MB — 800MHz
  • 1GB — 1.4 GHz
  • 2GB — 2.4 GHz
  • 4GB — 4.8 GHz
  • 8GB — 4.8 GHz

ในการตั้งค่าการจัดสรรหน่วยความจำและการหมดเวลาใน Google Cloud Console:

  1. ใน Google Google Cloud Console ให้เลือก Cloud Functions จากเมนูด้านซ้าย
  2. เลือกฟังก์ชันโดยคลิกที่ชื่อในรายการฟังก์ชัน
  3. คลิกไอคอน แก้ไข ในเมนูด้านบน
  4. เลือกการจัดสรรหน่วยความจำจากเมนูแบบเลื่อนลงที่ระบุว่า หน่วยความจำที่จัดสรร
  5. คลิก เพิ่มเติม เพื่อแสดงตัวเลือกขั้นสูง และป้อนจำนวนวินาทีในกล่องข้อความ หมดเวลา
  6. คลิก บันทึก เพื่ออัปเดตฟังก์ชัน