Usar o OAuth 2.0 para aplicativos de servidor para servidor

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.
Para mais informações, consulte Visão geral da autenticação na documentação do Google Cloud Platform.

O sistema Google OAuth 2.0 é compatível com interações de servidor para servidor, como as entre um aplicativo da Web e um serviço do Google. Para este cenário, você precisa de uma conta de serviço, que pertence ao aplicativo, e não a um usuário final individual. Seu aplicativo chama as APIs do Google em nome da conta de serviço para que os usuários não se envolvam diretamente. Este cenário às vezes é chamado de "OAuth de duas etapas" ou "2LO." O termo relacionado "OAuth de três pernas" se refere às situações em que seu aplicativo chama APIs do Google em nome de usuários finais, em que o consentimento do usuário às vezes é necessário.

Normalmente, um aplicativo usa uma conta de serviço quando usa APIs do Google para trabalhar com os próprios dados, em vez de dados do usuário. Por exemplo, um aplicativo que usa o Google Cloud Datastore para persistência de dados usa uma conta de serviço para autenticar as chamadas para a API Google Cloud Datastore.

Os administradores de domínios do Google Workspace também podem conceder às contas de serviço uma autoridade em todo o domínio para acessar os dados dos usuários em nome dos usuários no domínio.

Este documento descreve como um aplicativo pode concluir o fluxo do OAuth 2.0 de servidor para servidor usando uma biblioteca de cliente das APIs do Google (recomendado) ou HTTP.

Visão geral

Para oferecer compatibilidade com interações de servidor para servidor, primeiro crie uma conta de serviço para seu projeto no . Se você quiser acessar os dados dos usuários na sua conta do Google Workspace, delegue o acesso de todo o domínio à conta de serviço.

Em seguida, o aplicativo se prepara para fazer chamadas de API autorizadas usando as credenciais da conta de serviço para solicitar um token de acesso do servidor de autenticação OAuth 2.0.

Por fim, o aplicativo pode usar o token de acesso para chamar as APIs do Google.

Como criar uma conta de serviço

As credenciais de uma conta de serviço incluem um endereço de e-mail gerado que seja exclusivo e pelo menos um par de chaves públicas/privadas. Se a delegação em todo o domínio estiver ativada, um ID do cliente também fará parte das credenciais da conta de serviço.

Quando o aplicativo é executado no Google App Engine, uma conta de serviço é configurada automaticamente quando o projeto é criado.

Se o aplicativo for executado no Google Compute Engine, uma conta de serviço também será configurada automaticamente quando você criar o projeto. No entanto, será preciso especificar os escopos aos quais o aplicativo precisa acessar ao criar uma instância do Google Compute Engine. Para mais informações, consulte Como preparar uma instância para usar contas de serviço.

Se o aplicativo não for executado no Google App Engine ou no Google Compute Engine, consiga essas credenciais na . Para gerar credenciais de conta de serviço ou ver as credenciais públicas que você já gerou, faça o seguinte:

Primeiro, crie uma conta de serviço:

  1. Abra a Service accounts page.
  2. If prompted, select a project, or create a new one.
  3. Clique Criar conta de serviço.
  4. Sob os detalhes da conta de Serviços, digite um nome, ID, e uma descrição para a conta de serviço, clique em Criar e continuar.
  5. Opcional: Sob Grant este acesso da conta do serviço de projeto, selecione as funções do IAM para conceder à conta de serviço.
  6. Clique em Continuar.
  7. Opcional: Sob Grant usuários o acesso a esta conta do serviço, adicione os usuários ou grupos que têm permissão para usar e gerenciar a conta do serviço.
  8. Clique em Concluído.
  9. Clique Criar chave, clique em Criar.

Em seguida, crie uma chave de conta de serviço:

  1. Clique no endereço de e-mail da conta de serviço que você criou.
  2. Clique na guia Chaves.
  3. Na lista Add-chave drop-down, selecione Criar nova chave.
  4. Clique em Criar.

