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:

O Cloud Run e o Cloud Functions fornecem maneiras específicas de serviços para receber um token de ID. Para mais informações, consulte Autenticar aplicativos hospedados no Cloud Run ou no Cloud Functions

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 este exemplo de código, instale a Biblioteca de cliente da API do Google 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 

/**
 * 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 Python do Google Auth.


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 esse 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 incluir 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 incluir 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 incluir um token de ID com uma mensagem. Para mais informações, consulte Autenticação pela assinatura push.
Fluxos de trabalho
O Workflows é uma plataforma de orquestração totalmente gerenciada que executa serviços na ordem que você define, ou seja, em um fluxo de trabalho. É possível definir um fluxo de trabalho para incluir 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. Conceda à conta de serviço o papel do IAM necessário no serviço de destino:

    • Para serviços do Cloud Run, conceda o papel Invocador do Cloud Run (roles/run.invoker).
    • Para o Cloud Functions, 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.

  2. 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.

  3. Conceda ao principal o papel de Criador de token de identidade do OpenID Connect da conta de serviço (roles/iam.serviceAccountOpenIdTokenCreator).

  4. 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 o Cloud Run e o Cloud Functions

Use a CLI gcloud 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.

Gerar um token de ID usando um provedor de identidade externo

A geração de um token de ID usando um provedor de identidade externo usa a federação de identidade de carga de trabalho, que permite configurar uma relação entre o Google Cloud e seu provedor de identidade externo. Em seguida, use as credenciais fornecidas pelo seu provedor de identidade externo para gerar tokens de ID ou de acesso que podem ser usados no Google Cloud.

Para gerar um token de ID para credenciais fornecidas por um provedor de identidade externo, siga estas etapas:

  1. Identifique ou crie uma conta de serviço a fim de fornecer os papéis do IAM necessários para chamar o serviço de destino.

    Uma prática recomendada é criar uma conta de serviço especificamente para essa finalidade e atribuir a ela apenas o papel necessário. Essa abordagem segue o princípio de privilégio mínimo.

  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 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. Configure a federação de identidade da carga de trabalho para seu provedor de identidade, conforme descrito em Como configurar a federação de identidade da carga de trabalho.

  4. Siga as instruções em Como conceder permissões de identidades externas para representar uma conta de serviço, usando a conta de serviço configurada nas etapas anteriores como a conta de serviço a ser representada.

  5. Use a API REST para adquirir um token de curta duração, mas, na última etapa, use o método generateIdToken para receber um token de ID:

    Bash

    ID_TOKEN=$(curl -0 -X POST https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/SERVICE_ACCOUNT_EMAIL:generateIdToken \
    -H "Content-Type: text/json; charset=utf-8" \
    -H "Authorization: Bearer $STS_TOKEN" \
    -d @- <<EOF | jq -r .token
    {
        "audience": "AUDIENCE"
    }
EOF
)
echo $ID_TOKEN

    PowerShell

    $IdToken = (Invoke-RestMethod `
    -Method POST `
    -Uri "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/SERVICE_ACCOUNT_EMAIL:generateIdToken" `
    -Headers @{ "Authorization" = "Bearer $StsToken" } `
    -ContentType "application/json" `
    -Body (@{
        "audience" = "AUDIENCE"
    } | ConvertTo-Json)).token
Write-Host $IdToken

    Substitua:

    • SERVICE_ACCOUNT_EMAIL: o endereço de e-mail da conta de serviço.
    • AUDIENCE: o público-alvo do token, como o app ou serviço que o token usará para acessar.

A seguir