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

กำหนดค่าสภาพแวดล้อม

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

คุณมีตัวเลือก 3 แบบดังนี้

การกำหนดค่าที่มีพารามิเตอร์ (แนะนำสำหรับสถานการณ์ส่วนใหญ่) ซึ่งจะให้สภาพแวดล้อมที่มีการพิมพ์เฉพาะ ด้วยพารามิเตอร์ที่มีการตรวจสอบ ในเวลาใช้งาน ป้องกันข้อผิดพลาดและทำให้การแก้ไขข้อบกพร่องง่ายขึ้น
การกำหนดค่าตามไฟล์ของตัวแปรสภาพแวดล้อม ด้วยวิธีนี้ คุณสามารถสร้าง dotenv สําหรับการโหลด ตัวแปรสภาพแวดล้อม
การกำหนดค่าสภาพแวดล้อมรันไทม์ที่มี Firebase CLI และ functions.config (Cloud Functions (รุ่นที่ 1) เท่านั้น)

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

การกำหนดค่าพารามิเตอร์

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

หากต้องการกำหนดพารามิเตอร์ในโค้ดของคุณ ให้ทำตามโมเดลนี้

const functions = require('firebase-functions/v1');
const { defineInt, defineString } = require('firebase-functions/params');

// Define some parameters
const minInstancesConfig = defineInt('HELLO_WORLD_MININSTANCES');
const welcomeMessage = defineString('WELCOME_MESSAGE');

// To use configured parameters inside the config for a function, provide them
// directly. To use them at runtime, call .value() on them.
export const helloWorld = functions.runWith({ minInstances: minInstancesConfig}).https.onRequest(
  (req, res) => {
    res.send(`${welcomeMessage.value()}! I am a function.`);
  }
);

เมื่อทำให้ฟังก์ชันใช้งานได้กับตัวแปรการกำหนดค่าที่ทำเป็นพารามิเตอร์ Firebase CLI จะพยายามโหลดค่าจากไฟล์ .env ในเครื่องเป็นครั้งแรก หาก จะไม่มีอยู่ในไฟล์เหล่านี้และไม่ได้ตั้ง default ไว้ CLI จะแสดงข้อความแจ้งสำหรับ ค่าระหว่างการทำให้ใช้งานได้ จากนั้นบันทึกค่าลงใน .env ไฟล์ชื่อ .env.<project_ID> ในไดเรกทอรี functions/ ของคุณ:

$ firebase deploy
i  functions: preparing codebase default for deployment
? Enter a string value for ENVIRONMENT: prod
i  functions: Writing new parameter values to disk: .env.projectId
…
$ firebase deploy
i  functions: Loaded environment variables from .env.projectId

การเพิ่มไฟล์ .env.<project_ID> ที่สร้างขึ้นลงในการควบคุมเวอร์ชันอาจมีประโยชน์ ทั้งนี้ขึ้นอยู่กับเวิร์กโฟลว์การพัฒนา

การใช้พารามิเตอร์ในขอบเขตทั้งหมด

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

  const { GoogleGenerativeAI } = require('@google/generative-ai');
  const { defineSecret } = require('firebase-functions/params');
  const { onInit } = require('firebase-functions/v1');

  const apiKey = defineSecret('GOOGLE_API_KEY');

  let genAI;
  onInit(() => {
    genAI = new GoogleGenerativeAI(apiKey.value());
  })

กำหนดค่าลักษณะการทำงานของ CLI

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

const { defineString } = require('firebase-functions/params');

const welcomeMessage = defineString('WELCOME_MESSAGE', {default: 'Hello World',
description: 'The greeting that is returned to the caller of this function'});

