Autenticazione programmatica

Questa pagina descrive come eseguire l'autenticazione su 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 a risorse protette da IAP per conto di un utente. Ulteriori informazioni sulle credenziali dell'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 di accedere alle tue risorse protette da IAP. Scopri come comprendere gli account di servizio.

Prima di iniziare

Prima di iniziare devi avere:

  • Un'applicazione protetta da IAP a cui vuoi connetterti in modo programmatico tramite un account sviluppatore, un account di servizio o le credenziali dell'app per dispositivi mobili.

Autenticazione di un account utente

Puoi consentire all'utente l'accesso alla tua app da un'app desktop o per dispositivi mobili per consentire a un programma di interagire con una risorsa protetta da IAP.

Autenticazione da un'app per dispositivi mobili

  1. Crea un ID client OAuth 2.0 per la tua app per dispositivi mobili nello stesso progetto della risorsa protetta tramite IAP:
    1. Vai alla pagina Credenziali.
      Vai alla pagina Credenziali
    2. Seleziona il progetto con la risorsa protetta da IAP.
    3. Fai clic su Crea credenziali, quindi seleziona ID client OAuth.
    4. Seleziona il Tipo di applicazione per il quale vuoi creare le credenziali.
    5. Aggiungi un nome e delle limitazioni, se opportuno, poi fai clic su Crea.
  2. Nella finestra Client OAuth visualizzata, prendi nota dell'ID client per la risorsa protetta tramite IAP a cui vuoi connetterti.
  3. Ottieni un token ID per l'ID client con protezione IAP:
  4. Includi il token ID in un'intestazione Authorization: Bearer per effettuare la richiesta autenticata alla risorsa con protezione IAP.

Autenticazione da un'app desktop

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

Configurazione dell'ID client

Per consentire agli sviluppatori di accedere alla tua applicazione dalla riga di comando, devi innanzitutto creare le credenziali dell'ID client OAuth di tipo App desktop:

  1. Vai alla pagina Credenziali.
    Vai alla pagina Credenziali
  2. Seleziona il progetto con la risorsa protetta da IAP.
  3. Fai clic su Crea credenziali, quindi seleziona ID client OAuth.
  4. In Tipo di applicazione, seleziona App desktop, aggiungi un Nome, quindi fai clic su Crea.
  5. Nella finestra Client OAuth visualizzata, prendi nota dell'ID client e del client secret. Dovrai utilizzarli in uno script per gestire le credenziali o condividere le informazioni con gli sviluppatori in altro modo.
  6. Nella finestra Credenziali, le nuove credenziali dell'app desktop vengono visualizzate insieme all'ID client principale utilizzato per accedere all'applicazione.

Accesso all'applicazione

Ogni sviluppatore che vuole accedere a un'app protetta da IAP dovrà eseguire prima l'accesso. Puoi pacchettizzare il processo in uno script, ad esempio utilizzando l'interfaccia a riga di comando gcloud. Di seguito è riportato un esempio che utilizza curl per accedere e generare un token che può 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 eco le richieste in arrivo. $ nc -k -l 4444 NOTA: il comando utilizza l'utilità [NetCat](http://netcat.sourceforge.net/). Puoi utilizzare l'utilità che preferisci.
  3. Vai all'URI seguente dove DESKTOP_CLIENT_ID è l'ID client dell'app desktop che hai creato in precedenza:

    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

  4. Nell'output del server locale, cerca i parametri della richiesta. Dovresti vedere quanto segue: GET /?code=\$CODE&scope=email%20openid%20https://www.googleapis.com/auth/userinfo.email&hd=google.com&prompt=consent HTTP/1.1 copia il CODE per sostituire AUTH_CODE di seguito, insieme all'ID client e al secret dell'app desktop che hai creato in precedenza:

    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 campo refresh_token che puoi salvare come token di accesso per accedere all'applicazione.

Accesso all'applicazione

Per accedere all'applicazione, condividerai l'elemento refresh_token generato durante il flusso di accesso con un token ID. Il token ID è valido per circa un'ora, durante il quale puoi effettuare più richieste a un'app specifica. Di seguito è riportato un esempio che utilizza curl per utilizzare il token e accedere all'applicazione:

  1. Utilizza il codice riportato di seguito, dove REFRESH_TOKEN è il token del flusso di accesso, IAP_CLIENT_ID è l'ID client principale utilizzato per accedere all'applicazione, mentre DESKTOP_CLIENT_ID e DESKTOP_CLIENT_SECRET sono l'ID client e il secret che hai creato quando hai configurato l'ID client sopra indicato:

    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

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

  2. Per accedere all'app, utilizza l'elemento id_token come segue:

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

Autenticazione da un account di servizio

Utilizza un token OpenID Connect (OIDC) per autenticare un account di servizio in una risorsa protetta tramite IAP. Per trovare l'ID client:

  1. Vai alla pagina IAP.
  2. Individua la risorsa a cui vuoi accedere, quindi fai clic su Altro > Modifica client OAuth.
    Modifica il client OAuth nel menu Altro

  3. Nella pagina Credenziali visualizzata, prendi nota dell'ID client.

Devi aggiungere anche l'account di servizio all'elenco di accesso del progetto protetto da IAP. I seguenti esempi di codice mostrano come ottenere un token OIDC. Indipendentemente dalla scelta, devi includere il token in un'intestazione Authorization: Bearer per effettuare la richiesta autenticata con la risorsa protetta tramite IAP.

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 il seguente esempio di codice per generare il token per accedere a una risorsa protetta da 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="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

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.
 */
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

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

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

Se hai un file chiave dell'account di servizio, puoi adattare gli esempi di codice precedenti per fornire il file della 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 + 3600))"
    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 Bearer ID token.
    ID_TOKEN=$(get_token "${SERVICE_ACCOUNT_KEY}" "${IAP_CLIENT_ID}")
    # Access the application with the Bearer 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 IAM delle credenziali per generare un token OIDC basato su un token di accesso per un altro account di servizio subito prima di accedere a una risorsa protetta IAP:

  1. Aggiungi l'account nel token di accesso con il ruolo service account token creator all'account di destinazione. Questo garantisce che disponga dell'autorizzazione IAM necessaria per creare un token OIDC per l'account di servizio di destinazione.
  2. Chiama il file generateIdToken dell'account di servizio di destinazione con il token di accesso. Presta particolare attenzione a impostare il campo audience sull'ID client.

Autenticazione da intestazione proxy-autorizzazione

Se la tua applicazione utilizza l'intestazione della richiesta Authorization, puoi includere il token ID in un'intestazione Proxy-Authorization: Bearer. Se viene trovato un token ID valido in un'intestazione Proxy-Authorization, IAP autorizza la richiesta con tale ID. Dopo aver autorizzato la richiesta, IAP trasmette l'intestazione Authorization alla tua applicazione senza elaborare i contenuti.

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

Passaggi successivi