Autenticazione per le chiamate (1ª generazione.)

Per richiamare una funzione Cloud Run autenticata, il principal sottostante deve soddisfare i seguenti requisiti:

• Avere l'autorizzazione per richiamare la funzione.
• Fornisci un token ID quando richiama la funzione.

Che cos'è un principale? Come descritto in Proteggere le funzioni Cloud Run, Cloud Run Functions supporta due diversi tipi di identità, chiamate anche entità:

• Service account: si tratta di account speciali che fungono da identità di una persona non fisica, ad esempio una funzione, un'applicazione o una VM. Ti offrono un modo per autenticare queste entità non umane.
• Account utente: questi account rappresentano persone, in qualità di titolari di un Account Google individuale o come parte di un'entità controllata da Google, ad esempio un gruppo Google.

Consulta la panoramica di IAM per scoprire di più sui concetti di base di IAM.

Per richiamare una funzione Cloud Run autenticata, l'entità deve disporre dell'autorizzazione IAM invoker:

• cloudfunctions.functions.invoke. Di solito questo avviene tramite il ruolo Invoker.

Per concedere queste autorizzazioni, utilizza il comando add-invoker-policy-binding come mostrato in Autenticazione della funzione per le chiamate di funzioni.

Per l'autorizzazione a creare, aggiornare o eseguire altre azioni amministrative su una funzione, l'entità deve disporre di un ruolo appropriato. I ruoli includono autorizzazioni che definiscono le azioni consentite all'entità. Per saperne di più, consulta Utilizzare IAM per autorizzare l'accesso.

L'invocazione di una funzione può presentare ulteriori complessità. Le funzioni basate sugli eventi possono essere richiamate solo dall'origine eventi a cui sono iscritte, mentre le funzioni HTTP possono essere richiamate da diversi tipi di identità, provenienti da luoghi diversi. L'invoker potrebbe essere uno sviluppatore che sta testando la funzione o un'altra funzione o servizio che vuole utilizzare la funzione. Per impostazione predefinita, queste identità devono fornire un token ID con la richiesta per autenticarsi. Inoltre, all'account utilizzato devono essere state concesse le autorizzazioni appropriate.

Scopri di più su come generare e utilizzare i token ID.

Esempi di autenticazione

Questa sezione mostra alcuni esempi diversi di autenticazione per l'invocazione.

Esempio 1: autenticare i test degli sviluppatori

In qualità di sviluppatore, devi disporre dell'accesso per creare, aggiornare ed eliminare funzioni e questo accesso viene concesso utilizzando la normale procedura IAM.

Tuttavia, in qualità di sviluppatore, potresti dover richiamare le tue funzioni a scopo di test. Per richiamare una funzione utilizzando curl o strumenti simili, tieni presente quanto segue:

• Assegna un ruolo al tuo account utente Cloud Run Functions che contenga l'autorizzazione di chiamata.

  • cloudfunctions.functions.invoke. In genere, questo avviene tramite il ruolo Invoker. Per impostazione predefinita, i ruoli Amministratore funzioni Cloud Run e Sviluppatore funzioni Cloud Run dispongono di questa autorizzazione. Consulta Ruoli IAM per le funzioni Cloud Run per l'elenco completo dei ruoli e delle relative autorizzazioni.

• Se lavori dalla tua macchina locale, configura l'accesso alla riga di comando inizializzando Google Cloud CLI.

• Fornisci la richiesta con le credenziali di autenticazione come token ID generato da Google memorizzato in un'intestazione Authorization. Ad esempio, recupera un token ID utilizzando gcloud eseguendo questo comando:

  curl  -H "Authorization: Bearer $(gcloud auth print-identity-token)" \
    https://FUNCTION_URL

  dove FUNCTION_URL è l'URL della tua funzione. Recupera questo URL dalla pagina delle funzioni Cloud Run della consoleGoogle Cloud o eseguendo il comando gcloud functions describe come mostrato nel primo passaggio dell'esempio di comando di deployment di Google Cloud CLI.

Puoi utilizzare i token creati da gcloud per richiamare le funzioni HTTP in qualsiasi progetto, a condizione che il tuo account disponga dell'autorizzazione cloudfunctions.functions.invoke per la funzione richiamata. A scopo di sviluppo, utilizza token ID generati da gcloud. Tuttavia, tieni presente che questi token non includono una rivendicazione del pubblico, il che li rende vulnerabili agli attacchi di tipo relay. Negli ambienti di produzione, utilizza i token ID emessi per un account di servizio con il pubblico appropriato specificato. Questo approccio migliora la sicurezza limitando l'utilizzo dei token solo al servizio previsto.

