เอกสารนี้อธิบายวิธีที่แอปพลิเคชันเว็บเซิร์ฟเวอร์ใช้ไลบรารีของไคลเอ็นต์ 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('hint@example.com'); // 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='hint@example.com', # 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="/authorize">authorize</a> before ' + 'testing the code to revoke credentials.') credentials = google.oauth2.credentials.Credentials( **flask.session['credentials']) revoke = requests.post('https://oauth2.googleapis.com/revoke', params={'token': credentials.token}, headers = {'content-type': 'application/x-www-form-urlencoded'}) status_code = getattr(revoke, 'status_code') if status_code == 200: return('Credentials successfully revoked.' + print_index_table()) else: return('An error occurred.' + print_index_table()) @app.route('/clear') def clear_credentials(): if 'credentials' in flask.session: del flask.session['credentials'] return ('Credentials have been cleared.<br><br>' + print_index_table()) def credentials_to_dict(credentials): return {'token': credentials.token, 'refresh_token': credentials.refresh_token, 'token_uri': credentials.token_uri, 'client_id': credentials.client_id, 'client_secret': credentials.client_secret, 'scopes': credentials.scopes} def print_index_table(): return ('<table>' + '<tr><td><a href="/test">Test an API request</a></td>' + '<td>Submit an API request and see a formatted JSON response. ' + ' Go through the authorization flow if there are no stored ' + ' credentials for the user.</td></tr>' + '<tr><td><a href="/authorize">Test the auth flow directly</a></td>' + '<td>Go directly to the authorization flow. If there are stored ' + ' credentials, you still might not be prompted to reauthorize ' + ' the application.</td></tr>' + '<tr><td><a href="/revoke">Revoke current credentials</a></td>' + '<td>Revoke the access token associated with the current user ' + ' session. After revoking credentials, if you go to the test ' + ' page, you should see an <code>invalid_grant</code> error.' + '</td></tr>' + '<tr><td><a href="/clear">Clear Flask session credentials</a></td>' + '<td>Clear the access token currently stored in the user session. ' + ' After clearing the token, if you <a href="/test">test the ' + ' API request</a> again, you should go back to the auth flow.' + '</td></tr></table>') if __name__ == '__main__': # When running locally, disable OAuthlib's HTTPs verification. # ACTION ITEM for developers: # When running in production *do not* leave this option enabled. os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1' # Specify a hostname and port that are set as a valid redirect URI # for your API project in the Google API Console. app.run('localhost', 8080, debug=True)
Ruby
ตัวอย่างนี้ใช้เฟรมเวิร์ก Sinatra
require 'google/apis/drive_v3' require 'sinatra' require 'googleauth' require 'googleauth/stores/redis_token_store' configure do enable :sessions set :client_id, Google::Auth::ClientId.from_file('/path/to/client_secret.json') set :scope, Google::Apis::DriveV3::AUTH_DRIVE_METADATA_READONLY set :token_store, Google::Auth::Stores::RedisTokenStore.new(redis: Redis.new) set :authorizer, Google::Auth::WebUserAuthorizer.new(settings.client_id, settings.scope, settings.token_store, '/oauth2callback') end get '/' do user_id = settings.client_id.id credentials = settings.authorizer.get_credentials(user_id, request) if credentials.nil? redirect settings.authorizer.get_authorization_url(login_hint: user_id, request: request) end drive = Google::Apis::DriveV3::DriveService.new files = drive.list_files(options: { authorization: credentials }) "<pre>#{JSON.pretty_generate(files.to_h)}</pre>" end get '/oauth2callback' do target_url = Google::Auth::WebUserAuthorizer.handle_auth_callback_deferred(request) redirect target_url end
Node.js
วิธีเรียกใช้ตัวอย่างนี้
-
ใน 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
โปรดดู ปกป้องบัญชีผู้ใช้ด้วยหน้าการป้องกันแบบครอบคลุมหลายบริการ ดูข้อมูลเพิ่มเติมเกี่ยวกับวิธีใช้การป้องกันแบบครอบคลุมหลายบริการและรายการเหตุการณ์ทั้งหมดที่มี