Autenticação programática

Neste documento, descrevemos como autenticar em um recurso protegido pelo IAP usando uma conta de usuário ou de conta de serviço.

O acesso programático se refere à chamada de aplicativos protegidos pelo IAP de clientes que não são navegadores, como ferramentas de linha de comando, chamadas de serviço a serviço e aplicativos para dispositivos móveis. Dependendo do caso de uso, talvez você queira 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, não um usuário individual. Você autentica uma conta de serviço quando quer permitir que um aplicativo acesse seus recursos protegidos pelo IAP. Para mais informações, consulte Contas de serviço.

O IAP é compatível com os 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 do IAP. * JWT assinado pela conta de serviço: um token JWT autoassinado ou emitido pelo Google para uma conta de serviço.

Inclua essas credenciais no IAP no cabeçalho HTTP Authorization ou Proxy-Authorization da solicitação.

Antes de começar

  1. Verifique se você tem um aplicativo que quer acessar de forma programática usando uma conta de desenvolvedor, uma conta de serviço ou credenciais de app para dispositivos móveis.

  2. Para criar um ou mais clientes OAuth 2.0, consulte Acesso programático.

Autenticar uma conta de usuário

É possível permitir que o usuário acesse seu aplicativo em um computador ou dispositivo móvel para que um programa interaja com um recurso protegido pelo IAP.

Autenticar em um app para dispositivos móveis

  1. Crie ou use um ID do cliente OAuth 2.0 para seu 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. Consiga um token de ID para o ID do cliente OAuth 2.0 do recurso protegido pelo IAP.
  3. Inclua o token de ID em um cabeçalho Authorization: Bearer para fazer a solicitação autenticada ao recurso protegido pelo IAP.

Autenticar em 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 pela linha de comando, crie um ID do cliente OAuth 2.0 para computador ou compartilhe um ID do cliente OAuth para computador.
  2. Adicione o ID do OAuth à lista de permissões para acesso programático ao aplicativo.

Faça login no aplicativo.

Cada desenvolvedor precisa fazer login para acessar um app protegido pelo IAP. É possível empacotar o processo em um script, por exemplo, usando a CLI gcloud. O exemplo a seguir usa 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 do 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 de CODE para substituir 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 o id_token:

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

Token de atualização

Use 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, período em que é possível fazer várias solicitações para um app específico.

O exemplo a seguir usa curl para usar o token de atualização para 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 de 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 das diferenças entre os tokens de autenticação e os recursos deles.

Recursos do Authentication JWT da conta de serviço Token do OpenID Connect
Compatibilidade com o acesso baseado no contexto
Requisito de ID do cliente OAuth 2.0
Escopo do token URL do recurso protegido pelo IAP ID do cliente OAuth 2.0

Autenticar com um JWT de conta de serviço

O IAP é compatível com a autenticação JWT de conta de serviço para identidades do Google, Identity Platform e aplicativos configurados com a federação de identidade de colaboradores.

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

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

    O papel concede aos principais 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.

