Autenticar cargas de trabajo en las APIs de Google Cloud mediante cuentas de servicio

En esta página se describe cómo usar cuentas de servicio para permitir que las aplicaciones que se ejecutan en tus instancias de máquina virtual (VM) se autentiquen en las APIs de Google Cloud y autoricen el acceso a los recursos.

Para usar cuentas de servicio en la autenticación, primero debes asegurarte de que tu máquina virtual esté configurada para usar una cuenta de servicio. Para ello, completa uno de los siguientes procedimientos:

• Para configurar una cuenta de servicio durante la creación de una VM, consulta el artículo Crear una VM que use una cuenta de servicio gestionada por el usuario.
• Para configurar una cuenta de servicio en una VM que ya tengas, consulta Cambiar la cuenta de servicio vinculada.

Antes de empezar

• Consulta el artículo Resumen de las cuentas de servicio.
• Si aún no lo has hecho, configura la autenticación. La autenticación verifica tu identidad para acceder a Google Cloud servicios y APIs. Para ejecutar código o ejemplos desde un entorno de desarrollo local, puedes autenticarte en Compute Engine seleccionando una de las siguientes opciones:

  Para usar las Python muestras de esta página en un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, a continuación, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

  Instala Google Cloud CLI.

  Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

  If you're using a local shell, then create local authentication credentials for your user account:

  gcloud auth application-default login

  You don't need to do this if you're using Cloud Shell.

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  Para obtener más información, consulta Set up authentication for a local development environment.

Información general

Una vez que hayas configurado una instancia de VM para que se ejecute con una cuenta de servicio, una aplicación que se ejecute en la instancia de VM podrá usar uno de los siguientes métodos para autenticarse:

• En la mayoría de las aplicaciones, elige una de las siguientes opciones:
  • Usar las credenciales de aplicación predeterminadas y una biblioteca de cliente
  • Usar Google Cloud CLI
• En el caso de las aplicaciones que requieren un token de acceso OAuth2, solicita y usa tokens de acceso directamente desde el servidor de metadatos.

Autenticar aplicaciones con credenciales de cuenta de servicio

Después de configurar una instancia para que se ejecute como una cuenta de servicio, puedes usar las credenciales de la cuenta de servicio para autenticar las aplicaciones que se ejecutan en la instancia.

Autenticar aplicaciones con una biblioteca de cliente

Las bibliotecas de cliente pueden usar las credenciales predeterminadas de la aplicación para autenticarse en las APIs de Google y enviar solicitudes a esas APIs. Las credenciales predeterminadas de la aplicación permiten que las aplicaciones obtengan automáticamente credenciales de varias fuentes para que puedas probar tu aplicación de forma local y, a continuación, implementarla en una instancia de Compute Engine sin cambiar el código de la aplicación.

Para obtener información sobre cómo configurar las credenciales predeterminadas de la aplicación, consulta Proporcionar credenciales a las credenciales predeterminadas de la aplicación.

En este ejemplo se usa la biblioteca de cliente de Python para autenticar y hacer una solicitud a la API Cloud Storage con el fin de enumerar los contenedores de un proyecto. En el ejemplo se sigue el siguiente procedimiento:

1. Obtén las credenciales de autenticación necesarias para la API de Cloud Storage e inicializa el servicio de Cloud Storage con el método build() y las credenciales.
2. Lista los segmentos de Cloud Storage.

Puedes ejecutar este ejemplo en una instancia que tenga acceso para gestionar segmentos en Cloud Storage.

import argparse
from typing import List

from google.cloud import storage


def create_client() -> storage.Client:
    """
    Construct a client object for the Storage API using the
    application default credentials.

    Returns:
        Storage API client object.
    """
    # Construct the service object for interacting with the Cloud Storage API -
    # the 'storage' service, at version 'v1'.
    # Authentication is provided by application default credentials.
    # When running locally, these are available after running
    # `gcloud auth application-default login`. When running on Compute
    # Engine, these are available from the environment.
    return storage.Client()


def list_buckets(client: storage.Client, project_id: str) -> List[storage.Bucket]:
    """
    Retrieve bucket list of a project using provided client object.


    Args:
        client: Storage API client object.
        project_id: name of the project to list buckets from.

    Returns:
        List of Buckets found in the project.
    """
    buckets = client.list_buckets()
    return list(buckets)


def main(project_id: str) -> None:
    client = create_client()
    buckets = list_buckets(client, project_id)
    print(buckets)


