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

ระบบ Google OAuth 2.0 รองรับการโต้ตอบระหว่างเซิร์ฟเวอร์กับเซิร์ฟเวอร์ เช่น การโต้ตอบระหว่างเว็บ แอปพลิเคชันกับบริการของ Google ในกรณีนี้ คุณต้องมีบัญชีบริการ ซึ่งเป็นบัญชีที่เป็นของแอปพลิเคชันคุณ ไม่ใช่ของผู้ใช้ปลายทางแต่ละราย แอปพลิเคชันของคุณจะเรียก Google APIs ในนามของบัญชีบริการ ผู้ใช้จึงไม่มีส่วนเกี่ยวข้องโดยตรง บางครั้งสถานการณ์นี้เรียกว่า "OAuth แบบ 2 ขา" หรือ "2LO" (คำที่เกี่ยวข้อง "OAuth แบบ 3 ทาง" หมายถึงสถานการณ์ที่แอปพลิเคชันของคุณเรียกใช้ Google APIs ในนามของผู้ใช้ปลายทาง และในบางครั้งอาจต้องได้รับความยินยอมจากผู้ใช้)

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

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

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

ภาพรวม

หากต้องการรองรับการโต้ตอบระหว่างเซิร์ฟเวอร์กับเซิร์ฟเวอร์ ให้สร้างบัญชีบริการสำหรับโปรเจ็กต์ใน API Consoleก่อน หากต้องการเข้าถึงข้อมูลผู้ใช้สำหรับผู้ใช้ในบัญชี Google Workspace ให้มอบสิทธิ์เข้าถึงทั่วทั้งโดเมนแก่บัญชีบริการ

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

สุดท้าย แอปพลิเคชันของคุณจะใช้โทเค็นการเข้าถึงเพื่อเรียก Google API ได้

การสร้างบัญชีบริการ

ข้อมูลเข้าสู่ระบบของบัญชีบริการประกอบด้วยอีเมลที่สร้างขึ้นซึ่งไม่ซ้ำกัน และคู่คีย์สาธารณะ/ส่วนตัวอย่างน้อย 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 ขององค์กรสามารถให้สิทธิ์แอปพลิเคชันเข้าถึงข้อมูลผู้ใช้ Workspace ในนามของผู้ใช้ในโดเมน Google Workspace ได้โดยใช้บัญชี Google Workspace เช่น แอปพลิเคชันที่ใช้ Google Calendar API เพื่อเพิ่มกิจกรรมลงในปฏิทินของผู้ใช้ทั้งหมดใน โดเมน 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 สำหรับ Java เพื่อสร้างออบเจ็กต์ GoogleCredentials จากข้อมูลเข้าสู่ระบบของบัญชีบริการและ ขอบเขตที่แอปพลิเคชันของคุณต้องเข้าถึง เช่น

import com.google.auth.oauth2.GoogleCredentials;
import com.google.api.services.sqladmin.SQLAdminScopes;

// ...

GoogleCredentials credentials = GoogleCredentials.fromStream(new FileInputStream("MyProject-1234.json"))
    .createScoped(Collections.singleton(SQLAdminScopes.SQLSERVICE_ADMIN));

หากกำลังพัฒนาแอปใน Google Cloud Platform คุณสามารถใช้ข้อมูลเข้าสู่ระบบเริ่มต้นของแอปพลิเคชันแทนได้ ซึ่งจะช่วยลดความซับซ้อนของกระบวนการ

มอบสิทธิ์ระดับโดเมน

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

GoogleCredentials credentials = GoogleCredentials.fromStream(new FileInputStream("MyProject-1234.json"))
    .createScoped(Collections.singleton(SQLAdminScopes.SQLSERVICE_ADMIN))
    .createDelegated("workspace-user@example.com");

โค้ดด้านบนใช้ออบเจ็กต์ GoogleCredentials เพื่อเรียกใช้เมธอด createDelegated() อาร์กิวเมนต์สำหรับเมธอด createDelegated() ต้องเป็นผู้ใช้ที่อยู่ในบัญชี Workspace ของคุณ โค้ดที่ส่งคำขอจะใช้ข้อมูลเข้าสู่ระบบนี้เพื่อเรียกใช้ Google APIs โดยใช้บัญชีบริการของคุณ

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')

