หน้านี้ได้รับการแปลโดย Cloud Translation API

การใช้ 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 API เพื่อเข้าถึงข้อมูลตามโปรเจ็กต์ ไม่ใช่ข้อมูลเฉพาะของผู้ใช้ แอปพลิเคชันเว็บเซิร์ฟเวอร์สามารถใช้บัญชีบริการร่วมกับการให้สิทธิ์ผู้ใช้

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

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

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

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

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

สิ่งที่ต้องดำเนินการก่อน

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

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

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

Open the API Library ใน Google API Console

If prompted, select a project, or create a new one.

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

เลือก API ที่ต้องการเปิดใช้ แล้วคลิกปุ่มเปิดใช้

If prompted, enable billing.

If prompted, read and accept the API's Terms of Service.

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

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

Go to the Credentials page.

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

เลือกประเภทแอปพลิเคชันเว็บแอปพลิเคชัน

กรอกแบบฟอร์มและคลิกสร้าง แอปพลิเคชันที่ใช้ภาษาและเฟรมเวิร์ก เช่น PHP, Java, Python, Ruby และ .NET ต้องระบุ URI การเปลี่ยนเส้นทางที่ได้รับอนุญาต URI การเปลี่ยนเส้นทางคือปลายทางที่เซิร์ฟเวอร์ OAuth 2.0 ส่งการตอบกลับได้ ปลายทางเหล่านี้ต้องเป็นไปตามกฎการตรวจสอบของ Google
สําหรับการทดสอบ คุณจะระบุ URI ที่อ้างอิงเครื่องในเครื่องได้ เช่น http://localhost:8080 ดังนั้น โปรดทราบว่าตัวอย่างทั้งหมดในเอกสารนี้ใช้ http://localhost:8080 เป็น URI การเปลี่ยนเส้นทาง

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

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

ข้อสําคัญ: อย่าเก็บไฟล์ client_secret.json ไว้ในตําแหน่งสาธารณะ นอกจากนี้ หากคุณแชร์ซอร์สโค้ดไปยังแอปพลิเคชัน เช่น ใน GitHub ให้จัดเก็บไฟล์ client_secret.json ไว้นอกโครงสร้างต้นทางเพื่อหลีกเลี่ยงการแชร์ข้อมูลเข้าสู่ระบบของไคลเอ็นต์โดยไม่ตั้งใจ

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

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

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

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

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

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

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

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

PHP

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

PHP 5.6 ขึ้นไปที่ติดตั้งส่วนขยายบรรทัดคําสั่ง (CLI) และส่วนขยาย JSON

เครื่องมือการจัดการทรัพยากร Dependency Composer

ไลบรารีของไคลเอ็นต์ Google APIs สําหรับ 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.2.2 ขึ้นไป

ไลบรารีของไคลเอ็นต์ Google APIs สําหรับ Ruby มีดังนี้

gem install google-api-client

เฟรมเวิร์กเว็บแอปพลิเคชัน 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 ที่ต้องมีการให้สิทธิ์ผู้ใช้ได้

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

แอปพลิเคชันของคุณระบุสิทธิ์ที่ต้องการ

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

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

แอปพลิเคชันดูสิ่งที่ผู้ใช้เลือก

หากผู้ใช้ให้สิทธิ์ที่ขอ แอปพลิเคชันของคุณจะเรียกโทเค็นที่จําเป็นต้องใช้ในการสร้างคําขอ 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" ensures that your application always receives a refresh token. // If you are not using offline access, you can omit this. $client->setApprovalPrompt('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 หลังจากที่ผู้ใช้ให้ความยินยอมหรือปฏิเสธคําขอเข้าถึงของแอปพลิเคชัน

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

หากต้องการตั้งค่านี้ใน 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 ให้เรียกใช้ฟังก์ชัน setApprovalPrompt ดังนี้

