Receber um token de ID

Nesta página, você vai aprender como adquirir um token de ID do OpenID Connect (OIDC) assinado pelo Google.

É necessário ter um token de ID assinado pelo Google nos seguintes casos de uso de autenticação:

Para informações sobre o conteúdo e o ciclo de vida dos tokens de ID, consulte Tokens de ID.

Os tokens de ID podem ser usados em serviços ou aplicativos específicos, que são especificados pelo valor da declaração aud. Neste documento, usamos o termo serviço de destino para fazer referência ao serviço ou aplicativo em que o token de ID pode ser usado para autenticação.

Ao receber o token de ID, é possível incluí-lo em um cabeçalho Authorization na solicitação para o serviço de destino.

Métodos para ter acesso a um token de ID

Há várias maneiras de acessar um token de ID. Nesta página, descrevemos os seguintes métodos:

Se você precisa que um token de ID seja aceito por um aplicativo não hospedado no Google Cloud, provavelmente pode usar esses métodos, mas deve determinar as declarações do token de ID exigidas pelo aplicativo.

Receber um token de ID do servidor de metadados

Quando o código está em execução em um recurso que pode ter uma conta de serviço anexada, o servidor de metadados do serviço associado pode, na maioria dos casos, fornecer um token de ID. O servidor de metadados gera tokens de ID para a conta de serviço anexada. Não é possível receber um token de ID do servidor de metadados com base em credenciais de usuário.

É possível receber um token de ID do servidor de metadados quando o código é executado nos seguintes serviços do Google Cloud :

Para recuperar um token de ID do servidor de metadados, consulte o endpoint de identidade da conta de serviço, conforme mostrado no exemplo.

curl

Substitua AUDIENCE pelo URI do serviço de destino, como http://www.example.com.

curl -H "Metadata-Flavor: Google" \
  'http://metadata/computeMetadata/v1/instance/service-accounts/default/identity?audience=AUDIENCE'

PowerShell

Substitua AUDIENCE pelo URI do serviço de destino, como http://www.example.com.

$value = (Invoke-RestMethod `
  -Headers @{'Metadata-Flavor' = 'Google'} `
  -Uri "http://metadata/computeMetadata/v1/instance/service-accounts/default/identity?audience=AUDIENCE")
$value

Java

Para executar o exemplo de código, instale a biblioteca de cliente de autenticação para Java. 


import com.google.auth.oauth2.GoogleCredentials;
import com.google.auth.oauth2.IdTokenCredentials;
import com.google.auth.oauth2.IdTokenProvider;
import com.google.auth.oauth2.IdTokenProvider.Option;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.Arrays;

public class IdTokenFromMetadataServer {

  public static void main(String[] args) throws IOException, GeneralSecurityException {
    // TODO(Developer): Replace the below variables before running the code.

    // The url or target audience to obtain the ID token for.
    String url = "https://example.com";

    getIdTokenFromMetadataServer(url);
  }

  // Use the Google Cloud metadata server to create an identity token and add it to the
  // HTTP request as part of an Authorization header.
  public static void getIdTokenFromMetadataServer(String url) throws IOException {
    // Construct the GoogleCredentials object which obtains the default configuration from your
    // working environment.
    GoogleCredentials googleCredentials = GoogleCredentials.getApplicationDefault();

    IdTokenCredentials idTokenCredentials =
        IdTokenCredentials.newBuilder()
            .setIdTokenProvider((IdTokenProvider) googleCredentials)
            .setTargetAudience(url)
            // Setting the ID token options.
            .setOptions(Arrays.asList(Option.FORMAT_FULL, Option.LICENSES_TRUE))
            .build();

    // Get the ID token.
    // Once you've obtained the ID token, you can use it to make an authenticated call to the
    // target audience.
    String idToken = idTokenCredentials.refreshAccessToken().getTokenValue();
    System.out.println("Generated ID token.");
  }
}

Go 

import (
	"context"
	"fmt"
	"io"

	"golang.org/x/oauth2/google"
	"google.golang.org/api/idtoken"
	"google.golang.org/api/option"
)

