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

ใช้การกำหนดค่าระยะไกลฝั่งเซิร์ฟเวอร์ร่วมกับ Cloud Functions และ Vertex AI

คู่มือนี้จะอธิบายวิธีเริ่มต้นใช้งานรุ่นที่ 2 Cloud Functions กับ Remote Config ฝั่งเซิร์ฟเวอร์ เพื่อกำหนดให้เป็นฝั่งเซิร์ฟเวอร์ การเรียกไปยัง Vertex AI Gemini API

ในบทแนะนำนี้ คุณจะเพิ่ม Remote Config ในฟังก์ชันที่คล้ายแชทบ็อตที่ ใช้โมเดล Gemini เพื่อตอบคำถามของผู้ใช้ Remote Config จะ จัดการอินพุต Gemini API รายการ (รวมถึงข้อความแจ้งที่คุณจะเพิ่มไว้ข้างหน้า คำถามของผู้ใช้ที่ได้รับ) และคุณสามารถอัปเดตข้อมูลเหล่านี้ได้ตามต้องการจาก คอนโซล Firebase นอกจากนี้ คุณจะใช้ Firebase Local Emulator Suite เพื่อทดสอบและ ดีบักฟังก์ชัน จากนั้นหลังจากยืนยันว่าใช้งานได้แล้ว คุณจะทำให้ใช้งานได้และ ทดสอบใน Google Cloud

ข้อกำหนดเบื้องต้น

คู่มือนี้จะถือว่าคุณคุ้นเคยกับการใช้ JavaScript ในการพัฒนา แอปพลิเคชัน

สร้างโปรเจ็กต์ Firebase

หากยังไม่มีโปรเจ็กต์ Firebase

ลงชื่อเข้าใช้คอนโซลของ Firebase
คลิกสร้างโปรเจ็กต์ แล้วใช้ตัวเลือกใดตัวเลือกหนึ่งต่อไปนี้
- ตัวเลือกที่ 1: สร้างโปรเจ็กต์ Firebase ใหม่ (และโปรเจ็กต์ที่สำคัญ) Google Cloudโดยอัตโนมัติ) โดยป้อนชื่อโปรเจ็กต์ใหม่ใน ขั้นตอนแรกของ "สร้างโปรเจ็กต์"
- ตัวเลือกที่ 2: "เพิ่ม Firebase" ลงในโปรเจ็กต์ Google Cloud ที่มีอยู่ได้ การเลือกชื่อโครงการ Google Cloud จากเมนูแบบเลื่อนลงใน ขั้นตอนแรกของ "สร้างโปรเจ็กต์"
เมื่อได้รับข้อความแจ้ง คุณไม่จำเป็นต้องตั้งค่า Google Analytics เพื่อใช้งาน โซลูชันนี้
ทําตามวิธีการบนหน้าจอต่อไปเพื่อสร้างโปรเจ็กต์

หากคุณมีโปรเจ็กต์ Firebase อยู่แล้ว ให้ทำดังนี้

ดำเนินการต่อเพื่อกำหนดค่าสภาพแวดล้อมในการพัฒนาซอฟต์แวร์

กำหนดค่าสภาพแวดล้อมในการพัฒนาซอฟต์แวร์

คุณจะต้องใช้สภาพแวดล้อม Node.js เพื่อเขียนฟังก์ชัน และ คุณจะต้องมี Firebase CLI เพื่อทำให้ฟังก์ชันใช้งานได้กับ Cloud Functions รันไทม์

ติดตั้ง Node.js และ npm

สำหรับการติดตั้ง Node.js และ npm ขอแนะนำให้ใช้ เครื่องมือจัดการเวอร์ชันโหนด

สำคัญ: เราขอแนะนำให้ใช้ Node.js v20 ขึ้นไป โปรดดู ตั้งค่าตัวเลือกรันไทม์ เพื่อดูข้อมูลสำคัญเกี่ยวกับการสนับสนุนอย่างต่อเนื่องสำหรับ เวอร์ชัน Node.js
ติดตั้ง Firebase CLI โดยใช้ วิธีที่ต้องการ ตัวอย่างเช่น ในการติดตั้ง CLI โดยใช้ npm ให้เรียกใช้ คำสั่ง:
```
npm install -g firebase-tools@latest
```
คำสั่งนี้จะติดตั้งคำสั่ง firebase ที่ใช้ได้ทั่วโลก หากสิ่งนี้ ล้มเหลว คุณอาจต้อง เปลี่ยนสิทธิ์ npm