$client->setApprovalPrompt('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 หลังจากที่ผู้ใช้ให้ความยินยอมหรือปฏิเสธคําขอเข้าถึงของแอปพลิเคชัน

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

ใน 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_v2' require 'google/api_client/client_secrets' client_secrets = Google::APIClient::ClientSecrets.load auth_client = client_secrets.to_authorization auth_client.update!( :scope => 'https://www.googleapis.com/auth/drive.metadata.readonly', :redirect_uri => 'http://www.example.com/oauth2callback', :additional_parameters => { "access_type" => "offline", # offline access "include_granted_scopes" => "true" # incremental auth } )

แอปพลิเคชันของคุณใช้ออบเจ็กต์ไคลเอ็นต์เพื่อดําเนินการ OAuth 2.0 เช่น การสร้าง URL คําขอการให้สิทธิ์และการใช้โทเค็นเพื่อการเข้าถึงกับคําขอ HTTP

Node.js

ข้อมูลโค้ดด้านล่างจะสร้างออบเจ็กต์ google.auth.OAuth2 ซึ่งกําหนดพารามิเตอร์ในคําขอการให้สิทธิ์

ออบเจ็กต์ดังกล่าวใช้ข้อมูลจากไฟล์ client_secret.json เพื่อระบุแอปพลิเคชัน หากต้องการขอสิทธิ์จากผู้ใช้ในการเรียกโทเค็นเพื่อการเข้าถึง คุณต้องเปลี่ยนเส้นทางผู้ใช้ไปยังหน้าความยินยอม วิธีสร้าง 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 หลังจากที่ผู้ใช้ให้ความยินยอมหรือปฏิเสธคําขอเข้าถึงของแอปพลิเคชัน

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

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

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

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

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

none อย่าแสดงหน้าจอการตรวจสอบสิทธิ์หรือความยินยอม ต้องระบุด้วยค่าอื่น

consent แสดงข้อความแจ้งผู้ใช้เพื่อขอความยินยอม

select_account แสดงข้อความแจ้งให้ผู้ใช้เลือกบัญชี

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

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

PHP

สร้าง URL เพื่อขอสิทธิ์เข้าถึงจากเซิร์ฟเวอร์ OAuth 2.0 ของ Google ดังนี้
$auth_url = $client->createAuthUrl();

เปลี่ยนเส้นทางผู้ใช้ไปยัง $auth_url
header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL));

Python

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

return flask.redirect(authorization_url)

Ruby

สร้าง URL เพื่อขอสิทธิ์เข้าถึงจากเซิร์ฟเวอร์ OAuth 2.0 ของ Google ดังนี้
auth_uri = auth_client.authorization_uri.to_s

เปลี่ยนเส้นทางผู้ใช้ไปยัง auth_uri

Node.js

ใช้ URL authorizationUrl ที่สร้างขึ้นจากเมธอด ขั้นตอนที่ 1 generateAuthUrl เพื่อขอสิทธิ์เข้าถึงจากเซิร์ฟเวอร์ OAuth 2.0 ของ Google

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

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) ที่เลิกใช้งานแล้วและไม่รองรับแล้ว โปรดดูคําแนะนําในการย้ายข้อมูลเพื่ออัปเดตการผสานรวม

ขั้นตอนที่ 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

สําคัญ: หากปลายทางการตอบสนองของคุณแสดงหน้า HTML ทรัพยากรใดๆ ในหน้านั้นจะเห็นรหัสการให้สิทธิ์ใน URL สคริปต์จะอ่าน URL ได้โดยตรง และอาจส่ง URL ในส่วนหัว HTTP ของ Referer ไปยังทรัพยากรบางส่วนหรือทั้งหมดในหน้าเว็บ
พิจารณาอย่างรอบคอบว่าต้องการส่งข้อมูลเข้าสู่ระบบการให้สิทธิ์ไปยังทรัพยากรทั้งหมดในหน้านั้น (โดยเฉพาะสคริปต์ของบุคคลที่สาม เช่น ปลั๊กอินโซเชียลและการวิเคราะห์) เพื่อหลีกเลี่ยงปัญหานี้ เราขอแนะนําให้เซิร์ฟเวอร์จัดการคําขอก่อน แล้วเปลี่ยนเส้นทางไปยัง URL อื่นที่ไม่มีพารามิเตอร์การตอบกลับ

ตัวอย่างการตอบกลับของเซิร์ฟเวอร์ 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

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

auth_client.code = auth_code auth_client.fetch_access_token!

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 เสมอ

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

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

