程式輔助驗證

本文說明如何透過使用者帳戶或服務帳戶，驗證受 IAP 保護的資源。

程式輔助存取是指從非瀏覽器用戶端 (例如指令列工具、服務對服務呼叫和行動應用程式) 呼叫 IAP 保護的應用程式。視用途而定，您可能想使用使用者憑證或服務憑證向 IAP 進行驗證。

• 「使用者帳戶」屬於個別使用者。當您的應用程式需要代表使用者存取受 IAP 保護的資源時，您可以驗證使用者帳戶。詳情請參閱「使用者帳戶」。

  注意： IAP 僅支援 Google 身分，可供使用者帳戶以程式輔助方式存取。程式輔助存取不支援 Identity Platform 和員工身分聯盟身分。

• 「服務帳戶」代表應用程式，而非個別使用者。當您想讓應用程式存取受 IAP 保護的資源時，可以驗證服務帳戶。詳情請參閱服務帳戶。

IAP 支援下列類型的憑證，用於程式輔助存取：

• OAuth 2.0 ID 權杖 - Google 為使用者或服務帳戶核發的權杖，且目標對象聲明設定為 IAP 應用程式的資源 ID。
• 服務帳戶簽署的 JWT - 服務帳戶的自行簽署或 Google 發行的 JWT 權杖。

在要求的 Authorization 或 Proxy-Authorization HTTP 標頭中，將這些憑證傳送給 IAP。

事前準備

開始前，請確認您有受 IAP 保護的應用程式，且想使用開發人員帳戶、服務帳戶或行動應用程式憑證以程式化方式連線。

警告： 如果您將應用程式設定為使用 Google 管理的 OAuth 2.0 用戶端，系統預設會封鎖程式輔助存取權。您必須將 OAuth 2.0 用戶端新增至允許清單，呼叫端才能使用該用戶端產生憑證。

驗證使用者帳戶

您可以讓使用者從電腦或行動裝置存取您的應用程式，以讓程式與受 IAP 保護的資源互動。

透過行動應用程式驗證

1. 為行動應用程式建立或使用現有的 OAuth 2.0 用戶端 ID。如要使用現有的 OAuth 2.0 用戶端 ID，請按照「如何共用 OAuth 用戶端」一文中的步驟操作。將 OAuth 用戶端 ID 新增至應用程式的程式輔助存取許可清單。
2. 針對受 IAP 保護資源的 OAuth 2.0 用戶端 ID，取得 ID 符記。
   • Android：使用 Google Sign-In API 要求 OpenID Connect (OIDC) 權杖。將requestIdToken 用戶端 ID 設為您將要連線的資源用戶端 ID。
   • iOS：使用 Google 登入取得 ID 符記。
3. 將 ID 憑證包含在 Authorization: Bearer 標頭中，以對受 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 是「Desktop app」(電腦應用程式) 用戶端 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 替換為該值，並一併提供桌面應用程式的用戶端 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 物件，您可以使用該欄位存取應用程式。

注意： 存取層級政策不支援重新整理權杖工作流程。您必須使用完整的驗證流程重新產生新的 ID 權杖。

驗證服務帳戶

您可以使用服務帳戶 JWT 或 OpenID Connect (OIDC) 權杖，向受 IAP 保護的資源驗證服務帳戶。下表列出不同驗證權杖及其功能的差異。

驗證功能	服務帳戶 JWT	OpenID Connect 權杖
情境感知存取權支援
OAuth 2.0 用戶端 ID 規定
權杖範圍	受 IAP 保護的資源網址	OAuth 2.0 用戶端 ID

注意： 服務帳戶不支援裝置政策屬性，

使用服務帳戶 JWT 進行驗證

IAP 支援 Google 身分、Identity Platform 和 Workforce Identity Federation 設定應用程式的服務帳戶 JWT 驗證。

使用 JWT 驗證服務帳戶的步驟如下：

