Programmatische Authentifizierung

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

• Ein Nutzerkonto gehört zu einem einzelnen Nutzer. Ein Nutzerkonto muss authentifiziert werden, wenn Ihre Anwendung im Namen eines Nutzers auf Ressourcen zugreifen soll, die mit IAP gesichert sind. Weitere Informationen finden Sie unter 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 finden Sie unter Dienstkonten.

Hinweise

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 oder verwenden Sie eine vorhandene OAuth 2.0-Client-ID für Ihre mobile App. Wenn Sie eine vorhandene OAuth 2.0-Client-ID verwenden möchten, folgen Sie der Anleitung unter OAuth-Clients freigeben.
2. Fügen Sie die OAuth-Client-ID für den programmatischen Zugriff für die Anwendung der Zulassungsliste hinzu.
3. Rufen Sie ein ID-Token für die mit IAP gesicherte Client-ID ab.
   • Android: Fordern Sie mit der Google Sign-In API ein OpenID Connect-Token (OIDC) an. Geben Sie für die Client-ID von requestIdToken die Client-ID für die Ressource an, zu der Sie eine Verbindung herstellen möchten.
   • iOS: Fordern Sie mit Google Log-in ein ID-Token an.
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.

1. Damit Entwickler über die Befehlszeile auf Ihre Anwendung zugreifen können, erstellen Sie eine OAuth 2.0-Client-ID für Desktop-Anwendungen oder teilen Sie eine vorhandene OAuth-Client-ID für Desktop-Anwendungen.
2. Fügen Sie die OAuth-Client-ID für den programmatischen Zugriff für die Anwendung der Zulassungsliste hinzu.

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 der gcloud CLI. 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. Starten Sie einen lokalen Server, der die eingehenden Anfragen echoen kann.

       $ nc -k -l 4444
       

   HINWEIS: Der Befehl verwendet das Dienstprogramm NetCat. Sie können das Dienstprogramm Ihrer Wahl verwenden.
3. Öffnen Sie den folgenden URI, wobei DESKTOP_CLIENT_ID die Client-ID Desktop-Anwendung ist:

   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. Suchen Sie in der Ausgabe des lokalen Servers nach den Anfrageparametern. Die Ausgabe sollte in etwa so aussehen: GET /?code=$CODE&scope=email%20openid%20https://www.googleapis.com/auth/userinfo.email&hd=google.com&prompt=consent HTTP/1.1 Kopieren Sie den CODE, um ihn unten anstelle von AUTH_CODE zusammen mit der Client-ID und dem Secret der Desktop-Anwendung einzufügen:

   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

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

Auf die Anwendung zugreifen

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

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

Aktualisierungstoken

Sie können das Aktualisierungstoken verwenden, das während des Anmeldevorgangs generiert wurde, um neue ID-Tokens abzurufen. Das ist hilfreich, wenn das ursprüngliche ID-Token abläuft. Jedes 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 wird mit curl ein neues ID-Token mithilfe des Aktualisierungstokens abgerufen. Im folgenden Beispiel ist REFRESH_TOKEN das Token aus dem Anmeldevorgang. DESKTOP_CLIENT_ID und DESKTOP_CLIENT_SECRET müssen mit den Werten übereinstimmen, die im Anmeldevorgang verwendet werden:

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

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

Hinweis: Der Ablauf für Aktualisierungstokens wird für Richtlinien für Zugriffsebenen nicht unterstützt. Sie müssen ein neues ID-Token mit dem vollständigen Authentifizierungsablauf neu generieren.

Dienstkonto authentifizieren

Sie können ein JWT für ein Dienstkonto oder ein OpenID Connect (OIDC)-Token verwenden, um ein Dienstkonto bei einer mit IAP gesicherten Ressource zu authentifizieren. In der folgenden Tabelle werden einige der Unterschiede zwischen den verschiedenen Authentifizierungstokens und ihren Funktionen beschrieben.

Authentifizierungsfunktionen	JWT für Dienstkonto	OpenID Connect-Token
Unterstützung für die Funktion „Kontextsensitiver Zugriff“
Anforderung für OAuth 2.0-Client-ID
Tokenbereich	URL der IAP-gesicherten Ressource	OAuth 2.0-Client-ID

