Google มุ่งมั่นที่จะพัฒนาความเท่าเทียมทางเชื้อชาติให้กับชุมชนคนผิวดำ ดูวิธีการ
หน้านี้ได้รับการแปลโดย Cloud Translation API
Switch to English

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

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

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

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

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

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

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

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

ไลบรารีไคลเอ็นต์พร้อมใช้งานสำหรับภาษาต่อไปนี้:

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

เปิดใช้ API สำหรับโครงการของคุณ

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

ในการเปิดใช้ API สำหรับโครงการของคุณ:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

PHP

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

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

    php composer.phar require google/apiclient:^2.0

Python

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

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

ทับทิม

ในการเรียกใช้ตัวอย่างรหัส Ruby ในเอกสารนี้คุณจะต้อง:

  • Ruby 2.2.2 หรือสูงกว่า
  • ไลบรารีไคลเอ็นต์ Google APIs สำหรับ Ruby:

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

    gem install sinatra

HTTP / REST

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

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

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

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

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

ขั้นตอนที่ 1: ตั้งค่าพารามิเตอร์การอนุญาต

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

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

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

PHP

ข้อมูลโค้ดด้านล่างสร้างออบเจ็กต์ Google_Client() ซึ่งกำหนดพารามิเตอร์ในคำขอการอนุญาต

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

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

$client = new Google_Client();
$client->setAuthConfig('client_secret.json');
$client->addScope(Google_Service_Drive::DRIVE_METADATA_READONLY);
$client->setRedirectUri('http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php');
// offline access will give you both an access and refresh token so that
// your app can refresh the access token without user interaction.
$client->setAccessType('offline');
// Using "consent" ensures that your application always receives a refresh token.
// If you are not using offline access, you can omit this.
$client->setApprovalPrompt("consent");
$client->setIncludeGrantedScopes(true);   // incremental auth

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

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

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

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

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

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

โปรดทราบว่ารูปแบบ http หรือ https กรณีและเครื่องหมายทับ (' / ') ต้องตรงกันทั้งหมด

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

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

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

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

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

$client->addScope(Google_Service_Drive::DRIVE_METADATA_READONLY);

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

access_type แนะนำ

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

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

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

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

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

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

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

$client->setState($sample_passthrough_value);
include_granted_scopes ไม่จำเป็น

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

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

$client->setIncludeGrantedScopes(true);
login_hint ไม่จำเป็น

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

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

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

$client->setLoginHint('None');
prompt ไม่จำเป็น

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

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

$client->setApprovalPrompt('consent');

ค่าที่เป็นไปได้คือ:

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

Python

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

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

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

import google.oauth2.credentials
import google_auth_oauthlib.flow

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

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

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

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

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

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

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

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

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

โปรดทราบว่ารูปแบบ http หรือ https กรณีและเครื่องหมายทับ (' / ') ต้องตรงกันทั้งหมด

หากต้องการตั้งค่านี้ใน Python ให้ตั้งค่าคุณสมบัติ redirect_uri ของวัตถุ flow :

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

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

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

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

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

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

access_type แนะนำ

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

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

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

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

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

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

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

authorization_url, state = flow.authorization_url(
    access_type='offline',
    state=sample_passthrough_value,
    include_granted_scopes='true')
include_granted_scopes ไม่จำเป็น

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

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

authorization_url, state = flow.authorization_url(
    access_type='offline',
    include_granted_scopes='true')
login_hint ไม่จำเป็น

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

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

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

authorization_url, state = flow.authorization_url(
    access_type='offline',
    login_hint='None',
    include_granted_scopes='true')
prompt ไม่จำเป็น

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

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

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

ค่าที่เป็นไปได้คือ:

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

ทับทิม

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

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

require 'google/apis/drive_v2'
require 'google/api_client/client_secrets'

client_secrets = Google::APIClient::ClientSecrets.load
auth_client = client_secrets.to_authorization
auth_client.update!(
  :scope => 'https://www.googleapis.com/auth/drive.metadata.readonly',
  :redirect_uri => 'http://www.example.com/oauth2callback',
  :additional_parameters => {
    "access_type" => "offline",         # offline access
    "include_granted_scopes" => "true"  # incremental auth
  }
)

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

