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

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

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

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

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

ไลบรารีของไคลเอ็นต์

ตัวอย่างเฉพาะภาษาในหน้านี้ใช้ไลบรารีของไคลเอ็นต์ Google API เพื่อนำการให้สิทธิ์ OAuth 2.0 ไปใช้ หากต้องการเรียกใช้ตัวอย่างโค้ด คุณต้องติดตั้งไลบรารีของไคลเอ็นต์สำหรับภาษาของคุณก่อน

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

ไลบรารีของไคลเอ็นต์ Google API สำหรับแอปพลิเคชันฝั่งเซิร์ฟเวอร์มีให้บริการในภาษาต่อไปนี้

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

เปิดใช้ API สำหรับโปรเจ็กต์

แอปพลิเคชันที่เรียกใช้ Google API จะต้องเปิดใช้ API ดังกล่าวใน API Console

วิธีเปิดใช้ API สำหรับโปรเจ็กต์ของคุณ

  1. Open the API Library ใน Google API Console
  2. If prompted, select a project, or create a new one.
  3. API Library แสดงรายการ API ทั้งหมดที่ใช้ได้โดยจัดกลุ่มตามตระกูลผลิตภัณฑ์และความนิยม หาก API ที่ต้องการเปิดใช้ไม่ปรากฏในรายการ ให้ใช้การค้นหาเพื่อหา API หรือคลิกดูทั้งหมดในกลุ่มผลิตภัณฑ์ที่ API นั้นอยู่
  4. เลือก API ที่ต้องการเปิดใช้ แล้วคลิกปุ่มเปิดใช้
  5. If prompted, enable billing.
  6. If prompted, read and accept the API's Terms of Service.

สร้างข้อมูลเข้าสู่ระบบการให้สิทธิ์

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

  1. Go to the Credentials page.
  2. คลิกสร้างข้อมูลเข้าสู่ระบบ > รหัสไคลเอ็นต์ OAuth
  3. เลือกประเภทแอปพลิเคชันเว็บแอปพลิเคชัน
  4. กรอกแบบฟอร์มและคลิกสร้าง แอปพลิเคชันที่ใช้ภาษาและเฟรมเวิร์ก เช่น PHP, Java, Python, Ruby และ .NET ต้องระบุ URI การเปลี่ยนเส้นทางที่ได้รับอนุญาต URI การเปลี่ยนเส้นทางคือปลายทางที่เซิร์ฟเวอร์ OAuth 2.0 ส่งการตอบกลับได้ ปลายทางเหล่านี้ต้องเป็นไปตามกฎการตรวจสอบของ Google

    สำหรับการทดสอบ คุณจะระบุ URI ที่อ้างอิงถึงเครื่องภายในได้ เช่น http://localhost:8080 โปรดทราบว่าตัวอย่างทั้งหมดในเอกสารฉบับนี้ใช้ http://localhost:8080 เป็น URI การเปลี่ยนเส้นทาง

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

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

ระบุขอบเขตการเข้าถึง

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

ก่อนที่จะเริ่มใช้การให้สิทธิ์ OAuth 2.0 เราขอแนะนำให้คุณระบุขอบเขตที่แอปจำเป็นต้องได้รับสิทธิ์เข้าถึง

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

เอกสารขอบเขต OAuth 2.0 API มีรายการขอบเขตทั้งหมดที่คุณอาจใช้เพื่อเข้าถึง Google APIs

ข้อกำหนดเฉพาะภาษา

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

PHP

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

  • PHP 5.6 ขึ้นไปที่ติดตั้งส่วนขยายบรรทัดคำสั่ง (CLI) และส่วนขยาย JSON
  • เครื่องมือการจัดการทรัพยากร Dependency ของ Composer
  • ไลบรารีของไคลเอ็นต์ Google API สำหรับ PHP:

    composer require google/apiclient:^2.10

Python

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

  • Python 2.6 ขึ้นไป
  • เครื่องมือจัดการแพ็กเกจ pip
  • ไลบรารีของไคลเอ็นต์ Google APIs สำหรับ Python:
    pip install --upgrade google-api-python-client
  • google-auth, google-auth-oauthlib และ google-auth-httplib2 สำหรับการให้สิทธิ์ผู้ใช้
    pip install --upgrade google-auth google-auth-oauthlib google-auth-httplib2
  • เฟรมเวิร์กเว็บแอปพลิเคชัน Flask Python
    pip install --upgrade flask
  • ไลบรารี HTTP requests
    pip install --upgrade requests

Ruby

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

  • Ruby 2.6 ขึ้นไป
  • Google Auth Library สำหรับ Ruby:

    gem install googleauth
  • เฟรมเวิร์กเว็บแอปพลิเคชัน Sinatra Ruby

    gem install sinatra

Node.js

หากต้องการเรียกใช้ตัวอย่างโค้ด Node.js ในเอกสารนี้ คุณจะต้องมีสิ่งต่อไปนี้

  • LTS การบำรุงรักษา, LTS ที่ใช้งานอยู่ หรือ Node.js รุ่นปัจจุบัน
  • ไคลเอ็นต์ Google APIs Node.js

    npm install googleapis

HTTP/REST

คุณไม่จำเป็นต้องติดตั้งไลบรารีเพื่อให้เรียกใช้ปลายทาง OAuth 2.0 ได้โดยตรง

การรับโทเค็นเพื่อการเข้าถึง OAuth 2.0

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

รายการต่อไปนี้จะสรุปขั้นตอนเหล่านี้อย่างรวดเร็ว

  1. แอปพลิเคชันระบุสิทธิ์ที่ต้องการ
  2. แอปพลิเคชันเปลี่ยนเส้นทางผู้ใช้ไปยัง Google พร้อมด้วยรายการสิทธิ์ที่ขอ
  3. ผู้ใช้จะเป็นผู้ตัดสินใจว่าจะให้สิทธิ์แอปพลิเคชันของคุณหรือไม่
  4. แอปพลิเคชันจะตรวจสอบสิ่งที่ผู้ใช้ตัดสินใจ
  5. หากผู้ใช้ให้สิทธิ์ที่ขอ แอปพลิเคชันจะเรียกโทเค็นที่จำเป็นต่อการสร้างคำขอ API ในนามของผู้ใช้

ขั้นตอนที่ 1: ตั้งค่าพารามิเตอร์การให้สิทธิ์

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

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

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

PHP

ข้อมูลโค้ดด้านล่างจะสร้างออบเจ็กต์ Google\Client() ซึ่งกำหนดพารามิเตอร์ในคำขอการให้สิทธิ์

ออบเจ็กต์ดังกล่าวจะใช้ข้อมูลจากไฟล์ client_secret.json เพื่อระบุแอปพลิเคชัน (ดูการสร้างข้อมูลเข้าสู่ระบบการให้สิทธิ์สำหรับข้อมูลเพิ่มเติมเกี่ยวกับไฟล์นั้น) ออบเจ็กต์ยังระบุขอบเขตที่แอปพลิเคชันกำลังขอสิทธิ์ในการเข้าถึงและ URL ไปยังปลายทางการตรวจสอบสิทธิ์ของแอปพลิเคชัน ซึ่งจะจัดการการตอบกลับจากเซิร์ฟเวอร์ OAuth 2.0 ของ Google สุดท้าย โค้ดจะกําหนดพารามิเตอร์ access_type และ include_granted_scopes ซึ่งไม่บังคับ

ตัวอย่างเช่น โค้ดนี้ขอการเข้าถึง Google ไดรฟ์ของผู้ใช้แบบอ่านอย่างเดียวแบบออฟไลน์

$client = new Google\Client();
$client->setAuthConfig('client_secret.json');
$client->addScope(Google\Service\Drive::DRIVE_METADATA_READONLY);
$client->setRedirectUri('http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php');
// offline access will give you both an access and refresh token so that
// your app can refresh the access token without user interaction.
$client->setAccessType('offline');
// Using "consent" will prompt the user for consent
$client->setPrompt('consent');
$client->setIncludeGrantedScopes(true);   // incremental auth

คำขอจะระบุข้อมูลต่อไปนี้

พารามิเตอร์
client_id จำเป็น

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

ใน PHP ให้เรียกใช้ฟังก์ชัน setAuthConfig เพื่อโหลดข้อมูลเข้าสู่ระบบการให้สิทธิ์จากไฟล์ client_secret.json

$client = new Google\Client();
$client->setAuthConfig('client_secret.json');
redirect_uri จำเป็น

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

โปรดทราบว่าชุดรูปแบบ http หรือ https ตัวพิมพ์ และเครื่องหมายทับปิดท้าย ("/") ต้องตรงกันทั้งหมด

หากต้องการตั้งค่านี้ใน PHP ให้เรียกใช้ฟังก์ชัน setRedirectUri โปรดทราบว่าคุณต้องระบุ URI การเปลี่ยนเส้นทางที่ถูกต้องสำหรับ client_id ที่ระบุ

$client->setRedirectUri('https://oauth2.example.com/code');
scope จำเป็น

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

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

หากต้องการตั้งค่านี้ใน PHP ให้เรียกใช้ฟังก์ชัน addScope:

$client->addScope(Google\Service\Drive::DRIVE_METADATA_READONLY);

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

access_type แนะนำ

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

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

หากต้องการตั้งค่านี้ใน PHP ให้เรียกใช้ฟังก์ชัน setAccessType:

$client->setAccessType('offline');
state แนะนำ

ระบุค่าสตริงที่แอปพลิเคชันจะใช้เพื่อรักษาสถานะระหว่างคำขอการให้สิทธิ์และการตอบกลับของเซิร์ฟเวอร์การให้สิทธิ์ เซิร์ฟเวอร์จะแสดงค่าที่คุณส่งเป็นคู่ name=value ในคอมโพเนนต์การค้นหา URL (?) ของ redirect_uri หลังจากที่ผู้ใช้ยินยอมหรือปฏิเสธคำขอเข้าถึงแอปพลิเคชันของคุณ

