程序化身份验证

本文档介绍如何从用户账号或服务帐号向受 IAP 保护的资源进行身份验证。

以编程方式访问是指从非浏览器客户端（例如命令行工具、服务间调用和移动应用）调用受 IAP 保护的应用。您可以根据应用场景，选择使用用户凭据或服务凭据向 IAP 进行身份验证。

  • 用户账号 属于个别用户。当您的应用需要代表用户访问受 IAP 保护的资源，则对用户账号进行身份验证。如需了解更多 信息，请参阅用户账号。

  • 服务账号 代表应用而非个别用户。如果要允许应用访问受 IAP 保护的资源，则对服务帐号进行身份验证。如需了解详情，请参阅服务账号。

IAP 支持以下类型的凭据进行编程访问：

  • OAuth 2.0 ID 令牌 - Google 为人类用户或服务 账号颁发的令牌，其受众群体声明设置为 IAP 应用的资源 ID。
  • 服务账号签名的 JWT - 服务账号的自签名或 Google 颁发的 JWT 令牌 。

将这些凭据添加到请求的 Authorization 或 Proxy-Authorization HTTP 标头中的 IAP。

准备工作

  1. 确保您有一个应用，并且您希望使用开发者账号、服务帐号或移动应用凭据以编程方式访问该应用。

  2. 如需创建一个或多个 OAuth 2.0 客户端，请参阅 编程访问。

对用户账号进行身份验证

您可以允许用户从桌面应用或移动应用访问您的应用，从而支持程序与受 IAP 保护的资源进行交互。

从移动应用进行身份验证

  1. 为您的移动应用创建或使用现有的 OAuth 2.0 客户端 ID。如需使用现有的 OAuth 2.0 客户端 ID， 请按照 如何共享 OAuth 客户端中的步骤操作。 将 OAuth 客户端 ID 添加到允许列表中，以便 以编程方式访问 应用。
  2. 为受 IAP 保护的资源的 OAuth 2.0 客户端 ID 获取 ID 令牌。
  3. 在 Authorization: Bearer 标头中包含 ID 令牌以向受 IAP 保护的资源发出经过身份验证的请求。

从桌面应用进行身份验证

本部分介绍如何使用桌面命令行对用户账号进行身份验证。

  1. 如需允许开发者使用命令行访问您的应用， 请创建桌面 OAuth 2.0 客户端 ID 或 共享现有的桌面 OAuth 客户端 ID。
  2. 将 OAuth ID 添加到允许列表中，以便 以编程方式访问 应用。

登录应用

每位开发者都必须登录才能访问受 IAP 保护的应用。您可以 使用 gcloud CLI等工具将此过程打包到脚本中。以下示例演示了如何使用 curl 登录并生成一个可用于访问应用的令牌：

  1. 登录有权访问该 Google Cloud 资源的账号。

  2. 启动可以回显传入请求的本地服务器。

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

  3. 转到以下 URI，其中 DESKTOP_CLIENT_ID 是桌面应用 客户端 ID：

      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. 在本地服务器输出中，查找请求参数：

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

  5. 复制 CODE 值以替换 CODE 以下命令中的 CODE，以及 桌面应用 客户端 ID 和密钥：

      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

    此命令会返回一个带有 id_token 字段的 JSON 对象，您可以使用该字段访问应用。

访问应用

如需访问应用，请使用 id_token：

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

刷新令牌

您可以使用在登录流程中生成的刷新令牌来获取新的 ID 令牌。当原始 ID 令牌过期时，此方法非常有用。每个 ID 令牌的有效期约为一小时，在此期间，您可以向特定应用发出多个请求。

以下示例演示了如何使用 curl 获取刷新令牌以获取新的 ID 令牌。 在此示例中，REFRESH_TOKEN 是登录流程中的令牌。 DESKTOP_CLIENT_ID 和 DESKTOP_CLIENT_SECRET 与登录流程中使用的相同：

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

此命令会返回一个带有新 id_token 字段的 JSON 对象，您可以使用该字段访问应用。

对服务帐号进行身份验证

您可以使用 服务账号 JWT 或 OpenID Connect (OIDC) 令牌向 受 IAP 保护的资源对服务帐号进行身份验证。下表概述了不同身份验证令牌及其功能之间的一些差异。

