Autenticação programática

Nesta página, você vai aprender a fazer a autenticação em um recurso protegido pelo Identity-Aware Proxy (IAP) usando uma conta de usuário ou uma conta de serviço.

O acesso programático é o cenário em que você chama aplicativos protegidos pelo IAP de clientes que não são de navegador. Isso inclui ferramentas de linha de comando, chamadas de serviço para serviço e aplicativos para dispositivos móveis. Dependendo do caso de uso, talvez seja necessário autenticar no IAP usando credenciais de usuário ou de serviço.

• A conta de usuário pertence a um usuário individual. Ela é usada na autenticação quando o aplicativo precisa acessar recursos protegidos pelo IAP em nome de um usuário. Para mais informações, consulte Contas de usuário.

• Uma conta de serviço representa um aplicativo, e não um usuário individual. Ela é usada na conta de serviço quando você quer permitir que um aplicativo acesse seus recursos protegidos pelo IAP. Para mais informações, consulte Contas de serviço.

O IAP oferece suporte aos seguintes tipos de credenciais para acesso programático:

• Token de ID do OAuth 2.0: um token emitido pelo Google para um usuário humano ou uma conta de serviço com a declaração de público-alvo definida como o ID do recurso do aplicativo IAP.
• JWT assinado pela conta de serviço: um token JWT autoassinado ou emitido pelo Google para uma conta de serviço.

Transmita essas credenciais ao IAP no cabeçalho HTTP Authorization ou Proxy-Authorization.

Antes de começar

Antes de começar, você precisa de um aplicativo protegido pelo IAP ao qual quer se conectar de maneira programática usando uma conta de desenvolvedor, uma conta de serviço ou credenciais de app para dispositivos móveis.

Autenticar uma conta de usuário

É possível liberar o acesso de usuários a seu aplicativo por meio de um app para computador ou dispositivos móveis para permitir que um programa interaja com um recurso protegido pelo IAP.

Autenticar usando um app para dispositivos móveis

1. Crie ou use um ID do cliente OAuth 2.0 para o app para dispositivos móveis. Para usar um ID do cliente OAuth 2.0, siga as etapas em Como compartilhar clientes OAuth. Adicione o ID do cliente OAuth à lista de permissões para acesso programático ao aplicativo.
2. Receba um token de ID para o ID do cliente protegido pelo IAP.
   • Android: use a API Google Sign-in para solicitar um token do OpenID Connect (OIDC). Defina o ID do cliente requestIdToken como o do recurso a que você está se conectando.
   • iOS: use o Login do Google para receber um token de ID.
3. Inclua o token de ID em um cabeçalho Authorization: Bearer para fazer a solicitação autenticada ao recurso protegido pelo IAP.

Autenticar usando um app para computador

Esta seção descreve como autenticar uma conta de usuário de uma linha de comando de um desktop.

1. Para permitir que os desenvolvedores acessem seu aplicativo na linha de comando, crie um ID do cliente OAuth 2.0 para computador ou compartilhe um ID do cliente OAuth para computador existente.
2. Adicione o ID do OAuth à lista de permissões para acesso programático ao aplicativo.

Fazer login no aplicativo

Cada desenvolvedor que quiser acessar um app protegido pelo IAP precisa fazer login primeiro. É possível empacotar o processo em um script, por exemplo, usando a CLI gcloud. O exemplo a seguir usa o curl para fazer login e gerar um token que pode ser usado para acessar o aplicativo:

1. Faça login na conta que tem acesso ao recurso Google Cloud .

2. Inicie um servidor local que possa repetir as solicitações recebidas.

     # Example using Netcat (http://netcat.sourceforge.net/)
     nc -k -l 4444
   

3. Acesse o seguinte URI, em que DESKTOP_CLIENT_ID é o ID do cliente do app para computador:

     https://accounts.google.com/o/oauth2/v2/auth?client_id=DESKTOP_CLIENT_ID&response_type=code&scope=openid%20email&access_type=offline&redirect_uri=http://localhost:4444&cred_ref=true
   

4. Na saída do servidor local, procure os parâmetros de solicitação:

     GET /?code=CODE&scope=email%20openid%20https://www.googleapis.com/auth/userinfo.email&hd=google.com&prompt=consent HTTP/1.1
   