คุณใช้พารามิเตอร์นี้ได้เพื่อวัตถุประสงค์หลายประการ เช่น การนำผู้ใช้ไปยังทรัพยากรที่ถูกต้องในแอปพลิเคชัน การส่ง Nonce และการบรรเทาการปลอมแปลงคำขอข้ามเว็บไซต์ เนื่องจากการคาดเดาของ redirect_uri ได้ การใช้ค่า state จะช่วยเพิ่มความมั่นใจได้ว่าการเชื่อมต่อขาเข้าเป็นผลมาจากคำขอการตรวจสอบสิทธิ์ หากสร้างสตริงแบบสุ่มหรือเข้ารหัสแฮชของคุกกี้หรือค่าอื่นที่บันทึกสถานะของไคลเอ็นต์ คุณสามารถตรวจสอบการตอบกลับเพื่อให้มั่นใจว่าคำขอและคำตอบนั้นสร้างขึ้นในเบราว์เซอร์เดียวกัน ซึ่งจะช่วยป้องกันการโจมตีต่างๆ เช่น การปลอมแปลงคำขอข้ามเว็บไซต์ โปรดดูเอกสาร OpenID Connect สำหรับตัวอย่างวิธีสร้างและยืนยันโทเค็น state

หากต้องการตั้งค่านี้ใน PHP ให้เรียกใช้ฟังก์ชัน setState:

$client->setState($sample_passthrough_value);
include_granted_scopes ไม่บังคับ

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

หากต้องการตั้งค่านี้ใน PHP ให้เรียกใช้ฟังก์ชัน setIncludeGrantedScopes:

$client->setIncludeGrantedScopes(true);
login_hint ไม่บังคับ

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

ตั้งค่าค่าพารามิเตอร์เป็นอีเมลหรือตัวระบุ sub ซึ่งเทียบเท่ากับรหัส Google ของผู้ใช้

หากต้องการตั้งค่านี้ใน PHP ให้เรียกใช้ฟังก์ชัน setLoginHint:

$client->setLoginHint('None');
prompt ไม่บังคับ

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

หากต้องการตั้งค่านี้ใน PHP ให้เรียกใช้ฟังก์ชัน setPrompt:

$client->setPrompt('consent');

ค่าที่เป็นไปได้มีดังนี้

none ไม่แสดงหน้าจอการตรวจสอบสิทธิ์หรือความยินยอม ไม่ต้องระบุพร้อมกับค่าอื่นๆ
consent แจ้งให้ผู้ใช้ขอความยินยอม
select_account แจ้งให้ผู้ใช้เลือกบัญชี

Python

ข้อมูลโค้ดต่อไปนี้ใช้โมดูล google-auth-oauthlib.flow เพื่อสร้างคำขอการให้สิทธิ์

โค้ดจะสร้างออบเจ็กต์ Flow ซึ่งระบุแอปพลิเคชันของคุณโดยใช้ข้อมูลจากไฟล์ client_secret.json ที่คุณดาวน์โหลดหลังจากสร้างข้อมูลเข้าสู่ระบบการให้สิทธิ์ ออบเจ็กต์ดังกล่าวยังระบุขอบเขตที่แอปพลิเคชันกำลังขอสิทธิ์ในการเข้าถึงและ URL ไปยังปลายทางการตรวจสอบสิทธิ์ของแอปพลิเคชัน ซึ่งจะจัดการการตอบกลับจากเซิร์ฟเวอร์ OAuth 2.0 ของ Google สุดท้าย โค้ดจะกําหนดพารามิเตอร์ access_type และ include_granted_scopes ซึ่งไม่บังคับ

ตัวอย่างเช่น โค้ดนี้ขอการเข้าถึง Google ไดรฟ์ของผู้ใช้แบบอ่านอย่างเดียวแบบออฟไลน์

import google.oauth2.credentials
import google_auth_oauthlib.flow

# Use the client_secret.json file to identify the application requesting
# authorization. The client ID (from that file) and access scopes are required.
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
    'client_secret.json',
    scopes=['https://www.googleapis.com/auth/drive.metadata.readonly'])

# Indicate where the API server will redirect the user after the user completes
# the authorization flow. The redirect URI is required. The value must exactly
# match one of the authorized redirect URIs for the OAuth 2.0 client, which you
# configured in the API Console. If this value doesn't match an authorized URI,
# you will get a 'redirect_uri_mismatch' error.
flow.redirect_uri = 'https://www.example.com/oauth2callback'

# Generate URL for request to Google's OAuth 2.0 server.
# Use kwargs to set optional request parameters.
authorization_url, state = flow.authorization_url(
    # Enable offline access so that you can refresh an access token without
    # re-prompting the user for permission. Recommended for web server apps.
    access_type='offline',
    # Enable incremental authorization. Recommended as a best practice.
    include_granted_scopes='true')

คำขอจะระบุข้อมูลต่อไปนี้

พารามิเตอร์
client_id จำเป็น

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

ใน Python ให้เรียกใช้เมธอด from_client_secrets_file เพื่อเรียกข้อมูลรหัสไคลเอ็นต์จากไฟล์ client_secret.json (นอกจากนี้ คุณยังใช้เมธอด from_client_config ซึ่งจะส่งการกำหนดค่าไคลเอ็นต์ตามที่ปรากฏในไฟล์ข้อมูลลับของไคลเอ็นต์ได้ในตอนแรก แต่ไม่ได้เข้าถึงไฟล์)

flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
    'client_secret.json',
    scopes=['https://www.googleapis.com/auth/drive.metadata.readonly'])
redirect_uri จำเป็น

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

โปรดทราบว่าชุดรูปแบบ http หรือ https ตัวพิมพ์ และเครื่องหมายทับปิดท้าย ("/") ต้องตรงกันทั้งหมด

หากต้องการตั้งค่านี้ใน Python ให้ตั้งค่าพร็อพเพอร์ตี้ redirect_uri ของออบเจ็กต์ flow ดังนี้

flow.redirect_uri = 'https://oauth2.example.com/code'
scope จำเป็น

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

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

ใน Python ให้ใช้วิธีเดียวกับที่คุณใช้ตั้งค่า client_id เพื่อระบุรายการขอบเขต

flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
    'client_secret.json',
    scopes=['https://www.googleapis.com/auth/drive.metadata.readonly'])

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

access_type แนะนำ

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

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

ใน Python ให้ตั้งค่าพารามิเตอร์ access_type โดยระบุ access_type เป็นอาร์กิวเมนต์คีย์เวิร์ดเมื่อเรียกใช้เมธอด flow.authorization_url ดังนี้

authorization_url, state = flow.authorization_url(
    access_type='offline',
    include_granted_scopes='true')
state แนะนำ

ระบุค่าสตริงที่แอปพลิเคชันจะใช้เพื่อรักษาสถานะระหว่างคำขอการให้สิทธิ์และการตอบกลับของเซิร์ฟเวอร์การให้สิทธิ์ เซิร์ฟเวอร์จะแสดงค่าที่คุณส่งเป็นคู่ name=value ในคอมโพเนนต์การค้นหา URL (?) ของ redirect_uri หลังจากที่ผู้ใช้ยินยอมหรือปฏิเสธคำขอเข้าถึงแอปพลิเคชันของคุณ

คุณใช้พารามิเตอร์นี้ได้เพื่อวัตถุประสงค์หลายประการ เช่น การนำผู้ใช้ไปยังทรัพยากรที่ถูกต้องในแอปพลิเคชัน การส่ง Nonce และการบรรเทาการปลอมแปลงคำขอข้ามเว็บไซต์ เนื่องจากการคาดเดาของ redirect_uri ได้ การใช้ค่า state จะช่วยเพิ่มความมั่นใจได้ว่าการเชื่อมต่อขาเข้าเป็นผลมาจากคำขอการตรวจสอบสิทธิ์ หากสร้างสตริงแบบสุ่มหรือเข้ารหัสแฮชของคุกกี้หรือค่าอื่นที่บันทึกสถานะของไคลเอ็นต์ คุณสามารถตรวจสอบการตอบกลับเพื่อให้มั่นใจว่าคำขอและคำตอบนั้นสร้างขึ้นในเบราว์เซอร์เดียวกัน ซึ่งจะช่วยป้องกันการโจมตีต่างๆ เช่น การปลอมแปลงคำขอข้ามเว็บไซต์ โปรดดูเอกสาร OpenID Connect สำหรับตัวอย่างวิธีสร้างและยืนยันโทเค็น state

ใน Python ให้ตั้งค่าพารามิเตอร์ state โดยระบุ state เป็นอาร์กิวเมนต์คีย์เวิร์ดเมื่อเรียกใช้เมธอด flow.authorization_url ดังนี้

authorization_url, state = flow.authorization_url(
    access_type='offline',
    state=sample_passthrough_value,
    include_granted_scopes='true')
include_granted_scopes ไม่บังคับ

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

ใน Python ให้ตั้งค่าพารามิเตอร์ include_granted_scopes โดยระบุ include_granted_scopes เป็นอาร์กิวเมนต์คีย์เวิร์ดเมื่อเรียกใช้เมธอด flow.authorization_url ดังนี้

authorization_url, state = flow.authorization_url(
    access_type='offline',
    include_granted_scopes='true')
login_hint ไม่บังคับ

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

ตั้งค่าค่าพารามิเตอร์เป็นอีเมลหรือตัวระบุ sub ซึ่งเทียบเท่ากับรหัส Google ของผู้ใช้

ใน Python ให้ตั้งค่าพารามิเตอร์ login_hint โดยระบุ login_hint เป็นอาร์กิวเมนต์คีย์เวิร์ดเมื่อเรียกใช้เมธอด flow.authorization_url ดังนี้