Criar o JWT

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

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

  • Nos campos iss e sub, especifique o endereço de e-mail da conta de serviço. O endereço de e-mail está no campo client_email do arquivo JSON da conta de serviço ou é fornecido como entrada. Formato típico: service-account@PROJECT_ID.iam.gserviceaccount.com

  • No campo aud, especifique o URL exato ou o URL com um caractere curinga de caminho (/*) do recurso protegido pelo IAP, por exemplo, https://example.com/ ou https://example.com/*. Um JWT com o URL exato no campo aud só pode acessar esse URL específico. Um JWT com o caractere curinga de caminho (/*) no campo aud pode acessar todos os URLs que têm como prefixo a string aud sem o * final.

  • No campo iat, especifique o horário atual da época Unix e, no campo exp, especifique um horário até 3.600 segundos depois. Define quando o JWT expira.

Assinar o JWT

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

  • Use a API IAM Credentials para assinar um JWT sem precisar de acesso direto a uma chave privada.
  • Use um arquivo de chave de credenciais local para assinar o JWT localmente.
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 o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

gcloud

  1. Execute o comando a seguir para preparar uma solicitação com o payload JWT:
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
  1. Use o seguinte comando da Google Cloud CLI para assinar o payload em claim.json:
gcloud iam service-accounts sign-jwt --iam-account="SERVICE_ACCOUNT_EMAIL_ADDRESS" claim.json output.jwt

Após uma solicitação bem-sucedida, output.jwt contém um JWT assinado que pode ser usado para acessar o recurso protegido pelo IAP.

Python

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 the service account that the
        JWT is created for.
        resource_url (str): Specifies the 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-secured application.

    Returns:
        str: A signed JWT that can be used to access IAP-secured applications.
            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.
    # Project should always be "-".
    # Replacing the wildcard character with a project ID is invalid.
    name = iam_client.service_account_path("-", 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

curl

  1. Execute o comando a seguir para preparar uma solicitação com o payload JWT:

    cat << EOF > request.json
{
  "payload": JWT_PAYLOAD
}
EOF

  2. Assinar o JWT usando o IAM

    API Service Account Credentials:

    curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json; charset=utf-8" \
  -d @request.json \
  "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/SERVICE_ACCOUNT_EMAIL_ADDRESS:signJwt"

    Após uma solicitação bem-sucedida, um JWT assinado é retornado na resposta.

  3. Use o JWT para acessar o recurso protegido pelo IAP.

Assinar 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 de conta de serviço, o JWT poderá ser assinado localmente.

Ao assinar o JWT localmente, inclua um cabeçalho JWT com o payload. No 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 de credencial da conta de serviço. A chave privada do arquivo é usada para assinar o JWT.

Acessar o aplicativo

Para acessar o aplicativo, inclua o JWT assinado no cabeçalho de autorização:

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

Autenticar com um token OIDC de conta de serviço

Para autenticar com um token OIDC de conta de serviço, faça o seguinte:

  1. Crie um novo ID do cliente OIDC ou use um que já existe.

    • Para criar um novo ID do cliente OAuth 2.0, faça o seguinte:

      1. Registre seu aplicativo para usar o Google Auth, se ainda não tiver feito isso.

      2. Acesse a página da Google Auth Platform.

        Acessar a Google Auth Platform

        Se você não tiver um projeto selecionado, será solicitado que crie um.

      3. Clique em Criar cliente.

      4. Selecione o tipo de aplicativo adequado e insira as informações adicionais necessárias.

      5. Preencha as informações necessárias para o tipo de cliente selecionado. Para criar o cliente, clique em Criar.

    • 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, inclua o token no cabeçalho Authorization: Authorization: 'Bearer OIDC_TOKEN'

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

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

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

C#

Para autenticar no IAP, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.


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);
    }
}

Go

Para autenticar no IAP, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

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
}

Java

Para autenticar no IAP, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 


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());
  }
}

Node.js

Para autenticar no IAP, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

/**
 * 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;
});

PHP

Para autenticar no IAP, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

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());
}

Python

Para autenticar no IAP, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

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

Ruby

Para autenticar no IAP, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

# 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

Receber um token OIDC de um arquivo de chave da conta de serviço local

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

Bash

#!/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 "$@"

Esse script executa as seguintes etapas:

  1. Extrai as informações da chave da conta de serviço do arquivo de chave JSON.
  2. Cria um JWT com os campos necessários, incluindo o ID do cliente do IAP como público-alvo.
  3. Assina o JWT usando a chave privada da conta de serviço.
  4. Troca esse JWT por um token OIDC usando o serviço OAuth do Google.
  5. Usa o token resultante para fazer uma solicitação autenticada ao recurso protegido pelo IAP.

Para usar este script:

  1. Salve-o em um arquivo, por exemplo: get_iap_token.sh
  2. Torne-o executável: chmod +x get_iap_token.sh
  3. Execute-o com três parâmetros:
  ./get_iap_token.sh service-account-key.json \
    OAUTH_CLIENT_ID \
    URL

Em que:

  • service-account-key.json é o arquivo de chave da conta de serviço que você salvou.
  • OAUTH_CLIENT_ID é o ID do cliente OAuth do recurso protegido pelo IAP.
  • URL é o URL que você quer acessar.

Receber um token do OIDC usando a identidade temporária de conta de serviço

Em todos os outros casos, use a API IAM Credentials para gerar um token OIDC personificando uma conta de serviço de destino logo 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 de token de identidade do OpenID Connect da conta de serviço (roles/iam.serviceAccountOpenIdTokenCreator).

    Isso permite que a conta de serviço de chamada represente 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 detalhadas, consulte Criar um token de ID.

Autenticar pelo cabeçalho Proxy-Authorization

Se o aplicativo usar o cabeçalho da solicitação Authorization, será possível incluir 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 continuará processando o cabeçalho Authorization e removerá o cabeçalho Proxy-Authorization antes de transmitir a solicitação para o aplicativo.

Acessar o aplicativo

Para acessar o aplicativo usando o cabeçalho Proxy-Authorization, execute o seguinte comando:

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

A seguir