프로그래매틱 인증

이 페이지에서는 사용자 계정 또는 서비스 계정에서 IAP(Identity-Aware Proxy) 보안 리소스를 인증하는 방법에 대해 설명합니다.

  • 사용자 계정은 개별 사용자에 속합니다. 애플리케이션에서 사용자를 대신하여 IAP 보안 리소스에 액세스해야 하는 경우 사용자 계정을 인증합니다. 사용자 계정 사용자 인증 정보를 읽어보세요.
  • 서비스 계정은 개별 사용자 대신 애플리케이션에 속합니다. 애플리케이션이 IAP 보안 리소스에 액세스하도록 허용하려는 경우 서비스 계정을 인증합니다. 서비스 계정 이해 방법을 알아보세요.

시작하기 전에

시작하기 전에 다음이 필요합니다.

  • 개발자 계정, 서비스 계정 또는 모바일 앱 사용자 인증 정보를 사용하여 프로그래매틱 방식으로 연결하려는 IAP 보안 애플리케이션입니다.

사용자 계정 인증

데스크톱 또는 모바일 앱에서 사용자가 앱에 액세스하여 프로그램이 IAP 보안 리소스와 상호작용하도록 할 수 있습니다.

모바일 앱에서 인증

  1. IAP 보안 리소스와 동일한 프로젝트에서 모바일 앱에 대한 OAuth 2.0 클라이언트 ID를 만듭니다.
    1. 사용자 인증 정보 페이지로 이동합니다.
      사용자 인증 정보 페이지로 이동
    2. IAP 보안 리소스가 포함된 프로젝트를 선택합니다.
    3. 사용자 인증 정보 만들기를 클릭하고 OAuth 클라이언트 ID를 선택합니다.
    4. 사용자 인증 정보를 만들려는 애플리케이션 유형을 선택합니다.
    5. 필요에 따라 이름 및 제한사항을 추가한 후 만들기를 클릭합니다.
  2. 표시되는 OAuth 클라이언트 창에서 연결하려는 IAP 보안 리소스의 클라이언트 ID를 확인합니다.
  3. Cloud IAP 보안 클라이언트 ID에 대한 ID 토큰을 가져옵니다.
  4. IAP 보안 리소스에 인증된 요청을 하려면 Authorization: Bearer 헤더에 ID 토큰을 포함합니다.

데스크톱 앱에서 인증

이 섹션에서는 데스크톱 명령줄에서 사용자 계정을 인증하는 방법을 설명합니다.

클라이언트 ID 설정

개발자가 명령줄에서 애플리케이션에 액세스하도록 허용하려면 먼저 데스크톱 앱 유형의 OAuth 클라이언트 ID 사용자 인증 정보를 만들어야 합니다.

  1. 사용자 인증 정보 페이지로 이동합니다.
    사용자 인증 정보 페이지로 이동
  2. IAP 보안 리소스가 포함된 프로젝트를 선택합니다.
  3. 사용자 인증 정보 만들기를 클릭하고 OAuth 클라이언트 ID를 선택합니다.
  4. 애플리케이션 유형에서 데스크톱 앱을 선택하고 이름을 추가한 다음 만들기를 클릭합니다.
  5. 표시된 OAuth 클라이언트 창에서 클라이언트 ID 및 클라이언트 보안 비밀을 기록해둡니다. 사용자 인증 정보를 관리하거나 개발자들과 공유하기 위해 스크립트에서 이를 사용해야 합니다.
  6. 사용자 인증 정보 창에서 새로운 데스크톱 앱 사용자 인증 정보가 애플리케이션에 액세스하기 위해 사용되는 기본 클라이언트 ID와 함께 표시됩니다.

애플리케이션에 로그인

IAP 보안 앱에 액세스하려는 각 개발자는 먼저 로그인해야 합니다. Cloud SDK를 사용하는 것과 같이 프로세스를 스크립트로 패키지화할 수 있습니다. 다음은 curl을 사용하여 로그인하고 애플리케이션에 액세스하기 위해 사용할 수 있는 토큰을 만드는 예시입니다.

  1. Google Cloud 리소스에 액세스할 수 있는 계정에 로그인합니다.
  2. 다음 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=urn:ietf:wg:oauth:2.0:oob

  3. 표시된 창에서 위에서 만든 데스크톱 앱 클라이언트 ID 및 보안 비밀과 함께, 아래의 AUTH_CODE를 대체할 승인 코드를 기록해둡니다. 

    curl --verbose \
      --data client_id=DESKTOP_CLIENT_ID \
      --data client_secret=DESKTOP_CLIENT_SECRET \
      --data code=AUTH_CODE \
      --data redirect_uri=urn:ietf:wg:oauth:2.0:oob \
      --data grant_type=authorization_code \
      https://oauth2.googleapis.com/token

    이 코드는 애플리케이션에 액세스하기 위해 로그인 토큰으로 저장할 수 있는 refresh_token 필드가 있는 JSON 객체를 반환합니다.