authorization_url, state = flow.authorization_url(
    access_type='offline',
    login_hint='None',
    include_granted_scopes='true')
prompt ไม่บังคับ

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

ใน Python ให้ตั้งค่าพารามิเตอร์ prompt โดยระบุ prompt เป็นอาร์กิวเมนต์คีย์เวิร์ดเมื่อเรียกใช้เมธอด flow.authorization_url ดังนี้

authorization_url, state = flow.authorization_url(
      access_type='offline',
      prompt='consent',
      include_granted_scopes='true')

ค่าที่เป็นไปได้มีดังนี้

none ไม่แสดงหน้าจอการตรวจสอบสิทธิ์หรือความยินยอม ไม่ต้องระบุพร้อมกับค่าอื่นๆ
consent แจ้งให้ผู้ใช้ขอความยินยอม
select_account แจ้งให้ผู้ใช้เลือกบัญชี

Ruby

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

ตัวอย่างเช่น โค้ดนี้ขอการเข้าถึง Google ไดรฟ์ของผู้ใช้แบบอ่านอย่างเดียวแบบออฟไลน์

require 'google/apis/drive_v3'
require "googleauth"
require 'googleauth/stores/redis_token_store'

client_id = Google::Auth::ClientId.from_file('/path/to/client_secret.json')
scope = 'https://www.googleapis.com/auth/drive.metadata.readonly'
token_store = Google::Auth::Stores::RedisTokenStore.new(redis: Redis.new)
authorizer = Google::Auth::WebUserAuthorizer.new(client_id, scope, token_store, '/oauth2callback')

Your application uses the client object to perform OAuth 2.0 operations, such as generating authorization request URLs and applying access tokens to HTTP requests.

Node.js

The code snippet below creates a google.auth.OAuth2 object, which defines the parameters in the authorization request.

That object uses information from your client_secret.json file to identify your application. To ask for permissions from a user to retrieve an access token, you redirect them to a consent page. To create a consent page URL:

const {google} = require('googleapis');

/**
 * To use OAuth2 authentication, we need access to a CLIENT_ID, CLIENT_SECRET, AND REDIRECT_URI
 * from the client_secret.json file. To get these credentials for your application, visit
 * https://console.cloud.google.com/apis/credentials.
 */
const oauth2Client = new google.auth.OAuth2(
  YOUR_CLIENT_ID,
  YOUR_CLIENT_SECRET,
  YOUR_REDIRECT_URL
);

// Access scopes for read-only Drive activity.
const scopes = [
  'https://www.googleapis.com/auth/drive.metadata.readonly'
];

// Generate a url that asks permissions for the Drive activity scope
const authorizationUrl = oauth2Client.generateAuthUrl({
  // 'online' (default) or 'offline' (gets refresh_token)
  access_type: 'offline',
  /** Pass in the scopes array defined above.
    * Alternatively, if only one scope is needed, you can pass a scope URL as a string */
  scope: scopes,
  // Enable incremental authorization. Recommended as a best practice.
  include_granted_scopes: true
});

หมายเหตุสำคัญ - ระบบจะส่งคืน refresh_token ในการให้สิทธิ์ครั้งแรกเท่านั้น ดูรายละเอียดเพิ่มเติม ที่นี่

HTTP/REST

ปลายทาง OAuth 2.0 ของ Google จะอยู่ที่ https://accounts.google.com/o/oauth2/v2/auth ปลายทางนี้จะเข้าถึงได้ผ่าน HTTPS เท่านั้น การเชื่อมต่อ HTTP ธรรมดาจะถูกปฏิเสธ

เซิร์ฟเวอร์การให้สิทธิ์ของ Google รองรับพารามิเตอร์สตริงคำค้นหาต่อไปนี้สำหรับแอปพลิเคชันเว็บเซิร์ฟเวอร์

พารามิเตอร์
client_id จำเป็น

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

redirect_uri จำเป็น

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

โปรดทราบว่าชุดรูปแบบ http หรือ https ตัวพิมพ์ และเครื่องหมายทับปิดท้าย ("/") ต้องตรงกันทั้งหมด

response_type จำเป็น

กำหนดว่าปลายทางของ Google OAuth 2.0 จะแสดงรหัสการให้สิทธิ์หรือไม่

ตั้งค่าพารามิเตอร์เป็น code สำหรับแอปพลิเคชันเว็บเซิร์ฟเวอร์

scope จำเป็น

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

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

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

access_type แนะนำ

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

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

state แนะนำ

ระบุค่าสตริงที่แอปพลิเคชันจะใช้เพื่อรักษาสถานะระหว่างคำขอการให้สิทธิ์และการตอบกลับของเซิร์ฟเวอร์การให้สิทธิ์ เซิร์ฟเวอร์จะแสดงค่าที่คุณส่งเป็นคู่ name=value ในคอมโพเนนต์การค้นหา URL (?) ของ redirect_uri หลังจากที่ผู้ใช้ยินยอมหรือปฏิเสธคำขอเข้าถึงแอปพลิเคชันของคุณ

คุณใช้พารามิเตอร์นี้ได้เพื่อวัตถุประสงค์หลายประการ เช่น การนำผู้ใช้ไปยังทรัพยากรที่ถูกต้องในแอปพลิเคชัน การส่ง Nonce และการบรรเทาการปลอมแปลงคำขอข้ามเว็บไซต์ เนื่องจากการคาดเดาของ redirect_uri ได้ การใช้ค่า state จะช่วยเพิ่มความมั่นใจได้ว่าการเชื่อมต่อขาเข้าเป็นผลมาจากคำขอการตรวจสอบสิทธิ์ หากสร้างสตริงแบบสุ่มหรือเข้ารหัสแฮชของคุกกี้หรือค่าอื่นที่บันทึกสถานะของไคลเอ็นต์ คุณสามารถตรวจสอบการตอบกลับเพื่อให้มั่นใจว่าคำขอและคำตอบนั้นสร้างขึ้นในเบราว์เซอร์เดียวกัน ซึ่งจะช่วยป้องกันการโจมตีต่างๆ เช่น การปลอมแปลงคำขอข้ามเว็บไซต์ โปรดดูเอกสาร OpenID Connect สำหรับตัวอย่างวิธีสร้างและยืนยันโทเค็น state

include_granted_scopes ไม่บังคับ

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

login_hint ไม่บังคับ

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

ตั้งค่าค่าพารามิเตอร์เป็นอีเมลหรือตัวระบุ sub ซึ่งเทียบเท่ากับรหัส Google ของผู้ใช้

prompt ไม่บังคับ

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

ค่าที่เป็นไปได้มีดังนี้

none ไม่แสดงหน้าจอการตรวจสอบสิทธิ์หรือความยินยอม ไม่ต้องระบุพร้อมกับค่าอื่นๆ
consent แจ้งให้ผู้ใช้ขอความยินยอม
select_account แจ้งให้ผู้ใช้เลือกบัญชี

ขั้นตอนที่ 2: เปลี่ยนเส้นทางไปยังเซิร์ฟเวอร์ OAuth 2.0 ของ Google

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

PHP

  1. สร้าง URL เพื่อขอสิทธิ์เข้าถึงจากเซิร์ฟเวอร์ OAuth 2.0 ของ Google:
    $auth_url = $client->createAuthUrl();
  2. เปลี่ยนเส้นทางผู้ใช้ไปยัง $auth_url:
    header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL));

Python

ตัวอย่างนี้แสดงวิธีเปลี่ยนเส้นทางผู้ใช้ไปยัง URL การให้สิทธิ์โดยใช้เฟรมเวิร์กเว็บแอปพลิเคชัน Flask

return flask.redirect(authorization_url)

Ruby

  1. สร้าง URL เพื่อขอสิทธิ์เข้าถึงจากเซิร์ฟเวอร์ OAuth 2.0 ของ Google:
    auth_uri = authorizer.get_authorization_url(login_hint: user_id, request: request)
  2. เปลี่ยนเส้นทางผู้ใช้ไปที่ auth_uri

Node.js

  1. ใช้ URL ที่สร้างขึ้นauthorizationUrl จากวิธีทำขั้นตอนที่ 1 generateAuthUrl เพื่อขอสิทธิ์เข้าถึงจากเซิร์ฟเวอร์ OAuth 2.0 ของ Google
  2. เปลี่ยนเส้นทางผู้ใช้ไปที่ authorizationUrl
    res.writeHead(301, { "Location": authorizationUrl });

HTTP/REST

Sample redirect to Google's authorization server

An example URL is shown below, with line breaks and spaces for readability.

https://accounts.google.com/o/oauth2/v2/auth?
 scope=https%3A//www.googleapis.com/auth/drive.metadata.readonly&
 access_type=offline&
 include_granted_scopes=true&
 response_type=code&
 state=state_parameter_passthrough_value&
 redirect_uri=https%3A//oauth2.example.com/code&
 client_id=client_id

หลังจากที่คุณสร้าง URL คำขอแล้ว ให้เปลี่ยนเส้นทางผู้ใช้ไปที่ URL นั้น

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

ขั้นตอนที่ 3: Google แจ้งให้ผู้ใช้ขอความยินยอม

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

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

ข้อผิดพลาด

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

admin_policy_enforced

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

disallowed_useragent

ปลายทางการให้สิทธิ์จะแสดงภายใน User Agent แบบฝังที่นโยบาย OAuth 2.0 ของ Google ไม่อนุญาต

Android

นักพัฒนาซอฟต์แวร์ Android อาจเห็นข้อความแสดงข้อผิดพลาดนี้เมื่อเปิดคำขอการให้สิทธิ์ใน android.webkit.WebView นักพัฒนาซอฟต์แวร์ควรใช้ไลบรารี Android แทน เช่น Google Sign-In สำหรับ Android หรือ AppAuth สำหรับ Android ของ OpenID Foundation

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