5. Copie o valor CODE para substituir AUTH_CODE no comando a seguir, junto com o ID do cliente e a chave secreta do app para computador:

     curl --verbose \
       --data client_id=DESKTOP_CLIENT_ID \
       --data client_secret=DESKTOP_CLIENT_SECRET \
       --data code=CODE \
       --data redirect_uri=http://localhost:4444 \
       --data grant_type=authorization_code \
       https://oauth2.googleapis.com/token
   

   Esse comando retorna um objeto JSON com um campo id_token que pode ser usado para acessar o aplicativo.

Acessar o aplicativo

Para acessar o app, use id_token:

curl --verbose --header 'Authorization: Bearer ID_TOKEN' URL

Token de atualização

É possível usar o token de atualização gerado durante o fluxo de login para receber novos tokens de ID. Isso é útil quando o token de ID original expira. Cada token de ID é válido por cerca de uma hora. Durante esse período, é possível fazer várias solicitações a um app específico.

O exemplo a seguir usa o curl para usar o token de atualização e receber um novo token de ID. Neste exemplo, REFRESH_TOKEN é o token do fluxo de login. DESKTOP_CLIENT_ID e DESKTOP_CLIENT_SECRET são os mesmos usados no fluxo de login:

curl --verbose \
  --data client_id=DESKTOP_CLIENT_ID \
  --data client_secret=DESKTOP_CLIENT_SECRET \
  --data refresh_token=REFRESH_TOKEN \
  --data grant_type=refresh_token \
  https://oauth2.googleapis.com/token

Esse comando retorna um objeto JSON com um novo campo id_token, que pode ser usado para acessar o app.

Autenticar uma conta de serviço

É possível usar um JWT da conta de serviço ou um token do OpenID Connect (OIDC) para autenticar uma conta de serviço com um recurso protegido pelo IAP. A tabela a seguir descreve algumas diferenças entre os diferentes tokens de autenticação e os recursos deles.

Autenticar com um JWT de conta de serviço

O IAP oferece suporte à autenticação JWT da conta de serviço para identidades do Google, do Identity Platform e da federação de identidade de colaboradores configuradas.

A autenticação de uma conta de serviço usando um JWT compreende as seguintes etapas principais:

1. Conceda à conta de serviço de chamada o papel Criador de token da conta de serviço (roles/iam.serviceAccountTokenCreator).

   O papel concede aos principais a permissão para criar credenciais de curta duração, como JWTs.

2. Crie um JWT para o recurso protegido pelo IAP.

3. Assine o JWT usando a chave privada da conta de serviço.

Como criar o JWT

O JWT criado precisa ter um payload semelhante ao exemplo abaixo:

{
  "iss": SERVICE_ACCOUNT_EMAIL_ADDRESS,
  "sub": SERVICE_ACCOUNT_EMAIL_ADDRESS,
  "aud": TARGET_URL,
  "iat": IAT,
  "exp": EXP,
}

• Para os campos iss e sub, especifique o endereço de e-mail da conta de serviço. Ele é encontrado no campo client_email do arquivo JSON da conta de serviço ou transmitido. Formato típico: service-account@PROJECT_ID.iam.gserviceaccount.com

• No campo aud, especifique o URL do recurso protegido por IAP.

• Para o campo iat, especifique a época atual do Unix e, para o campo exp, especifique um horário dentro de 3600 segundos depois. Isso define quando o JWT expira.

Assinaturar o JWT

Use um dos seguintes métodos para assinar o JWT:

• Use a API de credenciais do IAM para assinar um JWT sem exigir acesso direto a uma chave privada.
• Use um arquivo de chave de credenciais local para assinar o JWT localmente.

Como assinar o JWT usando a API Service Account Credentials do IAM

Use a API Service Account Credentials do IAM para assinar um JWT de conta de serviço. O método busca a chave privada associada à sua conta de serviço e a usa para assinar o payload do JWT. Isso permite a assinatura de um JWT sem acesso direto a uma chave privada.

Para autenticar no IAP, configure as credenciais padrão do aplicativo. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

cat > claim.json << EOM
{
  "iss": "SERVICE_ACCOUNT_EMAIL_ADDRESS",
  "sub": "SERVICE_ACCOUNT_EMAIL_ADDRESS",
  "aud": "TARGET_URL",
  "iat": $(date +%s),
  "exp": $((`date +%s` + 3600))
}
EOM

gcloud iam service-accounts sign-jwt --iam-account="SERVICE_ACCOUNT_EMAIL_ADDRESS" claim.json output.jwt

import datetime
import json

import google.auth
from google.cloud import iam_credentials_v1