Come sempre, ti consigliamo di allocare il set minimo di autorizzazioni necessarie per sviluppare e utilizzare le tue funzioni. Assicurati che i criteri IAM sulle tue funzioni siano limitati al numero minimo di utenti e service account.

Esempio 2: autenticare le chiamate da funzione a funzione

Quando crei servizi che connettono più funzioni, è consigliabile assicurarsi che ogni funzione possa inviare richieste solo a un sottoinsieme specifico delle altre funzioni. Ad esempio, se hai una funzione login, dovrebbe essere in grado di accedere alla funzione user profiles, ma probabilmente non dovrebbe essere in grado di accedere alla funzione search.

Per configurare la funzione di ricezione in modo che accetti le richieste da una funzione di chiamata specifica, devi concedere il ruolo di invoker appropriato al account di servizio della funzione di chiamata nella funzione di ricezione. Il ruolo invoker è Invoker di Cloud Run Functions (roles/cloudfunctions.invoker):

gcloud functions add-invoker-policy-binding RECEIVING_FUNCTION \
  --member='serviceAccount:CALLING_FUNCTION_IDENTITY'

Poiché richiamerà la funzione di ricezione, la funzione di chiamata deve fornire anche un token ID firmato da Google per l'autenticazione. Si tratta di una procedura in due passaggi:

1. Crea un token ID firmato da Google con il campo pubblico (aud) impostato sull'URL della funzione di ricezione.

2. Includi il token ID in un'intestazione Authorization: Bearer ID_TOKEN nella richiesta alla funzione.

Il modo di gran lunga più semplice e affidabile per gestire questo processo è utilizzare le librerie di autenticazione, come mostrato di seguito, per generare e utilizzare questo token.

Generare token ID

Questa sezione descrive i diversi modi in cui puoi generare il token ID necessario a un principal per richiamare una funzione.

È possibile l'accesso non autenticato senza un token ID, ma deve essere attivato. Per ulteriori informazioni, consulta la sezione Utilizzo di IAM per autorizzare l'accesso.

Generare token in modo programmatico

Dopo che il seguente codice genera un token ID, chiama la tua funzione Cloud Run con quel token per tuo conto. Questo codice funziona in qualsiasi ambiente in cui le librerie possono ottenere le credenziali di autenticazione, inclusi gli ambienti che supportano le credenziali predefinite dell'applicazione locali.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */

// Cloud Functions uses your function's url as the `targetAudience` value
// const targetAudience = 'https://project-region-projectid.cloudfunctions.net/myFunction';
// For Cloud Functions, endpoint (`url`) and `targetAudience` should be equal
// const url = targetAudience;


const {GoogleAuth} = require('google-auth-library');
const auth = new GoogleAuth();

async function request() {
  console.info(`request ${url} with target audience ${targetAudience}`);
  const client = await auth.getIdTokenClient(targetAudience);

  // Alternatively, one can use `client.idTokenProvider.fetchIdToken`
  // to return the ID Token.
  const res = await client.fetch(url);
  console.info(res.data);
}

request().catch(err => {
  console.error(err.message);
  process.exitCode = 1;
});

import urllib

import google.auth.transport.requests
import google.oauth2.id_token


def make_authorized_get_request(endpoint, audience):
    """
    make_authorized_get_request makes a GET request to the specified HTTP endpoint
    by authenticating with the ID token obtained from the google-auth client library
    using the specified audience value.
    """

    # Cloud Functions uses your function's URL as the `audience` value
    # audience = https://project-region-projectid.cloudfunctions.net/myFunction
    # For Cloud Functions, `endpoint` and `audience` should be equal

    req = urllib.request.Request(endpoint)

    auth_req = google.auth.transport.requests.Request()
    id_token = google.oauth2.id_token.fetch_id_token(auth_req, audience)

    req.add_header("Authorization", f"Bearer {id_token}")
    response = urllib.request.urlopen(req)

    return response.read()

import (
	"context"
	"fmt"
	"io"

	"google.golang.org/api/idtoken"
)

