Bu belgede, web sunucusu uygulamalarının YouTube Data API'ye erişmek için OAuth 2.0 yetkilendirmesini uygulamak amacıyla Google API İstemci Kitaplıklarını veya Google OAuth 2.0 uç noktalarını nasıl kullandığı açıklanmaktadır.
OAuth 2.0, kullanıcıların kullanıcı adlarını, şifrelerini ve diğer bilgilerini gizli tutarken belirli verileri bir uygulamayla paylaşmasına olanak tanır. Örneğin, bir uygulama, kullanıcının YouTube kanalına video yükleme izni almak için OAuth 2.0'ı kullanabilir.
Bu OAuth 2.0 akışı, özel olarak kullanıcı yetkilendirmesi içindir. Gizli bilgileri depolayabilen ve durumu koruyabilen uygulamalar için tasarlanmıştır. Uygun şekilde yetkilendirilmiş bir web sunucusu uygulaması, kullanıcı uygulamayla etkileşim kurarken veya uygulamadan ayrıldıktan sonra API'lere erişebilir.
Web sunucusu uygulamaları, özellikle de kullanıcıya özel veriler yerine proje tabanlı verilere erişmek için Cloud API'leri çağırırken API isteklerini yetkilendirmek için sıklıkla
hizmet hesaplarını kullanır. Web sunucusu uygulamaları, hizmet hesaplarını kullanıcı yetkilendirmesiyle birlikte kullanabilir.
YouTube Data API'nin, hizmet hesabı akışını yalnızca birden fazla YouTube kanalına sahip ve yöneten YouTube içerik sahipleri için desteklediğini unutmayın.
İçerik sahipleri, spesifik olarak onBehalfOfContentOwner
istek parametresini destekleyen API yöntemlerini çağırmak için hizmet hesaplarını kullanabilir.
İstemci kitaplıkları
Bu sayfadaki dile özgü örneklerde, OAuth 2.0 yetkilendirmesini uygulamak için Google API İstemci Kitaplıkları kullanılmaktadır. Kod örneklerini çalıştırmak için önce dilinize uygun istemci kitaplığını yüklemeniz gerekir.
Uygulamanızın OAuth 2.0 akışını yönetmek için Google API İstemci Kitaplığı kullandığınızda istemci kitaplığı, uygulamanın normalde kendi başına yapması gereken birçok işlemi gerçekleştirir. Örneğin, uygulamanın depolanan erişim jetonlarını ne zaman kullanabileceğini veya yenileyebileceğini ve uygulamanın ne zaman yeniden izin alması gerektiğini belirler. İstemci kitaplığı ayrıca doğru yönlendirme URL'leri oluşturur ve erişim jetonları için yetkilendirme kodlarını değiş tokuş eden yönlendirme işleyicilerin uygulanmasına yardımcı olur.
Sunucu tarafı uygulamalar için Google API İstemci Kitaplıkları aşağıdaki dillerde kullanılabilir:
Ön koşullar
Projeniz için API'leri etkinleştirin
Google API'lerini çağıran uygulamaların, bu API'leri API Consoleuygulamasında etkinleştirmesi gerekir.
Projenizde bir API'yi etkinleştirmek için:
- Open the API Library Google API Console.
- If prompted, select a project, or create a new one.
- YouTube Data API'yi bulup etkinleştirmek için Kitaplık sayfasını kullanın. Uygulamanızın kullanacağı diğer API'leri bulun ve bunları da etkinleştirin.
Yetkilendirme kimlik bilgileri oluşturma
Google API'lerine erişmek için OAuth 2.0 kullanan tüm uygulamaların, uygulamayı Google'ın OAuth 2.0 sunucusuna tanımlayan yetkilendirme kimlik bilgilerine sahip olması gerekir. Aşağıdaki adımlarda, projeniz için nasıl kimlik bilgileri oluşturacağınız açıklanmaktadır. Ardından uygulamalarınız bu projede etkinleştirdiğiniz API'lere erişmek için kimlik bilgilerini kullanabilir.
- Go to the Credentials page.
- Kimlik bilgisi oluştur > OAuth istemci kimliği seçeneğini tıklayın.
- Web uygulaması uygulama türünü seçin.
- Formu doldurun ve Oluştur'u tıklayın. PHP, Java, Python, Ruby ve .NET gibi dilleri ve çerçeveleri kullanan uygulamalar, yetkili yönlendirme URI'leri belirtmelidir. Yönlendirme URI'leri, OAuth 2.0 sunucusunun yanıt gönderebileceği uç noktalardır. Bu uç noktalar Google'ın doğrulama kurallarına uygun olmalıdır.
Test için
http://localhost:8080
gibi yerel makineye işaret eden URI'ler belirtebilirsiniz. Bununla birlikte, bu belgedeki tüm örneklerin yönlendirme URI'si olarakhttp://localhost:8080
kullandığını lütfen unutmayın.Uygulamanızın, sayfadaki diğer kaynaklara yetkilendirme kodlarını göstermemesi için uygulamanızın kimlik doğrulama uç noktalarını tasarlamanızı öneririz.
Kimlik bilgilerinizi oluşturduktan sonra API Consolekonumundan client_secret.json dosyasını indirin. Dosyayı yalnızca uygulamanızın erişebileceği bir konumda güvenli bir şekilde depolayın.
Erişim kapsamlarını tanımlama
Kapsamlar, uygulamanızın yalnızca ihtiyaç duyduğu kaynaklara erişim isteğinde bulunmasını sağlarken kullanıcıların da uygulamanıza verdikleri erişim miktarını kontrol etmesine olanak tanır. Dolayısıyla, talep edilen kapsam sayısı ile kullanıcı izni alma olasılığı arasında ters bir ilişki olabilir.
OAuth 2.0 yetkilendirmesini uygulamaya başlamadan önce uygulamanızın erişmek için izne ihtiyaç duyacağı kapsamları belirlemenizi öneririz.
Uygulamanızın, artımlı yetkilendirme işlemi aracılığıyla yetkilendirme kapsamlarına erişim isteğinde bulunmasını da öneririz. Bu işlemde uygulamanız bağlam içinde kullanıcı verilerine erişim isteğinde bulunur. Bu en iyi uygulama, uygulamanızın istediği erişime neden ihtiyaç duyduğunu kullanıcıların daha kolay anlamalarına yardımcı olur.
YouTube Data API v3'te aşağıdaki kapsamlar kullanılır:
Nişan dürbünleri | |
---|---|
https://www.googleapis.com/auth/youtube | YouTube hesabınızı yönetin |
https://www.googleapis.com/auth/youtube.channel-memberships.creator | Mevcut etkin kanal üyelerinizin listesini, geçerli düzeylerini ve ne zaman üye olduklarını görme |
https://www.googleapis.com/auth/youtube.force-ssl | YouTube videolarınızı, derecelendirmelerinizi, yorumlarınızı ve altyazılarınızı görün, düzenleyin ve kalıcı olarak silin |
https://www.googleapis.com/auth/youtube.readonly | YouTube hesabınızı görüntüleyin |
https://www.googleapis.com/auth/youtube.upload | YouTube videolarınızı yönetin |
https://www.googleapis.com/auth/youtubepartner | YouTube'daki varlıklarınızı ve ilişkili içeriği görüntüleyin ve yönetin |
https://www.googleapis.com/auth/youtubepartner-channel-audit | Bir YouTube iş ortağı ile denetim süreci sırasında alakalı olan, YouTube kanalınıza ait gizli bilgileri görüntüleyin |
OAuth 2.0 API Kapsamları belgesi, Google API'lerine erişmek için kullanabileceğiniz kapsamların tam listesini içerir.
Dile özgü gereksinimler
Bu dokümandaki kod örneklerinden herhangi birini çalıştırmak için bir Google hesabına, internet erişimine ve web tarayıcısına ihtiyacınız vardır. API istemci kitaplıklarından birini kullanıyorsanız aşağıdaki dile özgü gereksinimleri de inceleyin.
PHP
Bu dokümandaki PHP kod örneklerini çalıştırmak için gerekenler:
- Komut satırı arayüzü (KSA) ve JSON uzantısı yüklü olarak PHP 5.6 veya sonraki sürümler.
- Composer bağımlılık yönetimi aracı.
-
PHP için Google API'leri İstemci Kitaplığı:
composer require google/apiclient:^2.10
Python
Bu belgedeki Python kod örneklerini çalıştırmak için gerekenler:
- Python 2.6 veya sonraki sürümler
- pip paket yönetim aracı.
- Python için Google API'leri İstemci Kitaplığı:
pip install --upgrade google-api-python-client
- Kullanıcı yetkilendirmesi için
google-auth
,google-auth-oauthlib
vegoogle-auth-httplib2
.pip install --upgrade google-auth google-auth-oauthlib google-auth-httplib2
- Flask Python web uygulaması çerçevesi.
pip install --upgrade flask
requests
HTTP kitaplığı.pip install --upgrade requests
Ruby
Bu belgedeki Ruby kod örneklerini çalıştırmak için gerekenler:
- Ruby 2.6 veya sonraki sürümler
-
Ruby için Google Kimlik Doğrulama Kitaplığı:
gem install googleauth
-
Sinatra Ruby web uygulaması çerçevesi.
gem install sinatra
Node.js
Bu dokümanda Node.js kod örneklerini çalıştırmak için gerekenler:
- Bakım LTS'si, etkin LTS veya Node.js'nin mevcut sürümü.
-
Google API'leri Node.js İstemcisi:
npm install googleapis crypto express express-session
HTTP/REST
OAuth 2.0 uç noktalarını doğrudan çağırabilmek için herhangi bir kitaplık yüklemeniz gerekmez.
OAuth 2.0 erişim jetonları alma
Aşağıdaki adımlarda uygulamanızın, kullanıcı adına API isteği gerçekleştirme izni almak için Google'ın OAuth 2.0 sunucusuyla nasıl etkileşimde bulunduğu gösterilmektedir. Uygulamanızın kullanıcı yetkilendirmesi gerektiren bir Google API isteğini yürütmesi için önce bu izni almış olması gerekir.
Aşağıdaki listede bu adımlar hızlı bir şekilde özetlenmektedir:
- Uygulamanız gereken izinleri belirler.
- Uygulamanız, kullanıcıyı istenen izinlerin listesiyle birlikte Google'a yönlendiriyor.
- Uygulamanıza izin verip vermeyeceğinize kullanıcı karar verir.
- Uygulamanız, kullanıcının neye karar verdiğini öğrenir.
- Kullanıcı istenen izinleri verdiyse uygulamanız kullanıcı adına API istekleri yapmak için gereken jetonları alır.
1. Adım: Yetkilendirme parametrelerini ayarlayın
İlk adımınız, yetkilendirme isteği oluşturmaktır. Bu istek, uygulamanızı tanımlayan parametreleri ve kullanıcıdan uygulamanıza verilecek izinleri tanımlar.
- OAuth 2.0 kimlik doğrulama ve yetkilendirmesi için Google istemci kitaplığı kullanıyorsanız bu parametreleri tanımlayan bir nesne oluşturup yapılandırırsınız.
- Google OAuth 2.0 uç noktasını doğrudan çağırırsanız bir URL oluşturur ve parametreleri bu URL'de ayarlarsınız.
Aşağıdaki sekmeler, web sunucusu uygulamaları için desteklenen yetkilendirme parametrelerini tanımlar. Dile özgü örnekler, bu parametreleri ayarlayan bir nesneyi yapılandırmak için istemci kitaplığının veya yetkilendirme kitaplığının nasıl kullanılacağını da gösterir.
PHP
Aşağıdaki kod snippet'i, yetkilendirme isteğindeki parametreleri tanımlayan bir Google\Client()
nesnesi oluşturur.
Bu nesne, uygulamanızı tanımlamak için client_secret.json dosyanızdaki bilgileri kullanır. (Bu dosya hakkında daha fazla bilgi için yetkilendirme kimlik bilgileri oluşturma bölümüne bakın.) Nesne, uygulamanızın erişim izni istediği kapsamları ve Google'ın OAuth 2.0 sunucusundan gelen yanıtı işleyecek uygulamanızın kimlik doğrulama uç noktasının URL'sini de tanımlar. Son olarak, kod isteğe bağlı access_type
ve include_granted_scopes
parametrelerini ayarlar.
Örneğin, aşağıdaki kod kullanıcının YouTube hesabını yönetmek için çevrimdışı erişim ister:
$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_YOUTUBE::YOUTUBE_FORCE_SSL); // 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
Aşağıdaki kod snippet'i, yetkilendirme isteğini oluşturmak için google-auth-oauthlib.flow
modülünü kullanır.
Kod, yetkilendirme kimlik bilgilerini oluşturduktan sonra indirdiğiniz client_secret.json dosyasındaki bilgileri kullanarak uygulamanızı tanımlayan bir Flow
nesnesi oluşturur. Bu nesne, uygulamanızın erişim izni istediği kapsamları ve Google'ın OAuth 2.0 sunucusundan gelen yanıtı işleyecek olan, uygulamanızın kimlik doğrulama uç noktasının URL'sini de tanımlar. Son olarak kod, isteğe bağlı access_type
ve include_granted_scopes
parametrelerini ayarlar.
Örneğin, aşağıdaki kod kullanıcının YouTube hesabını yönetmek için çevrimdışı erişim ister:
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/youtube.force-ssl']) # 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
Uygulamanızdaki bir istemci nesnesini yapılandırmak için oluşturduğunuz client_secrets.json dosyasını kullanın. Bir istemci nesnesini yapılandırdığınızda, uygulamanızın erişmesi gereken kapsamları ve OAuth 2.0 sunucusundan alınan yanıtı işleyecek uygulamanızın kimlik doğrulama uç noktasının URL'sini belirtirsiniz.
Örneğin, aşağıdaki kod kullanıcının YouTube hesabını yönetmek için çevrimdışı erişim ister:
require 'google/apis/youtube_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/youtube.force-ssl' token_store = Google::Auth::Stores::RedisTokenStore.new(redis: Redis.new) authorizer = Google::Auth::WebUserAuthorizer.new(client_id, scope, token_store, '/oauth2callback')
Uygulamanız, yetkilendirme isteği URL'leri oluşturma ve HTTP isteklerine erişim jetonları uygulama gibi OAuth 2.0 işlemlerini gerçekleştirmek için istemci nesnesini kullanır.
Node.js
Aşağıdaki kod snippet'i, yetkilendirme isteğindeki parametreleri tanımlayan bir google.auth.OAuth2
nesnesi oluşturur.
Bu nesne, uygulamanızı tanımlamak için client_secret.json dosyanızdaki bilgileri kullanır. Bir kullanıcıdan erişim jetonu almak için izin istemek amacıyla kullanıcıyı bir izin sayfasına yönlendirirsiniz. İzin sayfası URL'si oluşturmak için:
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 });
Önemli Not: refresh_token
yalnızca ilk yetkilendirmede döndürülür. Daha fazla bilgiyi
burada bulabilirsiniz.
HTTP/REST
Google'ın OAuth 2.0 uç noktası https://accounts.google.com/o/oauth2/v2/auth
adresindedir. Bu uç noktaya yalnızca HTTPS üzerinden erişilebilir. Düz HTTP bağlantıları reddediliyor.
Google yetkilendirme sunucusu, web sunucusu uygulamaları için aşağıdaki sorgu dizesi parametrelerini destekler:
Parametreler | |||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
client_id |
Zorunlu
Uygulamanızın istemci kimliği. Bu değeri API Console Credentials pageiçinde bulabilirsiniz. |
||||||||||||||||
redirect_uri |
Zorunlu
Kullanıcı yetkilendirme akışını tamamladıktan sonra API sunucusunun kullanıcıyı nereye yönlendireceğini
belirler. Değer, OAuth 2.0 istemcisi için istemcinizin API Console
Credentials pageiçinde yapılandırdığınız yetkili yönlendirme URI'lerinden biriyle tam olarak eşleşmelidir. Bu değer, sağlanan
|
||||||||||||||||
response_type |
Zorunlu
Google OAuth 2.0 uç noktasının bir yetkilendirme kodu döndürüp döndürmeyeceğini belirler. Web sunucusu uygulamaları için parametre değerini |
||||||||||||||||
scope |
Zorunlu
Uygulamanızın kullanıcı adına erişebileceği kaynakları tanımlayan, boşlukla sınırlandırılmış bir kapsam listesi. Bu değerler, Google'ın kullanıcıya gösterdiği izin ekranını bilgilendirir. Kapsamlar, uygulamanızın yalnızca ihtiyaç duyduğu kaynaklara erişim isteğinde bulunmasına ve kullanıcıların uygulamanıza verdikleri erişim miktarını kontrol etmesine olanak tanır. Dolayısıyla, talep edilen kapsam sayısı ile kullanıcı izni alma olasılığı arasında ters bir ilişki vardır. YouTube Data API v3'te aşağıdaki kapsamlar kullanılır:
OAuth 2.0 API Kapsamları belgesi, Google API'lerine erişmek için kullanabileceğiniz kapsamların tam listesini sağlar. Uygulamanızın, mümkün olduğunda yetkilendirme kapsamlarına bağlam içinde erişim isteğinde bulunmasını öneririz. Artımlı yetkilendirme ile bir bağlam içinde kullanıcı verilerine erişim isteğinde bulunarak kullanıcıların, uygulamanızın istediği erişime neden ihtiyaç duyduğunu daha kolay anlamasına yardımcı olursunuz. |
||||||||||||||||
access_type |
Önerilen
Kullanıcı tarayıcıda değilken uygulamanızın erişim jetonlarını yenileyip yenileyemeyeceğini belirtir. Geçerli parametre değerleri, varsayılan değer olan Kullanıcı tarayıcıda olmadığında uygulamanızın erişim jetonlarını yenilemesi gerekiyorsa değeri |
||||||||||||||||
state |
Önerilen
Uygulamanızın yetkilendirme isteğiniz ile yetkilendirme sunucusunun yanıtı arasındaki durumu korumak için kullandığı herhangi bir dize değerini belirtir.
Kullanıcı, uygulamanızın erişim isteğini kabul ettikten veya reddettikten sonra sunucu, Bu parametreyi, kullanıcıyı uygulamanızdaki doğru kaynağa yönlendirmek, nonce göndermek ve siteler arası istek sahtekarlığını azaltmak gibi çeşitli amaçlarla kullanabilirsiniz. |
||||||||||||||||
include_granted_scopes |
İsteğe bağlı
Uygulamaların bağlam içinde ek kapsamlara erişim istemek için artımlı yetkilendirme kullanmasını sağlar. Bu parametrenin değerini |
||||||||||||||||
enable_granular_consent |
İsteğe bağlı
Varsayılan olarak Google bir uygulama için ayrıntılı izinleri etkinleştirdiğinde bu parametrenin artık herhangi bir etkisi olmaz. |
||||||||||||||||
login_hint |
İsteğe bağlı
Uygulamanız hangi kullanıcının kimlik doğrulaması yapmaya çalıştığını biliyorsa Google Kimlik Doğrulama Sunucusu'na ipucu sağlamak için bu parametreyi kullanabilir. Sunucu, oturum açma formundaki e-posta alanını önceden doldurarak veya uygun çoklu giriş oturumunu seçerek giriş akışını basitleştirmek için ipucunu kullanır. Parametre değerini, bir e-posta adresi veya kullanıcının Google kimliğine eşdeğer olan bir |
||||||||||||||||
prompt |
İsteğe bağlı
Kullanıcıya sunmak için kullanılan, boşlukla ayrılmış, büyük/küçük harfe duyarlı bir istem listesi. Bu parametreyi belirtmezseniz kullanıcıdan yalnızca projeniz ilk kez erişim istediğinde istenir. Daha fazla bilgi için Yeniden izin isteme başlıklı makaleye göz atın. Olası değerler:
|
2. Adım: Google'ın OAuth 2.0 sunucusuna yönlendirin
Kimlik doğrulama ve yetkilendirme sürecini başlatmak için kullanıcıyı Google'ın OAuth 2.0 sunucusuna yönlendirin. Bu durum genellikle uygulamanızın, kullanıcı verilerine ilk kez erişmesi gerektiğinde gerçekleşir. Artımlı yetkilendirme söz konusu olduğunda bu adım, uygulamanızın henüz erişim izni olmadığı ek kaynaklara ilk kez erişmesi gerektiğinde de gerçekleşir.
PHP
- Google'ın OAuth 2.0 sunucusundan erişim istemek için bir URL oluşturun:
$auth_url = $client->createAuthUrl();
- Kullanıcıyı
$auth_url
adresine yönlendirin:header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL));
Python
Bu örnekte, Flask web uygulaması çerçevesi kullanılarak kullanıcının yetkilendirme URL'sine nasıl yönlendirileceği gösterilmektedir:
return flask.redirect(authorization_url)
Ruby
- Google'ın OAuth 2.0 sunucusundan erişim istemek için bir URL oluşturun:
auth_uri = authorizer.get_authorization_url(login_hint: user_id, request: request)
- Kullanıcıyı
auth_uri
adresine yönlendirin.
Node.js
-
Google'ın OAuth 2.0 sunucusundan erişim isteğinde bulunmak için 1. Adım'da oluşturulan
generateAuthUrl
yöntemini (authorizationUrl
) kullanın. -
Kullanıcıyı
authorizationUrl
adresine yönlendirin.res.redirect(authorizationUrl);
HTTP/REST
Sample redirect to Google's authorization server
The sample URL below requests offline access
(access_type=offline
) to a scope that permits access to view
the user's YouTube account. It uses incremental authorization to ensure that
the new access token covers any scopes to which the user previously granted
the application access. The URL also sets values for the required
redirect_uri
, response_type
, and
client_id
parameters as well as for the state
parameter. The URL contains line breaks and spaces for readability.
https://accounts.google.com/o/oauth2/v2/auth?
scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fyoutube.readonly&
access_type=offline&
include_granted_scopes=true&
state=state_parameter_passthrough_value&
redirect_uri=http%3A%2F%2Flocalhost%2Foauth2callback&
response_type=code&
client_id=client_id
İstek URL'sini oluşturduktan sonra kullanıcıyı bu URL'ye yönlendirin.
Google'ın OAuth 2.0 sunucusu, kullanıcının kimliğini doğrular ve uygulamanızın istenen kapsamlara erişmesi için kullanıcıdan izin alır. Yanıt, belirttiğiniz yönlendirme URL'si kullanılarak uygulamanıza geri gönderilir.
3. adım: Google, kullanıcıdan izin ister
Bu adımda kullanıcı, uygulamanıza istenen erişimi verip vermeyeceğini belirler. Google, bu aşamada uygulamanızın adını ve kullanıcının yetkilendirme kimlik bilgileriyle erişim izni istediği Google API hizmetlerini gösteren bir izin penceresi ve verilecek erişim kapsamlarının bir özetini gösterir. Daha sonra kullanıcı, uygulamanız tarafından istenen bir veya daha fazla kapsama erişim izni verebilir veya isteği reddedebilir.
Google'ın OAuth 2.0 sunucusundan, herhangi bir erişim izni verilip verilmediğini belirten bir yanıt beklediği için uygulamanızın bu aşamada herhangi bir şey yapması gerekmez. Bu yanıt aşağıdaki adımda açıklanmaktadır.
Hatalar
Google'ın OAuth 2.0 yetkilendirme uç noktasına gönderilen istekler, beklenen kimlik doğrulama ve yetkilendirme akışları yerine kullanıcılara yönelik hata mesajları gösterebilir. Yaygın hata kodları ve önerilen çözümler aşağıda listelenmiştir.
admin_policy_enforced
Google Hesabı, Google Workspace yöneticisinin politikaları nedeniyle istenen bir veya daha fazla kapsamı yetkilendiremedi. OAuth istemci kimliğinize açıkça erişim verilene kadar bir yöneticinin tüm kapsamlara ya da hassas ve kısıtlanmış kapsamlara erişimi nasıl kısıtlayabileceği hakkında daha fazla bilgi için Hangi üçüncü taraf uygulamalarının ve dahili uygulamaların Google Workspace verilerine erişebileceğini kontrol etme konulu Google Workspace Yöneticisi yardım makalesine göz atın.
disallowed_useragent
Yetkilendirme uç noktası, Google'ın OAuth 2.0 Politikaları tarafından izin verilmeyen yerleşik bir kullanıcı aracısının içinde görüntülenir.
Android
Android geliştiricileri, android.webkit.WebView
ürününde yetkilendirme isteklerini açarken bu hata mesajıyla karşılaşabilir.
Geliştiriciler bunun yerine Android için Google ile Oturum Açma veya RFC Foundation'ın AppAuth for Android gibi Android kitaplıklarını kullanmalıdır.
Bir Android uygulaması yerleşik kullanıcı aracısında genel bir web bağlantısı açtığında ve kullanıcı sitenizden Google'ın OAuth 2.0 yetkilendirme uç noktasına gittiğinde web geliştiricileri bu hatayla karşılaşabilir. Geliştiriciler, işletim sisteminin varsayılan bağlantı işleyicisinde (hem Android App Links işleyicilerini hem de varsayılan tarayıcı uygulamasını içeren) genel bağlantıların açılmasına izin vermelidir. Android Özel Sekmeleri kitaplığı da desteklenen bir seçenektir.
iOS
iOS ve macOS geliştiricileri, WKWebView
ürününde yetkilendirme isteklerini açarken bu hatayla karşılaşabilir.
Geliştiriciler bunun yerine iOS için Google ile Oturum Açma gibi iOS kitaplıklarını veya COPPA Vakfı'nın iOS için AppAuth dosyasını kullanmalıdır.
Bir iOS veya macOS uygulaması, yerleştirilmiş kullanıcı aracısında genel bir web bağlantısı açıp bir kullanıcı sitenizden Google'ın OAuth 2.0 yetkilendirme uç noktasına gittiğinde web geliştiricileri bu hatayla karşılaşabilir. Geliştiriciler, genel bağlantıların işletim sisteminin varsayılan bağlantı işleyicisinde açılmasına izin vermelidir. Bu bağlantı, hem Geçiş Bağlantıları işleyicileri hem de varsayılan tarayıcı uygulamasını içerir. SFSafariViewController
kitaplığı da desteklenen bir seçenektir.
org_internal
İstekteki OAuth istemci kimliği, belirli bir Google Cloud kuruluşundaki Google Hesaplarına erişimi sınırlayan bir projenin parçası. Bu yapılandırma seçeneği hakkında daha fazla bilgi için OAuth izin ekranınızı ayarlama yardım makalesinin Kullanıcı türü bölümüne bakın.
invalid_client
OAuth istemci gizli anahtarı yanlış. Bu istek için kullanılan istemci kimliği ve gizli anahtar bilgisi de dahil olmak üzere OAuth istemci yapılandırmasını inceleyin.
invalid_grant
Bir erişim jetonunu yenilerken veya artımlı yetkilendirme kullanırken jetonun süresi dolmuş veya geçersiz kılınmış olabilir. Kullanıcının kimliğini tekrar doğrulayın ve yeni jetonlar almak için kullanıcıdan izin isteyin. Bu hatayı görmeye devam ediyorsanız uygulamanızın doğru şekilde yapılandırıldığından ve isteğinizde doğru jeton ve parametreleri kullandığınızdan emin olun. Aksi takdirde, kullanıcı hesabı silinmiş veya devre dışı bırakılmış olabilir.
redirect_uri_mismatch
Yetkilendirme isteğinde iletilen redirect_uri
, OAuth istemci kimliğine ait yetkili yönlendirme URI'siyle eşleşmiyor. Google API Console Credentials pageiçindeki yetkili yönlendirme URI'lerini inceleyin.
redirect_uri
parametresi, kullanımdan kaldırılan ve artık desteklenmeyen OAuth bant dışı (OOB) akışına işaret ediyor olabilir. Entegrasyonunuzu güncellemek için taşıma rehberine bakın.
invalid_request
Talebinizle ilgili bir sorun oluştu. Bunun birkaç nedeni olabilir:
- İstek düzgün biçimlendirilmemiş
- İstekte gerekli parametreler eksikti
- İstek, Google'ın desteklemediği bir yetkilendirme yöntemi kullanıyor. OAuth entegrasyonunuzun önerilen bir entegrasyon yöntemini kullandığını doğrulama
4. Adım: OAuth 2.0 sunucu yanıtını yönetin
OAuth 2.0 sunucusu, uygulamanızın erişim isteğine, istekte belirtilen URL'yi kullanarak yanıt verir.
Kullanıcı erişim isteğini onaylarsa yanıt bir yetkilendirme kodu içerir. Kullanıcı isteği onaylamazsa yanıt bir hata mesajı içerir. Web sunucusuna döndürülen yetkilendirme kodu veya hata mesajı, sorgu dizesinde aşağıda gösterildiği gibi görünür:
Hata yanıtı:
https://oauth2.example.com/auth?error=access_denied
Yetkilendirme kodu yanıtı:
https://oauth2.example.com/auth?code=4/P7q7W91a-oMsCeLvIaQm6bTrgtp7
Örnek OAuth 2.0 sunucu yanıtı
Google Drive'ınızdaki dosyaların meta verilerini görüntülemek için salt okuma erişimi isteyen aşağıdaki örnek URL'yi tıklayarak bu akışı test edebilirsiniz:
https://accounts.google.com/o/oauth2/v2/auth? scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fyoutube.readonly& access_type=offline& include_granted_scopes=true& state=state_parameter_passthrough_value& redirect_uri=http%3A%2F%2Flocalhost%2Foauth2callback& response_type=code& client_id=client_id
OAuth 2.0 akışını tamamladıktan sonra http://localhost/oauth2callback
sitesine yönlendirilirsiniz. Yerel makineniz ilgili adrese dosya sunmadığı takdirde muhtemelen 404 NOT FOUND
hatası verir. Bir sonraki adım, kullanıcı uygulamanıza tekrar yönlendirildiğinde URI'de döndürülen bilgiler hakkında daha ayrıntılı bilgi sağlar.
5. Adım: Yenileme ve erişim jetonları için yetkilendirme kodunu değiştirin
Web sunucusu yetkilendirme kodunu aldıktan sonra, yetkilendirme kodunu bir erişim jetonuyla değiştirebilir.
PHP
Yetkilendirme kodunu erişim jetonuyla değiştirmek için authenticate
yöntemini kullanın:
$client->authenticate($_GET['code']);
Erişim jetonunu getAccessToken
yöntemiyle alabilirsiniz:
$access_token = $client->getAccessToken();
Python
Geri çağırma sayfanızda, yetkilendirme sunucusu yanıtını doğrulamak için google-auth
kitaplığını kullanın. Ardından, flow.fetch_token
yöntemini kullanarak bu yanıttaki yetkilendirme kodunu erişim jetonuyla değiştirin:
state = flask.session['state'] flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file( 'client_secret.json', scopes=['https://www.googleapis.com/auth/youtube.force-ssl'], 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
Geri çağırma sayfanızda, yetkilendirme sunucusu yanıtını doğrulamak için googleauth
kitaplığını
kullanın. Yetkilendirme kodunu kaydetmek ve başlangıçta yetkilendirme isteğinde bulunan URL'ye yeniden yönlendirme yapmak için authorizer.handle_auth_callback_deferred
yöntemini kullanın. Bu, sonuçları kullanıcı oturumunda geçici olarak saklayarak kod değişimini erteler.
target_url = Google::Auth::WebUserAuthorizer.handle_auth_callback_deferred(request) redirect target_url
Node.js
Yetkilendirme kodunu erişim jetonuyla değiştirmek için getToken
yöntemini kullanın:
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
Erişim jetonuyla yetkilendirme kodu değişimi yapmak için https://oauth2.googleapis.com/token
uç noktasını çağırın ve aşağıdaki parametreleri ayarlayın:
Alanlar | |
---|---|
client_id |
Credentials pageiçinden API Console alınan istemci kimliği. |
client_secret |
Credentials pageöğesinden alınan istemci gizli anahtarı API Console. |
code |
İlk istekten döndürülen yetkilendirme kodu. |
grant_type |
OAuth 2.0 spesifikasyonunda tanımlandığı gibi, bu alanın değeri authorization_code olarak ayarlanmalıdır. |
redirect_uri |
Belirtilen client_id için API Console
Credentials page içinde projenizle ilgili olarak listelenen yönlendirme URI'lerinden biri. |
Aşağıdaki snippet'te örnek bir istek gösterilmektedir:
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, bu isteğe kısa ömürlü erişim jetonu ve yenileme jetonu içeren bir JSON nesnesi döndürerek yanıt verir.
Yenileme jetonunun yalnızca uygulamanızın Google'ın yetkilendirme sunucusuna yapılan ilk istekte access_type
parametresini offline
olarak ayarlaması durumunda döndürüleceğini unutmayın.
Yanıt aşağıdaki alanları içerir:
Alanlar | |
---|---|
access_token |
Uygulamanızın bir Google API isteğini yetkilendirmek için gönderdiği jeton. |
expires_in |
Erişim jetonunun saniye cinsinden kalan ömrü. |
refresh_token |
Yeni bir erişim jetonu almak için kullanabileceğiniz jeton. Yenileme jetonları, kullanıcı erişimi iptal edene kadar geçerlidir.
Bu alan yalnızca Google'ın yetkilendirme sunucusuna yapılan ilk istekte access_type parametresini offline olarak ayarlarsanız bu yanıtta bulunur.
|
scope |
access_token tarafından verilen erişim kapsamları, boşlukla sınırlandırılmış, büyük/küçük harfe duyarlı dizelerin bir listesi olarak ifade edilir. |
token_type |
Döndürülen jetonun türü. Şu anda bu alanın değeri her zaman Bearer olarak ayarlanmıştır. |
Aşağıdaki snippet örnek bir yanıt gösterir:
{ "access_token": "1/fFAGRNJru1FTz70BzhT3Zg", "expires_in": 3920, "token_type": "Bearer", "scope": "https://www.googleapis.com/auth/youtube.force-ssl", "refresh_token": "1//xEoDL4iW3cxlI7yDbSRFYNG01kVKM2C-259HOF2aQbI" }
Hatalar
Yetkilendirme kodunu erişim jetonuyla değiştirirken beklenen yanıt yerine aşağıdaki hatayla karşılaşabilirsiniz. Yaygın hata kodları ve önerilen çözümler aşağıda listelenmiştir.
invalid_grant
Sağlanan yetkilendirme kodu geçersiz veya yanlış biçimde. Kullanıcıdan tekrar izin istemek için OAuth sürecini yeniden başlatarak yeni bir kod isteyin.
Google API'lerini çağırma
PHP
Aşağıdaki adımları tamamlayarak Google API'lerini çağırmak için erişim jetonunu kullanın:
- Erişim jetonunu yeni bir
Google\Client
nesnesine uygulamanız gerekiyorsa (örneğin, erişim jetonunu bir kullanıcı oturumunda depoladıysanız)setAccessToken
yöntemini kullanın:$client->setAccessToken($access_token);
- Çağırmak istediğiniz API için bir hizmet nesnesi oluşturun. Çağırmak istediğiniz API için oluşturucuya yetkilendirilmiş bir
Google\Client
nesnesi sağlayarak bir hizmet nesnesi derlersiniz. Örneğin, YouTube Data API'yi çağırmak için:$youtube = new Google_Service_YouTube($client);
- Hizmet nesnesi tarafından sağlanan arayüzü kullanarak API hizmetine istek gönderin.
Örneğin, yetkili kullanıcının YouTube kanalıyla ilgili verileri almak için:
$channel = $youtube->channels->listChannels('snippet', array('mine' => $mine));
Python
Erişim jetonu aldıktan sonra, uygulamanız belirli bir kullanıcı hesabı veya hizmet hesabı adına API isteklerini yetkilendirmek için bu jetonu kullanabilir. Kullanıcıya özel yetkilendirme kimlik bilgilerini kullanarak çağırmak istediğiniz API için hizmet nesnesi oluşturun ve yetkilendirilmiş API isteklerinde bulunmak için bu nesneyi kullanın.
- Çağırmak istediğiniz API için bir hizmet nesnesi oluşturun. API'nin adı, sürümü ve kullanıcı kimlik bilgileriyle birlikte
googleapiclient.discovery
kitaplığınınbuild
yöntemini çağırarak bir hizmet nesnesi oluşturursunuz: Örneğin, YouTube Data API'nin 3. sürümünü çağırmak için:from googleapiclient.discovery import build youtube = build('youtube', 'v3', credentials=credentials)
- Hizmet nesnesi tarafından sağlanan arayüzü kullanarak API hizmetine istek gönderin.
Örneğin, yetkili kullanıcının YouTube kanalıyla ilgili verileri almak için:
channel = youtube.channels().list(mine=True, part='snippet').execute()
Ruby
Erişim jetonu aldıktan sonra uygulamanız belirli bir kullanıcı hesabı veya hizmet hesabı adına API isteklerinde bulunmak için bu jetonu kullanabilir. Kullanıcıya özel yetkilendirme kimlik bilgilerini kullanarak çağırmak istediğiniz API için hizmet nesnesi oluşturun ve yetkilendirilmiş API isteklerinde bulunmak için bu nesneyi kullanın.
- Çağırmak istediğiniz API için bir hizmet nesnesi oluşturun.
Örneğin, YouTube Data API'nin 3. sürümünü çağırmak için:
youtube = Google::Apis::YoutubeV3::YouTubeService.new
- Hizmetteki kimlik bilgilerini ayarlayın:
youtube.authorization = credentials
- Hizmet nesnesi tarafından sağlanan arayüzü kullanarak API hizmetine istek gönderin.
Örneğin, yetkili kullanıcının YouTube kanalıyla ilgili verileri almak için:
channel = youtube.list_channels(part, :mine => mine)
Alternatif olarak, yetkilendirme bir yönteme options
parametresi sağlanarak yöntem bazında sağlanabilir:
channel = youtube.list_channels(part, :mine => mine, options: { authorization: auth_client })
Node.js
Bir erişim jetonu alıp bunu OAuth2
nesnesine ayarladıktan sonra, Google API'lerini çağırmak için nesneyi kullanın. Uygulamanız, belirli bir kullanıcı hesabı veya hizmet hesabı adına API isteklerini yetkilendirmek için bu jetonu kullanabilir. Çağırmak istediğiniz API için bir hizmet nesnesi oluşturun.
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
Uygulamanız bir erişim jetonu aldıktan sonra, API'nin ihtiyaç duyduğu erişim kapsamları verildiyse bu jetonu belirli bir kullanıcı hesabı adına Google API'ye çağrı yapmak için kullanabilirsiniz. Bunu yapmak için bir access_token
sorgu parametresi veya Authorization
HTTP başlığı Bearer
değeri ekleyerek API'ye yapılan bir isteğe erişim jetonunu dahil edin. Sorgu dizeleri, sunucu günlüklerinde genellikle görünür olduğundan, mümkünse HTTP üst bilgisi tercih edilir. Çoğu durumda, Google API'lerine yapılan çağrılarınızı ayarlamak için bir istemci kitaplığı kullanabilirsiniz (örneğin, YouTube Data API'yi çağırırken).
YouTube Data API'nin hizmet hesaplarını yalnızca plak şirketleri ve film stüdyoları gibi birden fazla YouTube kanalına sahip ve yöneten YouTube içerik sahipleri için desteklediğini unutmayın.
Tüm Google API'lerini deneyebilir ve OAuth 2.0 Playground'da kapsamlarını görüntüleyebilirsiniz.
HTTP GET örnekleri
Authorization: Bearer
HTTP üst bilgisi kullanılarak
youtube.channels
uç noktasına (YouTube Data API) yapılan çağrı aşağıdaki gibi görünebilir. Kendi erişim jetonunuzu belirtmeniz gerektiğini unutmayın:
GET /youtube/v3/channels?part=snippet&mine=true HTTP/1.1 Host: www.googleapis.com Authorization: Bearer access_token
Aşağıda, access_token
sorgu dizesi parametresini kullanarak kimliği doğrulanmış kullanıcı için aynı API'ye yapılan bir çağrıyı görebilirsiniz:
GET https://www.googleapis.com/youtube/v3/channels?access_token=access_token&part=snippet&mine=true
curl
örnekleri
Bu komutları curl
komut satırı uygulamasıyla test edebilirsiniz. HTTP üstbilgisi seçeneğini kullanan bir örneği burada bulabilirsiniz (tercih edilen):
curl -H "Authorization: Bearer access_token" https://www.googleapis.com/youtube/v3/channels?part=snippet&mine=true
Alternatif olarak, sorgu dizesi parametre seçeneği şu şekildedir:
curl https://www.googleapis.com/youtube/v3/channels?access_token=access_token&part=snippet&mine=true
Tam örnek
Aşağıdaki örnekte, kullanıcı kimliğini doğrulayıp uygulamayı kullanıcının YouTube hesabını yönetmek için yetkilendirdikten sonra kullanıcının YouTube kanalıyla ilgili bilgileri gösteren JSON biçimli bir nesne yazdırılır.
PHP
Bu örneği çalıştırmak için:
- API Consolealanında, yerel makinenin URL'sini yönlendirme URL'leri listesine ekleyin. Örneğin,
http://localhost:8080
ekleyin. - Yeni bir dizin oluşturun ve bu dizinde değişiklik yapın. Örneğin:
mkdir ~/php-oauth2-example cd ~/php-oauth2-example
- Composer'ı kullanarak PHP için Google API İstemci Kitaplığı'nı yükleyin:
composer require google/apiclient:^2.10
- Aşağıdaki içerikle
index.php
veoauth2callback.php
dosyalarını oluşturun. - Örneği, PHP'yi sunacak şekilde yapılandırılmış bir web sunucusuyla çalıştırın. PHP 5.6 veya daha yeni bir sürümü kullanıyorsanız PHP'nin yerleşik test web sunucusunu kullanabilirsiniz:
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_YOUTUBE::YOUTUBE_FORCE_SSL); if (isset($_SESSION['access_token']) && $_SESSION['access_token']) { $client->setAccessToken($_SESSION['access_token']); $youtube = new Google_Service_YouTube($client); $channel = $youtube->channels->listChannels('snippet', array('mine' => $mine)); echo json_encode($channel); } 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_YOUTUBE::YOUTUBE_FORCE_SSL); 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
Bu örnekte Flask çerçevesi kullanılmaktadır. http://localhost:8080
adresinde, OAuth 2.0 akışını test etmenize olanak tanıyan bir web uygulaması çalıştırır. Bu URL'ye giderseniz dört bağlantı görürsünüz:
- API isteğini test etme: Bu bağlantı, örnek bir API isteğini yürütmeye çalışan bir sayfaya işaret eder. Gerekirse yetkilendirme akışını başlatır. Başarılı olursa sayfada API yanıtı gösterilir.
- Yetkilendirme akışını doğrudan test etme: Bu bağlantı, kullanıcıyı yetkilendirme akışı üzerinden göndermeye çalışan bir sayfaya yönlendirir. Uygulama, kullanıcı adına yetkilendirilmiş API istekleri göndermek için izin ister.
- Mevcut kimlik bilgilerini iptal et: Bu bağlantı, kullanıcının uygulamaya daha önce vermiş olduğu izinleri iptal eden bir sayfaya yönlendirir.
- Flask oturumu kimlik bilgilerini temizle: Bu bağlantı, Flask oturumunda depolanan yetkilendirme kimlik bilgilerini temizler. Bu sayede, uygulamanıza daha önce izin vermiş bir kullanıcı yeni bir oturumda API isteği yürütmeye çalıştığında ne olacağını görebilirsiniz. Ayrıca, bir kullanıcının uygulamanıza verilen izinleri iptal etmesine rağmen uygulamanız hâlâ iptal edilmiş erişim jetonuyla bir isteği yetkilendirmeye çalıştığında uygulamanızın alacağı API yanıtını da görebilirsiniz.
# -*- 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/youtube.force-ssl'] API_SERVICE_NAME = 'youtube' API_VERSION = 'v3' 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']) youtube = googleapiclient.discovery.build( API_SERVICE_NAME, API_VERSION, credentials=credentials) channel = youtube.channels().list(mine=True, part='snippet').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(**channel) @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
Bu örnekte Sinatra çerçevesi kullanılmaktadır.
require 'google/apis/youtube_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 youtube = Google::Apis::YoutubeV3::YouTubeService.new channel = youtube.list_channels(part, :mine => mine, options: { authorization: auth_client }) "<pre>#{JSON.pretty_generate(channel.to_h)}</pre>" end get '/oauth2callback' do target_url = Google::Auth::WebUserAuthorizer.handle_auth_callback_deferred(request) redirect target_url end
Node.js
Bu örneği çalıştırmak için:
-
API Consolealanında, yerel makinenin URL'sini yönlendirme URL'leri listesine ekleyin. Örneğin,
http://localhost
ekleyin. - Bakım LTS, etkin LTS veya Node.js'nin mevcut sürümünün yüklü olduğundan emin olun.
-
Yeni bir dizin oluşturun ve bu dizinde değişiklik yapın. Örneğin:
mkdir ~/nodejs-oauth2-example cd ~/nodejs-oauth2-example
-
Install the
Google API Client
Library
for Node.js using npm:
npm install googleapis
-
Aşağıdaki içeriklerle
main.js
dosyalarını oluşturun. -
Örneği çalıştırın:
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
Bu Python örneğinde, OAuth 2.0 web akışını göstermek için Flask çerçevesi ve Requests kitaplığı kullanılmaktadır. Bu akışta Python için Google API İstemci Kitaplığı'nı kullanmanızı öneririz. (Python sekmesindeki örnek, istemci kitaplığını kullanır.)
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/youtube.force-ssl' 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/youtube/v3/channels/list' 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()
Yönlendirme URI'si doğrulama kuralları
Google, geliştiricilerin uygulamalarını güvende tutmalarına yardımcı olmak amacıyla, yönlendirme URI'leri için aşağıdaki doğrulama kurallarını uygular. Yönlendirme URI'leriniz bu kurallara uygun olmalıdır. Aşağıda belirtilen alan, ana makine, yol, sorgu, şema ve kullanıcı bilgilerinin tanımı için RFC 3986 bölüm 3'e bakın.
Doğrulama kuralları | |
---|---|
Şema |
Yönlendirme URI'leri düz HTTP değil, HTTPS şemasını kullanmalıdır. Yerel ana makine URI'leri (localhost IP adresi URI'leri dahil) bu kuraldan muaftır. |
Düzenleyen |
Ana makineler ham IP adresleri olamaz. Localhost IP adresleri bu kuraldan muaftır. |
Alan |
“googleusercontent.com” olamaz.goo.gl ) içeremez. Ayrıca, daha kısa bir alan adına sahip olan bir uygulama bu alan adına yönlendirmeyi seçerse söz konusu yönlendirme URI'sinin yolunda “/google-callback/” içermesi veya “/google-callback” ile bitmesi gerekir. |
Kullanıcı Bilgileri |
Yönlendirme URI'leri kullanıcı bilgileri alt bileşenini içeremez. |
Yol |
Yönlendirme URI'leri, |
Sorgu |
Yönlendirme URI'leri açık yönlendirmeler içeremez. |
Parça |
Yönlendirme URI'leri parça bileşeni içeremez. |
Karakterler |
Yönlendirme URI'leri aşağıdakiler de dahil olmak üzere belirli karakterleri içeremez:
|
Artımlı yetkilendirme
OAuth 2.0 protokolünde, uygulamanız kapsamlarla tanımlanan kaynaklara erişim yetkisi ister. İhtiyacınız olduğu anda kaynaklar için yetkilendirme istemek, en iyi kullanıcı deneyimi uygulamalarından biri olarak kabul edilir. Bu uygulamayı mümkün kılmak için Google'ın yetkilendirme sunucusu artımlı yetkilendirmeyi destekler. Bu özellik, gerektiğinde kapsamları istemenize olanak tanır ve kullanıcı yeni kapsam için izin verirse kullanıcının projeye verdiği tüm kapsamları içeren bir jeton karşılığında değiştirilebilecek bir yetkilendirme kodu döndürür.
Örneğin, bir uygulamanın kullanıcıların ilginç yerel etkinlikleri tanımasına yardımcı olduğunu varsayalım. Uygulama, kullanıcıların etkinliklerle ilgili videoları izlemesine, videoları derecelendirmesine ve videoları oynatma listelerine eklemesine olanak tanır. Kullanıcılar ayrıca uygulamayı Google Takvimlerine etkinlik eklemek için de kullanabilirler.
Bu durumda, uygulama oturum açma sırasında herhangi bir kapsama ihtiyaç duymayabilir veya erişim isteğinde bulunmayabilir. Ancak kullanıcı bir videoyu derecelendirmeye, oynatma listesine video eklemeye veya başka bir YouTube işlemi gerçekleştirmeye çalıştıysa uygulama https://www.googleapis.com/auth/youtube.force-ssl
kapsamına erişim isteğinde bulunabilir.
Benzer şekilde, kullanıcı bir takvim etkinliği eklemeye çalıştığında uygulama https://www.googleapis.com/auth/calendar
kapsamına erişim isteğinde bulunabilir.
Artımlı yetkilendirme uygulamak için erişim jetonu istemeyle ilgili normal akışı tamamlarsınız ancak yetkilendirme isteğinin daha önce verilmiş kapsamları içerdiğinden emin olmanız gerekir. Bu yaklaşım sayesinde uygulamanız birden fazla erişim jetonunu yönetmek zorunda kalmaz.
Aşağıdaki kurallar, artımlı yetkilendirmeden elde edilen bir erişim jetonu için geçerlidir:
- Jeton, yeni ve birleştirilmiş yetkilendirmeye dahil edilen kapsamlardan herhangi birine karşılık gelen kaynaklara erişmek için kullanılabilir.
- Erişim jetonu almak amacıyla birleştirilmiş yetkilendirme için yenileme jetonunu kullandığınızda erişim jetonu, birleştirilmiş yetkilendirmeyi temsil eder ve yanıtta yer alan
scope
değerlerinden herhangi biri için kullanılabilir. - Birleşik yetkilendirme, izinlerin farklı istemcilerden istenmiş olsa bile kullanıcının API projesine verdiği tüm kapsamları içerir. Örneğin, bir kullanıcı bir uygulamanın masaüstü istemcisini kullanarak bir kapsama erişim izni verip daha sonra mobil istemci aracılığıyla aynı uygulamaya başka bir kapsam verdiyse birleştirilmiş yetkilendirme her iki kapsamı da içerir.
- Birleşik bir yetkilendirmeyi temsil eden bir jetonu iptal ederseniz ilişkilendirilmiş kullanıcı adına bu yetkilendirmenin tüm kapsamlarına erişim aynı anda iptal edilir.
1. Adım: Yetkilendirme parametrelerini ayarlayın bölümündeki dile özgü kod örnekleri ve 2. Adım: Google'ın OAuth 2.0 sunucusuna yönlendirme bölümündeki örnek HTTP/REST yönlendirme URL'sinin hepsinde artımlı yetkilendirme kullanılmaktadır. Aşağıdaki kod örneklerinde, artımlı yetkilendirme kullanmak için eklemeniz gereken kod da gösterilmektedir.
PHP
$client->setIncludeGrantedScopes(true);
Python
Yetkilendirme isteğinin önceden verilmiş kapsamları içerdiğinden emin olmak için Python'da include_granted_scopes
anahtar kelime bağımsız değişkenini true
olarak ayarlayın. Aşağıdaki örnekte gösterildiği gibi, include_granted_scopes
değerinin ayarladığınız tek anahtar kelime bağımsız değişkeni olmaması oldukça olasıdır.
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
Bu örnekte, çağıran uygulama kullanıcının uygulamaya önceden vermiş olduğu diğer erişimlerin yanı sıra YouTube Analytics verilerini de almak için erişim isteğinde bulunur.
GET https://accounts.google.com/o/oauth2/v2/auth? scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fyt-analytics.readonly& access_type=offline& state=security_token%3D138rk%3Btarget_url%3Dhttp...index& redirect_uri=http%3A%2F%2Flocalhost%2Foauth2callback& response_type=code& client_id=client_id& include_granted_scopes=true
Refreshing an access token (offline access)
Access tokens periodically expire and become invalid credentials for a related API request. You can refresh an access token without prompting the user for permission (including when the user is not present) if you requested offline access to the scopes associated with the token.
- 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 tooffline
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");
Bir kullanıcı istenen kapsamlara çevrimdışı erişim izni verdikten sonra kullanıcı çevrimdışıyken onun adına Google API'lerine erişmek için API istemcisini kullanmaya devam edebilirsiniz. İstemci nesnesi, erişim jetonunu gerektiğinde yeniler.
Python
Python'da, erişim jetonunu kullanıcıdan yeniden izin istemek zorunda kalmadan yenileyebileceğinizden emin olmak için access_type
anahtar kelime bağımsız değişkenini offline
olarak ayarlayın. Aşağıdaki örnekte gösterildiği gibi, access_type
, ayarladığınız tek anahtar kelime bağımsız değişkeni olmayabilir.
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')
Bir kullanıcı istenen kapsamlara çevrimdışı erişim izni verdikten sonra kullanıcı çevrimdışıyken onun adına Google API'lerine erişmek için API istemcisini kullanmaya devam edebilirsiniz. İstemci nesnesi, erişim jetonunu gerektiğinde yeniler.
Ruby
Uygulamanızın bir Google API'ye çevrimdışı erişmesi gerekiyorsa API istemcisinin erişim türünü offline
olarak ayarlayın:
auth_client.update!( :additional_parameters => {"access_type" => "offline"} )
Bir kullanıcı istenen kapsamlara çevrimdışı erişim izni verdikten sonra kullanıcı çevrimdışıyken onun adına Google API'lerine erişmek için API istemcisini kullanmaya devam edebilirsiniz. İstemci nesnesi, erişim jetonunu gerektiğinde yeniler.
Node.js
Uygulamanızın bir Google API'ye çevrimdışı erişmesi gerekiyorsa API istemcisinin erişim türünü offline
olarak ayarlayın:
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 });
Bir kullanıcı istenen kapsamlara çevrimdışı erişim izni verdikten sonra kullanıcı çevrimdışıyken onun adına Google API'lerine erişmek için API istemcisini kullanmaya devam edebilirsiniz. İstemci nesnesi, erişim jetonunu gerektiğinde yeniler.
Erişim jetonlarının süresi dolar. Bu kitaplık, süresi dolmak üzereyse yeni bir erişim jetonu almak için otomatik olarak bir yenileme jetonu kullanır. En yeni jetonları her zaman sakladığınızdan emin olmanın kolay bir yolu jeton etkinliğini kullanmaktır:
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); });
Bu jeton etkinliği yalnızca ilk yetkilendirmede gerçekleşir ve yenileme jetonunu almak için generateAuthUrl
yöntemini çağırırken access_type
ayarınızı offline
olarak ayarlamanız gerekir. Yenileme jetonu almak için uygun kısıtlamaları ayarlamadan uygulamanıza gerekli izinleri verdiyseniz yeni bir yenileme jetonu almak için uygulamayı yeniden yetkilendirmeniz gerekir.
refresh_token
özelliğini daha sonra ayarlamak için setCredentials
yöntemini kullanabilirsiniz:
oauth2Client.setCredentials({ refresh_token: `STORED_REFRESH_TOKEN` });
İstemci bir yenileme jetonu aldıktan sonra, erişim jetonları alınır ve bir sonraki API çağrısında otomatik olarak yenilenir.
HTTP/REST
Uygulamanız, bir erişim jetonunu yenilemek için Google'ın yetkilendirme sunucusuna (https://oauth2.googleapis.com/token
) aşağıdaki parametreleri içeren bir HTTPS POST
isteği gönderir:
Alanlar | |
---|---|
client_id |
API Consoleöğesinden alınan istemci kimliği. |
client_secret |
API Consoleöğesinden alınan istemci gizli anahtarı. |
grant_type |
OAuth 2.0 spesifikasyonunda tanımlandığı gibi, bu alanın değeri refresh_token olarak ayarlanmalıdır. |
refresh_token |
Yetkilendirme kodu exchange'inden döndürülen yenileme jetonu. |
Aşağıdaki snippet'te örnek bir istek gösterilmektedir:
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
Kullanıcı, uygulamaya verilen erişimi iptal etmediği sürece jeton sunucusu, yeni bir erişim jetonu içeren bir JSON nesnesi döndürür. Aşağıdaki snippet'te örnek bir yanıt gösterilmektedir:
{ "access_token": "1/fFAGRNJru1FTz70BzhT3Zg", "expires_in": 3920, "scope": "https://www.googleapis.com/auth/drive.metadata.readonly", "token_type": "Bearer" }
Verilecek yenileme jetonlarının sayısının sınırlı olduğunu unutmayın. Bunlar, tüm istemcilerde istemci/kullanıcı kombinasyonu başına bir ve kullanıcı başına başka bir sınırdır. Yenileme jetonlarını uzun süreli depolama alanına kaydetmeniz ve geçerli kaldıkları sürece kullanmaya devam etmeniz gerekir. Uygulamanız çok fazla yenileme jetonu isterse bu sınırlarla karşılaşabilir. Bu durumda, eski yenileme jetonları çalışmayı durdurur.
Jetonu iptal etme
Bazı durumlarda, bir kullanıcı bir uygulamaya verilen erişimi iptal etmek isteyebilir. Kullanıcı, Hesap Ayarları'na giderek erişimi iptal edebilir. Daha fazla bilgi için destek dokümanında, Hesabınıza erişimi olan üçüncü taraf siteler ve uygulamaların site veya uygulama erişimini kaldırma bölümüne bakın.
Bir uygulamanın, kendisine verilen erişimi programlı olarak iptal etmesi de mümkündür. Kullanıcının abonelikten çıktığı, bir uygulamayı kaldırdığı veya bir uygulamanın gerektirdiği API kaynaklarının önemli ölçüde değiştiği durumlarda programlı iptal önemlidir. Diğer bir deyişle, kaldırma sürecinin bir bölümü, uygulamaya daha önce verilmiş izinlerin kaldırıldığından emin olmak için bir API isteğini içerebilir.
PHP
Bir jetonu programlı olarak iptal etmek için revokeToken()
komutunu çağırın:
$client->revokeToken();
Python
Bir jetonu programatik olarak iptal etmek için https://oauth2.googleapis.com/revoke
üzerinde, jetonu parametre olarak içeren ve Content-Type
başlığını ayarlayan bir istek gönderin:
requests.post('https://oauth2.googleapis.com/revoke', params={'token': credentials.token}, headers = {'content-type': 'application/x-www-form-urlencoded'})
Ruby
Bir jetonu programatik olarak iptal etmek için oauth2.revoke
uç noktasına bir HTTP isteği gönderin:
uri = URI('https://oauth2.googleapis.com/revoke') response = Net::HTTP.post_form(uri, 'token' => auth_client.access_token)
Bu jeton bir erişim jetonu veya yenileme jetonu olabilir. Jeton bir erişim jetonuysa ve buna karşılık gelen bir yenileme jetonu varsa yenileme jetonu da iptal edilir.
İptal başarıyla işlenirse yanıtın durum kodu 200
olur. Hata koşulları için hata koduyla birlikte 400
durum kodu döndürülür.
Node.js
Bir jetonu programatik olarak iptal etmek için /revoke
uç noktasına HTTPS POST isteği gönderin:
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();
Jeton parametresi, bir erişim jetonu veya yenileme jetonu olabilir. Jeton bir erişim jetonuysa ve buna karşılık gelen bir yenileme jetonu varsa yenileme jetonu da iptal edilir.
İptal başarıyla işlenirse yanıtın durum kodu 200
olur. Hata koşulları için hata koduyla birlikte 400
durum kodu döndürülür.
HTTP/REST
Uygulamanız, bir jetonu programlı bir şekilde iptal etmek için https://oauth2.googleapis.com/revoke
kaynağına istek gönderir ve jetonu parametre olarak ekler:
curl -d -X -POST --header "Content-type:application/x-www-form-urlencoded" \ https://oauth2.googleapis.com/revoke?token={token}
Bu jeton bir erişim jetonu veya yenileme jetonu olabilir. Jeton bir erişim jetonuysa ve buna karşılık gelen bir yenileme jetonu varsa yenileme jetonu da iptal edilir.
İptal başarıyla işlenirse yanıtın HTTP durum kodu 200
olur. Hata koşulları için hata koduyla birlikte 400
HTTP durum kodu döndürülür.