iOS

นักพัฒนา iOS และ macOS อาจพบข้อผิดพลาดนี้เมื่อเปิดคำขอการให้สิทธิ์ใน WKWebView นักพัฒนาซอฟต์แวร์ควรใช้ไลบรารี iOS แทน เช่น Google Sign-In สำหรับ iOS หรือ AppAuth สำหรับ iOS ของ OpenID Foundation

นักพัฒนาเว็บอาจพบข้อผิดพลาดนี้เมื่อแอป iOS หรือ macOS เปิดเว็บลิงก์ทั่วไปใน User Agent แบบฝัง และผู้ใช้ไปยังปลายทางการให้สิทธิ์ OAuth 2.0 ของ Google จากเว็บไซต์ของคุณ นักพัฒนาซอฟต์แวร์ควรอนุญาตให้เปิดลิงก์ทั่วไปในเครื่องจัดการลิงก์เริ่มต้นของระบบปฏิบัติการ ซึ่งจะมีทั้งเครื่องจัดการ Universal Link หรือแอปเบราว์เซอร์เริ่มต้น ไลบรารี SFSafariViewController ก็เป็นตัวเลือกที่รองรับเช่นกัน

org_internal

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

invalid_client

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

invalid_grant

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

redirect_uri_mismatch

redirect_uri ที่ส่งในคำขอการให้สิทธิ์ไม่ตรงกับ URI การเปลี่ยนเส้นทางที่ได้รับอนุญาตสำหรับรหัสไคลเอ็นต์ OAuth ตรวจสอบ URI การเปลี่ยนเส้นทางที่ได้รับอนุญาตใน Google API Console Credentials page

พารามิเตอร์ redirect_uri อาจหมายถึงขั้นตอน OAuth นอกย่านความถี่ (OOB) ซึ่งเลิกใช้งานไปแล้วและไม่รองรับอีกต่อไป โปรดอ่านคำแนะนำในการย้ายข้อมูลเพื่ออัปเดตการผสานรวม

invalid_request

เกิดข้อผิดพลาดกับคำขอที่คุณส่ง ซึ่งอาจเกิดจากสาเหตุหลายประการดังนี้

  • คำขอมีรูปแบบที่ไม่ถูกต้อง
  • คำขอไม่มีพารามิเตอร์ที่จำเป็น
  • คำขอใช้วิธีการให้สิทธิ์ที่ Google ไม่รองรับ ยืนยันว่าการผสานรวม OAuth ใช้วิธีการผสานรวมที่แนะนำ

ขั้นตอนที่ 4: จัดการการตอบสนองของเซิร์ฟเวอร์ OAuth 2.0

เซิร์ฟเวอร์ OAuth 2.0 จะตอบสนองต่อคำขอเข้าถึงแอปพลิเคชันของคุณโดยใช้ URL ที่ระบุในคำขอ

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

การตอบกลับที่มีข้อผิดพลาด:

https://oauth2.example.com/auth?error=access_denied

การตอบกลับรหัสการให้สิทธิ์

https://oauth2.example.com/auth?code=4/P7q7W91a-oMsCeLvIaQm6bTrgtp7

ตัวอย่างการตอบกลับของเซิร์ฟเวอร์ OAuth 2.0

คุณสามารถทดสอบขั้นตอนนี้ได้โดยคลิก URL ตัวอย่างต่อไปนี้ ซึ่งส่งคำขอสิทธิ์การเข้าถึงระดับอ่านอย่างเดียวเพื่อดูข้อมูลเมตาสำหรับไฟล์ใน Google ไดรฟ์ของคุณ

https://accounts.google.com/o/oauth2/v2/auth?
 scope=https%3A//www.googleapis.com/auth/drive.metadata.readonly&
 access_type=offline&
 include_granted_scopes=true&
 response_type=code&
 state=state_parameter_passthrough_value&
 redirect_uri=https%3A//oauth2.example.com/code&
 client_id=client_id

หลังจากทำขั้นตอน OAuth 2.0 จนเสร็จสมบูรณ์แล้ว คุณควรเปลี่ยนเส้นทางไปที่ http://localhost/oauth2callback ซึ่งมีแนวโน้มที่จะแสดงข้อผิดพลาด 404 NOT FOUND เว้นแต่เครื่องในเครื่องจะแสดงไฟล์ตามที่อยู่ดังกล่าว ขั้นตอนถัดไปจะให้รายละเอียดเพิ่มเติมเกี่ยวกับข้อมูลที่แสดงใน URI เมื่อระบบเปลี่ยนเส้นทางผู้ใช้กลับไปยังแอปพลิเคชัน

ขั้นตอนที่ 5: รหัสการให้สิทธิ์ Exchange สำหรับโทเค็นการรีเฟรชและเข้าถึง

หลังจากที่เว็บเซิร์ฟเวอร์ได้รับรหัสการให้สิทธิ์แล้ว เว็บเซิร์ฟเวอร์จะแลกเปลี่ยนรหัสการให้สิทธิ์กับโทเค็นเพื่อการเข้าถึงได้

PHP

หากต้องการแลกเปลี่ยนรหัสการให้สิทธิ์กับโทเค็นเพื่อการเข้าถึง ให้ใช้เมธอด authenticate ดังนี้

$client->authenticate($_GET['code']);

คุณจะเรียกข้อมูลโทเค็นเพื่อการเข้าถึงได้ด้วยเมธอด getAccessToken ดังนี้

$access_token = $client->getAccessToken();

Python

ในหน้าเรียกกลับ ให้ใช้ไลบรารี google-auth เพื่อยืนยันการตอบสนองของเซิร์ฟเวอร์การให้สิทธิ์ จากนั้นใช้เมธอด flow.fetch_token เพื่อแลกเปลี่ยนรหัสการให้สิทธิ์ในการตอบสนองนั้นสำหรับโทเค็นเพื่อการเข้าถึง ดังนี้

state = flask.session['state']
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
    'client_secret.json',
    scopes=['https://www.googleapis.com/auth/drive.metadata.readonly'],
    state=state)
flow.redirect_uri = flask.url_for('oauth2callback', _external=True)

authorization_response = flask.request.url
flow.fetch_token(authorization_response=authorization_response)

# Store the credentials in the session.
# ACTION ITEM for developers:
#     Store user's access and refresh tokens in your data store if
#     incorporating this code into your real app.
credentials = flow.credentials
flask.session['credentials'] = {
    'token': credentials.token,
    'refresh_token': credentials.refresh_token,
    'token_uri': credentials.token_uri,
    'client_id': credentials.client_id,
    'client_secret': credentials.client_secret,
    'scopes': credentials.scopes}

Ruby

ในหน้าเรียกกลับ ให้ใช้ไลบรารี googleauth เพื่อยืนยันการตอบสนองของเซิร์ฟเวอร์การให้สิทธิ์ ให้ใช้เมธอด authorizer.handle_auth_callback_deferred เพื่อบันทึกรหัสการให้สิทธิ์และเปลี่ยนเส้นทางกลับไปยัง URL ที่ขอการให้สิทธิ์ในตอนแรก ซึ่งจะเลื่อนการแลกเปลี่ยนโค้ดด้วยการเก็บผลลัพธ์ไว้ในเซสชันของผู้ใช้ชั่วคราว

  target_url = Google::Auth::WebUserAuthorizer.handle_auth_callback_deferred(request)
  redirect target_url

Node.js

หากต้องการแลกเปลี่ยนรหัสการให้สิทธิ์กับโทเค็นเพื่อการเข้าถึง ให้ใช้เมธอด getToken ดังนี้

const url = require('url');

// Receive the callback from Google's OAuth 2.0 server.
if (req.url.startsWith('/oauth2callback')) {
  // Handle the OAuth 2.0 server response
  let q = url.parse(req.url, true).query;

  // Get access and refresh tokens (if access_type is offline)
  let { tokens } = await oauth2Client.getToken(q.code);
  oauth2Client.setCredentials(tokens);
}

HTTP/REST

หากต้องการแลกเปลี่ยนรหัสการให้สิทธิ์กับโทเค็นเพื่อการเข้าถึง ให้เรียกใช้ปลายทาง https://oauth2.googleapis.com/token และตั้งค่าพารามิเตอร์ต่อไปนี้

ช่อง
client_id รหัสไคลเอ็นต์ที่ได้รับจาก API Console Credentials page
client_secret รหัสลับไคลเอ็นต์ที่ได้จาก API Console Credentials page
code รหัสการให้สิทธิ์ที่ส่งคืนจากคำขอเริ่มต้น
grant_type ตามที่ระบุไว้ในข้อกำหนด OAuth 2.0 ค่าของช่องนี้ต้องตั้งค่าเป็น authorization_code
redirect_uri หนึ่งใน URI การเปลี่ยนเส้นทางที่แสดงสำหรับโปรเจ็กต์ของคุณใน API Console Credentials page สำหรับ client_id ที่ระบุ

ข้อมูลโค้ดต่อไปนี้แสดงตัวอย่างคำขอ

POST /token HTTP/1.1
Host: oauth2.googleapis.com
Content-Type: application/x-www-form-urlencoded

code=4/P7q7W91a-oMsCeLvIaQm6bTrgtp7&
client_id=your_client_id&
client_secret=your_client_secret&
redirect_uri=https%3A//oauth2.example.com/code&
grant_type=authorization_code

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

การตอบกลับจะมีช่องต่อไปนี้