def generate_jwt_payload(service_account_email: str, resource_url: str) -> str:
    """Generates JWT payload for service account.

    Creates a properly formatted JWT payload with standard claims (iss, sub, aud,
    iat, exp) needed for IAP authentication.

    Args:
        service_account_email (str): Specifies service account JWT is created for.
        resource_url (str): Specifies scope of the JWT, the URL that the JWT will
            be allowed to access.

    Returns:
        str: JSON string containing the JWT payload with properly formatted claims.
    """
    # Create current time and expiration time (1 hour later) in UTC
    iat = datetime.datetime.now(tz=datetime.timezone.utc)
    exp = iat + datetime.timedelta(seconds=3600)

    # Convert datetime objects to numeric timestamps (seconds since epoch)
    # as required by JWT standard (RFC 7519)
    payload = {
        "iss": service_account_email,
        "sub": service_account_email,
        "aud": resource_url,
        "iat": int(iat.timestamp()),
        "exp": int(exp.timestamp()),
    }

    return json.dumps(payload)

def sign_jwt(target_sa: str, resource_url: str) -> str:
    """Signs JWT payload using ADC and IAM credentials API.

    Uses Google Cloud's IAM Credentials API to sign a JWT. This requires the
    caller to have iap.webServiceVersions.accessViaIap permission on the target
    service account.

    Args:
        target_sa (str): Service Account JWT is being created for.
            iap.webServiceVersions.accessViaIap permission is required.
        resource_url (str): Audience of the JWT, and scope of the JWT token.
            This is the url of the IAP protected application.

    Returns:
        str: A signed JWT that can be used to access IAP protected apps.
            Use in Authorization header as: 'Bearer <signed_jwt>'
    """
    # Get default credentials from environment or application credentials
    source_credentials, project_id = google.auth.default()

    # Initialize IAM credentials client with source credentials
    iam_client = iam_credentials_v1.IAMCredentialsClient(credentials=source_credentials)

    # Generate the service account resource name
    # If project_id is None, use '-' as placeholder as per API requirements
    project = project_id if project_id else "-"
    name = iam_client.service_account_path(project, target_sa)

    # Create and sign the JWT payload
    payload = generate_jwt_payload(target_sa, resource_url)

    # Sign the JWT using the IAM credentials API
    response = iam_client.sign_jwt(name=name, payload=payload)

    return response.signed_jwt

Assinando o JWT de um arquivo de chave de credencial local

Os JWTs são assinados usando a chave privada da conta de serviço.

Se você tiver um arquivo de chave da conta de serviço, o JWT poderá ser assinado localmente.

O script envia um cabeçalho JWT com o payload. Para o campo kid no cabeçalho, use o ID da chave privada da conta de serviço, que está no campo private_key_id do arquivo JSON da credencial da conta de serviço. A chave também é usada para assinar o JWT.

Como acessar o aplicativo

Em todos os casos, para acessar o app, use signed-jwt:

curl --verbose --header 'Authorization: Bearer SIGNED_JWT' URL

Autenticar com um token OIDC

1. Crie ou use um ID do cliente OAuth 2.0 existente. Para usar um ID do cliente OAuth 2.0, siga as etapas em Como compartilhar clientes OAuth.
2. Adicione o ID do OAuth à lista de permissões para acesso programático ao aplicativo.
3. Verifique se a conta de serviço padrão foi adicionada à lista de acesso do projeto protegido pelo IAP.

Ao fazer solicitações ao recurso protegido pelo IAP, é necessário incluir o token no cabeçalho Authorization: Authorization: 'Bearer OIDC_TOKEN'

Os exemplos de código abaixo demonstram como receber um token OIDC.

Como conseguir um token OIDC para a conta de serviço padrão

Para receber um token do OIDC para a conta de serviço padrão do Compute Engine, do App Engine ou do Cloud Run, consulte a exemplo de código a seguir para gerar um token para acessar um recurso protegido pelo IAP:

using Google.Apis.Auth.OAuth2;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;