Seu novo par de chaves pública / privada é gerado e baixado para sua máquina; ele serve como a única cópia da chave privada. Você é responsável por armazená-lo com segurança. Se você perder este par de chaves, precisará gerar um novo.

Você pode voltar ao API Console a qualquer momento para ver o endereço de e-mail, as impressões públicas da chave e outras informações ou gerar outros pares de chaves públicas/privadas. Para mais detalhes sobre credenciais de conta de serviço no API Console, consulte Contas de serviço no arquivo de ajuda API Console.

Anote o endereço de e-mail da conta de serviço e armazene o arquivo de chave privada dela em um local acessível ao aplicativo. Seu aplicativo precisa deles para fazer chamadas de API autorizadas.

Delegar autoridade em todo o domínio à conta de serviço

Se você tem uma conta do Google Workspace, um administrador da organização pode autorizar um aplicativo a acessar os dados dos usuários em nome dos usuários no domínio do Google Workspace. Por exemplo, um aplicativo que usa a API Google Calendar para adicionar eventos às agendas de todos os usuários em um domínio do Google Workspace usará uma conta de serviço para acessar essa API em nome de usuários. Autorizar uma conta de serviço a acessar dados em nome de usuários em um domínio é, às vezes, chamado de "delegar autoridade em todo o domínio" a uma conta de serviço.

Para delegar a autoridade de todo o domínio a uma conta de serviço, siga as seguintes etapas em um superadministrador do domínio do Google Workspace:

  1. No Admin Console do domínio do Google Workspace, acesse Menu principal > Segurança > Acesso e controle de dados > Controles de API.
  2. No painel Delegação em todo o domínio, selecione Gerenciar a delegação em todo o domínio.
  3. clique em Add new;
  4. No campo ID do cliente, insira o ID do cliente da conta de serviço. Localize o ID do cliente da sua conta de serviço em Service accounts page.
  5. No campo Escopos OAuth (delimitado por vírgulas), insira a lista de escopos aos quais seu aplicativo deve receber acesso. Por exemplo, se o aplicativo precisar de acesso total ao domínio à API Google Drive e à API Google Calendar, digite: https://www.googleapis.com/auth/drive, https://www.googleapis.com/auth/calendar.
  6. Clique em Autorizar.

