การตรวจสอบสิทธิ์ด้วยการเริ่มต้นใช้งาน OAuth อย่างรวดเร็ว

Gemini API ให้คุณดึงข้อมูลเชิงความหมายตามข้อมูลของคุณเองได้ เนื่องจาก ข้อมูลของคุณได้ วิธีนี้ต้องมีการควบคุมการเข้าถึงที่เข้มงวดกว่าคีย์ API

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

วัตถุประสงค์

  • ตั้งค่าโปรเจ็กต์ที่อยู่ในระบบคลาวด์สำหรับ OAuth
  • ตั้งค่าข้อมูลเข้าสู่ระบบเริ่มต้นของแอปพลิเคชัน
  • จัดการข้อมูลเข้าสู่ระบบในโปรแกรมของคุณแทนการใช้ gcloud auth

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

หากต้องการเรียกใช้การเริ่มต้นอย่างรวดเร็วนี้ คุณต้องมีสิ่งต่อไปนี้

ตั้งค่าโปรเจ็กต์ที่อยู่ในระบบคลาวด์

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

1. เปิดใช้ API

ก่อนใช้ Google APIs คุณต้องเปิดใช้ API เหล่านี้ในโปรเจ็กต์ Google Cloud

2. กำหนดค่าหน้าจอขอความยินยอม OAuth

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

  1. ในคอนโซล Google Cloud ให้ไปที่เมนู > API และ บริการ > OAuth หน้าจอขอความยินยอม

    ไปที่หน้าจอขอความยินยอม OAuth

  2. เลือกประเภทผู้ใช้ภายนอกสำหรับแอป แล้วคลิกสร้าง

  3. กรอกแบบฟอร์มการลงทะเบียนแอป (คุณสามารถเว้นช่องส่วนใหญ่ว่างไว้ได้) แล้วคลิกบันทึกและต่อไป

  4. ในตอนนี้ คุณสามารถข้ามการเพิ่มขอบเขต แล้วคลิกบันทึกและดำเนินการต่อได้ ใน เมื่อคุณสร้างแอปสำหรับใช้ภายนอก Google Workspace คุณต้องเพิ่มและยืนยันขอบเขตการให้สิทธิ์ที่ แอปจำเป็นต้องใช้

  5. เพิ่มผู้ใช้ทดสอบ

    1. ในส่วนผู้ใช้ทดสอบ ให้คลิกเพิ่มผู้ใช้
    2. ป้อนอีเมลของคุณและผู้ใช้ทดสอบรายอื่นๆ ที่ได้รับอนุญาต คลิกบันทึกและดำเนินการต่อ

  6. ตรวจสอบสรุปการลงทะเบียนแอป หากต้องการเปลี่ยนแปลง ให้คลิกแก้ไข ถ้า การลงทะเบียนแอปถูกต้องแล้ว จากนั้นคลิกกลับไปที่แดชบอร์ด

3. ให้สิทธิ์ข้อมูลเข้าสู่ระบบสำหรับแอปพลิเคชันเดสก์ท็อป

หากต้องการตรวจสอบสิทธิ์ในฐานะผู้ใช้ปลายทางและเข้าถึงข้อมูลผู้ใช้ในแอป คุณจะต้องดำเนินการต่อไปนี้ สร้างรหัสไคลเอ็นต์ OAuth 2.0 อย่างน้อย 1 รหัส รหัสไคลเอ็นต์ใช้เพื่อระบุ แอปเดียวไปยังเซิร์ฟเวอร์ OAuth ของ Google หากแอปทำงานบนหลายแพลตฟอร์ม คุณต้องสร้างรหัสไคลเอ็นต์แยกกันสำหรับแต่ละแพลตฟอร์ม

  1. ในคอนโซล Google Cloud ให้ไปที่เมนู > API และ บริการ > ข้อมูลเข้าสู่ระบบ

    ไปที่ข้อมูลเข้าสู่ระบบ

  2. คลิกสร้างข้อมูลเข้าสู่ระบบ > รหัสไคลเอ็นต์ OAuth

  3. คลิกประเภทแอปพลิเคชัน > แอปบนเดสก์ท็อป

  4. ในช่องชื่อ ให้พิมพ์ชื่อของข้อมูลเข้าสู่ระบบ ชื่อนี้เป็นเพียง ที่แสดงในคอนโซล Google Cloud

  5. คลิกสร้าง หน้าจอที่สร้างไคลเอ็นต์ OAuth จะปรากฏขึ้น ซึ่งจะแสดง Client-ID และรหัสลับไคลเอ็นต์

  6. คลิกตกลง ข้อมูลเข้าสู่ระบบที่สร้างขึ้นใหม่จะปรากฏในส่วนไคลเอ็นต์ OAuth 2.0 บัตรประจำตัว

  7. คลิกปุ่มดาวน์โหลดเพื่อบันทึกไฟล์ 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

ครั้งแรกที่คุณเรียกใช้สคริปต์ หน้าต่างเบราว์เซอร์จะเปิดขึ้นมาและให้คุณ เพื่อให้สิทธิ์เข้าถึง

  1. หากคุณยังไม่ได้ลงชื่อเข้าใช้บัญชี Google คุณจะได้รับแจ้งให้ ลงชื่อเข้าใช้ หากคุณลงชื่อเข้าใช้หลายบัญชี โปรดเลือก บัญชีที่คุณกำหนดเป็น "บัญชีทดสอบ" เมื่อกำหนดค่าโปรเจ็กต์

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

คุณตั้งค่าการตรวจสอบสิทธิ์เรียบร้อยแล้ว