public class IAPClient
{
    /// <summary>
    /// Makes a request to a IAP secured application by first obtaining
    /// an OIDC token.
    /// </summary>
    /// <param name="iapClientId">The client ID observed on 
    /// https://console.cloud.google.com/apis/credentials. </param>
    /// <param name="uri">HTTP URI to fetch.</param>
    /// <param name="cancellationToken">The token to propagate operation cancel notifications.</param>
    /// <returns>The HTTP response message.</returns>
    public async Task<HttpResponseMessage> InvokeRequestAsync(
        string iapClientId, string uri, CancellationToken cancellationToken = default)
    {
        // Get the OidcToken.
        // You only need to do this once in your application
        // as long as you can keep a reference to the returned OidcToken.
        OidcToken oidcToken = await GetOidcTokenAsync(iapClientId, cancellationToken);

        // Before making an HTTP request, always obtain the string token from the OIDC token,
        // the OIDC token will refresh the string token if it expires.
        string token = await oidcToken.GetAccessTokenAsync(cancellationToken);

        // Include the OIDC token in an Authorization: Bearer header to 
        // IAP-secured resource
        // Note: Normally you would use an HttpClientFactory to build the httpClient.
        // For simplicity we are building the HttpClient directly.
        using HttpClient httpClient = new HttpClient();
        httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
        return await httpClient.GetAsync(uri, cancellationToken);
    }

    /// <summary>
    /// Obtains an OIDC token for authentication an IAP request.
    /// </summary>
    /// <param name="iapClientId">The client ID observed on 
    /// https://console.cloud.google.com/apis/credentials. </param>
    /// <param name="cancellationToken">The token to propagate operation cancel notifications.</param>
    /// <returns>The HTTP response message.</returns>
    public async Task<OidcToken> GetOidcTokenAsync(string iapClientId, CancellationToken cancellationToken)
    {
        // Obtain the application default credentials.
        GoogleCredential credential = await GoogleCredential.GetApplicationDefaultAsync(cancellationToken);

        // Request an OIDC token for the Cloud IAP-secured client ID.
       return await credential.GetOidcTokenAsync(OidcTokenOptions.FromTargetAudience(iapClientId), cancellationToken);
    }
}

import (
	"context"
	"fmt"
	"io"
	"net/http"

	"google.golang.org/api/idtoken"
)

// makeIAPRequest makes a request to an application protected by Identity-Aware
// Proxy with the given audience.
func makeIAPRequest(w io.Writer, request *http.Request, audience string) error {
	// request, err := http.NewRequest("GET", "http://example.com", nil)
	// audience := "IAP_CLIENT_ID.apps.googleusercontent.com"
	ctx := context.Background()

	// client is a http.Client that automatically adds an "Authorization" header
	// to any requests made.
	client, err := idtoken.NewClient(ctx, audience)
	if err != nil {
		return fmt.Errorf("idtoken.NewClient: %w", err)
	}

	response, err := client.Do(request)
	if err != nil {
		return fmt.Errorf("client.Do: %w", err)
	}
	defer response.Body.Close()
	if _, err := io.Copy(w, response.Body); err != nil {
		return fmt.Errorf("io.Copy: %w", err)
	}

	return nil
}

import com.google.api.client.http.HttpRequest;
import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.auth.oauth2.IdTokenCredentials;
import com.google.auth.oauth2.IdTokenProvider;
import com.google.common.base.Preconditions;
import java.io.IOException;
import java.util.Collections;

public class BuildIapRequest {
  private static final String IAM_SCOPE = "https://www.googleapis.com/auth/iam";

  private static final HttpTransport httpTransport = new NetHttpTransport();

  private BuildIapRequest() {}

  private static IdTokenProvider getIdTokenProvider() throws IOException {
    GoogleCredentials credentials =
        GoogleCredentials.getApplicationDefault().createScoped(Collections.singleton(IAM_SCOPE));

    Preconditions.checkNotNull(credentials, "Expected to load credentials");
    Preconditions.checkState(
        credentials instanceof IdTokenProvider,
        String.format(
            "Expected credentials that can provide id tokens, got %s instead",
            credentials.getClass().getName()));

    return (IdTokenProvider) credentials;
  }

  /**
   * Clone request and add an IAP Bearer Authorization header with ID Token.
   *
   * @param request Request to add authorization header
   * @param iapClientId OAuth 2.0 client ID for IAP protected resource
   * @return Clone of request with Bearer style authorization header with ID Token.
   * @throws IOException exception creating ID Token
   */
  public static HttpRequest buildIapRequest(HttpRequest request, String iapClientId)
      throws IOException {

    IdTokenProvider idTokenProvider = getIdTokenProvider();
    IdTokenCredentials credentials =
        IdTokenCredentials.newBuilder()
            .setIdTokenProvider(idTokenProvider)
            .setTargetAudience(iapClientId)
            .build();

    HttpRequestInitializer httpRequestInitializer = new HttpCredentialsAdapter(credentials);

    return httpTransport
        .createRequestFactory(httpRequestInitializer)
        .buildRequest(request.getRequestMethod(), request.getUrl(), request.getContent());
  }
}

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const url = 'https://some.iap.url';
// const targetAudience = 'IAP_CLIENT_ID.apps.googleusercontent.com';

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

