เคล็ดลับและคำแนะนำ

เอกสารนี้อธิบายแนวทางปฏิบัติแนะนำสำหรับการออกแบบ การติดตั้งใช้งาน การทดสอบ และการติดตั้งใช้งาน Cloud Functions

ความถูกต้อง

ส่วนนี้อธิบายแนวทางปฏิบัติแนะนำทั่วไปสำหรับการออกแบบและการติดตั้งใช้งาน Cloud Functions

เขียนฟังก์ชันไอดีมโพเทนต์

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

อย่าเริ่มกิจกรรมในเบื้องหลัง

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

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

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

ลบไฟล์ชั่วคราวเสมอ

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

คุณดูหน่วยความจำที่ฟังก์ชันแต่ละรายการใช้ได้โดยเลือกฟังก์ชันในรายการฟังก์ชันในคอนโซล Google Cloud แล้วเลือกพล็อตการใช้หน่วยความจำ

หากต้องการเข้าถึงพื้นที่เก็บข้อมูลระยะยาว ให้ลองใช้Cloud Run การติดตั้งโวลุ่มด้วย Cloud Storage หรือโวลุ่ม NFS

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

Functions Framework

เราขอแนะนำให้คุณรวมไลบรารี Functions Framework ไว้ในเครื่องมือจัดการแพ็กเกจและตรึงการอ้างอิงไว้กับ Functions Framework เวอร์ชันใดเวอร์ชันหนึ่ง เพื่อให้มั่นใจว่ามีการติดตั้งการอ้างอิงเดียวกันอย่างสม่ำเสมอในสภาพแวดล้อมต่างๆ

โดยให้ระบุเวอร์ชันที่ต้องการในไฟล์ล็อกที่เกี่ยวข้อง (เช่น package-lock.json สำหรับ Node.js หรือ requirements.txt สำหรับ Python)

หากไม่ได้ระบุ Functions Framework เป็นการพึ่งพาอย่างชัดเจน ระบบจะเพิ่ม Framework โดยอัตโนมัติในระหว่างกระบวนการสร้างโดยใช้เวอร์ชันล่าสุดที่มี

เครื่องมือ

ส่วนนี้จะให้หลักเกณฑ์เกี่ยวกับวิธีใช้เครื่องมือเพื่อติดตั้งใช้งาน ทดสอบ และ โต้ตอบกับ Cloud Functions

การพัฒนาในพื้นที่

การติดตั้งใช้งานฟังก์ชันจะใช้เวลาสักครู่ ดังนั้นการทดสอบโค้ด ของฟังก์ชันในเครื่องจึงมักจะเร็วกว่า

หลีกเลี่ยงการหมดเวลาในการติดตั้งใช้งานระหว่างการเริ่มต้น

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

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

หากต้องการหลีกเลี่ยงการหมดเวลา ให้ใช้กลยุทธ์ใดกลยุทธ์หนึ่งต่อไปนี้

(แนะนํา) ใช้ onInit() เพื่อเลื่อนการเริ่มต้น

ใช้ฮุก onInit() เพื่อหลีกเลี่ยงการเรียกใช้โค้ดการเริ่มต้นระหว่างการ ติดตั้งใช้งาน โค้ดภายในฮุก onInit() จะทำงานเมื่อมีการติดตั้งใช้งานฟังก์ชันใน Cloud Run เท่านั้น ไม่ใช่ในระหว่างกระบวนการติดตั้งใช้งาน

const { onInit } = require('firebase-functions/v2/core');
const { onRequest } = require('firebase-functions/v2/https');

// Example of a slow initialization task
function slowInitialization() {
  // Simulate a long-running operation (e.g., loading a large model, network request).
  return new Promise(resolve => {
      setTimeout(() => {
          console.log("Slow initialization complete");
          resolve("Initialized Value");
      }, 20000); // Simulate a 20-second delay
  });
}
let initializedValue;

onInit(async () => {
  initializedValue = await slowInitialization();
});

exports.myFunction = onRequest((req, res) => {
  // Access the initialized value. It will be ready after the first invocation.
  res.send(`Value: ${initializedValue}`);
});

from firebase_functions.core import init
from firebase_functions import https_fn
import time

# Example of a slow initialization task
def _slow_initialization():
  time.sleep(20)  # Simulate a 20-second delay
  print("Slow initialization complete")
  return "Initialized Value"

_initialized_value = None

@init
def initialize():
  global _initialized_value
  _initialized_value = _slow_initialization()

@https_fn.on_request()
def my_function(req: https_fn.Request) -> https_fn.Response:
  # Access the initialized value. It will be ready after the first invocation.
  return https_fn.Response(f"Value: {_initialized_value}")

(ทางเลือก) เพิ่มระยะหมดเวลาการค้นหา

หากปรับโครงสร้างโค้ดเพื่อใช้ onInit() ไม่ได้ คุณสามารถเพิ่มการหมดเวลาในการติดตั้งใช้งานของ CLI ได้โดยใช้ตัวแปรสภาพแวดล้อม FUNCTIONS_DISCOVERY_TIMEOUT ดังนี้