หากต้องการอัปเดต firebase-tools เป็นเวอร์ชันล่าสุด ให้เรียกใช้คำสั่งเดิมอีกครั้ง
ติดตั้ง firebase-functions และ firebase-admin และใช้ --save เพื่อบันทึก ลงใน package.json ของคุณ:
```
npm install firebase-functions@latest firebase-admin@latest --save
```

ตอนนี้คุณพร้อมที่จะติดตั้งใช้งานเครื่องมือนี้แล้ว โซลูชัน

การใช้งาน

ทำตามขั้นตอนเหล่านี้เพื่อสร้าง ทดสอบ และทำให้รุ่นที่ 2 ใช้งานได้ Cloud Functions ด้วย Remote Config และ Vertex AI:

เปิดใช้ API ที่แนะนำ Vertex AI รายการในคอนโซล Google Cloud
เริ่มต้นโปรเจ็กต์และติดตั้งทรัพยากร Dependency ของโหนด
กำหนดค่าสิทธิ์ IAM สำหรับบัญชีบริการ Admin SDK และ บันทึกคีย์ของคุณ
สร้างฟังก์ชัน
สร้างเทมเพลต Remote Config เฉพาะเซิร์ฟเวอร์
ทำให้ฟังก์ชันใช้งานได้และทดสอบใน Firebase Local Emulator Suite
ทำให้ฟังก์ชันใช้งานได้กับ Google Cloud

ขั้นตอนที่ 1: เปิดใช้ API ที่แนะนำ Vertex AI รายการในคอนโซล Google Cloud

เปิด คอนโซล Google Cloud และ เมื่อได้รับข้อความแจ้ง ให้เลือกโปรเจ็กต์
ในช่องค้นหาที่ด้านบนของคอนโซล ให้ป้อน Vertex AI และรอให้ Vertex AI ปรากฏขึ้น
เลือก Vertex AI แดชบอร์ด Vertex AI จะปรากฏขึ้น
คลิกเปิดใช้ API ที่แนะนำทั้งหมด

การเปิดใช้ API อาจใช้เวลาสักครู่จึงจะเสร็จสมบูรณ์ เก็บหน้าเว็บไว้ ทำงานและเปิดอยู่จนกว่าการเปิดใช้จะเสร็จสิ้น
หากไม่ได้เปิดใช้งานการเรียกเก็บเงินไว้ ระบบจะแจ้งให้คุณเพิ่มหรือลิงก์ บัญชี Cloud Billing หลังจากเปิดใช้บัญชีสำหรับการเรียกเก็บเงินแล้ว ให้กลับไปที่ Vertex AI หน้าแดชบอร์ดและยืนยันว่าได้เปิดใช้ API ที่แนะนำทั้งหมดแล้ว

ขั้นตอนที่ 2: เริ่มต้นโปรเจ็กต์และติดตั้งทรัพยากร Dependency ของโหนด

เปิดเทอร์มินัลในคอมพิวเตอร์ และไปยังไดเรกทอรีที่คุณ วางแผนสร้างฟังก์ชัน
ลงชื่อเข้าสู่ระบบ Firebase
```
firebase login
```
เรียกใช้คำสั่งต่อไปนี้เพื่อเริ่มต้น Cloud Functions for Firebase
```
firebase init functions
```
เลือกใช้โปรเจ็กต์ที่มีอยู่ แล้วระบุรหัสโปรเจ็กต์
เมื่อได้รับแจ้งให้เลือกภาษาที่จะใช้ ให้เลือก JavaScript แล้วกด ป้อน
สำหรับตัวเลือกอื่นๆ ทั้งหมด ให้เลือกค่าเริ่มต้น