HTTP / REST

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

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

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

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

redirect_uri จำเป็น

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

โปรดทราบว่ารูปแบบ http หรือ https กรณีและเครื่องหมายทับ (' / ') ต้องตรงกันทั้งหมด

response_type จำเป็น

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

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

scope จำเป็น

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

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

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

access_type แนะนำ

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

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

state แนะนำ

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

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

include_granted_scopes ไม่จำเป็น

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

login_hint ไม่จำเป็น

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

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

prompt ไม่จำเป็น

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

ค่าที่เป็นไปได้คือ:

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

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

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

PHP

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

Python

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

return flask.redirect(authorization_url)

ทับทิม

  1. สร้าง URL เพื่อขอการเข้าถึงจากเซิร์ฟเวอร์ OAuth 2.0 ของ Google:
    auth_uri = auth_client.authorization_uri.to_s
  2. เปลี่ยนเส้นทางผู้ใช้ไปที่ auth_uri

HTTP / REST

ตัวอย่างการเปลี่ยนเส้นทางไปยังเซิร์ฟเวอร์การอนุญาตของ Google

ตัวอย่าง URL แสดงอยู่ด้านล่างพร้อมตัวแบ่งบรรทัดและช่องว่างเพื่อให้อ่านง่าย

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

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

ขั้นตอนที่ 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: แลกเปลี่ยนรหัสการอนุญาตเพื่อรีเฟรชและเข้าถึงโทเค็น

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

PHP

ในการแลกเปลี่ยนรหัสการอนุญาตสำหรับโทเค็นการเข้าถึงให้ใช้วิธีการ authenticate ตัว authenticate :

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

คุณสามารถดึงโทเค็นการเข้าถึงด้วยเมธอด getAccessToken :

$access_token = $client->getAccessToken();

Python

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

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

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

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

ทับทิม

ในการแลกเปลี่ยนรหัสการอนุญาตสำหรับโทเค็นการเข้าถึงให้ใช้ fetch_access_token! วิธี:

auth_client.code = auth_code
auth_client.fetch_access_token!

HTTP / REST

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

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

ตัวอย่างต่อไปนี้แสดงคำขอตัวอย่าง:

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

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

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

คำตอบประกอบด้วยฟิลด์ต่อไปนี้:

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

ตัวอย่างต่อไปนี้แสดงตัวอย่างการตอบสนอง:

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

เรียกใช้ Google API

PHP

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

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

Python

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

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

ทับทิม

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

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

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

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

HTTP / REST

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

คุณสามารถทดลองใช้ Google API ทั้งหมดและดูขอบเขตได้ที่ OAuth 2.0 Playground

ตัวอย่าง HTTP GET

การเรียกไปยังปลายทาง drive.files (Drive Files API) โดยใช้ Authorization: Bearer HTTP header อาจมีลักษณะดังต่อไปนี้ โปรดทราบว่าคุณต้องระบุโทเค็นการเข้าถึงของคุณเอง:

GET /drive/v2/files HTTP/1.1
Host: www.googleapis.com
Authorization: Bearer access_token

นี่คือการเรียก API เดียวกันสำหรับผู้ใช้ที่พิสูจน์ตัวตนโดยใช้พารามิเตอร์สตริงการสืบค้น access_token :

GET https://www.googleapis.com/drive/v2/files?access_token=access_token

ตัวอย่าง curl

คุณสามารถทดสอบคำสั่งเหล่านี้ด้วยแอปพลิเคชันบรรทัดคำสั่ง curl นี่คือตัวอย่างที่ใช้ตัวเลือกส่วนหัว HTTP (แนะนำ):

curl -H "Authorization: Bearer access_token" https://www.googleapis.com/drive/v2/files

หรืออีกทางหนึ่งคือตัวเลือกพารามิเตอร์สตริงการสืบค้น:

curl https://www.googleapis.com/drive/v2/files?access_token=access_token

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

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

PHP

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

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

index.php

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

session_start();

$client = new Google_Client();
$client->setAuthConfig('client_secrets.json');
$client->addScope(Google_Service_Drive::DRIVE_METADATA_READONLY);

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

oauth2callback.php

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

session_start();

$client = new Google_Client();
$client->setAuthConfigFile('client_secrets.json');
$client->setRedirectUri('http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php');
$client->addScope(Google_Service_Drive::DRIVE_METADATA_READONLY);

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

Python

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

  • ทดสอบคำขอ 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)

ทับทิม

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

require 'google/apis/drive_v2'
require 'google/api_client/client_secrets'
require 'json'
require 'sinatra'

enable :sessions
set :session_secret, 'setme'

get '/' do
  unless session.has_key?(:credentials)
    redirect to('/oauth2callback')
  end
  client_opts = JSON.parse(session[:credentials])
  auth_client = Signet::OAuth2::Client.new(client_opts)
  drive = Google::Apis::DriveV2::DriveService.new
  files = drive.list_files(options: { authorization: auth_client })
  "<pre>#{JSON.pretty_generate(files.to_h)}</pre>"
end

get '/oauth2callback' do
  client_secrets = Google::APIClient::ClientSecrets.load
  auth_client = client_secrets.to_authorization
  auth_client.update!(
    :scope => 'https://www.googleapis.com/auth/drive.metadata.readonly',
    :redirect_uri => url('/oauth2callback'))
  if request['code'] == nil
    auth_uri = auth_client.authorization_uri.to_s
    redirect to(auth_uri)
  else
    auth_client.code = request['code']
    auth_client.fetch_access_token!
    auth_client.client_secret = nil
    session[:credentials] = auth_client.to_json
    redirect to('/')
  end
end

HTTP / REST

This Python example uses the Flask framework and the Requests library to demonstrate the OAuth 2.0 web flow. We recommend using the Google API Client Library for Python for this flow. (The example in the Python tab does use the client library.)

import json

import flask
import requests


app = flask.Flask(__name__)

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


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


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


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

Redirect URI validation rules

Google applies the following validation rules to redirect URIs in order to help developers keep their applications secure. Your redirect URIs must adhere to these rules. See RFC 3986 section 3 for the definition of domain, host, path, query, scheme and userinfo, mentioned below.

Validation rules
Scheme

URIs must use the HTTPS scheme, not plain HTTP.

Host

Hosts cannot be raw IP addresses. Localhost IP addresses are exempted from this rule.