$ export FUNCTIONS_DISCOVERY_TIMEOUT=30
$ firebase deploy --only functions

ใช้ Sendgrid เพื่อส่งอีเมล

Cloud Functions ไม่อนุญาตการเชื่อมต่อขาออกในพอร์ต 25 คุณจึงไม่สามารถ ทำการเชื่อมต่อที่ไม่ปลอดภัยกับเซิร์ฟเวอร์ SMTP วิธีที่แนะนำในการส่งอีเมลคือการใช้บริการของบุคคลที่สาม เช่น SendGrid คุณดูตัวเลือกอื่นๆ สำหรับการส่งอีเมลได้ในบทแนะนำ การส่งอีเมลจากอินสแตนซ์ สำหรับ Google Compute Engine

ประสิทธิภาพ

ส่วนนี้จะอธิบายแนวทางปฏิบัติแนะนำในการเพิ่มประสิทธิภาพ

หลีกเลี่ยงการทำงานพร้อมกันต่ำ

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

ใช้การขึ้นต่อกันอย่างชาญฉลาด

เนื่องจากฟังก์ชันไม่มีสถานะ ระบบจึงมักเริ่มต้นสภาพแวดล้อมการดำเนินการ ตั้งแต่ต้น (ในระหว่างที่เรียกว่าการเริ่มแบบเย็น) เมื่อเกิดการเริ่มระบบใหม่ ระบบจะประเมินบริบทส่วนกลางของฟังก์ชัน

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

ใช้ตัวแปรส่วนกลางเพื่อนำออบเจ็กต์กลับมาใช้ใหม่ในการเรียกใช้ในอนาคต

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

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

console.log('Global scope');
const perInstance = heavyComputation();
const functions = require('firebase-functions');

exports.function = functions.https.onRequest((req, res) => {
  console.log('Function invocation');
  const perFunction = lightweightComputation();

  res.send(`Per instance: ${perInstance}, per function: ${perFunction}`);
});

import time

from firebase_functions import https_fn

# Placeholder
def heavy_computation():
  return time.time()

# Placeholder
def light_computation():
  return time.time()

# Global (instance-wide) scope
# This computation runs at instance cold-start
instance_var = heavy_computation()

@https_fn.on_request()
def scope_demo(request):

  # Per-function scope
  # This computation runs every time this function is called
  function_var = light_computation()
  return https_fn.Response(f"Instance: {instance_var}; function: {function_var}")
  

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

ลด Cold Start โดยการกำหนดจำนวนอินสแตนซ์ขั้นต่ำ

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

หมายเหตุเกี่ยวกับการเริ่มต้นแบบ Cold Start และการเริ่มต้น

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

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

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

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

ตัวอย่างการอุ่นไลบรารี Node.js แบบไม่พร้อมกัน

Node.js ที่มี Firestore เป็นตัวอย่างของไลบรารี Node.js แบบอะซิงโครนัส หากต้องการใช้ประโยชน์จาก min_instances โค้ดต่อไปนี้จะโหลดให้เสร็จสมบูรณ์ และเริ่มต้นที่เวลาโหลด โดยจะบล็อกการโหลดโมดูล

มีการใช้ TLA ซึ่งหมายความว่าต้องใช้ ES6 โดยใช้ส่วนขยาย .mjs สำหรับโค้ด node.js หรือเพิ่ม type: module ลงในไฟล์ package.json

{
  "main": "main.js",
  "type": "module",
  "dependencies": {
    "@google-cloud/firestore": "^7.10.0",
    "@google-cloud/functions-framework": "^3.4.5"
  }
}

import Firestore from '@google-cloud/firestore';
import * as functions from '@google-cloud/functions-framework';

const firestore = new Firestore({preferRest: true});

// Pre-warm firestore connection pool, and preload our global config
// document in cache. In order to ensure no other request comes in,
// block the module loading with a synchronous global request:
const config = await firestore.collection('collection').doc('config').get();

functions.http('fetch', (req, res) => {

// Do something with config and firestore client, which are now preloaded
// and will execute at lower latency.
});

ตัวอย่างการเริ่มต้นส่วนกลาง

const functions = require('firebase-functions');
let myCostlyVariable;

exports.function = functions.https.onRequest((req, res) => {
  doUsualWork();
  if(unlikelyCondition()){
      myCostlyVariable = myCostlyVariable || buildCostlyVariable();
  }
  res.status(200).send('OK');
});

from firebase_functions import https_fn

# Always initialized (at cold-start)
non_lazy_global = file_wide_computation()

# Declared at cold-start, but only initialized if/when the function executes
lazy_global = None

@https_fn.on_request()
def lazy_globals(request):

  global lazy_global, non_lazy_global

  # This value is initialized only if (and when) the function is called
  if not lazy_global:
      lazy_global = function_specific_computation()

  return https_fn.Response(f"Lazy: {lazy_global}, non-lazy: {non_lazy_global}.")
  

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

แหล่งข้อมูลเพิ่มเติม

ดูข้อมูลเพิ่มเติมเกี่ยวกับการเพิ่มประสิทธิภาพในวิดีโอ "Google Cloud Performance Atlas" Cloud Functions เวลา Cold Boot