Autenticazione programmatica

Questa pagina descrive come eseguire l'autenticazione in una risorsa protetta da Identity-Aware Proxy (IAP) da un account utente o da un account di servizio.

• Un account utente appartiene a un singolo utente. Autentichi un account utente quando la tua applicazione richiede l'accesso alle risorse protette da IAP per conto di un utente. Per ulteriori informazioni informazioni, consulta Account utente.

• Un account di servizio appartiene a un'applicazione anziché a un singolo utente. Autentichi un account di servizio quando vuoi consentire a un'applicazione alle tue risorse protette con IAP. Per ulteriori informazioni, consulta Account di servizio.

Prima di iniziare

Prima di iniziare, ti serviranno:

• Un'applicazione protetta da IAP a cui desideri connettersi a livello di programmazione tramite un account sviluppatore, un account di servizio o un dispositivo mobile le credenziali dell'app.

Autenticazione di un account utente

Puoi consentire l'accesso degli utenti alla tua app da un'app desktop o mobile per consentire per interagire con una risorsa protetta da IAP.

Autenticazione da un'app mobile

1. Crea o utilizza un ID client OAuth 2.0 esistente per la tua app mobile. Per utilizzare un ID client OAuth 2.0 esistente, segui i passaggi descritti in Come condividere client OAuth.
2. Autorizza l'ID client OAuth per l'accesso programmatico all'applicazione.
3. Ottieni un token ID per l'ID cliente protetto da IAP.
   • Android: utilizza il API Accedi con Google per richiedere un OpenID Connect (OIDC). Imposta l'ID client requestIdToken all'ID client della risorsa a cui ti stai connettendo.
   • iOS: utilizza Accedi con Google per ottenere un token ID.
4. Includi il token ID in un'intestazione Authorization: Bearer per rendere richiesta autenticata alla risorsa protetta da IAP.

Autenticazione da un'app desktop

Questa sezione descrive come autenticare un account utente da un comando desktop dalla riga di comando.

1. Per consentire agli sviluppatori di accedere all'applicazione dalla riga di comando, crea un ID client OAuth 2.0 desktop o condividi un ID client OAuth desktop esistente.
2. Autorizza l'ID client OAuth per l'accesso programmatico all'applicazione.

Accesso all'applicazione

Ogni sviluppatore che desidera accedere a un'app protetta da IAP che devi prima eseguire l'accesso. Puoi pacchettizzare il processo in uno script, ad esempio utilizzando gcloud CLI. Di seguito è riportato un esempio di utilizzo di curl accedi e genera un token che possa essere utilizzato per accedere all'applicazione:

1. Accedi al tuo account che ha accesso alla risorsa Google Cloud.
2. Avvia un server locale che possa ripetere le richieste in arrivo.

       $ nc -k -l 4444
       

   NOTA: il comando utilizza l'utilità NetCat. Puoi utilizzare l'utilità che preferisci.
3. Vai al seguente URI, dove DESKTOP_CLIENT_ID è l'ID client dell'app desktop:

   https://accounts.google.com/o/oauth2/v2/auth?client_id=DESKTOP_CLIENT_ID&response_type=code&scope=openid%20email&access_type=offline&redirect_uri=http://localhost:4444&cred_ref=true

4. Nell'output del server locale, cerca i parametri della richiesta. Dovresti vedere ad esempio: GET /?code=$CODE&scope=email%20openid%20https://www.googleapis.com/auth/userinfo.email&hd=google.com&prompt=consent HTTP/1.1 copia il CODICE per sostituire AUTH_CODE di seguito insieme a l'ID client e il secret dell'app desktop:

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

   Questo codice restituisce un oggetto JSON con un'etichetta id_token campo che che puoi utilizzare per accedere all'applicazione.

Accesso all'applicazione

Per accedere all'app, utilizza id_token nel seguente modo:

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

Aggiorna token

Puoi utilizzare il token di aggiornamento generato durante il flusso di accesso per ottenere nuovi token ID. Questo è utile quando il token ID originale scade. Ogni ID è valido per circa un'ora, durante il quale puoi eseguire richieste a un'app specifica.

Di seguito è riportato un esempio in cui viene utilizzato curl per ottenere un nuovo ID con il token di aggiornamento di accesso. Nell'esempio seguente, REFRESH_TOKEN è il token del flusso di accesso. DESKTOP_CLIENT_ID e DESKTOP_CLIENT_SECRET sono i uguale a quello utilizzato nel flusso di accesso:

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

Questo codice restituisce un oggetto JSON con un nuovo id_token campo che puoi per accedere all'app.

Nota: il flusso di lavoro del token di aggiornamento non è supportato per i criteri relativi ai livelli di accesso. Devi rigenerare un nuovo token ID utilizzando il flusso di autenticazione completo.

Autenticazione di un account di servizio