ใช้ออบเจ็กต์ Credentials เพื่อเรียก Google APIs ในแอปพลิเคชัน

HTTP/REST

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

  1. สร้างโทเค็นเว็บ JSON (JWT ออกเสียงว่า "จ็อต") ซึ่งมีส่วนหัว ชุดการอ้างสิทธิ์ และลายเซ็น
  2. ขอโทเค็นเพื่อการเข้าถึงจากเซิร์ฟเวอร์การให้สิทธิ์ OAuth 2.0 ของ Google
  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 ฟิลด์ที่ระบุอัลกอริทึมการลงนาม รูปแบบของ การยืนยัน และ[รหัสคีย์ของคีย์บัญชีบริการ](https://cloud.google.com/iam/docs/reference/rest/v1/projects.serviceAccounts.keys) ที่ใช้ในการลงนาม JWT คุณต้องระบุอัลกอริทึมและรูปแบบ และแต่ละฟิลด์จะมีค่าได้เพียงค่าเดียว เมื่อมีการเปิดตัวอัลกอริทึมและรูปแบบเพิ่มเติม ส่วนหัวนี้ก็จะเปลี่ยนแปลงตามไปด้วย รหัสคีย์เป็นตัวเลือก และหากระบุรหัสคีย์ที่ไม่ถูกต้อง 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 จะเป็นข้อผิดพลาด

ตัวอย่างชุดการอ้างสิทธิ์ 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 ชุดการอ้างสิทธิ์ของ JWT ควรได้รับการซีเรียลไลซ์เป็น UTF-8 และเข้ารหัสแบบ Base64url-safe ด้านล่างนี้คือตัวอย่างการแสดงชุดการอ้างสิทธิ์ JWT เป็น JSON

{
  "iss": "761326798069-r5mljlln1rd4lrbhg75efgigp36m78j5@developer.gserviceaccount.com",
  "scope": "https://www.googleapis.com/auth/prediction",
  "aud": "https://oauth2.googleapis.com/token",
  "exp": 1328554385,
  "iat": 1328550785
}
การคำนวณลายเซ็น

JSON Web Signature (JWS) คือข้อกำหนดที่แนะนำกลไกการสร้างลายเซ็นสำหรับ JWT อินพุตสำหรับลายเซ็นคืออาร์เรย์ไบต์ของเนื้อหาต่อไปนี้

{Base64url encoded header}.{Base64url encoded claim set}

ต้องใช้อัลกอริทึมการลงนามในส่วนหัวของ JWT เมื่อคำนวณลายเซ็น อัลกอริทึมการลงนามเดียวที่เซิร์ฟเวอร์การให้สิทธิ์ OAuth 2.0 ของ Google รองรับคือ 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 ที่ลงชื่อแล้ว แอปพลิเคชันจะใช้ 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

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

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

Python

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

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

sqladmin = googleapiclient.discovery.build('sqladmin', 'v1beta3', credentials=credentials)
  2. ส่งคำขอไปยังบริการ API โดยใช้อินเทอร์เฟซที่ออบเจ็กต์บริการจัดหาให้ เช่น หากต้องการแสดงรายการอินสแตนซ์ของฐานข้อมูล Cloud SQL ในโปรเจ็กต์ exciting-example-123 ให้ทำดังนี้ 
    response = sqladmin.instances().list(project='exciting-example-123').execute()

HTTP/REST

หลังจากที่แอปพลิเคชันได้รับโทเค็นการเข้าถึงแล้ว คุณจะใช้โทเค็นเพื่อเรียกใช้ Google API ในนามของบัญชีบริการหรือ บัญชีผู้ใช้ที่ระบุได้ หากได้รับขอบเขตการเข้าถึงที่ API ต้องการ โดยให้ใส่โทเค็นเพื่อการเข้าถึงในคำขอไปยัง API โดยใส่พารามิเตอร์การค้นหา access_token หรือค่าส่วนหัว HTTP Authorization Bearer หากเป็นไปได้ เราขอแนะนำให้ใช้ส่วนหัว HTTP เนื่องจากสตริงการค้นหามักจะปรากฏในบันทึกของเซิร์ฟเวอร์ ในกรณีส่วนใหญ่ คุณสามารถใช้ไลบรารีของไคลเอ็นต์เพื่อตั้งค่าการเรียกไปยัง Google APIs ได้ (เช่น เมื่อเรียกใช้ Drive Files API)

คุณลองใช้ Google APIs ทั้งหมดและดูขอบเขตของ 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

เมื่อโทเค็นเพื่อการเข้าถึงหมดอายุ

โทเค็นเพื่อการเข้าถึงที่เซิร์ฟเวอร์การให้สิทธิ์ OAuth 2.0 ของ Google ออกให้จะหมดอายุหลังจากระยะเวลา ที่ระบุโดยค่า 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

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

ไคลเอ็นต์ OAuth หรือโทเค็น JWT ไม่ถูกต้องหรือกำหนดค่าไม่ถูกต้อง

ดูรายละเอียดได้ในคำอธิบายข้อผิดพลาด

ตรวจสอบว่าโทเค็น JWT ใช้ได้และมีคำกล่าวอ้างที่ถูกต้อง

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

ตรวจสอบว่าโทเค็น JWT ถูกต้องและออกให้รหัสไคลเอ็นต์ในคำขอ

deleted_client (ค่าใดก็ได้)

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

ใช้รหัสไคลเอ็นต์ที่ยังใช้งานอยู่
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 โดยไม่มีบรรทัดใหม่หรือเครื่องหมายเท่ากับสำหรับ Padding

ถอดรหัสชุดการอ้างสิทธิ์ 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 ที่เฉพาะเจาะจง

ใช้บัญชีบริการจากองค์กรเพื่อตรวจสอบสิทธิ์ ยืนยันการกำหนดค่าประเภทผู้ใช้สำหรับแอปพลิเคชัน OAuth

ภาคผนวก: การให้สิทธิ์บัญชีบริการโดยไม่ต้องใช้ OAuth

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

หาก API ที่คุณต้องการเรียกมีคำจำกัดความของบริการที่เผยแพร่ใน ที่เก็บ GitHub ของ Google APIs คุณสามารถทำการเรียก API ที่ได้รับอนุญาตโดยใช้ JWT แทนโทเค็นเพื่อการเข้าถึงได้ โดยทำดังนี้

  1. สร้างบัญชีบริการตามที่อธิบายไว้ข้างต้น โปรด เก็บไฟล์ JSON ที่คุณได้รับเมื่อสร้างบัญชี
  2. สร้าง JWT ที่มีส่วนหัวและเพย์โหลดเหมือนตัวอย่างต่อไปนี้โดยใช้ไลบรารี JWT มาตรฐาน เช่น ไลบรารีที่พบใน jwt.io 
    {
  "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 ในส่วนหัว ให้ระบุรหัสคีย์ส่วนตัวของบัญชีบริการ คุณดูค่านี้ได้ในช่อง private_key_id ของไฟล์ JSON ของบัญชีบริการ
    • สำหรับช่อง iss และ sub ให้ระบุอีเมลของบัญชีบริการ คุณดูค่านี้ได้ในช่อง client_email ของไฟล์ JSON ของบัญชีบริการ
    • สำหรับฟิลด์ aud ให้ระบุปลายทาง API ตัวอย่างเช่น https://SERVICE.googleapis.com/
    • สำหรับฟิลด์ iat ให้ระบุเวลา Unix ปัจจุบัน และสำหรับฟิลด์ exp ให้ระบุเวลาที่ตรงกับ 3600 วินาทีต่อมา ซึ่งเป็นเวลาที่ JWT จะหมดอายุ

ลงชื่อ JWT ด้วย RSA-256 โดยใช้คีย์ส่วนตัวที่อยู่ในไฟล์ JSON ของบัญชีบริการ

เช่น

Java

การใช้ google-auth-library-java และ java-jwt

import com.google.auth.oauth2.ServiceAccountCredentials;
...
GoogleCredentials credentials =
        GoogleCredentials.fromStream(new FileInputStream("MyProject-1234.json"));
PrivateKey privateKey = ((ServiceAccountCredentials) credentials).getPrivateKey();
String privateKeyId = ((ServiceAccountCredentials) credentials).getPrivateKeyId();

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

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