Hinweis: Dienstkonten unterstützen keine Attributwerte für Geräterichtlinien mit kontextbezogenem Zugriff.

Mit einem JWT für ein Dienstkonto authentifizieren

Die Authentifizierung eines Dienstkontos mit einem JWT umfasst die folgenden Hauptschritte:

1. Weisen Sie dem anrufenden Dienstkonto die Rolle Ersteller von Dienstkonto-Tokens (roles/iam.serviceAccountTokenCreator) zu.

   Die Rolle gewährt Hauptkonten die Berechtigung, kurzlebige Anmeldedaten wie JWTs zu erstellen.

2. Erstellen Sie ein JWT für die mit IAP gesicherte Ressource.

3. Signieren Sie das JWT mit dem privaten Schlüssel des Dienstkontos.

JWT erstellen

Das erstellte JWT sollte eine Nutzlast haben, die dem folgenden Beispiel ähnelt:

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

• Geben Sie in den Feldern iss und sub die E-Mail-Adresse des Dienstkontos an. Sie finden sie im Feld client_email der JSON-Datei des Dienstkontos oder geben sie ein. Typisches Format: service-account@PROJECT_ID.iam.gserviceaccount.com

• Geben Sie im Feld aud die URL der mit IAP gesicherten Ressource an.

• Geben Sie für das Feld iat die aktuelle Unix-Epochenzeit und für das Feld exp eine Zeit innerhalb von 3.600 Sekunden an. Hier wird festgelegt, wann das JWT abläuft.

Hinweis: JWTs für Dienstkonten sind auf die angegebene Zielgruppe beschränkt. Die Zielgruppe sollte die URL der IAP-geschützten Ressource sein. Beispiel: https://example.com JWTs mit der Zielgruppe https://example.com verweigern den Zugriff auf Subdomains des Pfads.

JWT signieren

Sie können eine der folgenden Methoden verwenden, um das JWT zu signieren:

• Mit der IAM Credentials API können Sie ein JWT signieren, ohne direkten Zugriff auf einen privaten Schlüssel zu benötigen.
• Verwenden Sie eine lokale Anmeldedaten-Schlüsseldatei, um das JWT lokal zu signieren.

JWT mit der IAM Service Account Credentials API signieren

Verwenden Sie die IAM Service Account Credentials API, um ein JWT für ein Dienstkonto zu signieren. Die Methode ruft den privaten Schlüssel ab, der mit Ihrem Dienstkonto verknüpft ist, und verwendet ihn, um die JWT-Nutzlast zu signieren. So ist das Signieren eines JWT ohne direkten Zugriff auf einen privaten Schlüssel möglich.

Richten Sie zur Authentifizierung bei IAP die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

gcloud

1. Führen Sie den folgenden Befehl aus, um eine Anfrage mit der JWT-Nutzlast vorzubereiten:

   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. Verwenden Sie den folgenden Google Cloud CLI-Befehl, um die Nutzlast in request.json zu signieren:

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

   Nach einer erfolgreichen Anfrage enthält output.jwt ein signiertes JWT.

3. Verwenden Sie das JWT, um auf Ihre mit IAP gesicherte Ressource zuzugreifen.

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

Bei einer erfolgreichen Anfrage gibt das Script ein signiertes JWT zurück. Verwenden Sie das JWT, um auf Ihre mit IAP gesicherte Ressource zuzugreifen.

curl

1. Führen Sie den folgenden Befehl aus, um eine Anfrage mit der JWT-Nutzlast vorzubereiten:

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

2. Signieren Sie das JWT mit der 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"

   Nach einer erfolgreichen Anfrage ist in der Antwort ein signiertes JWT enthalten.

3. Verwenden Sie das JWT, um auf Ihre mit IAP gesicherte Ressource zuzugreifen.

Hinweis :Wenn Sie die IAM Credentials API zum Signieren des JWT verwenden, wird ein Netzwerkaufruf verwendet.

JWT aus einer lokalen Anmeldedaten-Schlüsseldatei signieren

JWTs werden mit dem privaten Schlüssel des Dienstkontos signiert.

Wenn Sie eine Schlüsseldatei für ein Dienstkonto haben, kann das JWT lokal signiert werden.

