Autentikasi terprogram

Halaman ini menjelaskan cara mengautentikasi ke resource yang diamankan oleh Identity-Aware Proxy (IAP) dari akun pengguna atau akun layanan.

• Akun pengguna adalah milik pengguna individual. Anda mengautentikasi akun pengguna saat aplikasi Anda memerlukan akses ke resource yang diamankan IAP atas nama pengguna. Untuk mengetahui informasi selengkapnya, lihat Akun pengguna.

• Akun layanan adalah milik aplikasi, bukan pengguna perorangan. Anda mengautentikasi akun layanan saat ingin mengizinkan aplikasi untuk mengakses resource yang diamankan IAP. Untuk mengetahui informasi selengkapnya, lihat Akun layanan.

Sebelum memulai

Sebelum memulai, Anda memerlukan hal-hal berikut:

• Aplikasi yang diamankan IAP yang ingin Anda hubungkan secara terprogram menggunakan kredensial akun developer, akun layanan, atau aplikasi seluler.

Mengautentikasi akun pengguna

Anda dapat mengaktifkan akses pengguna ke aplikasi dari aplikasi desktop atau seluler untuk mengizinkan program berinteraksi dengan resource yang diamankan IAP.

Mengautentikasi dari aplikasi seluler

1. Buat atau gunakan client ID OAuth 2.0 yang ada untuk aplikasi seluler Anda. Untuk menggunakan client ID OAuth 2.0 yang ada, ikuti langkah-langkah di Cara membagikan Klien OAuth.
2. Izinkan client ID OAuth untuk akses terprogram untuk aplikasi.
3. Mendapatkan token ID untuk client ID yang diamankan IAP.
   • Android: Gunakan Google Sign-In API untuk meminta token OpenID Connect (OIDC). Tetapkan client ID requestIdToken ke client ID untuk resource yang Anda hubungkan.
   • iOS: Gunakan Login dengan Google untuk mendapatkan token ID.
4. Sertakan token ID di header Authorization: Bearer untuk membuat permintaan yang diautentikasi ke resource yang diamankan IAP.

Melakukan autentikasi dari aplikasi desktop

Bagian ini menjelaskan cara mengautentikasi akun pengguna dari command line desktop.

1. Untuk mengizinkan developer mengakses aplikasi Anda dari command line, buat client ID OAuth 2.0 desktop atau bagikan client ID OAuth desktop yang ada.
2. Izinkan client ID OAuth untuk akses terprogram untuk aplikasi.

Login ke aplikasi

Setiap developer yang ingin mengakses aplikasi yang diamankan IAP harus login terlebih dahulu. Anda dapat memaketkan proses ke dalam skrip, seperti dengan menggunakan gcloud CLI. Berikut adalah contoh penggunaan curl untuk login dan membuat token yang dapat digunakan untuk mengakses aplikasi:

1. Login ke akun Anda yang memiliki akses ke resource Google Cloud.
2. Mulai server lokal yang dapat mengulang permintaan masuk.

       $ nc -k -l 4444
       

   CATATAN: Perintah ini menggunakan utilitas NetCat. Anda dapat menggunakan utilitas pilihan Anda.
3. Buka URI berikut dengan DESKTOP_CLIENT_ID adalah client ID aplikasi Desktop:

   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. Di output server lokal, cari parameter permintaan. Anda akan melihat sesuatu seperti berikut: GET /?code=$CODE&scope=email%20openid%20https://www.googleapis.com/auth/userinfo.email&hd=google.com&prompt=consent HTTP/1.1 salin KODE untuk mengganti AUTH_CODE di bawah bersama dengan client ID dan secret Aplikasi desktop:

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

   Kode ini menampilkan objek JSON dengan kolom id_token yang dapat Anda gunakan untuk mengakses aplikasi.

Mengakses aplikasi

Untuk mengakses aplikasi, gunakan id_token sebagai berikut:

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

Token Refresh

Anda dapat menggunakan token refresh yang dibuat selama alur login untuk mendapatkan token ID baru. Hal ini berguna saat masa berlaku token ID asli berakhir. Setiap token ID valid selama sekitar satu jam, selama waktu tersebut Anda dapat membuat beberapa permintaan ke aplikasi tertentu.