// getIdTokenFromMetadataServer uses the Google Cloud metadata server environment
// to create an identity token and add it to the HTTP request as part of an Authorization header.
func getIdTokenFromMetadataServer(w io.Writer, url string) error {
	// url := "http://www.example.com"

	ctx := context.Background()

	// Construct the GoogleCredentials object which obtains the default configuration from your
	// working environment.
	credentials, err := google.FindDefaultCredentials(ctx)
	if err != nil {
		return fmt.Errorf("failed to generate default credentials: %w", err)
	}

	ts, err := idtoken.NewTokenSource(ctx, url, option.WithCredentials(credentials))
	if err != nil {
		return fmt.Errorf("failed to create NewTokenSource: %w", err)
	}

	// Get the ID token.
	// Once you've obtained the ID token, you can use it to make an authenticated call
	// to the target audience.
	_, err = ts.Token()
	if err != nil {
		return fmt.Errorf("failed to receive token: %w", err)
	}
	fmt.Fprintf(w, "Generated ID token.\n")

	return nil
}

Node.js

Para executar o exemplo de código, instale a biblioteca de autenticação do Google para Node.js 

/**
 * TODO(developer):
 *  1. Uncomment and replace these variables before running the sample.
 */
// const targetAudience = 'http://www.example.com';

const {GoogleAuth} = require('google-auth-library');

async function getIdTokenFromMetadataServer() {
  const googleAuth = new GoogleAuth();

  const client = await googleAuth.getIdTokenClient(targetAudience);

  // Get the ID token.
  // Once you've obtained the ID token, you can use it to make an authenticated call
  // to the target audience.
  await client.idTokenProvider.fetchIdToken(targetAudience);
  console.log('Generated ID token.');
}

getIdTokenFromMetadataServer();

Python

Para executar o exemplo de código, instale a biblioteca de autenticação do Google para Python. 


import google
import google.oauth2.credentials
from google.auth import compute_engine
import google.auth.transport.requests


def idtoken_from_metadata_server(url: str):
    """
    Use the Google Cloud metadata server in the Cloud Run (or AppEngine or Kubernetes etc.,)
    environment to create an identity token and add it to the HTTP request as part of an
    Authorization header.

    Args:
        url: The url or target audience to obtain the ID token for.
            Examples: http://www.example.com
    """

    request = google.auth.transport.requests.Request()
    # Set the target audience.
    # Setting "use_metadata_identity_endpoint" to "True" will make the request use the default application
    # credentials. Optionally, you can also specify a specific service account to use by mentioning
    # the service_account_email.
    credentials = compute_engine.IDTokenCredentials(
        request=request, target_audience=url, use_metadata_identity_endpoint=True
    )

    # Get the ID token.
    # Once you've obtained the ID token, use it to make an authenticated call
    # to the target audience.
    credentials.refresh(request)
    # print(credentials.token)
    print("Generated ID token.")

Ruby

Para executar o exemplo de código, instale a biblioteca de autenticação do Google para Ruby. 

require "googleauth"

##
# Uses the Google Cloud metadata server environment to create an identity token
# and add it to the HTTP request as part of an Authorization header.
#
# @param url [String] The url or target audience to obtain the ID token for
#   (e.g. "http://www.example.com")
#
def auth_cloud_idtoken_metadata_server url:
  # Create the GCECredentials client.
  id_client = Google::Auth::GCECredentials.new target_audience: url

  # Get the ID token.
  # Once you've obtained the ID token, you can use it to make an authenticated call
  # to the target audience.
  id_client.fetch_access_token
  puts "Generated ID token."

  id_client.refresh!
end

Usar um serviço de conexão para gerar um token de ID

Alguns serviços do Google Cloud ajudam você a chamar outros serviços. Esses serviços de conexão podem ajudar a determinar quando a chamada é feita ou gerenciar um fluxo de trabalho que inclui a chamada ao serviço. Os serviços abaixo podem incluir automaticamente um token de ID com o valor apropriado para a declaração aud quando iniciam uma chamada para um serviço que exige um token de ID:

Cloud Scheduler
O Cloud Scheduler é um programador de cron jobs totalmente gerenciado e de nível empresarial. É possível configurá-lo para incluir um token de ID ou de acesso ao invocar outro serviço. Para mais informações, consulte Como usar a autenticação com destinos HTTP.
Cloud Tasks
O Cloud Tasks permite gerenciar a execução de tarefas distribuídas. É possível configurar uma tarefa para incluir um token de ID ou de acesso ao chamar um serviço. Para mais informações, consulte Como usar tarefas de destino HTTP com tokens de autenticação.
Pub/Sub
O Pub/Sub permite a comunicação assíncrona entre serviços. É possível configurar o Pub/Sub para incluir um token de ID com uma mensagem. Para mais informações, consulte Autenticação para assinaturas por push.
Workflows
O Workflows é uma plataforma de orquestração totalmente gerenciada que executa serviços na ordem definida por você: um fluxo de trabalho. É possível definir um fluxo de trabalho para incluir um token de ID ou de acesso ao invocar outro serviço. Para mais informações, consulte Fazer solicitações autenticadas usando um fluxo de trabalho.

Gerar um token de ID com a representação de uma conta de serviço

A identidade temporária de conta de serviço (representação) permite que um principal gere credenciais de curta duração para uma conta de serviço confiável. O principal pode usar essas credenciais para realizar a autenticação como a conta de serviço.

Para que um principal possa representar uma conta de serviço, ele precisa ter um papel do IAM nessa conta que permita a representação. Se o principal for outra conta de serviço, poderá parecer mais fácil fornecer as permissões necessárias diretamente para ele, a fim de que represente a si mesmo. No entanto, essa configuração de autorepresentação cria uma vulnerabilidade de segurança, porque permite que a conta de serviço crie um token de acesso que pode ser atualizado perpetuamente.

A identidade temporária de conta de serviço precisa sempre envolver dois principais: um que representa o autor da chamada e a conta de serviço que está sendo representada, chamada de conta de serviço com privilégios.

Para gerar um token de ID por meio da representação de uma conta de serviço, use o processo geral a seguir.

Para instruções detalhadas, consulte Criar um token de ID.

  1. Identifique ou crie uma conta de serviço para ter os privilégios.

  2. Identifique os papéis necessários para invocar o serviço de destino. Conceda esses papéis à conta de serviço no serviço de destino:

    • Para serviços do Cloud Run, conceda o papel de Invocador do Cloud Run (roles/run.invoker).
    • Para o Cloud Run functions, conceda o papel de Invocador do Cloud Functions (roles/cloudfunctions.invoker).
    • Para outros serviços de destino, consulte a documentação do produto para o serviço.

  3. Identifique o principal que executará a representação e configure o Application Default Credentials (ADC) para usar as credenciais do principal.

    Para ambientes de desenvolvimento, o principal geralmente é a conta de usuário que você forneceu ao ADC usando a gcloud CLI. No entanto, para execuções em recursos com uma conta de serviço anexada, essa conta de serviço anexada é o principal.

  4. Conceda ao principal o papel de Criador de tokens de identidade do OpenID Connect na conta de serviço (roles/iam.serviceAccountOpenIdTokenCreator).

  5. Use a API IAM Credentials para gerar o token de ID da conta de serviço autorizada.

    Substitua:

    • AUDIENCE: o URI do serviço de destino, como http://www.example.com.
    • SERVICE_ACCOUNT_EMAIL: o endereço de e-mail da conta de serviço com privilégios.
    curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
-d '{"audience": "AUDIENCE", "includeEmail": "true"}' \
https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/SERVICE_ACCOUNT_EMAIL:generateIdToken

Gerar um token de ID genérico para desenvolvimento com o Cloud Run e o Cloud Run functions

Use a gcloud CLI para ter acesso a um token de ID para suas credenciais de usuário que possa ser usado com qualquer serviço ou função do Cloud Run em que o autor da chamada tenha as permissões do IAM necessárias para a invocação. Esse token não vai funcionar em nenhum outro aplicativo.

A seguir