ช่อง
access_token โทเค็นที่แอปพลิเคชันของคุณส่งเพื่อให้สิทธิ์คำขอ Google API
expires_in อายุการใช้งานที่เหลือของโทเค็นเพื่อการเข้าถึงเป็นวินาที
refresh_token โทเค็นที่ใช้เพื่อรับโทเค็นเพื่อการเข้าถึงใหม่ได้ โทเค็นการรีเฟรชจะใช้ได้จนกว่าผู้ใช้เพิกถอนสิทธิ์เข้าถึง เช่นเดียวกัน ช่องนี้จะปรากฏในการตอบกลับนี้ก็ต่อเมื่อคุณตั้งค่าพารามิเตอร์ access_type เป็น offline ในคำขอเริ่มต้นไปยังเซิร์ฟเวอร์การให้สิทธิ์ของ Google
scope ขอบเขตของการเข้าถึงที่ได้รับจาก access_token ซึ่งแสดงเป็นรายการสตริงที่คั่นด้วยช่องว่างและคำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่
token_type ประเภทของโทเค็นที่ส่งคืน ปัจจุบันค่าของช่องนี้จะตั้งค่าเป็น Bearer เสมอ

ข้อมูลโค้ดต่อไปนี้แสดงตัวอย่างการตอบกลับ

{
  "access_token": "1/fFAGRNJru1FTz70BzhT3Zg",
  "expires_in": 3920,
  "token_type": "Bearer",
  "scope": "https://www.googleapis.com/auth/drive.metadata.readonly",
  "refresh_token": "1//xEoDL4iW3cxlI7yDbSRFYNG01kVKM2C-259HOF2aQbI"
}

ข้อผิดพลาด

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

invalid_grant

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

การเรียกใช้ Google API

PHP

ใช้โทเค็นเพื่อการเข้าถึงเพื่อเรียก Google API โดยทําตามขั้นตอนต่อไปนี้

  1. หากต้องการใช้โทเค็นเพื่อการเข้าถึงกับออบเจ็กต์ Google\Client ใหม่ เช่น หากคุณจัดเก็บโทเค็นเพื่อการเข้าถึงไว้ในเซสชันผู้ใช้ ให้ใช้เมธอด setAccessToken ดังนี้
    $client->setAccessToken($access_token);
  2. สร้างออบเจ็กต์บริการสำหรับ API ที่คุณต้องการเรียกใช้ คุณสร้างออบเจ็กต์บริการได้โดยการระบุออบเจ็กต์ Google\Client ที่ได้รับอนุญาตให้แก่เครื่องมือสร้างสำหรับ API ที่ต้องการเรียกใช้ เช่น หากต้องการเรียกใช้ Drive API ให้ทำดังนี้
    $drive = new Google\Service\Drive($client);
  3. ส่งคำขอไปยังบริการ API โดยใช้อินเทอร์เฟซที่ออบเจ็กต์บริการมีให้ เช่น หากต้องการแสดงไฟล์ใน Google ไดรฟ์ของผู้ใช้ที่ตรวจสอบสิทธิ์แล้ว ให้ทำดังนี้
    $files = $drive->files->listFiles(array())->getItems();

Python

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

  1. สร้างออบเจ็กต์บริการสำหรับ API ที่คุณต้องการเรียกใช้ คุณสร้างออบเจ็กต์บริการได้โดยเรียกใช้เมธอด build ของไลบรารี googleapiclient.discovery ด้วยชื่อและเวอร์ชันของ API รวมถึงข้อมูลเข้าสู่ระบบของผู้ใช้ เช่น หากต้องการเรียกใช้ Drive API เวอร์ชัน 3 ให้ทำดังนี้
    from googleapiclient.discovery import build
    
    drive = build('drive', 'v2', credentials=credentials)
  2. ส่งคำขอไปยังบริการ API โดยใช้อินเทอร์เฟซที่ออบเจ็กต์บริการมีให้ เช่น หากต้องการแสดงไฟล์ใน Google ไดรฟ์ของผู้ใช้ที่ตรวจสอบสิทธิ์แล้ว ให้ทำดังนี้
    files = drive.files().list().execute()

Ruby

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

  1. สร้างออบเจ็กต์บริการสำหรับ API ที่คุณต้องการเรียกใช้ เช่น หากต้องการเรียกใช้ Drive API เวอร์ชัน 3 ให้ทำดังนี้
    drive = Google::Apis::DriveV3::DriveService.new
  2. ตั้งค่าข้อมูลเข้าสู่ระบบในบริการ:
    drive.authorization = credentials
  3. ส่งคำขอไปยังบริการ API โดยใช้อินเทอร์เฟซที่ออบเจ็กต์บริการมีให้ เช่น หากต้องการแสดงรายการไฟล์ใน Google ไดรฟ์ของผู้ใช้ที่ตรวจสอบสิทธิ์แล้ว ให้ทำดังนี้
    files = drive.list_files

อีกวิธีหนึ่งคือ ระบุการให้สิทธิ์แบบรายวิธีได้โดยการใส่พารามิเตอร์ options ลงในเมธอด ดังนี้

files = drive.list_files(options: { authorization: credentials })

Node.js

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

const { google } = require('googleapis');

// Example of using Google Drive API to list filenames in user's Drive.
const drive = google.drive('v3');
drive.files.list({
  auth: oauth2Client,
  pageSize: 10,
  fields: 'nextPageToken, files(id, name)',
}, (err1, res1) => {
  if (err1) return console.log('The API returned an error: ' + err1);
  const files = res1.data.files;
  if (files.length) {
    console.log('Files:');
    files.map((file) => {
      console.log(`${file.name} (${file.id})`);
    });
  } else {
    console.log('No files found.');
  }
});

HTTP/REST

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

คุณลองใช้ Google 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

ตัวอย่างที่สมบูรณ์

ตัวอย่างต่อไปนี้จะพิมพ์รายการไฟล์ในรูปแบบ JSON ใน Google ไดรฟ์ของผู้ใช้ หลังจากที่ผู้ใช้ตรวจสอบสิทธิ์และให้ความยินยอมให้แอปพลิเคชันเข้าถึงข้อมูลเมตาในไดรฟ์ของผู้ใช้แล้ว

PHP

ในการเรียกใช้ตัวอย่างนี้ ให้ทำดังนี้

  1. ใน API Consoleให้เพิ่ม URL ของเครื่องคอมพิวเตอร์ลงในรายการ URL การเปลี่ยนเส้นทาง เช่น เพิ่ม http://localhost:8080
  2. สร้างไดเรกทอรีใหม่และทำการเปลี่ยนแปลง เช่น
    mkdir ~/php-oauth2-example
    cd ~/php-oauth2-example
  3. ติดตั้งไลบรารีของไคลเอ็นต์ Google API สำหรับ PHP โดยใช้ Composer ดังนี้
    composer require google/apiclient:^2.10
  4. สร้างไฟล์ index.php และ oauth2callback.php ที่มีเนื้อหาด้านล่าง
  5. เรียกใช้ตัวอย่างนี้ด้วยเว็บเซิร์ฟเวอร์ที่กำหนดค่าให้ให้บริการ PHP หากใช้ PHP 5.6 หรือใหม่กว่า คุณสามารถใช้เว็บเซิร์ฟเวอร์ทดสอบในตัวของ PHP ได้ดังนี้
    php -S localhost:8080 ~/php-oauth2-example

index.php

<?php
require_once __DIR__.'/vendor/autoload.php';

session_start();

$client = new Google\Client();
$client->setAuthConfig('client_secrets.json');
$client->addScope(Google\Service\Drive::DRIVE_METADATA_READONLY);

if (isset($_SESSION['access_token']) && $_SESSION['access_token']) {
  $client->setAccessToken($_SESSION['access_token']);
  $drive = new Google\Service\Drive($client);
  $files = $drive->files->listFiles(array())->getItems();
  echo json_encode($files);
} else {
  $redirect_uri = 'http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php';
  header('Location: ' . filter_var($redirect_uri, FILTER_SANITIZE_URL));
}

oauth2callback.php

<?php
require_once __DIR__.'/vendor/autoload.php';

session_start();

$client = new Google\Client();
$client->setAuthConfigFile('client_secrets.json');
$client->setRedirectUri('http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php');
$client->addScope(Google\Service\Drive::DRIVE_METADATA_READONLY);

if (! isset($_GET['code'])) {
  $auth_url = $client->createAuthUrl();
  header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL));
} else {
  $client->authenticate($_GET['code']);
  $_SESSION['access_token'] = $client->getAccessToken();
  $redirect_uri = 'http://' . $_SERVER['HTTP_HOST'] . '/';
  header('Location: ' . filter_var($redirect_uri, FILTER_SANITIZE_URL));
}

Python

ตัวอย่างนี้ใช้เฟรมเวิร์ก Flask โดยเรียกใช้เว็บแอปพลิเคชันที่ http://localhost:8080 ซึ่งจะช่วยให้คุณทดสอบขั้นตอน OAuth 2.0 ได้ หากไปที่ URL ดังกล่าว คุณควรจะเห็นลิงก์ 4 ลิงก์ ได้แก่

  • ทดสอบคำขอ API: ลิงก์นี้ชี้ไปยังหน้าเว็บที่พยายามดำเนินการคำขอ API ตัวอย่าง จากนั้นจะเริ่มขั้นตอนการให้สิทธิ์หากจำเป็น หากสําเร็จ หน้าเว็บจะแสดงการตอบสนองของ API
  • ทดสอบขั้นตอนการตรวจสอบสิทธิ์โดยตรง: ลิงก์นี้จะชี้ไปยังหน้าเว็บที่พยายามส่งผู้ใช้ผ่านขั้นตอนการให้สิทธิ์ แอปขอสิทธิ์เพื่อส่งคำขอ API ที่ได้รับอนุญาตในนามของผู้ใช้
  • เพิกถอนข้อมูลเข้าสู่ระบบปัจจุบัน: ลิงก์นี้ชี้ไปที่หน้าที่ เพิกถอนสิทธิ์ที่ผู้ใช้ได้ให้ไว้กับแอปพลิเคชันแล้ว
  • ล้างข้อมูลเข้าสู่ระบบเซสชัน Flask: ลิงก์นี้จะล้างข้อมูลเข้าสู่ระบบการให้สิทธิ์ที่จัดเก็บไว้ในเซสชัน Flask วิธีนี้ช่วยให้คุณเห็นว่าจะเกิดอะไรขึ้นหากผู้ใช้ที่ให้สิทธิ์แอปไปแล้วพยายามดำเนินการตามคำขอ API ในเซสชันใหม่ นอกจากนี้ยังช่วยให้คุณเห็นการตอบสนองของ API ที่แอปจะได้รับหากผู้ใช้เพิกถอนสิทธิ์ที่ให้แก่แอปของคุณ และแอปยังคงพยายามอนุมัติคําขอที่มีโทเค็นเพื่อการเข้าถึงที่ถูกเพิกถอน