async function request() {
  console.info(`request IAP ${url} with target audience ${targetAudience}`);
  const client = await auth.getIdTokenClient(targetAudience);
  const res = await client.fetch(url);
  console.info(res.data);
}

request().catch(err => {
  console.error(err.message);
  process.exitCode = 1;
});

namespace Google\Cloud\Samples\Iap;

# Imports Auth libraries and Guzzle HTTP libraries.
use Google\Auth\ApplicationDefaultCredentials;
use GuzzleHttp\Client;
use GuzzleHttp\HandlerStack;

/**
 * Make a request to an application protected by Identity-Aware Proxy.
 *
 * @param string $url The Identity-Aware Proxy-protected URL to fetch.
 * @param string $clientId The client ID used by Identity-Aware Proxy.
 */
function make_iap_request($url, $clientId)
{
    // create middleware, using the client ID as the target audience for IAP
    $middleware = ApplicationDefaultCredentials::getIdTokenMiddleware($clientId);
    $stack = HandlerStack::create();
    $stack->push($middleware);

    // create the HTTP client
    $client = new Client([
        'handler' => $stack,
        'auth' => 'google_auth'
    ]);

    // make the request
    $response = $client->get($url);
    print('Printing out response body:');
    print($response->getBody());
}

from google.auth.transport.requests import Request
from google.oauth2 import id_token
import requests


def make_iap_request(url, client_id, method="GET", **kwargs):
    """Makes a request to an application protected by Identity-Aware Proxy.

    Args:
      url: The Identity-Aware Proxy-protected URL to fetch.
      client_id: The client ID used by Identity-Aware Proxy.
      method: The request method to use
              ('GET', 'OPTIONS', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE')
      **kwargs: Any of the parameters defined for the request function:
                https://github.com/requests/requests/blob/master/requests/api.py
                If no timeout is provided, it is set to 90 by default.

    Returns:
      The page body, or raises an exception if the page couldn't be retrieved.
    """
    # Set the default timeout, if missing
    if "timeout" not in kwargs:
        kwargs["timeout"] = 90

    # Obtain an OpenID Connect (OIDC) token from metadata server or using service
    # account.
    open_id_connect_token = id_token.fetch_id_token(Request(), client_id)

    # Fetch the Identity-Aware Proxy-protected URL, including an
    # Authorization header containing "Bearer " followed by a
    # Google-issued OpenID Connect token for the service account.
    resp = requests.request(
        method,
        url,
        headers={"Authorization": "Bearer {}".format(open_id_connect_token)},
        **kwargs
    )
    if resp.status_code == 403:
        raise Exception(
            "Service account does not have permission to "
            "access the IAP-protected application."
        )
    elif resp.status_code != 200:
        raise Exception(
            "Bad response from application: {!r} / {!r} / {!r}".format(
                resp.status_code, resp.headers, resp.text
            )
        )
    else:
        return resp.text

# url = "The Identity-Aware Proxy-protected URL to fetch"
# client_id = "The client ID used by Identity-Aware Proxy"
require "googleauth"
require "faraday"

# The client ID as the target audience for IAP
id_token_creds = Google::Auth::Credentials.default target_audience: client_id

headers = {}
id_token_creds.client.apply! headers

resp = Faraday.get url, nil, headers

if resp.status == 200
  puts "X-Goog-Iap-Jwt-Assertion:"
  puts resp.body
else
  puts "Error requesting IAP"
  puts resp.status
  puts resp.headers
end

Como conseguir um token OIDC de um arquivo de chave de conta de serviço local

Para gerar um token OIDC usando um arquivo de chave de conta de serviço, use o arquivo de chave para criar e assinar uma declaração JWT e troque essa declaração por um token de ID. O script Bash a seguir demonstra esse processo:

#!/usr/bin/env bash
#
# Example script that generates an OIDC token using a service account key file
# and uses it to access an IAP-secured resource

set -euo pipefail

