Google menggunakan teknologi AI untuk menerjemahkan konten ke dalam bahasa pilihan Anda. Terjemahan AI mungkin mengandung kesalahan.

Mengamankan aplikasi Anda dengan header yang ditandatangani

Halaman ini menjelaskan cara mengamankan aplikasi Anda dengan header IAP yang ditandatangani. Saat dikonfigurasi, Identity-Aware Proxy (IAP) menggunakan Token Web JSON (JWT) untuk memastikan bahwa permintaan ke aplikasi Anda diizinkan. Tindakan ini melindungi aplikasi Anda dari risiko berikut:

IAP tidak sengaja dinonaktifkan
Firewall yang salah dikonfigurasi
Akses tidak sah dari dalam project

Untuk membantu mengamankan aplikasi Anda, Anda harus menggunakan header yang ditandatangani untuk semua jenis aplikasi.

Atau, jika Anda memiliki aplikasi lingkungan standar App Engine, Anda dapat menggunakan Users API.

Health check Compute Engine dan GKE tidak menyertakan header JWT dan IAP tidak memproses health check. Jika health check menampilkan error akses, pastikan Anda telah mengonfigurasi health check dengan benar di Google Cloud konsol dan bahwa validasi header JWT Anda mengizinkan jalur health check. Untuk mengetahui informasi selengkapnya, lihat Membuat pengecualian health check.

Sebelum memulai

Untuk mengamankan aplikasi Anda dengan header yang ditandatangani, Anda memerlukan hal berikut:

Aplikasi yang ingin Anda hubungkan dengan pengguna.
Library JWT pihak ketiga untuk bahasa Anda yang mendukung algoritma ES256.

Mengamankan aplikasi Anda dengan header IAP

Untuk mengamankan aplikasi Anda dengan JWT IAP, verifikasi header, payload, dan tanda tangan JWT. JWT berada di header permintaan HTTP x-goog-iap-jwt-assertion. Jika penyerang melewati IAP, penyerang dapat memalsukan header identitas yang tidak ditandatangani IAP, x-goog-authenticated-user-{email,id}. JWT IAP memberikan alternatif yang lebih aman.

Header yang ditandatangani memberikan keamanan sekunder jika seseorang melewati IAP. Saat IAP diaktifkan, IAP akan menghapus header x-goog-* yang disediakan oleh klien saat permintaan melalui infrastruktur penayangan IAP.

Memverifikasi header JWT

Pastikan header JWT sesuai dengan batasan berikut:

Klaim Header JWT
`alg`	Algoritma	`ES256`
`kid`	ID Kunci	Harus sesuai dengan salah satu kunci publik yang tercantum dalam file kunci IAP, yang tersedia dalam dua format berbeda: `https://www.gstatic.com/iap/verify/public_key` dan `https://www.gstatic.com/iap/verify/public_key-jwk`

Pastikan JWT ditandatangani oleh kunci pribadi yang sesuai dengan klaim kid token. Pertama, ambil kunci publik dari salah satu dari dua tempat:

https://www.gstatic.com/iap/verify/public_key. URL ini berisi kamus JSON yang memetakan klaim kid ke nilai kunci publik.
https://www.gstatic.com/iap/verify/public_key-jwk. URL ini berisi kunci publik IAP dalam JWK.

Setelah Anda memiliki kunci publik, gunakan library JWT untuk memverifikasi tanda tangan.

IAP secara berkala merotasi kunci publiknya. Untuk memastikan Anda selalu dapat memverifikasi JWT, lihat Mengotomatiskan caching kunci publik.

Memverifikasi payload JWT

Pastikan payload JWT sesuai dengan batasan berikut:

Klaim Payload JWT
`exp`	Waktu habis masa berlaku	Harus di masa depan. Waktu diukur dalam hitungan detik sejak epoch UNIX. Izinkan 30 detik untuk kemiringan. Masa aktif maksimum token adalah 10 menit + 2 kemiringan.*
`iat`	Waktu penerbitan	Harus di masa lalu. Waktu diukur dalam hitungan detik sejak epoch UNIX. Izinkan 30 detik untuk kemiringan.
`aud`	Audiens	Harus berupa string dengan nilai berikut: App Engine: `/projects/PROJECT_NUMBER/apps/PROJECT_ID` Compute Engine dan GKE: `/projects/PROJECT_NUMBER/global/backendServices/SERVICE_ID` Cloud Run: `/projects/PROJECT_NUMBER/locations/REGION/services/SERVICE_NAME`
`iss`	Penerbit	Harus berupa `https://cloud.google.com/iap`.
`hd`	Domain akun	Jika akun milik domain yang dihosting, klaim `hd` akan diberikan untuk membedakan domain yang terkait dengan akun tersebut.
`google`	Klaim Google	Jika satu atau beberapa tingkat akses berlaku untuk permintaan, namanya akan disimpan dalam objek JSON klaim `google`, di bawah kunci `access_levels`, sebagai array string. Saat Anda menentukan kebijakan perangkat dan Org memiliki akses ke data perangkat, `DeviceId` juga akan disimpan dalam objek JSON. Perhatikan bahwa permintaan yang ditujukan ke Org lain mungkin tidak memiliki izin untuk melihat data perangkat.

