Programmatische Authentifizierung

Auf dieser Seite wird gezeigt, wie die Authentifizierung für eine mit Identity-Aware Proxy (IAP) gesicherte Ressource über ein Nutzerkonto oder ein Dienstkonto erfolgt.

  • Ein Nutzerkonto ist einem einzelnen Nutzer zugeordnet. Ein Nutzerkonto muss authentifiziert werden, wenn Ihre Anwendung im Namen eines Nutzers auf Ressourcen zugreifen soll, die mit IAP gesichert sind. Weitere Informationen dazu finden Sie unter Anmeldedaten von Nutzerkonten.
  • Ein Dienstkonto ist keinem einzelnen Nutzer, sondern einer Anwendung zugeordnet. Ein Dienstkonto muss authentifiziert werden, wenn Sie einer Anwendung Zugriff auf Ihre mit IAP gesicherten Ressourcen gewähren möchten. Weitere Informationen dazu finden Sie unter Informationen zu Dienstkonten.

Vorbereitung

Für den Start ist Folgendes erforderlich:

  • Eine mit IAP gesicherte Anwendung, zu der Sie mithilfe der Anmeldedaten eines Entwicklerkontos, eines Dienstkontos oder einer mobilen App programmatisch eine Verbindung herstellen möchten

Nutzerkonto authentifizieren

Damit ein Programm mit einer Ressource interagieren kann, die mit IAP gesichert ist, können Sie den Nutzerzugriff von einer Desktopanwendung oder einer mobilen App auf Ihre Anwendung aktivieren.

Von einer mobilen App aus authentifizieren

  1. Erstellen Sie für Ihre mobile App eine OAuth 2.0-Client-ID im selben Projekt wie die mit IAP gesicherte Ressource:
    1. Rufen Sie die Seite Anmeldedaten auf.
      Zur Seite "Anmeldedaten"
    2. Wählen Sie das Projekt mit der Ressource aus, die mit IAP gesichert ist.
    3. Klicken Sie auf Anmeldedaten erstellen und wählen Sie OAuth-Client-ID aus.
    4. Wählen Sie den Anwendungstyp aus, für den Sie die Anmeldedaten erstellen möchten.
    5. Fügen Sie gegebenenfalls Werte für Name und Einschränkungen hinzu und klicken Sie dann auf Erstellen.
  2. Notieren Sie sich die im eingeblendeten Fenster OAuth-Client angezeigte Client-ID für die mit IAP gesicherte Ressource, zu der Sie eine Verbindung herstellen möchten.
  3. Rufen Sie ein ID-Token für die mit IAP gesicherte Client-ID ab:
  4. Fügen Sie das ID-Token in einen Authorization: Bearer-Header ein, um die authentifizierte Anfrage an die mit IAP gesicherte Ressource zu senden.

Von einer Desktopanwendung aus authentifizieren

In diesem Abschnitt wird beschrieben, wie Sie ein Nutzerkonto von einer Desktop-Befehlszeile aus authentifizieren können.

Die Client-ID einrichten

Damit Entwickler über die Befehlszeile auf Ihre Anwendung zugreifen können, müssen Sie zuerst OAuth-Client-ID-Anmeldedaten vom Typ Desktop-Anwendung erstellen:

  1. Rufen Sie die Seite Anmeldedaten auf.
    Zur Seite "Anmeldedaten"
  2. Wählen Sie das Projekt mit der Ressource aus, die mit IAP gesichert ist.
  3. Klicken Sie auf Anmeldedaten erstellen und wählen Sie OAuth-Client-ID aus.
  4. Wählen Sie unter Anwendungstyp die Option Desktop-Anwendung aus. Geben Sie anschließend unter Name einen Namen ein und klicken Sie auf Erstellen.
  5. Notieren Sie die im eingeblendeten Fenster OAuth-Client angezeigte Client-ID und den Clientschlüssel. Sie benötigen diese in einem Skript, um Anmeldedaten zu verwalten oder mit Ihren Entwicklern anderweitig gemeinsam zu nutzen.
  6. Im Fenster Anmeldedaten werden die neuen Anmeldedaten der Option Desktop-Anwendung mit der primären Client-ID angezeigt, die für den Zugriff auf die Anwendung verwendet wird.

