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


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

ทำให้ฟังก์ชันใช้งานได้

หากต้องการทำให้ฟังก์ชันใช้งานได้ ให้เรียกใช้คำสั่ง Firebase CLI นี้

firebase deploy --only functions

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

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

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

ดูรายการคำสั่งทั้งหมดที่พร้อมใช้งานได้ในFirebase ข้อมูลอ้างอิง CLI

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

ลบฟังก์ชัน

คุณลบฟังก์ชันที่ติดตั้งใช้งานไปก่อนหน้านี้ได้ดังนี้

  • อย่างชัดเจนใน Firebase CLI ด้วย functions:delete
  • อย่างชัดเจนในคอนโซล Google Cloud
  • โดยปริยายด้วยการนําฟังก์ชันออกจากแหล่งที่มาก่อนการนําไปใช้งาน

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

การลบฟังก์ชันอย่างชัดแจ้งใน 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 จะแยกวิเคราะห์แหล่งที่มาและนำฟังก์ชันที่นําออกจากไฟล์ออกจากเวอร์ชันที่ใช้งานจริง

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

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

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

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

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

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

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

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. ติดตั้งใช้งานฟังก์ชันที่เปลี่ยนชื่อ ซึ่งจะทําให้เรียกใช้โค้ดเดียวกันในทั้ง 2 ชุดของภูมิภาคชั่วคราว
  3. ลบฟังก์ชันก่อนหน้า

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

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

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

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

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

จากนั้นทําให้ใช้งานได้โดยเรียกใช้

firebase deploy --only functions:webhookAsia

ตอนนี้มีฟังก์ชันที่เหมือนกัน 2 รายการที่ทำงานอยู่ โดย webhook ทำงานใน us-central1 และ webhookAsia ทำงานใน asia-northeast1

จากนั้นลบ webhook

firebase functions:delete webhook

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

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

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

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

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

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

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

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

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

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 อนุญาตให้เลือกรันไทม์ Node.js คุณสามารถเลือกที่จะเรียกใช้ฟังก์ชันทั้งหมดในโปรเจ็กต์ในสภาพแวดล้อมรันไทม์ที่สอดคล้องกับเวอร์ชัน Node.js ที่รองรับอย่างใดอย่างหนึ่งต่อไปนี้โดยเฉพาะ

  • Node.js 20 (เวอร์ชันตัวอย่าง)
  • Node.js 18
  • Node.js 16
  • Node.js 14

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

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

  "engines": {"node": "18"}

หากคุณใช้เครื่องมือจัดการแพ็กเกจ Yarn หรือมีข้อกำหนดเฉพาะอื่นๆ สำหรับช่อง engines คุณสามารถตั้งค่ารันไทม์สำหรับ Firebase SDK สำหรับ Cloud Functions ใน firebase.json แทนได้โดยทำดังนี้

  {
    "functions": {
      "runtime": "nodejs18" // or nodejs14, nodejs16 or nodejs20
    }
  }

CLI จะใช้ค่าที่ตั้งไว้ใน firebase.json แทนค่าหรือช่วงที่คุณตั้งค่าแยกต่างหากใน package.json

อัปเกรดรันไทม์ Node.js

วิธีอัปเกรดรันไทม์ Node.js

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

ควบคุมลักษณะการปรับขนาด

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

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

ลดจำนวน Cold Start

หากต้องการตั้งค่าจำนวนอินสแตนซ์ขั้นต่ำของฟังก์ชันในซอร์สโค้ด ให้ใช้วิธี 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
    });
index.js

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

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

  • การตั้งค่าอินสแตนซ์ขั้นต่ำอาจเหมาะกับสภาพแวดล้อมที่ใช้งานจริง แต่โดยทั่วไปควรหลีกเลี่ยงในสภาพแวดล้อมการทดสอบ หากต้องการปรับขนาดเป็น 0 ในโปรเจ็กต์ทดสอบแต่ยังคงลด Cold Start ในโปรเจ็กต์เวอร์ชันที่ใช้งานจริง คุณสามารถตั้งค่า 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
    });
    index.js

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

หากต้องการตั้งค่าอินสแตนซ์สูงสุดในซอร์สโค้ดของฟังก์ชัน ให้ใช้วิธี 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
    });
index.js

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

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

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

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

หากต้องการกำหนดการจัดสรรหน่วยความจำและการหมดเวลาในซอร์สโค้ดของฟังก์ชัน ให้ใช้พารามิเตอร์ runWith ที่เปิดตัวใน Firebase SDK สำหรับ Cloud Functions 2.0.0 ตัวเลือกรันไทม์นี้จะยอมรับออบเจ็กต์ JSON ที่เป็นไปตามอินเทอร์เฟซ RuntimeOptions ซึ่งจะกำหนดค่าสำหรับ timeoutSeconds และ memory ตัวอย่างเช่น ฟังก์ชันพื้นที่เก็บข้อมูลนี้ใช้หน่วยความจำ 1 GB และหมดเวลาหลังจาก 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
    });
index.js

ค่าสูงสุดสำหรับ 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

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