{ "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 โดยทําตามขั้นตอนต่อไปนี้

หากต้องการใช้โทเค็นเพื่อการเข้าถึงกับออบเจ็กต์ Google\Client ใหม่ เช่น หากคุณจัดเก็บโทเค็นเพื่อการเข้าถึงไว้ในเซสชันของผู้ใช้ ให้ใช้เมธอด setAccessToken ดังนี้
$client->setAccessToken($access_token);

สร้างออบเจ็กต์บริการสําหรับ API ที่ต้องการเรียก คุณสร้างออบเจ็กต์บริการได้โดยระบุออบเจ็กต์ Google\Client ที่ได้รับอนุญาตแก่เครื่องมือสร้างสําหรับ API ที่ต้องการเรียก เช่น วิธีเรียก Drive API
$drive = new Google\Service\Drive($client);

ส่งคําขอไปยังบริการ API โดยใช้อินเทอร์เฟซที่ออบเจ็กต์บริการให้บริการ เช่น วิธีแสดงไฟล์ใน Google ไดรฟ์ของผู้ใช้ที่ได้รับการตรวจสอบสิทธิ์
$files = $drive->files->listFiles(array())->getItems();

Python

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

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

ส่งคําขอไปยังบริการ API โดยใช้อินเทอร์เฟซที่ออบเจ็กต์บริการให้บริการ เช่น วิธีแสดงไฟล์ใน Google ไดรฟ์ของผู้ใช้ที่ได้รับการตรวจสอบสิทธิ์
files = drive.files().list().execute()

Ruby

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

สร้างออบเจ็กต์บริการสําหรับ API ที่ต้องการเรียก เช่น หากต้องการเรียก Drive API เวอร์ชัน 2 ให้ทําดังนี้
drive = Google::Apis::DriveV2::DriveService.new

ตั้งค่าข้อมูลเข้าสู่ระบบในบริการ
drive.authorization = auth_client

ส่งคําขอไปยังบริการ API โดยใช้อินเทอร์เฟซที่ออบเจ็กต์บริการมีให้ เช่น วิธีแสดงไฟล์ใน Google ไดรฟ์ของผู้ใช้ที่ได้รับการตรวจสอบสิทธิ์
files = drive.list_files

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

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

Node.js

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

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

วิธีเรียกใช้ตัวอย่างนี้

ใน API Consoleให้เพิ่ม URL ของเครื่องลงในรายการ URL เปลี่ยนเส้นทาง เช่น เพิ่ม http://localhost:8080

สร้างไดเรกทอรีใหม่และเปลี่ยนไปใช้ไดเรกทอรีนี้ เช่น
mkdir ~/php-oauth2-example cd ~/php-oauth2-example

ติดตั้งไลบรารีของไคลเอ็นต์ Google API สําหรับ PHP โดยใช้ Composer ดังนี้
composer require google/apiclient:^2.10

สร้างไฟล์ index.php และ oauth2callback.php ที่มีเนื้อหาด้านล่าง

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

หมายเหตุ: หากต้องการเรียกใช้โค้ดในเครื่อง คุณต้องทําตามคําแนะนําในส่วนข้อกําหนดเบื้องต้น ซึ่งรวมถึงการตั้งค่า http://localhost:8080 เป็น URI การเปลี่ยนเส้นทางที่ถูกต้องสําหรับข้อมูลเข้าสู่ระบบ และดาวน์โหลดไฟล์ client_secret.json ของข้อมูลเข้าสู่ระบบเหล่านั้นไปยังไดเรกทอรีการทํางาน

# -*- 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_v2' require 'google/api_client/client_secrets' require 'json' require 'sinatra' enable :sessions set :session_secret, 'setme' get '/' do unless session.has_key?(:credentials) redirect to('/oauth2callback') end client_opts = JSON.parse(session[:credentials]) auth_client = Signet::OAuth2::Client.new(client_opts) drive = Google::Apis::DriveV2::DriveService.new files = drive.list_files(options: { authorization: auth_client }) "<pre>#{JSON.pretty_generate(files.to_h)}</pre>" end get '/oauth2callback' do client_secrets = Google::APIClient::ClientSecrets.load auth_client = client_secrets.to_authorization auth_client.update!( :scope => 'https://www.googleapis.com/auth/drive.metadata.readonly', :redirect_uri => url('/oauth2callback')) if request['code'] == nil auth_uri = auth_client.authorization_uri.to_s redirect to(auth_uri) else auth_client.code = request['code'] auth_client.fetch_access_token! auth_client.client_secret = nil session[:credentials] = auth_client.to_json redirect to('/') end end

Node.js

วิธีเรียกใช้ตัวอย่างนี้

ใน API Consoleให้เพิ่ม URL ของเครื่องในเครื่องลงในรายการ URL การเปลี่ยนเส้นทาง เช่น เพิ่ม http://localhost

ตรวจสอบว่าคุณได้ติดตั้ง LTS, LTS ที่ใช้งานอยู่ หรือการติดตั้ง Node.js เวอร์ชันปัจจุบันไว้

สร้างไดเรกทอรีใหม่และเปลี่ยนไปใช้ไดเรกทอรีนี้ เช่น
mkdir ~/nodejs-oauth2-example cd ~/nodejs-oauth2-example

Install the Google API Client Library for Node.js using npm:
npm install googleapis

สร้างไฟล์ main.js ที่มีเนื้อหาด้านล่าง

เรียกใช้ตัวอย่าง
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 การเปลี่ยนเส้นทางต้องไม่มีการข้ามผ่านเส้นทาง (หรือเรียกอีกอย่างว่าการติดตามย้อนกลับไดเรกทอรี) ซึ่งแทนด้วย “/..” หรือ “\..” หรือการเข้ารหัส 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 API ในนามของผู้ใช้ต่อไปได้เมื่อผู้ใช้ออฟไลน์ ออบเจ็กต์ไคลเอ็นต์จะรีเฟรชโทเค็นเพื่อการเข้าถึงตามที่จําเป็น

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 API ในนามของผู้ใช้ต่อไปได้เมื่อผู้ใช้ออฟไลน์ ออบเจ็กต์ไคลเอ็นต์จะรีเฟรชโทเค็นเพื่อการเข้าถึงตามที่จําเป็น

Ruby

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

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

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

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 API ในนามของผู้ใช้ต่อไปได้เมื่อผู้ใช้ออฟไลน์ ออบเจ็กต์ไคลเอ็นต์จะรีเฟรชโทเค็นเพื่อการเข้าถึงตามที่จําเป็น

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

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

หากต้องการรีเฟรชโทเค็นเพื่อการเข้าถึง แอปพลิเคชันจะส่งคําขอ POST แบบ HTTPS ไปยังเซิร์ฟเวอร์การให้สิทธิ์ของ 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 จะแสดงผลพร้อมกับรหัสข้อผิดพลาด

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

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

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

สิ่งที่ต้องดำเนินการก่อน

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

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

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

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

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

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

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

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

ข้อผิดพลาด

`admin_policy_enforced`

`disallowed_useragent`

Android

iOS

`org_internal`

`invalid_client`

`invalid_grant`

`redirect_uri_mismatch`

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

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

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

ข้อผิดพลาด

`invalid_grant`

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

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

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

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

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

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

ช่อง
`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` ที่ระบุ

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

กฎการตรวจสอบความถูกต้อง
รูปแบบ	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 การเปลี่ยนเส้นทางต้องไม่มีการข้ามผ่านเส้นทาง (หรือเรียกอีกอย่างว่าการติดตามย้อนกลับไดเรกทอรี) ซึ่งแทนด้วย `“/..”` หรือ `“\..”` หรือการเข้ารหัส URL
การค้นหา	URI การเปลี่ยนเส้นทางต้องไม่มีการเปลี่ยนเส้นทางแบบเปิด
ส่วนย่อย	URI การเปลี่ยนเส้นทางต้องไม่มีคอมโพเนนต์ส่วนย่อย
อักขระ	URI การเปลี่ยนเส้นทางต้องไม่มีอักขระบางตัวต่อไปนี้ อักขระไวลด์การ์ด (`'*'`) อักขระ ASCII ที่พิมพ์ไม่ได้ การเข้ารหัสเปอร์เซ็นต์ไม่ถูกต้อง (การเข้ารหัสเปอร์เซ็นต์ที่ไม่เป็นไปตามรูปแบบการเข้ารหัส URL ของเครื่องหมายเปอร์เซ็นต์ตามด้วยเลขฐานสิบหก 2 หลัก) อักขระ Null (อักขระ NULL ที่เข้ารหัส เช่น `%00`, `%C0%80`)

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

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

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

สิ่งที่ต้องดำเนินการก่อน

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

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

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

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

PHP

Python

Ruby

Node.js

HTTP/REST

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

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

PHP

Python

Ruby

Node.js

HTTP/REST

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

PHP

Python

Ruby

Node.js

HTTP/REST

Sample redirect to Google's authorization server

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

ข้อผิดพลาด

admin_policy_enforced

disallowed_useragent

Android

iOS

org_internal

invalid_client

invalid_grant

redirect_uri_mismatch

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

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

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

PHP

Python

Ruby

Node.js

HTTP/REST

ข้อผิดพลาด

invalid_grant

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

PHP

Python

Ruby

Node.js

HTTP/REST

ตัวอย่าง HTTP GET

ตัวอย่างของ curl

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

PHP

index.php

oauth2callback.php

Python

Ruby

Node.js

Main.js

HTTP/REST

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

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

PHP

Python

Ruby

Node.js

HTTP/REST

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

PHP

Python

Ruby

Node.js

HTTP/REST

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

PHP

Python

Ruby

`admin_policy_enforced`

`disallowed_useragent`

`org_internal`

`invalid_client`

`invalid_grant`

`redirect_uri_mismatch`

`invalid_grant`

ตัวอย่างของ `curl`