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

  1. ลงชื่อเข้าใช้คอนโซล Firebase

  2. คลิกสร้างโปรเจ็กต์ แล้วใช้ตัวเลือกใดตัวเลือกหนึ่งต่อไปนี้

    • ตัวเลือกที่ 1: สร้างโปรเจ็กต์ Firebase ใหม่ (และโปรเจ็กต์พื้นฐาน Google Cloudโดยอัตโนมัติ) โดยป้อนชื่อโปรเจ็กต์ใหม่ใน ขั้นตอนแรกของเวิร์กโฟลว์ "สร้างโปรเจ็กต์"
    • ตัวเลือกที่ 2: "เพิ่ม Firebase" ลงในโปรเจ็กต์ Google Cloud ที่มีอยู่โดย เลือกชื่อโปรเจ็กต์ Google Cloud จากเมนูแบบเลื่อนลงใน ขั้นตอนแรกของเวิร์กโฟลว์ "สร้างโปรเจ็กต์"

  3. เมื่อได้รับข้อความแจ้ง คุณไม่จำเป็นต้องตั้งค่า Google Analytics เพื่อใช้ โซลูชันนี้

  4. ทำตามวิธีการบนหน้าจอต่อไปเพื่อสร้างโปรเจ็กต์

หากคุณมีโปรเจ็กต์ Firebase อยู่แล้ว

ไปที่กำหนดค่าสภาพแวดล้อมในการพัฒนา

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

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

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

    สําหรับการติดตั้ง Node.js และ npm เราขอแนะนําให้ใช้ Node Version Manager

  2. ติดตั้ง Firebase CLI โดยใช้วิธีการที่ต้องการ เช่น หากต้องการติดตั้ง CLI โดยใช้ npm ให้เรียกใช้คำสั่งนี้

    npm install -g firebase-tools@latest

    คำสั่งนี้จะติดตั้งคำสั่ง firebase ที่พร้อมใช้งานทั่วโลก หากคำสั่งนี้ไม่สำเร็จ คุณอาจต้องเปลี่ยนสิทธิ์ npm

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

  3. ติดตั้ง firebase-functions และ firebase-admin แล้วใช้ --save เพื่อบันทึก ลงใน package.json โดยทำดังนี้

    npm install firebase-functions@latest firebase-admin@latest --save

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