get_token() {
  # Get the bearer token in exchange for the service account credentials
  local service_account_key_file_path="${1}"
  local iap_client_id="${2}"

  # Define the scope and token endpoint
  local iam_scope="https://www.googleapis.com/auth/iam"
  local oauth_token_uri="https://www.googleapis.com/oauth2/v4/token"

  # Extract data from service account key file
  local private_key_id="$(cat "${service_account_key_file_path}" | jq -r '.private_key_id')"
  local client_email="$(cat "${service_account_key_file_path}" | jq -r '.client_email')"
  local private_key="$(cat "${service_account_key_file_path}" | jq -r '.private_key')"

  # Set token timestamps (current time and expiration 10 minutes later)
  local issued_at="$(date +%s)"
  local expires_at="$((issued_at + 600))"

  # Create JWT header and payload
  local header="{'alg':'RS256','typ':'JWT','kid':'${private_key_id}'}"
  local header_base64="$(echo "${header}" | base64 | tr -d '\n')"
  local payload="{'iss':'${client_email}','aud':'${oauth_token_uri}','exp':${expires_at},'iat':${issued_at},'sub':'${client_email}','target_audience':'${iap_client_id}'}"
  local payload_base64="$(echo "${payload}" | base64 | tr -d '\n')"

  # Create JWT signature using the private key
  local signature_base64="$(printf %s "${header_base64}.${payload_base64}" | openssl dgst -binary -sha256 -sign <(printf '%s\n' "${private_key}")  | base64 | tr -d '\n')"
  local assertion="${header_base64}.${payload_base64}.${signature_base64}"

  # Exchange the signed JWT assertion for an ID token
  local token_payload="$(curl -s \
    --data-urlencode "grant_type=urn:ietf:params:oauth:grant-type:jwt-bearer" \
    --data-urlencode "assertion=${assertion}" \
    https://www.googleapis.com/oauth2/v4/token)"

  # Extract just the ID token from the response
  local bearer_id_token="$(echo "${token_payload}" | jq -r '.id_token')"
  echo "${bearer_id_token}"
}

main() {
  # Check if required arguments are provided
  if [[ $# -lt 3 ]]; then
    echo "Usage: $0 <service_account_key_file.json> <iap_client_id> <url>"
    exit 1
  fi

  # Assign parameters to variables
  SERVICE_ACCOUNT_KEY="$1"
  IAP_CLIENT_ID="$2"
  URL="$3"

  # Generate the ID token
  echo "Generating token..."
  ID_TOKEN=$(get_token "${SERVICE_ACCOUNT_KEY}" "${IAP_CLIENT_ID}")

  # Access the IAP-secured resource with the token
  echo "Accessing: ${URL}"
  curl --header "Authorization: Bearer ${ID_TOKEN}" "${URL}"
}

# Run the main function with all provided arguments
main "$@"

  ./get_iap_token.sh service-account-key.json \
    OAUTH_CLIENT_ID \
    URL

Como conseguir um token OIDC em todos os outros casos

Em todos os outros casos, use a API de credenciais do IAM para gerar um token OIDC falsificando uma conta de serviço de destino antes de acessar um recurso protegido pelo IAP: Esse processo envolve as seguintes etapas:

1. Forneça à conta de serviço de chamada (a conta de serviço associada ao código que está recebendo o token de ID) o papel de Criador do token de identidade do OpenID Connect da conta de serviço (roles/iam.serviceAccountOpenIdTokenCreator).

   Isso permite que a conta de serviço de chamada imite a conta de serviço de destino.

2. Use as credenciais fornecidas pela conta de serviço de chamada para chamar o método generateIdToken na conta de serviço de destino.

   Defina o campo audience como o ID do cliente.

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

Autenticação pelo cabeçalho Proxy-Authorization

Se o aplicativo usar o cabeçalho de solicitação Authorization, inclua o token de ID em um cabeçalho Proxy-Authorization: Bearer. Se um token de ID válido for encontrado em um cabeçalho Proxy-Authorization, o IAP vai autorizar a solicitação com ele. Depois de autorizar a solicitação, o IAP transmite o cabeçalho Authorization para o aplicativo sem processar o conteúdo.

Se nenhum token de ID válido for encontrado no cabeçalho Proxy-Authorization, o IAP vai continuar processando o cabeçalho Authorization e retirar o cabeçalho Proxy-Authorization antes de transmitir a solicitação para o app.

A seguir

• Saiba mais sobre Autorização: tokens do portador.
• Tente usar o Login no Android ou o Login no iOS.