Puoi utilizzare un token JWT dell'account di servizio o un token OpenID Connect (OIDC) per autenticare un account di servizio con una risorsa protetta da IAP. La seguente tabella illustra alcuni dei le differenze tra i diversi token di autenticazione e le relative caratteristiche.

Funzionalità di autenticazione	JWT dell'account di servizio	Token OpenID Connect
Supporto dell'accesso sensibile al contesto
Requisito per l'ID client OAuth 2.0
Ambito token	URL della risorsa protetta da IAP	ID client OAuth 2.0

Nota: l'account di servizio non supporta gli attributi dei criteri relativi ai dispositivi con accesso sensibile al contesto.

Autenticazione con un account di servizio JWT

L'autenticazione di un account di servizio tramite un JWT comprende i seguenti passaggi principali:

1. Concedi all'account di servizio che chiama il ruolo Creatore token account di servizio (roles/iam.serviceAccountTokenCreator).

   Il ruolo concede alle entità l'autorizzazione per creare credenziali di breve durata, come JWT.

2. Crea un JWT per la risorsa protetta da IAP.

3. Firma il JWT utilizzando la chiave privata dell'account di servizio.

Creazione del JWT

Il JWT creato dovrebbe avere un payload simile all'esempio seguente:

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

• Per i campi iss e sub, specifica l'indirizzo email dell'account di servizio. Si trova nel campo client_email del file JSON dell'account di servizio o viene passato. Formato tipico: service-account@PROJECT_ID.iam.gserviceaccount.com

• Per il campo aud, specifica l'URL della risorsa protetta da IAP.

• Per il campo iat, specifica l'ora Unix epoch corrente e per il campo exp specifica un'ora successiva a 3600 secondi. Definisce quando scade il JWT.

Nota: i JWT degli account di servizio hanno come ambito il pubblico fornito. Il segmento di pubblico deve essere l'URL della risorsa protetta da IAP. Ad esempio: https://example.com. I JWT con un segmento di pubblico di https://example.com negano l'accesso ai sottodomini del percorso.

Firma del JWT

Per firmare il JWT, puoi utilizzare uno dei seguenti metodi:

• Utilizza l'API delle credenziali IAM per firmare un JWT senza richiedere l'accesso diretto a una chiave privata.
• Utilizza un file di chiavi delle credenziali locali per firmare il JWT localmente.

Firma del JWT utilizzando l'API IAM Service Account Credentials

Utilizza l'API Credenziali dell'account di servizio IAM per firmare un JWT dell'account di servizio. Il metodo recupera la chiave privata associata al tuo account di servizio e la utilizza per firmare il payload JWT. Ciò consente la firma di un JWT senza accesso diretto a una chiave privata.

Per eseguire l'autenticazione su IAP, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configurare l'autenticazione per un ambiente di sviluppo locale.

gcloud

1. Esegui questo comando per preparare una richiesta con il payload JWT:

   cat > claim.json << EOM
   {
     "iss": "SERVICE_ACCOUNT_EMAIL_ADDRESS",
     "sub": "SERVICE_ACCOUNT_EMAIL_ADDRESS",
     "aud": "TARGET_URL",
     "iat": $(date +%s),
     "exp": $((`date +%s` + 3600))
   }
   EOM
   

2. Utilizza il seguente comando Google Cloud CLI per firmare il payload in request.json:

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

   Se la richiesta viene approvata, output.jwt contiene un JWT firmato.

3. Utilizza il JWT per accedere alla risorsa protetta da IAP.

Python

import datetime
import json

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

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

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

  Args:
    service_account_email (str): Specifies service account JWT is created for.
    resource_url (str): Specifies scope of the JWT, the URL that the JWT will be allowed to access.
  Returns:
    A signed-jwt that can be used to access IAP protected applications.
    Access the application with the JWT in the Authorization Header.
    curl --verbose --header 'Authorization: Bearer SIGNED_JWT' URL
  """
  iat = datetime.datetime.now(tz=datetime.timezone.utc)
  exp = iat + 3600
  return json.dumps({
      'iss': service_account_email,
      'sub': service_account_email,
      'aud': resource_url,
      'iat': iat,
      'exp': exp,
  })

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

  Args:
    target_sa (str): Service Account JWT is being created for.
      iap.webServiceVersions.accessViaIap permission is required.
    resource_url (str): Audience of the JWT, and scope of the JWT token.
      This is the url of the IAP protected application.
  Returns:
    A signed-jwt that can be used to access IAP protected apps.
  """
  source_credentials, _ = google.auth.default()
  iam_client = iam_credentials_v1.IAMCredentialsClient(credentials=source_credentials)
  return iam_client.sign_jwt(
      name=iam_client.service_account_path('-', target_sa),
      payload=generate_jwt_payload(target_sa, resource_url),
  ).signed_jwt

Se la richiesta viene approvata, lo script restituisce un JWT firmato. Utilizza il JWT per accedere alla risorsa protetta da IAP.

curl

