การใช้ OAuth 2.0 สำหรับแอปพลิเคชันระหว่างเซิร์ฟเวอร์กับเซิร์ฟเวอร์

วันที่

ระบบ 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วิธีสร้างบัญชีบริการ หรือดูข้อมูลรับรองสาธารณะที่คุณสร้างไว้แล้ว ให้ทำดังนี้

ขั้นแรก สร้างบัญชีบริการ:

  1. เปิด Service accounts page
  2. If prompted, select a project, or create a new one.
  3. คลิก สร้างบัญชีบริการ
  4. ภายใต้ รายละเอียดบัญชีบริการ ให้พิมพ์ชื่อ ID และคำอธิบายสำหรับบัญชีบริการ จากนั้นคลิก สร้างและดำเนิน การต่อ
  5. ทางเลือก: ภายใต้ ให้สิทธิ์การเข้าถึงบัญชีบริการนี้กับโครงการ เลือกบทบาท IAM เพื่อมอบให้กับบัญชีบริการ
  6. คลิกดำเนินการ ต่อ
  7. ไม่บังคับ: ภายใต้ ให้สิทธิ์ผู้ใช้เข้าถึงบัญชีบริการนี้ ให้ เพิ่มผู้ใช้หรือกลุ่มที่ได้รับอนุญาตให้ใช้และจัดการบัญชีบริการ
  8. คลิก เสร็จสิ้น

จากนั้น สร้างรหัสบัญชีบริการ:

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

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

คุณสามารถกลับไปที่ API Console ได้ทุกเมื่อเพื่อดูอีเมล แบบสาธารณะ ลายนิ้วมือหลัก และข้อมูลอื่นๆ หรือสร้างคู่คีย์สาธารณะ/ส่วนตัวเพิ่มเติม สำหรับ รายละเอียดเพิ่มเติมเกี่ยวกับข้อมูลเข้าสู่ระบบของบัญชีบริการใน API Consoleโปรดดู บัญชีบริการใน API Console ไฟล์ช่วยเหลือ

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

การมอบสิทธิ์ทั่วทั้งโดเมนให้กับบัญชีบริการ

ผู้ดูแลระบบ Workspace ขององค์กรสามารถใช้บัญชี Google Workspace เพื่อให้สิทธิ์ สำหรับเข้าถึงข้อมูลผู้ใช้ Workspace ในนามของผู้ใช้ในโดเมน Google Workspace ตัวอย่างเช่น แอปพลิเคชันที่ใช้ API ของ Google ปฏิทิน เพื่อเพิ่มกิจกรรมในปฏิทินของผู้ใช้ทั้งหมดใน โดเมน Google Workspace จะใช้บัญชีบริการเพื่อเข้าถึง Google Calendar API ใน ในนามของผู้ใช้ การให้สิทธิ์บัญชีบริการเพื่อเข้าถึงข้อมูลในนามของผู้ใช้ในโดเมนคือ บางครั้งเรียกว่า "การมอบสิทธิ์ทั่วทั้งโดเมน" กับบัญชีบริการ

หากต้องการมอบสิทธิ์ทั่วทั้งโดเมนให้กับบัญชีบริการ ผู้ดูแลระบบขั้นสูงของ Google โดเมน Workspace ต้องทําตามขั้นตอนต่อไปนี้

  1. จาก ของโดเมน Google Workspace ของคุณ คอนโซลผู้ดูแลระบบ ให้ไปที่เมนูหลัก ความปลอดภัย > การเข้าถึงและการควบคุมข้อมูล > การควบคุม API
  2. ในแผงการมอบสิทธิ์ทั่วทั้งโดเมน ให้เลือกจัดการการมอบสิทธิ์ทั่วทั้งโดเมน
  3. คลิกเพิ่มใหม่
  4. ในช่องรหัสไคลเอ็นต์ ให้ป้อนรหัสไคลเอ็นต์ของบัญชีบริการ คุณดู รหัสไคลเอ็นต์ของบัญชีบริการใน Service accounts page
  5. ในช่องขอบเขต OAuth (คั่นด้วยเครื่องหมายจุลภาค) ให้ป้อนรายการขอบเขตที่ แอปพลิเคชันควรได้รับสิทธิ์ในการเข้าถึง ตัวอย่างเช่น หากแอปพลิเคชันของคุณต้องใช้ทั้งโดเมน สิทธิ์เข้าถึง Google Drive API และ Google Calendar API โดยสมบูรณ์ ให้ป้อนข้อมูลต่อไปนี้ https://www.googleapis.com/auth/drive, https://www.googleapis.com/auth/calendar
  6. คลิกให้สิทธิ์