Berikut adalah contoh penggunaan curl untuk menggunakan token refresh guna mendapatkan token ID baru. Pada contoh berikut, REFRESH_TOKEN adalah token dari alur login. DESKTOP_CLIENT_ID, dan DESKTOP_CLIENT_SECRET sama dengan yang digunakan dalam alur 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

Kode ini menampilkan objek JSON dengan kolom id_token baru yang dapat Anda gunakan untuk mengakses aplikasi.

Catatan: Alur kerja token refresh tidak didukung untuk kebijakan tingkat akses. Anda harus membuat ulang token ID baru menggunakan alur autentikasi penuh.

Mengautentikasi akun layanan

Anda dapat menggunakan JWT akun layanan atau token OpenID Connect (OIDC) untuk mengautentikasi akun layanan dengan resource yang diamankan IAP. Tabel berikut menguraikan beberapa perbedaan antara berbagai token autentikasi dan fiturnya.

Fitur Authentication	JWT akun layanan	Token OpenID Connect
Dukungan akses kontekstual
Persyaratan Client ID OAuth 2.0
Cakupan token	URL resource yang diamankan IAP	Client ID OAuth 2.0

Catatan: Akun layanan tidak mendukung atribut kebijakan perangkat dengan akses kontekstual.

Melakukan autentikasi dengan JWT akun layanan

Mengautentikasi akun layanan menggunakan JWT terdiri dari langkah-langkah utama berikut:

1. Berikan peran Service Account Token Creator (roles/iam.serviceAccountTokenCreator) ke akun layanan panggilan.

   Peran ini memberi akun utama izin untuk membuat kredensial jangka pendek, seperti JWT.

2. Buat JWT untuk resource yang diamankan IAP.

3. Tanda tangani JWT menggunakan kunci pribadi akun layanan.

Membuat JWT

JWT yang dibuat harus memiliki payload yang mirip dengan contoh berikut:

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

• Untuk kolom iss dan sub, tentukan alamat email akun layanan. Ini ditemukan di kolom client_email file JSON akun layanan, atau diteruskan. Format standar: service-account@PROJECT_ID.iam.gserviceaccount.com

• Untuk kolom aud, tentukan URL resource yang diamankan IAP.

• Untuk kolom iat, tentukan waktu epoch Unix saat ini, dan untuk kolom exp, tentukan waktu dalam 3600 detik ke depan. Ini menentukan kapan JWT berakhir masa berlakunya.

Catatan: JWT akun layanan dicakup untuk audiens yang diberikan. Audiens harus berupa URL resource yang diamankan dengan IAP. Contohnya, https://example.com JWT dengan audiens https://example.com menolak akses ke subdomain jalur.

Menandatangani JWT

Anda dapat menggunakan salah satu metode berikut untuk menandatangani JWT:

• Gunakan IAM credentials API untuk menandatangani JWT tanpa memerlukan akses langsung ke kunci pribadi.
• Gunakan file kunci kredensial lokal untuk menandatangani JWT secara lokal.

Menandatangani JWT menggunakan IAM Service Account Credentials API

Gunakan IAM Service Account Credentials API untuk menandatangani JWT akun layanan. Metode ini mengambil kunci pribadi yang terkait dengan akun layanan Anda dan menggunakannya untuk menandatangani payload JWT. Hal ini memungkinkan penandatanganan JWT tanpa akses langsung ke kunci pribadi.

Untuk melakukan autentikasi ke IAP, siapkan Kredensial Default Aplikasi. Untuk informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

gcloud

1. Jalankan perintah berikut untuk menyiapkan permintaan dengan 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
   

2. Gunakan perintah Google Cloud CLI berikut untuk menandatangani payload di request.json:

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

   Setelah permintaan berhasil, output.jwt akan berisi JWT yang ditandatangani.

3. Gunakan JWT untuk mengakses resource yang diamankan IAP.

Python

import datetime
import json