Bei der Anwendung anmelden

Jeder Entwickler, der auf eine mit IAP gesicherte Anwendung zugreifen möchte, muss sich als Erstes anmelden. Sie können den Vorgang in einem Skript bündeln, z. B. mit dem Cloud SDK. Im Folgenden finden Sie ein Beispiel mit curl, mit dem Sie sich anmelden und ein Token generieren können, um damit auf die Anwendung zuzugreifen:

  1. Melden Sie sich bei Ihrem Konto an, das Zugriff auf die Google Cloud-Ressource hat.
  2. Öffnen Sie den folgenden URI, wobei DESKTOP_CLIENT_ID die Client-ID Desktop-Anwendung ist, die Sie oben erstellt haben:

    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. Notieren Sie sich den Autorisierungscode aus dem eingeblendeten Fenster. Ersetzen Sie unten AUTH_CODE durch diesen Code in Verbindung mit der Client-ID vom Typ Desktop-Anwendung und dem Secret, das Sie oben erstellt haben:

    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

    Dieser Code gibt ein JSON-Objekt mit dem Feld refresh_token zurück, das Sie als Anmeldetoken für den Zugriff auf die Anwendung speichern können.

Auf die Anwendung zugreifen

Für den Zugriff auf die Anwendung tauschen Sie das beim Anmelden generierte refresh_token gegen ein ID-Token aus. Das ID-Token ist für etwa eine Stunde gültig. In dieser Zeit können Sie mehrere Anfragen an eine bestimmte Anwendung senden. Im folgenden Beispiel mit curl wird dargestellt, wie Sie das Token verwenden und auf die Anwendung zugreifen:

  1. Verwenden Sie den untenstehenden Code. Dabei ist REFRESH_TOKEN das Token aus der Anmeldung, IAP_CLIENT_ID ist die primäre Client-ID für den Zugriff auf Ihre Anwendung und DESKTOP_CLIENT_ID sowie DESKTOP_CLIENT_SECRET sind die Client-ID und der Clientschlüssel, die Sie oben bei der Einrichtung der Client-ID erstellt haben:

    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

    Dieser Code gibt ein JSON-Objekt mit dem Feld id_token zurück, mit dem Sie auf die Anwendung zugreifen können.

  2. Für den Zugriff auf die Anwendung verwenden Sie id_token in folgender Weise:

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

Von einem Dienstkonto aus authentifizieren

Zum Authentifizieren eines Dienstkontos bei einer mit IAP gesicherten Ressource verwenden Sie ein OIDC-Token (OpenID Connect).

  1. Fügen Sie das Dienstkonto zur Zugriffsliste für das mit IAP gesicherte Projekt hinzu.
  2. Generieren Sie ein JWT-basiertes Zugriffstoken. Dieses verwendet die zusätzliche Anforderung target_audience, die eine Client-ID erfordert. Um die Client-ID zu finden, gehen Sie so vor:

    1. Rufen Sie die Seite "IAP" auf.
    2. Suchen Sie die Ressource, auf die Sie zugreifen möchten, und klicken Sie im Dreipunkt-Menü auf Edit OAuth Client (OAuth-Client bearbeiten).
      OAuth-Client mit dem Dreipunkt-Menü bearbeiten

    3. Notieren Sie sich die auf der Seite Anmeldedaten angezeigte Client-ID.

  3. Fordern Sie ein OIDC-Token für die mit IAP gesicherte Client-ID an. Folgen Sie diesen Schritten, um ein ID-Token für ein Dienstkonto anzufordern. Hinweis: Achten Sie darauf, dass das generierte ID-Token eine "email"-Anforderung hat. Dies ist eine Anforderung für IAP.

  4. Fügen Sie das OIDC-Token in einen Authorization: Bearer-Header ein, um die authentifizierte Anfrage an die mit IAP gesicherte Ressource zu senden.

Mit dem folgenden Beispielcode wird das Standarddienstkonto für eine mit IAP gesicherte Ressource authentifiziert:

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
}

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 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.
    google_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(
            google_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

Nächste Schritte