# -*- coding: utf-8 -*-

import os
import flask
import requests

import google.oauth2.credentials
import google_auth_oauthlib.flow
import googleapiclient.discovery

# This variable specifies the name of a file that contains the OAuth 2.0
# information for this application, including its client_id and client_secret.
CLIENT_SECRETS_FILE = "client_secret.json"

# This OAuth 2.0 access scope allows for full read/write access to the
# authenticated user's account and requires requests to use an SSL connection.
SCOPES = ['https://www.googleapis.com/auth/drive.metadata.readonly']
API_SERVICE_NAME = 'drive'
API_VERSION = 'v2'

app = flask.Flask(__name__)
# Note: A secret key is included in the sample so that it works.
# If you use this code in your application, replace this with a truly secret
# key. See https://flask.palletsprojects.com/quickstart/#sessions.
app.secret_key = 'REPLACE ME - this value is here as a placeholder.'


@app.route('/')
def index():
  return print_index_table()


@app.route('/test')
def test_api_request():
  if 'credentials' not in flask.session:
    return flask.redirect('authorize')

  # Load credentials from the session.
  credentials = google.oauth2.credentials.Credentials(
      **flask.session['credentials'])

  drive = googleapiclient.discovery.build(
      API_SERVICE_NAME, API_VERSION, credentials=credentials)

  files = drive.files().list().execute()

  # Save credentials back to session in case access token was refreshed.
  # ACTION ITEM: In a production app, you likely want to save these
  #              credentials in a persistent database instead.
  flask.session['credentials'] = credentials_to_dict(credentials)

  return flask.jsonify(**files)


@app.route('/authorize')
def authorize():
  # Create flow instance to manage the OAuth 2.0 Authorization Grant Flow steps.
  flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
      CLIENT_SECRETS_FILE, scopes=SCOPES)

  # The URI created here must exactly match one of the authorized redirect URIs
  # for the OAuth 2.0 client, which you configured in the API Console. If this
  # value doesn't match an authorized URI, you will get a 'redirect_uri_mismatch'
  # error.
  flow.redirect_uri = flask.url_for('oauth2callback', _external=True)

  authorization_url, state = flow.authorization_url(
      # Enable offline access so that you can refresh an access token without
      # re-prompting the user for permission. Recommended for web server apps.
      access_type='offline',
      # Enable incremental authorization. Recommended as a best practice.
      include_granted_scopes='true')

  # Store the state so the callback can verify the auth server response.
  flask.session['state'] = state

  return flask.redirect(authorization_url)


@app.route('/oauth2callback')
def oauth2callback():
  # Specify the state when creating the flow in the callback so that it can
  # verified in the authorization server response.
  state = flask.session['state']

  flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
      CLIENT_SECRETS_FILE, scopes=SCOPES, state=state)
  flow.redirect_uri = flask.url_for('oauth2callback', _external=True)

  # Use the authorization server's response to fetch the OAuth 2.0 tokens.
  authorization_response = flask.request.url
  flow.fetch_token(authorization_response=authorization_response)

  # Store credentials in the session.
  # ACTION ITEM: In a production app, you likely want to save these
  #              credentials in a persistent database instead.
  credentials = flow.credentials
  flask.session['credentials'] = credentials_to_dict(credentials)

  return flask.redirect(flask.url_for('test_api_request'))


@app.route('/revoke')
def revoke():
  if 'credentials' not in flask.session:
    return ('You need to <a href="/authorize">authorize</a> before ' +
            'testing the code to revoke credentials.')

  credentials = google.oauth2.credentials.Credentials(
    **flask.session['credentials'])

  revoke = requests.post('https://oauth2.googleapis.com/revoke',
      params={'token': credentials.token},
      headers = {'content-type': 'application/x-www-form-urlencoded'})

  status_code = getattr(revoke, 'status_code')
  if status_code == 200:
    return('Credentials successfully revoked.' + print_index_table())
  else:
    return('An error occurred.' + print_index_table())


@app.route('/clear')
def clear_credentials():
  if 'credentials' in flask.session:
    del flask.session['credentials']
  return ('Credentials have been cleared.<br><br>' +
          print_index_table())


def credentials_to_dict(credentials):
  return {'token': credentials.token,
          'refresh_token': credentials.refresh_token,
          'token_uri': credentials.token_uri,
          'client_id': credentials.client_id,
          'client_secret': credentials.client_secret,
          'scopes': credentials.scopes}

def print_index_table():
  return ('<table>' +
          '<tr><td><a href="/test">Test an API request</a></td>' +
          '<td>Submit an API request and see a formatted JSON response. ' +
          '    Go through the authorization flow if there are no stored ' +
          '    credentials for the user.</td></tr>' +
          '<tr><td><a href="/authorize">Test the auth flow directly</a></td>' +
          '<td>Go directly to the authorization flow. If there are stored ' +
          '    credentials, you still might not be prompted to reauthorize ' +
          '    the application.</td></tr>' +
          '<tr><td><a href="/revoke">Revoke current credentials</a></td>' +
          '<td>Revoke the access token associated with the current user ' +
          '    session. After revoking credentials, if you go to the test ' +
          '    page, you should see an <code>invalid_grant</code> error.' +
          '</td></tr>' +
          '<tr><td><a href="/clear">Clear Flask session credentials</a></td>' +
          '<td>Clear the access token currently stored in the user session. ' +
          '    After clearing the token, if you <a href="/test">test the ' +
          '    API request</a> again, you should go back to the auth flow.' +
          '</td></tr></table>')


if __name__ == '__main__':
  # When running locally, disable OAuthlib's HTTPs verification.
  # ACTION ITEM for developers:
  #     When running in production *do not* leave this option enabled.
  os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1'

  # Specify a hostname and port that are set as a valid redirect URI
  # for your API project in the Google API Console.
  app.run('localhost', 8080, debug=True)

Ruby

ตัวอย่างนี้ใช้เฟรมเวิร์ก Sinatra

require 'google/apis/drive_v3'
require 'sinatra'
require 'googleauth'
require 'googleauth/stores/redis_token_store'

configure do
  enable :sessions

  set :client_id, Google::Auth::ClientId.from_file('/path/to/client_secret.json')
  set :scope, Google::Apis::DriveV3::AUTH_DRIVE_METADATA_READONLY
  set :token_store, Google::Auth::Stores::RedisTokenStore.new(redis: Redis.new)
  set :authorizer, Google::Auth::WebUserAuthorizer.new(settings.client_id, settings.scope, settings.token_store, '/oauth2callback')
end

get '/' do
  user_id = settings.client_id.id
  credentials = settings.authorizer.get_credentials(user_id, request)
  if credentials.nil?
    redirect settings.authorizer.get_authorization_url(login_hint: user_id, request: request)
  end
  drive = Google::Apis::DriveV3::DriveService.new
  files = drive.list_files(options: { authorization: credentials })
  "<pre>#{JSON.pretty_generate(files.to_h)}</pre>"
end

get '/oauth2callback' do
  target_url = Google::Auth::WebUserAuthorizer.handle_auth_callback_deferred(request)
  redirect target_url
end

Node.js

ในการเรียกใช้ตัวอย่างนี้ ให้ทำดังนี้

  1. ใน API Consoleให้เพิ่ม URL ของเครื่องคอมพิวเตอร์ลงในรายการ URL การเปลี่ยนเส้นทาง เช่น เพิ่ม http://localhost
  2. ตรวจสอบว่าคุณติดตั้ง LTS สำหรับการบำรุงรักษา, LTS ที่ใช้งานอยู่ หรือ Node.js รุ่นปัจจุบันติดตั้งอยู่
  3. สร้างไดเรกทอรีใหม่และทำการเปลี่ยนแปลง เช่น
    mkdir ~/nodejs-oauth2-example
    cd ~/nodejs-oauth2-example
  4. Install the Google API Client Library for Node.js using npm:
    npm install googleapis
  5. สร้างไฟล์ main.js ที่มีเนื้อหาด้านล่าง
  6. เรียกใช้ตัวอย่าง:
    node .\main.js

Main.js

const http = require('http');
const https = require('https');
const url = require('url');
const { google } = require('googleapis');

/**
 * To use OAuth2 authentication, we need access to a CLIENT_ID, CLIENT_SECRET, AND REDIRECT_URI.
 * To get these credentials for your application, visit
 * https://console.cloud.google.com/apis/credentials.
 */
const oauth2Client = new google.auth.OAuth2(
  YOUR_CLIENT_ID,
  YOUR_CLIENT_SECRET,
  YOUR_REDIRECT_URL
);

// Access scopes for read-only Drive activity.
const scopes = [
  'https://www.googleapis.com/auth/drive.metadata.readonly'
];

// Generate a url that asks permissions for the Drive activity scope
const authorizationUrl = oauth2Client.generateAuthUrl({
  // 'online' (default) or 'offline' (gets refresh_token)
  access_type: 'offline',
  /** Pass in the scopes array defined above.
    * Alternatively, if only one scope is needed, you can pass a scope URL as a string */
  scope: scopes,
  // Enable incremental authorization. Recommended as a best practice.
  include_granted_scopes: true
});