1. Esegui questo comando per preparare una richiesta con il payload JWT:

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

2. Firma il JWT utilizzando l'API IAM Service Account Credentials:

   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"

   Se la richiesta viene approvata, nella risposta è presente un JWT firmato.

3. Utilizza il JWT per accedere alla risorsa protetta da IAP.

Nota: l'utilizzo dell'API delle credenziali IAM per firmare il JWT utilizza una chiamata di rete.

Firma del JWT da un file di chiave delle credenziali locali

I JWT vengono firmati utilizzando la chiave privata dell'account di servizio.

Se hai un file della chiave dell'account di servizio, il JWT può essere firmato localmente.

Lo script invia un'intestazione JWT insieme al payload. Per il campo kid nell'intestazione, utilizza l'ID chiave privata dell'account di servizio, che si trova nel private_key_id campo del file JSON delle credenziali dell'account di servizio. La chiave viene utilizzata anche per firmare il JWT.

Python

import time
import jwt
import json

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

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

  Args:
    service_account_email (str): Specifies service account JWT is created for.
    resource_url (str): Specifies scope of the JWT, the URL that the JWT will be allowed to access.
  Returns:
    A signed-jwt that can be used to access IAP protected applications.
    Access the application with the JWT in the Authorization Header.
    curl --verbose --header 'Authorization: Bearer SIGNED_JWT' URL
  """
  iat = datetime.datetime.now(tz=datetime.timezone.utc)
  exp = iat + 3600
  return json.dumps({
      'iss': service_account_email,
      'sub': service_account_email,
      'aud': resource_url,
      'iat': iat,
      'exp': exp,
  })

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

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

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

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

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

Il risultato è un JWT firmato.

Accesso all'applicazione

In ogni caso, per accedere all'app, utilizza il signed-jwt come segue:

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

Autenticazione con un token OIDC

1. Crea o utilizza un ID client OAuth 2.0 esistente. Per utilizzare un ID client OAuth 2.0 esistente, segui i passaggi descritti in Come condividere client OAuth.
2. Autorizza l'ID client OAuth per l'accesso programmatico all'applicazione.

Devi anche aggiungere l'account di servizio all'elenco per gli accessi per il progetto protetto da IAP. I seguenti esempi di codice mostrano come ottenere un token OIDC. Devi includere il token in un'intestazione Authorization: Bearer per effettuare la richiesta di autenticazione alla risorsa protetta da IAP.

Nota: assicurati che il token ID generato abbia un indirizzo "email" reclamo. Questo è un requisito per gli acquisti in-app.

Ottenere un token OIDC per l'account di servizio predefinito

Se vuoi ottenere un token OIDC per l'account di servizio predefinito per Compute Engine, App Engine o Cloud Run, puoi utilizzare quanto segue: di esempio di codice per generare il token per accedere a un risorsa:

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

Per autenticarti a IAP, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti a IAP, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale.

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

Per eseguire l'autenticazione su IAP, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per eseguire l'autenticazione su IAP, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

# 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

Ottenere un token OIDC da un file della chiave dell'account di servizio locale

Se disponi di un file delle chiavi dell'account di servizio, puoi adattare gli esempi di codice precedenti per fornire la chiave dell'account di servizio .

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

Ottenere un token OIDC in tutti gli altri casi

In tutti gli altri casi, utilizza l'API delle credenziali IAM per genera un token OIDC impersonando un account di servizio di destinazione proprio prima di accedere a risorsa con protezione IAP. Questo processo prevede quanto segue: passaggi:

1. Fornisci l'account di servizio per le chiamate (l'account di servizio associato a il codice che riceve il token ID) con l'OpenID dell'account di servizio Collega il ruolo Creatore token di identità (roles/iam.serviceAccountOpenIdTokenCreator).

   In questo modo l'account di servizio chiamante può impersonare o un account di servizio di destinazione.

2. Utilizza le credenziali fornite dall'account di servizio chiamante per chiamare il generateIdToken sull'account di servizio di destinazione.

   Imposta il campo audience sul tuo ID client.

Per istruzioni passo passo, vedi Crea un token ID.

Autenticazione dall'intestazione Proxy-Authorization

Se la tua applicazione utilizza l'intestazione della richiesta Authorization, puoi: dovrai includere il token ID in un'intestazione Proxy-Authorization: Bearer. Se in un'intestazione Proxy-Authorization, IAP autorizza la richiesta con questo strumento. Dopo aver autorizzato il richiesta, IAP passa l'intestazione Authorization al tuo all'applicazione senza elaborare i contenuti.

Se nell'intestazione Proxy-Authorization non viene trovato alcun token ID valido, IAP continua a elaborare l'intestazione Proxy-Authorization e la rimuove prima di passare la richiesta all'applicazione.

Passaggi successivi

• Scopri di più sull'autorizzazione: token di connessione.
• Prova la funzionalità Accedi per Android o Accedi per iOS.