ระบบจะสร้างไดเรกทอรี functions ในไดเรกทอรีปัจจุบัน ภายใน คุณจะ หาไฟล์ index.js ที่จะใช้สร้างฟังก์ชัน ไดเรกทอรี node_modules ที่มีทรัพยากร Dependency สำหรับฟังก์ชัน และไฟล์ package.json ที่มีทรัพยากร Dependency ของแพ็กเกจ
เพิ่มแพ็กเกจ Admin SDK และ Vertex AI โดยการเรียกใช้แพ็กเกจ ต่อไปนี้ โดยใช้ --save เพื่อให้มั่นใจว่าบันทึกลงใน package.json ไฟล์:
```
cd functions
npm install firebase-admin@latest @google-cloud/vertexai --save
```

ไฟล์ functions/package.json ของคุณควรมีลักษณะดังต่อไปนี้ โดย เวอร์ชันล่าสุดที่ระบุ:

  {
    "name": "functions",
    "description": "Cloud Functions for Firebase",
    "scripts": {
      "serve": "firebase emulators:start --only functions",
      "shell": "firebase functions:shell",
      "start": "npm run shell",
      "deploy": "firebase deploy --only functions",
      "logs": "firebase functions:log"
    },
    "engines": {
      "node": "20"
    },
    "main": "index.js",
    "dependencies": {
      "@google-cloud/vertexai": "^1.1.0",
      "firebase-admin": "^12.1.0",
      "firebase-functions": "^5.0.0"
    },
    "devDependencies": {
      "firebase-functions-test": "^3.1.0"
    },
    "private": true
  }

โปรดทราบว่าหากใช้ ESLint คุณจะเห็นสแตนซาที่มีข้อความดังกล่าว ใน อย่าลืมตรวจสอบว่าเวอร์ชัน Node Engine ตรงกับเวอร์ชันที่ติดตั้งไว้ ของ Node.js และเวอร์ชันที่คุณเรียกใช้ใน Google Cloud ในท้ายที่สุด ตัวอย่างเช่น หาก ข้อความ engines ใน package.json ได้รับการกำหนดค่าเป็นโหนดเวอร์ชัน 18 และ คุณใช้ Node.js 20 อยู่ โปรดอัปเดตไฟล์ให้ใช้ 20

  "engines": {
    "node": "20"
  },

ขั้นตอนที่ 3: กำหนดค่าสิทธิ์ IAM สำหรับบัญชีบริการ Admin SDK และบันทึกคีย์

ในโซลูชันนี้ คุณจะใช้บัญชีบริการ Firebase Admin SDK เพื่อเรียกใช้ ฟังก์ชันของคุณ

ในคอนโซล Google Cloud ให้เปิด IAM และ หน้าผู้ดูแลระบบ และค้นหาบัญชีบริการ Admin SDK (ชื่อ firebase-adminsdk)
เลือกบัญชีและคลิกแก้ไขผู้ใช้หลัก หน้าแก้ไขการเข้าถึง จะปรากฏขึ้น
คลิกเพิ่มบทบาทอื่น เลือกผู้ดู Remote Config
คลิกเพิ่มบทบาทอื่น เลือกนักพัฒนาแพลตฟอร์ม AI
คลิกเพิ่มบทบาทอื่น เลือกผู้ใช้ Vertex AI ราย
คลิกเพิ่มบทบาทอื่น เลือกผู้เรียกใช้ Cloud Run
คลิกบันทึก

จากนั้นให้ส่งออกข้อมูลเข้าสู่ระบบของบัญชีบริการ Admin SDK แล้วบันทึกข้อมูลเหล่านั้น ในตัวแปรสภาพแวดล้อม GOOGLE_APPLICATION_CREDENTIALS

ในคอนโซล Google Cloud ให้เปิด หน้าข้อมูลเข้าสู่ระบบ
คลิกบัญชีบริการ Admin SDK เพื่อเปิดหน้ารายละเอียด
คลิก Keys
คลิกเพิ่มคีย์ > สร้างคีย์ใหม่
ตรวจดูว่าได้เลือก JSON เป็นประเภทคีย์ จากนั้นคลิกสร้าง
ดาวน์โหลดคีย์ไว้ในที่ปลอดภัยในคอมพิวเตอร์
จากเทอร์มินัล ให้ส่งออกคีย์เป็นตัวแปรสภาพแวดล้อมดังนี้
```
export GOOGLE_APPLICATION_CREDENTIALS="/path/to/your/service-account-key.json"
```

