Autenticar para invocar (1.ª gen.)

Para invocar una función de Cloud Run autenticada, el principal subyacente debe cumplir los siguientes requisitos:

• Tener permiso para invocar la función.
• Proporciona un token de ID cuando invoca la función.

¿Qué es un centro educativo? Como se describe en el artículo Protege tus funciones de Cloud Run, Cloud Run Functions admite dos tipos de identidades, también llamadas principales:

• Cuentas de servicio: son cuentas especiales que sirven como identidad de una entidad que no es una persona, como una función, una aplicación o una VM. Te permiten autenticar a estas entidades no personales.
• Cuentas de usuario: estas cuentas representan a personas, ya sea como titulares de cuentas de Google individuales o como parte de una entidad controlada por Google, como un grupo de Google.

Consulta la descripción general de la gestión de identidades y accesos para obtener más información sobre los conceptos básicos de IAM.

Para invocar una función de Cloud Run autenticada, la entidad debe tener el permiso de invocador de gestión de identidades y accesos:

• cloudfunctions.functions.invoke. Normalmente, se hace a través del rol de invocador.

Para conceder estos permisos, usa el comando add-invoker-policy-binding como se muestra en Autenticar funciones para llamar a funciones.

Para tener permiso para crear, actualizar o realizar otras acciones administrativas en una función, la entidad debe tener un rol adecuado. Los roles incluyen permisos que definen las acciones que puede realizar la entidad de seguridad. Para obtener más información, consulta Usar gestión de identidades y accesos para autorizar el acceso.

Invocar una función puede tener complejidades adicionales. Las funciones basadas en eventos solo pueden invocarse mediante la fuente de eventos a la que están suscritas, pero las funciones HTTP pueden invocarse mediante diferentes tipos de identidades procedentes de distintos lugares. El invocador puede ser un desarrollador que esté probando la función u otra función o servicio que quiera usarla. De forma predeterminada, estas identidades deben proporcionar un token de ID con la solicitud para autenticarse. Además, la cuenta que se utilice debe tener los permisos adecuados.

Consulta más información sobre cómo generar y usar tokens de ID.

Ejemplos de autenticación

En esta sección se muestran algunos ejemplos de autenticación para la invocación.

Ejemplo 1: Autenticar pruebas de desarrolladores

Como desarrollador, necesitas acceso para crear, actualizar y eliminar funciones, y esto se concede mediante el proceso normal de gestión de identidades y accesos.

Sin embargo, como desarrollador, es posible que tengas que invocar tus funciones para hacer pruebas. Para invocar una función mediante curl u otras herramientas similares, ten en cuenta lo siguiente:

• Asigna a la cuenta de usuario de tus funciones de Cloud Run un rol que contenga el permiso de invocación.

  • cloudfunctions.functions.invoke. Normalmente, esto se hace mediante el rol Invocador. De forma predeterminada, los roles Administrador de Cloud Run Functions y Desarrollador de Cloud Run Functions tienen este permiso. Consulta la lista completa de roles de gestión de identidades y accesos de las funciones de Cloud Run y sus permisos asociados.

• Si trabajas desde tu máquina local, configura el acceso a la línea de comandos inicializando la CLI de Google Cloud.

• Proporcione su solicitud con las credenciales de autenticación como un token de ID generado por Google y almacenado en un encabezado Authorization. Por ejemplo, puedes obtener un token de ID con gcloud ejecutando el siguiente comando:

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

  donde FUNCTION_URL es la URL de tu función. Obtén esta URL en la página de funciones de Cloud Run de laGoogle Cloud consola o ejecutando el comando gcloud functions describe, tal como se muestra en el primer paso del ejemplo de comando de implementación de la CLI de Google Cloud.

Puedes usar tokens creados por gcloud para invocar funciones HTTP en cualquier proyecto, siempre que tu cuenta tenga el permiso cloudfunctions.functions.invoke en la función que se esté invocando. Para actividades de desarrollo, usa tokens de ID generados por gcloud. Sin embargo, ten en cuenta que estos tokens no tienen una reclamación de audiencia, lo que los hace susceptibles a ataques de retransmisión. En entornos de producción, usa tokens de ID emitidos para una cuenta de servicio con la audiencia adecuada especificada. Este enfoque mejora la seguridad, ya que restringe el uso de tokens únicamente al servicio previsto.