애플리케이션 액세스

애플리케이션에 액세스하기 위해 로그인 과정 중에 생성한 refresh_token을 ID 토큰으로 교환합니다. ID 토큰은 약 1시간 동안 유효하며 이 기간 동안 특정 앱에 여러 요청을 할 수 있습니다. 다음은 curl을 사용하여 토큰을 사용하고 애플리케이션에 액세스하는 예시입니다.

  1. 아래 코드를 사용합니다. 여기서 REFRESH_TOKEN은 로그인 과정의 토큰이고, IAP_CLIENT_ID는 애플리케이션에 액세스하기 위해 사용되는 기본 클라이언트 ID이고, DESKTOP_CLIENT_ID 및 DESKTOP_CLIENT_SECRET은 위에서 클라이언트 ID를 설정할 때 만든 클라이언트 ID와 보안 비밀입니다. 

    curl --verbose \
      --data client_id=DESKTOP_CLIENT_ID \
      --data client_secret=DESKTOP_CLIENT_SECRET \
      --data refresh_token=REFRESH_TOKEN \
      --data grant_type=refresh_token \
      --data audience=IAP_CLIENT_ID \
      https://oauth2.googleapis.com/token

    이 코드는 앱에 액세스하는 데 사용할 수 있는 id_token 필드가 있는 JSON 객체를 반환합니다.

  2. 앱에 액세스하려면 다음과 같이 id_token을 사용합니다. 

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

서비스 계정에서 인증

OIDC(OpenID Connect) 토큰을 사용하여 IAP 보안 리소스에 대한 서비스 계정을 인증합니다. 클라이언트 ID를 찾으려면 다음 단계를 따르세요.

  1. IAP 페이지로 이동합니다.

  2. 액세스하려는 리소스를 찾은 후 더보기 > OAuth 클라이언트 수정을 클릭합니다.
    더보기 메뉴에서 OAuth 클라이언트 편집

  3. 표시된 사용자 인증 정보 페이지에서 클라이언트 ID를 기록해둡니다.

또한 IAP 보안 프로젝트의 액세스 목록에 서비스 계정을 추가해야 합니다. 다음 코드 샘플은 OIDC 토큰을 얻는 방법을 보여줍니다. 어떤 방법을 선택하든 Authorization: Bearer 헤더에 토큰을 포함하여 IAP 보안 리소스에 대해 인증 요청을 수행해야 합니다.

기본 서비스 계정의 OIDC 토큰 가져오기

Compute Engine, App Engine 또는 Cloud Run의 기본 서비스 계정용 OIDC 토큰을 가져오려는 경우 다음 코드 샘플을 사용하여 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="credentialsFilePath">Path to the credentials .json file
    /// downloaded from 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 credentialsFilePath, 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, credentialsFilePath, cancellationToken).ConfigureAwait(false);

        // 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).ConfigureAwait(false);

        // 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).ConfigureAwait(false);
    }

    /// <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="credentialsFilePath">Path to the credentials .json file
    /// downloaded from 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, string credentialsFilePath, CancellationToken cancellationToken)
    {
        // Read credentials from the credentials .json file.
        GoogleCredential credential = await GoogleCredential
            .FromFileAsync(credentialsFilePath, cancellationToken).ConfigureAwait(false);

        // Request an OIDC token for the Cloud IAP-secured client ID.
       return await credential
            .GetOidcTokenAsync(OidcTokenOptions.FromTargetAudience(iapClientId), cancellationToken).ConfigureAwait(false);
    }
}

Go

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: %v", err)
	}

	response, err := client.Do(request)
	if err != nil {
		return fmt.Errorf("client.Do: %v", err)
	}
	defer response.Body.Close()
	if _, err := io.Copy(w, response.Body); err != nil {
		return fmt.Errorf("io.Copy: %v", err)
	}

	return nil
}

자바


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 signed JWT 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 signed jwt token.
   * @throws IOException exception creating signed JWT
   */
  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

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.
 *
 * @return The response body.
 */
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
    return $client->get($url);
}

Python

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

# 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 토큰 가져오기

그 외 모든 경우에는 IAM Credentials API를 사용하여 다른 서비스 계정의 액세스 토큰을 기반으로 IAP 보안 리소스에 액세스하기 직전에 OIDC 토큰을 생성합니다.

  1. service account token creator 역할이 있는 액세스 토큰의 계정을 대상 계정에 추가합니다. 이러면 대상 서비스 계정의 OIDC 토큰을 만드는 데 필요한 IAM 권한이 대상 계정에 부여됩니다.
  2. 액세스 토큰이 있는 대상 서비스 계정에서 generateIdToken을 호출합니다. audience 필드를 클라이언트 ID로 설정하는 경우 특히 주의하세요.

다음 단계