ระบบ Google OAuth 2.0 สนับสนุนการโต้ตอบแบบเซิร์ฟเวอร์ต่อเซิร์ฟเวอร์ เช่น การโต้ตอบระหว่างเว็บ แอปพลิเคชันและบริการของ Google ในสถานการณ์นี้คุณต้องมีบัญชีบริการ เป็นบัญชีที่เป็นของแอปพลิเคชันของคุณ ไม่ใช่ของผู้ใช้แต่ละราย บัญชี จะเรียก Google APIs ในนามของบัญชีบริการนั้น ดังนั้นผู้ใช้จะไม่ได้ ที่เกี่ยวข้อง สถานการณ์นี้บางครั้งเรียกว่า "OAuth แบบ 2 ทาง" หรือ "2LO" (คำที่เกี่ยวข้อง "OAuth แบบ 3 ทาง" หมายถึงสถานการณ์ที่แอปพลิเคชันของคุณเรียกใช้ Google APIs ในนามของ ของผู้ใช้ปลายทาง และบางครั้งต้องได้รับความยินยอมจากผู้ใช้)
โดยปกติแล้ว แอปพลิเคชันจะใช้บัญชีบริการเมื่อแอปพลิเคชันใช้ Google APIs ในการทำงาน ด้วยข้อมูลของตัวเอง ไม่ใช่ข้อมูลของผู้ใช้ เช่น แอปพลิเคชันที่ใช้ Google Cloud พื้นที่เก็บข้อมูลสำหรับความต่อเนื่องของข้อมูลจะใช้บัญชีบริการเพื่อตรวจสอบสิทธิ์การเรียกไปยัง API ของ Google Cloud Datastore
ผู้ดูแลระบบโดเมน Google Workspace ยัง ให้สิทธิ์ใช้งานทั่วทั้งโดเมนของบัญชีบริการเพื่อเข้าถึงผู้ใช้ ข้อมูลในนามของผู้ใช้ในโดเมน
เอกสารนี้จะอธิบายวิธีที่แอปพลิเคชันสามารถดำเนินการตามขั้นตอน OAuth 2.0 แบบเซิร์ฟเวอร์ต่อเซิร์ฟเวอร์ โดยใช้ไลบรารีของไคลเอ็นต์ Google APIs (แนะนำ) หรือ HTTP
ภาพรวม
หากต้องการรองรับการโต้ตอบแบบเซิร์ฟเวอร์ต่อเซิร์ฟเวอร์ ก่อนอื่นให้สร้างบัญชีบริการของโปรเจ็กต์ใน API Consoleหากคุณต้องการเข้าถึงข้อมูลผู้ใช้สำหรับผู้ใช้ใน บัญชี Google Workspace ของคุณ แล้วมอบสิทธิ์เข้าถึงทั่วทั้งโดเมนให้กับบัญชีบริการ
จากนั้นแอปพลิเคชันจะเตรียมการเรียก API ที่ได้รับอนุญาตโดยใช้ ข้อมูลเข้าสู่ระบบเพื่อขอโทเค็นเพื่อการเข้าถึงจากเซิร์ฟเวอร์การตรวจสอบสิทธิ์ OAuth 2.0
ประการสุดท้าย แอปพลิเคชันของคุณสามารถใช้โทเค็นเพื่อการเข้าถึงเพื่อเรียกใช้ Google APIs ได้
การสร้างบัญชีบริการ
ข้อมูลเข้าสู่ระบบของบัญชีบริการจะรวมถึงอีเมลที่สร้างขึ้นเฉพาะที่ไม่ซ้ำกันและเป็นอย่างน้อย คู่คีย์สาธารณะ/ส่วนตัว 1 คู่ หากเปิดใช้การมอบสิทธิ์ทั่วทั้งโดเมน รหัสไคลเอ็นต์ก็เป็นส่วนหนึ่งของด้วยเช่นกัน ของข้อมูลเข้าสู่ระบบของบัญชีบริการ
หากแอปพลิเคชันของคุณทำงานใน Google App Engine บัญชีบริการจะได้รับการตั้งค่าโดยอัตโนมัติเมื่อ เมื่อสร้างโปรเจ็กต์
หากแอปพลิเคชันของคุณทำงานบน Google Compute Engine จะมีการตั้งค่าบัญชีบริการด้วย โดยอัตโนมัติเมื่อคุณสร้างโครงการ แต่คุณต้องระบุขอบเขตที่ แอปพลิเคชันต้องการเข้าถึงเมื่อคุณสร้างอินสแตนซ์ของ Google Compute Engine สำหรับข้อมูลเพิ่มเติม ดูข้อมูลได้ที่ การเตรียมอินสแตนซ์เพื่อใช้บัญชีบริการ
หากแอปพลิเคชันของคุณไม่ได้ทำงานบน Google App Engine หรือ Google Compute Engine คุณจะต้องได้รับ ข้อมูลเข้าสู่ระบบเหล่านี้ใน Google API Consoleวิธีสร้างบัญชีบริการ หรือดูข้อมูลรับรองสาธารณะที่คุณสร้างไว้แล้ว ให้ทำดังนี้
ขั้นแรก สร้างบัญชีบริการ:
- เปิด Service accounts page
- If prompted, select a project, or create a new one.
- คลิก สร้างบัญชีบริการ
- ภายใต้ รายละเอียดบัญชีบริการ ให้พิมพ์ชื่อ ID และคำอธิบายสำหรับบัญชีบริการ จากนั้นคลิก สร้างและดำเนิน การต่อ
- ทางเลือก: ภายใต้ ให้สิทธิ์การเข้าถึงบัญชีบริการนี้กับโครงการ เลือกบทบาท IAM เพื่อมอบให้กับบัญชีบริการ
- คลิกดำเนินการ ต่อ
- ไม่บังคับ: ภายใต้ ให้สิทธิ์ผู้ใช้เข้าถึงบัญชีบริการนี้ ให้ เพิ่มผู้ใช้หรือกลุ่มที่ได้รับอนุญาตให้ใช้และจัดการบัญชีบริการ
- คลิก เสร็จสิ้น
จากนั้น สร้างรหัสบัญชีบริการ:
- คลิกที่อยู่อีเมลสำหรับบัญชีบริการที่คุณสร้างขึ้น
- คลิกแท็บ คีย์
- ในรายการดรอปดาวน์ เพิ่มคีย์ เลือก สร้างคีย์ใหม่
- คลิก สร้าง
คู่คีย์สาธารณะ/ส่วนตัวใหม่ของคุณถูกสร้างขึ้นและดาวน์โหลดลงในเครื่องของคุณ มันทำหน้าที่เป็นสำเนาเดียวของคีย์ส่วนตัว คุณมีหน้าที่รับผิดชอบในการจัดเก็บอย่างปลอดภัย หากคุณทำคู่คีย์นี้หาย คุณจะต้องสร้างคู่คีย์ใหม่
คุณสามารถกลับไปที่ API Console ได้ทุกเมื่อเพื่อดูอีเมล แบบสาธารณะ ลายนิ้วมือหลัก และข้อมูลอื่นๆ หรือสร้างคู่คีย์สาธารณะ/ส่วนตัวเพิ่มเติม สำหรับ รายละเอียดเพิ่มเติมเกี่ยวกับข้อมูลเข้าสู่ระบบของบัญชีบริการใน API Consoleโปรดดู บัญชีบริการใน API Console ไฟล์ช่วยเหลือ
จดอีเมลของบัญชีบริการและเก็บคีย์ส่วนตัวของบัญชีบริการ ในตำแหน่งที่แอปพลิเคชันของคุณเข้าถึงได้ แอปพลิเคชันของคุณจำเป็นต้องมี การเรียก API ที่ได้รับอนุญาต
การมอบสิทธิ์ทั่วทั้งโดเมนให้กับบัญชีบริการ
ผู้ดูแลระบบ Workspace ขององค์กรสามารถใช้บัญชี Google Workspace เพื่อให้สิทธิ์ สำหรับเข้าถึงข้อมูลผู้ใช้ Workspace ในนามของผู้ใช้ในโดเมน Google Workspace ตัวอย่างเช่น แอปพลิเคชันที่ใช้ API ของ Google ปฏิทิน เพื่อเพิ่มกิจกรรมในปฏิทินของผู้ใช้ทั้งหมดใน โดเมน Google Workspace จะใช้บัญชีบริการเพื่อเข้าถึง Google Calendar API ใน ในนามของผู้ใช้ การให้สิทธิ์บัญชีบริการเพื่อเข้าถึงข้อมูลในนามของผู้ใช้ในโดเมนคือ บางครั้งเรียกว่า "การมอบสิทธิ์ทั่วทั้งโดเมน" กับบัญชีบริการ
หากต้องการมอบสิทธิ์ทั่วทั้งโดเมนให้กับบัญชีบริการ ผู้ดูแลระบบขั้นสูงของ Google โดเมน Workspace ต้องทําตามขั้นตอนต่อไปนี้
- จาก ของโดเมน Google Workspace ของคุณ คอนโซลผู้ดูแลระบบ ให้ไปที่เมนูหลัก ความปลอดภัย > การเข้าถึงและการควบคุมข้อมูล > การควบคุม API
- ในแผงการมอบสิทธิ์ทั่วทั้งโดเมน ให้เลือกจัดการการมอบสิทธิ์ทั่วทั้งโดเมน
- คลิกเพิ่มใหม่
- ในช่องรหัสไคลเอ็นต์ ให้ป้อนรหัสไคลเอ็นต์ของบัญชีบริการ คุณดู รหัสไคลเอ็นต์ของบัญชีบริการใน Service accounts page
- ในช่องขอบเขต OAuth (คั่นด้วยเครื่องหมายจุลภาค) ให้ป้อนรายการขอบเขตที่ แอปพลิเคชันควรได้รับสิทธิ์ในการเข้าถึง ตัวอย่างเช่น หากแอปพลิเคชันของคุณต้องใช้ทั้งโดเมน สิทธิ์เข้าถึง Google Drive API และ Google Calendar API โดยสมบูรณ์ ให้ป้อนข้อมูลต่อไปนี้ https://www.googleapis.com/auth/drive, https://www.googleapis.com/auth/calendar
- คลิกให้สิทธิ์
ตอนนี้แอปพลิเคชันของคุณมีสิทธิ์เรียก API ในฐานะผู้ใช้ในโดเมน Workspace (เพื่อ "แอบอ้าง" ผู้ใช้) เมื่อคุณเตรียมเรียก API ที่ได้รับมอบสิทธิ์เหล่านี้ คุณจะระบุผู้ใช้อย่างชัดเจนให้ การอ้างชื่อ
กำลังเตรียมเรียก API ที่ได้รับมอบสิทธิ์
Java
หลังจากได้ที่อยู่อีเมลไคลเอ็นต์และคีย์ส่วนตัวจาก
API Consoleให้ใช้
ไลบรารีของไคลเอ็นต์ Google APIs สำหรับ Java
เพื่อสร้างออบเจ็กต์ GoogleCredential
จากข้อมูลเข้าสู่ระบบของบัญชีบริการ และ
ขอบเขตที่แอปพลิเคชันของคุณต้องการเข้าถึง เช่น
import com.google.api.client.googleapis.auth.oauth2.GoogleCredential; import com.google.api.services.sqladmin.SQLAdminScopes; // ... GoogleCredential credential = GoogleCredential.fromStream(new FileInputStream("MyProject-1234.json")) .createScoped(Collections.singleton(SQLAdminScopes.SQLSERVICE_ADMIN));
หากคุณกำลังพัฒนาแอปบน Google Cloud Platform คุณสามารถใช้ ข้อมูลเข้าสู่ระบบเริ่มต้นของแอปพลิเคชัน แต่จะทำให้กระบวนการนี้ง่ายขึ้น
มอบสิทธิ์ทั่วทั้งโดเมน
หากคุณมอบสิทธิ์ทั่วทั้งโดเมนให้บัญชีบริการและต้องการแอบอ้างเป็นบุคคลอื่น
บัญชีผู้ใช้ ให้ระบุอีเมลของบัญชีผู้ใช้ด้วย
เมธอด createDelegated
ของออบเจ็กต์ GoogleCredential
สำหรับ
ตัวอย่าง:
GoogleCredential credential = GoogleCredential.fromStream(new FileInputStream("MyProject-1234.json")) .createScoped(Collections.singleton(SQLAdminScopes.SQLSERVICE_ADMIN)) .createDelegated("workspace-user@example.com");
โค้ดด้านบนใช้ออบเจ็กต์ GoogleCredential
เพื่อเรียกใช้ createDelegated()
อาร์กิวเมนต์สำหรับเมธอด createDelegated()
ต้องเป็นผู้ใช้ที่เป็น
Google Workspace รหัสที่ส่งคำขอจะใช้ข้อมูลเข้าสู่ระบบนี้เพื่อโทรหา Google
API ที่ใช้บัญชีบริการของคุณ
Python
หลังจากได้ที่อยู่อีเมลไคลเอ็นต์และคีย์ส่วนตัวจาก API Consoleให้ใช้ ไลบรารีของไคลเอ็นต์ Google APIs สำหรับ Python เพื่อทำตามขั้นตอนต่อไปนี้
- สร้างออบเจ็กต์
Credentials
จากข้อมูลเข้าสู่ระบบของบัญชีบริการและ ที่แอปพลิเคชันของคุณต้องการเข้าถึง ดังตัวอย่างต่อไปนี้from google.oauth2 import service_account SCOPES = ['https://www.googleapis.com/auth/sqlservice.admin'] SERVICE_ACCOUNT_FILE = '/path/to/service.json' credentials = service_account.Credentials.from_service_account_file( SERVICE_ACCOUNT_FILE, scopes=SCOPES)
หากคุณกำลังพัฒนาแอปบน Google Cloud Platform คุณสามารถใช้ ข้อมูลเข้าสู่ระบบเริ่มต้นของแอปพลิเคชัน แต่จะทำให้กระบวนการนี้ง่ายขึ้น
- มอบสิทธิ์ทั่วทั้งโดเมน
หากคุณมอบสิทธิ์เข้าถึงทั่วทั้งโดเมนให้กับบัญชีบริการแล้วและต้องการ แอบอ้างบัญชีผู้ใช้อื่น ใช้เมธอด
with_subject
ของบัญชีที่มีอยู่ServiceAccountCredentials
ออบเจ็กต์ เช่นdelegated_credentials = credentials.with_subject('user@example.org')
ใช้ออบเจ็กต์ข้อมูลเข้าสู่ระบบเพื่อเรียกใช้ Google API ในแอปพลิเคชันของคุณ
HTTP/REST
หลังจากได้รหัสไคลเอ็นต์และคีย์ส่วนตัวจาก API Consoleใบสมัครของคุณต้องผ่าน ขั้นตอนต่อไปนี้
- สร้างเว็บโทเค็น JSON (JWT อ่านว่า "jot") ซึ่งประกอบด้วยส่วนหัว ชุดการอ้างสิทธิ์ และลายเซ็น
- ส่งคำขอโทเค็นการเข้าถึงจากเซิร์ฟเวอร์การให้สิทธิ์ของ Google OAuth 2.0
- จัดการการตอบกลับ JSON ที่เซิร์ฟเวอร์การให้สิทธิ์แสดง
ส่วนต่อไปนี้จะอธิบายวิธีทำตามขั้นตอนเหล่านี้
ถ้าการตอบกลับมีโทเค็นเพื่อการเข้าถึง คุณจะสามารถใช้โทเค็นเพื่อการเข้าถึงเพื่อ เรียก Google API (หากคำตอบไม่รวมสิทธิ์การเข้าถึง โทเค็น JWT และคำขอโทเค็นอาจมีรูปแบบไม่ถูกต้อง หรือบัญชีบริการอาจ ไม่มีสิทธิ์เข้าถึงขอบเขตที่ขอ)
เมื่อโทเค็นเพื่อการเข้าถึงหมดอายุ แอปพลิเคชันจะสร้างโทเค็นอื่น JWT, ลงนาม และขอโทเค็นเพื่อการเข้าถึงใหม่
![แอปพลิเคชันเซิร์ฟเวอร์ของคุณใช้ JWT เพื่อขอโทเค็นจาก Google
เซิร์ฟเวอร์การให้สิทธิ์ จากนั้นจะใช้โทเค็นเพื่อเรียกใช้ปลายทาง Google API ยังไม่ได้ติดต่อ
ให้ผู้ใช้ปลายทางมีส่วนร่วมด้วย](https://developers-dot-devsite-v2-prod.appspot.com/static/identity/protocols/oauth2/images/flows/jwt.png?authuser=9&hl=th)
ส่วนที่เหลือของส่วนนี้จะอธิบายรายละเอียดในการสร้าง JWT, การลงชื่อ JWT, สร้างคำขอโทเค็นเพื่อการเข้าถึง และจัดการการตอบสนอง
การสร้าง JWT
JWT ประกอบด้วย 3 ส่วน ได้แก่ ส่วนหัว ชุดการอ้างสิทธิ์ และ
ลายเซ็น ส่วนหัวและชุดการอ้างสิทธิ์เป็นออบเจ็กต์ JSON ออบเจ็กต์ JSON เหล่านี้มีการเรียงลำดับเป็น
UTF-8 ไบต์ แล้วเข้ารหัสโดยใช้การเข้ารหัส Base64url การเข้ารหัสนี้ช่วยเสริมความยืดหยุ่น
กับการเปลี่ยนแปลงการเข้ารหัสเนื่องจากการดำเนินการเข้ารหัสซ้ำ ส่วนหัว ชุดการอ้างสิทธิ์ และ
ลายเซ็นจะต่อกันด้วยอักขระจุด (.
)
JWT ประกอบด้วย
{Base64url encoded header}.{Base64url encoded claim set}.{Base64url encoded signature}
สตริงพื้นฐานสำหรับลายเซ็นมีดังนี้
{Base64url encoded header}.{Base64url encoded claim set}
การสร้างส่วนหัว JWT
ส่วนหัวประกอบด้วย 3 ฟิลด์ที่ระบุอัลกอริทึมการลงชื่อ ซึ่งเป็นรูปแบบของ การยืนยัน และ [รหัสคีย์ของบัญชีบริการ key](https://cloud.google.com/iam/docs/reference/rest/v1/projects.serviceAccounts.keys) ที่ใช้ในการลงนาม JWT คุณต้องระบุอัลกอริทึมและรูปแบบ โดยแต่ละช่องจะมีเพียง 1 ค่า เมื่อมีการแนะนำอัลกอริทึมและรูปแบบเพิ่มเติม ส่วนหัวนี้จะเปลี่ยนไป ตามนั้น คุณจะระบุรหัสคีย์หรือไม่ก็ได้ และหากระบุรหัสคีย์ไม่ถูกต้อง GCP จะพยายาม คีย์ทั้งหมดที่เชื่อมโยงกับบัญชีบริการเพื่อยืนยันโทเค็นและปฏิเสธโทเค็น หาก ไม่พบคีย์ที่ถูกต้อง Google ขอสงวนสิทธิ์ในการปฏิเสธโทเค็นที่มีรหัสคีย์ไม่ถูกต้อง ในอนาคต
บัญชีบริการใช้อัลกอริทึม RSA SHA-256 และรูปแบบโทเค็น JWT ด้วยเหตุนี้ การแสดงส่วนหัว JSON ดังนี้
{"alg":"RS256","typ":"JWT", "kid":"370ab79b4513eb9bad7c9bd16a95cb76b5b2a56a"}
ตัวแทน Base64url ของข้อมูลนี้มีดังนี้
eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCIsICJraWQiOiIzNzBhYjc5YjQ1MTNlYjliYWQ3YzliZDE2YTk1Y2I3NmI1YjJhNTZhIn0=
การสร้างชุดการอ้างสิทธิ์ JWT
ชุดการอ้างสิทธิ์ JWT มีข้อมูลเกี่ยวกับ JWT รวมถึงสิทธิ์ต่างๆ (ขอบเขต) เป้าหมายของโทเค็น ผู้ออกโทเค็น เวลาที่ออกโทเค็น และอายุการใช้งานของโทเค็น ช่องส่วนใหญ่เป็นช่องบังคับ เช่นเดียวกับส่วนหัว JWT ชุดการอ้างสิทธิ์ JWT เป็นออบเจ็กต์ JSON และใช้ในการคำนวณลายเซ็น
การอ้างสิทธิ์ที่จำเป็น
การเคลมที่จำเป็นในชุดการอ้างสิทธิ์ JWT จะแสดงอยู่ด้านล่างนี้ ซึ่งอาจเรียงลำดับอย่างไรก็ได้ใน ชุดการอ้างสิทธิ์
ชื่อ | คำอธิบาย |
---|---|
iss |
อีเมลของบัญชีบริการ |
scope |
รายการสิทธิ์ที่แอปพลิเคชันร้องขอโดยคั่นด้วยช่องว่าง |
aud |
ข้อบ่งชี้ถึงเป้าหมายที่มุ่งหมายของการยืนยัน เมื่อสร้างโทเค็นเพื่อการเข้าถึง
ค่านี้มีค่าเป็น https://oauth2.googleapis.com/token เสมอ |
exp |
เวลาหมดอายุของการยืนยัน ซึ่งระบุเป็นวินาทีตั้งแต่ 00:00:00 น. ตามเขตเวลา UTC 1 มกราคม 1970 ค่านี้มีระยะเวลาสูงสุด 1 ชั่วโมงหลังจากเวลาที่ออก |
iat |
เวลาที่ออกการยืนยัน ซึ่งระบุเป็นวินาทีตั้งแต่ 00:00:00 น. ตามเขตเวลา UTC 1 มกราคม 1970 |
การแสดง JSON ของช่องที่ต้องกรอกในชุดการอ้างสิทธิ์ JWT แสดงอยู่ด้านล่าง
{ "iss": "761326798069-r5mljlln1rd4lrbhg75efgigp36m78j5@developer.gserviceaccount.com", "scope": "https://www.googleapis.com/auth/devstorage.read_only", "aud": "https://oauth2.googleapis.com/token", "exp": 1328554385, "iat": 1328550785 }
การอ้างสิทธิ์เพิ่มเติม
ในบางกรณีขององค์กร แอปพลิเคชันจะใช้การมอบสิทธิ์ทั่วทั้งโดเมนเพื่อดำเนินการในนามได้ ของผู้ใช้บางรายในองค์กร สิทธิ์ในการดำเนินการแอบอ้างเป็นบุคคลอื่นประเภทนี้ ต้องได้รับสิทธิ์ก่อนที่แอปพลิเคชันจะสามารถสวมบทบาทเป็นผู้ใช้ได้ และโดยทั่วไปจะจัดการโดย ผู้ดูแลระบบขั้นสูง สำหรับข้อมูลเพิ่มเติม โปรดดู ควบคุมการเข้าถึง API ด้วยการมอบสิทธิ์ทั่วทั้งโดเมน
วิธีรับโทเค็นเพื่อการเข้าถึงที่มอบสิทธิ์เข้าถึงแหล่งข้อมูลให้แก่แอปพลิเคชัน
ใส่อีเมลของผู้ใช้ในการอ้างสิทธิ์ JWT ซึ่งตั้งเป็นค่าของ
sub
ชื่อ | คำอธิบาย |
---|---|
sub |
อีเมลของผู้ใช้ที่แอปพลิเคชันขอมอบสิทธิ์ สิทธิ์การเข้าถึง |
หากแอปพลิเคชันไม่มีสิทธิ์ในการสวมบทบาทเป็นผู้ใช้ การตอบกลับ
คำขอโทเค็นเพื่อการเข้าถึงที่มีช่อง sub
จะอยู่ในรูปแบบ
error
แสดงตัวอย่างชุดการอ้างสิทธิ์ JWT ที่มีช่อง sub
ด้านล่าง
{ "iss": "761326798069-r5mljlln1rd4lrbhg75efgigp36m78j5@developer.gserviceaccount.com", "sub": "some.user@example.com", "scope": "https://www.googleapis.com/auth/prediction", "aud": "https://oauth2.googleapis.com/token", "exp": 1328554385, "iat": 1328550785 }
การเข้ารหัสชุดการอ้างสิทธิ์ JWT
ชุดการอ้างสิทธิ์ JWT ควรอยู่ในรูปแบบ UTF-8 และ Base64url-safe เช่นเดียวกับส่วนหัว JWT เข้ารหัสแล้ว ด้านล่างนี้เป็นตัวอย่างการแสดง JSON ของชุดการอ้างสิทธิ์ JWT
{ "iss": "761326798069-r5mljlln1rd4lrbhg75efgigp36m78j5@developer.gserviceaccount.com", "scope": "https://www.googleapis.com/auth/prediction", "aud": "https://oauth2.googleapis.com/token", "exp": 1328554385, "iat": 1328550785 }
กำลังประมวลผลลายเซ็น
ลายเซ็นเว็บ JSON (JWS) เป็นข้อกำหนดที่แนะนำกลไกในการสร้างลายเซ็นสำหรับ JWT อินพุตสำหรับลายเซ็นคือไบต์อาร์เรย์ของเนื้อหาต่อไปนี้
{Base64url encoded header}.{Base64url encoded claim set}
ต้องใช้อัลกอริทึมการลงชื่อในส่วนหัว JWT เมื่อคำนวณลายเซ็น
เฉพาะอัลกอริทึมการลงชื่อที่เซิร์ฟเวอร์การให้สิทธิ์ Google OAuth 2.0 รองรับคือ RSA ที่ใช้
อัลกอริทึมการแฮช SHA-256 ค่านี้จะแสดงเป็น RS256
ใน alg
ในส่วนหัว JWT
ลงนามการแสดงอินพุตแบบ UTF-8 โดยใช้ SHA256withRSA (หรือที่เรียกว่า RSASSA-PKCS1-V1_5-SIGN พร้อมฟังก์ชันแฮช SHA-256) ด้วยคีย์ส่วนตัวที่ได้รับจาก Google API Consoleเอาต์พุตจะเป็นอาร์เรย์แบบไบต์
จากนั้นลายเซ็นจะต้องเข้ารหัส Base64url ส่วนหัว ชุดการอ้างสิทธิ์ และลายเซ็น
ต่อกันด้วยอักขระจุด (.
) ผลที่ได้คือ JWT ทั้งนี้
ควรเป็นดังนี้ (เพิ่มตัวแบ่งบรรทัดเพื่อความชัดเจน)
{Base64url encoded header}. {Base64url encoded claim set}. {Base64url encoded signature}
ด้านล่างเป็นตัวอย่างของ JWT ก่อนการเข้ารหัส Base64url
{"alg":"RS256","typ":"JWT"}. { "iss":"761326798069-r5mljlln1rd4lrbhg75efgigp36m78j5@developer.gserviceaccount.com", "scope":"https://www.googleapis.com/auth/prediction", "aud":"https://oauth2.googleapis.com/token", "exp":1328554385, "iat":1328550785 }. [signature bytes]
ด้านล่างเป็นตัวอย่างของ JWT ที่ลงนามและพร้อมส่งแล้ว
eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiI3NjEzMjY3OTgwNjktcjVtbGpsbG4xcmQ0bHJiaGc3NWVmZ2lncDM2bTc4ajVAZGV2ZWxvcGVyLmdzZXJ2aWNlYWNjb3VudC5jb20iLCJzY29wZSI6Imh0dHBzOi8vd3d3Lmdvb2dsZWFwaXMuY29tL2F1dGgvcHJlZGljdGlvbiIsImF1ZCI6Imh0dHBzOi8vd3d3Lmdvb2dsZWFwaXMuY29tL29hdXRoMi92NC90b2tlbiIsImV4cCI6MTMyODU1NDM4NSwiaWF0IjoxMzI4NTUwNzg1fQ.UFUt59SUM2_AW4cRU8Y0BYVQsNTo4n7AFsNrqOpYiICDu37vVt-tw38UKzjmUKtcRsLLjrR3gFW3dNDMx_pL9DVjgVHDdYirtrCekUHOYoa1CMR66nxep5q5cBQ4y4u2kIgSvChCTc9pmLLNoIem-ruCecAJYgI9Ks7pTnW1gkOKs0x3YpiLpzplVHAkkHztaXiJdtpBcY1OXyo6jTQCa3Lk2Q3va1dPkh_d--GU2M5flgd8xNBPYw4vxyt0mP59XZlHMpztZt0soSgObf7G3GXArreF_6tpbFsS3z2t5zkEiHuWJXpzcYr5zWTRPDEHsejeBSG8EgpLDce2380ROQ
การส่งคำขอโทเค็นเพื่อการเข้าถึง
หลังจากสร้าง JWT ที่ลงนามแล้ว แอปพลิเคชันจะใช้แอปพลิเคชันเพื่อขอโทเค็นเพื่อการเข้าถึงได้
คำขอโทเค็นเพื่อการเข้าถึงนี้เป็นคำขอ HTTPS POST
และส่วนเนื้อหาคือ URL
เข้ารหัสแล้ว URL ที่แสดงด้านล่าง:
https://oauth2.googleapis.com/token
ต้องมีพารามิเตอร์ต่อไปนี้ในคำขอ HTTPS POST
ชื่อ | คำอธิบาย |
---|---|
grant_type |
ใช้สตริงต่อไปนี้ โดยเข้ารหัส URL ตามที่จำเป็น
urn:ietf:params:oauth:grant-type:jwt-bearer |
assertion |
JWT รวมถึงลายเซ็น |
ด้านล่างนี้คือข้อมูลดิบของคำขอ HTTPS POST
ที่ใช้ในโทเค็นเพื่อการเข้าถึง
คำขอ:
POST /token HTTP/1.1 Host: oauth2.googleapis.com Content-Type: application/x-www-form-urlencoded grant_type=urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Ajwt-bearer&assertion=eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiI3NjEzMjY3OTgwNjktcjVtbGpsbG4xcmQ0bHJiaGc3NWVmZ2lncDM2bTc4ajVAZGV2ZWxvcGVyLmdzZXJ2aWNlYWNjb3VudC5jb20iLCJzY29wZSI6Imh0dHBzOi8vd3d3Lmdvb2dsZWFwaXMuY29tL2F1dGgvcHJlZGljdGlvbiIsImF1ZCI6Imh0dHBzOi8vYWNjb3VudHMuZ29vZ2xlLmNvbS9vL29hdXRoMi90b2tlbiIsImV4cCI6MTMyODU3MzM4MSwiaWF0IjoxMzI4NTY5NzgxfQ.ixOUGehweEVX_UKXv5BbbwVEdcz6AYS-6uQV6fGorGKrHf3LIJnyREw9evE-gs2bmMaQI5_UbabvI4k-mQE4kBqtmSpTzxYBL1TCd7Kv5nTZoUC1CmwmWCFqT9RE6D7XSgPUh_jF1qskLa2w0rxMSjwruNKbysgRNctZPln7cqQ
ด้านล่างนี้เป็นคำขอเดียวกันที่ใช้ curl
curl -d 'grant_type=urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Ajwt-bearer&assertion=eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiI3NjEzMjY3OTgwNjktcjVtbGpsbG4xcmQ0bHJiaGc3NWVmZ2lncDM2bTc4ajVAZGV2ZWxvcGVyLmdzZXJ2aWNlYWNjb3VudC5jb20iLCJzY29wZSI6Imh0dHBzOi8vd3d3Lmdvb2dsZWFwaXMuY29tL2F1dGgvcHJlZGljdGlvbiIsImF1ZCI6Imh0dHBzOi8vYWNjb3VudHMuZ29vZ2xlLmNvbS9vL29hdXRoMi90b2tlbiIsImV4cCI6MTMyODU3MzM4MSwiaWF0IjoxMzI4NTY5NzgxfQ.RZVpzWygMLuL-n3GwjW1_yhQhrqDacyvaXkuf8HcJl8EtXYjGjMaW5oiM5cgAaIorrqgYlp4DPF_GuncFqg9uDZrx7pMmCZ_yHfxhSCXru3gbXrZvAIicNQZMFxrEEn4REVuq7DjkTMyCMGCY1dpMa8aWfTQFt3Eh7smLchaZsU ' https://oauth2.googleapis.com/token
การจัดการคำตอบ
หากคำขอ JWT และโทเค็นเพื่อการเข้าถึงมีรูปแบบถูกต้อง และบัญชีบริการมี สิทธิ์ในการดำเนินการ จากนั้นการตอบกลับ JSON จากเซิร์ฟเวอร์การให้สิทธิ์ มีโทเค็นเพื่อการเข้าถึง ตัวอย่างการตอบกลับมีดังนี้
{ "access_token": "1/8xbJqaOZXSUZbHLl5EOtu1pxz3fmmetKx9W8CV4t79M", "scope": "https://www.googleapis.com/auth/prediction" "token_type": "Bearer", "expires_in": 3600 }
โทเค็นเพื่อการเข้าถึงสามารถนำกลับมาใช้ซ้ำได้ในระหว่างช่วงเวลาที่ระบุโดย
expires_in
การเรียกใช้ Google APIs
Java
ใช้ออบเจ็กต์ GoogleCredential
เพื่อเรียกใช้ Google API โดยกรอกข้อมูลใน
ขั้นตอนต่อไปนี้
- สร้างออบเจ็กต์บริการสำหรับ API ที่คุณต้องการเรียกใช้โดยใช้
ออบเจ็กต์
GoogleCredential
รายการ ตัวอย่างเช่นSQLAdmin sqladmin = new SQLAdmin.Builder(httpTransport, JSON_FACTORY, credential).build();
- ส่งคำขอไปยังบริการ API โดยใช้
อินเทอร์เฟซจากออบเจ็กต์บริการ
ตัวอย่างเช่น เพื่อแสดงรายการอินสแตนซ์ของฐานข้อมูล Cloud SQL ในที่น่าตื่นเต้น-example-123
โปรเจ็กต์:
SQLAdmin.Instances.List instances = sqladmin.instances().list("exciting-example-123").execute();
Python
ใช้ออบเจ็กต์ Credentials
ที่ได้รับอนุญาตเพื่อเรียกใช้ Google APIs โดยดําเนินการตาม
ขั้นตอนต่อไปนี้
- สร้างออบเจ็กต์บริการสำหรับ API ที่คุณต้องการเรียกใช้ คุณสร้างออบเจ็กต์บริการ
โดยเรียกใช้ฟังก์ชัน
build
ด้วยชื่อและเวอร์ชันของ API และ ออบเจ็กต์Credentials
ที่ได้รับอนุญาต เช่น หากต้องการเรียกเวอร์ชัน 1beta3 ของ API การดูแลระบบ Cloud SQLimport googleapiclient.discovery sqladmin = googleapiclient.discovery.build('sqladmin', 'v1beta3', credentials=credentials)
- ส่งคำขอไปยังบริการ API โดยใช้
อินเทอร์เฟซจากออบเจ็กต์บริการ
ตัวอย่างเช่น เพื่อแสดงรายการอินสแตนซ์ของฐานข้อมูล Cloud SQL ในที่น่าตื่นเต้น-example-123
โปรเจ็กต์:
response = sqladmin.instances().list(project='exciting-example-123').execute()
HTTP/REST
หลังจากแอปพลิเคชันได้รับโทเค็นเพื่อการเข้าถึงแล้ว คุณจะสามารถใช้โทเค็นดังกล่าวเพื่อเรียกไปยัง
API ในนามของบัญชีบริการที่ระบุ หรือ
บัญชีผู้ใช้ หากได้มีการให้สิทธิ์สำหรับขอบเขตการเข้าถึงที่ API กำหนด วิธีการคือ
โทเค็นเพื่อการเข้าถึงในคำขอที่ส่งไปยัง API โดยรวมคำค้นหา access_token
หรือค่า Bearer
ของส่วนหัว HTTP Authorization
เมื่อทำได้
ส่วนหัว HTTP ดีกว่า เนื่องจากสตริงการค้นหามักจะมองเห็นได้ในบันทึกของเซิร์ฟเวอร์ ส่วนใหญ่
คุณสามารถใช้ไลบรารีของไคลเอ็นต์เพื่อตั้งค่าการเรียก Google APIs (เช่น เมื่อ
การเรียกใช้ Drive Files API)
คุณสามารถทดลองใช้ Google API ทั้งหมดและดูขอบเขตของ API เหล่านี้ได้ที่ OAuth 2.0 Playground
ตัวอย่าง HTTP GET
การเรียกไปยัง
drive.files
ปลายทาง (Drive Files API) โดยใช้ HTTP Authorization: Bearer
ส่วนหัวอาจมีลักษณะดังต่อไปนี้ โปรดทราบว่าคุณต้องระบุโทเค็นเพื่อการเข้าถึงของคุณเอง
GET /drive/v2/files HTTP/1.1 Host: www.googleapis.com Authorization: Bearer access_token
นี่คือการเรียก API เดียวกันสำหรับผู้ใช้ที่ตรวจสอบสิทธิ์แล้วโดยใช้ access_token
พารามิเตอร์สตริงการค้นหา:
GET https://www.googleapis.com/drive/v2/files?access_token=access_token
ตัวอย่างของ curl
ทดสอบคำสั่งเหล่านี้ได้ด้วยแอปพลิเคชันบรรทัดคำสั่ง curl
นี่คือ
ตัวอย่างที่ใช้ตัวเลือกส่วนหัว HTTP (แนะนำ)
curl -H "Authorization: Bearer access_token" https://www.googleapis.com/drive/v2/files
หรือใช้ตัวเลือกพารามิเตอร์สตริงคำค้นหาดังนี้
curl https://www.googleapis.com/drive/v2/files?access_token=access_token
เมื่อโทเค็นเพื่อการเข้าถึงหมดอายุ
โทเค็นเพื่อการเข้าถึงที่ออกโดยเซิร์ฟเวอร์การให้สิทธิ์ของ Google OAuth 2.0 จะหมดอายุหลังจากระยะเวลาดังกล่าว
ที่ระบุโดยค่า expires_in
เมื่อโทเค็นเพื่อการเข้าถึงหมดอายุ
แอปพลิเคชันควรสร้าง JWT อื่น ลงนาม และขอโทเค็นเพื่อการเข้าถึงรายการใหม่
รหัสข้อผิดพลาด JWT
error ช่อง |
error_description ช่อง |
ความหมาย | วิธีแก้ไข |
---|---|---|---|
unauthorized_client |
Unauthorized client or scope in request. |
หากคุณพยายามใช้การมอบสิทธิ์ทั่วทั้งโดเมน บัญชีบริการจะไม่ได้รับสิทธิ์ใน คอนโซลผู้ดูแลระบบของโดเมนผู้ใช้ |
ตรวจสอบว่าบัญชีบริการได้รับอนุญาตใน
หน้าการมอบสิทธิ์ทั่วทั้งโดเมนของคอนโซลผู้ดูแลระบบสำหรับผู้ใช้ใน
การอ้างสิทธิ์ ซึ่งโดยปกติจะใช้เวลาเพียงไม่กี่นาที แต่บางครั้งอาจใช้เวลาถึง 24 ชั่วโมงจึงจะได้รับสิทธิ์ มีผลกับผู้ใช้ทั้งหมดในบัญชี Google ของคุณ |
unauthorized_client |
Client is unauthorized to retrieve access tokens using this method, or client not
authorized for any of the scopes requested. |
บัญชีบริการได้รับสิทธิ์โดยใช้อีเมลไคลเอ็นต์ ไม่ใช่รหัสไคลเอ็นต์ (ตัวเลข) ในคอนโซลผู้ดูแลระบบ | ใน หน้าการมอบสิทธิ์ทั่วทั้งโดเมนในคอนโซลผู้ดูแลระบบ แล้วนำไคลเอ็นต์ออก แล้วเพิ่มกลับเข้าไปใหม่ ด้วยรหัสตัวเลข |
access_denied |
(ค่าใดก็ได้) | หากใช้การมอบสิทธิ์ทั่วทั้งโดเมน ขอบเขตที่ขออย่างน้อย 1 รายการไม่ได้รับอนุมัติ ในคอนโซลผู้ดูแลระบบ |
ตรวจสอบว่าบัญชีบริการได้รับอนุญาตใน
หน้าการมอบสิทธิ์ทั่วทั้งโดเมนของคอนโซลผู้ดูแลระบบสำหรับผู้ใช้ใน
การอ้างสิทธิ์ (ช่อง) ซึ่งโดยปกติจะใช้เวลาเพียงไม่กี่นาที แต่บางครั้งอาจใช้เวลาถึง 24 ชั่วโมงจึงจะได้รับสิทธิ์ มีผลกับผู้ใช้ทั้งหมดในบัญชี Google ของคุณ |
admin_policy_enforced |
(ค่าใดก็ได้) | บัญชี Google ให้สิทธิ์ขอบเขตที่ขออย่างน้อย 1 ขอบเขตไม่ได้เนื่องจาก นโยบายของผู้ดูแลระบบ Google Workspace |
ดูบทความช่วยเหลือสำหรับผู้ดูแลระบบ Google Workspace ควบคุมว่าจะให้บุคคลที่สาม แอปภายในเข้าถึงข้อมูล Google Workspace เพื่อดูข้อมูลเพิ่มเติมเกี่ยวกับวิธีที่ ผู้ดูแลระบบอาจจำกัดสิทธิ์เข้าถึงขอบเขตทั้งหมด หรือขอบเขตที่จำกัดและละเอียดอ่อนจนกว่า ระบบจะให้สิทธิ์เข้าถึงรหัสไคลเอ็นต์ OAuth อย่างชัดแจ้ง |
invalid_client |
(ค่าใดก็ได้) |
ไคลเอ็นต์ OAuth หรือโทเค็น JWT ไม่ถูกต้องหรือกําหนดค่าไม่ถูกต้อง โปรดดูรายละเอียดในคำอธิบายข้อผิดพลาด |
ตรวจสอบว่าโทเค็น JWT ถูกต้องและมีการอ้างสิทธิ์ที่ถูกต้อง ตรวจสอบว่าบัญชีลูกค้า OAuth และบัญชีบริการ มีการกำหนดค่าอย่างถูกต้อง และคุณใช้ที่อยู่อีเมลที่ถูกต้อง ตรวจสอบว่าโทเค็น JWT ถูกต้องและออกให้กับรหัสไคลเอ็นต์ใน อีกครั้ง |
invalid_grant |
Not a valid email. |
ไม่มีผู้ใช้นี้ | ตรวจสอบว่าอีเมลในการอ้างสิทธิ์ sub ถูกต้อง |
invalid_grant |
|
โดยทั่วไปหมายความว่าเวลาของระบบท้องถิ่นไม่ถูกต้อง หรืออาจเกิดขึ้นหาก
ค่า exp เกิน 65 นาทีในอนาคตจากค่า iat
หรือค่า exp ต่ำกว่าค่า iat |
ตรวจสอบว่านาฬิกาในระบบที่สร้าง JWT ถูกต้อง ถ้า ให้ซิงค์เวลาของคุณกับ NTP ของ Google |
invalid_grant |
Invalid JWT Signature. |
การยืนยัน JWT ลงนามด้วยคีย์ส่วนตัวที่ไม่ได้เชื่อมโยงกับบัญชีบริการ ที่ระบุโดยอีเมลไคลเอ็นต์หรือคีย์ที่ใช้ถูกลบ ปิดใช้งาน หรือ หมดอายุแล้ว หรือการยืนยัน JWT อาจเข้ารหัสไม่ถูกต้อง ต้อง เข้ารหัส Base64 โดยไม่มีการขึ้นบรรทัดใหม่หรือเครื่องหมายเท่ากับระยะห่างจากขอบ |
ถอดรหัสชุดการอ้างสิทธิ์ JWT และยืนยันว่าคีย์ที่ลงนามในการยืนยันมีความเชื่อมโยง ด้วยบัญชีบริการ ลองใช้ไลบรารี OAuth ที่ Google จัดเตรียมไว้ให้เพื่อให้แน่ใจว่าสร้าง JWT ได้อย่างถูกต้อง |
invalid_scope |
Invalid OAuth scope or ID token audience provided. |
ไม่มีคำขอขอบเขต (รายการขอบเขตว่างเปล่า) หรือขอบเขตที่ขอรายการใดรายการหนึ่งไม่มี มีอยู่ (เช่น ไม่ถูกต้อง) |
ตรวจสอบว่ามีการป้อนข้อมูลการอ้างสิทธิ์ โปรดทราบว่ารายการขอบเขตในการอ้างสิทธิ์ |
disabled_client |
The OAuth client was disabled. |
คีย์ที่ใช้ในการลงนามการยืนยัน JWT ปิดใช้อยู่ |
ไปที่ Google API Consoleและภายใต้ IAM และ ผู้ดูแลระบบ บัญชีบริการ ให้เปิดใช้บัญชีบริการที่มี "รหัสคีย์" ใช้แล้ว เพื่อลงชื่อยืนยัน |
org_internal |
This client is restricted to users within its organization. |
รหัสไคลเอ็นต์ OAuth ในคำขอเป็นส่วนหนึ่งของโปรเจ็กต์ที่จำกัดการเข้าถึง Google บัญชีใน Google Cloud Organization |
โปรดใช้บัญชีบริการจากองค์กรในการตรวจสอบสิทธิ์ ยืนยัน ประเภทผู้ใช้ สำหรับแอปพลิเคชัน OAuth |
ภาคผนวก: การให้สิทธิ์บัญชีบริการโดยไม่มี OAuth
สำหรับ Google APIs บางอย่าง คุณสามารถเรียก API ที่ได้รับอนุญาตโดยใช้ JWT ที่ลงชื่อได้โดยตรง โทเค็นสำหรับผู้ถือ ไม่ใช่โทเค็นเพื่อการเข้าถึง OAuth 2.0 เมื่อเป็นไปได้ คุณสามารถหลีกเลี่ยงการ เพื่อส่งคำขอเครือข่ายไปยังเซิร์ฟเวอร์การให้สิทธิ์ของ Google ก่อนเรียก API
หาก API ที่คุณต้องการเรียกใช้มีการเผยแพร่คำจำกัดความของบริการใน ที่เก็บ Google APIs GitHub คุณสามารถเรียก API ที่ได้รับอนุญาตโดยใช้ JWT แทนโทเค็นเพื่อการเข้าถึงได้ โดยทำดังนี้
- สร้างบัญชีบริการตามที่อธิบายไว้ข้างต้น อย่าลืม จะเก็บไฟล์ JSON ที่คุณได้รับเมื่อสร้างบัญชี
- ใช้ไลบรารี JWT มาตรฐานใดก็ได้ เช่น ไลบรารีที่พบที่
jwt.io ให้สร้าง JWT ที่มีส่วนหัว
และเพย์โหลดตามตัวอย่างต่อไปนี้
{ "alg": "RS256", "typ": "JWT", "kid": "abcdef1234567890" } . { "iss": "123456-compute@developer.gserviceaccount.com", "sub": "123456-compute@developer.gserviceaccount.com", "aud": "https://firestore.googleapis.com/", "iat": 1511900000, "exp": 1511903600 }
- สำหรับช่อง
kid
ในส่วนหัว ให้ระบุคีย์ส่วนตัวของบัญชีบริการ ID คุณดูค่านี้ได้ในช่องprivate_key_id
ของบัญชีบริการ JSON - สำหรับช่อง
iss
และsub
ให้ระบุอีเมลของบัญชีบริการ ที่อยู่ คุณจะดูค่านี้ได้ในช่องclient_email
ของบริการ ไฟล์ JSON ของบัญชี - สําหรับช่อง
aud
ให้ระบุปลายทาง API ดังตัวอย่างต่อไปนี้https://SERVICE.googleapis.com/
- สำหรับช่อง
iat
ให้ระบุเวลาปัจจุบันของ Unix และในช่องexp
ให้ระบุเวลาในอีก 3,600 วินาทีต่อมาเมื่อ JWT จะ หมดอายุ
ลงนาม JWT ด้วย RSA-256 โดยใช้คีย์ส่วนตัวที่พบในไฟล์ JSON ของบัญชีบริการ
เช่น
Java
การใช้ google-api-java-client และ java-jwt:
GoogleCredential credential = GoogleCredential.fromStream(new FileInputStream("MyProject-1234.json")); PrivateKey privateKey = credential.getServiceAccountPrivateKey(); String privateKeyId = credential.getServiceAccountPrivateKeyId(); long now = System.currentTimeMillis(); try { Algorithm algorithm = Algorithm.RSA256(null, privateKey); String signedJwt = JWT.create() .withKeyId(privateKeyId) .withIssuer("123456-compute@developer.gserviceaccount.com") .withSubject("123456-compute@developer.gserviceaccount.com") .withAudience("https://firestore.googleapis.com/") .withIssuedAt(new Date(now)) .withExpiresAt(new Date(now + 3600 * 1000L)) .sign(algorithm); } catch ...
Python
ใช้ PyJWT
iat = time.time() exp = iat + 3600 payload = {'iss': '123456-compute@developer.gserviceaccount.com', 'sub': '123456-compute@developer.gserviceaccount.com', 'aud': 'https://firestore.googleapis.com/', 'iat': iat, 'exp': exp} additional_headers = {'kid': PRIVATE_KEY_ID_FROM_JSON} signed_jwt = jwt.encode(payload, PRIVATE_KEY_FROM_JSON, headers=additional_headers, algorithm='RS256')
- เรียกใช้ API โดยใช้ JWT ที่ลงชื่อเป็นโทเค็นสำหรับผู้ถือ
GET /v1/projects/abc/databases/123/indexes HTTP/1.1 Authorization: Bearer SIGNED_JWT Host: firestore.googleapis.com
การใช้การป้องกันแบบครอบคลุมหลายบริการ
ขั้นตอนเพิ่มเติมที่คุณควรทำเพื่อปกป้องผู้ใช้ของคุณ บัญชีกำลังใช้ข้ามบัญชี ป้องกันโดยใช้บริการการป้องกันแบบครอบคลุมหลายบริการของ Google บริการนี้ช่วยให้คุณ สมัครรับการแจ้งเตือนเกี่ยวกับการดำเนินการด้านความปลอดภัย ซึ่งจะให้ข้อมูลเกี่ยวกับแอปพลิเคชันของคุณเกี่ยวกับ การเปลี่ยนแปลงที่สำคัญในบัญชีผู้ใช้ จากนั้นคุณสามารถใช้ข้อมูลดังกล่าวเพื่อดำเนินการต่างๆ โดย วิธีตัดสินใจตอบสนองต่อเหตุการณ์
ตัวอย่างประเภทเหตุการณ์ที่บริการการป้องกันแบบครอบคลุมหลายบริการของ Google ส่งไปยังแอปของคุณ ได้แก่
-
https://schemas.openid.net/secevent/risc/event-type/sessions-revoked
-
https://schemas.openid.net/secevent/oauth/event-type/token-revoked
-
https://schemas.openid.net/secevent/risc/event-type/account-disabled
โปรดดู ปกป้องบัญชีผู้ใช้ด้วยหน้าการป้องกันแบบครอบคลุมหลายบริการ ดูข้อมูลเพิ่มเติมเกี่ยวกับวิธีใช้การป้องกันแบบครอบคลุมหลายบริการและรายการเหตุการณ์ทั้งหมดที่มี