Receber um token de ID

Nesta página, descrevemos algumas maneiras de adquirir um token de ID do OpenID Connect (OIDC) assinado pelo Google.

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

Para informações sobre o conteúdo e o ciclo de vida do token de código, consulte Tokens de ID.

Os tokens de ID têm um serviço ou aplicativo específico para que possam ser usados, especificados pelo valor da reivindicação aud. Nesta página, usamos o termo serviço de destino para fazer referência ao serviço ou ao 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 receber um token de ID

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

Se um token de ID não for aceito por um aplicativo não hospedado no Google Cloud, provavelmente você poderá usar esses métodos, mas determine as declarações de token de ID que o aplicativo exige.

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 ID. token. O servidor de metadados gera tokens de ID para a conta de serviço anexada. Não é possível receber um token de ID com base nas credenciais de usuário do servidor de metadados.

É 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 neste exemplo.

curl

Substitua AUDIENCE pelo URI do serviço de destino. Por exemplo, 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. Por exemplo, 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 esse exemplo de código, instale a biblioteca de cliente do Auth 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 este exemplo de código, instale a biblioteca do Google Auth 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 este exemplo de código, instale a biblioteca do Google Auth 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 este exemplo de código, instale a biblioteca do Google Auth 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. Esses serviços de conexão podem ajudar a determinar quando a chamada é feita ou a gerenciar um fluxo de trabalho que inclui a chamada do serviço. Os serviços a seguir podem incluir automaticamente um token de ID com o valor apropriado para a declaração aud quando iniciarem 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 configurar o Cloud Scheduler para que inclua um token de ID ou de acesso quando ele 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 que inclua um token de ID ou um token 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 os serviços. É possível configurar o Pub/Sub para que inclua um token de ID com uma mensagem. Para mais informações, consulte Autenticação para assinatura por push.
Fluxos de trabalho
O Workflows é uma plataforma de orquestração totalmente gerenciada que executa serviços na ordem que você define: um fluxo de trabalho. É possível definir um fluxo de trabalho para que inclua um token de ID ou de acesso quando ele invocar outro serviço. Para mais informações, consulte Fazer solicitações autenticadas de um fluxo de trabalho.

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

A representação de uma conta de serviç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 autenticar como a conta de serviço.

Antes que um principal possa representar uma conta de serviço, ele precisa ter um papel do IAM nessa conta de serviço que permita a representação. Se a principal for outra conta de serviço, pode parecer mais fácil simplesmente fornecer as permissões necessárias diretamente para essa conta de serviço e ativá-la. Essa configuração, conhecida como 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 representação da conta de serviço precisa sempre envolver dois principais: um principal 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 simulando uma conta de serviço, use o processo geral a seguir.

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

  1. Identifique ou crie uma conta de serviço para ser a de serviço com 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 funções do Cloud Run, conceda o papel 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 CLI gcloud. No entanto, se você está executando em um recurso com uma conta de serviço anexada, a conta de serviço anexada é a principal.

  4. Conceda ao principal o papel de Criador de token de identidade do OpenID Connect da 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.

Gerar um token de ID genérico para desenvolvimento com funções do Cloud Run e do Cloud Functions

Use a gcloud CLI para receber um token de ID para suas credenciais de usuário que podem ser usadas 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 invocar. Esse token não vai funcionar em nenhum outro aplicativo.

A seguir