/* Global variable that stores user credential in this code example.
 * ACTION ITEM for developers:
 *   Store user's refresh token in your data store if
 *   incorporating this code into your real app.
 *   For more information on handling refresh tokens,
 *   see https://github.com/googleapis/google-api-nodejs-client#handling-refresh-tokens
 */
let userCredential = null;

async function main() {
  const server = http.createServer(async function (req, res) {
    // Example on redirecting user to Google's OAuth 2.0 server.
    if (req.url == '/') {
      res.writeHead(301, { "Location": authorizationUrl });
    }

    // Receive the callback from Google's OAuth 2.0 server.
    if (req.url.startsWith('/oauth2callback')) {
      // Handle the OAuth 2.0 server response
      let q = url.parse(req.url, true).query;

      if (q.error) { // An error response e.g. error=access_denied
        console.log('Error:' + q.error);
      } else { // Get access and refresh tokens (if access_type is offline)
        let { tokens } = await oauth2Client.getToken(q.code);
        oauth2Client.setCredentials(tokens);

        /** Save credential to the global variable in case access token was refreshed.
          * ACTION ITEM: In a production app, you likely want to save the refresh token
          *              in a secure persistent database instead. */
        userCredential = tokens;

        // Example of using Google Drive API to list filenames in user's Drive.
        const drive = google.drive('v3');
        drive.files.list({
          auth: oauth2Client,
          pageSize: 10,
          fields: 'nextPageToken, files(id, name)',
        }, (err1, res1) => {
          if (err1) return console.log('The API returned an error: ' + err1);
          const files = res1.data.files;
          if (files.length) {
            console.log('Files:');
            files.map((file) => {
              console.log(`${file.name} (${file.id})`);
            });
          } else {
            console.log('No files found.');
          }
        });
      }
    }

    // Example on revoking a token
    if (req.url == '/revoke') {
      // Build the string for the POST request
      let postData = "token=" + userCredential.access_token;

      // Options for POST request to Google's OAuth 2.0 server to revoke a token
      let postOptions = {
        host: 'oauth2.googleapis.com',
        port: '443',
        path: '/revoke',
        method: 'POST',
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded',
          'Content-Length': Buffer.byteLength(postData)
        }
      };

      // Set up the request
      const postReq = https.request(postOptions, function (res) {
        res.setEncoding('utf8');
        res.on('data', d => {
          console.log('Response: ' + d);
        });
      });

      postReq.on('error', error => {
        console.log(error)
      });

      // Post the request with data
      postReq.write(postData);
      postReq.end();
    }
    res.end();
  }).listen(80);
}
main().catch(console.error);

HTTP/REST

ตัวอย่าง Python นี้ใช้เฟรมเวิร์ก Flask และไลบรารีคำขอเพื่อสาธิตขั้นตอนเว็บ OAuth 2.0 เราขอแนะนำให้ใช้ไลบรารีของไคลเอ็นต์ Google API สำหรับ Python สำหรับขั้นตอนนี้ (ตัวอย่างในแท็บ Python ใช้ไลบรารีของไคลเอ็นต์)

import json

import flask
import requests


app = flask.Flask(__name__)

CLIENT_ID = '123456789.apps.googleusercontent.com'
CLIENT_SECRET = 'abc123'  # Read from a file or environmental variable in a real app
SCOPE = 'https://www.googleapis.com/auth/drive.metadata.readonly'
REDIRECT_URI = 'http://example.com/oauth2callback'


@app.route('/')
def index():
  if 'credentials' not in flask.session:
    return flask.redirect(flask.url_for('oauth2callback'))
  credentials = json.loads(flask.session['credentials'])
  if credentials['expires_in'] <= 0:
    return flask.redirect(flask.url_for('oauth2callback'))
  else:
    headers = {'Authorization': 'Bearer {}'.format(credentials['access_token'])}
    req_uri = 'https://www.googleapis.com/drive/v2/files'
    r = requests.get(req_uri, headers=headers)
    return r.text


@app.route('/oauth2callback')
def oauth2callback():
  if 'code' not in flask.request.args:
    auth_uri = ('https://accounts.google.com/o/oauth2/v2/auth?response_type=code'
                '&client_id={}&redirect_uri={}&scope={}').format(CLIENT_ID, REDIRECT_URI, SCOPE)
    return flask.redirect(auth_uri)
  else:
    auth_code = flask.request.args.get('code')
    data = {'code': auth_code,
            'client_id': CLIENT_ID,
            'client_secret': CLIENT_SECRET,
            'redirect_uri': REDIRECT_URI,
            'grant_type': 'authorization_code'}
    r = requests.post('https://oauth2.googleapis.com/token', data=data)
    flask.session['credentials'] = r.text
    return flask.redirect(flask.url_for('index'))


if __name__ == '__main__':
  import uuid
  app.secret_key = str(uuid.uuid4())
  app.debug = False
  app.run()

เปลี่ยนเส้นทางกฎการตรวจสอบ URI

Google ใช้กฎการตรวจสอบต่อไปนี้ในการเปลี่ยนเส้นทาง URI เพื่อช่วยนักพัฒนาแอปรักษาความปลอดภัยให้กับแอปพลิเคชัน URI การเปลี่ยนเส้นทางต้องเป็นไปตามกฎเหล่านี้ โปรดดูส่วน RFC 3986 ที่ 3 สำหรับคำจำกัดความของโดเมน โฮสต์ เส้นทาง การค้นหา รูปแบบ และข้อมูลผู้ใช้ที่ระบุไว้ด้านล่าง

กฎการตรวจสอบความถูกต้อง
รูปแบบ

URI การเปลี่ยนเส้นทางต้องใช้ชุดรูปแบบ HTTPS ไม่ใช่ HTTP ธรรมดา URI ของ Localhost (รวมถึง URI ที่อยู่ IP ของ localhost) จะได้รับการยกเว้นจากกฎนี้

โฮสต์

โฮสต์จะเป็นที่อยู่ IP ดิบไม่ได้ ที่อยู่ IP ของ Localhost จะได้รับการยกเว้นจากกฎนี้

