เอกสารนี้จะอธิบายวิธีที่แอปพลิเคชันเว็บเซิร์ฟเวอร์ใช้ไลบรารีของไคลเอ็นต์ Google API หรือปลายทาง OAuth 2.0 ของการใช้งาน OAuth 2.0 เพื่อเข้าถึง Google API
OAuth 2.0 ช่วยให้ผู้ใช้แชร์ข้อมูลที่เจาะจงกับแอปพลิเคชันได้ ขณะที่เก็บชื่อผู้ใช้ รหัสผ่าน และข้อมูลอื่นๆ ไว้เป็นส่วนตัว ตัวอย่างเช่น แอปพลิเคชันสามารถใช้ OAuth 2.0 เพื่อรับสิทธิ์จากผู้ใช้ในการจัดเก็บไฟล์ใน Google ไดรฟ์
ขั้นตอนของ OAuth 2.0 นี้มีไว้สําหรับการให้สิทธิ์ผู้ใช้โดยเฉพาะ ซึ่งออกแบบมาสําหรับแอปพลิเคชันที่จัดเก็บข้อมูลที่เป็นความลับและรักษาสถานะ แอปพลิเคชันเว็บเซิร์ฟเวอร์ที่ได้รับอนุญาตอย่างถูกต้องจะเข้าถึง API ได้ในขณะที่ผู้ใช้โต้ตอบกับแอปพลิเคชันหรือหลังจากที่ผู้ใช้ออกจากแอปพลิเคชันแล้ว
แอปพลิเคชันเว็บเซิร์ฟเวอร์มักใช้บัญชีบริการเพื่อให้สิทธิ์คําขอ API โดยเฉพาะเมื่อเรียกใช้ Cloud API เพื่อเข้าถึงข้อมูลที่อิงตามโปรเจ็กต์แทนข้อมูลเฉพาะของผู้ใช้ แอปพลิเคชันเว็บเซิร์ฟเวอร์จะใช้บัญชีบริการร่วมกับการให้สิทธิ์ผู้ใช้ได้
ไลบรารีของไคลเอ็นต์
ตัวอย่างภาษาเฉพาะในหน้านี้ใช้ไลบรารีของไคลเอ็นต์ Google API เพื่อใช้การให้สิทธิ์ OAuth 2.0 หากต้องการเรียกใช้ตัวอย่างโค้ด คุณต้องติดตั้งไลบรารีของไคลเอ็นต์สําหรับภาษาก่อน
เมื่อคุณใช้ไลบรารีของไคลเอ็นต์ Google API เพื่อจัดการขั้นตอน OAuth 2.0 ของแอปพลิเคชัน ไลบรารีของไคลเอ็นต์จะดําเนินการหลายอย่างที่แอปพลิเคชันจะต้องจัดการด้วยตัวเอง เช่น พิจารณาว่าแอปพลิเคชันจะใช้หรือรีเฟรชโทเค็นเพื่อการเข้าถึงที่จัดเก็บไว้เมื่อใด ตลอดจนเมื่อแอปพลิเคชันต้องขอความยินยอมอีกครั้ง ไลบรารีของไคลเอ็นต์ยังสร้าง URL เปลี่ยนเส้นทางที่ถูกต้อง และช่วยใช้งานเครื่องจัดการการเปลี่ยนเส้นทางที่แลกเปลี่ยนรหัสการให้สิทธิ์สําหรับโทเค็นเพื่อการเข้าถึง
ไลบรารีของไคลเอ็นต์ Google API สําหรับแอปพลิเคชันฝั่งเซิร์ฟเวอร์มีให้บริการในภาษาต่อไปนี้
สิ่งที่ต้องมีก่อน
เปิดใช้ API สําหรับโปรเจ็กต์
แอปพลิเคชันใดก็ตามที่เรียกใช้ Google APIs จะต้องเปิดใช้ 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 APIs ต้องมีข้อมูลเข้าสู่ระบบการให้สิทธิ์ที่ระบุแอปพลิเคชันไปยังเซิร์ฟเวอร์ 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เก็บไฟล์ไว้ในตําแหน่งที่ปลอดภัยซึ่งมีเพียงแอปพลิเคชันเท่านั้นที่เข้าถึงได้
ระบุขอบเขตการเข้าถึง
ขอบเขตจะช่วยให้แอปพลิเคชันของคุณขอเข้าถึงเฉพาะทรัพยากรที่จําเป็นเท่านั้น ขณะเดียวกันก็ช่วยให้ผู้ใช้ควบคุมจํานวนสิทธิ์เข้าถึงที่ตนให้กับแอปพลิเคชันของคุณได้ ดังนั้น อาจมีความสัมพันธ์แบบผกผันระหว่างจํานวนขอบเขตที่ขอและความเป็นไปได้ที่จะได้รับคํายินยอมจากผู้ใช้
ก่อนที่จะเริ่มใช้การให้สิทธิ์ OAuth 2.0 เราขอแนะนําให้คุณระบุขอบเขตที่แอปจําเป็นต้องมีสิทธิ์เข้าถึง
นอกจากนี้ เราขอแนะนําให้แอปพลิเคชันขอสิทธิ์เข้าถึงขอบเขตการให้สิทธิ์ผ่านขั้นตอนการให้สิทธิ์เพิ่มขึ้น ซึ่งแอปพลิเคชันจะขอสิทธิ์เข้าถึงข้อมูลผู้ใช้ในบริบท แนวทางปฏิบัติแนะนํานี้จะช่วยให้ผู้ใช้เข้าใจได้ง่ายขึ้นว่าทําไมแอปพลิเคชันของคุณจึงต้องใช้การเข้าถึงที่ขอ
เอกสารขอบเขต API ของ OAuth 2.0 จะมีรายการขอบเขตทั้งหมดที่คุณอาจเข้าถึงได้เพื่อเข้าถึง Google API
ข้อกําหนดเฉพาะภาษา
หากต้องการเรียกใช้ตัวอย่างโค้ดในเอกสารนี้ คุณจะต้องมีบัญชี Google, การเข้าถึงอินเทอร์เน็ต และเว็บเบราว์เซอร์ หากคุณใช้ไลบรารีของไคลเอ็นต์ API ตัวใดตัวหนึ่ง โปรดดูข้อกําหนดเฉพาะภาษาด้านล่าง
PHP
หากต้องการเรียกใช้ตัวอย่างโค้ด PHP ในเอกสารนี้ คุณจะต้องมีสิ่งต่อไปนี้
- PHP 5.4 ขึ้นไปที่ติดตั้งอินเทอร์เฟซบรรทัดคําสั่ง (CLI) และส่วนขยาย JSON แล้ว
- เครื่องมือจัดการทรัพยากร Dependency ของ Composer
-
ไลบรารีของไคลเอ็นต์ Google APIs สําหรับ PHP:
php composer.phar require google/apiclient:^2.0
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 รุ่นปัจจุบัน
-
ไคลเอ็นต์ Node.js ของ Google APIs:
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 ConsoleCredentials page ใน PHP ให้เรียกใช้ฟังก์ชัน $client = new Google_Client(); $client->setAuthConfig('client_secret.json'); |
||||||
redirect_uri |
จำเป็น
ระบุตําแหน่งที่เซิร์ฟเวอร์ API เปลี่ยนเส้นทางผู้ใช้หลังจากที่ผู้ใช้ดําเนินการขั้นตอนการให้สิทธิ์เสร็จสิ้นแล้ว ค่าต้องตรงกับ URI การเปลี่ยนเส้นทางที่ได้รับอนุญาตรายการใดรายการหนึ่งสําหรับไคลเอ็นต์ OAuth 2.0 ซึ่งคุณกําหนดค่าใน API Consoleของ Credentials pageไคลเอ็นต์ หากค่านี้ไม่ตรงกับ URI การเปลี่ยนเส้นทางที่ได้รับอนุญาตสําหรับ โปรดทราบว่ารูปแบบ หากต้องการตั้งค่านี้ใน PHP ให้เรียกใช้ฟังก์ชัน $client->setRedirectUri('https://oauth2.example.com/code'); |
||||||
scope |
จำเป็น
รายการขอบเขตที่คั่นด้วยช่องว่างซึ่งระบุทรัพยากรที่แอปพลิเคชันเข้าถึงได้ในนามของผู้ใช้ ค่าเหล่านี้จะบอกให้หน้าจอคํายินยอมที่ Google แสดงต่อผู้ใช้ ขอบเขตจะช่วยให้แอปพลิเคชันของคุณขอเข้าถึงเฉพาะทรัพยากรที่จําเป็นเท่านั้น ขณะเดียวกันก็ช่วยให้ผู้ใช้ควบคุมจํานวนสิทธิ์เข้าถึงที่ตนให้กับแอปพลิเคชันของคุณได้ ดังนั้น ความสัมพันธ์ระหว่างขอบเขตที่ขอกับความเป็นไปได้ที่จะได้รับความยินยอมจากผู้ใช้จึงมีความสัมพันธ์กัน หากต้องการตั้งค่านี้ใน PHP ให้เรียกใช้ฟังก์ชัน $client->addScope(Google_Service_Drive::DRIVE_METADATA_READONLY); เราขอแนะนําให้แอปพลิเคชันขอสิทธิ์เข้าถึงขอบเขตการให้สิทธิ์ในบริบทเมื่อเป็นไปได้ การขอสิทธิ์เข้าถึงข้อมูลผู้ใช้ในบริบทผ่านการให้สิทธิ์ที่เพิ่มขึ้นจะช่วยให้ผู้ใช้เข้าใจได้ง่ายขึ้นว่าทําไมแอปพลิเคชันของคุณจึงต้องใช้การเข้าถึงที่ขอ |
||||||
access_type |
แนะนำ
ระบุว่าแอปพลิเคชันจะรีเฟรชโทเค็นเพื่อการเข้าถึงได้หรือไม่เมื่อผู้ใช้ไม่ได้อยู่ในเบราว์เซอร์ ค่าพารามิเตอร์ที่ถูกต้องคือ ตั้งค่าเป็น หากต้องการตั้งค่านี้ใน PHP ให้เรียกใช้ฟังก์ชัน $client->setAccessType('offline'); |
||||||
state |
แนะนำ
ระบุค่าสตริงที่แอปพลิเคชันจะใช้เพื่อรักษาสถานะระหว่างคําขอการให้สิทธิ์กับการตอบกลับของเซิร์ฟเวอร์การให้สิทธิ์
เซิร์ฟเวอร์จะส่งคืนค่าที่แน่นอนที่คุณส่งเป็นคู่ของ คุณใช้พารามิเตอร์นี้เพื่อวัตถุประสงค์ต่างๆ ได้ เช่น การนําผู้ใช้ไปยังทรัพยากรที่ถูกต้องในแอปพลิเคชัน การส่ง nonces และการบรรเทาการปลอมแปลงคําขอแบบข้ามเว็บไซต์ เนื่องจาก หากต้องการตั้งค่านี้ใน PHP ให้เรียกใช้ฟังก์ชัน $client->setState($sample_passthrough_value); |
||||||
include_granted_scopes |
ไม่บังคับ
อนุญาตให้แอปพลิเคชันใช้การให้สิทธิ์เพิ่มเติมเพื่อขอสิทธิ์เข้าถึงขอบเขตเพิ่มเติมในบริบท หากคุณตั้งค่าพารามิเตอร์นี้เป็น หากต้องการตั้งค่านี้ใน PHP ให้เรียกใช้ฟังก์ชัน $client->setIncludeGrantedScopes(true); |
||||||
login_hint |
ไม่บังคับ
หากแอปพลิเคชันทราบว่าผู้ใช้รายใดพยายามตรวจสอบสิทธิ์ แอปก็จะใช้พารามิเตอร์นี้เพื่อให้คําแนะนําแก่เซิร์ฟเวอร์การตรวจสอบสิทธิ์ของ Google เซิร์ฟเวอร์จะใช้คําแนะนําที่ช่วยให้ขั้นตอนการเข้าสู่ระบบง่ายขึ้น โดยกรอกข้อมูลในช่องอีเมลในแบบฟอร์มการลงชื่อเข้าใช้หรือเลือกเซสชันการลงชื่อเข้าสู่ระบบที่เหมาะสม ตั้งค่าพารามิเตอร์เป็นอีเมลหรือตัวระบุ หากต้องการตั้งค่านี้ใน PHP ให้เรียกใช้ฟังก์ชัน $client->setLoginHint('None'); |
||||||
prompt |
ไม่บังคับ
รายการข้อความแจ้งที่คํานึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่เพื่อนําเสนอผู้ใช้ หากไม่ระบุพารามิเตอร์นี้ ระบบจะแจ้งให้ผู้ใช้ทราบเฉพาะครั้งแรกที่โปรเจ็กต์ขอสิทธิ์เข้าถึง ดูข้อมูลเพิ่มเติมได้ที่ข้อความแจ้งคํายินยอมซ้ํา หากต้องการตั้งค่านี้ใน PHP ให้เรียกใช้ฟังก์ชัน $client->setApprovalPrompt('consent'); ค่าที่เป็นไปได้มีดังนี้
|
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 ConsoleCredentials page ใน Python ให้เรียกใช้เมธอด 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 การเปลี่ยนเส้นทางที่ได้รับอนุญาตสําหรับ โปรดทราบว่ารูปแบบ หากต้องการตั้งค่านี้ใน Python ให้ตั้งค่าพร็อพเพอร์ตี้ flow.redirect_uri = 'https://oauth2.example.com/code' |
||||||
scope |
จำเป็น
รายการขอบเขตที่ระบุทรัพยากรที่แอปพลิเคชันเข้าถึงได้ในนามของผู้ใช้ ค่าเหล่านี้จะบอกให้หน้าจอคํายินยอมที่ Google แสดงต่อผู้ใช้ ขอบเขตจะช่วยให้แอปพลิเคชันของคุณขอเข้าถึงเฉพาะทรัพยากรที่จําเป็นเท่านั้น ขณะเดียวกันก็ช่วยให้ผู้ใช้ควบคุมจํานวนสิทธิ์เข้าถึงที่ตนให้กับแอปพลิเคชันของคุณได้ ดังนั้น ความสัมพันธ์ระหว่างขอบเขตที่ขอกับความเป็นไปได้ที่จะได้รับความยินยอมจากผู้ใช้จึงมีความสัมพันธ์กัน ใน Python ให้ใช้วิธีเดียวกับที่ใช้ตั้งค่า flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file( 'client_secret.json', scopes=['https://www.googleapis.com/auth/drive.metadata.readonly']) เราขอแนะนําให้แอปพลิเคชันขอสิทธิ์เข้าถึงขอบเขตการให้สิทธิ์ในบริบทเมื่อเป็นไปได้ การขอสิทธิ์เข้าถึงข้อมูลผู้ใช้ในบริบทผ่านการให้สิทธิ์ที่เพิ่มขึ้นจะช่วยให้ผู้ใช้เข้าใจได้ง่ายขึ้นว่าทําไมแอปพลิเคชันของคุณจึงต้องใช้การเข้าถึงที่ขอ |
||||||
access_type |
แนะนำ
ระบุว่าแอปพลิเคชันจะรีเฟรชโทเค็นเพื่อการเข้าถึงได้หรือไม่เมื่อผู้ใช้ไม่ได้อยู่ในเบราว์เซอร์ ค่าพารามิเตอร์ที่ถูกต้องคือ ตั้งค่าเป็น ใน Python ให้ตั้งค่าพารามิเตอร์ authorization_url, state = flow.authorization_url( access_type='offline', include_granted_scopes='true') |
||||||
state |
แนะนำ
ระบุค่าสตริงที่แอปพลิเคชันจะใช้เพื่อรักษาสถานะระหว่างคําขอการให้สิทธิ์กับการตอบกลับของเซิร์ฟเวอร์การให้สิทธิ์
เซิร์ฟเวอร์จะส่งคืนค่าที่แน่นอนที่คุณส่งเป็นคู่ของ คุณใช้พารามิเตอร์นี้เพื่อวัตถุประสงค์ต่างๆ ได้ เช่น การนําผู้ใช้ไปยังทรัพยากรที่ถูกต้องในแอปพลิเคชัน การส่ง nonces และการบรรเทาการปลอมแปลงคําขอแบบข้ามเว็บไซต์ เนื่องจาก ใน Python ให้ตั้งค่าพารามิเตอร์ authorization_url, state = flow.authorization_url( access_type='offline', state=sample_passthrough_value, include_granted_scopes='true') |
||||||
include_granted_scopes |
ไม่บังคับ
อนุญาตให้แอปพลิเคชันใช้การให้สิทธิ์เพิ่มเติมเพื่อขอสิทธิ์เข้าถึงขอบเขตเพิ่มเติมในบริบท หากคุณตั้งค่าพารามิเตอร์นี้เป็น ใน Python ให้ตั้งค่าพารามิเตอร์ authorization_url, state = flow.authorization_url( access_type='offline', include_granted_scopes='true') |
||||||
login_hint |
ไม่บังคับ
หากแอปพลิเคชันทราบว่าผู้ใช้รายใดพยายามตรวจสอบสิทธิ์ แอปก็จะใช้พารามิเตอร์นี้เพื่อให้คําแนะนําแก่เซิร์ฟเวอร์การตรวจสอบสิทธิ์ของ Google เซิร์ฟเวอร์จะใช้คําแนะนําที่ช่วยให้ขั้นตอนการเข้าสู่ระบบง่ายขึ้น โดยกรอกข้อมูลในช่องอีเมลในแบบฟอร์มการลงชื่อเข้าใช้หรือเลือกเซสชันการลงชื่อเข้าสู่ระบบที่เหมาะสม ตั้งค่าพารามิเตอร์เป็นอีเมลหรือตัวระบุ ใน Python ให้ตั้งค่าพารามิเตอร์ authorization_url, state = flow.authorization_url( access_type='offline', login_hint='None', include_granted_scopes='true') |
||||||
prompt |
ไม่บังคับ
รายการข้อความแจ้งที่คํานึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่เพื่อนําเสนอผู้ใช้ หากไม่ระบุพารามิเตอร์นี้ ระบบจะแจ้งให้ผู้ใช้ทราบเฉพาะครั้งแรกที่โปรเจ็กต์ขอสิทธิ์เข้าถึง ดูข้อมูลเพิ่มเติมได้ที่ข้อความแจ้งคํายินยอมซ้ํา ใน Python ให้ตั้งค่าพารามิเตอร์ authorization_url, state = flow.authorization_url( access_type='offline', prompt='consent', include_granted_scopes='true') ค่าที่เป็นไปได้มีดังนี้
|
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 ConsoleCredentials page |
||||||
redirect_uri |
จำเป็น
ระบุตําแหน่งที่เซิร์ฟเวอร์ API เปลี่ยนเส้นทางผู้ใช้หลังจากที่ผู้ใช้ดําเนินการขั้นตอนการให้สิทธิ์เสร็จสิ้นแล้ว ค่าต้องตรงกับ URI การเปลี่ยนเส้นทางที่ได้รับอนุญาตรายการใดรายการหนึ่งสําหรับไคลเอ็นต์ OAuth 2.0 ซึ่งคุณกําหนดค่าใน API Consoleของ Credentials pageไคลเอ็นต์ หากค่านี้ไม่ตรงกับ URI การเปลี่ยนเส้นทางที่ได้รับอนุญาตสําหรับ โปรดทราบว่ารูปแบบ |
||||||
response_type |
จำเป็น
กําหนดว่าปลายทาง OAuth 2.0 ของ Google แสดงรหัสการให้สิทธิ์หรือไม่ ตั้งค่าพารามิเตอร์เป็น |
||||||
scope |
จำเป็น
รายการขอบเขตที่คั่นด้วยช่องว่างซึ่งระบุทรัพยากรที่แอปพลิเคชันเข้าถึงได้ในนามของผู้ใช้ ค่าเหล่านี้จะบอกให้หน้าจอคํายินยอมที่ Google แสดงต่อผู้ใช้ ขอบเขตจะช่วยให้แอปพลิเคชันของคุณขอเข้าถึงเฉพาะทรัพยากรที่จําเป็นเท่านั้น ขณะเดียวกันก็ช่วยให้ผู้ใช้ควบคุมจํานวนสิทธิ์เข้าถึงที่ตนให้กับแอปพลิเคชันของคุณได้ ดังนั้น ความสัมพันธ์ระหว่างขอบเขตที่ขอกับความเป็นไปได้ที่จะได้รับความยินยอมจากผู้ใช้จึงมีความสัมพันธ์กัน เราขอแนะนําให้แอปพลิเคชันขอสิทธิ์เข้าถึงขอบเขตการให้สิทธิ์ในบริบทเมื่อเป็นไปได้ การขอสิทธิ์เข้าถึงข้อมูลผู้ใช้ในบริบทผ่านการให้สิทธิ์ที่เพิ่มขึ้นจะช่วยให้ผู้ใช้เข้าใจได้ง่ายขึ้นว่าทําไมแอปพลิเคชันของคุณจึงต้องใช้การเข้าถึงที่ขอ |
||||||
access_type |
แนะนำ
ระบุว่าแอปพลิเคชันจะรีเฟรชโทเค็นเพื่อการเข้าถึงได้หรือไม่เมื่อผู้ใช้ไม่ได้อยู่ในเบราว์เซอร์ ค่าพารามิเตอร์ที่ถูกต้องคือ ตั้งค่าเป็น |
||||||
state |
แนะนำ
ระบุค่าสตริงที่แอปพลิเคชันจะใช้เพื่อรักษาสถานะระหว่างคําขอการให้สิทธิ์กับการตอบกลับของเซิร์ฟเวอร์การให้สิทธิ์
เซิร์ฟเวอร์จะส่งคืนค่าที่แน่นอนที่คุณส่งเป็นคู่ของ คุณใช้พารามิเตอร์นี้เพื่อวัตถุประสงค์ต่างๆ ได้ เช่น การนําผู้ใช้ไปยังทรัพยากรที่ถูกต้องในแอปพลิเคชัน การส่ง nonces และการบรรเทาการปลอมแปลงคําขอแบบข้ามเว็บไซต์ เนื่องจาก |
||||||
include_granted_scopes |
ไม่บังคับ
อนุญาตให้แอปพลิเคชันใช้การให้สิทธิ์เพิ่มเติมเพื่อขอสิทธิ์เข้าถึงขอบเขตเพิ่มเติมในบริบท หากคุณตั้งค่าพารามิเตอร์นี้เป็น |
||||||
login_hint |
ไม่บังคับ
หากแอปพลิเคชันทราบว่าผู้ใช้รายใดพยายามตรวจสอบสิทธิ์ แอปก็จะใช้พารามิเตอร์นี้เพื่อให้คําแนะนําแก่เซิร์ฟเวอร์การตรวจสอบสิทธิ์ของ Google เซิร์ฟเวอร์จะใช้คําแนะนําที่ช่วยให้ขั้นตอนการเข้าสู่ระบบง่ายขึ้น โดยกรอกข้อมูลในช่องอีเมลในแบบฟอร์มการลงชื่อเข้าใช้หรือเลือกเซสชันการลงชื่อเข้าสู่ระบบที่เหมาะสม ตั้งค่าพารามิเตอร์เป็นอีเมลหรือตัวระบุ |
||||||
prompt |
ไม่บังคับ
รายการข้อความแจ้งที่คํานึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่เพื่อนําเสนอผู้ใช้ หากไม่ระบุพารามิเตอร์นี้ ระบบจะแจ้งให้ผู้ใช้ทราบเฉพาะครั้งแรกที่โปรเจ็กต์ขอสิทธิ์เข้าถึง ดูข้อมูลเพิ่มเติมได้ที่ข้อความแจ้งคํายินยอมซ้ํา ค่าที่เป็นไปได้มีดังนี้
|
ขั้นตอนที่ 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
ที่สร้างขึ้นจากวิธีขั้นตอนที่ 1generateAuthUrl
เพื่อขอสิทธิ์เข้าถึงจากเซิร์ฟเวอร์ 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 โปรดดูบทความช่วยเหลือของผู้ดูแลระบบ Google Workspace เพื่อควบคุมว่าจะให้แอปของบุคคลที่สามและแอปภายในรายการใดเข้าถึงข้อมูล Google Workspace ได้บ้างเพื่อดูข้อมูลเพิ่มเติมเกี่ยวกับวิธีที่ผู้ดูแลระบบอาจจํากัดการเข้าถึงขอบเขตทั้งหมดหรือขอบเขตที่มีความละเอียดอ่อนและถูกจํากัด จนกว่าจะได้รับสิทธิ์เข้าถึงรหัสไคลเอ็นต์ OAuth อย่างชัดแจ้ง
disallowed_useragent
ปลายทางการให้สิทธิ์จะแสดงใน User Agent แบบฝังที่นโยบาย OAuth 2.0 ของ Google ไม่อนุญาต
Android
นักพัฒนาแอป Android อาจพบข้อความแสดงข้อผิดพลาดนี้เมื่อเปิดคําขอการให้สิทธิ์ใน android.webkit.WebView
นักพัฒนาซอฟต์แวร์ควรใช้ไลบรารี Android เช่น Google Sign-In สําหรับ Android หรือ OpenID Foundation'AppAuth สําหรับ Android แทน
นักพัฒนาเว็บอาจพบข้อผิดพลาดนี้เมื่อแอป Android เปิดลิงก์เว็บทั่วไปใน User Agent ที่ฝังอยู่ และผู้ใช้ไปที่ปลายทางการให้สิทธิ์ OAuth 2.0 ของ Google จากเว็บไซต์ของคุณ นักพัฒนาซอฟต์แวร์ควรอนุญาตให้ลิงก์ทั่วไปเปิดในเครื่องจัดการลิงก์เริ่มต้นของระบบปฏิบัติการ ซึ่งรวมทั้งเครื่องจัดการ Android App Link หรือแอปเบราว์เซอร์เริ่มต้น นอกจากนี้ไลบรารีแท็บที่กําหนดเองของ Android ก็เป็นตัวเลือกที่รองรับด้วย
iOS
นักพัฒนา iOS และ macOS อาจพบข้อผิดพลาดนี้เมื่อเปิดคําขอการให้สิทธิ์ใน WKWebView
นักพัฒนาซอฟต์แวร์ควรใช้ไลบรารี iOS เช่น Google Sign-In สําหรับ iOS หรือ OpenID Foundation'AppAuth สําหรับ iOS แทน
นักพัฒนาเว็บอาจพบข้อผิดพลาดนี้เมื่อแอป iOS หรือ macOS เปิดลิงก์เว็บทั่วไปใน User Agent ที่ฝังอยู่และผู้ใช้ไปยังปลายทางการให้สิทธิ์ OAuth 2.0 ของ Google จากเว็บไซต์ของคุณ นักพัฒนาซอฟต์แวร์ควรอนุญาตให้ลิงก์ทั่วไปเปิดในเครื่องจัดการลิงก์เริ่มต้นของระบบปฏิบัติการ ซึ่งรวมทั้งเครื่องจัดการ Universal Link หรือแอปเบราว์เซอร์เริ่มต้น นอกจากนี้ไลบรารี SFSafariViewController
ก็เป็นตัวเลือกที่รองรับด้วย
org_internal
รหัสไคลเอ็นต์ OAuth ในคําขอเป็นส่วนหนึ่งของโปรเจ็กต์ที่จํากัดการเข้าถึงบัญชี Google ในองค์กร Google Cloud ที่เจาะจง ดูข้อมูลเพิ่มเติมเกี่ยวกับตัวเลือกการกําหนดค่านี้ได้ในส่วนประเภทผู้ใช้ในบทความช่วยเหลือการตั้งค่าการตั้งค่าความยินยอมของ OAuth
redirect_uri_mismatch
redirect_uri
ที่ส่งผ่านในคําขอการให้สิทธิ์ไม่ตรงกับ URI การเปลี่ยนเส้นทางที่ได้รับอนุญาตสําหรับรหัสไคลเอ็นต์ OAuth ตรวจสอบ URI การเปลี่ยนเส้นทางที่ได้รับอนุญาตใน Google API Console Credentials page
ขั้นตอนที่ 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
หากต้องการแลกเปลี่ยนรหัสการให้สิทธิ์สําหรับโทเค็นเพื่อการเข้าถึง ให้ใช้เมธอด 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 ConsoleCredentials 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" }
การเรียก Google APIs
PHP
ใช้โทเค็นเพื่อการเข้าถึงเพื่อเรียก Google APIs โดยทําตามขั้นตอนต่อไปนี้
- หากต้องการใช้โทเค็นเพื่อการเข้าถึงกับออบเจ็กต์
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 ที่ต้องการเรียกใช้ คุณสร้างออบเจ็กต์บริการโดยเรียกใช้เมธอด
googleapiclient.discovery
library'sbuild
ด้วยชื่อและเวอร์ชันของ API และข้อมูลเข้าสู่ระบบของผู้ใช้ ดังนี้ หากต้องการเรียกใช้ Drive API เวอร์ชัน 2from googleapiclient.discovery import build drive = build('drive', 'v2', credentials=credentials)
- ส่งคําขอไปยังบริการ API โดยใช้อินเทอร์เฟซที่ออบเจ็กต์บริการให้บริการ
เช่น หากต้องการแสดงไฟล์ใน Google ไดรฟ์ของผู้ใช้ที่ตรวจสอบสิทธิ์แล้ว ให้ทําดังนี้
files = drive.files().list().execute()
Ruby
ใช้ออบเจ็กต์ auth_client
เพื่อเรียก Google APIs โดยทําตามขั้นตอนต่อไปนี้
- สร้างออบเจ็กต์บริการสําหรับ 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 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
หลังจากที่แอปพลิเคชันได้รับโทเค็นเพื่อการเข้าถึงแล้ว คุณจะใช้โทเค็นเพื่อเรียก 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.0
- สร้างไฟล์
index.php
และoauth2callback.php
ที่มีเนื้อหาด้านล่าง - เรียกใช้ตัวอย่างที่มีเว็บเซิร์ฟเวอร์ที่กําหนดค่าไว้ให้แสดง PHP หากใช้ PHP 5.4 หรือใหม่กว่า คุณจะใช้เว็บเซิร์ฟเวอร์การทดสอบในตัวของ 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_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
.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 และไลบรารี Requests เพื่อแสดงโฟลว์เว็บ 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 จะได้รับการยกเว้นจากกฎนี้ |
โดเมน |
“googleusercontent.com” goo.gl ) เว้นแต่ว่าแอปเป็นเจ้าของโดเมน นอกจากนี้ หากแอปที่เป็นเจ้าของโดเมนที่สั้นกว่าเลือกที่จะเปลี่ยนเส้นทางไปยังโดเมนดังกล่าว URI การเปลี่ยนเส้นทางดังกล่าวต้องมี “/google-callback/” ในเส้นทางหรือลงท้ายด้วย “/google-callback” |
ข้อมูลผู้ใช้ |
URI การเปลี่ยนเส้นทางต้องไม่มีองค์ประกอบย่อยของ userinfo |
เส้นทาง |
URI การเปลี่ยนเส้นทางจะต้องไม่มีการส่งผ่านเส้นทาง (หรือที่เรียกว่าการติดตามย้อนกลับไดเรกทอรี) ซึ่งนําเสนอด้วย |
การค้นหา |
URI การเปลี่ยนเส้นทางต้องไม่มีการเปลี่ยนเส้นทางแบบเปิด |
ส่วนย่อย |
URI การเปลี่ยนเส้นทางต้องไม่มีคอมโพเนนต์ส่วนย่อย |
อักขระ |
URI การเปลี่ยนเส้นทางต้องไม่มีอักขระบางตัวต่อไปนี้
|
การให้สิทธิ์ที่เพิ่มขึ้น
ในโปรโตคอล OAuth 2.0 แอปของคุณจะขอสิทธิ์เข้าถึงทรัพยากร ซึ่งระบุโดยขอบเขต การดําเนินการนี้ถือเป็นแนวทางปฏิบัติแนะนําสําหรับประสบการณ์ของผู้ใช้ที่ขอการให้สิทธิ์ทรัพยากรในเวลาที่คุณต้องการ ในการเปิดใช้แนวทางปฏิบัติดังกล่าว เซิร์ฟเวอร์การให้สิทธิ์ของ Google รองรับการให้สิทธิ์แบบเพิ่มขึ้นเรื่อยๆ ฟีเจอร์นี้ช่วยให้คุณส่งคําขอขอบเขตได้ตามความจําเป็น และหากผู้ใช้ให้สิทธิ์ในขอบเขตใหม่ ให้แสดงรหัสการให้สิทธิ์ที่อาจแลกเปลี่ยนกับโทเค็นที่มีขอบเขตทั้งหมดที่ผู้ใช้ให้โปรเจ็กต์ได้
ตัวอย่างเช่น แอปที่ให้ผู้ใช้สุ่มตัวอย่างแทร็กเพลงและสร้างมิกซ์อาจต้องใช้ทรัพยากรน้อยมากเมื่อลงชื่อเข้าใช้ ซึ่งอาจไม่มีอะไรมากไปกว่าชื่อของผู้ที่ลงชื่อเข้าใช้ แต่การบันทึกมิกซ์ที่เสร็จสมบูรณ์ต้องมีสิทธิ์เข้าถึง Google ไดรฟ์ ผู้คนส่วนใหญ่มักพบว่านี่เป็นเรื่องธรรมชาติ หากมีการขอสิทธิ์การเข้าถึง Google ไดรฟ์ในขณะที่แอปต้องการจริงๆ เท่านั้น
ในกรณีนี้ แอปอาจขอขอบเขต openid
และ profile
ในการลงชื่อเข้าใช้ขั้นพื้นฐาน ในขณะที่ลงชื่อเข้าใช้ และจะขอขอบเขตของ https://www.googleapis.com/auth/drive.file
ตอนที่มีคําขอแรกในการบันทึกมิกซ์
หากต้องการใช้การให้สิทธิ์ที่เพิ่มขึ้น คุณต้องทําตามขั้นตอนปกติในการขอโทเค็นเพื่อการเข้าถึง แต่ตรวจสอบว่าคําขอการให้สิทธิ์มีขอบเขตที่เคยอนุญาตแล้ว วิธีนี้ช่วยให้แอปไม่ต้องจัดการโทเค็นเพื่อการเข้าถึงหลายรายการ
กฎต่อไปนี้จะมีผลกับโทเค็นเพื่อการเข้าถึงที่ได้รับจากการให้สิทธิ์ที่เพิ่มขึ้น
- คุณจะใช้โทเค็นเพื่อเข้าถึงทรัพยากรที่สอดคล้องกับขอบเขตใดๆ ที่รวมไว้ในการให้สิทธิ์แบบรวมแบบใหม่ได้
- เมื่อคุณใช้โทเค็นการรีเฟรชสําหรับการให้สิทธิ์แบบรวมเพื่อรับโทเค็นเพื่อการเข้าถึง โทเค็นเพื่อการเข้าถึงแสดงถึงการให้สิทธิ์แบบรวม และสามารถใช้กับค่า
scope
ที่รวมอยู่ในการตอบกลับได้ - การให้สิทธิ์แบบรวมนี้รวมขอบเขตทั้งหมดที่ผู้ใช้มอบให้กับโปรเจ็กต์ API แม้ว่าจะมีการส่งคําขอสิทธิ์จากไคลเอ็นต์ต่างๆ ก็ตาม ตัวอย่างเช่น หากผู้ใช้ให้สิทธิ์เข้าถึงขอบเขตหนึ่งโดยใช้ไคลเอ็นต์เดสก์ท็อปของแอปพลิเคชัน แล้วให้สิทธิ์อีก 1 ขอบเขตไปยังแอปพลิเคชันเดียวกันผ่านไคลเอ็นต์ในอุปกรณ์เคลื่อนที่ การให้สิทธิ์แบบรวมจะมีทั้ง 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
ในการรีเฟรชโทเค็นเพื่อการเข้าถึง แอปพลิเคชันจะส่งคําขอ 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 ต่อชุดค่าผสมของไคลเอ็นต์/ผู้ใช้ และจํานวนที่จํากัดต่อผู้ใช้ต่อไคลเอ็นต์ทั้งหมด คุณควรบันทึกโทเค็นการรีเฟรชในระยะยาว แล้วใช้โทเค็นต่อไปตราบใดที่โทเค็นนั้นยังคงใช้งานได้ หากแอปพลิเคชันของคุณขอโทเค็นการรีเฟรชมากเกินไป โทเค็นดังกล่าวอาจทํางานผิดพลาดได้ ซึ่งในกรณีนี้โทเค็นการรีเฟรชเวอร์ชันเก่าจะหยุดทํางาน
กําลังเพิกถอนโทเค็น
ในบางกรณีผู้ใช้อาจต้องการเพิกถอนสิทธิ์เข้าถึงแอปพลิเคชัน ผู้ใช้จะเพิกถอนสิทธิ์เข้าถึงได้โดยไปที่การตั้งค่าบัญชี ดูข้อมูลเพิ่มเติมได้จากเอกสารสนับสนุนในหัวข้อนําเว็บไซต์หรือแอปออกของเว็บไซต์ของบุคคลที่สามและแอปที่มีสิทธิ์เข้าถึงบัญชีของคุณ
นอกจากนี้ แอปพลิเคชันอาจเพิกถอนการเข้าถึงแบบเป็นโปรแกรมด้วยโปรแกรมได้ การเพิกถอนแบบเป็นโปรแกรมมีความสําคัญในกรณีที่ผู้ใช้ยกเลิกการสมัคร นําแอปพลิเคชันออก หรือทรัพยากร 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
พร้อมกับรหัสข้อผิดพลาด