Anda bisa mendapatkan nilai untuk string aud yang disebutkan di atas dengan mengakses Google Cloud konsol, atau Anda dapat menggunakan alat command line gcloud.

Untuk mendapatkan nilai string aud `aud` dari konsol Google Cloud , buka setelan Identity-Aware Proxy untuk project Anda, klik More di samping resource Load Balancer, lalu pilih Signed Header JWT Audience. Dialog Signed Header JWT yang muncul menampilkan klaim aud untuk resource yang dipilih.

Jika Anda ingin menggunakan gcloud CLI alat command line gcloud untuk mendapatkan nilai string aud, Anda harus mengetahui project ID. Anda dapat menemukan project ID di kartu Google Cloud konsol Project info, lalu menjalankan perintah yang ditentukan untuk setiap nilai.

Nomor project

Untuk mendapatkan nomor project Anda menggunakan alat command line gcloud, jalankan perintah berikut:

gcloud projects describe PROJECT_ID

Perintah ini akan menampilkan output seperti berikut:

createTime: '2016-10-13T16:44:28.170Z'
lifecycleState: ACTIVE
name: project_name
parent:
  id: '433637338589'
  type: organization
projectId: PROJECT_ID
projectNumber: 'PROJECT_NUMBER'

ID Layanan

Untuk mendapatkan ID layanan Anda menggunakan alat command line gcloud, jalankan perintah berikut:

gcloud compute backend-services describe SERVICE_NAME --project=PROJECT_ID --global

Perintah ini akan menampilkan output seperti berikut:

affinityCookieTtlSec: 0
backends:
- balancingMode: UTILIZATION
  capacityScaler: 1.0
  group: https://www.googleapis.com/compute/v1/projects/project_name/regions/us-central1/instanceGroups/my-group
connectionDraining:
  drainingTimeoutSec: 0
creationTimestamp: '2017-04-03T14:01:35.687-07:00'
description: ''
enableCDN: false
fingerprint: zaOnO4k56Cw=
healthChecks:
- https://www.googleapis.com/compute/v1/projects/project_name/global/httpsHealthChecks/my-hc
id: 'SERVICE_ID'
kind: compute#backendService
loadBalancingScheme: EXTERNAL
name: my-service
port: 8443
portName: https
protocol: HTTPS
selfLink: https://www.googleapis.com/compute/v1/projects/project_name/global/backendServices/my-service
sessionAffinity: NONE
timeoutSec: 3610

Mengambil identitas pengguna

Jika semua verifikasi sebelumnya berhasil, ambil identitas pengguna. Payload token ID berisi informasi pengguna berikut:

Identitas Pengguna Payload Token ID
`sub`	Subjek	ID unik dan stabil untuk pengguna. Gunakan nilai ini, bukan `x-goog-authenticated-user-id` header.
`email`	Email pengguna	Alamat email pengguna. Gunakan nilai ini, bukan `x-goog-authenticated-user-email` header. Tidak seperti header tersebut dan klaim `sub`, nilai ini tidak memiliki awalan namespace.

Berikut adalah contoh kode untuk mengamankan aplikasi dengan header IAP yang ditandatangani:

C#


using Google.Apis.Auth;
using Google.Apis.Auth.OAuth2;
using System;
using System.Threading;
using System.Threading.Tasks;

public class IAPTokenVerification
{
    /// <summary>
    /// Verifies a signed jwt token and returns its payload.
    /// </summary>
    /// <param name="signedJwt">The token to verify.</param>
    /// <param name="expectedAudience">The audience that the token should be meant for.
    /// Validation will fail if that's not the case.</param>
    /// <param name="cancellationToken">The cancellation token to propagate cancellation requests.</param>
    /// <returns>A task that when completed will have as its result the payload of the verified token.</returns>
    /// <exception cref="InvalidJwtException">If verification failed. The message of the exception will contain
    /// information as to why the token failed.</exception>
    public async Task<JsonWebSignature.Payload> VerifyTokenAsync(
        string signedJwt, string expectedAudience, CancellationToken cancellationToken = default)
    {
        SignedTokenVerificationOptions options = new SignedTokenVerificationOptions
        {
            // Use clock tolerance to account for possible clock differences
            // between the issuer and the verifier.
            IssuedAtClockTolerance = TimeSpan.FromMinutes(1),
            ExpiryClockTolerance = TimeSpan.FromMinutes(1),
            TrustedAudiences = { expectedAudience },
            TrustedIssuers = { "https://cloud.google.com/iap" },
            CertificatesUrl = GoogleAuthConsts.IapKeySetUrl,
        };

        return await JsonWebSignature.VerifySignedTokenAsync(signedJwt, options, cancellationToken: cancellationToken);
    }
}

