Gemini API ให้คุณดึงข้อมูลเชิงความหมายตามข้อมูลของคุณเองได้ เนื่องจาก ข้อมูลของคุณได้ วิธีนี้ต้องมีการควบคุมการเข้าถึงที่เข้มงวดกว่าคีย์ API
การเริ่มต้นอย่างรวดเร็วนี้ใช้วิธีการตรวจสอบสิทธิ์ที่ง่ายและเหมาะสม สำหรับสภาพแวดล้อมการทดสอบ สำหรับสภาพแวดล้อมของการใช้งานจริง โปรดเรียนรู้ ประมาณ การตรวจสอบสิทธิ์และการให้สิทธิ์ ก่อน การเลือกข้อมูลเข้าสู่ระบบ ที่เหมาะกับแอปของคุณ
วัตถุประสงค์
- ตั้งค่าโปรเจ็กต์ที่อยู่ในระบบคลาวด์สำหรับ OAuth
- ตั้งค่าข้อมูลเข้าสู่ระบบเริ่มต้นของแอปพลิเคชัน
- จัดการข้อมูลเข้าสู่ระบบในโปรแกรมของคุณแทนการใช้
gcloud auth
ข้อกำหนดเบื้องต้น
หากต้องการเรียกใช้การเริ่มต้นอย่างรวดเร็วนี้ คุณต้องมีสิ่งต่อไปนี้
ตั้งค่าโปรเจ็กต์ที่อยู่ในระบบคลาวด์
คุณต้องตั้งค่าโปรเจ็กต์ที่อยู่ในระบบคลาวด์ก่อน เพื่อให้เสร็จสมบูรณ์สำหรับการเริ่มต้นอย่างรวดเร็วนี้
1. เปิดใช้ API
ก่อนใช้ Google APIs คุณต้องเปิดใช้ API เหล่านี้ในโปรเจ็กต์ Google Cloud
เปิดใช้ Google Generative Language API ในคอนโซล Google Cloud
2. กำหนดค่าหน้าจอขอความยินยอม OAuth
ถัดไป ให้กำหนดค่าหน้าจอคำยินยอม OAuth ของโครงการและเพิ่มตัวคุณเองเป็นการทดสอบ ผู้ใช้ หากทําตามขั้นตอนนี้สําหรับโปรเจ็กต์ที่อยู่ในระบบคลาวด์เรียบร้อยแล้ว ให้ข้ามไปที่ ส่วนถัดไป
ในคอนโซล Google Cloud ให้ไปที่เมนู > API และ บริการ > OAuth หน้าจอขอความยินยอม
เลือกประเภทผู้ใช้ภายนอกสำหรับแอป แล้วคลิกสร้าง
กรอกแบบฟอร์มการลงทะเบียนแอป (คุณสามารถเว้นช่องส่วนใหญ่ว่างไว้ได้) แล้วคลิกบันทึกและต่อไป
ในตอนนี้ คุณสามารถข้ามการเพิ่มขอบเขต แล้วคลิกบันทึกและดำเนินการต่อได้ ใน เมื่อคุณสร้างแอปสำหรับใช้ภายนอก Google Workspace คุณต้องเพิ่มและยืนยันขอบเขตการให้สิทธิ์ที่ แอปจำเป็นต้องใช้
เพิ่มผู้ใช้ทดสอบ
- ในส่วนผู้ใช้ทดสอบ ให้คลิกเพิ่มผู้ใช้
- ป้อนอีเมลของคุณและผู้ใช้ทดสอบรายอื่นๆ ที่ได้รับอนุญาต คลิกบันทึกและดำเนินการต่อ
ตรวจสอบสรุปการลงทะเบียนแอป หากต้องการเปลี่ยนแปลง ให้คลิกแก้ไข ถ้า การลงทะเบียนแอปถูกต้องแล้ว จากนั้นคลิกกลับไปที่แดชบอร์ด
3. ให้สิทธิ์ข้อมูลเข้าสู่ระบบสำหรับแอปพลิเคชันเดสก์ท็อป
หากต้องการตรวจสอบสิทธิ์ในฐานะผู้ใช้ปลายทางและเข้าถึงข้อมูลผู้ใช้ในแอป คุณจะต้องดำเนินการต่อไปนี้ สร้างรหัสไคลเอ็นต์ OAuth 2.0 อย่างน้อย 1 รหัส รหัสไคลเอ็นต์ใช้เพื่อระบุ แอปเดียวไปยังเซิร์ฟเวอร์ OAuth ของ Google หากแอปทำงานบนหลายแพลตฟอร์ม คุณต้องสร้างรหัสไคลเอ็นต์แยกกันสำหรับแต่ละแพลตฟอร์ม
ในคอนโซล Google Cloud ให้ไปที่เมนู > API และ บริการ > ข้อมูลเข้าสู่ระบบ
คลิกสร้างข้อมูลเข้าสู่ระบบ > รหัสไคลเอ็นต์ OAuth
คลิกประเภทแอปพลิเคชัน > แอปบนเดสก์ท็อป
ในช่องชื่อ ให้พิมพ์ชื่อของข้อมูลเข้าสู่ระบบ ชื่อนี้เป็นเพียง ที่แสดงในคอนโซล Google Cloud
คลิกสร้าง หน้าจอที่สร้างไคลเอ็นต์ OAuth จะปรากฏขึ้น ซึ่งจะแสดง Client-ID และรหัสลับไคลเอ็นต์
คลิกตกลง ข้อมูลเข้าสู่ระบบที่สร้างขึ้นใหม่จะปรากฏในส่วนไคลเอ็นต์ OAuth 2.0 บัตรประจำตัว
คลิกปุ่มดาวน์โหลดเพื่อบันทึกไฟล์ JSON ซึ่งจะได้รับการบันทึกเป็น
client_secret_<identifier>.json
และเปลี่ยนชื่อเป็นclient_secret.json
และย้ายไปยังไดเรกทอรีที่ใช้งานอยู่
ตั้งค่าข้อมูลเข้าสู่ระบบเริ่มต้นของแอปพลิเคชัน
หากต้องการแปลงไฟล์ client_secret.json
เป็นข้อมูลเข้าสู่ระบบที่ใช้ได้ ให้ส่ง
กำหนดตำแหน่งของคำสั่ง gcloud auth application-default login
อาร์กิวเมนต์ --client-id-file
gcloud auth application-default login \
--client-id-file=client_secret.json \
--scopes='https://www.googleapis.com/auth/cloud-platform,https://www.googleapis.com/auth/generative-language.retriever'
การตั้งค่าโครงการแบบง่ายในบทแนะนำนี้เรียกใช้ "Google ยืนยันแอปนี้แล้ว" ซึ่งเป็นเรื่องปกติ ให้เลือก "ดำเนินการต่อ"
วิธีนี้จะวางโทเค็นที่ได้ไว้ในตำแหน่งที่รู้จักเพื่อให้เข้าถึงได้
โดย gcloud
หรือไลบรารีของไคลเอ็นต์
gcloud auth application-default login
--no-browser
--client-id-file=client_secret.json
--scopes='https://www.googleapis.com/auth/cloud-platform,https://www.googleapis.com/auth/generative-language.retriever'
เมื่อคุณตั้งค่าข้อมูลรับรองเริ่มต้นของแอปพลิเคชัน (ACD) แล้ว ไคลเอ็นต์ ห้องสมุดในภาษาส่วนใหญ่ต้องการความช่วยเหลือในการค้นหาน้อยมากหรือไม่มีเลย
Curl
วิธีที่เร็วที่สุดในการทดสอบว่าวิธีนี้ได้ผลคือการใช้เพื่อเข้าถึง REST API ที่ใช้ curl:
access_token=$(gcloud auth application-default print-access-token) project_id=<MY PROJECT ID>
curl -X GET https://generativelanguage.googleapis.com/v1/models \ -H 'Content-Type: application/json' \ -H "Authorization: Bearer ${access_token}" \ -H "x-goog-user-project: ${project_id}" | grep '"name"'
Python
ใน Python ไลบรารีของไคลเอ็นต์ควรค้นหาได้โดยอัตโนมัติ:
pip install google-generativeai
สคริปต์ขนาดเล็กที่จะทดสอบอาจเป็นดังนี้
import google.generativeai as genai
print('Available base models:', [m.name for m in genai.list_models()])
ขั้นตอนถัดไป
ถ้าได้ผล คุณก็พร้อมที่จะลองใช้ การดึงข้อมูลเชิงความหมายในข้อมูลข้อความ
จัดการข้อมูลเข้าสู่ระบบด้วยตนเอง [Python]
ในหลายกรณี คุณจะไม่มีคำสั่ง gcloud
เพื่อสร้างการเข้าถึง
โทเค็นจาก Client-ID (client_secret.json
) Google จัดให้มีห้องสมุดใน
หลายภาษาเพื่อให้คุณจัดการกระบวนการดังกล่าวภายในแอปของคุณได้ ส่วนนี้
จะสาธิตกระบวนการใน Python มีตัวอย่างที่คล้ายกันของการจัดเรียงนี้
สำหรับภาษาอื่นๆ ที่อยู่ใน
เอกสารประกอบของ Drive API
1. ติดตั้งไลบรารีที่จำเป็น
ติดตั้งไลบรารีของไคลเอ็นต์ Google สำหรับ Python และไลบรารีของไคลเอ็นต์ Gemini
pip install --upgrade -q google-api-python-client google-auth-httplib2 google-auth-oauthlib
pip install google-generativeai
2. เขียนเครื่องมือจัดการข้อมูลเข้าสู่ระบบ
เพื่อลดจำนวนครั้งที่คุณต้องคลิกผ่านการให้สิทธิ์
สร้างไฟล์ชื่อ load_creds.py
ในไดเรกทอรีการทำงานเพื่อ
จะแคชไฟล์ token.json
ที่นำไปใช้ซ้ำในภายหลังได้ หรือรีเฟรชหากไฟล์หมดอายุ
เริ่มต้นด้วย
โค้ดต่อไปนี้เพื่อแปลงไฟล์ client_secret.json
เป็นโทเค็นที่ใช้ได้กับ
genai.configure
:
import os.path
from google.auth.transport.requests import Request
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
SCOPES = ['https://www.googleapis.com/auth/generative-language.retriever']
def load_creds():
"""Converts `client_secret.json` to a credential object.
This function caches the generated tokens to minimize the use of the
consent screen.
"""
creds = None
# The file token.json stores the user's access and refresh tokens, and is
# created automatically when the authorization flow completes for the first
# time.
if os.path.exists('token.json'):
creds = Credentials.from_authorized_user_file('token.json', SCOPES)
# If there are no (valid) credentials available, let the user log in.
if not creds or not creds.valid:
if creds and creds.expired and creds.refresh_token:
creds.refresh(Request())
else:
flow = InstalledAppFlow.from_client_secrets_file(
'client_secret.json', SCOPES)
creds = flow.run_local_server(port=0)
# Save the credentials for the next run
with open('token.json', 'w') as token:
token.write(creds.to_json())
return creds
3. เขียนโปรแกรมของคุณ
ตอนนี้ให้สร้าง script.py
ของคุณ:
import pprint
import google.generativeai as genai
from load_creds import load_creds
creds = load_creds()
genai.configure(credentials=creds)
print()
print('Available base models:', [m.name for m in genai.list_models()])
4. เรียกใช้โปรแกรมของคุณ
ในไดเรกทอรีการทำงาน ให้เรียกใช้ตัวอย่าง
python script.py
ครั้งแรกที่คุณเรียกใช้สคริปต์ หน้าต่างเบราว์เซอร์จะเปิดขึ้นมาและให้คุณ เพื่อให้สิทธิ์เข้าถึง
หากคุณยังไม่ได้ลงชื่อเข้าใช้บัญชี Google คุณจะได้รับแจ้งให้ ลงชื่อเข้าใช้ หากคุณลงชื่อเข้าใช้หลายบัญชี โปรดเลือก บัญชีที่คุณกำหนดเป็น "บัญชีทดสอบ" เมื่อกำหนดค่าโปรเจ็กต์
ข้อมูลการให้สิทธิ์จะเก็บไว้ในระบบไฟล์ ดังนั้นในครั้งถัดไปที่คุณ เรียกใช้โค้ดตัวอย่าง คุณจะไม่ได้รับข้อความแจ้งให้ให้สิทธิ์
คุณตั้งค่าการตรวจสอบสิทธิ์เรียบร้อยแล้ว