ขั้นตอนที่ 4: สร้างฟังก์ชัน

ในขั้นตอนนี้ คุณจะได้สร้างฟังก์ชันที่จัดการอินพุตของผู้ใช้และสร้าง คำตอบที่ทำงานด้วยระบบ AI คุณจะต้องรวมข้อมูลโค้ดหลายรายการเพื่อสร้าง ฟังก์ชันที่ครอบคลุมซึ่งเริ่มต้น Admin SDK และ Vertex AI Gemini API กำหนดค่าพารามิเตอร์เริ่มต้นโดยใช้ Remote Config, ดึงข้อมูลพารามิเตอร์ Remote Config, กระบวนการล่าสุด ข้อมูลจากผู้ใช้ และสตรีมคำตอบกลับไปยังผู้ใช้

ในฐานของโค้ด ให้เปิด functions/index.js ในโปรแกรมแก้ไขข้อความหรือ IDE

ลบเนื้อหาที่มีอยู่ แล้วเพิ่ม Admin SDK Remote Config และ SDK Vertex AI และเริ่มต้นแอปโดย วางโค้ดต่อไปนี้ลงในไฟล์:

const { onRequest } = require("firebase-functions/v2/https");
const logger = require("firebase-functions/logger");

const { initializeApp } = require("firebase-admin/app");
const { VertexAI } = require('@google-cloud/vertexai');
const { getRemoteConfig } = require("firebase-admin/remote-config");

// Set and check environment variables.
const project = process.env.GCLOUD_PROJECT;

// Initialize Firebase.
const app = initializeApp();index.js

กําหนดค่าเริ่มต้นที่ฟังก์ชันจะใช้หากเชื่อมต่อไม่ได้ เซิร์ฟเวอร์ Remote Config โซลูชันนี้จะกำหนดค่า textModel generationConfig, safetySettings, textPrompt และ location เป็น Remote Config พารามิเตอร์ที่สอดคล้องกับ Remote Config ซึ่งคุณจะกำหนดค่าเพิ่มเติมได้ในคู่มือนี้ สำหรับข้อมูลเพิ่มเติม ข้อมูลเกี่ยวกับพารามิเตอร์เหล่านี้ โปรดดู ไคลเอ็นต์ Vertex AI Node.js

หรือไม่บังคับ คุณยังกำหนดค่าพารามิเตอร์เพื่อควบคุมว่า เข้าถึง Vertex AI Gemini API (ในตัวอย่างนี้คือพารามิเตอร์ที่ชื่อ vertex_enabled) การตั้งค่านี้จะมีประโยชน์เมื่อทดสอบฟังก์ชัน ใน ข้อมูลโค้ดต่อไปนี้ ค่านี้ตั้งเป็น false ซึ่งจะข้าม โดยใช้ Vertex AI ขณะทดสอบการทำให้ฟังก์ชันพื้นฐานใช้งานได้ กำลังตั้งค่าเป็น true จะเรียกใช้ Vertex AI Gemini API
```
// Define default (fallback) parameter values for Remote Config.
const defaultConfig = {

  // Default values for Vertex AI.
  model_name: "gemini-1.5-flash-preview-0514",
  generation_config: [{
    "stopSequences": [], "temperature": 0.7,
    "maxOutputTokens": 64, "topP": 0.1, "topK": 20
  }],
  prompt: "I'm a developer who wants to learn about Firebase and you are a \
    helpful assistant who knows everything there is to know about Firebase!",
  safety_settings: [{
    "category":
      "HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT",
    "threshold": "HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE"
  }],
  location: 'us-central1',

  // Disable Vertex AI Gemini API access for testing.
  vertex_enabled: false
};index.js
```

สร้างฟังก์ชันและตั้งค่า Remote Config ฝั่งเซิร์ฟเวอร์:

// Export the function.
exports.generateWithVertex = onRequest(async (request, response) => {

  try {

    // Set up Remote Config.
    const rc = getRemoteConfig(app);

    // Get the Remote Config template and assign default values.
    const template = await rc.getServerTemplate({
      defaultConfig: defaultConfig
    });

    // Add the template evaluation to a constant.
    const config = template.evaluate();

    // Obtain values from Remote Config.
    const textModel = config.getString("model_name") ||
        defaultConfig.model_name;
    const textPrompt = config.getString("prompt") || defaultConfig.prompt;
    const generationConfig = config.getString("generation_config") ||
        defaultConfig.generation_config;
    const safetySettings = config.getString("safety_settings") ||
        defaultConfig.safety_settings;
    const location = config.getString("location") ||
        defaultConfig.location;
    const vertexEnabled = config.getBoolean("is_vertex_enabled") ||
        defaultConfig.vertex_enabled;index.js

ตั้งค่า Vertex AI และเพิ่มตรรกะการแชทและการตอบกลับ ดังนี้

  // Allow user input.
  const userInput = request.query.prompt || '';

  // Instantiate Vertex AI.
    const vertex_ai = new VertexAI({ project: project, location: location });
    const generativeModel = vertex_ai.getGenerativeModel({
      model: textModel,
      safety_settings: safetySettings,
      generation_config: generationConfig,
    });

    // Combine prompt from Remote Config with optional user input.
    const chatInput = textPrompt + " " + userInput;

    if (!chatInput) {
      return res.status(400).send('Missing text prompt');
    }
    // If vertexEnabled isn't true, do not send queries to Vertex AI.
    if (vertexEnabled !== true) {
      response.status(200).send({
        message: "Vertex AI call skipped. Vertex is not enabled."
      });
      return;
    }

    logger.log("\nRunning with model ", textModel, ", prompt: ", textPrompt,
      ", generationConfig: ", generationConfig, ", safetySettings: ",
      safetySettings, " in ", location, "\n");

    const result = await generativeModel.generateContentStream(chatInput); 
    response.writeHead(200, { 'Content-Type': 'text/plain' });

    for await (const item of result.stream) {
      const chunk = item.candidates[0].content.parts[0].text;
      logger.log("Received chunk:", chunk);
      response.write(chunk);
    }

    response.end();

  } catch (error) {
    logger.error(error);
    response.status(500).send('Internal server error');
  }
});index.js

บันทึกและปิดไฟล์

ขั้นตอนที่ 5: สร้างเทมเพลต Remote Config เฉพาะเซิร์ฟเวอร์

ถัดไป ให้สร้างเทมเพลต Remote Config ฝั่งเซิร์ฟเวอร์และกำหนดค่าพารามิเตอร์ และค่าที่จะใช้ในฟังก์ชัน วิธีสร้าง URL เฉพาะเซิร์ฟเวอร์ เทมเพลต Remote Config:

เปิดคอนโซล Firebase และขยายจากเมนูการนำทาง เรียกใช้ และเลือก Remote Config
เลือก Server จากตัวเลือก Client/Server ที่ด้านบน Remote Config หน้า
- หากใช้งาน Remote Config หรือเทมเพลตเซิร์ฟเวอร์เป็นครั้งแรก คลิก Create Configuration หน้าต่างสร้างฝั่งเซิร์ฟเวอร์แรกของคุณ แผงพารามิเตอร์จะปรากฏขึ้น
- หากนี่ไม่ใช่ครั้งแรกที่คุณใช้เทมเพลตเซิร์ฟเวอร์ Remote Config คลิกเพิ่มพารามิเตอร์

กำหนดพารามิเตอร์ Remote Config ต่อไปนี้

ชื่อพารามิเตอร์	คำอธิบาย	ประเภท	ค่าเริ่มต้น
`model_name`	ชื่อรุ่น สำหรับรายการชื่อโมเดลล่าสุดที่จะใช้ในโค้ดของคุณ โปรดดู โมเดล เวอร์ชันและวงจร หรือ พร้อมใช้งาน ชื่อรุ่น	สตริง	`gemini-1.5-pro-preview-0514`
`prompt`	ข้อความแจ้งให้แทรกคำค้นหาของผู้ใช้	สตริง	`I'm a developer who wants to learn about Firebase and you are a helpful assistant who knows everything there is to know about Firebase!`
`generation_config`	พารามิเตอร์ เพื่อส่งให้กับโมเดล	JSON	`[{"stopSequences": ["I hope this helps"],"temperature": 0.7,"maxOutputTokens": 512, "topP": 0.1,"topK": 20}]`
`safety_settings`	ความปลอดภัย การตั้งค่าสำหรับ Vertex AI	JSON	`[{"category": "HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "HarmBlockThreshold.BLOCK_LOW_AND_ABOVE"}]`
`location`	สถานที่ตั้ง เพื่อเรียกใช้บริการและโมเดล Vertex AI	สตริง	`us-central1`
`is_vertex_enabled`	พารามิเตอร์ที่ไม่บังคับซึ่งควบคุมว่าจะส่งคำค้นหาไปยัง Vertex AI	บูลีน	`true`

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