import google.auth
from google.cloud import iam_credentials_v1
import jwt

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

  The resource url provided must be the same as the url of the IAP secured resource.

  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:
    A signed-jwt that can be used to access IAP protected applications.
    Access the application with the JWT in the Authorization Header.
    curl --verbose --header 'Authorization: Bearer SIGNED_JWT' URL
  """
  iat = datetime.datetime.now(tz=datetime.timezone.utc)
  exp = iat + 3600
  return json.dumps({
      'iss': service_account_email,
      'sub': service_account_email,
      'aud': resource_url,
      'iat': iat,
      'exp': exp,
  })

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

  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:
    A signed-jwt that can be used to access IAP protected apps.
  """
  source_credentials, _ = google.auth.default()
  iam_client = iam_credentials_v1.IAMCredentialsClient(credentials=source_credentials)
  return iam_client.sign_jwt(
      name=iam_client.service_account_path('-', target_sa),
      payload=generate_jwt_payload(target_sa, resource_url),
  ).signed_jwt

Setelah permintaan berhasil, skrip akan menampilkan JWT yang ditandatangani. Gunakan JWT untuk mengakses resource yang diamankan IAP.

curl

1. Jalankan perintah berikut untuk menyiapkan permintaan dengan payload JWT:

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

2. Tanda tangani JWT menggunakan IAM 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"

   Setelah permintaan berhasil, JWT yang ditandatangani akan ada dalam respons.

3. Gunakan JWT untuk mengakses resource yang diamankan IAP.

Catatan: Menggunakan IAM credentials API untuk menandatangani JWT menggunakan panggilan jaringan.

Menandatangani JWT dari file kunci kredensial lokal

JWT ditandatangani menggunakan kunci pribadi akun layanan.

Jika Anda memiliki file kunci akun layanan, JWT dapat ditandatangani secara lokal.

Skrip mengirim header JWT beserta payload. Untuk kolom kid di header, gunakan ID kunci pribadi akun layanan, yang ada di kolom private_key_id dari file JSON kredensial akun layanan. Kunci ini juga digunakan untuk menandatangani JWT.

Python

