Este documento explica como implementar a autorização OAuth 2.0 para acessar a API YouTube Analytics ou a API YouTube Reporting a partir de um aplicativo da Web JavaScript. O OAuth 2.0 permite que os usuários compartilham dados específicos com um aplicativo, mantendo seus nomes de usuário, senhas e outros manter a privacidade das informações. Por exemplo, um aplicativo pode usar OAuth 2.0 para obter permissões para recuperar os dados do YouTube Analytics de um canal.
Esse fluxo do OAuth 2.0 é chamado de fluxo de concessão implícito. Ele é projetado para aplicativos que acessam APIs somente enquanto o usuário está presente nele. Esses aplicativos não podem armazenar informações confidenciais.
Nesse fluxo, seu app abre um URL do Google que usa parâmetros de consulta para identificá-lo. e o tipo de acesso à API que o app exige. Você pode abrir o URL no navegador atual ou um pop-up. O usuário pode se autenticar com o Google e conceder as permissões solicitadas. Em seguida, o Google redireciona o usuário de volta para o app. O redirecionamento inclui um token de acesso, que o app verifica e usa para fazer solicitações de API.
Biblioteca de cliente das APIs do Google e Serviços de Identificação do Google
Se você usa a biblioteca de cliente de APIs do Google para JavaScript para fazer chamadas autorizadas para o Google, use Biblioteca JavaScript dos Serviços de Identificação do Google para processar o fluxo do OAuth 2.0. Consulte o Google Serviços de identidade" modelo de token, que é com base no fluxo de concessão implícita do OAuth 2.0.
Pré-requisitos
Ativar as APIs do projeto
Qualquer aplicativo que chame APIs do Google precisa ativar essas APIs no API Console:
Para ativar uma API para um projeto, faça o seguinte:
- Open the API Library no Google API Console.
- If prompted, select a project, or create a new one.
- Use a página "Biblioteca" para encontrar e ativar a API YouTube Analytics e a API YouTube Reporting. Muitos aplicativos que recuperam dados do YouTube Analytics também interagem com a API de dados do YouTube. Encontre e ative outras APIs que seu aplicativo vai usar.
Criar credenciais de autorização
Qualquer aplicativo que use o OAuth 2.0 para acessar as APIs do Google deve ter credenciais de autorização que identificam o aplicativo para o servidor OAuth 2.0 do Google. As etapas a seguir explicam como criar credenciais para seu projeto. Seus aplicativos podem usar as credenciais para acessar as APIs que você ativou nesse projeto.
- Go to the Credentials page.
- Clique em Criar credenciais > ID do cliente OAuth.
- Selecione o tipo de aplicativo Aplicativo da Web.
- Preencha o formulário. Aplicativos que usam JavaScript para fazer solicitações autorizadas da API do Google precisa especificar as origens do JavaScript autorizadas. As origens identificam os domínios na qual seu aplicativo pode enviar solicitações para o servidor OAuth 2.0. Essas origens precisam aderir às regras de validação do Google.
Identificar escopos de acesso
Os escopos permitem que seu aplicativo solicite acesso apenas aos recursos necessários permitindo que os usuários controlem a quantidade de acesso que eles concedem ao aplicativo. Portanto, há pode ser uma relação inversa entre o número de escopos solicitados e a probabilidade de obter o consentimento do usuário.
Antes de começar a implementar a autorização do OAuth 2.0, recomendamos que você identifique os escopos que o app precisa de permissão para acessar.
A API YouTube Analytics usa os seguintes escopos:
| Scopes | |
|---|---|
| https://www.googleapis.com/auth/youtube | Gerenciar sua conta do YouTube |
| https://www.googleapis.com/auth/youtube.readonly | Visualize sua conta do YouTube |
| https://www.googleapis.com/auth/youtubepartner | Visualize e gerencie seus ativos e conteúdo associado no YouTube |
| https://www.googleapis.com/auth/yt-analytics-monetary.readonly | Visualize relatórios monetários e não monetários do YouTube Analytics para seu conteúdo do YouTube |
| https://www.googleapis.com/auth/yt-analytics.readonly | Visualize relatórios do YouTube Analytics para seu conteúdo do YouTube |
A API YouTube Reporting usa os seguintes escopos:
| Scopes | |
|---|---|
| https://www.googleapis.com/auth/yt-analytics-monetary.readonly | Visualize relatórios monetários e não monetários do YouTube Analytics para seu conteúdo do YouTube |
| https://www.googleapis.com/auth/yt-analytics.readonly | Visualize relatórios do YouTube Analytics para seu conteúdo do YouTube |
O documento Escopos da API OAuth 2.0 contém um lista de escopos que você pode usar para acessar as APIs do Google.
Como conseguir tokens de acesso do OAuth 2.0
As etapas a seguir mostram como seu aplicativo interage com o servidor OAuth 2.0 do Google para receber o consentimento de um usuário para executar uma solicitação de API em nome dele. Seu aplicativo precisa ter consentimento antes de executar uma solicitação de API do Google que exija a autorização do usuário.
Etapa 1: redirecionar para o servidor OAuth 2.0 do Google
Para solicitar permissão de acesso aos dados de um usuário, redirecione o usuário para o OAuth 2.0 do Google servidor.
Endpoints do OAuth 2.0
Gere um URL para solicitar acesso ao endpoint OAuth 2.0 do Google em
https://accounts.google.com/o/oauth2/v2/auth: Esse endpoint é acessível por HTTPS.
conexões HTTP simples são recusadas.
O servidor de autorização do Google aceita os seguintes parâmetros de string de consulta para aplicativos de servidor:
| Parâmetros | |||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
client_id |
Obrigatório
O ID do cliente do aplicativo. É possível encontrar esse valor API Console Credentials page. |
||||||||||||||||||
redirect_uri |
Obrigatório
Determina para onde o servidor da API redireciona o usuário depois que ele conclui a
fluxo de autorização. O valor deve corresponder exatamente a um dos URIs de redirecionamento autorizados para
o cliente OAuth 2.0, que você configurou no
API Console
Credentials page. Se esse valor não corresponder a um
URI de redirecionamento autorizado para o Observe que o esquema, a capitalização e a barra final |
||||||||||||||||||
response_type |
Obrigatório
Aplicativos JavaScript precisam definir o valor do parâmetro como |
||||||||||||||||||
scope |
Obrigatório
Um delimitado por espaço lista de escopos que identificam os recursos que seu aplicativo pode acessar na em nome do usuário. Esses valores informam a tela de consentimento que o Google exibe ao usuário. Os escopos permitem que o aplicativo solicite acesso apenas aos recursos necessários além de permitir que os usuários controlem a quantidade de acesso que eles concedem aos seus para o aplicativo. Desse modo, há uma relação inversa entre o número de escopos solicitados e a probabilidade de obter o consentimento do usuário. A API YouTube Analytics usa os seguintes escopos:
A API YouTube Reporting usa os seguintes escopos:
O documento Escopos da API OAuth 2.0 fornece uma lista completa de escopos que podem ser usados para acessar as APIs do Google. Recomendamos que seu aplicativo solicite acesso aos escopos de autorização no contexto sempre que possível. Ao solicitar acesso aos dados do usuário no contexto, por meio de autorização incremental, você ajuda os usuários a entender por que seu aplicativo precisa do acesso que está solicitando. |
||||||||||||||||||
state |
Recomendado
Especifica qualquer valor de string que seu aplicativo usa para manter o estado entre suas
solicitação de autorização e a resposta do servidor de autorização.
O servidor retorna o valor exato que você envia como um par Esse parâmetro pode ser usado para várias finalidades, como direcionar o usuário para o
o recurso correto no aplicativo, enviando valores de uso único e reduzindo solicitações entre sites.
falsificação. Como seu |
||||||||||||||||||
include_granted_scopes |
Opcional
Permite que os aplicativos usem a autorização incremental para solicitar acesso a mais
escopos no contexto. Se você definir o valor desse parâmetro como |
||||||||||||||||||
enable_granular_consent |
Opcional
O valor padrão é Quando o Google ativa permissões granulares para um aplicativo, esse parâmetro não será não terão mais efeito. |
||||||||||||||||||
login_hint |
Opcional
Caso seu aplicativo saiba qual usuário está tentando autenticar, ele pode usar esse parâmetro para fornecer uma dica ao servidor de autenticação do Google. O servidor usa a dica para simplificar o fluxo de login preenchendo automaticamente o campo de e-mail no formulário de login ou selecionar a sessão de login múltiplo apropriada. Defina o valor do parâmetro como um endereço de e-mail ou identificador |
||||||||||||||||||
prompt |
Opcional
Uma lista de comandos para apresentar ao usuário, delimitada por espaços e que diferencia maiúsculas de minúsculas. Se você não especifique esse parâmetro, o usuário receberá a solicitação apenas na primeira vez que seu projeto solicita acesso. Consulte Solicitar novo consentimento para mais informações. Os valores possíveis são:
|
||||||||||||||||||
Exemplo de redirecionamento para o servidor de autorização do Google
O URL de exemplo abaixo solicita acesso off-line
(access_type=offline) para um escopo que permite o acesso recuperar
os relatórios do YouTube Analytics do usuário. Ele usa autorização incremental para
garantir que o novo token de acesso abranja os escopos aos quais o usuário
que receberam o acesso ao aplicativo. O URL também define valores para o campo
redirect_uri, response_type e
client_id, bem como para o state
. O URL contém quebras de linha e espaços para facilitar a leitura.
https://accounts.google.com/o/oauth2/v2/auth?
scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fyt-analytics.readonly&
include_granted_scopes=true&
state=state_parameter_passthrough_value&
redirect_uri=http%3A%2F%2Flocalhost%2Foauth2callback&
response_type=token&
client_id=client_id
Depois de criar o URL da solicitação, redirecione o usuário para ele.
Exemplo de código JavaScript
O snippet de JavaScript a seguir mostra como iniciar o fluxo de autorização em JavaScript sem usar a biblioteca de cliente das APIs do Google para JavaScript. Como esse OAuth 2.0 não suporta o Compartilhamento de recursos entre origens (CORS), o snippet cria um formulário que abre a solicitação para esse endpoint.
/*
* Create form to request access token from Google's OAuth 2.0 server.
*/
function oauthSignIn() {
// Google's OAuth 2.0 endpoint for requesting an access token
var oauth2Endpoint = 'https://accounts.google.com/o/oauth2/v2/auth';
// Create <form> element to submit parameters to OAuth 2.0 endpoint.
var form = document.createElement('form');
form.setAttribute('method', 'GET'); // Send as a GET request.
form.setAttribute('action', oauth2Endpoint);
// Parameters to pass to OAuth 2.0 endpoint.
var params = {'client_id': 'YOUR_CLIENT_ID',
'redirect_uri': 'YOUR_REDIRECT_URI',
'response_type': 'token',
'scope': 'https://www.googleapis.com/auth/yt-analytics.readonly',
'include_granted_scopes': 'true',
'state': 'pass-through value'};
// Add form parameters as hidden input values.
for (var p in params) {
var input = document.createElement('input');
input.setAttribute('type', 'hidden');
input.setAttribute('name', p);
input.setAttribute('value', params[p]);
form.appendChild(input);
}
// Add form to page and submit it to open the OAuth 2.0 endpoint.
document.body.appendChild(form);
form.submit();
}
Etapa 2: o Google solicita o consentimento do usuário
Nesta etapa, o usuário decide se quer conceder o acesso solicitado ao seu aplicativo. Neste etapa, o Google exibe uma janela de consentimento com o nome do seu aplicativo e a API do Google serviços que está solicitando permissão de acesso com as credenciais de autorização do usuário. um resumo dos escopos de acesso a serem concedidos. O o usuário poderá então consentir em conceder acesso a um ou mais escopos solicitados por seu aplicativo ou recusar a solicitação.
O aplicativo não precisa fazer nada nessa etapa, já que aguarda a resposta Servidor OAuth 2.0 do Google indicando se algum acesso foi concedido. Essa resposta é explicada em próxima etapa.
Erros
As solicitações para o endpoint de autorização do OAuth 2.0 do Google podem exibir mensagens de erro voltadas para o usuário em vez dos fluxos de autenticação e autorização esperados. Códigos de erro comuns e sugestões resoluções estão listadas abaixo.
admin_policy_enforced
A Conta do Google não pode autorizar um ou mais escopos solicitados devido às políticas de administrador do Google Workspace. Consulte o artigo de ajuda para admins do Google Workspace Controle quais aplicativos de terceiros apps internos acessam dados do Google Workspace para mais informações sobre como um administrador pode restringir o acesso a todos os escopos ou informações escopos restritos até que o acesso seja explicitamente concedido ao seu ID do cliente OAuth.
disallowed_useragent
O endpoint de autorização é exibido dentro de um user agent incorporado não permitido pelo Políticas do OAuth 2.0.
Android
Os desenvolvedores Android podem encontrar essa mensagem de erro ao abrir solicitações de autorização no
android.webkit.WebView
Em vez disso, os desenvolvedores devem usar bibliotecas Android, como
Login do Google para Android ou do OpenID Foundation
AppAuth para Android.
Os desenvolvedores Web podem encontrar esse erro quando um app Android abre um link geral da Web em uma user agent incorporado e um usuário navegar até o endpoint de autorização OAuth 2.0 do Google seu site. Os desenvolvedores devem permitir que links gerais sejam abertos no gerenciador de links padrão do do Google, o que inclui Links do app Android ou o app de navegador padrão. O Guias personalizadas do Android também é uma opção com suporte.
iOS
Os desenvolvedores de iOS e macOS podem encontrar esse erro ao abrir solicitações de autorização no
WKWebView
Em vez disso, os desenvolvedores devem usar bibliotecas iOS como
Login do Google para iOS ou do OpenID Foundation
AppAuth para iOS.
Os desenvolvedores Web podem encontrar esse erro quando um app para iOS ou macOS abre um link geral da Web em
um user agent incorporado e um usuário navegar até o endpoint de autorização do OAuth 2.0 do Google
seu site. Os desenvolvedores devem permitir que links gerais sejam abertos no gerenciador de links padrão do
do Google, o que inclui
Links universais
ou o app de navegador padrão. O
SFSafariViewController
também é uma opção com suporte.
org_internal
O ID do cliente OAuth da solicitação faz parte de um projeto que limita o acesso às Contas do Google em um específicas Organização do Google Cloud. Para mais informações sobre essa opção de configuração, consulte a Tipo de usuário no artigo de ajuda "Como configurar a tela de permissão OAuth".
invalid_client
A origem da qual a solicitação foi feita não está autorizada para este cliente. Consulte
origin_mismatch:
invalid_grant
Ao usar a autorização incremental, o token pode ter expirado ou foi invalidado. Autentique o usuário novamente e peça o consentimento dele para receber novos tokens. Se você estiver continuando encontrar esse erro, verifique se o aplicativo foi configurado corretamente e se você está usando os tokens e parâmetros corretos em sua solicitação. Caso contrário, a conta de usuário pode ter tenha sido excluída ou desativada.
origin_mismatch
O esquema, domínio e/ou porta do JavaScript que originou a solicitação de autorização não pode corresponder a um URI de origem JavaScript autorizado registrado no ID do cliente OAuth. Análise autorizada Origens do JavaScript no Google API Console Credentials page.
redirect_uri_mismatch
O redirect_uri transmitido na solicitação de autorização não corresponde a um
URI de redirecionamento para o ID do cliente OAuth. Revise os URIs de redirecionamento autorizados na
Google API Console Credentials page.
O esquema, domínio e/ou porta do JavaScript que originou a solicitação de autorização não pode corresponder a um URI de origem JavaScript autorizado registrado no ID do cliente OAuth. Análise origens do JavaScript autorizadas na Google API Console Credentials page.
O parâmetro redirect_uri pode se referir ao fluxo OAuth fora de banda (OOB) que tem
foi descontinuada e não tem mais suporte. Consulte a
guia de migração para atualizar seu
integração total.
invalid_request
Havia algo errado com a solicitação que você fez. Isso pode ocorrer por vários motivos:
- A solicitação não foi formatada corretamente
- Faltaram parâmetros obrigatórios na solicitação
- A solicitação usa um método de autorização incompatível com o Google. Verificar o OAuth usa um método de integração recomendado
Etapa 3: gerenciar a resposta do servidor OAuth 2.0
Endpoints do OAuth 2.0
O servidor OAuth 2.0 envia uma resposta para o redirect_uri especificado no
solicitação de token de acesso.
Se o usuário aprovar a solicitação, a resposta conterá um token de acesso. Se o usuário não aprovar a solicitação, a resposta conterá uma mensagem de erro. O token de acesso é retornada no fragmento de hash do URI de redirecionamento, conforme mostrado abaixo:
Uma resposta de token de acesso:
https://oauth2.example.com/callback#access_token=4/P7q7W91&token_type=Bearer&expires_in=3600
Além do parâmetro
access_token, a string do fragmento também contém o parâmetrotoken_type, que é sempre definido comoBearere o parâmetroexpires_in, que especifica do token, em segundos. Se o parâmetrostatetiver sido especificado na solicitação do token de acesso, seu valor também será incluído na resposta.- Uma resposta de erro:
https://oauth2.example.com/callback#error=access_denied
Exemplo de resposta do servidor OAuth 2.0
É possível testar esse fluxo clicando no exemplo de URL a seguir, que solicita acesso somente leitura para visualizar metadados de arquivos no Google Drive:
https://accounts.google.com/o/oauth2/v2/auth? scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fyt-analytics.readonly& include_granted_scopes=true& state=state_parameter_passthrough_value& redirect_uri=http%3A%2F%2Flocalhost%2Foauth2callback& response_type=token& client_id=client_id
Depois de concluir o fluxo do OAuth 2.0, você será redirecionado para
http://localhost/oauth2callback: Esse URL resultará em uma
404 NOT FOUND, a menos que sua máquina local exiba um arquivo em
esse endereço. A próxima etapa fornece mais detalhes sobre as informações retornadas
URI quando o usuário é redirecionado de volta para seu aplicativo.
Como chamar APIs do Google
Endpoints do OAuth 2.0
Depois que o aplicativo obtém um token de acesso, você pode usá-lo para fazer chamadas a um serviço
em nome de um determinado
conta de usuário se os escopos de acesso exigidos pela API tiverem sido concedidos. Para fazer isso, inclua
o token de acesso em uma solicitação à API incluindo uma consulta access_token
ou um valor Bearer do cabeçalho HTTP Authorization. Quando possível,
o cabeçalho HTTP é preferível, porque as strings de consulta tendem a ser visíveis nos registros do servidor. Na maioria
casos, você pode usar uma biblioteca de cliente para configurar suas chamadas para as APIs do Google (por exemplo, quando
chamando a API YouTube Analytics).
A API YouTube Analytics não é compatível com a conta de serviço fluxo A API YouTube Reporting oferece suporte a contas de serviço somente para Os proprietários de conteúdo do YouTube que possuem e gerenciam vários canais do YouTube, como como gravadoras e estúdios de cinema.
Você pode experimentar todas as APIs do Google e visualizar seus escopos em OAuth 2.0 Playground.
Exemplos GET HTTP
Uma chamada ao
reports.query
endpoint (a API YouTube Analytics) usando a solicitação HTTP Authorization: Bearer
pode ser semelhante ao seguinte. É necessário especificar seu próprio token de acesso:
GET /youtube/analytics/v1/reports?ids=channel%3D%3DMINE&start-date=2016-05-01&end-date=2016-06-30&metrics=views HTTP/1.1 Host: www.googleapis.com Authorization: Bearer access_token
Esta é uma chamada para a mesma API para o usuário autenticado com o access_token
parâmetro da string de consulta:
GET https://www.googleapis.com/youtube/analytics/v1/reports?access_token=access_token&ids=channel%3D%3DMINE&start-date=2016-05-01&end-date=2016-06-30&metrics=views
Exemplos de curl
É possível testar esses comandos com o aplicativo de linha de comando curl. Este é um
exemplo que usa a opção de cabeçalho HTTP (preferencial):
curl -H "Authorization: Bearer access_token" https://www.googleapis.com/youtube/analytics/v1/reports?ids=channel%3D%3DMINE&start-date=2016-05-01&end-date=2016-06-30&metrics=views
Ou, alternativamente, a opção do parâmetro da string de consulta:
curl https://www.googleapis.com/youtube/analytics/v1/reports?access_token=access_token&ids=channel%3D%3DMINE&start-date=2016-05-01&end-date=2016-06-30&metrics=views
Exemplo de código JavaScript
O snippet de código abaixo demonstra como usar o Compartilhamento de recursos entre origens (CORS) para enviar uma para uma API do Google. Este exemplo não usa a biblioteca de cliente de APIs do Google para JavaScript. No entanto, mesmo que você não esteja usando a biblioteca do cliente, a guia de suporte ao CORS na documentação da biblioteca provavelmente ajudará você para entender melhor essas solicitações.
Neste snippet de código, a variável access_token representa o token que você tem.
para fazer solicitações de API em nome do usuário autorizado. A página completa
example demonstra como armazenar esse token no armazenamento local do navegador e recuperá-lo
ao fazer uma solicitação de API.
var xhr = new XMLHttpRequest();
xhr.open('GET',
'https://www.googleapis.com/youtube/analytics/v1/reports?ids=channel%3D%3DMINE&start-date=2016-05-01&end-date=2016-06-30&metrics=views&' +
'access_token=' + params['access_token']);
xhr.onreadystatechange = function (e) {
console.log(xhr.response);
};
xhr.send(null);
Exemplo completo
Endpoints do OAuth 2.0
Este exemplo de código demonstra como completar o fluxo do OAuth 2.0 em JavaScript sem usar o Biblioteca cliente de APIs do Google para JavaScript. O código é de uma página HTML que exibe um botão para tente uma solicitação de API. Se você clicar no botão, o código verificará se a página armazenou uma Token de acesso à API no armazenamento local do navegador. Nesse caso, ele executa a solicitação de API. Caso contrário, ele inicia o fluxo do OAuth 2.0.
Para o fluxo do OAuth 2.0, a página segue estas etapas:
- Ele direciona o usuário para o servidor OAuth 2.0 do Google, que solicita acesso à
escopo
https://www.googleapis.com/auth/yt-analytics.readonly. - Após conceder (ou negar) acesso a um ou mais escopos solicitados, o usuário é redirecionado para página original, que analisa o token de acesso a partir da string do identificador de fragmento.
A página usa o token de acesso para fazer o exemplo de solicitação de API.
Esta solicitação de API chama o método
reports.queryda API YouTube Analytics para recuperar contagens de visualização para o canal do YouTube do usuário autorizado.- Se a solicitação for executada com êxito, a resposta da API será registrada no arquivo de depuração do navegador no console do Google Cloud.
É possível revogar o acesso ao app pela página Permissões para sua Conta do Google. O aplicativo estará listado como OAuth 2.0 Demo for Google API Docs.
Para executar esse código localmente, você precisa definir valores para o YOUR_CLIENT_ID e
YOUR_REDIRECT_URI variáveis que correspondem à sua
credenciais de autorização. A variável YOUR_REDIRECT_URI
deve ser definido como o mesmo URL em que a página é veiculada. O valor precisa corresponder exatamente a
os URIs de redirecionamento autorizados para o cliente OAuth 2.0, que você configurou no
API Console Credentials page. Se
esse valor não corresponder a um URI autorizado, você vai receber um redirect_uri_mismatch
erro. Seu projeto também deve ter
ativou a API apropriada para a solicitação.
<html><head></head><body>
<script>
var YOUR_CLIENT_ID = 'REPLACE_THIS_VALUE';
var YOUR_REDIRECT_URI = 'REPLACE_THIS_VALUE';
// Parse query string to see if page request is coming from OAuth 2.0 server.
var fragmentString = location.hash.substring(1);
var params = {};
var regex = /([^&=]+)=([^&]*)/g, m;
while (m = regex.exec(fragmentString)) {
params[decodeURIComponent(m[1])] = decodeURIComponent(m[2]);
}
if (Object.keys(params).length > 0 && params['state']) {
if (params['state'] == localStorage.getItem('state')) {
localStorage.setItem('oauth2-test-params', JSON.stringify(params) );
trySampleRequest();
} else {
console.log('State mismatch. Possible CSRF attack');
}
}
// Function to generate a random state value
function generateCryptoRandomState() {
const randomValues = new Uint32Array(2);
window.crypto.getRandomValues(randomValues);
// Encode as UTF-8
const utf8Encoder = new TextEncoder();
const utf8Array = utf8Encoder.encode(
String.fromCharCode.apply(null, randomValues)
);
// Base64 encode the UTF-8 data
return btoa(String.fromCharCode.apply(null, utf8Array))
.replace(/\+/g, '-')
.replace(/\//g, '_')
.replace(/=+$/, '');
}
// If there's an access token, try an API request.
// Otherwise, start OAuth 2.0 flow.
function trySampleRequest() {
var params = JSON.parse(localStorage.getItem('oauth2-test-params'));
if (params && params['access_token']) {
var xhr = new XMLHttpRequest();
xhr.open('GET',
'https://www.googleapis.com/youtube/analytics/v1/reports?ids=channel%3D%3DMINE&start-date=2016-05-01&end-date=2016-06-30&metrics=views&' +
'access_token=' + params['access_token']);
xhr.onreadystatechange = function (e) {
if (xhr.readyState === 4 && xhr.status === 200) {
console.log(xhr.response);
} else if (xhr.readyState === 4 && xhr.status === 401) {
// Token invalid, so prompt for user permission.
oauth2SignIn();
}
};
xhr.send(null);
} else {
oauth2SignIn();
}
}
/*
* Create form to request access token from Google's OAuth 2.0 server.
*/
function oauth2SignIn() {
// create random state value and store in local storage
var state = generateCryptoRandomState();
localStorage.setItem('state', state);
// Google's OAuth 2.0 endpoint for requesting an access token
var oauth2Endpoint = 'https://accounts.google.com/o/oauth2/v2/auth';
// Create element to open OAuth 2.0 endpoint in new window.
var form = document.createElement('form');
form.setAttribute('method', 'GET'); // Send as a GET request.
form.setAttribute('action', oauth2Endpoint);
// Parameters to pass to OAuth 2.0 endpoint.
var params = {'client_id': YOUR_CLIENT_ID,
'redirect_uri': YOUR_REDIRECT_URI,
'scope': 'https://www.googleapis.com/auth/yt-analytics.readonly',
'state': state,
'include_granted_scopes': 'true',
'response_type': 'token'};
// Add form parameters as hidden input values.
for (var p in params) {
var input = document.createElement('input');
input.setAttribute('type', 'hidden');
input.setAttribute('name', p);
input.setAttribute('value', params[p]);
form.appendChild(input);
}
// Add form to page and submit it to open the OAuth 2.0 endpoint.
document.body.appendChild(form);
form.submit();
}
</script>
<button onclick="trySampleRequest();">Try sample request</button>
</body></html>
Regras de validação de origem do JavaScript
O Google aplica as seguintes regras de validação às origens do JavaScript para ajudar desenvolvedores a proteger os aplicativos. Suas origens do JavaScript precisam aderir a essas regras. Consulte a seção 3 do RFC 3986 para os definição de domínio, host e esquema mencionada abaixo.
| Regras de validação | |
|---|---|
| Esquema |
As origens do JavaScript precisam usar o esquema HTTPS, não HTTP simples. URIs do host local (incluindo URIs de endereço IP do localhost) estão isentos dessa regra. |
| Host |
Os hosts não podem ser endereços IP brutos. Os endereços IP do host local estão isentos dessa regra. |
| Domínio |
“googleusercontent.com”.goo.gl)
a menos que o app seja proprietário do domínio. |
| Userinfo (link em inglês) |
As origens do JavaScript não podem conter o subcomponente userinfo. |
| Caminho |
As origens do JavaScript não podem conter o componente do caminho. |
| Consulta |
As origens do JavaScript não podem conter o componente de consulta. |
| Fragmentos |
As origens do JavaScript não podem conter o componente de fragmento. |
| Personagens |
As origens do JavaScript não podem conter determinados caracteres, incluindo:
|
Autorização incremental
No protocolo OAuth 2.0, o aplicativo solicita autorização para acessar recursos, que são identificados por escopos. Solicitar autorização é uma prática recomendada para a experiência do usuário recursos no momento em que você precisa deles. Para isso, o servidor de autorização do Google dá suporte à autorização incremental. Esse recurso permite solicitar escopos conforme eles são necessários. se o usuário conceder permissão para o novo escopo, retorna um código de autorização que pode ser trocado por um token que contém todos os escopos concedidos pelo usuário ao projeto.
Por exemplo, suponha que um aplicativo recupere relatórios do YouTube Analytics, alguns
que são relatórios monetários que exigem acesso a um escopo adicional, não
necessários para outros relatórios. Nesse caso, no momento do login, o app pode apenas
solicitar acesso ao
escopo https://www.googleapis.com/auth/yt-analytics.readonly.
No entanto, se o usuário tentasse recuperar um relatório monetário, o aplicativo também poderia
solicitar acesso ao
https://www.googleapis.com/auth/yt-analytics-monetary.readonly
do projeto.
As regras a seguir se aplicam a um token de acesso recebido de uma autorização incremental:
- O token pode ser usado para acessar recursos correspondentes a qualquer um dos escopos incluídos nova autorização combinada.
- Quando você usa o token de atualização para a autorização combinada para obter um token de acesso, o
token de acesso representa a autorização combinada e pode ser usado para qualquer um
Valores
scopeincluídos na resposta. - A autorização combinada inclui todos os escopos que o usuário concedeu ao projeto de API, mesmo se as concessões foram solicitadas por clientes diferentes. Por exemplo, se um usuário deu acesso a um escopo usando o cliente de desktop de um aplicativo e, em seguida, concedia outro escopo para o mesmo por um cliente móvel, a autorização combinada incluiria os dois escopos.
- Se você revogar um token que representa uma autorização combinada, o acesso a todos esses escopos de autorização em nome do usuário associado são revogados simultaneamente.
Os exemplos de código abaixo mostram como adicionar escopos a um token de acesso existente. Essa abordagem permite seu app para evitar ter que gerenciar múltiplos tokens de acesso.
Endpoints do OAuth 2.0
Neste exemplo, o aplicativo de chamada solicita acesso para recuperar o dados do YouTube Analytics do usuário, além de qualquer outro acesso que ele já concedeu ao aplicativo.
Para adicionar escopos a um token de acesso atual, inclua o include_granted_scopes
na sua solicitação para o servidor OAuth 2.0 do Google.
O snippet de código abaixo demonstra como fazer isso. O snippet presume que você armazenou
os escopos para os quais seu token de acesso é válido no armazenamento local do navegador. O
O código de exemplo completo armazena uma lista de escopos para os quais o token de acesso
é válido definindo a propriedade oauth2-test-params.scope no valor
storage.)
O snippet compara os escopos nos quais o token de acesso é válido com o escopo que você quer usar
para uma consulta específica. Se o token de acesso não abranger esse escopo, o fluxo do OAuth 2.0 será iniciado.
Aqui, a função oauth2SignIn é a mesma que foi fornecida no
etapa 2 (e é fornecida mais tarde na etapa
exemplo).
var SCOPE = 'https://www.googleapis.com/auth/yt-analytics.readonly';
var params = JSON.parse(localStorage.getItem('oauth2-test-params'));
var current_scope_granted = false;
if (params.hasOwnProperty('scope')) {
var scopes = params['scope'].split(' ');
for (var s = 0; s < scopes.length; s++) {
if (SCOPE == scopes[s]) {
current_scope_granted = true;
}
}
}
if (!current_scope_granted) {
oauth2SignIn(); // This function is defined elsewhere in this document.
} else {
// Since you already have access, you can proceed with the API request.
}
Revogação de um token
Em alguns casos, um usuário pode querer revogar o acesso concedido a um aplicativo. Um usuário pode revogar o acesso acessando Configurações da conta. Consulte a Remover seção de acesso a sites ou apps da lista Sites de terceiros e apps com acesso à sua conta documento de suporte para mais informações.
Também é possível para um aplicativo revogar programaticamente o acesso concedido a ele. A revogação programática é importante nos casos em que um usuário cancela a inscrição, remove uma aplicativo ou os recursos de API exigidos por um aplicativo tiverem mudado significativamente. Em outras palavras, do processo de remoção pode incluir uma solicitação de API para garantir que as permissões anteriores concedidas ao aplicativo são removidas.
Endpoints do OAuth 2.0
Para revogar programaticamente um token, seu aplicativo faz uma solicitação para
https://oauth2.googleapis.com/revoke e inclui o token como um parâmetro:
curl -d -X -POST --header "Content-type:application/x-www-form-urlencoded" \
https://oauth2.googleapis.com/revoke?token={token}
O token pode ser um token de acesso ou de atualização. Se o token for de acesso e tiver um token de atualização correspondente, o token de atualização também será revogado.
Se a revogação for processada com sucesso, o código de status HTTP da resposta será
200: Para condições de erro, um código de status HTTP 400 é retornado junto
com um código de erro.
O snippet de JavaScript a seguir mostra como revogar um token em JavaScript sem usar a propriedade
Biblioteca cliente de APIs do Google para JavaScript. Como o endpoint OAuth 2.0 do Google para revogação
não oferece suporte ao Compartilhamento de recursos entre origens (CORS), o código cria um formulário e envia
o formulário no endpoint em vez de usar o método XMLHttpRequest() para publicar a
solicitação.
function revokeAccess(accessToken) {
// Google's OAuth 2.0 endpoint for revoking access tokens.
var revokeTokenEndpoint = 'https://oauth2.googleapis.com/revoke';
// Create <form> element to use to POST data to the OAuth 2.0 endpoint.
var form = document.createElement('form');
form.setAttribute('method', 'post');
form.setAttribute('action', revokeTokenEndpoint);
// Add access token to the form so it is set as value of 'token' parameter.
// This corresponds to the sample curl request, where the URL is:
// https://oauth2.googleapis.com/revoke?token={token}
var tokenField = document.createElement('input');
tokenField.setAttribute('type', 'hidden');
tokenField.setAttribute('name', 'token');
tokenField.setAttribute('value', accessToken);
form.appendChild(tokenField);
// Add form to page and submit it to actually revoke the token.
document.body.appendChild(form);
form.submit();
}