Das Script sendet zusammen mit der Nutzlast einen JWT-Header. Verwenden Sie für das Feld kid in der Kopfzeile die ID des privaten Schlüssels des Dienstkontos, die sich im Feld private_key_id der JSON-Datei mit den Anmeldedaten des Dienstkontos befindet. Der Schlüssel wird auch zum Signieren des JWT verwendet.

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

Das Ergebnis ist ein signiertes JWT.

Auf die Anwendung zugreifen

Für den Zugriff auf die Anwendung verwenden Sie signed-jwt in jedem Fall so:

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

Mit einem OIDC-Token authentifizieren

1. Erstellen oder vorhandene OAuth 2.0-Client-ID verwenden Wenn Sie eine vorhandene OAuth 2.0-Client-ID verwenden möchten, folgen Sie der Anleitung unter OAuth-Clients freigeben.
2. Fügen Sie die OAuth-Client-ID für den programmatischen Zugriff für die Anwendung der Zulassungsliste hinzu.

Außerdem müssen Sie das Dienstkonto der Zugriffsliste für das mit IAP gesicherte Projekt hinzufügen. Die folgenden Codebeispiele zeigen, wie Sie ein OIDC-Token erhalten. Sie müssen das Token in einen Authorization: Bearer-Header einfügen, um die Authentifizierungsanfrage an die mit IAP gesicherte Ressource zu senden.

Hinweis: Achten Sie darauf, dass das generierte ID-Token eine „E-Mail“-Anforderung hat. Dies ist für IAP erforderlich.

OIDC-Token für das Standarddienstkonto abrufen

Wenn Sie ein OIDC-Token für das Standarddienstkonto für Compute Engine, App Engine oder Cloud Run abrufen möchten, können Sie das folgende Codebeispiel verwenden, um das Token zu generieren, um auf eine mit IAP gesicherte Ressource zuzugreifen:

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

Richten Sie zur Authentifizierung bei IAP die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Richten Sie zur Authentifizierung bei IAP die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Richten Sie zur Authentifizierung bei IAP die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Richten Sie zur Authentifizierung bei IAP die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

# 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-Token aus einer lokalen Dienstkonto-Schlüsseldatei abrufen

Wenn Sie eine Dienstkonto-Schlüsseldatei haben, können Sie die vorhergehenden Codebeispiele anpassen, um die Dienstkonto-Schlüsseldatei bereitzustellen.

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 "$@"

In allen anderen Fällen ein OIDC-Token abrufen

In allen anderen Fällen können Sie mit der IAM Credentials API ein OIDC-Token generieren. Dazu wird direkt vor dem Zugriff auf eine mit IAP gesicherte Ressource die Identität eines Zieldienstkontos übernommen. Dieser Vorgang umfasst folgende Schritte:

1. Weisen Sie dem anrufenden Dienstkonto (dem Dienstkonto, das mit dem Code verknüpft ist, über den das ID-Token abgerufen wird) die Rolle „Ersteller des OpenID Connect-Identitätstokens für das Dienstkonto“ (roles/iam.serviceAccountOpenIdTokenCreator) zu.

   Dadurch kann das aufrufende Dienstkonto die Identität des Zieldienstkontos übernehmen.

2. Rufen Sie mit den Anmeldedaten des aufrufenden Dienstkontos die Methode generateIdToken im Zieldienstkonto auf.

   Legen Sie im Feld audience Ihre Client-ID fest.

Eine detaillierte Anleitung finden Sie unter ID-Token erstellen.

Authentifizierung über Proxy-Autorisierungsheader

Wenn Ihre Anwendung den Anfrageheader Authorization verwendet, können Sie das ID-Token stattdessen in einem Proxy-Authorization: Bearer-Header einfügen. Wenn ein gültiges ID-Token in einem Proxy-Authorization-Header gefunden wird, autorisiert IAP die Anfrage damit. Nach der Autorisierung der Anfrage übergibt IAP den Authorization-Header an Ihre Anwendung, ohne die Inhalte zu verarbeiten.

Wenn im Proxy-Authorization-Header kein gültiges ID-Token gefunden wird, verarbeitet IAP den Authorization-Header weiter und entfernt den Proxy-Authorization-Header, bevor die Anfrage an Ihre Anwendung weitergeleitet wird.

Nächste Schritte

• Autorisierung: Inhabertoken
• Log-in für Android oder Log-in für iOS testen