การใช้งาน

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

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

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

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

  4. คลิกเปิดใช้ API ที่แนะนำทั้งหมด

    การเปิดใช้ API อาจใช้เวลาสักครู่ โปรดเปิดหน้าเว็บ ไว้จนกว่าการเปิดใช้จะเสร็จสิ้น

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

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

  1. เปิดเทอร์มินัลในคอมพิวเตอร์ แล้วไปที่ไดเรกทอรีที่คุณ วางแผนจะสร้างฟังก์ชัน

  2. เข้าสู่ระบบ Firebase โดยทำดังนี้

    firebase login

  3. เรียกใช้คำสั่งต่อไปนี้เพื่อเริ่มต้น Cloud Functions for Firebase

    firebase init functions

  4. เลือกใช้โปรเจ็กต์ที่มีอยู่และระบุรหัสโปรเจ็กต์

  5. เมื่อได้รับข้อความแจ้งให้เลือกภาษาที่จะใช้ ให้เลือก Javascript แล้วกด Enter

  6. สำหรับตัวเลือกอื่นๆ ทั้งหมด ให้เลือกค่าเริ่มต้น

    ระบบจะสร้างไดเรกทอรี functions ในไดเรกทอรีปัจจุบัน ภายใน คุณจะเห็นไฟล์ index.js ที่จะใช้สร้างฟังก์ชัน ไดเรกทอรี node_modules ที่มีทรัพยากร Dependency สำหรับฟังก์ชัน และไฟล์ package.json ที่มีทรัพยากร Dependency ของแพ็กเกจ

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

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

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

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

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

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

  1. ในคอนโซล Google Cloud ให้เปิดหน้าข้อมูลเข้าสู่ระบบ
  2. คลิกบัญชีบริการ Admin SDK เพื่อเปิดหน้ารายละเอียด
  3. คลิกคีย์
  4. คลิกเพิ่มคีย์ > สร้างคีย์ใหม่
  5. ตรวจสอบว่าได้เลือก JSON เป็นประเภทคีย์แล้ว จากนั้นคลิกสร้าง
  6. ดาวน์โหลดคีย์ไปยังที่ปลอดภัยในคอมพิวเตอร์

  7. จากเทอร์มินัลของคุณ ให้ส่งออกคีย์เป็นตัวแปรสภาพแวดล้อม:

    export GOOGLE_APPLICATION_CREDENTIALS="/path/to/your/service-account-key.json"

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

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

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

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

    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

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

    นอกจากนี้ คุณยังกำหนดค่าพารามิเตอร์เพื่อควบคุมว่าจะเข้าถึง 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-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

  4. สร้างฟังก์ชันและตั้งค่า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

  5. ตั้งค่า 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

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

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

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

  1. เปิดFirebaseคอนโซล แล้วขยายเรียกใช้จากเมนูการนำทาง แล้วเลือก Remote Config

  2. เลือกเซิร์ฟเวอร์จากตัวเลือกไคลเอ็นต์/เซิร์ฟเวอร์ที่ด้านบนของ Remote Config หน้า

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

  3. กําหนดพารามิเตอร์ 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 การตั้งค่าความปลอดภัย สำหรับ 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

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

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

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

  1. ตรวจสอบว่าคุณได้ตั้งค่า GOOGLE_APPLICATION_CREDENTIALS เป็นตัวแปรสภาพแวดล้อมตามที่อธิบายไว้ในขั้นตอนที่ 3: กำหนดค่าสิทธิ์ IAM สำหรับบัญชีบริการ Admin SDK และบันทึกคีย์ จากนั้นจากไดเรกทอรีหลักของไดเรกทอรี functions ให้ทําการติดตั้งใช้งานฟังก์ชันไปยังโปรแกรมจำลอง Firebase โดยใช้คำสั่งต่อไปนี้

    firebase emulators:start --project PROJECT_ID --only functions

  2. เปิดหน้าบันทึกของโปรแกรมจำลอง ซึ่งควรแสดงว่าฟังก์ชันโหลดแล้ว

  3. เข้าถึงฟังก์ชันโดยเรียกใช้คำสั่งต่อไปนี้ โดยที่ PROJECT_ID คือรหัสโปรเจ็กต์ และ LOCATION คือภูมิภาคที่คุณได้ติดตั้งใช้งาน ฟังก์ชัน (เช่น us-central1)

    curl http://localhost:5001/PROJECT_ID/LOCATION/generateWithVertex

  4. รอการตอบกลับ จากนั้นกลับไปที่หน้าบันทึกของโปรแกรมจำลอง Firebase หรือคอนโซลของคุณ แล้วตรวจสอบหาข้อผิดพลาดหรือคำเตือน

  5. ลองส่งข้อมูลที่ผู้ใช้ป้อน โดยโปรดทราบว่าเนื่องจากมีการกำหนดค่า 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

  6. ทำการเปลี่ยนแปลงเทมเพลตเซิร์ฟเวอร์ในคอนโซล Remote Config Firebase จากนั้นเข้าถึงฟังก์ชันอีกครั้งเพื่อดูการเปลี่ยนแปลง

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

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

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

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

firebase deploy --only functions

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

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

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

  1. ในGoogle Cloudคอนโซล ให้เปิด Cloud Run

  2. คลิก generateWithVertex แล้วคลิกแท็บความปลอดภัย

  3. เปิดใช้ต้องมีการตรวจสอบสิทธิ์ แล้วคลิกบันทึก

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

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

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

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

  3. เลือก Service Account Token Creator แล้วคลิกบันทึก

    ดูข้อมูลโดยละเอียดเกี่ยวกับการแอบอ้างเป็นบัญชีบริการได้ที่ การแอบอ้างเป็นบัญชีบริการ ในเอกสารประกอบของ Google Cloud

  4. เปิดหน้าGoogle Cloudคอนโซล Cloud Functions แล้วคลิกฟังก์ชัน generateWithVertex ในรายการฟังก์ชัน

  5. เลือกทริกเกอร์ > แก้ไข แล้วขยายการตั้งค่ารันไทม์ การสร้าง การเชื่อมต่อ และความปลอดภัย

  6. จากแท็บรันไทม์ ให้เปลี่ยนบัญชีบริการรันไทม์เป็น บัญชี Admin SDK

  7. คลิกถัดไป แล้วคลิกทำให้ใช้งานได้

ตั้งค่า gcloud CLI

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

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

  1. หากยังไม่ได้ติดตั้งในคอมพิวเตอร์ ให้ติดตั้ง gcloud CLI ตามที่อธิบายไว้ในติดตั้ง gcloud CLI

  2. รับข้อมูลเข้าสู่ระบบสำหรับบัญชี Google Cloud

    gcloud auth login

  3. ตั้งรหัสโปรเจ็กต์ใน 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เทมเพลตเซิร์ฟเวอร์ เผยแพร่ การเปลี่ยนแปลงเหล่านั้น และทดสอบตัวเลือกต่างๆ ได้แล้ว

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