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

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

ในบทแนะนำนี้ คุณจะได้เพิ่มการกำหนดค่าระยะไกลลงในฟังก์ชันที่เหมือนแชทบ็อต ใช้โมเดล Gemini เพื่อตอบคำถามของผู้ใช้ การกำหนดค่าระยะไกลจะ จัดการอินพุต Gemini API (รวมถึงพรอมต์ที่คุณจะเพิ่ม คำถามของผู้ใช้ที่ได้รับ) และคุณสามารถอัปเดตข้อมูลเหล่านี้ได้ตามต้องการจาก คอนโซล Firebase นอกจากนี้คุณยังใช้ชุดโปรแกรมจำลองภายในของ Firebase เพื่อทดสอบและ ดีบักฟังก์ชัน จากนั้นหลังจากยืนยันว่าใช้งานได้แล้ว คุณจะทำให้ใช้งานได้และ ทดสอบใน 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 เพื่อเขียนฟังก์ชัน และ คุณจะต้องมี Firebase CLI เพื่อทำให้ฟังก์ชันใช้งานได้กับ Cloud Functions รันไทม์

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

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

  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 ที่มีการกำหนดค่าระยะไกลและ Vertex AI:

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

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

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

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

    การเปิดใช้ API อาจใช้เวลาสักครู่จึงจะเสร็จสมบูรณ์ เก็บหน้าเว็บไว้ ทำงานและเปิดอยู่จนกว่าการเปิดใช้จะเสร็จสิ้น

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

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

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

  2. ลงชื่อเข้าสู่ระบบ Firebase

    firebase login

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

    firebase init functions

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    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

  3. กําหนดค่าเริ่มต้นที่ฟังก์ชันจะใช้หากเชื่อมต่อไม่ได้ เซิร์ฟเวอร์การกำหนดค่าระยะไกล โซลูชันนี้จะกำหนดค่า textModel generationConfig, safetySettings, textPrompt และ location เป็น พารามิเตอร์การกำหนดค่าระยะไกลที่สอดคล้องกับการกำหนดค่าระยะไกล ซึ่งคุณจะกำหนดค่าเพิ่มเติมได้ในคู่มือนี้ สำหรับข้อมูลเพิ่มเติม ข้อมูลเกี่ยวกับพารามิเตอร์เหล่านี้ โปรดดู ไคลเอ็นต์ 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

  4. สร้างฟังก์ชันและตั้งค่า การกำหนดค่าระยะไกลฝั่งเซิร์ฟเวอร์:

    // 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: สร้างเทมเพลตการกำหนดค่าระยะไกลเฉพาะเซิร์ฟเวอร์

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

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

  2. เลือก Server จากตัวเลือก Client/Server ที่ด้านบน หน้าการกำหนดค่าระยะไกล

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

  3. กำหนดพารามิเตอร์การกำหนดค่าระยะไกลต่อไปนี้

    ชื่อพารามิเตอร์ คำอธิบาย ประเภท ค่าเริ่มต้น
    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

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

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

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

  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 มีค่า ที่กำหนดค่าไว้ในเทมเพลตเซิร์ฟเวอร์การกำหนดค่าระยะไกล การดำเนินการนี้ควรเข้าถึง Gemini ผ่าน Vertex AI Gemini API และนี่อาจเป็น มีค่าใช้จ่าย:

    curl http://localhost:5001/PROJECT_ID/LOCATION/generateWithVertex?prompt=Tell%20me%20everything%20you%20know%20about%20cats

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

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

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

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

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

firebase deploy --only functions

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

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

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

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

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

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

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

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

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

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

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

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

  4. เปิดหน้า Cloud Functions สำหรับ Google Cloud Console และคลิกฟังก์ชัน 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"

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

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