โดเมน
  • TLD ของโฮสต์ (โดเมนระดับบนสุด) ต้องเป็นรายการคำต่อท้ายสาธารณะ
  • โดเมนที่ฝากบริการจะเป็น “googleusercontent.com” ไม่ได้
  • URI การเปลี่ยนเส้นทางต้องไม่มีโดเมนเครื่องมือย่อ URL (เช่น goo.gl) เว้นแต่แอปเป็นเจ้าของโดเมน นอกจากนี้ หากแอปที่เป็นเจ้าของโดเมนเครื่องมือย่อเลือกที่จะเปลี่ยนเส้นทางไปยังโดเมนนั้น URI การเปลี่ยนเส้นทางนั้นต้องมี “/google-callback/” ในเส้นทางหรือลงท้ายด้วย “/google-callback”
  • ข้อมูลผู้ใช้

    URI การเปลี่ยนเส้นทางไม่สามารถมีคอมโพเนนต์ย่อยของ userinfo ได้

    เส้นทาง

    URI การเปลี่ยนเส้นทางไม่สามารถมี Path Traversal (หรือที่เรียกว่าการย้อนกลับไดเรกทอรี) ซึ่งแสดงด้วย “/..” หรือ “\..” หรือการเข้ารหัส URL ของ URL ไม่ได้

    การค้นหา

    URI การเปลี่ยนเส้นทางต้องไม่มีการเปลี่ยนเส้นทางแบบเปิด

    ส่วนย่อย

    URI การเปลี่ยนเส้นทางไม่สามารถมีคอมโพเนนต์แฟรกเมนต์

    อักขระ URI การเปลี่ยนเส้นทางต้องไม่มีอักขระบางตัว ได้แก่
    • อักขระไวลด์การ์ด ('*')
    • อักขระ ASCII ที่พิมพ์ไม่ได้
    • การเข้ารหัสเปอร์เซ็นต์ไม่ถูกต้อง (การเข้ารหัสเปอร์เซ็นต์ที่ไม่เป็นไปตามรูปแบบการเข้ารหัส URL ของเครื่องหมายเปอร์เซ็นต์ตามด้วยเลขฐานสิบหก 2 หลัก)
    • อักขระ Null (อักขระ NULL ที่เข้ารหัส เช่น %00 %C0%80)

    การให้สิทธิ์ส่วนเพิ่ม

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

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

    ในกรณีนี้ เมื่อลงชื่อเข้าใช้ แอปอาจขอขอบเขต openid และ profile เพื่อลงชื่อเข้าใช้ขั้นพื้นฐาน จากนั้นขอขอบเขต https://www.googleapis.com/auth/drive.file ในภายหลัง ณ เวลาที่ขอครั้งแรกเพื่อบันทึกมิกซ์

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

    กฎต่อไปนี้จะมีผลกับโทเค็นเพื่อการเข้าถึงที่ได้รับจากการให้สิทธิ์ที่เพิ่มขึ้น

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

    ตัวอย่างโค้ดเฉพาะภาษาในขั้นตอนที่ 1: ตั้งค่าพารามิเตอร์การให้สิทธิ์ และตัวอย่าง URL การเปลี่ยนเส้นทาง HTTP/REST ในขั้นตอนที่ 2: เปลี่ยนเส้นทางไปยังเซิร์ฟเวอร์ OAuth 2.0 ของ Google ทั้งหมดใช้การให้สิทธิ์ที่เพิ่มขึ้น ตัวอย่างโค้ดด้านล่างยังแสดงโค้ดที่คุณต้องเพิ่มเพื่อใช้การให้สิทธิ์ที่เพิ่มขึ้นด้วย

    PHP

    $client->setIncludeGrantedScopes(true);

    Python

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

    authorization_url, state = flow.authorization_url(
        # Enable offline access so that you can refresh an access token without
        # re-prompting the user for permission. Recommended for web server apps.
        access_type='offline',
        # Enable incremental authorization. Recommended as a best practice.
        include_granted_scopes='true')

    Ruby

    auth_client.update!(
      :additional_parameters => {"include_granted_scopes" => "true"}
    )

    Node.js

    const authorizationUrl = oauth2Client.generateAuthUrl({
      // 'online' (default) or 'offline' (gets refresh_token)
      access_type: 'offline',
      /** Pass in the scopes array defined above.
        * Alternatively, if only one scope is needed, you can pass a scope URL as a string */
      scope: scopes,
      // Enable incremental authorization. Recommended as a best practice.
      include_granted_scopes: true
    });
    

    HTTP/REST

    GET https://accounts.google.com/o/oauth2/v2/auth?
      client_id=your_client_id&
      response_type=code&
      state=state_parameter_passthrough_value&
      scope=https%3A//www.googleapis.com/auth/drive.file&
      redirect_uri=https%3A//oauth2.example.com/code&
      prompt=consent&
      include_granted_scopes=true

    การรีเฟรชโทเค็นเพื่อการเข้าถึง (การเข้าถึงแบบออฟไลน์)

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

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

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

    เว็บแอปพลิเคชันฝั่งเซิร์ฟเวอร์ แอปพลิเคชันที่ติดตั้ง และอุปกรณ์ทั้งหมดจะได้รับโทเค็นการรีเฟรชระหว่างขั้นตอนการให้สิทธิ์ โดยทั่วไปโทเค็นการรีเฟรชจะไม่ใช้ในเว็บแอปพลิเคชันฝั่งไคลเอ็นต์ (JavaScript)

    PHP

    หากแอปพลิเคชันต้องการเข้าถึง Google API แบบออฟไลน์ ให้ตั้งค่าประเภทการเข้าถึงของไคลเอ็นต์ API เป็น offline:

    $client->setAccessType("offline");

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

    Python

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

    authorization_url, state = flow.authorization_url(
        # Enable offline access so that you can refresh an access token without
        # re-prompting the user for permission. Recommended for web server apps.
        access_type='offline',
        # Enable incremental authorization. Recommended as a best practice.
        include_granted_scopes='true')

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

    Ruby

    หากแอปพลิเคชันต้องการเข้าถึง Google API แบบออฟไลน์ ให้ตั้งค่าประเภทการเข้าถึงของไคลเอ็นต์ API เป็น offline:

    auth_client.update!(
      :additional_parameters => {"access_type" => "offline"}
    )

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

    Node.js

    หากแอปพลิเคชันต้องการเข้าถึง Google API แบบออฟไลน์ ให้ตั้งค่าประเภทการเข้าถึงของไคลเอ็นต์ API เป็น offline:

    const authorizationUrl = oauth2Client.generateAuthUrl({
      // 'online' (default) or 'offline' (gets refresh_token)
      access_type: 'offline',
      /** Pass in the scopes array defined above.
        * Alternatively, if only one scope is needed, you can pass a scope URL as a string */
      scope: scopes,
      // Enable incremental authorization. Recommended as a best practice.
      include_granted_scopes: true
    });
    

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

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

    oauth2Client.on('tokens', (tokens) => {
      if (tokens.refresh_token) {
        // store the refresh_token in your secure persistent database
        console.log(tokens.refresh_token);
      }
      console.log(tokens.access_token);
    });

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

    หากต้องการตั้งค่า refresh_token ในภายหลัง ให้ใช้เมธอด setCredentials ดังนี้

    oauth2Client.setCredentials({
      refresh_token: `STORED_REFRESH_TOKEN`
    });
    

    เมื่อไคลเอ็นต์มีโทเค็นการรีเฟรช ระบบจะรับและรีเฟรชโทเค็นเพื่อการเข้าถึงโดยอัตโนมัติในการเรียก API ครั้งถัดไป

    HTTP/REST

    หากต้องการรีเฟรชโทเค็นเพื่อการเข้าถึง แอปพลิเคชันจะส่งคำขอ HTTPS POST ไปยังเซิร์ฟเวอร์การให้สิทธิ์ของ Google (https://oauth2.googleapis.com/token) ที่มีพารามิเตอร์ต่อไปนี้

    ช่อง
    client_id รหัสไคลเอ็นต์ที่ได้รับจาก API Console
    client_secret รหัสลับไคลเอ็นต์ที่ได้รับจาก API Console
    grant_type ตามที่กำหนดไว้ในข้อกำหนด OAuth 2.0 ค่าของช่องนี้ต้องตั้งค่าเป็น refresh_token
    refresh_token โทเค็นการรีเฟรชที่ส่งคืนจากการแลกเปลี่ยนรหัสการให้สิทธิ์

    ข้อมูลโค้ดต่อไปนี้แสดงตัวอย่างคำขอ

    POST /token HTTP/1.1
    Host: oauth2.googleapis.com
    Content-Type: application/x-www-form-urlencoded
    
    client_id=your_client_id&
    client_secret=your_client_secret&
    refresh_token=refresh_token&
    grant_type=refresh_token

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

    {
      "access_token": "1/fFAGRNJru1FTz70BzhT3Zg",
      "expires_in": 3920,
      "scope": "https://www.googleapis.com/auth/drive.metadata.readonly",
      "token_type": "Bearer"
    }

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

    การเพิกถอนโทเค็น

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

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

    PHP

    หากต้องการเพิกถอนโทเค็นแบบเป็นโปรแกรม ให้เรียกใช้ revokeToken()

    $client->revokeToken();

    Python

    หากต้องการเพิกถอนโทเค็นแบบเป็นโปรแกรม ให้ส่งคำขอไปยัง https://oauth2.googleapis.com/revoke ซึ่งมีโทเค็นเป็นพารามิเตอร์และตั้งค่าส่วนหัว Content-Type ดังนี้

    requests.post('https://oauth2.googleapis.com/revoke',
        params={'token': credentials.token},
        headers = {'content-type': 'application/x-www-form-urlencoded'})

    Ruby

    หากต้องการเพิกถอนโทเค็นแบบเป็นโปรแกรม ให้ส่งคำขอ HTTP ไปยังปลายทาง oauth2.revoke ดังนี้

    uri = URI('https://oauth2.googleapis.com/revoke')
    response = Net::HTTP.post_form(uri, 'token' => auth_client.access_token)
    

    โดยโทเค็นดังกล่าวอาจเป็นโทเค็นเพื่อการเข้าถึงหรือโทเค็นการรีเฟรชก็ได้ หากโทเค็นเป็นโทเค็นเพื่อการเข้าถึงและมีโทเค็นการรีเฟรชที่เกี่ยวข้อง ระบบจะเพิกถอนโทเค็นการรีเฟรชด้วย

    หากประมวลผลการเพิกถอนสำเร็จแล้ว รหัสสถานะของการตอบกลับจะเป็น 200 สำหรับเงื่อนไขข้อผิดพลาด ระบบจะส่งรหัสสถานะ 400 พร้อมกับรหัสข้อผิดพลาด

    Node.js

    หากต้องการเพิกถอนโทเค็นแบบเป็นโปรแกรม ให้ส่งคำขอ HTTPS POST ไปยังปลายทาง /revoke โดยทำดังนี้

    const https = require('https');
    
    // Build the string for the POST request
    let postData = "token=" + userCredential.access_token;
    
    // Options for POST request to Google's OAuth 2.0 server to revoke a token
    let postOptions = {
      host: 'oauth2.googleapis.com',
      port: '443',
      path: '/revoke',
      method: 'POST',
      headers: {
        'Content-Type': 'application/x-www-form-urlencoded',
        'Content-Length': Buffer.byteLength(postData)
      }
    };
    
    // Set up the request
    const postReq = https.request(postOptions, function (res) {
      res.setEncoding('utf8');
      res.on('data', d => {
        console.log('Response: ' + d);
      });
    });
    
    postReq.on('error', error => {
      console.log(error)
    });
    
    // Post the request with data
    postReq.write(postData);
    postReq.end();
    

    พารามิเตอร์โทเค็นอาจเป็นโทเค็นเพื่อการเข้าถึงหรือโทเค็นการรีเฟรชก็ได้ หากโทเค็นเป็นโทเค็นเพื่อการเข้าถึงและมีโทเค็นการรีเฟรชที่เกี่ยวข้อง ระบบจะเพิกถอนโทเค็นการรีเฟรชด้วย

    หากประมวลผลการเพิกถอนสำเร็จแล้ว รหัสสถานะของการตอบกลับจะเป็น 200 สำหรับเงื่อนไขข้อผิดพลาด ระบบจะส่งรหัสสถานะ 400 พร้อมกับรหัสข้อผิดพลาด

    HTTP/REST

    หากต้องการเพิกถอนโทเค็นแบบเป็นโปรแกรม แอปพลิเคชันจะส่งคำขอไปยัง https://oauth2.googleapis.com/revoke และใส่โทเค็นนั้นเป็นพารามิเตอร์

    curl -d -X -POST --header "Content-type:application/x-www-form-urlencoded" \
            https://oauth2.googleapis.com/revoke?token={token}

    โดยโทเค็นดังกล่าวอาจเป็นโทเค็นเพื่อการเข้าถึงหรือโทเค็นการรีเฟรชก็ได้ หากโทเค็นเป็นโทเค็นเพื่อการเข้าถึงและมีโทเค็นการรีเฟรชที่เกี่ยวข้อง ระบบจะเพิกถอนโทเค็นการรีเฟรชด้วย

    หากประมวลผลการเพิกถอนสำเร็จแล้ว รหัสสถานะ HTTP ของการตอบกลับจะเป็น 200 สำหรับเงื่อนไขข้อผิดพลาด ระบบจะส่งรหัสสถานะ HTTP 400 พร้อมกับรหัสข้อผิดพลาด