if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter
    )
    parser.add_argument("project_id", help="Your Google Cloud Project ID.")

    args = parser.parse_args()

    main(args.project_id)

Autenticar aplicaciones directamente con tokens de acceso

En la mayoría de las aplicaciones, puedes autenticarte mediante las credenciales de aplicación predeterminadas, que buscan credenciales y gestionan tokens por ti. Sin embargo, si tu aplicación requiere que proporciones un token de acceso de OAuth 2.0, Compute Engine te permite obtener un token de acceso de su servidor de metadatos para usarlo en tu aplicación.

Hay varias opciones para obtener y usar estos tokens de acceso para autenticar tus aplicaciones. Por ejemplo, puedes usar curl para crear una solicitud sencilla o usar un lenguaje de programación como Python para tener más flexibilidad.

import argparse

import requests


METADATA_URL = "http://metadata.google.internal/computeMetadata/v1/"
METADATA_HEADERS = {"Metadata-Flavor": "Google"}
SERVICE_ACCOUNT = "default"


def get_access_token() -> str:
    """
    Retrieves access token from the metadata server.

    Returns:
        The access token.
    """
    url = f"{METADATA_URL}instance/service-accounts/{SERVICE_ACCOUNT}/token"

    # Request an access token from the metadata server.
    r = requests.get(url, headers=METADATA_HEADERS)
    r.raise_for_status()

    # Extract the access token from the response.
    access_token = r.json()["access_token"]

    return access_token


def list_buckets(project_id: str, access_token: str) -> dict:
    """
    Calls Storage API to retrieve a list of buckets.

    Args:
        project_id: name of the project to list buckets from.
        access_token: access token to authenticate with.

    Returns:
        Response from the API.
    """
    url = "https://www.googleapis.com/storage/v1/b"
    params = {"project": project_id}
    headers = {"Authorization": f"Bearer {access_token}"}

    r = requests.get(url, params=params, headers=headers)
    r.raise_for_status()

    return r.json()


def main(project_id: str) -> None:
    """
    Retrieves access token from metadata server and uses it to list
    buckets in a project.

    Args:
        project_id: name of the project to list buckets from.
    """
    access_token = get_access_token()
    buckets = list_buckets(project_id, access_token)
    print(buckets)


if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter
    )
    parser.add_argument("project_id", help="Your Google Cloud project ID.")

    args = parser.parse_args()

    main(args.project_id)

Los tokens de acceso caducan al cabo de un breve periodo. El servidor de metadatos almacena en caché los tokens de acceso hasta que les queden 5 minutos antes de caducar. Si no se pueden almacenar en caché los tokens, es posible que se limite la frecuencia de las solicitudes que superen las 50 consultas por segundo. Tus aplicaciones deben tener un token de acceso válido para que sus llamadas a la API se realicen correctamente.

Autenticar herramientas en una instancia mediante una cuenta de servicio

Algunas aplicaciones pueden usar comandos de la CLI de gcloud, que se incluye de forma predeterminada en la mayoría de las imágenes de Compute Engine. La CLI de gcloud reconoce automáticamente la cuenta de servicio de una instancia y los permisos relevantes concedidos a la cuenta de servicio. En concreto, si asignas los roles correctos a la cuenta de servicio, puedes usar la interfaz de línea de comandos gcloud desde tus instancias sin tener que usar gcloud auth login.

El reconocimiento de la cuenta de servicio se produce automáticamente y solo se aplica a la CLI de gcloud incluida en la instancia. Si creas herramientas nuevas o añades herramientas personalizadas, debes autorizar tu aplicación mediante una biblioteca de cliente o usando tokens de acceso directamente en tu aplicación.

Para aprovechar el reconocimiento automático de cuentas de servicio, asigna los roles de gestión de identidades y accesos adecuados a la cuenta de servicio y asocia la cuenta de servicio a la instancia. Por ejemplo, si asignas el rol roles/storage.objectAdmin a una cuenta de servicio, la CLI de gcloud puede gestionar y acceder automáticamente a objetos de Cloud Storage.

Del mismo modo, si habilitas roles/compute.instanceAdmin.v1 en la cuenta de servicio, la herramienta gcloud compute podrá gestionar las instancias automáticamente.

Siguientes pasos

• Autenticar cargas de trabajo en otras cargas de trabajo mediante mTLS .
• Consulta más información sobre las cuentas de servicio.
• Consulta más información sobre los roles y permisos de gestión de identidades y accesos de Compute Engine.
• Consulta más información sobre las prácticas recomendadas para trabajar con cuentas de servicio.