Go

import (
	"context"
	"fmt"
	"io"

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

// validateJWTFromAppEngine validates a JWT found in the
// "x-goog-iap-jwt-assertion" header.
func validateJWTFromAppEngine(w io.Writer, iapJWT, projectNumber, projectID string) error {
	// iapJWT := "YmFzZQ==.ZW5jb2RlZA==.and0" // req.Header.Get("X-Goog-IAP-JWT-Assertion")
	// projectNumber := "123456789"
	// projectID := "your-project-id"
	ctx := context.Background()
	aud := fmt.Sprintf("/projects/%s/apps/%s", projectNumber, projectID)

	payload, err := idtoken.Validate(ctx, iapJWT, aud)
	if err != nil {
		return fmt.Errorf("idtoken.Validate: %w", err)
	}

	// payload contains the JWT claims for further inspection or validation
	fmt.Fprintf(w, "payload: %v", payload)

	return nil
}

// validateJWTFromComputeEngine validates a JWT found in the
// "x-goog-iap-jwt-assertion" header.
func validateJWTFromComputeEngine(w io.Writer, iapJWT, projectNumber, backendServiceID string) error {
	// iapJWT := "YmFzZQ==.ZW5jb2RlZA==.and0" // req.Header.Get("X-Goog-IAP-JWT-Assertion")
	// projectNumber := "123456789"
	// backendServiceID := "backend-service-id"
	ctx := context.Background()
	aud := fmt.Sprintf("/projects/%s/global/backendServices/%s", projectNumber, backendServiceID)

	payload, err := idtoken.Validate(ctx, iapJWT, aud)
	if err != nil {
		return fmt.Errorf("idtoken.Validate: %w", err)
	}

	// payload contains the JWT claims for further inspection or validation
	fmt.Fprintf(w, "payload: %v", payload)

	return nil
}

Java


import com.google.api.client.http.HttpRequest;
import com.google.api.client.json.webtoken.JsonWebToken;
import com.google.auth.oauth2.TokenVerifier;

/** Verify IAP authorization JWT token in incoming request. */
public class VerifyIapRequestHeader {

  private static final String IAP_ISSUER_URL = "https://cloud.google.com/iap";

  // Verify jwt tokens addressed to IAP protected resources on App Engine.
  // The project *number* for your Google Cloud project via 'gcloud projects describe $PROJECT_ID'
  // The project *number* can also be retrieved from the Project Info card in Cloud Console.
  // projectId is The project *ID* for your Google Cloud Project.
  boolean verifyJwtForAppEngine(HttpRequest request, long projectNumber, String projectId)
      throws Exception {
    // Check for iap jwt header in incoming request
    String jwt = request.getHeaders().getFirstHeaderStringValue("x-goog-iap-jwt-assertion");
    if (jwt == null) {
      return false;
    }
    return verifyJwt(
        jwt,
        String.format("/projects/%s/apps/%s", Long.toUnsignedString(projectNumber), projectId));
  }

  boolean verifyJwtForComputeEngine(HttpRequest request, long projectNumber, long backendServiceId)
      throws Exception {
    // Check for iap jwt header in incoming request
    String jwtToken = request.getHeaders().getFirstHeaderStringValue("x-goog-iap-jwt-assertion");
    if (jwtToken == null) {
      return false;
    }
    return verifyJwt(
        jwtToken,
        String.format(
            "/projects/%s/global/backendServices/%s",
            Long.toUnsignedString(projectNumber), Long.toUnsignedString(backendServiceId)));
  }

  private boolean verifyJwt(String jwtToken, String expectedAudience) {
    TokenVerifier tokenVerifier =
        TokenVerifier.newBuilder().setAudience(expectedAudience).setIssuer(IAP_ISSUER_URL).build();
    try {
      JsonWebToken jsonWebToken = tokenVerifier.verify(jwtToken);

      // Verify that the token contain subject and email claims
      JsonWebToken.Payload payload = jsonWebToken.getPayload();
      return payload.getSubject() != null && payload.get("email") != null;
    } catch (TokenVerifier.VerificationException e) {
      System.out.println(e.getMessage());
      return false;
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const iapJwt = 'SOME_ID_TOKEN'; // JWT from the "x-goog-iap-jwt-assertion" header

let expectedAudience = null;
if (projectNumber && projectId) {
  // Expected Audience for App Engine.
  expectedAudience = `/projects/${projectNumber}/apps/${projectId}`;
} else if (projectNumber && backendServiceId) {
  // Expected Audience for Compute Engine
  expectedAudience = `/projects/${projectNumber}/global/backendServices/${backendServiceId}`;
}

const oAuth2Client = new OAuth2Client();

async function verify() {
  // Verify the id_token, and access the claims.
  const response = await oAuth2Client.getIapPublicKeys();
  const ticket = await oAuth2Client.verifySignedJwtWithCertsAsync(
    iapJwt,
    response.pubkeys,
    expectedAudience,
    ['https://cloud.google.com/iap'],
  );
  // Print out the info contained in the IAP ID token
  console.log(ticket);
}

verify().catch(console.error);

PHP

namespace Google\Cloud\Samples\Iap;

# Imports Google auth libraries for IAP validation
use Google\Auth\AccessToken;

/**
 * Validate a JWT passed to your App Engine app by Identity-Aware Proxy.
 *
 * @param string $iapJwt The contents of the X-Goog-IAP-JWT-Assertion header.
 * @param string $cloudProjectNumber The project *number* for your Google
 *     Cloud project. This is returned by 'gcloud projects describe $PROJECT_ID',
 *     or in the Project Info card in Cloud Console.
 * @param string $cloudProjectId Your Google Cloud Project ID.
 */
function validate_jwt_from_app_engine(
    string $iapJwt,
    string $cloudProjectNumber,
    string $cloudProjectId
): void {
    $expectedAudience = sprintf(
        '/projects/%s/apps/%s',
        $cloudProjectNumber,
        $cloudProjectId
    );
    validate_jwt($iapJwt, $expectedAudience);
}

/**
 * Validate a JWT passed to your Compute / Container Engine app by Identity-Aware Proxy.
 *
 * @param string $iapJwt The contents of the X-Goog-IAP-JWT-Assertion header.
 * @param string $cloudProjectNumber The project *number* for your Google
 *     Cloud project. This is returned by 'gcloud projects describe $PROJECT_ID',
 *     or in the Project Info card in Cloud Console.
 * @param string $backendServiceId The ID of the backend service used to access the
 *     application. See https://cloud.google.com/iap/docs/signed-headers-howto
 *     for details on how to get this value.
 */
function validate_jwt_from_compute_engine(
    string $iapJwt,
    string $cloudProjectNumber,
    string $backendServiceId
): void {
    $expectedAudience = sprintf(
        '/projects/%s/global/backendServices/%s',
        $cloudProjectNumber,
        $backendServiceId
    );
    validate_jwt($iapJwt, $expectedAudience);
}

/**
 * Validate a JWT passed to your app by Identity-Aware Proxy.
 *
 * @param string $iapJwt The contents of the X-Goog-IAP-JWT-Assertion header.
 * @param string $expectedAudience The expected audience of the JWT with the following formats:
 *     App Engine:     /projects/{PROJECT_NUMBER}/apps/{PROJECT_ID}
 *     Compute Engine: /projects/{PROJECT_NUMBER}/global/backendServices/{BACKEND_SERVICE_ID}
 */
function validate_jwt(string $iapJwt, string $expectedAudience): void
{
    // Validate the signature using the IAP cert URL.
    $token = new AccessToken();
    $jwt = $token->verify($iapJwt, [
        'certsLocation' => AccessToken::IAP_CERT_URL
    ]);

    if (!$jwt) {
        print('Failed to validate JWT: Invalid JWT');
        return;
    }

    // Validate token by checking issuer and audience fields.
    assert($jwt['iss'] == 'https://cloud.google.com/iap');
    assert($jwt['aud'] == $expectedAudience);

    print('Printing user identity information from ID token payload:');
    printf('sub: %s', $jwt['sub']);
    printf('email: %s', $jwt['email']);
}

Python

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


def validate_iap_jwt(iap_jwt, expected_audience):
    """Validate an IAP JWT.

    Args:
      iap_jwt: The contents of the X-Goog-IAP-JWT-Assertion header.
      expected_audience: The Signed Header JWT audience. See
          https://cloud.google.com/iap/docs/signed-headers-howto
          for details on how to get this value.

    Returns:
      (user_id, user_email, error_str).
    """

    try:
        decoded_jwt = id_token.verify_token(
            iap_jwt,
            requests.Request(),
            audience=expected_audience,
            certs_url="https://www.gstatic.com/iap/verify/public_key",
        )
        return (decoded_jwt["sub"], decoded_jwt["email"], "")
    except Exception as e:
        return (None, None, f"**ERROR: JWT validation error {e}**")

Ruby

# iap_jwt = "The contents of the X-Goog-Iap-Jwt-Assertion header"
# project_number = "The project *number* for your Google Cloud project"
# project_id = "Your Google Cloud project ID"
# backend_service_id = "Your Compute Engine backend service ID"
require "googleauth"

audience = nil
if project_number && project_id
  # Expected audience for App Engine
  audience = "/projects/#{project_number}/apps/#{project_id}"
elsif project_number && backend_service_id
  # Expected audience for Compute Engine
  audience = "/projects/#{project_number}/global/backendServices/#{backend_service_id}"
end

# The client ID as the target audience for IAP
payload = Google::Auth::IDTokens.verify_iap iap_jwt, aud: audience

puts payload

if audience.nil?
  puts "Audience not verified! Supply a project_number and project_id to verify"
end

Menguji kode validasi Anda

Jika Anda mengunjungi aplikasi menggunakan parameter kueri secure_token_test, IAP akan menyertakan JWT yang tidak valid. Gunakan parameter ini untuk memastikan logika validasi JWT Anda menangani semua kasus kegagalan dan untuk melihat perilaku aplikasi Anda saat menerima JWT yang tidak valid.

Membuat pengecualian health check

Seperti yang disebutkan sebelumnya, health check Compute Engine dan GKE tidak menggunakan header JWT dan IAP tidak menangani health check. Anda harus mengonfigurasi health check dan aplikasi untuk mengizinkan akses health check.

Mengonfigurasi health check

Jika Anda belum menetapkan jalur untuk health check, gunakan Google Cloud konsol untuk menetapkan jalur yang tidak sensitif untuk health check. Pastikan jalur ini tidak dibagikan oleh resource lain.

Buka halaman Health checks Google Cloud konsol.
Buka halaman Health checks
Klik health check yang Anda gunakan untuk aplikasi, lalu klik Edit.
Di bagian Request path , tambahkan nama jalur yang tidak sensitif. Tindakan ini menentukan jalur URL yang Google Cloud digunakan saat mengirim permintaan health check. Jika dihilangkan, permintaan health check akan dikirim ke /.
Klik Save.

Mengonfigurasi validasi JWT

Dalam kode yang memanggil rutinitas validasi JWT, tambahkan kondisi untuk menayangkan status HTTP 200 untuk jalur permintaan health check Anda. Contoh:

if HttpRequest.path_info = '/HEALTH_CHECK_REQUEST_PATH'
  return HttpResponse(status=200)
else
  VALIDATION_FUNCTION

Mengotomatiskan caching kunci publik

IAP secara berkala merotasi kunci publiknya. Untuk memastikan Anda selalu dapat memverifikasi JWT IAP, sebaiknya Anda melakukan cache kunci untuk menghindari pengambilan kunci dari URL publik untuk setiap permintaan dan mengotomatiskan proses pembaruan kunci yang di-cache. Pendekatan ini sangat berguna untuk aplikasi yang berjalan di lingkungan dengan batasan jaringan, seperti perimeter Kontrol Layanan VPC.

Perimeter Kontrol Layanan VPC dapat mencegah akses langsung ke URL publik untuk kunci. Dengan melakukan cache kunci di bucket Cloud Storage, aplikasi Anda dapat mengambilnya dari lokasi dalam perimeter VPC-SC.

Konfigurasi Terraform berikut men-deploy fungsi ke Cloud Run yang mengambil kunci publik IAP terbaru dari https://www.gstatic.com/iap/verify/public_key-jwk dan menyimpannya di bucket Cloud Storage. Tugas Cloud Scheduler memicu fungsi ini setiap 12 jam untuk memastikan kunci tetap terbaru.

Penyiapan ini mencakup hal berikut:

Necessary Google Cloud APIs diaktifkan untuk menggunakan Cloud Run serta menyimpan dan melakukan cache kunci
Bucket Cloud Storage untuk menyimpan kunci publik IAP yang diambil
Bucket Cloud Storage untuk menampung kode sumber fungsi Cloud Run
Akun layanan untuk fungsi Cloud Run dan Cloud Scheduler dengan izin IAM yang sesuai
Fungsi Python untuk mengambil dan menyimpan kunci
Tugas Cloud Scheduler untuk memicu fungsi setiap 12 jam

Struktur direktori

├── function_source/
│   ├── main.py
│   └── requirements.txt
├── main.tf
├── outputs.tf
├── variables.tf
└── terraform.tfvars

`function_source/main.py`

import functions_framework
import requests
from google.cloud import storage
import os

# Environment variables to be set in the function configuration
BUCKET_NAME = os.environ.get("BUCKET_NAME")
OBJECT_NAME = os.environ.get("OBJECT_NAME", "iap_public_keys.jwk")
IAP_KEYS_URL = "https://www.gstatic.com/iap/verify/public_key-jwk"

@functions_framework.http
def update_iap_keys(request):
    """Fetches IAP public keys from the public URL and stores them in a Cloud Storage bucket."""
    if not BUCKET_NAME:
        print("Error: BUCKET_NAME environment variable not set.")
        return "BUCKET_NAME environment variable not set.", 500

    try:
        # Fetch the keys
        response = requests.get(IAP_KEYS_URL)
        response.raise_for_status()  # Raise an exception for bad status codes
        keys_content = response.text
        print(f"Successfully fetched keys from {IAP_KEYS_URL}")

        # Store in Cloud Storage
        storage_client = storage.Client()
        bucket = storage_client.bucket(BUCKET_NAME)
        blob = bucket.blob(OBJECT_NAME)

        blob.upload_from_string(keys_content, content_type='application/json')

        print(f"Successfully wrote IAP keys to gs://{BUCKET_NAME}/{OBJECT_NAME}")
        return f"Successfully updated {OBJECT_NAME} in bucket {BUCKET_NAME}", 200

    except requests.exceptions.RequestException as e:
        print(f"Error fetching keys from {IAP_KEYS_URL}: {e}")
        return f"Error fetching keys: {e}", 500
    except Exception as e:
        print(f"Error interacting with Cloud Storage: {e}")
        return f"Error interacting with Cloud Storage: {e}", 500

Ganti kode berikut:

BUCKET_NAME: nama bucket Cloud Storage Anda
OBJECT_NAME: nama objek untuk menyimpan kunci Anda

`function_source/requirements.txt`

functions-framework==3.*
requests
google-cloud-storage

`variables.tf`

variable "project_id" {
  description = "The Google Cloud project ID."
  type        = string
  default     = PROJECT_ID
}

variable "region" {
  description = "The Google Cloud region."
  type        = string
  default     = "REGION"
}

variable "iap_keys_bucket_name" {
  description = "The name of the Cloud Storage bucket to store IAP keys."
  type        = string
  default     = BUCKET_NAME"
}

variable "function_source_bucket_name" {
  description = "The name of the Cloud Storage bucket to store the function source code."
  type        = string
  default     = "BUCKET_NAME_FUNCTION"
}

Ganti kode berikut:

PROJECT_ID: ID proyek Google Cloud Anda
REGION: region untuk men-deploy resource—misalnya, us-central1
BUCKET_NAME: nama untuk bucket Cloud Storage yang menyimpan kunci IAP
BUCKET_NAME_FUNCTION: nama untuk bucket Cloud Storage yang menyimpan kode sumber fungsi Cloud Run

`main.tf`

terraform {
  required_providers {
    google = {
      source  = "hashicorp/google"
      version = ">= 4.50.0"
    }
    google-beta = {
      source  = "hashicorp/google-beta"
      version = ">= 4.50.0"
    }
  }
}

provider "google" {
  project = var.project_id
  region  = var.region
}

provider "google-beta" {
  project = var.project_id
  region  = var.region
}

# Enable necessary APIs
resource "google_project_service" "services" {
  for_each = toset([
    "storage.googleapis.com",
    "cloudfunctions.googleapis.com",
    "run.googleapis.com", # Cloud Functions v2 uses Cloud Run
    "cloudscheduler.googleapis.com",
    "iamcredentials.googleapis.com",
    "cloudbuild.googleapis.com" # Needed for Cloud Functions deployment
  ])
  service            = each.key
  disable_on_destroy = false
}

# Cloud Storage Bucket to store the IAP public keys
resource "google_storage_bucket" "iap_keys_bucket" {
  name                        = var.iap_keys_bucket_name
  location                    = var.region
  uniform_bucket_level_access = true
  versioning {
    enabled = true
  }
  lifecycle {
    prevent_destroy = false # Set to true in production to prevent accidental deletion
  }
}

# Cloud Storage Bucket to store the Cloud Function source code
resource "google_storage_bucket" "function_source_bucket" {
  name                        = var.function_source_bucket_name
  location                    = var.region
  uniform_bucket_level_access = true
}

# Archive the function source code
data "archive_file" "function_source_zip" {
  type        = "zip"
  source_dir  = "${path.module}/function_source"
  output_path = "${path.module}/function_source.zip"
}

# Upload the zipped source code to the source bucket
resource "google_storage_bucket_object" "function_source_object" {
  name   = "function_source.zip"
  bucket = google_storage_bucket.function_source_bucket.name
  source = data.archive_file.function_source_zip.output_path
}

# Service Account for the Cloud Function
resource "google_service_account" "iap_key_updater_sa" {
  account_id   = "iap-key-updater"
  display_name = "IAP Key Updater Function SA"
}

# Grant the function's SA permission to write to the IAP keys bucket
resource "google_storage_bucket_iam_member" "keys_bucket_writer" {
  bucket = google_storage_bucket.iap_keys_bucket.name
  role   = "roles/storage.objectAdmin"
  member = "serviceAccount:${google_service_account.iap_key_updater_sa.email}"
}

# Cloud Function (v2)
resource "google_cloudfunctions2_function" "update_iap_keys_func" {
  provider = google-beta # CFv2 often has newer features in google-beta
  name     = "update-iap-keys-function"
  location = var.region

  build_config {
    runtime     = "python312"
    entry_point = "update_iap_keys"
    source {
      storage_source {
        bucket = google_storage_bucket.function_source_bucket.name
        object = google_storage_bucket_object.function_source_object.name
      }
    }
  }

  service_config {
    max_instance_count = 1
    available_memory   = "256M"
    timeout_seconds    = 60
    ingress_settings   = "ALLOW_ALL"
    service_account_email = google_service_account.iap_key_updater_sa.email
    environment_variables = {
      BUCKET_NAME = google_storage_bucket.iap_keys_bucket.name
      OBJECT_NAME = "iap_public_keys.jwk"
    }
  }

  depends_on = [
    google_project_service.services,
    google_storage_bucket_iam_member.keys_bucket_writer
  ]
}

# Service Account for the Cloud Scheduler job
resource "google_service_account" "iap_key_scheduler_sa" {
  account_id   = "iap-key-scheduler"
  display_name = "IAP Key Update Scheduler SA"
}

# Grant the Scheduler SA permission to invoke the Cloud Function
resource "google_cloudfunctions2_function_iam_member" "invoker" {
  provider       = google-beta
  project        = google_cloudfunctions2_function.update_iap_keys_func.project
  location       = google_cloudfunctions2_function.update_iap_keys_func.location
  cloud_function = google_cloudfunctions2_function.update_iap_keys_func.name
  role           = "roles/cloudfunctions.invoker"
  member         = "serviceAccount:${google_service_account.iap_key_scheduler_sa.email}"
}

# Cloud Scheduler Job
resource "google_cloud_scheduler_job" "iap_key_update_schedule" {
  name        = "iap-key-update-schedule"
  description = "Fetches IAP public keys and stores them in Cloud Storage every 12 hours"
  schedule    = "0 */12 * * *" # Every 12 hours
  time_zone   = "Etc/UTC"
  region      = var.region

  http_target {
    uri = google_cloudfunctions2_function.update_iap_keys_func.service_config[0].uri
    http_method = "POST"

    oidc_token {
      service_account_email = google_service_account.iap_key_scheduler_sa.email
    }
  }

  depends_on = [
    google_cloudfunctions2_function_iam_member.invoker,
    google_project_service.services
  ]
}

`outputs.tf`

output "iap_keys_bucket_url" {
  description = "The Cloud Storage bucket URL where IAP public keys are stored."
  value       = "gs://${google_storage_bucket.iap_keys_bucket.name}"
}

output "cloud_function_url" {
  description = "The URL of the Cloud Function endpoint that triggers key updates."
  value       = google_cloudfunctions2_function.update_iap_keys_func.service_config[0].uri
}

`terraform.tfvars`

Buat file terraform.tfvars untuk menentukan project ID Anda dan menyesuaikan nama bucket jika diperlukan:

project_id = "your-gcp-project-id"
# Optional: Customize bucket names
# iap_keys_bucket_name = "custom-iap-keys-bucket"
# function_source_bucket_name = "custom-func-src-bucket"

Deploy dengan Terraform

Simpan file dalam struktur direktori yang dijelaskan sebelumnya.
Buka direktori di terminal Anda dan lakukan inisialisasi Terraform:
```
terraform init
```
Rencanakan perubahan:
```
terraform plan
```
Terapkan perubahan:
```
terraform apply
```

Tindakan ini akan men-deploy infrastruktur. Tugas Cloud Scheduler memicu fungsi setiap 12 jam, mengambil kunci IAP, dan menyimpannya di gs://BUCKET_NAME/iap_public_keys.jwk secara default. Aplikasi Anda kini dapat mengambil kunci dari bucket ini.

Membersihkan resource

Untuk menghapus resource yang dibuat oleh Terraform, jalankan perintah berikut:

gsutil rm -a gs://BUCKET_NAME/**

terraform destroy -auto-approve

Ganti BUCKET_NAME dengan bucket Cloud Storage untuk kunci Anda.

Catatan: Perintah gsutil diperlukan karena Terraform tidak menghancurkan bucket Cloud Storage yang berisi objek saat pembuatan versi diaktifkan.

JWT untuk identitas eksternal

Jika Anda menggunakan IAP dengan identitas eksternal, IAP akan tetap mengeluarkan JWT yang ditandatangani pada setiap permintaan yang diautentikasi, seperti halnya dengan identitas Google. Namun, ada beberapa perbedaan.

Informasi penyedia

Saat menggunakan identitas eksternal, payload JWT akan berisi klaim bernama gcip. Klaim ini berisi informasi pengguna, seperti email, URL foto, dan atribut khusus penyedia tambahan.

Berikut adalah contoh JWT untuk pengguna yang login dengan Facebook:

"gcip": '{
  "auth_time": 1553219869,
  "email": "facebook_user@gmail.com",
  "email_verified": false,
  "firebase": {
    "identities": {
      "email": [
        "facebook_user@gmail.com"
      ],
      "facebook.com": [
        "1234567890"
      ]
    },
    "sign_in_provider": "facebook.com",
  },
  "name": "Facebook User",
  "picture: "https://graph.facebook.com/1234567890/picture",
  "sub": "gZG0yELPypZElTmAT9I55prjHg63"
}',

Kolom `email` dan `sub`

Jika pengguna diautentikasi oleh Identity Platform, kolom email dan sub JWT akan diberi awalan dengan penerbit token Identity Platform dan ID tenant yang digunakan (jika ada). Contoh:

"email": "securetoken.google.com/PROJECT-ID/TENANT-ID:demo_user@gmail.com",
"sub": "securetoken.google.com/PROJECT-ID/TENANT-ID:gZG0yELPypZElTmAT9I55prjHg63"

Mengontrol akses dengan `sign_in_attributes`

IAM tidak mendukung identitas eksternal, tetapi Anda dapat menggunakan klaim yang disematkan di kolom sign_in_attributes untuk mengontrol akses. Misalnya, pertimbangkan pengguna yang login menggunakan penyedia SAML:

{
  "aud": "/projects/project_number/apps/my_project_id",
  "gcip": '{
    "auth_time": 1553219869,
    "email": "demo_user@gmail.com",
    "email_verified": true,
    "firebase": {
      "identities": {
        "email": [
          "demo_user@gmail.com"
        ],
        "saml.myProvider": [
          "demo_user@gmail.com"
        ]
      },
      "sign_in_attributes": {
        "firstname": "John",
        "group": "test group",
        "role": "admin",
        "lastname": "Doe"
      },
      "sign_in_provider": "saml.myProvider",
      "tenant": "my_tenant_id"
    },
    "sub": "gZG0yELPypZElTmAT9I55prjHg63"
  }',
  "email": "securetoken.google.com/my_project_id/my_tenant_id:demo_user@gmail.com",
  "exp": 1553220470,
  "iat": 1553219870,
  "iss": "https://cloud.google.com/iap",
  "sub": "securetoken.google.com/my_project_id/my_tenant_id:gZG0yELPypZElTmAT9I55prjHg63"
}

Anda dapat menambahkan logika ke aplikasi Anda yang mirip dengan kode di bawah untuk membatasi akses ke pengguna dengan peran yang valid:

const gcipClaims = JSON.parse(decodedIapJwtClaims.gcip);
if (gcipClaims &&
    gcipClaims.firebase &&
    gcipClaims.firebase.sign_in_attributes &&
    gcipClaims.firebase.sign_in_attribute.role === 'admin') {
  // Allow access to admin restricted resource.
} else {
  // Block access.
}

Anda dapat mengakses atribut pengguna tambahan dari penyedia SAML dan OIDC Identity Platform menggunakan klaim bertingkat gcipClaims.gcip.firebase.sign_in_attributes.

Batasan ukuran klaim IdP

Setelah pengguna login dengan Identity Platform, atribut pengguna tambahan akan dipropagasi ke payload token ID Identity Platform tanpa status, yang akan diteruskan dengan aman ke IAP. IAP kemudian akan mengeluarkan cookie buram tanpa statusnya sendiri, yang juga berisi klaim yang sama. IAP akan membuat header JWT yang ditandatangani berdasarkan konten cookie.

Akibatnya, jika sesi dimulai dengan banyak klaim, sesi tersebut mungkin melebihi ukuran cookie maksimum yang diizinkan, yang biasanya sekitar 4 KB di sebagian besar browser. Hal ini akan menyebabkan operasi login gagal.

Pastikan hanya klaim yang diperlukan yang dipropagasi dalam atribut SAML atau OIDC IdP. Opsi lainnya adalah menggunakan fungsi pemblokiran untuk memfilter klaim yang tidak diperlukan untuk pemeriksaan otorisasi.

const gcipCloudFunctions = require('gcip-cloud-functions');

const authFunctions = new gcipCloudFunctions.Auth().functions();

// This function runs before any sign-in operation.
exports.beforeSignIn = authFunctions.beforeSignInHandler((user, context) => {
  if (context.credential &&
      context.credential.providerId === 'saml.my-provider') {
    // Get the original claims.
    const claims = context.credential.claims;
    // Define this function to filter out the unnecessary claims.
    claims.groups = keepNeededClaims(claims.groups);
    // Return only the needed claims. The claims will be propagated to the token
    // payload.
    return {
      sessionClaims: claims,
    };
  }
});

Mengamankan aplikasi Anda dengan header yang ditandatangani Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

Sebelum memulai

Mengamankan aplikasi Anda dengan header IAP

Memverifikasi header JWT

Memverifikasi payload JWT

Mengambil identitas pengguna

C#

Go

Java

Node.js

PHP

Python

Ruby

Menguji kode validasi Anda

Membuat pengecualian health check

Mengonfigurasi health check

Mengonfigurasi validasi JWT

Mengotomatiskan caching kunci publik

Struktur direktori

function_source/main.py

function_source/requirements.txt

variables.tf

main.tf

outputs.tf

terraform.tfvars

Deploy dengan Terraform

Membersihkan resource

JWT untuk identitas eksternal

Informasi penyedia

Kolom email dan sub

Mengontrol akses dengan sign_in_attributes

Batasan ukuran klaim IdP

Mengamankan aplikasi Anda dengan header yang ditandatangani

`function_source/main.py`

`function_source/requirements.txt`

`variables.tf`

`main.tf`

`outputs.tf`

`terraform.tfvars`

Kolom `email` dan `sub`

Mengontrol akses dengan `sign_in_attributes`