Domain
  • Host TLDs ( Top Level Domains ) must belong to the public suffix list .
  • Host domains cannot be “googleusercontent.com” .
  • URIs cannot contain URL shortener domains (eg goo.gl ) unless the app owns the domain. Furthermore, if an app that owns a shortener domain chooses to redirect to that domain, that redirect URI must either contain “/google-callback/” in its path or end with “/google-callback” .
  • Userinfo

    Redirect URIs cannot contain the userinfo subcomponent.

    Path

    Redirect URIs cannot contain a path traversal (also called directory backtracking), which is represented by an “/..” or “\..” or their URL encoding.

    Query

    Redirect URIs cannot contain open redirects .

    Characters URIs cannot contain certain characters including:
    • Wildcard characters ( '*' )
    • Non-printable ASCII characters
    • Invalid percent encodings (any percent encoding that does not follow URL-encoding form of a percent sign followed by two hexadecimal digits)
    • Null characters (an encoded NULL character, eg, %00 , %C0%80 )

    Incremental authorization

    In the OAuth 2.0 protocol, your app requests authorization to access resources, which are identified by scopes. It is considered a best user-experience practice to request authorization for resources at the time you need them. To enable that practice, Google's authorization server supports incremental authorization. This feature lets you request scopes as they are needed and, if the user grants permission for the new scope, returns an authorization code that may be exchanged for a token containing all scopes the user has granted the project.

    For example, an app that lets people sample music tracks and create mixes might need very few resources at sign-in time, perhaps nothing more than the name of the person signing in. However, saving a completed mix would require access to their Google Drive. Most people would find it natural if they only were asked for access to their Google Drive at the time the app actually needed it.

    In this case, at sign-in time the app might request the openid and profile scopes to perform basic sign-in, and then later request the https://www.googleapis.com/auth/drive.file scope at the time of the first request to save a mix.

    To implement incremental authorization, you complete the normal flow for requesting an access token but make sure that the authorization request includes previously granted scopes. This approach allows your app to avoid having to manage multiple access tokens.

    The following rules apply to an access token obtained from an incremental authorization:

    • The token can be used to access resources corresponding to any of the scopes rolled into the new, combined authorization.
    • When you use the refresh token for the combined authorization to obtain an access token, the access token represents the combined authorization and can be used for any of the scope values included in the response.
    • The combined authorization includes all scopes that the user granted to the API project even if the grants were requested from different clients. For example, if a user granted access to one scope using an application's desktop client and then granted another scope to the same application via a mobile client, the combined authorization would include both scopes.
    • If you revoke a token that represents a combined authorization, access to all of that authorization's scopes on behalf of the associated user are revoked simultaneously.

    The language-specific code samples in Step 1: Set authorization parameters and the sample HTTP/REST redirect URL in Step 2: Redirect to Google's OAuth 2.0 server all use incremental authorization. The code samples below also show the code that you need to add to use incremental authorization.

    PHP

    $client->setIncludeGrantedScopes(true);

    Python

    In Python, set the include_granted_scopes keyword argument to true to ensure that an authorization request includes previously granted scopes. It is very possible that include_granted_scopes will not be the only keyword argument that you set, as shown in the example below.

    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"}
    )

    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

    Refreshing an access token (offline access)

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

    • If you use a Google API Client Library, the client object refreshes the access token as needed as long as you configure that object for offline access.
    • If you are not using a client library, you need to set the access_type HTTP query parameter to offline when redirecting the user to Google's OAuth 2.0 server . In that case, Google's authorization server returns a refresh token when you exchange an authorization code for an access token. Then, if the access token expires (or at any other time), you can use a refresh token to obtain a new access token.

    Requesting offline access is a requirement for any application that needs to access a Google API when the user is not present. For example, an app that performs backup services or executes actions at predetermined times needs to be able to refresh its access token when the user is not present. The default style of access is called online .

    Server-side web applications, installed applications, and devices all obtain refresh tokens during the authorization process. Refresh tokens are not typically used in client-side (JavaScript) web applications.

    PHP

    If your application needs offline access to a Google API, set the API client's access type to offline :

    $client->setAccessType("offline");

    After a user grants offline access to the requested scopes, you can continue to use the API client to access Google APIs on the user's behalf when the user is offline. The client object will refresh the access token as needed.

    Python

    In Python, set the access_type keyword argument to offline to ensure that you will be able to refresh the access token without having to re-prompt the user for permission. It is very possible that access_type will not be the only keyword argument that you set, as shown in the example below.

    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')

    After a user grants offline access to the requested scopes, you can continue to use the API client to access Google APIs on the user's behalf when the user is offline. The client object will refresh the access token as needed.

    Ruby

    If your application needs offline access to a Google API, set the API client's access type to offline :

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

    After a user grants offline access to the requested scopes, you can continue to use the API client to access Google APIs on the user's behalf when the user is offline. The client object will refresh the access token as needed.

    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"
    }

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

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

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

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

    PHP

    To programmatically revoke a token, call revokeToken() :

    $client->revokeToken();

    Python

    To programmatically revoke a token, make a request to https://oauth2.googleapis.com/revoke that includes the token as a parameter and sets the Content-Type header:

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

    Ruby

    To programmatically revoke a token, make an HTTP request to the oauth2.revoke endpoint:

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

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

    If the revocation is successfully processed, then the status code of the response is 200 . For error conditions, a status code 400 is returned along with an error code.

    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 จะถูกส่งกลับพร้อมกับรหัสข้อผิดพลาด