Agora, seu aplicativo tem autoridade para fazer chamadas de API como usuários no seu domínio (para "quot;personperson""). Ao se preparar para fazer chamadas de API autorizadas, você especifica o usuário a ser representado.

Como se preparar para fazer uma chamada de API autorizada

Java

Depois de conseguir o endereço de e-mail e a chave privada do cliente no API Console, use a Biblioteca de cliente das APIs do Google para Java para criar um objeto GoogleCredential com as credenciais da conta de serviço e os escopos aos quais o aplicativo precisa acessar. Exemplo:

import com.google.api.client.googleapis.auth.oauth2.GoogleCredential;
import com.google.api.services.sqladmin.SQLAdminScopes;

// ...

GoogleCredential credential = GoogleCredential.fromStream(new FileInputStream("MyProject-1234.json"))
    .createScoped(Collections.singleton(SQLAdminScopes.SQLSERVICE_ADMIN));

Se você estiver desenvolvendo um aplicativo no Google Cloud Platform, use as credenciais padrão do aplicativo para simplificar o processo.

Delegar autoridade em todo o domínio

Se você tiver delegado acesso de todo o domínio à conta de serviço e quiser representar uma conta de usuário, especifique o endereço de e-mail da conta de usuário com o método createDelegated do objeto GoogleCredential. Por exemplo:

GoogleCredential credential = GoogleCredential.fromStream(new FileInputStream("MyProject-1234.json"))
    .createScoped(Collections.singleton(SQLAdminScopes.SQLSERVICE_ADMIN))
    .createDelegated("user@example.com");

Use o objeto GoogleCredential para chamar as APIs do Google no seu app.

Python

Depois de conseguir o endereço de e-mail e a chave privada do cliente no API Console, use a Biblioteca de cliente das APIs do Google para Python para concluir as seguintes etapas:

  1. Crie um objeto Credentials com as credenciais da conta de serviço e os escopos aos quais o aplicativo precisa acessar. Por exemplo:
    from google.oauth2 import service_account
    
    SCOPES = ['https://www.googleapis.com/auth/sqlservice.admin']
    SERVICE_ACCOUNT_FILE = '/path/to/service.json'
    
    credentials = service_account.Credentials.from_service_account_file(
            SERVICE_ACCOUNT_FILE, scopes=SCOPES)

    Se você estiver desenvolvendo um aplicativo no Google Cloud Platform, use as credenciais padrão do aplicativo para simplificar o processo.

  2. Delegar autoridade em todo o domínio

    Se você tiver delegado o acesso de todo o domínio à conta de serviço e quiser representar uma conta de usuário, use o método with_subject de um objeto ServiceAccountCredentials existente. Exemplo:

    delegated_credentials = credentials.with_subject('user@example.org')

Use o objeto Credentials para chamar as APIs do Google no seu aplicativo.

HTTP/REST

Depois de receber o ID do cliente e a chave privada do API Console, seu aplicativo precisa concluir as seguintes etapas:

  1. Crie um JSON Web Token (JWT, pronunciado, "jot") que inclua um cabeçalho, um conjunto de declarações e uma assinatura.
  2. Solicite um token de acesso do servidor de autorização do Google OAuth 2.0.
  3. Gerencie a resposta JSON que o servidor de autorização retorna.

As seções a seguir descrevem como concluir essas etapas.

Se a resposta incluir um token de acesso, será possível usá-lo para chamar uma API do Google. Se a resposta não incluir um token de acesso, a solicitação de JWT e o token talvez não sejam formatados corretamente ou a conta de serviço não tenha permissão para acessar os escopos solicitados.

Quando o token de acesso expira, seu aplicativo gera outro JWT, assina-o e solicita outro token de acesso.

O aplicativo de servidor usa um JWT para solicitar um token do servidor de autorização do Google e, em seguida, usa o token para chamar um endpoint da API do Google. Nenhum usuário final está envolvido.

O restante desta seção descreve as especificidades da criação de um JWT, assinatura do JWT, formação da solicitação de token de acesso e processamento da resposta.

Como criar um JWT

Um JWT é composto de três partes: um cabeçalho, um conjunto de declarações e uma assinatura. O cabeçalho e o conjunto de declarações são objetos JSON. Esses objetos JSON são serializados em bytes UTF-8 e, em seguida, codificados usando a codificação Base64url. Essa codificação oferece resiliência às mudanças de codificação devido a operações de codificação repetidas. O cabeçalho, o conjunto de declarações e a assinatura são concatenados com um caractere de ponto (.).

Um JWT é composto desta maneira:

{Base64url encoded header}.{Base64url encoded claim set}.{Base64url encoded signature}

A string de base da assinatura é a seguinte:

{Base64url encoded header}.{Base64url encoded claim set}
Como formar o cabeçalho JWT

O cabeçalho consiste em dois campos que indicam o algoritmo de assinatura e o formato da declaração. Ambos os campos são obrigatórios, e cada um tem apenas um valor. À medida que mais algoritmos e formatos são introduzidos, esse cabeçalho muda de acordo com as informações.

As contas de serviço dependem do algoritmo RSA SHA-256 e do formato de token JWT. Como resultado, a representação JSON do cabeçalho é a seguinte:

{"alg":"RS256","typ":"JWT"}

A representação Base64url disso é a seguinte:

eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9
Como criar o conjunto de declarações JWT

O conjunto de declarações JWT contém informações sobre o JWT, incluindo as permissões solicitadas (escopos), o destino do token, o emissor, a hora em que o token foi emitido e o ciclo de vida dele. A maioria dos campos é obrigatória. Assim como o cabeçalho JWT, o conjunto de declarações JWT é um objeto JSON e é usado no cálculo da assinatura.

Reivindicações obrigatórias

As reivindicações obrigatórias no conjunto de declarações JWT são mostradas abaixo. Elas podem aparecer em qualquer ordem no conjunto de reivindicações.

Nome Descrição
iss O endereço de e-mail da conta de serviço.
scope Uma lista delimitada por espaço das permissões solicitadas pelo aplicativo.
aud Um descritor do destino pretendido da declaração. Ao fazer uma solicitação de token de acesso, esse valor é sempre https://oauth2.googleapis.com/token.
exp O prazo de validade da declaração, especificado como segundos desde 00:00:00 UTC, 1o de janeiro de 1970. Esse valor tem no máximo uma hora após o horário de emissão.
iat O horário em que a declaração foi emitida, especificada como segundos desde 00:00:00 UTC, em 1o de janeiro de 1970.

Veja abaixo a representação JSON dos campos obrigatórios em um conjunto de declarações JWT:

{
  "iss": "761326798069-r5mljlln1rd4lrbhg75efgigp36m78j5@developer.gserviceaccount.com",
  "scope": "https://www.googleapis.com/auth/devstorage.read_only",
  "aud": "https://oauth2.googleapis.com/token",
  "exp": 1328554385,
  "iat": 1328550785
}
Outras reivindicações

Em alguns casos corporativos, um aplicativo pode usar a delegação em todo o domínio para agir em nome de um determinado usuário em uma organização. A permissão para realizar esse tipo de representação precisa ser concedida antes que um aplicativo possa representar um usuário e geralmente é processada por um superadministrador. Para mais informações, consulte Controlar o acesso à API com delegação em todo o domínio.

Para receber um token de acesso que conceda a um aplicativo acesso delegado a um recurso, inclua o endereço de e-mail do usuário no conjunto de declarações JWT como o valor do campo sub.

Nome Descrição
sub O endereço de e-mail do usuário para quem o aplicativo está solicitando acesso delegado.

Se um aplicativo não tiver permissão para representar um usuário, a resposta a uma solicitação de token de acesso que incluir o campo sub será um erro.

Veja abaixo um exemplo de um conjunto de declarações JWT que inclui o campo sub:

{
  "iss": "761326798069-r5mljlln1rd4lrbhg75efgigp36m78j5@developer.gserviceaccount.com",
  "sub": "some.user@example.com",
  "scope": "https://www.googleapis.com/auth/prediction",
  "aud": "https://oauth2.googleapis.com/token",
  "exp": 1328554385,
  "iat": 1328550785
}
Como codificar o conjunto de declarações JWT

Assim como o cabeçalho JWT, o conjunto de declarações JWT precisa ser serializado para UTF-8 e codificado seguro para Base64url. Veja abaixo um exemplo de uma representação JSON de um conjunto de declarações JWT:

{
  "iss": "761326798069-r5mljlln1rd4lrbhg75efgigp36m78j5@developer.gserviceaccount.com",
  "scope": "https://www.googleapis.com/auth/prediction",
  "aud": "https://oauth2.googleapis.com/token",
  "exp": 1328554385,
  "iat": 1328550785
}
Como calcular a assinatura

JSON Web Signature (JWS) é a especificação que orienta a mecânica de geração da assinatura para o JWT. A entrada da assinatura é a matriz de bytes do seguinte conteúdo:

{Base64url encoded header}.{Base64url encoded claim set}

O algoritmo de assinatura no cabeçalho JWT precisa ser usado ao calcular a assinatura. O único algoritmo de assinatura compatível com o servidor de autorização Google OAuth 2.0 é o RSA usando algoritmo de hash SHA-256. Isso é expresso como RS256 no campo alg no cabeçalho JWT.

Assine a representação UTF-8 da entrada usando SHA256withRSA (também conhecida como RSASSA-PKCS1-V1_5-SIGN com a função de hash SHA-256) com a chave privada recebida do Google API Console. A saída será uma matriz de bytes.

A assinatura precisa ser codificada em Base64url. O cabeçalho, o conjunto de declarações e a assinatura são concatenados com um caractere de ponto (.). O resultado é o JWT. Precisa ser o seguinte (as quebras de linha foram adicionadas para maior clareza):

{Base64url encoded header}.
{Base64url encoded claim set}.
{Base64url encoded signature}

Veja abaixo um exemplo de JWT antes da codificação Base64url:

{"alg":"RS256","typ":"JWT"}.
{
"iss":"761326798069-r5mljlln1rd4lrbhg75efgigp36m78j5@developer.gserviceaccount.com",
"scope":"https://www.googleapis.com/auth/prediction",
"aud":"https://oauth2.googleapis.com/token",
"exp":1328554385,
"iat":1328550785
}.
[signature bytes]

Veja abaixo um exemplo de um JWT assinado e pronto para transmissão:

eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiI3NjEzMjY3OTgwNjktcjVtbGpsbG4xcmQ0bHJiaGc3NWVmZ2lncDM2bTc4ajVAZGV2ZWxvcGVyLmdzZXJ2aWNlYWNjb3VudC5jb20iLCJzY29wZSI6Imh0dHBzOi8vd3d3Lmdvb2dsZWFwaXMuY29tL2F1dGgvcHJlZGljdGlvbiIsImF1ZCI6Imh0dHBzOi8vd3d3Lmdvb2dsZWFwaXMuY29tL29hdXRoMi92NC90b2tlbiIsImV4cCI6MTMyODU1NDM4NSwiaWF0IjoxMzI4NTUwNzg1fQ.UFUt59SUM2_AW4cRU8Y0BYVQsNTo4n7AFsNrqOpYiICDu37vVt-tw38UKzjmUKtcRsLLjrR3gFW3dNDMx_pL9DVjgVHDdYirtrCekUHOYoa1CMR66nxep5q5cBQ4y4u2kIgSvChCTc9pmLLNoIem-ruCecAJYgI9Ks7pTnW1gkOKs0x3YpiLpzplVHAkkHztaXiJdtpBcY1OXyo6jTQCa3Lk2Q3va1dPkh_d--GU2M5flgd8xNBPYw4vxyt0mP59XZlHMpztZt0soSgObf7G3GXArreF_6tpbFsS3z2t5zkEiHuWJXpzcYr5zWTRPDEHsejeBSG8EgpLDce2380ROQ

Como fazer a solicitação do token de acesso

Depois de gerar o JWT assinado, um aplicativo pode usá-lo para solicitar um token de acesso. Essa solicitação de token de acesso é uma solicitação HTTPS POST e o corpo é codificado para uso em URL. O URL é mostrado abaixo:

https://oauth2.googleapis.com/token

Os parâmetros a seguir são obrigatórios na solicitação HTTPS POST:

Nome Descrição
grant_type Use a seguinte string codificada em URL conforme necessário: urn:ietf:params:oauth:grant-type:jwt-bearer
assertion O JWT, incluindo a assinatura.

Veja abaixo um despejo bruto da solicitação HTTPS POST usada em uma solicitação de token de acesso:

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

grant_type=urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Ajwt-bearer&assertion=eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiI3NjEzMjY3OTgwNjktcjVtbGpsbG4xcmQ0bHJiaGc3NWVmZ2lncDM2bTc4ajVAZGV2ZWxvcGVyLmdzZXJ2aWNlYWNjb3VudC5jb20iLCJzY29wZSI6Imh0dHBzOi8vd3d3Lmdvb2dsZWFwaXMuY29tL2F1dGgvcHJlZGljdGlvbiIsImF1ZCI6Imh0dHBzOi8vYWNjb3VudHMuZ29vZ2xlLmNvbS9vL29hdXRoMi90b2tlbiIsImV4cCI6MTMyODU3MzM4MSwiaWF0IjoxMzI4NTY5NzgxfQ.ixOUGehweEVX_UKXv5BbbwVEdcz6AYS-6uQV6fGorGKrHf3LIJnyREw9evE-gs2bmMaQI5_UbabvI4k-mQE4kBqtmSpTzxYBL1TCd7Kv5nTZoUC1CmwmWCFqT9RE6D7XSgPUh_jF1qskLa2w0rxMSjwruNKbysgRNctZPln7cqQ

Veja abaixo a mesma solicitação, usando curl:

curl -d 'grant_type=urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Ajwt-bearer&assertion=eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiI3NjEzMjY3OTgwNjktcjVtbGpsbG4xcmQ0bHJiaGc3NWVmZ2lncDM2bTc4ajVAZGV2ZWxvcGVyLmdzZXJ2aWNlYWNjb3VudC5jb20iLCJzY29wZSI6Imh0dHBzOi8vd3d3Lmdvb2dsZWFwaXMuY29tL2F1dGgvcHJlZGljdGlvbiIsImF1ZCI6Imh0dHBzOi8vYWNjb3VudHMuZ29vZ2xlLmNvbS9vL29hdXRoMi90b2tlbiIsImV4cCI6MTMyODU3MzM4MSwiaWF0IjoxMzI4NTY5NzgxfQ.RZVpzWygMLuL-n3GwjW1_yhQhrqDacyvaXkuf8HcJl8EtXYjGjMaW5oiM5cgAaIorrqgYlp4DPF_GuncFqg9uDZrx7pMmCZ_yHfxhSCXru3gbXrZvAIicNQZMFxrEEn4REVuq7DjkTMyCMGCY1dpMa8aWfTQFt3Eh7smLchaZsU
' https://oauth2.googleapis.com/token

Como processar a resposta

Se o JWT e a solicitação do token de acesso estiverem corretos e a conta de serviço tiver permissão para realizar a operação, a resposta JSON do servidor de autorização incluirá um token de acesso. Veja a seguir um exemplo de resposta:

{
  "access_token": "1/8xbJqaOZXSUZbHLl5EOtu1pxz3fmmetKx9W8CV4t79M",
  "scope": "https://www.googleapis.com/auth/prediction"
  "token_type": "Bearer",
  "expires_in": 3600
}

Os tokens de acesso podem ser reutilizados durante a janela de duração especificada pelo valor expires_in.

Como chamar APIs do Google

Java

Use o objeto GoogleCredential para chamar as APIs do Google, concluindo as seguintes etapas:

  1. Crie um objeto de serviço para a API que você quer chamar usando o objeto GoogleCredential. Por exemplo:
    SQLAdmin sqladmin =
        new SQLAdmin.Builder(httpTransport, JSON_FACTORY, credential).build();
  2. Faça solicitações ao serviço da API usando a interface fornecida pelo objeto de serviço. Por exemplo, para listar as instâncias de bancos de dados do Cloud SQL no projeto empolgante-example-123:
    SQLAdmin.Instances.List instances =
        sqladmin.instances().list("exciting-example-123").execute();

Python

Use o objeto Credentials autorizado a chamar APIs do Google seguindo estas etapas:

  1. Crie um objeto de serviço para a API que você quer chamar. Crie um objeto de serviço chamando a função build com o nome e a versão da API e o objeto Credentials autorizado. Por exemplo, para chamar a versão 1beta3 da API de administração do Cloud SQL:
    import googleapiclient.discovery
    
    sqladmin = googleapiclient.discovery.build('sqladmin', 'v1beta3', credentials=credentials)
  2. Faça solicitações ao serviço da API usando a interface fornecida pelo objeto de serviço. Por exemplo, para listar as instâncias de bancos de dados do Cloud SQL no projeto empolgante-example-123:
    response = sqladmin.instances().list(project='exciting-example-123').execute()

HTTP/REST

Depois que seu aplicativo receber um token de acesso, é possível usá-lo para fazer chamadas para uma API do Google em nome de uma determinada conta de serviço ou 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 um parâmetro de consulta access_token ou um valor Bearer de cabeçalho HTTP Authorization. Quando possível, é preferível usar o cabeçalho HTTP, porque as strings de consulta tendem a ser visíveis nos registros do servidor. Na maioria dos casos, você pode usar uma biblioteca de cliente para configurar as chamadas para APIs do Google, por exemplo, ao chamar a API Drive Files.

Você pode testar todas as APIs do Google e ver os escopos no OAuth 2.0 Playground.

Exemplos de HTTP GET

Uma chamada para o endpoint drive.files (a API Drive Files) usando o cabeçalho HTTP Authorization: Bearer pode ser semelhante à seguinte. É necessário especificar seu próprio token de acesso:

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

Esta é uma chamada para a mesma API do usuário autenticado usando o parâmetro de string de consulta access_token:

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

Exemplos de curl

É possível testar esses comandos com o aplicativo de linha de comando curl. Veja um exemplo que usa a opção de cabeçalho HTTP (preferencial):

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

Ou, como alternativa, a opção de parâmetro de string de consulta:

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

Quando os tokens de acesso expiram

Os tokens de acesso emitidos pelo servidor de autorização do Google OAuth 2.0 expiram após a duração fornecida pelo valor expires_in. Quando um token de acesso expira, o aplicativo precisa gerar outro JWT, assiná-lo e solicitar outro token de acesso.

Códigos de erro do JWT

Campo error Campo error_description Significado Como resolver
unauthorized_client Unauthorized client or scope in request. Se você estiver tentando usar a delegação em todo o domínio, a conta de serviço não estará autorizada no Admin Console do domínio do usuário.

Verifique se a conta de serviço está autorizada na página Delegação em todo o domínio do Admin Console do usuário no campo (reivindicação sub).

Esse processo costuma levar alguns minutos, mas pode levar até 24 horas para que a autorização seja propagada para todos os usuários na sua Conta do Google.

unauthorized_client Client is unauthorized to retrieve access tokens using this method, or client not authorized for any of the scopes requested. Uma conta de serviço foi autorizada usando o endereço de e-mail do cliente em vez do ID do cliente (numérico) no Admin Console. Na página Delegação em todo o domínio no Admin Console, remova o cliente e adicione-o novamente com o ID numérico.
access_denied (qualquer valor) Se você estiver usando a delegação em todo o domínio, um ou mais escopos solicitados não estarão autorizados no Admin Console.

Verifique se a conta de serviço está autorizada na página Delegação em todo o domínio do Admin Console do usuário na declaração sub (campo) e se ela inclui todos os escopos solicitados na declaração scope do JWT.

Esse processo costuma levar alguns minutos, mas pode levar até 24 horas para que a autorização seja propagada para todos os usuários na sua Conta do Google.

invalid_grant Not a valid email. O usuário não existe. Verifique se o endereço de e-mail indicado na sub reivindicação (campo) está correto.
invalid_grant

Invalid JWT: Token must be a short-lived token (60 minutes) and in a reasonable timeframe. Check your 'iat' and 'exp' values and use a clock with skew to account for clock differences between systems.

Normalmente, isso significa que a hora local do sistema não está correta. Isso também pode acontecer se o valor exp estiver mais de 65 minutos no futuro a partir do valor iat, ou o valor exp for menor que o valor iat.

Verifique se o relógio do sistema em que o JWT é gerado está correto. Se necessário, sincronize seu tempo com o Google NTP.

invalid_grant Invalid JWT Signature.

A declaração JWT é assinada com uma chave privada não associada à conta de serviço identificada pelo e-mail do cliente ou porque a chave usada foi excluída, desativada ou expirou.

Como alternativa, a declaração JWT pode estar codificada incorretamente. Ela precisa ser codificada em Base64 sem linhas novas ou sinais de padding iguais.

Decodifique o conjunto de declarações JWT e verifique a chave que assinou a declaração está associada à conta de serviço.

Tente usar uma biblioteca OAuth fornecida pelo Google para garantir que o JWT seja gerado corretamente.

invalid_scope Invalid OAuth scope or ID token audience provided. Nenhum escopo foi solicitado (lista vazia de escopos), ou um dos escopos solicitados não existe (ou seja, é inválido).

Verifique se a declaração scope (campo) do JWT está preenchida e compare os escopos dela com os escopos documentados para as APIs que você quer usar, para garantir que não haja erros ou erros de digitação.

A lista de escopos na declaração scope precisa ser separada por espaços, e não vírgulas.

disabled_client The OAuth client was disabled. A chave usada para assinar a declaração JWT está desativada.

Acesse Google API Consolee, em IAM e contas de serviço > Admin, ative a conta de serviço que contém o "ID da chave" usado para assinar a declaração.

Adendo: autorização da conta de serviço sem OAuth

Com algumas APIs do Google, é possível fazer chamadas de API autorizadas usando um JWT assinado diretamente como um token do portador, em vez de um token de acesso do OAuth 2.0. Quando isso for possível, não será necessário fazer uma solicitação de rede ao servidor de autorização do Google antes de fazer uma chamada de API.

Se a API que você quer chamar tiver uma definição de serviço publicada no repositório do GitHub de APIs do Google, será possível fazer chamadas de API autorizadas usando um JWT em vez de um token de acesso. Basta seguir estas etapas:

  1. Crie uma conta de serviço conforme descrito acima. Mantenha o arquivo JSON recebido ao criar a conta.
  2. Usando qualquer biblioteca JWT padrão, como a encontrada em jwt.io, crie um JWT com um cabeçalho e payload como o exemplo a seguir:
    {
      "alg": "RS256",
      "typ": "JWT",
      "kid": "abcdef1234567890"
    }
    .
    {
      "iss": "123456-compute@developer.gserviceaccount.com",
      "sub": "123456-compute@developer.gserviceaccount.com",
      "aud": "https://firestore.googleapis.com/",
      "iat": 1511900000,
      "exp": 1511903600
    }
    • Para o campo kid no cabeçalho, especifique o ID da chave privada da conta de serviço. Esse valor está disponível no campo private_key_id do arquivo JSON da sua conta de serviço.
    • Para os campos iss e sub, especifique o endereço de e-mail da sua conta de serviço. Esse valor está no campo client_email do arquivo JSON da conta de serviço.
    • No campo aud, especifique o endpoint da API. Por exemplo, https://SERVICE.googleapis.com/.
    • No campo iat, especifique a hora atual do Unix. Para o campo exp, especifique a hora exatamente 3.600 segundos depois, quando o JWT expira.

Assine o JWT com RSA-256 usando a chave privada encontrada no arquivo JSON da sua conta de serviço.

Exemplo:

Java

Ao usar google-api-java-client e java-jwt:

GoogleCredential credential =
        GoogleCredential.fromStream(new FileInputStream("MyProject-1234.json"));
PrivateKey privateKey = credential.getServiceAccountPrivateKey();
String privateKeyId = credential.getServiceAccountPrivateKeyId();

long now = System.currentTimeMillis();

try {
    Algorithm algorithm = Algorithm.RSA256(null, privateKey);
    String signedJwt = JWT.create()
        .withKeyId(privateKeyId)
        .withIssuer("123456-compute@developer.gserviceaccount.com")
        .withSubject("123456-compute@developer.gserviceaccount.com")
        .withAudience("https://firestore.googleapis.com/")
        .withIssuedAt(new Date(now))
        .withExpiresAt(new Date(now + 3600 * 1000L))
        .sign(algorithm);
} catch ...

Python

Com o PyJWT:

iat = time.time()
exp = iat + 3600
payload = {'iss': '123456-compute@developer.gserviceaccount.com',
           'sub': '123456-compute@developer.gserviceaccount.com',
           'aud': 'https://firestore.googleapis.com/',
           'iat': iat,
           'exp': exp}
additional_headers = {'kid': PRIVATE_KEY_ID_FROM_JSON}
signed_jwt = jwt.encode(payload, PRIVATE_KEY_FROM_JSON, headers=additional_headers,
                       algorithm='RS256')
  1. Chame a API usando o JWT assinado como o token do portador:
    GET /v1/projects/abc/databases/123/indexes HTTP/1.1
    Authorization: Bearer SIGNED_JWT
    Host: firestore.googleapis.com