Authentication 功能 服务账号 JWT OpenID Connect 令牌
情境感知访问权限支持
OAuth 2.0 客户端 ID 要求
令牌范围 受 IAP 保护的资源的网址 OAuth 2.0 客户端 ID

使用服务帐号 JWT 进行身份验证

IAP 支持为 Google 身份、Identity Platform 和配置了员工身份联合的应用进行服务帐号 JWT 身份验证。

使用 JWT 对服务帐号进行身份验证涉及以下步骤：

  1. 向调用服务帐号授予 Service Account Token Creator 角色 (roles/iam.serviceAccountTokenCreator)。

    此角色授予主账号创建 短期有效凭据（ 例如 JWT）的权限。

  2. 为受 IAP 保护的资源创建 JWT。

  3. 使用服务帐号私钥为 JWT 签名。

创建 JWT

创建的 JWT 应具有类似于以下示例的载荷：

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

  • 对于 iss 和 sub 字段，请指定服务账号的电子邮件地址。电子邮件地址位于服务帐号 JSON 文件的 client_email 字段中，或作为输入提供。典型格式： service-account@PROJECT_ID.iam.gserviceaccount.com

  • 对于 aud 字段，请指定受 IAP 保护的资源的确切网址或带有路径通配符 (/*) 的网址，例如 https://example.com/ 或 https://example.com/*。在 aud 字段中包含确切网址的 JWT 只能访问该特定网址。在aud字段中包含路径通配符 (/*)的 JWT 可以访问所有以 aud字符串为前缀且不带尾随*的网址。

  • 对于 iat 字段，请指定当前的 Unix 时间戳；对于 exp 字段，请指定 3600 秒后的时间。这定义了 JWT 的过期时间。

为 JWT 签名

您可以使用以下任一方法为 JWT 签名：

  • 使用 IAM Credentials API 为 JWT 签名，而无需直接访问私钥。
  • 使用本地凭据密钥文件在本地为 JWT 签名。
使用 IAM Service Account Credentials API 为 JWT 签名

使用 IAM Service Account Credentials API 为服务帐号 JWT 签名。该方法会提取与您的服务帐号关联的私钥，并使用该私钥为 JWT 载荷签名。这样，您就可以在无需直接访问私钥的情况下为 JWT 签名。

如需向 IAP 进行身份验证，请设置应用默认凭据。如需了解详情，请参阅 为本地开发环境设置身份验证。

gcloud

  1. 运行以下命令，准备包含 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. 使用以下 Google Cloud CLI 命令为 claim.json 中的载荷签名：
gcloud iam service-accounts sign-jwt --iam-account="SERVICE_ACCOUNT_EMAIL_ADDRESS" claim.json output.jwt

请求成功后，output.jwt 会包含一个已签名的 JWT，您可以使用该 JWT 访问受 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. 运行以下命令，准备包含 JWT 载荷的请求：

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

  2. 使用 IAM

    Service Account Credentials API 为 JWT 签名：

    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"

    请求成功后，系统会在响应中返回已签名的 JWT。

  3. 使用 JWT 访问受 IAP 保护的资源。

使用本地凭据密钥文件为 JWT 签名

JWT 使用服务帐号的私钥进行签名。

如果您有 服务账号密钥文件， 则可以在本地为 JWT 签名。

在本地为 JWT 签名时，请在载荷中添加 JWT 标头。对于标头中的 kid 字段，请使用服务帐号的私钥 ID，该 ID 位于服务帐号凭据 JSON 文件的 private_key_id 字段中。 文件中的私钥用于为 JWT 签名。

访问应用

如需访问应用，请在 Authorization 标头中添加已签名的 JWT：

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

使用服务帐号 OIDC 令牌进行身份验证

如需使用服务帐号 OIDC 令牌进行身份验证，请执行以下操作：

  1. 创建新的 OIDC 客户端 ID 或使用现有的 OIDC 客户端 ID。

    • 如需创建新的 OAuth 2.0 客户端 ID，请执行以下操作：

      1. 确保您已注册应用以使用 Google Auth（如果尚未注册）。

      2. 前往 Google Auth Platform 页面。

        前往 Google Auth Platform

        如果您未选择项目，系统会提示您创建一个项目。

      3. 点击创建客户端 。

      4. 选择适当的应用类型，然后输入所有其他必需的信息。

      5. 填写所选客户端类型的必要信息。如需创建客户端，请点击创建 。

    • 如需使用现有的 OAuth 2.0 客户端 ID：请按照 如何共享 OAuth 客户端中的步骤操作。

  2. 将 OAuth ID 添加到允许列表中，以便 以编程方式访问 应用。

  3. 确保将默认服务帐号添加到受 IAP 保护的项目的 访问权限列表。

向受 IAP 保护的资源发出请求时，您必须 在 Authorization 标头中添加令牌：Authorization: 'Bearer OIDC_TOKEN'

以下代码示例演示了如何获取 OIDC 令牌。

获取默认服务帐号的 OIDC 令牌

如需获取 Compute Engine、App Engine 或 Cloud Run 的默认服务帐号的 OIDC 令牌，请参考以下代码示例生成令牌，以访问受 IAP 保护的资源：

C#

如需向 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);
    }
}

Go

如需向 IAP 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅 为本地开发环境设置身份验证。 

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

如需向 IAP 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅 为本地开发环境设置身份验证。 


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

如需向 IAP 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅 为本地开发环境设置身份验证。 

/**
 * 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

如需向 IAP 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅 为本地开发环境设置身份验证。 

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

如需向 IAP 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅 为本地开发环境设置身份验证。 

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

如需向 IAP 进行身份验证，请设置应用默认凭据。 如需了解详情，请参阅 为本地开发环境设置身份验证。 

# 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

从本地服务帐号密钥文件获取 OIDC 令牌

如需使用服务帐号密钥文件生成 OIDC 令牌，请使用该密钥文件创建并签署 JWT 断言，然后将该断言交换为 ID 令牌。以下 Bash 脚本演示了此过程：

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 "$@"

该脚本会执行以下步骤：

  1. 从 JSON 密钥文件中提取服务帐号密钥信息
  2. 创建包含必要字段的 JWT，包括作为目标受众群体的 IAP 客户端 ID
  3. 使用服务帐号的私钥为 JWT 签名
  4. 通过 Google 的 OAuth 服务将此 JWT 交换为 OIDC 令牌
  5. 使用生成的令牌向受 IAP 保护的资源发出经过身份验证的请求

如需使用此脚本，请执行以下操作：

  1. 将其保存到文件中，例如：get_iap_token.sh
  2. 将其设为可执行文件：chmod +x get_iap_token.sh
  3. 使用三个参数运行它：
  ./get_iap_token.sh service-account-key.json \
    OAUTH_CLIENT_ID \
    URL

其中：

  • service-account-key.json 是您下载的服务帐号密钥文件
  • OAUTH_CLIENT_ID 是受 IAP 保护的资源的 OAuth 客户端 ID
  • URL 是您要访问的网址

通过使用服务帐号模拟获取 OIDC 令牌

在其他所有情况下，请在访问受 IAP 保护的资源之前，通过 模拟目标服务帐号，使用 IAM Credentials API 来 生成 OIDC 令牌。此过程包括以下步骤：

  1. 向调用服务帐号（与获取 ID 令牌的代码关联的服务帐号）授予 Service Account OpenID Connect Identity Token Creator 角色 (roles/iam.serviceAccountOpenIdTokenCreator)。

    这样，调用服务帐号就能够模拟目标服务帐号。

  2. 使用调用服务帐号提供的凭据对目标服务帐号调用 generateIdToken 方法。

    将 audience 字段设置为您的客户端 ID。

如需查看分步说明，请参阅 创建 ID 令牌。

从 Proxy-Authorization 标头进行身份验证

如果您的应用使用 Authorization 请求标头，您可以改为在 Proxy-Authorization: Bearer 标头中添加 ID 令牌。如果在 Proxy-Authorization 标头中找到了有效的 ID 令牌，则 IAP 会用它授权请求。授权请求后，IAP 会将 Authorization 标头传递给您的应用，而不处理内容。

如果在 Proxy-Authorization 标头中未找到有效的 ID 令牌， 则 IAP 会继续处理 Authorization 标头并 在将请求传递给应用之前去除 Proxy-Authorization 标头。

访问应用

如需使用 Proxy-Authorization 标头访问应用，请运行以下命令：

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

后续步骤