ตอนนี้แอปพลิเคชันของคุณมีสิทธิ์เรียก 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 เพื่อทำตามขั้นตอนต่อไปนี้

  1. สร้างออบเจ็กต์ 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 คุณสามารถใช้ ข้อมูลเข้าสู่ระบบเริ่มต้นของแอปพลิเคชัน แต่จะทำให้กระบวนการนี้ง่ายขึ้น

  2. มอบสิทธิ์ทั่วทั้งโดเมน

    หากคุณมอบสิทธิ์เข้าถึงทั่วทั้งโดเมนให้กับบัญชีบริการแล้วและต้องการ แอบอ้างบัญชีผู้ใช้อื่น ใช้เมธอด with_subject ของบัญชีที่มีอยู่ ServiceAccountCredentials ออบเจ็กต์ เช่น

    delegated_credentials = credentials.with_subject('user@example.org')

ใช้ออบเจ็กต์ข้อมูลเข้าสู่ระบบเพื่อเรียกใช้ Google API ในแอปพลิเคชันของคุณ

HTTP/REST

หลังจากได้รหัสไคลเอ็นต์และคีย์ส่วนตัวจาก API Consoleใบสมัครของคุณต้องผ่าน ขั้นตอนต่อไปนี้

  1. สร้างเว็บโทเค็น JSON (JWT อ่านว่า "jot") ซึ่งประกอบด้วยส่วนหัว ชุดการอ้างสิทธิ์ และลายเซ็น
  2. ส่งคำขอโทเค็นการเข้าถึงจากเซิร์ฟเวอร์การให้สิทธิ์ของ Google OAuth 2.0
  3. จัดการการตอบกลับ JSON ที่เซิร์ฟเวอร์การให้สิทธิ์แสดง

ส่วนต่อไปนี้จะอธิบายวิธีทำตามขั้นตอนเหล่านี้

ถ้าการตอบกลับมีโทเค็นเพื่อการเข้าถึง คุณจะสามารถใช้โทเค็นเพื่อการเข้าถึงเพื่อ เรียก Google API (หากคำตอบไม่รวมสิทธิ์การเข้าถึง โทเค็น JWT และคำขอโทเค็นอาจมีรูปแบบไม่ถูกต้อง หรือบัญชีบริการอาจ ไม่มีสิทธิ์เข้าถึงขอบเขตที่ขอ)

เมื่อโทเค็นเพื่อการเข้าถึงหมดอายุ แอปพลิเคชันจะสร้างโทเค็นอื่น JWT, ลงนาม และขอโทเค็นเพื่อการเข้าถึงใหม่

แอปพลิเคชันเซิร์ฟเวอร์ของคุณใช้ JWT เพื่อขอโทเค็นจาก Google เซิร์ฟเวอร์การให้สิทธิ์ จากนั้นจะใช้โทเค็นเพื่อเรียกใช้ปลายทาง Google API ยังไม่ได้ติดต่อ ให้ผู้ใช้ปลายทางมีส่วนร่วมด้วย