Como siempre, te recomendamos que asignes el conjunto mínimo de permisos necesario para desarrollar y usar tus funciones. Asegúrate de que las políticas de IAM de tus funciones se limiten al número mínimo de usuarios y cuentas de servicio.

Ejemplo 2: Autenticar la función para las llamadas a funciones

Cuando crees servicios que conecten varias funciones, es recomendable que te asegures de que cada función solo pueda enviar solicitudes a un subconjunto específico de tus otras funciones. Por ejemplo, si tienes una función login, debería poder acceder a la función user profiles, pero probablemente no debería poder acceder a la función search.

Para configurar la función receptora de forma que acepte solicitudes de una función de llamada específica, debes asignar el rol de invocador adecuado a la cuenta de servicio de la función de llamada en la función receptora. El rol de invocador es Invocador de Cloud Run Functions (roles/cloudfunctions.invoker):

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

Como invocará la función receptora, la función de llamada también debe proporcionar un token de ID firmado por Google para autenticarse. Este proceso consta de dos pasos:

1. Crea un token de ID firmado por Google con el campo de audiencia (aud) configurado con la URL de la función receptora.

2. Incluye el token de ID en un encabezado Authorization: Bearer ID_TOKEN en la solicitud a la función.

La forma más sencilla y fiable de gestionar este proceso es usar las bibliotecas de autenticación, como se muestra a continuación, para generar y emplear este token.

Generar tokens de ID

En esta sección se describen las diferentes formas de generar el token de ID que necesita una entidad para invocar una función.

Es posible acceder sin autenticar y sin un token de ID, pero debe habilitarse. Para obtener más información, consulta Usar IAM para autorizar el acceso.

Generar tokens mediante programación

Después de que el siguiente código genere un token de ID, llamará a tu función de Cloud Run con ese token en tu nombre. Este código funciona en cualquier entorno en el que las bibliotecas puedan obtener credenciales de autenticación, incluidos los entornos que admiten credenciales predeterminadas de aplicación locales.

/**
 * 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();
  }
}

Generar tokens manualmente

Si invocas una función y, por algún motivo, no puedes usar las bibliotecas de autenticación, tienes dos formas de obtener el token de ID manualmente: mediante el servidor de metadatos de Compute o creando un JWT autofirmado e intercambiándolo por un token de ID firmado por Google.

Usar el servidor de metadatos

Puedes usar el servidor de metadatos de Compute para obtener tokens de ID con una audiencia específica de la siguiente manera:

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

Sustituye AUDIENCE por la URL de la función que estás invocando. Puedes obtener esta URL tal como se describe en la sección Autenticación de pruebas de desarrolladores de este artículo.

Intercambiar un JWT autofirmado por un token de ID firmado por Google

1. Asigna el rol Invocador (roles/cloudfunctions.invoker) a la cuenta de servicio de la función que llama en la función receptora.

2. Crea una cuenta de servicio y una clave y descarga el archivo con la clave privada (en formato JSON) en el host desde el que la función o el servicio que llama realiza sus solicitudes.

3. Crea un JWT con el encabezado definido como {"alg":"RS256","typ":"JWT"}. La carga útil debe incluir una reclamación target_audience definida como la URL de la función receptora, así como las reclamaciones iss y sub definidas como la dirección de correo de la cuenta de servicio utilizada anteriormente. También debe incluir las reclamaciones exp y iat. La reclamación aud debe tener el valor https://www.googleapis.com/oauth2/v4/token.

4. Usa la clave privada que has descargado anteriormente para firmar el JWT.

5. Con este JWT, envía una solicitud POST a https://www.googleapis.com/oauth2/v4/token. Los datos de autenticación deben incluirse en el encabezado y el cuerpo de la solicitud.

   En el encabezado:

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

   En el cuerpo:

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

   Sustituye $JWT por el JWT que acabas de crear.

   De esta forma, se devuelve otro JWT que incluye un id_token firmado por Google.

Envía tu solicitud GET/POST a la función receptora. Incluye el token de ID firmado por Google en un encabezado Authorization: Bearer ID_TOKEN_JWT de la solicitud.

Siguientes pasos

• Consulta cómo gestionar el acceso a las funciones.

• Obtén ayuda con otras formas de generar tokens de ID.