Google ใช้เทคโนโลยี AI เพื่อแปลเนื้อหาเป็นภาษาที่คุณต้องการ การแปลโดย AI อาจมีข้อผิดพลาด

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

คู่มือนี้อธิบายวิธีเริ่มต้นใช้งาน Cloud Functions รุ่นที่ 2 ด้วยRemote Configฝั่งเซิร์ฟเวอร์เพื่อทําการเรียกฝั่งเซิร์ฟเวอร์ไปยัง Agent Platform Gemini API (formerly Vertex AI)

ในบทแนะนำนี้ คุณจะเพิ่ม 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

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

หากต้องการอัปเดตเป็น firebase-tools เวอร์ชันล่าสุด ให้เรียกใช้คำสั่งเดิมอีกครั้ง

หมายเหตุ: คุณยังเรียกใช้คำสั่ง CLI ของ Firebase ใน Cloud Shell ได้ด้วย Cloud Shell เป็นสภาพแวดล้อมบรรทัดคำสั่งที่ทำงานในเบราว์เซอร์และมีการตรวจสอบสิทธิ์ล่วงหน้า ซึ่งเข้าถึงได้จากคอนโซล Firebase และมาพร้อมกับ Firebase CLI ที่ติดตั้งไว้ล่วงหน้า จึงเป็นตัวเลือกที่สะดวกในการเริ่มต้นใช้งานอย่างรวดเร็ว เพียงแค่เพิ่มไฟล์โปรเจ็กต์ลงในCloud Shellสภาพแวดล้อม
ติดตั้ง firebase-functions และ firebase-admin แล้วใช้ --save เพื่อบันทึก ลงใน package.json
```
npm install firebase-functions@latest firebase-admin@latest --save
```

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

การใช้งาน

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

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

ขั้นตอนที่ 1: เปิดใช้ Agent PlatformAPI ที่แนะนำในGoogle Cloudคอนโซล

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

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

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

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

ระบบจะสร้างไดเรกทอรี functions ในไดเรกทอรีปัจจุบัน ภายใน คุณจะเห็นไฟล์ index.js ที่จะใช้สร้างฟังก์ชัน ไดเรกทอรี node_modules ที่มีทรัพยากร Dependency สำหรับฟังก์ชัน และไฟล์ package.json ที่มีทรัพยากร Dependency ของแพ็กเกจ
เพิ่มแพ็กเกจ Admin SDK และ Agent Platform โดยเรียกใช้คำสั่งต่อไปนี้โดยใช้ --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.js ที่คุณติดตั้งและเวอร์ชันที่คุณเรียกใช้ใน Google Cloud ในท้ายที่สุด เช่น หากกำหนดค่า engines ใน package.json เป็น Node เวอร์ชัน 18 และคุณใช้ Node.js 20 ให้อัปเดตไฟล์เพื่อใช้ 20 ดังนี้

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

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

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

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

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

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

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

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

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

ลบเนื้อหาที่มีอยู่ แล้วเพิ่ม Admin SDK, Remote Config และ SDK ของ Agent Platform จากนั้นเริ่มต้นแอปโดย วางโค้ดต่อไปนี้ลงในไฟล์

const { onRequest } = require("firebase-functions/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 ซึ่งคุณจะกำหนดค่าเพิ่มเติมในคำแนะนำนี้ ดูข้อมูลเพิ่มเติมเกี่ยวกับพารามิเตอร์เหล่านี้ได้ที่ไคลเอ็นต์ Node.js ของ Vertex AI

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

  // Default values for Vertex AI.
  model_name: "gemini-1.5-flash-002",
  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

ตั้งค่า Agent Platform และเพิ่มตรรกะแชทและการตอบกลับ

  // 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เทมเพลตฝั่งเซิร์ฟเวอร์และกำหนดค่าพารามิเตอร์ และค่าที่จะใช้ในฟังก์ชัน วิธีสร้างเทมเพลต Remote Configเฉพาะเซิร์ฟเวอร์

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

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

ชื่อพารามิเตอร์	คำอธิบาย	ประเภท	ค่าเริ่มต้น
`model_name`	ชื่อโมเดล ดูรายการชื่อโมเดลล่าสุดที่จะใช้ในโค้ดได้ที่ เวอร์ชันและวงจรของโมเดล หรือ ชื่อโมเดลที่พร้อมใช้งาน	สตริง	`gemini-2.0-flash`
`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`	การตั้งค่าความปลอดภัยสำหรับ Agent Platform	JSON	`[{"category": "HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "HarmBlockThreshold.BLOCK_LOW_AND_ABOVE"}]`
`location`	สถานที่ที่จะเรียกใช้บริการและโมเดล Agent Platform	สตริง	`global`
`is_vertex_enabled`	พารามิเตอร์ที่ไม่บังคับซึ่งควบคุมว่าจะส่งการค้นหาไปยัง Agent Platform หรือไม่	บูลีน	`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 ผ่าน Agent Platform Gemini API (formerly Vertex AI) และอาจมีค่าใช้จ่ายเกิดขึ้น
```
curl http://localhost:5001/PROJECT_ID/LOCATION/generateWithVertex?prompt=Tell%20me%20everything%20you%20know%20about%20cats
```
ทำการเปลี่ยนแปลงเทมเพลตRemote Configเซิร์ฟเวอร์ใน Firebaseคอนโซล แล้วเข้าถึงฟังก์ชันอีกครั้งเพื่อดูการเปลี่ยนแปลง

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

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

Agent Platformราคา และราคาของ Cloud Functions ก่อนดำเนินการต่อ

ติดตั้งใช้งานฟังก์ชัน

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

firebase deploy --only functions

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

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

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

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

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

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

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

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

ดูข้อมูลโดยละเอียดเพิ่มเติมเกี่ยวกับการแอบอ้างเป็นบัญชีบริการได้ที่ การแอบอ้างเป็นบัญชีบริการ ในเอกสารประกอบของ Google Cloud
เปิดหน้าคอนโซล Google Cloud Cloud Functions แล้วคลิกฟังก์ชัน 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 ได้ที่หัวข้อเปิดใช้การบังคับใช้ App Check สำหรับ Cloud Functions
ลองใช้ฟังก์ชันที่เรียกใช้ได้ตัวอย่างกับ Remote Config ฝั่งเซิร์ฟเวอร์และ App Check ที่ เรียกใช้ Agent Platform Gemini API (formerly Vertex AI) ด้วย Remote Config และ App Check
ดูข้อมูลเพิ่มเติมเกี่ยวกับ Cloud Functions สำหรับ Firebase
ดูข้อมูลเพิ่มเติมเกี่ยวกับการใช้ Remote Config ในสภาพแวดล้อมของเซิร์ฟเวอร์