import time
import jwt
import json

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

  The resource url provided must be the same as the url of the IAP secured resource.

  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:
    A signed-jwt that can be used to access IAP protected applications.
    Access the application with the JWT in the Authorization Header.
    curl --verbose --header 'Authorization: Bearer SIGNED_JWT' URL
  """
  iat = datetime.datetime.now(tz=datetime.timezone.utc)
  exp = iat + 3600
  return json.dumps({
      'iss': service_account_email,
      'sub': service_account_email,
      'aud': resource_url,
      'iat': iat,
      'exp': exp,
  })

def sign_jwt_with_key_file(credential_key_file_path, resource_url):
  """Signs JWT payload using local service account credential key file.

  Args:
    credential_key_file_path (str): Path to the downloaded JSON credentials of the service
      account the JWT is being created for.
    resource_url (str): Scope of JWT token, This is the url of the IAP protected application.
  Returns:
    A service account JWT created with a downloaded private key.
  """
  with open(credential_key_file_path, 'r') as credential_key_file:
      key_data = json.load(credential_key_file)

  PRIVATE_KEY_ID_FROM_JSON = key_data["private_key_id"]
  PRIVATE_KEY_FROM_JSON = key_data["private_key"]
  SERVICE_ACCOUNT_EMAIL = key_data["client_email"]

  # Sign JWT with private key and store key id in the header
  additional_headers = {'kid': PRIVATE_KEY_ID_FROM_JSON}
  payload = generate_jwt_payload(service_account_email=SERVICE_ACCOUNT_EMAIL, resource_url=resource_url)

  signed_jwt = jwt.encode(
      payload,
      PRIVATE_KEY_FROM_JSON,
      headers=additional_headers,
      algorithm='RS256',
  )
  return signed_jwt

Hasilnya adalah JWT yang ditandatangani.

Mengakses aplikasi

Dalam semua kasus, untuk mengakses aplikasi, gunakan signed-jwt sebagai berikut:

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

Mengautentikasi dengan token OIDC

1. Buat atau gunakan client ID OAuth 2.0 yang ada. Untuk menggunakan client ID OAuth 2.0 yang ada, ikuti langkah-langkah di Cara membagikan Klien OAuth.
2. Izinkan client ID OAuth untuk akses terprogram untuk aplikasi.

Anda juga perlu menambahkan akun layanan ke daftar akses untuk project yang diamankan IAP. Contoh kode berikut menunjukkan cara mendapatkan token OIDC. Anda harus menyertakan token dalam header Authorization: Bearer untuk membuat permintaan autentikasi ke resource yang diamankan IAP.

Catatan: Pastikan token ID yang dihasilkan memiliki klaim 'email'. Ini adalah persyaratan untuk IAP.

Mendapatkan token OIDC untuk akun layanan default

Jika ingin mendapatkan token OIDC untuk akun layanan default untuk Compute Engine, App Engine, atau Cloud Run, Anda dapat menggunakan contoh kode berikut untuk membuat token guna mengakses resource yang diamankan IAP:

C#

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

Untuk melakukan autentikasi ke IAP, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

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

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

/**
 * 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.request({url});
  console.info(res.data);
}

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

PHP

Untuk melakukan autentikasi ke IAP, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

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

Untuk melakukan autentikasi ke IAP, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

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

Untuk melakukan autentikasi ke IAP, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

# 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

Mendapatkan token OIDC dari file kunci akun layanan lokal

Jika memiliki file kunci akun layanan, Anda dapat menyesuaikan contoh kode sebelumnya untuk memberikan file kunci akun layanan.

Bash

  #!/usr/bin/env bash
  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}"

    local iam_scope="https://www.googleapis.com/auth/iam"
    local oauth_token_uri="https://www.googleapis.com/oauth2/v4/token"

    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')"
    local issued_at="$(date +%s)"
    local expires_at="$((issued_at + 600))"
    local header="{'alg':'RS256','typ':'JWT','kid':'${private_key_id}'}"
    local header_base64="$(echo "${header}" | base64)"
    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)"
    local signature_base64="$(printf %s "${header_base64}.${payload_base64}" | openssl dgst -binary -sha256 -sign <(printf '%s\n' "${private_key}")  | base64)"
    local assertion="${header_base64}.${payload_base64}.${signature_base64}"
    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)"
    local bearer_id_token="$(echo "${token_payload}" | jq -r '.id_token')"
    echo "${bearer_id_token}"
  }

  main(){
    # TODO: Replace the following variables:
    SERVICE_ACCOUNT_KEY="service_account_key_file_path"
    IAP_CLIENT_ID="iap_client_id"
    URL="application_url"

    # Obtain the ID token.
    ID_TOKEN=$(get_token "${SERVICE_ACCOUNT_KEY}" "${IAP_CLIENT_ID}")
    # Access the application with the ID token.
    curl --header "Authorization: Bearer ${ID_TOKEN}" "${URL}"
  }

  main "$@"

Mendapatkan token OIDC dalam semua kasus lainnya

Dalam semua kasus lainnya, gunakan IAM credentials API untuk membuat token OIDC dengan meniru akun layanan target tepat sebelum mengakses resource yang diamankan IAP. Proses ini melibatkan langkah-langkah berikut:

1. Berikan akun layanan panggilan (akun layanan yang terkait dengan kode yang mendapatkan token ID) dengan peran Pembuat Token Identitas OpenID Connect Akun Layanan (roles/iam.serviceAccountOpenIdTokenCreator).

   Hal ini memberi akun layanan panggilan kemampuan untuk meniru identitas akun layanan target.

2. Gunakan kredensial yang disediakan oleh akun layanan panggilan untuk memanggil metode generateIdToken di akun layanan target.

   Tetapkan kolom audience ke client ID Anda.

Untuk petunjuk langkah demi langkah, lihat Membuat token ID.

Mengautentikasi dari Header Proxy-Authorization

Jika aplikasi Anda menggunakan header permintaan Authorization, Anda dapat menyertakan token ID dalam header Proxy-Authorization: Bearer. Jika token ID yang valid ditemukan di header Proxy-Authorization, IAP akan memberikan otorisasi permintaan dengan token tersebut. Setelah memberikan otorisasi pada permintaan, IAP akan meneruskan header Authorization ke aplikasi Anda tanpa memproses konten.

Jika tidak ada token ID yang valid yang ditemukan di header Proxy-Authorization, IAP akan terus memproses header Authorization dan menghapus header Proxy-Authorization sebelum meneruskan permintaan ke aplikasi Anda.

Langkah selanjutnya

• Pelajari Otorisasi: Token Pembawa lebih lanjut.
• Coba Sign-In untuk Android atau Sign-In untuk iOS.