// `makeGetRequest` makes a request to the provided `targetURL`
// with an authenticated client using audience `audience`.
func makeGetRequest(w io.Writer, targetURL string, audience string) error {
	// For Cloud Functions, endpoint (`serviceUrl`) and `audience` are the same.
	// Example `audience` value (Cloud Functions): https://<PROJECT>-<REGION>-<PROJECT_ID>.cloudfunctions.net/myFunction
	// (`targetURL` and `audience` will differ for GET parameters)
	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)
	}

	resp, err := client.Get(targetURL)
	if err != nil {
		return fmt.Errorf("client.Get: %w", err)
	}
	defer resp.Body.Close()
	if _, err := io.Copy(w, resp.Body); err != nil {
		return fmt.Errorf("io.Copy: %w", err)
	}

	return nil
}

import com.google.api.client.http.GenericUrl;
import com.google.api.client.http.HttpRequest;
import com.google.api.client.http.HttpResponse;
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 java.io.IOException;

public class Authentication {

  // makeGetRequest makes a GET request to the specified Cloud Run or
  // Cloud Functions endpoint `serviceUrl` (must be a complete URL), by
  // authenticating with an ID token retrieved from Application Default
  // Credentials using the specified `audience`.
  //
  // For Cloud Functions, endpoint (`serviceUrl`) and `audience` are the same.
  // Example `audience` value (Cloud Functions): https://project-region-projectid.cloudfunctions.net/myFunction
  public static HttpResponse makeGetRequest(String serviceUrl, String audience) throws IOException {
    GoogleCredentials credentials = GoogleCredentials.getApplicationDefault();
    if (!(credentials instanceof IdTokenProvider)) {
      throw new IllegalArgumentException("Credentials are not an instance of IdTokenProvider.");
    }
    IdTokenCredentials tokenCredential =
        IdTokenCredentials.newBuilder()
            .setIdTokenProvider((IdTokenProvider) credentials)
            .setTargetAudience(audience)
            .build();

    GenericUrl genericUrl = new GenericUrl(serviceUrl);
    HttpCredentialsAdapter adapter = new HttpCredentialsAdapter(tokenCredential);
    HttpTransport transport = new NetHttpTransport();
    HttpRequest request = transport.createRequestFactory(adapter).buildGetRequest(genericUrl);
    return request.execute();
  }
}

Generare token manualmente

Se richiami una funzione e per qualche motivo non puoi utilizzare le librerie di autenticazione, esistono due modi per ottenere manualmente il token ID, utilizzando il server dei metadati di Compute o creando un JWT autofirmato e scambiandolo con un token ID firmato da Google.

Utilizzare il server di metadati

Puoi utilizzare il server di metadati di Compute per recuperare i token ID con un pubblico specifico come segue:

curl "http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/identity?audience=AUDIENCE" \
     -H "Metadata-Flavor: Google"

Sostituisci AUDIENCE con l'URL della funzione che stai richiamando. Puoi recuperare questo URL come descritto nella sezione Autenticazione dei test per sviluppatori riportata sopra.

Scambia un JWT autofirmato con un token ID firmato da Google

1. Concedi il ruolo Invoker (roles/cloudfunctions.invoker) all'account di servizio della funzione chiamante nella funzione ricevente.

2. Crea un service account e una chiave e scarica il file con la chiave privata (in formato JSON) sull'host da cui la funzione o il servizio chiamante effettua le richieste.

3. Crea un JWT con l'intestazione impostata su {"alg":"RS256","typ":"JWT"}. Il payload deve includere un'attestazione target_audience impostata sull'URL della funzione di ricezione e le attestazioni iss e sub impostate sull'indirizzo email dell'account di servizio utilizzato sopra. Deve includere anche le rivendicazioni exp e iat. La rivendicazione aud deve essere impostata su https://www.googleapis.com/oauth2/v4/token.

4. Utilizza la chiave privata scaricata sopra per firmare il JWT.

5. Utilizzando questo JWT, invia una richiesta POST a https://www.googleapis.com/oauth2/v4/token. I dati di autenticazione devono essere inclusi nell'intestazione e nel corpo della richiesta.

   Nell'intestazione:

   Authorization: Bearer $JWT - where $JWT is the JWT you just created
   Content-Type: application/x-www-form-urlencoded
   

   Nel corpo:

   grant_type=urn:ietf:params:oauth:grant-type:jwt-bearer&assertion=$JWT
   

   Sostituisci $JWT con il JWT che hai appena creato.

   Restituisce un altro JWT che include un id_token firmato da Google.

Invia la richiesta GET/POST alla funzione di ricezione. Includi il token ID firmato da Google in un'intestazione Authorization: Bearer ID_TOKEN_JWT nella richiesta.

Passaggi successivi

• Scopri come gestire l'accesso alle funzioni.

• Ricevi assistenza per altri modi per generare token ID.