const onlyPhoneNumbers = defineString('PHONE_NUMBER', {input: {text:
{validationRegex: /\d{3}-\d{3}-\d{4}/, validationErrorMessage: "Please enter
a phone number in the format XXX-YYY-ZZZZ"}}});

const selectedOption = defineString('PARITY', {input: {select: {options:
[{value: "odd"}, {value: "even"}]}}})

const storageBucket = defineString('BUCKET', {input: {resource: {type:
"storage.googleapis.com/Bucket"}}, description: "This will automatically
populate the selector field with the deploying Cloud Project’s
storage buckets"})

ประเภทพารามิเตอร์

การกำหนดค่าพารามิเตอร์จะทำให้มีการพิมพ์ค่าพารามิเตอร์ที่แม่นยำ และ รองรับข้อมูลลับจาก Cloud Secret Manager ด้วย ประเภทที่รองรับ ได้แก่

ข้อมูลลับ
สตริง
บูลีน
จำนวนเต็ม
ทศนิยม

ค่าของพารามิเตอร์และนิพจน์

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

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

const functions = require('firebase-functions/v1');
const { defineInt} = require('firebase-functions/params');
const minInstancesConfig = defineInt('HELLO\_WORLD\_MININSTANCES');

export const helloWorld = functions.runWith({ minInstances: minInstancesConfig}).https.onRequest(
  (req, res) => {
    //…

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

const functions = require('firebase-functions/v1');
const { defineBool } = require('firebase-functions/params');
const environment = params.defineString(‘ENVIRONMENT’, {default: ‘dev’});

// use built-in comparators
const minInstancesConfig =environment.equals('PRODUCTION').thenElse(10, 1);
export const helloWorld = functions.runWith({ minInstances: minInstancesConfig}).https.onRequest(
  (req, res) => {
    //…

พารามิเตอร์และนิพจน์พารามิเตอร์ที่ใช้เมื่อรันไทม์เท่านั้นสามารถ เข้าถึงด้วยฟังก์ชัน value ของตน:

const functions = require('firebase-functions/v1');
const { defineString } = require('firebase-functions/params');
const welcomeMessage = defineString('WELCOME_MESSAGE');

// To use configured parameters inside the config for a function, provide them
// directly. To use them at runtime, call .value() on them.
export const helloWorld = functions.https.onRequest(
 (req, res) => {
    res.send(`${welcomeMessage.value()}! I am a function.`);
  }
);

พารามิเตอร์ในตัว

Cloud Functions SDK มีพารามิเตอร์ที่กำหนดไว้ล่วงหน้า 3 รายการ ซึ่งพร้อมให้ใช้งานจาก แพ็กเกจย่อย firebase-functions/params:

projectID — โปรเจ็กต์ที่อยู่ในระบบคลาวด์ที่ฟังก์ชันนี้ทำงานอยู่
databaseURL — URL ของอินสแตนซ์ Realtime Database ที่เชื่อมโยง ด้วยฟังก์ชัน (หากเปิดใช้ในโปรเจ็กต์ Firebase)
storageBucket — ที่เก็บข้อมูล Cloud Storage ที่เชื่อมโยงกับฟังก์ชัน (หากเปิดใช้ในโปรเจ็กต์ Firebase)

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

พารามิเตอร์ลับ

พารามิเตอร์ประเภท Secret กำหนดโดยใช้ defineSecret() แทนสตริง ซึ่งมีค่าเก็บไว้ใน Secret Manager ของ Cloud แทนที่จะเป็น ตรวจสอบไฟล์ .env ในเครื่องและเขียนค่าใหม่ลงในไฟล์หาก หายไป ตรวจสอบพารามิเตอร์ลับกับการมีอยู่ใน Secret Manager ของ Cloud และ แจ้งเตือนแบบอินเทอร์แอกทีฟเกี่ยวกับค่าของข้อมูลลับใหม่ในระหว่างการทำให้ใช้งานได้

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

const functions = require('firebase-functions/v1');
const { defineSecret } = require('firebase-functions/params');
const discordApiKey = defineSecret('DISCORD_API_KEY');

export const postToDiscord = functions.runWith({ secrets: [discordApiKey] }).https.onRequest(
  (req, res) => {
    const apiKey = discordApiKey.value();
    //…

เนื่องจากค่าของข้อมูลลับจะถูกซ่อนไว้จนกว่าจะมีการเรียกใช้ฟังก์ชัน คุณจึง ไม่สามารถใช้ในขณะกำหนดค่าฟังก์ชันได้

ตัวแปรสภาพแวดล้อม

Cloud Functions for Firebase รองรับ Dotenv รูปแบบไฟล์สำหรับโหลดตัวแปรสภาพแวดล้อมที่ระบุในไฟล์ .env ลงในไฟล์ รันไทม์ของแอปพลิเคชัน เมื่อทำให้ใช้งานได้แล้ว ตัวแปรสภาพแวดล้อมจะสามารถอ่านผ่าน process.env ของ Google

หากต้องการกำหนดค่าสภาพแวดล้อมด้วยวิธีนี้ ให้สร้างไฟล์ .env ในโปรเจ็กต์ เพิ่มตัวแปรที่ต้องการและทำให้ใช้งานได้

สร้างไฟล์ .env ในไดเรกทอรี functions/ ของคุณ

# Directory layout:
#   my-project/
#     firebase.json
#     functions/
#       .env
#       package.json
#       index.js

เปิดไฟล์ .env เพื่อแก้ไข แล้วเพิ่มคีย์ที่ต้องการ เช่น
```
PLANET=Earth
AUDIENCE=Humans
```
ทำให้ฟังก์ชันใช้งานได้และยืนยันว่าได้โหลดตัวแปรสภาพแวดล้อมแล้ว
```
firebase deploy --only functions
# ...
# i functions: Loaded environment variables from .env.
# ...
```

เมื่อทำให้ตัวแปรสภาพแวดล้อมที่กำหนดเองใช้งานได้แล้ว รหัสฟังก์ชันจะเข้าถึงฟังก์ชันเหล่านั้นได้ด้วย process.env ไวยากรณ์:

// Responds with "Hello Earth and Humans"
exports.hello = functions.https.onRequest((request, response) => {
  response.send(`Hello ${process.env.PLANET} and ${process.env.AUDIENCE}`);
});

การทำให้ตัวแปรสภาพแวดล้อมหลายชุดใช้งานได้

หากคุณต้องการชุดตัวแปรสภาพแวดล้อมอื่นสำหรับ Firebase (เช่น การทดลองใช้และเวอร์ชันที่ใช้งานจริง) ให้สร้าง .env.<project or alias> ไฟล์และเขียน ตัวแปรสภาพแวดล้อมเฉพาะโปรเจ็กต์ ตัวแปรสภาพแวดล้อมจาก .env และ .env เฉพาะโปรเจ็กต์ (หากมี) จะรวมอยู่ในฟังก์ชันที่ทำให้ใช้งานได้ทั้งหมด

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

`.env`	`.env.dev`	`.env.prod`
PLANET=โลก AUDIENCE=มนุษย์	AUDIENCE=มนุษย์พัฒนา	AUDIENCE ผู้ชมที่เป็นมนุษย์

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

$ firebase use dev
$ firebase deploy --only functions
i functions: Loaded environment variables from .env, .env.dev.
# Deploys functions with following user-defined environment variables:
#   PLANET=Earth
#   AUDIENCE=Dev Humans

$ firebase use prod
$ firebase deploy --only functions
i functions: Loaded environment variables from .env, .env.prod.
# Deploys functions with following user-defined environment variables:
#   PLANET=Earth
#   AUDIENCE=Prod Humans

ตัวแปรสภาพแวดล้อมที่สงวนไว้

คีย์ตัวแปรสภาพแวดล้อมบางรายการสงวนไว้สำหรับการใช้งานภายใน ไม่ใช้ คีย์เหล่านี้ในไฟล์ .env

คีย์ทั้งหมดที่ขึ้นต้นด้วย X_GOOGLE_
คีย์ทั้งหมดเริ่มต้นที่ EXT_
คีย์ทั้งหมดที่ขึ้นต้นด้วย FIREBASE_
คีย์ใดก็ได้จากรายการต่อไปนี้
การกำหนดค่าเวลา RUNTIME
ENTRY_POINT
GCP_PROJECT
โปรเจ็กต์ GCLOUD
โปรเจ็กต์ Google Cloud
ประเภท FUNCTION_ทริกเกอร์
FUNCTION_NAME
FUNCTION_MEMORY_MB
FUNCTION_TIMEOUT_SEC
FUNCTION_IDENTITY
FUNCTION_ภูมิภาค
FUNCTION_เป้าหมาย
ประเภท FUNCTION_SIGNATURE_TYPE
K_SERVICE
เกาหลี (K_REVISION)
พอร์ต
การกำหนดค่า K

จัดเก็บและเข้าถึงข้อมูลการกำหนดค่าที่ละเอียดอ่อน

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

เพื่อช่วยคุณจัดเก็บข้อมูลการกำหนดค่าที่ละเอียดอ่อน Cloud Functions for Firebase ผสานรวมกับ Google Cloud Secret Manager บริการที่เข้ารหัสนี้จะจัดเก็บการกำหนดค่าไว้อย่างปลอดภัย โดยยังคงสามารถเข้าถึงฟังก์ชันได้ง่ายๆ เมื่อจำเป็น

สร้างและใช้ข้อมูลลับ

หากต้องการสร้างข้อมูลลับ ให้ใช้ CLI ของ Firebase

วิธีสร้างและใช้ข้อมูลลับ

เรียกใช้คำสั่งต่อไปนี้จากรูทของไดเรกทอรีโปรเจ็กต์ในเครื่อง
```
firebase functions:secrets:set SECRET_NAME
```
ป้อนค่าสำหรับ SECRET_NAME

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

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

exports.processPayment = functions
  // Make the secret available to this function
  .runWith({ secrets: ["SECRET_NAME"] })
  .onCall((data, context) => {
    const myBillingService = initializeBillingService(
      // reference the secret value
      process.env.SECRET_NAME
    );
    // Process the payment
  });

ทำให้ Cloud Functions ใช้งานได้:
```
firebase deploy --only functions
```

ตอนนี้คุณจะสามารถเข้าถึงได้เช่นเดียวกับตัวแปรสภาพแวดล้อมอื่นๆ ในทางกลับกัน ถ้าฟังก์ชันอื่นที่ไม่ได้ระบุข้อมูลลับใน runWith พยายามเข้าถึงข้อมูลลับ โดยได้รับค่าที่ไม่ระบุ:

  exports.anotherEndpoint = functions.https.onRequest((request, response) => {
    response.send(`The secret API key is ${process.env.SECRET_NAME}`);
    // responds with "The secret API key is undefined" because the `runWith` parameter is missing
  });

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

การจัดการข้อมูลลับ

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

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

สรุปของคำสั่ง CLI ของ Firebase สำหรับการจัดการข้อมูลลับมีดังนี้

# Change the value of an existing secret
firebase functions:secrets:set SECRET_NAME

# View the value of a secret
functions:secrets:access SECRET_NAME

# Destroy a secret
functions:secrets:destroy SECRET_NAME

# View all secret versions and their state
functions:secrets:get SECRET_NAME

# Automatically clean up all secrets that aren't referenced by any of your functions
functions:secrets:prune

คุณระบุเวอร์ชันที่ไม่บังคับสำหรับคำสั่ง access และ destroy ได้ เพื่อจัดการเวอร์ชันเฉพาะ เช่น

functions:secrets:access SECRET_NAME[@VERSION]

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการดำเนินการเหล่านี้ ให้ส่ง -h ด้วยคำสั่งเพื่อ ดูความช่วยเหลือเกี่ยวกับ CLI

วิธีเรียกเก็บเงินสำหรับข้อมูลลับ

Secret Manager อนุญาตข้อมูลลับที่ใช้งานอยู่ 6 รายการ เวอร์ชัน โดยไม่มีค่าใช้จ่าย ซึ่งหมายความว่าคุณมีข้อมูลลับ 6 รายการต่อเดือนใน Firebase ที่ไม่มีค่าใช้จ่าย

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

Secret Manager อนุญาตให้มีการดำเนินการเข้าถึงรายเดือนที่ยังไม่ได้เรียกเก็บเงิน 10,000 รายการใน ข้อมูลลับ อินสแตนซ์ฟังก์ชันจะอ่านเฉพาะข้อมูลลับที่ระบุใน runWith ทุกครั้งที่ Cold Start หากมีอินสแตนซ์ของฟังก์ชันจำนวนมาก การอ่านข้อมูลลับจำนวนมาก โครงการของคุณอาจเกินค่าอนุญาตนี้ ซึ่งเมื่อถึงตอนนั้น คุณจะถูกเรียกเก็บเงิน $0.03 ต่อการดำเนินการเข้าถึง 10,000 ครั้ง

สำหรับข้อมูลเพิ่มเติม โปรดดู ราคาSecret Manager

การรองรับโปรแกรมจำลอง

การกำหนดค่าสภาพแวดล้อมด้วย dotenv ได้รับการออกแบบมาเพื่อทำงานร่วมกับ โปรแกรมจำลอง Cloud Functions ในเครื่อง

เมื่อใช้โปรแกรมจำลอง Cloud Functions ในเครื่อง คุณจะลบล้างสภาพแวดล้อมได้ ตัวแปรสำหรับโปรเจ็กต์ของคุณด้วยการตั้งค่าไฟล์ .env.local เนื้อหาของ .env.local จะมีความสำคัญเหนือ .env และไฟล์ .env เฉพาะโปรเจ็กต์

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

`.env`	`.env.dev`	`.env.local`
PLANET=โลก AUDIENCE=มนุษย์	AUDIENCE=มนุษย์พัฒนา	AUDIENCE มนุษย์ท้องถิ่น

โปรแกรมจำลองจะโหลดสภาพแวดล้อมเมื่อเริ่มต้นในบริบทเฉพาะเครื่อง ตัวแปรตามที่แสดง:

  $ firebase emulators:start
  i  emulators: Starting emulators: functions
  # Starts emulator with following environment variables:
  #  PLANET=Earth
  #  AUDIENCE=Local Humans

ข้อมูลลับและข้อมูลเข้าสู่ระบบในโปรแกรมจำลอง Cloud Functions

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

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

การย้ายข้อมูลจากการกำหนดค่าสภาพแวดล้อม

หากคุณใช้การกำหนดค่าสภาพแวดล้อมกับ functions.config คุณจะทำสิ่งต่อไปนี้ได้ สามารถย้ายข้อมูลการกำหนดค่าที่มีอยู่เป็นตัวแปรสภาพแวดล้อมได้ (ใน dotenv) CLI ของ Firebase มีคำสั่งการส่งออกที่แสดงเอาต์พุตของการกำหนดค่า ของชื่อแทนหรือโครงการแต่ละรายการในไฟล์ .firebaserc ของไดเรกทอรี (ในตัวอย่างด้านล่าง local, dev และ prod) เป็นไฟล์ .env

หากต้องการย้ายข้อมูล ให้ส่งออกการกำหนดค่าสภาพแวดล้อมที่มีอยู่โดยใช้ คำสั่ง firebase functions:config:export:

firebase functions:config:export
i  Importing configs from projects: [project-0, project-1]
⚠  The following configs keys could not be exported as environment variables:

⚠  project-0 (dev):
    1foo.a => 1FOO\_A (Key 1FOO\_A must start with an uppercase ASCII letter or underscore, and then consist of uppercase ASCII letters, digits, and underscores.)

Enter a PREFIX to rename invalid environment variable keys: CONFIG\_
✔  Wrote functions/.env.prod
✔  Wrote functions/.env.dev
✔  Wrote functions/.env.local
✔  Wrote functions/.env

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

เราขอแนะนำให้คุณตรวจสอบเนื้อหาของไฟล์ .env ที่สร้างขึ้นอย่างละเอียด ก่อนทำให้ฟังก์ชันใช้งานได้หรือตรวจสอบไฟล์ .env ในการควบคุมแหล่งที่มา ถ้า ค่าต่างๆ เป็นข้อมูลที่ละเอียดอ่อนและไม่ควรรั่วไหล ให้นำค่าดังกล่าวออกจาก .env และจัดเก็บไว้อย่างปลอดภัย Secret Manager แทน

คุณจะต้องอัปเดตโค้ดฟังก์ชันด้วย ฟังก์ชันต่างๆ ที่ใช้ ตอนนี้ functions.config จะต้องใช้ process.env แทน ดังที่แสดงใน อัปเกรดเป็นรุ่นที่ 2

การกำหนดค่าสภาพแวดล้อม

ก่อนที่จะมีการเผยแพร่การรองรับตัวแปรสภาพแวดล้อมใน firebase-functions v3.18.0 การใช้ functions.config() เป็นวิธีที่แนะนำสำหรับ การกำหนดค่าสภาพแวดล้อม เรายังคงรองรับวิธีการนี้ แต่เราขอแนะนํา โปรเจ็กต์ใหม่ทั้งหมดจะใช้ตัวแปรสภาพแวดล้อมแทน เนื่องจากใช้งานง่ายกว่า และเพิ่มความสามารถในการถ่ายโอนโค้ดได้

ตั้งค่าการกำหนดค่าสภาพแวดล้อมด้วย CLI

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

ตัวอย่างเช่น ในการจัดเก็บรหัสไคลเอ็นต์และคีย์ API สำหรับ "บริการบางอย่าง" คุณอาจเรียกใช้:

firebase functions:config:set someservice.key="THE API KEY" someservice.id="THE CLIENT ID"

เรียกข้อมูลการกำหนดค่าสภาพแวดล้อมปัจจุบัน

หากต้องการตรวจสอบสิ่งที่จัดเก็บไว้ในการกำหนดค่าสภาพแวดล้อมสำหรับโปรเจ็กต์ของคุณในปัจจุบัน ให้ทำดังนี้ สามารถใช้ firebase functions:config:get ซึ่งจะแสดงผล JSON ในรูปแบบนี้ ดังนี้

{
  "someservice": {
    "key":"THE API KEY",
    "id":"THE CLIENT ID"
  }
}

ฟังก์ชันการทำงานนี้อิงตาม Google Cloud Runtime Configuration API

ใช้ `functions.config` เพื่อเข้าถึงการกำหนดค่าสภาพแวดล้อมในฟังก์ชัน

การกำหนดค่าบางอย่างจะจัดเตรียมไว้โดยอัตโนมัติภายใต้ firebase ที่สงวนไว้ Namespace การกำหนดค่าสภาพแวดล้อมพร้อมให้ใช้งานแล้วในการเรียกใช้ ผ่าน functions.config() หากต้องการใช้การกำหนดค่าข้างต้น โค้ดของคุณอาจมีลักษณะดังนี้

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

exports.userCreated = functions.database.ref('/users/{id}').onWrite(event => {
  let email = event.data.child('email').val();

  return request({
    url: 'https://someservice.com/api/some/call',
    headers: {
      'X-Client-ID': functions.config().someservice.id,
      'Authorization': `Bearer ${functions.config().someservice.key}`
    },
    body: {email: email}
  });
});

ใช้การกำหนดค่าสภาพแวดล้อมเพื่อเริ่มต้นโมดูล

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

ตัวอย่างเช่น หากต้องการใช้โมดูล Slack Node SDK คุณอาจเขียนดังนี้

const functions = require('firebase-functions/v1');
const IncomingWebhook = require('@slack/client').IncomingWebhook;
const webhook = new IncomingWebhook(functions.config().slack.url);

ก่อนที่จะทำให้ใช้งานได้ ให้ตั้งค่าตัวแปรการกำหนดค่าสภาพแวดล้อม slack.url ดังนี้

firebase functions:config:set slack.url=https://hooks.slack.com/services/XXX

คำสั่งสภาพแวดล้อมเพิ่มเติม

firebase functions:config:unset key1 key2 นำคีย์ที่ระบุออกจากการกำหนดค่า
firebase functions:config:clone --from <fromProject> จะโคลนสภาพแวดล้อมของโปรเจ็กต์อื่นลงใน โปรเจ็กต์ที่ใช้งานอยู่ในปัจจุบัน

ตัวแปรสภาพแวดล้อมที่ป้อนข้อมูลโดยอัตโนมัติ

มีตัวแปรสภาพแวดล้อมที่มีการป้อนข้อมูลโดยอัตโนมัติใน รันไทม์และในฟังก์ชันที่จำลองเฉพาะเครื่อง ซึ่งรวมถึง ซึ่งสร้างขึ้นโดย Google Cloud รวมทั้งตัวแปรสภาพแวดล้อมเฉพาะ Firebase ดังนี้

process.env.FIREBASE_CONFIG: ระบุข้อมูลการกำหนดค่าโปรเจ็กต์ Firebase ต่อไปนี้

{
  databaseURL: 'https://databaseName.firebaseio.com',
  storageBucket: 'projectId.appspot.com',
  projectId: 'projectId'
}

ระบบจะใช้การกำหนดค่านี้โดยอัตโนมัติเมื่อคุณเริ่มต้น Firebase Admin SDK ที่ไม่มีอาร์กิวเมนต์ หากคุณเขียนฟังก์ชันด้วย JavaScript เริ่มต้นดังนี้

const admin = require('firebase-admin');
admin.initializeApp();

หากคุณกำลังเขียนฟังก์ชันใน TypeScript ให้เริ่มต้นดังนี้

import * as functions from 'firebase-functions/v1';
import * as admin from 'firebase-admin';
import 'firebase-functions/v1';
admin.initializeApp();

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

serviceAccount = require('./serviceAccount.json');

const adminConfig = JSON.parse(process.env.FIREBASE_CONFIG);
adminConfig.credential = admin.credential.cert(serviceAccount);
admin.initializeApp(adminConfig);