ส่วนที่เหลือของส่วนนี้จะอธิบายรายละเอียดในการสร้าง 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 โดยกรอกข้อมูลใน ขั้นตอนต่อไปนี้

  1. สร้างออบเจ็กต์บริการสำหรับ API ที่คุณต้องการเรียกใช้โดยใช้ ออบเจ็กต์ GoogleCredential รายการ ตัวอย่างเช่น 
    SQLAdmin sqladmin =
    new SQLAdmin.Builder(httpTransport, JSON_FACTORY, credential).build();
  2. ส่งคำขอไปยังบริการ API โดยใช้ อินเทอร์เฟซจากออบเจ็กต์บริการ ตัวอย่างเช่น เพื่อแสดงรายการอินสแตนซ์ของฐานข้อมูล Cloud SQL ในที่น่าตื่นเต้น-example-123 โปรเจ็กต์: 
    SQLAdmin.Instances.List instances =
    sqladmin.instances().list("exciting-example-123").execute();

Python

ใช้ออบเจ็กต์ Credentials ที่ได้รับอนุญาตเพื่อเรียกใช้ Google APIs โดยดําเนินการตาม ขั้นตอนต่อไปนี้

  1. สร้างออบเจ็กต์บริการสำหรับ API ที่คุณต้องการเรียกใช้ คุณสร้างออบเจ็กต์บริการ โดยเรียกใช้ฟังก์ชัน build ด้วยชื่อและเวอร์ชันของ API และ ออบเจ็กต์ Credentials ที่ได้รับอนุญาต เช่น หากต้องการเรียกเวอร์ชัน 1beta3 ของ API การดูแลระบบ Cloud SQL 
    import googleapiclient.discovery

sqladmin = googleapiclient.discovery.build('sqladmin', 'v1beta3', credentials=credentials)
  2. ส่งคำขอไปยังบริการ 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. หากคุณพยายามใช้การมอบสิทธิ์ทั่วทั้งโดเมน บัญชีบริการจะไม่ได้รับสิทธิ์ใน คอนโซลผู้ดูแลระบบของโดเมนผู้ใช้

ตรวจสอบว่าบัญชีบริการได้รับอนุญาตใน หน้าการมอบสิทธิ์ทั่วทั้งโดเมนของคอนโซลผู้ดูแลระบบสำหรับผู้ใช้ใน การอ้างสิทธิ์ sub (ช่อง)

ซึ่งโดยปกติจะใช้เวลาเพียงไม่กี่นาที แต่บางครั้งอาจใช้เวลาถึง 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 รายการไม่ได้รับอนุมัติ ในคอนโซลผู้ดูแลระบบ

ตรวจสอบว่าบัญชีบริการได้รับอนุญาตใน หน้าการมอบสิทธิ์ทั่วทั้งโดเมนของคอนโซลผู้ดูแลระบบสำหรับผู้ใช้ใน การอ้างสิทธิ์ (ช่อง) sub รายการ และมีขอบเขตทั้งหมดที่คุณขอ ในการอ้างสิทธิ์scopeของ JWT

ซึ่งโดยปกติจะใช้เวลาเพียงไม่กี่นาที แต่บางครั้งอาจใช้เวลาถึง 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

Invalid JWT: Token must be a short-lived token (60 minutes) and in a reasonable timeframe. Check your 'iat' and 'exp' values and use a clock with skew to account for clock differences between systems.

 โดยทั่วไปหมายความว่าเวลาของระบบท้องถิ่นไม่ถูกต้อง หรืออาจเกิดขึ้นหาก ค่า 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. ไม่มีคำขอขอบเขต (รายการขอบเขตว่างเปล่า) หรือขอบเขตที่ขอรายการใดรายการหนึ่งไม่มี มีอยู่ (เช่น ไม่ถูกต้อง)

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

โปรดทราบว่ารายการขอบเขตในการอ้างสิทธิ์ scope ต้องแยกกันด้วย เว้นวรรค ไม่ใช่จุลภาค
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 แทนโทเค็นเพื่อการเข้าถึงได้ โดยทำดังนี้

  1. สร้างบัญชีบริการตามที่อธิบายไว้ข้างต้น อย่าลืม จะเก็บไฟล์ JSON ที่คุณได้รับเมื่อสร้างบัญชี
  2. ใช้ไลบรารี 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')
  1. เรียกใช้ 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

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