ขั้นตอนที่ 6: ทำให้ฟังก์ชันใช้งานได้และทดสอบใน Firebase Local Emulator Suite

ตอนนี้คุณก็พร้อมที่จะปรับใช้และทดสอบฟังก์ชันภายในเครื่องด้วย Firebase Local Emulator Suite

ตรวจสอบว่าคุณได้ตั้งค่า GOOGLE_APPLICATION_CREDENTIALS เป็นสภาพแวดล้อมแล้ว ตามที่อธิบายไว้ในขั้นตอนที่ 3: กําหนดค่าสิทธิ์ IAM สําหรับ Admin SDK แล้วบันทึก จากนั้น จาก ไดเรกทอรีหลักของไดเรกทอรี functions ของคุณ ทำให้ฟังก์ชันใช้งานได้ โปรแกรมจำลอง Firebase:
```
firebase emulators:start --project PROJECT_ID --only functions
```
เคล็ดลับ: คุณยังเรียกใช้ฟังก์ชันในโปรแกรมจำลองได้ด้วยโดยเรียกใช้ npm run serve จากไดเรกทอรี functions
เปิด บันทึกของโปรแกรมจำลอง ซึ่งน่าจะแสดงให้เห็นว่าฟังก์ชันโหลดแล้ว
เข้าถึงฟังก์ชันโดยเรียกใช้คำสั่งต่อไปนี้ โดยที่ PROJECT_ID คือรหัสโปรเจ็กต์และ LOCATION คือภูมิภาคที่คุณทำให้ใช้งานได้ ฟังก์ชันที่จะ (เช่น us-central1):
```
curl http://localhost:5001/PROJECT_ID/LOCATION/generateWithVertex
```
เคล็ดลับ: ลิงก์นี้จะปรากฏในเอาต์พุตของคอนโซลหลังจากเริ่มต้น โปรแกรมจำลอง นอกจากนี้ คุณยังตัดและวางลงในเบราว์เซอร์ได้ด้วย
รอการตอบกลับ จากนั้นกลับไปที่หน้าบันทึกโปรแกรมจำลอง Firebase หรือ และตรวจหาข้อผิดพลาดหรือคำเตือน
ลองส่งข้อมูลจากผู้ใช้ โปรดทราบว่า is_vertex_enabled มีค่า กำหนดค่าไว้ในเทมเพลตเซิร์ฟเวอร์ Remote Config แล้ว Gemini ผ่าน Vertex AI Gemini API และนี่อาจ มีค่าใช้จ่าย:
```
curl http://localhost:5001/PROJECT_ID/LOCATION/generateWithVertex?prompt=Tell%20me%20everything%20you%20know%20about%20cats
```
ทำการเปลี่ยนแปลงเทมเพลตเซิร์ฟเวอร์ Remote Config ใน Firebase จากนั้นเข้าถึงฟังก์ชันอีกครั้งเพื่อดูการเปลี่ยนแปลง

ขั้นตอนที่ 7: ทำให้ฟังก์ชันใช้งานได้กับ Google Cloud

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

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

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

ทำให้ฟังก์ชันใช้งานได้โดยใช้ Firebase CLI:

firebase deploy --only functions

บล็อกการเข้าถึงฟังก์ชันที่ไม่ได้ตรวจสอบสิทธิ์

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

หากต้องการบล็อกการเข้าถึงฟังก์ชันที่ไม่ได้ตรวจสอบสิทธิ์ ให้ทำดังนี้

ในคอนโซล Google Cloud ให้เปิด Cloud Run
คลิก generateWithVertex จากนั้นคลิกแท็บความปลอดภัย
เปิดใช้ต้องมีการตรวจสอบสิทธิ์ แล้วคลิกบันทึก

