เอกสารนี้อธิบายวิธีที่แอปพลิเคชันเว็บเซิร์ฟเวอร์ใช้ไลบรารีของไคลเอ็นต์ Google API หรือที่ Google ปลายทาง OAuth 2.0 เพื่อใช้การให้สิทธิ์ OAuth 2.0 ในการเข้าถึง Google APIs
OAuth 2.0 ช่วยให้ผู้ใช้แชร์ข้อมูลที่ต้องการกับแอปพลิเคชันโดยที่ยังเก็บข้อมูล ชื่อผู้ใช้ รหัสผ่าน และข้อมูลอื่นๆ เป็นส่วนตัว เช่น แอปพลิเคชันสามารถใช้ OAuth 2.0 เพื่อขออนุญาตจาก จัดเก็บไฟล์ใน Google ไดรฟ์ได้
ขั้นตอน OAuth 2.0 นี้มีไว้สำหรับการให้สิทธิ์ผู้ใช้โดยเฉพาะ ออกแบบมาสำหรับแอปพลิเคชัน ที่สามารถจัดเก็บข้อมูลที่เป็นความลับและรักษาสถานะ เว็บเซิร์ฟเวอร์ที่ได้รับอนุญาตอย่างถูกต้อง แอปพลิเคชันสามารถเข้าถึง API ในขณะที่ผู้ใช้โต้ตอบกับแอปพลิเคชันหรือหลังจากที่ผู้ใช้ ได้ออกจากแอปพลิเคชันแล้ว
แอปพลิเคชันเว็บเซิร์ฟเวอร์มักจะใช้ บัญชีบริการเพื่อให้สิทธิ์คำขอ API โดยเฉพาะอย่างยิ่งเมื่อเรียกใช้ Cloud APIs เพื่อเข้าถึง ข้อมูลตามโปรเจ็กต์แทนที่จะเป็นข้อมูลที่เจาะจงผู้ใช้ แอปพลิเคชันเว็บเซิร์ฟเวอร์สามารถใช้บริการ บัญชีร่วมกับการให้สิทธิ์ผู้ใช้
ไลบรารีของไคลเอ็นต์
ตัวอย่างเฉพาะภาษาในหน้านี้ใช้ ไลบรารีไคลเอ็นต์ Google API เพื่อนำมาใช้ การให้สิทธิ์ OAuth 2.0 หากต้องการเรียกใช้ตัวอย่างโค้ด คุณต้องติดตั้ง ไลบรารีของไคลเอ็นต์สำหรับภาษาของคุณ
เมื่อคุณใช้ไลบรารีของไคลเอ็นต์ Google API ในการจัดการขั้นตอน OAuth 2.0 ของแอปพลิเคชัน ไลบรารีจะดำเนินการหลายอย่างที่แอปพลิเคชันจะต้องจัดการด้วยตัวเอง สำหรับ ตัวอย่างเช่น กำหนดว่าแอปพลิเคชันสามารถใช้หรือรีเฟรชโทเค็นเพื่อการเข้าถึงที่เก็บไว้เมื่อใด รวมถึง เมื่อแอปพลิเคชันต้องได้รับความยินยอม นอกจากนี้ ไลบรารีของไคลเอ็นต์ยังสร้างการเปลี่ยนเส้นทางที่ถูกต้อง URL และช่วยในการใช้งานตัวแฮนเดิลการเปลี่ยนเส้นทางที่จะแลกเปลี่ยนรหัสการให้สิทธิ์สำหรับโทเค็นเพื่อการเข้าถึง
ไลบรารีของไคลเอ็นต์ Google API สำหรับแอปพลิเคชันฝั่งเซิร์ฟเวอร์พร้อมให้บริการในภาษาต่อไปนี้
ข้อกำหนดเบื้องต้น
เปิดใช้ API สำหรับโปรเจ็กต์
แอปพลิเคชันใดๆ ที่เรียกใช้ Google 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 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เก็บไฟล์อย่างปลอดภัยในตำแหน่งที่ แอปพลิเคชันของคุณสามารถเข้าถึงได้
ระบุขอบเขตการเข้าถึง
ขอบเขตช่วยให้แอปพลิเคชันสามารถขอเข้าถึงเฉพาะทรัพยากรที่จำเป็นต้องใช้ และ ทำให้ผู้ใช้สามารถควบคุมปริมาณการเข้าถึงที่จะมอบให้กับแอปพลิเคชันของคุณได้ ดังนั้นจึงมี อาจเป็นความสัมพันธ์แบบผกผันระหว่างจำนวนขอบเขตที่ขอกับแนวโน้ม การขอความยินยอมจากผู้ใช้
ก่อนที่จะเริ่มใช้การให้สิทธิ์ OAuth 2.0 เราขอแนะนำให้คุณระบุขอบเขต ที่แอปของคุณจะต้องมีสิทธิ์เข้าถึง
นอกจากนี้ เราขอแนะนำให้แอปพลิเคชันของคุณส่งคำขอเข้าถึงขอบเขตการให้สิทธิ์ผ่าน การให้สิทธิ์เพิ่มขึ้น ซึ่งการสมัครของคุณ ขอสิทธิ์เข้าถึงข้อมูลผู้ใช้ในบริบทต่างๆ แนวทางปฏิบัติแนะนำนี้ช่วยให้ผู้ใช้เข้าใจง่ายขึ้น เหตุผลที่แอปพลิเคชันต้องการเข้าถึง
เอกสารขอบเขต API ของ OAuth 2.0 จะมีข้อมูลแบบเต็ม รายการขอบเขตที่คุณอาจใช้เพื่อเข้าถึง Google APIs
ข้อกำหนดเฉพาะภาษา
หากต้องการเรียกใช้ตัวอย่างโค้ดในเอกสารนี้ คุณจะต้องมีบัญชี Google ซึ่งสามารถเข้าถึง อินเทอร์เน็ต และเว็บเบราว์เซอร์ หากคุณใช้ไลบรารีของไคลเอ็นต์ API โปรดดู ข้อกำหนดเฉพาะภาษาได้ที่ด้านล่าง
PHP
หากต้องการเรียกใช้ตัวอย่างโค้ด PHP ในเอกสารนี้ คุณจะต้องมีสิ่งต่อไปนี้
- PHP 5.6 หรือสูงกว่าเมื่อติดตั้งส่วนขยายบรรทัดคำสั่ง (CLI) และส่วนขยาย JSON
- เครื่องมือการจัดการทรัพยากร Dependency คอมโพสเซอร์
-
ไลบรารีของไคลเอ็นต์ 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.6 หรือสูงกว่า
-
คลังการตรวจสอบสิทธิ์ของ Google สำหรับ Ruby มีลักษณะดังนี้
gem install googleauth
-
เฟรมเวิร์กเว็บแอปพลิเคชัน Sinatra Ruby
gem install sinatra
Node.js
หากต้องการเรียกใช้ตัวอย่างโค้ด Node.js ในเอกสารนี้ คุณจะต้องมีสิ่งต่อไปนี้
- LTS สำหรับการบำรุงรักษา, LTS ที่ใช้งานอยู่ หรือ Node.js รุ่นปัจจุบัน
-
ไคลเอ็นต์ Node.js ของ Google APIs มีลักษณะดังนี้
npm install googleapis crypto express express-session
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(); // Required, call the setAuthConfig function to load authorization credentials from // client_secret.json file. $client->setAuthConfig('client_secret.json'); // Required, to set the scope value, call the addScope function $client->addScope(Google\Service\Drive::DRIVE_METADATA_READONLY); // Required, call the setRedirectUri function to specify a valid redirect URI for the // provided client_id $client->setRedirectUri('http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php'); // Recommended, 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'); // Recommended, call the setState function. Using a state value can increase your assurance that // an incoming connection is the result of an authentication request. $client->setState($sample_passthrough_value); // Optional, if your application knows which user is trying to authenticate, it can use this // parameter to provide a hint to the Google Authentication Server. $client->setLoginHint('[email protected]'); // Optional, call the setPrompt function to set "consent" will prompt the user for consent $client->setPrompt('consent'); // Optional, call the setIncludeGrantedScopes function with true to enable incremental // authorization $client->setIncludeGrantedScopes(true);
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 # Required, call the from_client_secrets_file method to retrieve the client ID from a # client_secret.json file. The client ID (from that file) and access scopes are required. (You can # also use the from_client_config method, which passes the client configuration as it originally # appeared in a client secrets file but doesn't access the file itself.) flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file( 'client_secret.json', scopes=['https://www.googleapis.com/auth/drive.metadata.readonly']) # Required, 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( # Recommended, 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', # Optional, enable incremental authorization. Recommended as a best practice. include_granted_scopes='true', # Optional, if your application knows which user is trying to authenticate, it can use this # parameter to provide a hint to the Google Authentication Server. login_hint='[email protected]', # Optional, set prompt to 'consent' will prompt the user for consent prompt='consent')
Ruby
ใช้ไฟล์ client_secrets.json ที่คุณสร้างขึ้นเพื่อกำหนดค่าออบเจ็กต์ไคลเอ็นต์ในไฟล์ แอปพลิเคชัน เมื่อกำหนดค่าออบเจ็กต์ไคลเอ็นต์ คุณต้องระบุขอบเขตที่แอปพลิเคชันต้องใช้ พร้อมด้วย URL ไปยังปลายทางการตรวจสอบสิทธิ์ของแอปพลิเคชันของคุณ ซึ่งจะจัดการการตอบสนอง จากเซิร์ฟเวอร์ OAuth 2.0
ตัวอย่างเช่น โค้ดนี้จะขอเข้าถึงแบบอ่านอย่างเดียวและแบบออฟไลน์ Google ไดรฟ์:
require 'google/apis/drive_v3' require "googleauth" require 'googleauth/stores/redis_token_store' client_id = Google::Auth::ClientId.from_file('/path/to/client_secret.json') scope = 'https://www.googleapis.com/auth/drive.metadata.readonly' token_store = Google::Auth::Stores::RedisTokenStore.new(redis: Redis.new) authorizer = Google::Auth::WebUserAuthorizer.new(client_id, scope, token_store, '/oauth2callback')
แอปพลิเคชันของคุณจะใช้ออบเจ็กต์ไคลเอ็นต์เพื่อดำเนินการ OAuth 2.0 เช่น การสร้าง URL คำขอการให้สิทธิ์และการใช้โทเค็นเพื่อการเข้าถึงกับคำขอ HTTP
Node.js
ข้อมูลโค้ดต่อไปนี้จะสร้างออบเจ็กต์ google.auth.OAuth2
ซึ่งกำหนด
ในคำขอการให้สิทธิ์
ออบเจ็กต์ดังกล่าวใช้ข้อมูลจากไฟล์ client_secret.json เพื่อระบุแอปพลิเคชัน ถึง ขอสิทธิ์จากผู้ใช้เพื่อเรียกข้อมูลโทเค็นเพื่อการเข้าถึง คุณเปลี่ยนเส้นทางผู้ใช้ไปยังหน้าคำยินยอม วิธีสร้าง URL ของหน้าความยินยอม
const {google} = require('googleapis'); const crypto = require('crypto'); const express = require('express'); const session = require('express-session'); /** * 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 secure random state value. const state = crypto.randomBytes(32).toString('hex'); // Store state in the session req.session.state = state; // 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, // Include the state parameter to reduce the risk of CSRF attacks. state: state });
หมายเหตุสำคัญ - ระบบจะแสดงผล 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 การเปลี่ยนเส้นทางที่ได้รับอนุญาตสำหรับ โปรดทราบว่ารูปแบบ |
||||||
response_type |
จำเป็น
กำหนดว่าปลายทาง Google OAuth 2.0 ส่งรหัสการให้สิทธิ์กลับมาหรือไม่ ตั้งค่าพารามิเตอร์เป็น |
||||||
scope |
จำเป็น
ต คั่นด้วยช่องว่าง รายการขอบเขตที่ระบุทรัพยากรที่แอปพลิเคชันของคุณสามารถเข้าถึงได้ ในนามของผู้ใช้ ค่าเหล่านี้จะบอกหน้าจอความยินยอมที่ Google จะแสดงต่อ ผู้ใช้ ขอบเขตช่วยให้แอปพลิเคชันขอเข้าถึงเฉพาะทรัพยากรที่จำเป็นต้องใช้เท่านั้น ขณะเดียวกันก็ช่วยให้ผู้ใช้สามารถควบคุมปริมาณการเข้าถึงที่จะจำกัด แอปพลิเคชัน ดังนั้นจึงจะมีความสัมพันธ์แบบผกผันระหว่างจำนวนขอบเขตที่ขอ และแนวโน้มที่จะได้รับความยินยอมจากผู้ใช้ เราขอแนะนำให้แอปพลิเคชันของคุณขอสิทธิ์เข้าถึงขอบเขตการให้สิทธิ์ในบริบท หากเป็นไปได้ ขอสิทธิ์ในการเข้าถึงข้อมูลผู้ใช้ในบริบทต่างๆ ผ่าน การให้สิทธิ์ที่เพิ่มขึ้น เพื่อช่วยให้ผู้ใช้เข้าถึง ทำความเข้าใจว่าเหตุใดแอปพลิเคชันของคุณจึงต้องการสิทธิ์ในการเข้าถึง |
||||||
access_type |
แนะนำ
ระบุว่าแอปพลิเคชันของคุณสามารถรีเฟรชโทเค็นเพื่อการเข้าถึงได้หรือไม่เมื่อผู้ใช้อยู่
ที่เบราว์เซอร์ ค่าพารามิเตอร์ที่ถูกต้องคือ ตั้งค่าเป็น |
||||||
state |
แนะนำ
ระบุค่าสตริงที่แอปพลิเคชันใช้เพื่อรักษาสถานะระหว่าง
คำขอการให้สิทธิ์ และการตอบกลับของเซิร์ฟเวอร์การให้สิทธิ์
เซิร์ฟเวอร์จะแสดงผลค่าที่แน่นอนที่คุณส่งเป็นคู่ คุณสามารถใช้พารามิเตอร์นี้เพื่อวัตถุประสงค์หลายประการ เช่น เพื่อนําผู้ใช้ไปยัง
ทรัพยากรที่ถูกต้องในแอปพลิเคชัน การส่ง nonces และการลดคำขอข้ามเว็บไซต์
หน้าปลอมแปลง เนื่องจากคุณสามารถเดา |
||||||
include_granted_scopes |
ไม่บังคับ
อนุญาตให้แอปพลิเคชันใช้การให้สิทธิ์ที่เพิ่มขึ้นเพื่อขอสิทธิ์เข้าถึงเพิ่มเติม
ในบริบท หากคุณตั้งค่าของพารามิเตอร์นี้เป็น |
||||||
enable_granular_consent |
ไม่บังคับ
ค่าเริ่มต้นคือ เมื่อ Google เปิดใช้สิทธิ์แบบละเอียดสำหรับแอปพลิเคชัน พารามิเตอร์นี้จะไม่ จะส่งผลใดๆ ต่อคุณอีกต่อไป |
||||||
login_hint |
ไม่บังคับ
หากแอปพลิเคชันทราบว่าผู้ใช้ใดกำลังตรวจสอบสิทธิ์ แอปพลิเคชันจะใช้พารามิเตอร์นี้ได้ เพื่อให้คำแนะนำเกี่ยวกับเซิร์ฟเวอร์การตรวจสอบสิทธิ์ของ Google เซิร์ฟเวอร์จะใช้คำแนะนำเพื่อ ลดความซับซ้อนของขั้นตอนการเข้าสู่ระบบโดยกรอกข้อมูลในช่องอีเมลไว้ล่วงหน้าในแบบฟอร์มลงชื่อเข้าใช้หรือโดย ที่เลือกเซสชันการลงชื่อเข้าใช้หลายบัญชีที่เหมาะสม ตั้งค่าพารามิเตอร์เป็นอีเมลหรือตัวระบุ |
||||||
prompt |
ไม่บังคับ
รายการพรอมต์ที่คั่นด้วยช่องว่างซึ่งคำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่เพื่อนำเสนอแก่ผู้ใช้ หากไม่ ระบุพารามิเตอร์นี้ ผู้ใช้จะได้รับข้อความแจ้งในครั้งแรกที่โปรเจ็กต์ของคุณ ขอสิทธิ์เข้าถึง โปรดดู การแสดงข้อความแจ้งความยินยอมอีกครั้งเพื่อขอข้อมูลเพิ่มเติม โดยค่าที่เป็นไปได้มีดังนี้
|
ขั้นตอนที่ 2: เปลี่ยนเส้นทางไปยังเซิร์ฟเวอร์ OAuth 2.0 ของ Google
เปลี่ยนเส้นทางผู้ใช้ไปยังเซิร์ฟเวอร์ OAuth 2.0 ของ Google เพื่อเริ่มต้นการตรวจสอบสิทธิ์และ ขั้นตอนการให้สิทธิ์ โดยทั่วไปแล้ว ปัญหานี้จะเกิดขึ้นเมื่อแอปพลิเคชันของคุณจำเป็นต้องเข้าถึง ของ 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 = authorizer.get_authorization_url(login_hint: user_id, request: request)
- เปลี่ยนเส้นทางผู้ใช้ไปที่
auth_uri
Node.js
-
ใช้ URL
authorizationUrl
ที่สร้างขึ้นจากขั้นตอนที่ 1generateAuthUrl
วิธีขอสิทธิ์เข้าถึงจากเซิร์ฟเวอร์ OAuth 2.0 ของ Google -
เปลี่ยนเส้นทางผู้ใช้ไปที่
authorizationUrl
res.redirect(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 แบบฝังซึ่ง Google ไม่อนุญาต นโยบาย OAuth 2.0
Android
นักพัฒนาแอป Android อาจพบข้อความแสดงข้อผิดพลาดนี้เมื่อเปิดคำขอการให้สิทธิ์ใน
android.webkit.WebView
นักพัฒนาแอปควรใช้ไลบรารี Android แทน เช่น
Google Sign-In สำหรับ Android หรือ
AppAuth สำหรับ Android
นักพัฒนาเว็บอาจพบข้อผิดพลาดนี้เมื่อแอป Android เปิดเว็บลิงก์ทั่วไปใน User Agent ที่ฝังและผู้ใช้ไปยังปลายทางการให้สิทธิ์ OAuth 2.0 ของ Google จาก เว็บไซต์ของคุณ นักพัฒนาควรอนุญาตให้ลิงก์ทั่วไปเปิดในเครื่องจัดการลิงก์เริ่มต้นของ ซึ่งมีทั้ง ลิงก์แอป Android หรือแอปเบราว์เซอร์เริ่มต้น แท็บที่กำหนดเองของ 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 Organization สำหรับข้อมูลเพิ่มเติมเกี่ยวกับตัวเลือกการกำหนดค่านี้ โปรดดู ประเภทผู้ใช้ ในบทความช่วยเหลือการตั้งค่าหน้าจอขอความยินยอม OAuth
invalid_client
รหัสลับไคลเอ็นต์ OAuth ไม่ถูกต้อง ตรวจสอบ ไคลเอ็นต์ OAuth การกำหนดค่า รวมทั้งรหัสไคลเอ็นต์และข้อมูลลับที่ใช้สำหรับคำขอนี้
invalid_grant
เมื่อรีเฟรชโทเค็นเพื่อการเข้าถึงหรือใช้ การให้สิทธิ์ที่เพิ่มขึ้น โทเค็นอาจหมดอายุหรือ ใช้งานไม่ได้ ตรวจสอบสิทธิ์ผู้ใช้อีกครั้งและขอความยินยอมจากผู้ใช้เพื่อรับโทเค็นใหม่ หากคุณดำเนินการต่อ พบข้อผิดพลาดนี้ โปรดตรวจสอบว่าได้กำหนดค่าแอปพลิเคชันอย่างถูกต้อง และคุณ โดยใช้โทเค็นและพารามิเตอร์ที่ถูกต้องในคำขอ มิฉะนั้น บัญชีผู้ใช้ ถูกลบหรือปิดใช้งานไปแล้ว
redirect_uri_mismatch
redirect_uri
ที่ส่งผ่านในคำขอการให้สิทธิ์ไม่ตรงกับรายการที่ได้รับอนุญาต
URI การเปลี่ยนเส้นทางสำหรับรหัสไคลเอ็นต์ OAuth ตรวจสอบ URI การเปลี่ยนเส้นทางที่ได้รับอนุญาตใน
Google API Console Credentials page
พารามิเตอร์ redirect_uri
อาจอ้างถึงขั้นตอนนอกย่านความถี่ (OOB) ของ OAuth ที่
เลิกใช้งานแล้วและไม่มีการรองรับอีกต่อไป โปรดดู
คำแนะนำในการย้ายข้อมูลเพื่ออัปเดต
การผสานรวม
invalid_request
เกิดข้อผิดพลาดบางอย่างกับคำขอของคุณ ซึ่งอาจเกิดจากสาเหตุหลายประการ ดังนี้
- รูปแบบคำขอไม่ถูกต้อง
- คำขอไม่มีพารามิเตอร์ที่จำเป็น
- คำขอใช้วิธีการให้สิทธิ์ที่ Google ไม่รองรับ ยืนยัน OAuth จะใช้วิธีการผสานรวมที่แนะนำ
ขั้นตอนที่ 4: จัดการการตอบกลับของเซิร์ฟเวอร์ OAuth 2.0
เซิร์ฟเวอร์ OAuth 2.0 จะตอบสนองคำขอเข้าถึงแอปพลิเคชันของคุณโดยใช้ URL ที่ระบุ ในคำขอ
หากผู้ใช้อนุมัติคำขอเข้าถึง การตอบกลับจะมีรหัสการให้สิทธิ์ ถ้า ผู้ใช้ไม่อนุมัติคำขอ การตอบกลับมีข้อความแสดงข้อผิดพลาด รหัสการให้สิทธิ์หรือข้อความแสดงข้อผิดพลาดที่ส่งไปยังเว็บเซิร์ฟเวอร์จะปรากฏในการค้นหา ตามที่แสดงด้านล่าง
การตอบกลับข้อผิดพลาด:
https://oauth2.example.com/auth?error=access_denied
การตอบกลับรหัสการให้สิทธิ์
https://oauth2.example.com/auth?code=4/P7q7W91a-oMsCeLvIaQm6bTrgtp7
ตัวอย่างการตอบกลับของเซิร์ฟเวอร์ OAuth 2.0
คุณสามารถทดสอบขั้นตอนนี้ได้โดยคลิก ตัวอย่าง URL ต่อไปนี้ ที่ขอ สิทธิ์การอ่านอย่างเดียวเพื่อดูข้อมูลเมตาของไฟล์ใน Google ไดรฟ์
https://accounts.google.com/o/oauth2/v2/auth? scope=https%3A//www.googleapis.com/auth/drive.metadata.readonly& access_type=offline& include_granted_scopes=true& response_type=code& state=state_parameter_passthrough_value& redirect_uri=https%3A//oauth2.example.com/code& client_id=client_id
หลังจากเสร็จสิ้นขั้นตอน OAuth 2.0 แล้ว ระบบจะนำคุณไปยัง
http://localhost/oauth2callback
ซึ่งมีแนวโน้มที่จะให้ผล
404 NOT FOUND
เว้นแต่เครื่องของคุณเองจะส่งไฟล์ในที่อยู่นั้น
ขั้นตอนถัดไปจะให้รายละเอียดเพิ่มเติมเกี่ยวกับข้อมูลที่แสดงผลใน URI เมื่อผู้ใช้
เปลี่ยนเส้นทางกลับไปยังแอปพลิเคชันของคุณ
ขั้นตอนที่ 5: รหัสการให้สิทธิ์ของ Exchange สำหรับการรีเฟรชและการเข้าถึง โทเค็น
หลังจากที่เว็บเซิร์ฟเวอร์ได้รับรหัสการให้สิทธิ์ เว็บเซิร์ฟเวอร์จะแลกเปลี่ยนรหัสการให้สิทธิ์ได้ สำหรับโทเค็นเพื่อการเข้าถึง
PHP
หากต้องการแลกเปลี่ยนรหัสการให้สิทธิ์สำหรับโทเค็นเพื่อการเข้าถึง ให้ใช้ authenticate
วิธีการ:
$client->authenticate($_GET['code']);
คุณสามารถเรียกโทเค็นเพื่อการเข้าถึงได้โดยใช้เมธอด getAccessToken
ดังนี้
$access_token = $client->getAccessToken();
Python
ในหน้า Callback ให้ใช้ไลบรารี 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
ในหน้า Callback ให้ใช้ไลบรารี googleauth
เพื่อยืนยันเซิร์ฟเวอร์การให้สิทธิ์
คำตอบ ใช้เมธอด authorizer.handle_auth_callback_deferred
เพื่อบันทึก
รหัสการให้สิทธิ์ของคุณและเปลี่ยนเส้นทางไปยัง URL ที่ขอสิทธิ์เดิม ช่วงเวลานี้
เลื่อนการแลกเปลี่ยนโค้ดด้วยการซ่อนผลลัพธ์ไว้ในเซสชันของผู้ใช้ชั่วคราว
target_url = Google::Auth::WebUserAuthorizer.handle_auth_callback_deferred(request) redirect target_url
Node.js
หากต้องการแลกเปลี่ยนรหัสการให้สิทธิ์สำหรับโทเค็นเพื่อการเข้าถึง ให้ใช้ getToken
วิธีการ:
const url = require('url'); // Receive the callback from Google's OAuth 2.0 server. app.get('/oauth2callback', async (req, res) => { 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 if (q.state !== req.session.state) { //check state value console.log('State mismatch. Possible CSRF attack'); res.end('State mismatch. Possible CSRF attack'); } else { // 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
ในคำขอแรกที่ส่งไปยังแท็ก
เซิร์ฟเวอร์การให้สิทธิ์
คำตอบจะมีช่องต่อไปนี้
ช่อง | |
---|---|
access_token |
โทเค็นที่แอปพลิเคชันของคุณส่งเพื่อให้สิทธิ์คำขอ Google API |
expires_in |
อายุการใช้งานที่เหลือของโทเค็นเพื่อการเข้าถึงเป็นวินาที |
refresh_token |
โทเค็นที่คุณสามารถใช้เพื่อรับโทเค็นเพื่อการเข้าถึงใหม่ โทเค็นการรีเฟรชจะใช้ได้จนถึง
ผู้ใช้เพิกถอนการเข้าถึง
และระบบจะแสดงช่องนี้ในคำตอบนี้เท่านั้น หากคุณตั้งค่า access_type
ไปยัง offline ในคำขอเริ่มต้นที่ส่งไปยังเซิร์ฟเวอร์การให้สิทธิ์ของ Google
|
scope |
ขอบเขตการเข้าถึงที่ access_token อนุญาตซึ่งแสดงเป็นรายการ
สตริงที่คั่นด้วยช่องว่างและคำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ |
token_type |
ประเภทของโทเค็นที่แสดงผล ปัจจุบัน ค่าของช่องนี้จะกำหนดไว้เป็น
Bearer |
ข้อมูลโค้ดต่อไปนี้แสดงตัวอย่างคำตอบ
{ "access_token": "1/fFAGRNJru1FTz70BzhT3Zg", "expires_in": 3920, "token_type": "Bearer", "scope": "https://www.googleapis.com/auth/drive.metadata.readonly", "refresh_token": "1//xEoDL4iW3cxlI7yDbSRFYNG01kVKM2C-259HOF2aQbI" }
ข้อผิดพลาด
เมื่อแลกเปลี่ยนรหัสการให้สิทธิ์สำหรับโทเค็นเพื่อการเข้าถึง คุณอาจพบสิ่งต่อไปนี้ แทนที่จะเป็นคำตอบที่คาดไว้ รหัสข้อผิดพลาดที่พบบ่อยและวิธีแก้ปัญหาที่แนะนำมีดังนี้ ที่ระบุไว้ด้านล่าง
invalid_grant
รหัสการให้สิทธิ์ที่ระบุไม่ถูกต้องหรืออยู่ในรูปแบบที่ไม่ถูกต้อง ขอรหัสใหม่ภายในวันที่ การเริ่มกระบวนการ OAuth ใหม่เพื่อแสดงข้อความขอความยินยอมจากผู้ใช้ อีกครั้ง
การเรียกใช้ Google APIs
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 เวอร์ชัน 3 ให้ทำดังนี้from googleapiclient.discovery import build drive = build('drive', 'v2', credentials=credentials)
- ส่งคำขอไปยังบริการ API โดยใช้
อินเทอร์เฟซจากออบเจ็กต์บริการ
ตัวอย่างเช่น หากต้องการแสดงไฟล์ใน Google ไดรฟ์ของผู้ใช้ที่ผ่านการตรวจสอบสิทธิ์ ให้ทำดังนี้
files = drive.files().list().execute()
Ruby
หลังจากได้รับโทเค็นเพื่อการเข้าถึงแล้ว แอปพลิเคชันของคุณจะใช้โทเค็นนั้นเพื่อสร้างคำขอ API ได้ ในนามของบัญชีผู้ใช้หรือบัญชีบริการที่ระบุ ใช้ข้อมูลเข้าสู่ระบบของการให้สิทธิ์เฉพาะผู้ใช้ เพื่อสร้างออบเจ็กต์บริการสำหรับ API ที่คุณต้องการเรียกใช้ จากนั้นใช้ออบเจ็กต์ดังกล่าวเพื่อสร้าง คำขอ API ที่ได้รับอนุญาต
- สร้างออบเจ็กต์บริการสำหรับ API ที่คุณต้องการเรียกใช้
เช่น หากต้องการเรียกใช้ Drive API เวอร์ชัน 3 ให้ทำดังนี้
drive = Google::Apis::DriveV3::DriveService.new
- ตั้งค่าข้อมูลเข้าสู่ระบบสำหรับบริการดังนี้
drive.authorization = credentials
- ส่งคำขอไปยังบริการ API โดยใช้
อินเทอร์เฟซ
ที่ได้จากออบเจ็กต์บริการ
ตัวอย่างเช่น หากต้องการแสดงไฟล์ใน Google ไดรฟ์ของผู้ใช้ที่ผ่านการตรวจสอบสิทธิ์ ให้ทำดังนี้
files = drive.list_files
หรือจะระบุการให้สิทธิ์ตามวิธีการโดยการระบุ
พารามิเตอร์ options
ไปยังเมธอด:
files = drive.list_files(options: { authorization: credentials })
Node.js
หลังจากได้รับโทเค็นเพื่อการเข้าถึงและตั้งค่าเป็นออบเจ็กต์ OAuth2
แล้ว ให้ใช้ออบเจ็กต์
เพื่อเรียกใช้ Google APIs แอปพลิเคชันของคุณสามารถใช้โทเค็นนั้นเพื่อให้สิทธิ์คำขอ API ในนามของ
บัญชีผู้ใช้หรือบัญชีบริการหนึ่งๆ สร้างออบเจ็กต์บริการสำหรับ API ที่คุณต้องการเรียกใช้
const { google } = require('googleapis'); // Example of using Google Drive API to list filenames in user's Drive. const drive = google.drive('v3'); drive.files.list({ auth: oauth2Client, pageSize: 10, fields: 'nextPageToken, files(id, name)', }, (err1, res1) => { if (err1) return console.log('The API returned an error: ' + err1); const files = res1.data.files; if (files.length) { console.log('Files:'); files.map((file) => { console.log(`${file.name} (${file.id})`); }); } else { console.log('No files found.'); } });
HTTP/REST
หลังจากแอปพลิเคชันได้รับโทเค็นเพื่อการเข้าถึงแล้ว คุณจะสามารถใช้โทเค็นดังกล่าวเพื่อเรียกไปยัง
API ในนามของ
บัญชีผู้ใช้ หากได้มีการให้สิทธิ์สำหรับขอบเขตการเข้าถึงที่ API กำหนด วิธีการคือ
โทเค็นเพื่อการเข้าถึงในคำขอที่ส่งไปยัง API โดยรวมคำค้นหา access_token
หรือค่า Bearer
ของส่วนหัว HTTP Authorization
เมื่อทำได้
ส่วนหัว HTTP ดีกว่า เนื่องจากสตริงการค้นหามักจะมองเห็นได้ในบันทึกของเซิร์ฟเวอร์ ส่วนใหญ่
คุณสามารถใช้ไลบรารีของไคลเอ็นต์เพื่อตั้งค่าการเรียก Google APIs (เช่น เมื่อ
การเรียกใช้ Drive Files API)
คุณสามารถทดลองใช้ Google API ทั้งหมดและดูขอบเขตของ API เหล่านี้ได้ที่ OAuth 2.0 Playground
ตัวอย่าง HTTP GET
การเรียกไปยัง
drive.files
ปลายทาง (Drive Files API) โดยใช้ HTTP Authorization: Bearer
ส่วนหัวอาจมีลักษณะดังต่อไปนี้ โปรดทราบว่าคุณต้องระบุโทเค็นเพื่อการเข้าถึงของคุณเอง
GET /drive/v2/files HTTP/1.1 Host: www.googleapis.com Authorization: Bearer access_token
นี่คือการเรียก API เดียวกันสำหรับผู้ใช้ที่ตรวจสอบสิทธิ์แล้วโดยใช้ access_token
พารามิเตอร์สตริงการค้นหา:
GET https://www.googleapis.com/drive/v2/files?access_token=access_token
ตัวอย่างของ curl
ทดสอบคำสั่งเหล่านี้ได้ด้วยแอปพลิเคชันบรรทัดคำสั่ง curl
นี่คือ
ตัวอย่างที่ใช้ตัวเลือกส่วนหัว HTTP (แนะนำ)
curl -H "Authorization: Bearer access_token" https://www.googleapis.com/drive/v2/files
หรือใช้ตัวเลือกพารามิเตอร์สตริงคำค้นหาดังนี้
curl https://www.googleapis.com/drive/v2/files?access_token=access_token
ตัวอย่างที่สมบูรณ์
ตัวอย่างต่อไปนี้พิมพ์รายการไฟล์ในรูปแบบ JSON ใน Google ไดรฟ์ของผู้ใช้หลังจาก ผู้ใช้ตรวจสอบสิทธิ์และให้ความยินยอมแก่แอปพลิเคชันในการเข้าถึงข้อมูลเมตาในไดรฟ์ของผู้ใช้
PHP
วิธีเรียกใช้ตัวอย่างนี้
- ใน API Consoleให้เพิ่ม URL ของเครื่องภายใน
รายการ URL เปลี่ยนเส้นทาง เช่น เพิ่ม
http://localhost:8080
- สร้างไดเรกทอรีใหม่และทำการเปลี่ยนแปลง ดังตัวอย่างต่อไปนี้
mkdir ~/php-oauth2-example cd ~/php-oauth2-example
- ติดตั้งไคลเอ็นต์ Google API
Library สำหรับ 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'])) { // Generate and set state value $state = bin2hex(random_bytes(16)); $client->setState($state); $_SESSION['state'] = $state; $auth_url = $client->createAuthUrl(); header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL)); } else { // Check the state value if (!isset($_GET['state']) || $_GET['state'] !== $_SESSION['state']) { die('State mismatch. Possible CSRF attack.'); } $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="/https/developers.google.com/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="/https/developers.google.com/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="/https/developers.google.com/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="/https/developers.google.com/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="/https/developers.google.com/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="/https/developers.google.com/test">test the ' + ' API request</a> again, you should go back to the auth flow.' + '</td></tr></table>') if __name__ == '__main__': # When running locally, disable OAuthlib's HTTPs verification. # ACTION ITEM for developers: # When running in production *do not* leave this option enabled. os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1' # Specify a hostname and port that are set as a valid redirect URI # for your API project in the Google API Console. app.run('localhost', 8080, debug=True)
Ruby
ตัวอย่างนี้ใช้เฟรมเวิร์ก Sinatra
require 'google/apis/drive_v3' require 'sinatra' require 'googleauth' require 'googleauth/stores/redis_token_store' configure do enable :sessions set :client_id, Google::Auth::ClientId.from_file('/path/to/client_secret.json') set :scope, Google::Apis::DriveV3::AUTH_DRIVE_METADATA_READONLY set :token_store, Google::Auth::Stores::RedisTokenStore.new(redis: Redis.new) set :authorizer, Google::Auth::WebUserAuthorizer.new(settings.client_id, settings.scope, settings.token_store, '/oauth2callback') end get '/' do user_id = settings.client_id.id credentials = settings.authorizer.get_credentials(user_id, request) if credentials.nil? redirect settings.authorizer.get_authorization_url(login_hint: user_id, request: request) end drive = Google::Apis::DriveV3::DriveService.new files = drive.list_files(options: { authorization: credentials }) "<pre>#{JSON.pretty_generate(files.to_h)}</pre>" end get '/oauth2callback' do target_url = Google::Auth::WebUserAuthorizer.handle_auth_callback_deferred(request) redirect target_url end
Node.js
วิธีเรียกใช้ตัวอย่างนี้
-
ใน 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'); const crypto = require('crypto'); const express = require('express'); const session = require('express-session'); /** * 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' ]; /* 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 app = express(); app.use(session({ secret: 'your_secure_secret_key', // Replace with a strong secret resave: false, saveUninitialized: false, })); // Example on redirecting user to Google's OAuth 2.0 server. app.get('/', async (req, res) => { // Generate a secure random state value. const state = crypto.randomBytes(32).toString('hex'); // Store state in the session req.session.state = state; // 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, // Include the state parameter to reduce the risk of CSRF attacks. state: state }); res.redirect(authorizationUrl); }); // Receive the callback from Google's OAuth 2.0 server. app.get('/oauth2callback', async (req, res) => { // 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 if (q.state !== req.session.state) { //check state value console.log('State mismatch. Possible CSRF attack'); res.end('State mismatch. Possible CSRF attack'); } 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 app.get('/revoke', async (req, res) => { // 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(); }); const server = http.createServer(app); server.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: state = str(uuid.uuid4()) flask.session['state'] = state auth_uri = ('https://accounts.google.com/o/oauth2/v2/auth?response_type=code' '&client_id={}&redirect_uri={}&scope={}&state={}').format(CLIENT_ID, REDIRECT_URI, SCOPE, state) return flask.redirect(auth_uri) else: if 'state' not in flask.request.args or flask.request.args['state'] != flask.session['state']: return 'State mismatch. Possible CSRF attack.', 400 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 สำหรับ โดเมน โฮสต์ เส้นทาง ข้อความค้นหา สคีม และ userinfo ดังที่ระบุไว้ด้านล่าง
กฎการตรวจสอบความถูกต้อง | |
---|---|
รูปแบบ |
URI การเปลี่ยนเส้นทางต้องใช้รูปแบบ HTTPS ไม่ใช่ HTTP ธรรมดา URI ของ Localhost (รวมถึง URI ของที่อยู่ IP localhost) จะได้รับการยกเว้นจากกฎนี้ |
โฮสต์ |
โฮสต์จะเป็นที่อยู่ IP ดิบไม่ได้ ที่อยู่ IP ของ Localhost จะได้รับการยกเว้นจากกฎนี้ |
โดเมน |
“googleusercontent.com” ไม่ได้goo.gl ) เว้นแต่จะ
แอปดังกล่าวเป็นเจ้าของโดเมน นอกจากนี้หากแอปซึ่งเป็นเจ้าของโดเมนย่อกว่าเลือกที่จะ
เปลี่ยนเส้นทางไปยังโดเมนนั้น URI การเปลี่ยนเส้นทางนั้นต้องมี
“/google-callback/” ในเส้นทางหรือลงท้ายด้วย
“/google-callback” |
ข้อมูลผู้ใช้ |
URI การเปลี่ยนเส้นทางต้องไม่มีคอมโพเนนต์ย่อย userinfo |
เส้นทาง |
URI การเปลี่ยนเส้นทางต้องไม่มี Path Traversal (หรือที่เรียกว่าการย้อนกลับของไดเรกทอรี)
ซึ่งจะแสดงด้วย |
การค้นหา |
URI การเปลี่ยนเส้นทางต้องไม่มี การเปลี่ยนเส้นทางแบบเปิด |
เศษส่วน |
URI การเปลี่ยนเส้นทางต้องไม่มีคอมโพเนนต์ส่วนย่อย |
อักขระ |
URI การเปลี่ยนเส้นทางต้องไม่มีอักขระบางตัว ได้แก่
|
การให้สิทธิ์ที่เพิ่มขึ้น
ในโปรโตคอล OAuth 2.0 แอปของคุณจะขอสิทธิ์ในการเข้าถึงทรัพยากร ที่ระบุตามขอบเขต การขอการให้สิทธิ์ถือเป็นแนวทางปฏิบัติที่ดีที่สุดในการสร้างประสบการณ์ของผู้ใช้ ได้ในเวลาที่ต้องการ เพื่อให้สามารถปฏิบัติได้จริง เซิร์ฟเวอร์การให้สิทธิ์ของ Google สนับสนุนการให้สิทธิ์ที่เพิ่มขึ้น ฟีเจอร์นี้ช่วยให้คุณขอขอบเขตได้ตามต้องการ และ หากผู้ใช้ให้สิทธิ์สำหรับขอบเขตใหม่ จะแสดงรหัสการให้สิทธิ์ที่อาจ แลกเปลี่ยนเป็นโทเค็นที่มีขอบเขตทั้งหมดที่ผู้ใช้ได้ให้สิทธิ์โปรเจ็กต์ไว้
เช่น แอปที่ให้ผู้ใช้ได้ทดลองใช้แทร็กเพลงและสร้างมิกซ์อาจต้องใช้แทร็กเพลงน้อยมาก ณ เวลาที่ลงชื่อเข้าใช้ อาจจะมีอะไรมากกว่าชื่อของบุคคลที่ลงชื่อเข้าใช้ อย่างไรก็ตาม การบันทึกมิกซ์ที่เสร็จสมบูรณ์ต้องมีสิทธิ์เข้าถึง Google ไดรฟ์ ผู้คนส่วนใหญ่จะพบ เป็นเรื่องธรรมดาหากลูกค้าขอเข้าถึง Google ไดรฟ์ในขณะที่แอปนั้น ต้องการ
ในกรณีนี้ ขณะลงชื่อเข้าใช้ แอปอาจขอ openid
และ
profile
ขอบเขตเพื่อดำเนินการลงชื่อเข้าใช้ขั้นพื้นฐาน จากนั้นจึงขอ
https://www.googleapis.com/auth/drive.file
ขอบเขต ณ เวลาที่ส่งคำขอแรกเพื่อบันทึก
มิกซ์
หากต้องการใช้การให้สิทธิ์เพิ่มเติม คุณต้องทําตามขั้นตอนปกติในการขอสิทธิ์เข้าถึง แต่โปรดตรวจสอบว่าคำขอการให้สิทธิ์มีขอบเขตที่ได้รับสิทธิ์ก่อนหน้านี้แล้ว ช่วงเวลานี้ จะช่วยให้แอปของคุณหลีกเลี่ยงการจัดการโทเค็นเพื่อการเข้าถึงหลายรายการได้
กฎต่อไปนี้ใช้กับโทเค็นเพื่อการเข้าถึงที่ได้จากการให้สิทธิ์ที่เพิ่มขึ้น
- โทเค็นนี้สามารถใช้เพื่อเข้าถึงทรัพยากรที่เกี่ยวข้องกับขอบเขตใดๆ ใน การให้สิทธิ์แบบใหม่ที่ผสมผสานกัน
- เมื่อคุณใช้โทเค็นการรีเฟรชสำหรับการให้สิทธิ์แบบรวมเพื่อรับโทเค็นเพื่อการเข้าถึง
โทเค็นเพื่อการเข้าถึงแสดงถึงการให้สิทธิ์แบบรวม ซึ่งสามารถใช้เพื่อ
รวม
scope
ค่าไว้ในคำตอบ - การให้สิทธิ์รวมจะรวมขอบเขตทั้งหมดที่ผู้ใช้ให้กับโปรเจ็กต์ API ไว้ หากมีการของบประมาณสนับสนุนจากลูกค้ารายอื่น ตัวอย่างเช่น หากผู้ใช้ให้สิทธิ์การเข้าถึง ขอบเขตหนึ่งโดยใช้ไคลเอ็นต์บนเดสก์ท็อปของแอปพลิเคชัน แล้วให้สิทธิ์อีกขอบเขตหนึ่งแก่ขอบเขตเดียวกัน ผ่านไคลเอ็นต์มือถือ การให้สิทธิ์รวมจะรวมทั้งสองขอบเขต
- หากคุณเพิกถอนโทเค็นที่แสดงการให้สิทธิ์แบบรวม คุณจะสามารถเข้าถึงโทเค็นดังกล่าวทั้งหมด ขอบเขตการให้สิทธิ์ในนามของผู้ใช้ที่เชื่อมโยงจะถูกเพิกถอนพร้อมกัน
ตัวอย่างรหัสเฉพาะภาษาในขั้นตอนที่ 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 ระบบจะรีเฟรชออบเจ็กต์ไคลเอ็นต์ โทเค็นเพื่อการเข้าถึงเท่าที่จำเป็น ตราบใดที่คุณกำหนดค่าอ็อบเจกต์นั้นสำหรับการเข้าถึงแบบออฟไลน์
- หากไม่ได้ใช้ไลบรารีของไคลเอ็นต์ คุณต้องตั้งค่า
access_type
HTTP พารามิเตอร์การค้นหาเป็นoffline
เมื่อ เปลี่ยนเส้นทางผู้ใช้ไปยัง เซิร์ฟเวอร์ OAuth 2.0 ของ Google ในกรณีดังกล่าว เซิร์ฟเวอร์การให้สิทธิ์ของ Google จะแสดงผล รีเฟรชโทเค็นเมื่อคุณแลกเปลี่ยนการให้สิทธิ์ สำหรับโทเค็นเพื่อการเข้าถึง จากนั้น หากโทเค็นเพื่อการเข้าถึงหมดอายุ (หรือเมื่อเวลาอื่น) คุณ สามารถใช้โทเค็นการรีเฟรชเพื่อรับโทเค็นเพื่อการเข้าถึงใหม่ได้
การขอสิทธิ์เข้าถึงแบบออฟไลน์เป็นสิ่งจำเป็นสำหรับแอปพลิเคชันที่ต้องใช้เพื่อเข้าถึง
API เมื่อผู้ใช้ไม่มีอยู่ ตัวอย่างเช่น แอปที่ให้บริการสำรองข้อมูล หรือ
จะทำงานในเวลาที่กำหนดไว้ล่วงหน้าต้องสามารถรีเฟรชโทเค็นเพื่อการเข้าถึงเมื่อ
ไม่มีผู้ใช้ รูปแบบการเข้าถึงเริ่มต้นเรียกว่า online
เว็บแอปพลิเคชันฝั่งเซิร์ฟเวอร์ แอปพลิเคชันที่ติดตั้ง และอุปกรณ์ทั้งหมดจะได้รับโทเค็นการรีเฟรช ในระหว่างขั้นตอนการให้สิทธิ์ โดยทั่วไปโทเค็นการรีเฟรชจะไม่ใช้ในฝั่งไคลเอ็นต์ (JavaScript)
PHP
หากแอปพลิเคชันของคุณต้องการเข้าถึง Google API แบบออฟไลน์ ให้ตั้งค่าประเภทการเข้าถึงไคลเอ็นต์ API เป็น
offline
:
$client->setAccessType("offline");
หลังจากที่ผู้ใช้ให้สิทธิ์เข้าถึงแบบออฟไลน์แก่ขอบเขตที่ขอแล้ว คุณจะใช้ API ต่อไปได้ ที่จะเข้าถึง Google APIs ในนามของผู้ใช้เมื่อผู้ใช้ออฟไลน์ ออบเจ็กต์ไคลเอ็นต์ จะรีเฟรชโทเค็นเพื่อการเข้าถึง ตามความจำเป็น
Python
ใน Python ให้ตั้งค่าอาร์กิวเมนต์คีย์เวิร์ด access_type
เป็น offline
เพื่อให้
คุณจะรีเฟรชโทเค็นเพื่อการเข้าถึงได้โดยไม่ต้องแสดงข้อความแจ้งผู้ใช้อีกครั้ง
สิทธิ์ เป็นไปได้อย่างมากที่ access_type
จะไม่ใช่คีย์เวิร์ดอย่างเดียว
ที่คุณตั้งไว้ ดังที่แสดงในตัวอย่างด้านล่าง
authorization_url, state = flow.authorization_url( # Enable offline access so that you can refresh an access token without # re-prompting the user for permission. Recommended for web server apps. access_type='offline', # Enable incremental authorization. Recommended as a best practice. include_granted_scopes='true')
หลังจากที่ผู้ใช้ให้สิทธิ์เข้าถึงแบบออฟไลน์แก่ขอบเขตที่ขอแล้ว คุณจะใช้ API ต่อไปได้ ที่จะเข้าถึง Google APIs ในนามของผู้ใช้เมื่อผู้ใช้ออฟไลน์ ออบเจ็กต์ไคลเอ็นต์ จะรีเฟรชโทเค็นเพื่อการเข้าถึง ตามความจำเป็น
Ruby
หากแอปพลิเคชันของคุณต้องการเข้าถึง Google API แบบออฟไลน์ ให้ตั้งค่าประเภทการเข้าถึงไคลเอ็นต์ API เป็น
offline
:
auth_client.update!( :additional_parameters => {"access_type" => "offline"} )
หลังจากที่ผู้ใช้ให้สิทธิ์เข้าถึงแบบออฟไลน์แก่ขอบเขตที่ขอแล้ว คุณจะใช้ API ต่อไปได้ ที่จะเข้าถึง Google APIs ในนามของผู้ใช้เมื่อผู้ใช้ออฟไลน์ ออบเจ็กต์ไคลเอ็นต์ จะรีเฟรชโทเค็นเพื่อการเข้าถึง ตามความจำเป็น
Node.js
หากแอปพลิเคชันของคุณต้องการเข้าถึง Google API แบบออฟไลน์ ให้ตั้งค่าประเภทการเข้าถึงไคลเอ็นต์ API เป็น
offline
:
const authorizationUrl = oauth2Client.generateAuthUrl({ // 'online' (default) or 'offline' (gets refresh_token) access_type: 'offline', /** Pass in the scopes array defined above. * Alternatively, if only one scope is needed, you can pass a scope URL as a string */ scope: scopes, // Enable incremental authorization. Recommended as a best practice. include_granted_scopes: true });
หลังจากที่ผู้ใช้ให้สิทธิ์เข้าถึงแบบออฟไลน์แก่ขอบเขตที่ขอแล้ว คุณจะใช้ API ต่อไปได้ ที่จะเข้าถึง Google APIs ในนามของผู้ใช้เมื่อผู้ใช้ออฟไลน์ ออบเจ็กต์ไคลเอ็นต์ จะรีเฟรชโทเค็นเพื่อการเข้าถึง ตามความจำเป็น
โทเค็นเพื่อการเข้าถึงหมดอายุ ไลบรารีนี้จะใช้โทเค็นการรีเฟรชโดยอัตโนมัติเพื่อรับสิทธิ์เข้าถึงใหม่ หากโทเค็นกำลังจะหมดอายุ วิธีง่ายๆ ที่ช่วยให้มั่นใจว่าคุณเก็บโทเค็นล่าสุดไว้อยู่เสมอ คือการใช้เหตุการณ์โทเค็น
oauth2Client.on('tokens', (tokens) => { if (tokens.refresh_token) { // store the refresh_token in your secure persistent database console.log(tokens.refresh_token); } console.log(tokens.access_token); });
เหตุการณ์โทเค็นนี้จะเกิดขึ้นในการให้สิทธิ์ครั้งแรกเท่านั้น และคุณจะต้องตั้งค่า
access_type
ไปยัง offline
เมื่อโทรหา generateAuthUrl
เพื่อรับโทเค็นการรีเฟรช หากคุณให้สิทธิ์ที่จำเป็นแก่แอปแล้ว
โดยไม่ตั้งค่าข้อจำกัดที่เหมาะสมสำหรับการรับโทเค็นการรีเฟรช คุณจะต้อง
ให้สิทธิ์แอปพลิเคชันอีกครั้งเพื่อรับโทเค็นการรีเฟรชใหม่
หากต้องการตั้งค่า refresh_token
ภายหลัง ให้ใช้เมธอด setCredentials
ดังนี้
oauth2Client.setCredentials({ refresh_token: `STORED_REFRESH_TOKEN` });
เมื่อไคลเอ็นต์มีโทเค็นการรีเฟรช ระบบจะรับและรีเฟรชโทเค็นเพื่อการเข้าถึงโดยอัตโนมัติ ในการเรียก API ครั้งถัดไป
HTTP/REST
หากต้องการรีเฟรชโทเค็นเพื่อการเข้าถึง แอปพลิเคชันจะส่ง HTTPS POST
ไปยังเซิร์ฟเวอร์การให้สิทธิ์ของ Google (https://oauth2.googleapis.com/token
) ซึ่ง
ประกอบด้วยพารามิเตอร์ต่อไปนี้
ช่อง | |
---|---|
client_id |
รหัสไคลเอ็นต์ที่ได้รับจาก API Console |
client_secret |
รหัสลับไคลเอ็นต์ที่ได้รับจาก API Console |
grant_type |
อาส
ที่มีคำจำกัดความใน
OAuth 2.0
ต้องกำหนดค่าของช่องนี้เป็น refresh_token |
refresh_token |
โทเค็นการรีเฟรชที่แสดงผลจากการแลกเปลี่ยนรหัสการให้สิทธิ์ |
ข้อมูลโค้ดต่อไปนี้แสดงตัวอย่างคำขอ
POST /token HTTP/1.1 Host: oauth2.googleapis.com Content-Type: application/x-www-form-urlencoded client_id=your_client_id& client_secret=your_client_secret& refresh_token=refresh_token& grant_type=refresh_token
หากผู้ใช้ยังไม่ได้เพิกถอนการเข้าถึงที่ให้แก่แอปพลิเคชัน เซิร์ฟเวอร์โทเค็น แสดงผลออบเจ็กต์ JSON ที่มีโทเค็นเพื่อการเข้าถึงใหม่ ข้อมูลโค้ดต่อไปนี้แสดงตัวอย่าง การตอบกลับ:
{ "access_token": "1/fFAGRNJru1FTz70BzhT3Zg", "expires_in": 3920, "scope": "https://www.googleapis.com/auth/drive.metadata.readonly", "token_type": "Bearer" }
โปรดทราบว่าการออกโทเค็นการรีเฟรชมีขีดจำกัด 1 ขีดจำกัดต่อ ชุดค่าผสมของลูกค้า/ผู้ใช้ และอีกชุดหนึ่งต่อผู้ใช้สำหรับลูกค้าทั้งหมด คุณควรบันทึกโทเค็นการรีเฟรช ในพื้นที่เก็บข้อมูลระยะยาวและใช้งานต่อไปตราบเท่าที่ยังใช้ได้ หากแอปพลิเคชันของคุณ ส่งคำขอโทเค็นการรีเฟรชมากเกินไป โทเค็นอาจเกินขีดจำกัดเหล่านี้ ซึ่งในกรณีนี้โทเค็นการรีเฟรชเก่า จะหยุดทำงาน
การเพิกถอนโทเค็น
ในบางกรณี ผู้ใช้อาจต้องการเพิกถอนสิทธิ์เข้าถึงแอปพลิเคชัน ผู้ใช้สามารถเพิกถอนสิทธิ์เข้าถึงได้ โดยไปที่ การตั้งค่าบัญชี โปรดดู ลบ ส่วนการเข้าถึงเว็บไซต์หรือแอปของเว็บไซต์บุคคลที่สามและ แอปที่มีสิทธิ์เข้าถึงบัญชีของคุณ สำหรับข้อมูลเพิ่มเติมได้
นอกจากนี้ แอปพลิเคชันยังอาจเพิกถอนสิทธิ์เข้าถึงที่ให้ไว้ทางโปรแกรมได้อีกด้วย การเพิกถอนแบบเป็นโปรแกรมมีความสำคัญในกรณีที่ผู้ใช้ยกเลิกการสมัคร นำ หรือทรัพยากร 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
กลับมา
ที่มีรหัสข้อผิดพลาด
การใช้การป้องกันแบบครอบคลุมหลายบริการ
ขั้นตอนเพิ่มเติมที่คุณควรทำเพื่อปกป้องผู้ใช้ของคุณ บัญชีกำลังใช้ข้ามบัญชี ป้องกันโดยใช้บริการการป้องกันแบบครอบคลุมหลายบริการของ Google บริการนี้ช่วยให้คุณ สมัครรับการแจ้งเตือนเกี่ยวกับการดำเนินการด้านความปลอดภัย ซึ่งจะให้ข้อมูลเกี่ยวกับแอปพลิเคชันของคุณเกี่ยวกับ การเปลี่ยนแปลงที่สำคัญในบัญชีผู้ใช้ จากนั้นคุณสามารถใช้ข้อมูลดังกล่าวเพื่อดำเนินการต่างๆ โดย วิธีตัดสินใจตอบสนองต่อเหตุการณ์
ตัวอย่างประเภทเหตุการณ์ที่บริการการป้องกันแบบครอบคลุมหลายบริการของ Google ส่งไปยังแอปของคุณ ได้แก่
-
https://schemas.openid.net/secevent/risc/event-type/sessions-revoked
-
https://schemas.openid.net/secevent/oauth/event-type/token-revoked
-
https://schemas.openid.net/secevent/risc/event-type/account-disabled
โปรดดู ปกป้องบัญชีผู้ใช้ด้วยหน้าการป้องกันแบบครอบคลุมหลายบริการ ดูข้อมูลเพิ่มเติมเกี่ยวกับวิธีใช้การป้องกันแบบครอบคลุมหลายบริการและรายการเหตุการณ์ทั้งหมดที่มี