1. 將服務帳戶憑證建立者角色 (roles/iam.serviceAccountTokenCreator) 授予呼叫服務帳戶。

   警告： 為遵循最低權限原則，建議您在特定目標服務帳戶資源上授予 roles/iam.serviceAccountTokenCreator 角色，而非在專案層級授予。在專案層級授予 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 欄位中，指定確切網址或含有路徑萬用字元 (/*) 的網址，例如 https://example.com/ 或 https://example.com/*。如果 JWT 的 aud 欄位包含確切網址，就只能存取該網址。如果 JWT 的 aud 欄位含有路徑萬用字元 (/*)，則可存取所有以 aud 字串為前置字元的網址，但結尾不得有 *。

• 針對 iat 欄位，請指定目前的 Unix Epoch 時間；針對 exp 欄位，請指定 3600 秒內的時間。這會定義 JWT 的到期時間。

簽署 JWT

您可以使用下列任一方法簽署 JWT：

• 使用 IAM 憑證 API 簽署 JWT，不必直接存取私密金鑰。
• 使用本機憑證金鑰檔案在本機簽署 JWT。

使用 IAM 服務帳戶憑證 API 簽署 JWT

使用 IAM 服務帳戶憑證 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，可用於存取受 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 簽署 JWT

   Service Account Credentials API：

   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 保護的資源。

注意： 使用 IAM 憑證 API 簽署 JWT 需要進行網路呼叫。

從本機憑證金鑰檔案簽署 JWT

JWT 會使用服務帳戶的私密金鑰簽署。

如果您有服務帳戶金鑰檔案，則可在本機簽署 JWT。

在本地簽署 JWT 時，請在酬載中加入 JWT 標頭。如要使用標頭中的 kid 欄位，請使用服務帳戶的私密金鑰 ID，該 ID 位於服務帳戶憑證 JSON 檔案的 private_key_id 欄位中。檔案中的私密金鑰會用來簽署 JWT。

存取應用程式

如要存取應用程式，請在 Authorization 標頭中加入已簽署的 JWT：

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

使用服務帳戶 OIDC 權杖進行驗證

1. 建立或使用現有的 OAuth 2.0 用戶端 ID。如要使用現有的 OAuth 2.0 用戶端 ID，請按照「如何共用 OAuth 用戶端」一文中的步驟操作。
2. 將 OAuth ID 加入應用程式的程式輔助存取許可清單。
3. 確認預設服務帳戶已新增至受 IAP 保護專案的存取清單。

向受 IAP 保護的資源提出要求時，您必須在 Authorization 標頭中加入權杖：Authorization: 'Bearer OIDC_TOKEN'

注意： 產生的 ID 權杖必須含有應用程式內購的 email 聲明，系統才會接受。

下列程式碼範例說明如何取得 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 權杖

在所有其他情況下，請使用 IAM 憑證 API，在存取受 IAP 保護的資源之前，先模擬目標服務帳戶，產生 OIDC 權杖。這項程序包含下列步驟：

1. 為呼叫服務帳戶 (與取得 ID 權杖的程式碼相關聯的服務帳戶) 提供「服務帳戶 OpenID Connect 身分識別權杖建立者」角色 (roles/iam.serviceAccountOpenIdTokenCreator)。

   這項權限可讓呼叫服務帳戶模擬目標服務帳戶。

2. 使用呼叫服務帳戶提供的憑證，在目標服務帳戶上呼叫 generateIdToken 方法。

   將 audience 欄位設為您的用戶端 ID。

如需逐步操作說明，請參閱「建立 ID 權杖」。

透過 Proxy-Authorization 標頭驗證

如果應用程式使用 Authorization 要求標頭，您可以改為在 Proxy-Authorization: Bearer 標頭中加入 ID 權杖。如果 IAP 在 Proxy-Authorization 標頭中找到有效的 ID 權杖，就會使用該權杖授權要求。授權要求後，IAP 會將 Authorization 標頭傳遞至應用程式，但不會處理內容。

如果在 Proxy-Authorization 標頭中找不到有效的 ID 權杖，IAP 會繼續處理 Authorization 標頭，並在將要求傳遞至應用程式之前，先移除 Proxy-Authorization 標頭。

後續步驟

• 進一步瞭解 授權：不記名憑證。
• 測試 登入功能在 Android 應用程式的運作效果 或 登入功能在 iOS 應用程式的運作效果。