กำหนดค่าบัญชีผู้ใช้เพื่อใช้ข้อมูลเข้าสู่ระบบของบัญชีบริการ Admin SDK

เนื่องจากบัญชีบริการ Admin SDK มีบทบาทที่จำเป็นและ สิทธิ์ในการเรียกใช้ฟังก์ชันและโต้ตอบกับ Remote Config และ Vertex AI Gemini API คุณควรใช้ไฟล์นี้เพื่อเรียกใช้ฟังก์ชัน สิ่งต้องทำ คุณต้องสามารถสร้างโทเค็นสำหรับบัญชีจากบัญชีผู้ใช้ของคุณ

ขั้นตอนต่อไปนี้อธิบายวิธีกำหนดค่าบัญชีผู้ใช้และฟังก์ชัน ที่จะเรียกใช้ด้วยสิทธิ์ของบัญชีบริการ Admin SDK

ในคอนโซล Google Cloud ให้เปิดใช้ API ข้อมูลเข้าสู่ระบบบัญชีบริการ IAM
มอบบทบาทผู้สร้างโทเค็นบัญชีบริการให้กับบัญชีผู้ใช้: จาก คอนโซล Google Cloud เปิด IAM และ ผู้ดูแลระบบ > IAM เลือกผู้ใช้ของคุณ แล้วคลิกแก้ไขผู้ใช้หลัก > เพิ่มบทบาทอื่น
เลือก Service Account Token Creator แล้วคลิกบันทึก

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

ตั้งค่า gcloud CLI

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

หากต้องการเปิดใช้การสร้างโทเค็น ให้ติดตั้งและกำหนดค่า gcloud CLI ดังนี้

หากยังไม่ได้ติดตั้งในคอมพิวเตอร์ ให้ติดตั้ง gcloud CLI เป็น ที่อธิบายไว้ในหัวข้อติดตั้ง gcloud CLI
รับข้อมูลเข้าสู่ระบบสำหรับบัญชี Google Cloud ของคุณ:
```
gcloud auth login
```
ตั้งค่ารหัสโปรเจ็กต์ใน gcloud ดังนี้
```
gcloud config set project PROJECT_ID
```

ทดสอบฟังก์ชัน

คุณพร้อมทดสอบฟังก์ชันใน Google Cloud แล้ว วิธีทดสอบฟังก์ชัน เรียกใช้คำสั่งต่อไปนี้

curl -X POST https://LOCATION-PROJECT_ID.cloudfunctions.net/generateWithVertex \
  -H "Authorization: bearer $(gcloud auth print-identity-token)" \
  -H "Content-Type: application/json"

ลองอีกครั้งโดยใช้ข้อมูลที่ผู้ใช้ให้ไว้

curl -X POST https://LOCATION-PROJECT_ID.cloudfunctions.net/generateWithVertex?prompt=Tell%20me%20everything%20you%20know%20about%20dogs \
 -H "Authorization: bearer $(gcloud auth print-identity-token)" \
 -H "Content-Type: application/json"

ตอนนี้คุณเปลี่ยนแปลงเทมเพลตเซิร์ฟเวอร์ Remote Config ได้แล้ว เผยแพร่ การเปลี่ยนแปลงเหล่านั้น และทดสอบตัวเลือกต่างๆ

ขั้นตอนถัดไป

Firebase ขอแนะนำให้ใช้ App Check เพื่อรักษาความปลอดภัย Cloud Functions ดูเปิดใช้งานการบังคับใช้ App Check สำหรับ Cloud Functions เพื่อดูข้อมูลเพิ่มเติมเกี่ยวกับการรักษาความปลอดภัยให้ฟังก์ชันด้วย App Check
ลองใช้ตัวอย่างฟังก์ชันที่เรียกใช้ได้ที่มี Remote Config ฝั่งเซิร์ฟเวอร์และ ที่ App Check โทรหา Vertex AI Gemini API กับ Remote Config และ App Check
เรียนรู้เพิ่มเติมเกี่ยวกับ Cloud Functions สำหรับ Firebase
ดูข้อมูลเพิ่มเติมเกี่ยวกับการใช้ Remote Config ในเซิร์ฟเวอร์ สภาพแวดล้อม