Autentica cargas de trabajo en la APIs de Google Cloud a través de cuentas de servicio

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

Si quieres usar cuentas de servicio para la autenticación, primero debes asegurarte de que tu VM esté configurada para usar una cuenta de servicio. Para ello, completa uno de los siguientes procedimientos:

Antes de comenzar

  • Revisa la Descripción general de las cuentas de servicio.
  • Si aún no lo hiciste, configura la autenticación. La autenticación es el proceso mediante el cual se verifica tu identidad para acceder a los servicios y las API de Google Cloud. Para ejecutar código o muestras desde un entorno de desarrollo local, puedes autenticarte en Compute Engine seleccionando una de las siguientes opciones:

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

    1. Install the Google Cloud CLI.

    2. To initialize the gcloud CLI, run the following command: 

      gcloud init

    3. 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.

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

Descripción general

Después de configurar una instancia de VM para que se ejecute con una cuenta de servicio, una aplicación que se ejecuta en la instancia de VM puede usar uno de los siguientes métodos de autenticación:

Autentica aplicaciones mediante credenciales de cuenta de servicio

Después de configurar una instancia con el fin de 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.

Autentica aplicaciones con una biblioteca cliente

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

Para obtener información sobre la configuración de las credenciales predeterminadas de la aplicación, consulta Proporciona credenciales para las credenciales predeterminadas de la aplicación.

En este ejemplo, se usa la biblioteca cliente de Python para autenticar y realizar una solicitud a la API de Cloud Storage con el fin de generar una lista de los depósitos en un proyecto. En el ejemplo, se usa el siguiente procedimiento:

  1. Obtener las credenciales de autenticación necesarias para la API de Cloud Storage y, a continuación, inicializar el servicio de Cloud Storage con el método build() y las credenciales
  2. Enumerar los depósitos en Cloud Storage

Puedes ejecutar este ejemplo en una instancia que tenga acceso para administrar depósitos 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)

Autentica aplicaciones directamente con tokens de acceso

Para la mayoría de las aplicaciones, puedes autenticarte con las credenciales predeterminadas de la aplicación, que encuentra las credenciales y administra los tokens por ti. Sin embargo, si la aplicación requiere que proporciones un token de acceso de OAuth2, Compute Engine te permite obtener un token de acceso del servidor de metadatos para usarlo en la aplicación.

Hay varias opciones para obtener y usar estos tokens de acceso con el objetivo de autenticar tus aplicaciones. Por ejemplo, puedes usar curl para crear una solicitud simple o usar un lenguaje de programación, como Python, para lograr una mayor flexibilidad.

cURL

Para usar curl con el fin de solicitar un token de acceso y enviar una solicitud a una API, sigue estos pasos:

  1. En la instancia donde se ejecuta tu aplicación, usa el siguiente comando para realizar una consulta al servidor de metadatos con el fin de obtener un token de acceso:

    $ curl "http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token" \
-H "Metadata-Flavor: Google"

    La solicitud muestra una respuesta similar a la siguiente:

    {
      "access_token":"ya29.AHES6ZRN3-HlhAPya30GnW_bHSb_QtAS08i85nHq39HE3C2LTrCARA",
      "expires_in":3599,
      "token_type":"Bearer"
 }

    Para las solicitudes a la API, debes incluir el valor access_token, no toda la respuesta. Si tienes instalado el procesador JSON de la línea de comandos de jq, puedes usar el siguiente comando para extraer el valor del token de acceso de la respuesta:

    $ ACCESS_TOKEN=`curl \
"http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token" \
-H "Metadata-Flavor: Google" | jq -r '.access_token'`

  2. Copia el valor de la propiedad access_token de la respuesta y úsalo para enviar solicitudes a la API. Por ejemplo, la siguiente solicitud imprime una lista de instancias de tu proyecto desde una zona determinada:

    $ curl https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances \
-H "Authorization":"Bearer ACCESS_TOKEN"

    Reemplaza lo siguiente:

    • PROJECT_ID: el ID del proyecto de esta solicitud.
    • ZONE: la zona desde la cual se enumeran las VMs.
    • ACCESS_TOKEN: el valor del token de acceso que obtuviste en el paso anterior.

    Para obtener información sobre los parámetros que puedes configurar en tu solicitud, consulta el documento de los parámetros del sistema.

Python

En este ejemplo, se muestra cómo solicitar un token para acceder a la API de Cloud Storage en una aplicación de Python. En el ejemplo, se usa el siguiente procedimiento:

  1. Solicitar un token de acceso al servidor de metadatos
  2. Extrae el token de acceso de la respuesta del servidor.
  3. Usa el token de acceso para realizar una solicitud a Cloud Storage.
  4. Si la solicitud es exitosa, la secuencia de comandos imprime la respuesta

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 vencen después de un período corto. El servidor de metadatos almacena en caché los tokens de acceso hasta que queden 5 minutos de tiempo restante antes de que venzan. Si los tokens no se pueden almacenar en caché, 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 tengan éxito.

Autentica herramientas en una instancia mediante una cuenta de servicio

Algunas aplicaciones pueden usar comandos de gcloud CLI que está incluido de forma predeterminada en la mayoría de las imágenes de Compute Engine. gcloud CLI reconoce de forma automática la cuenta de servicio de una instancia y los permisos relevantes otorgados a la cuenta de servicio. De manera específica, si otorgas los roles correctos a la cuenta de servicio, podrás usar gcloud CLI desde de tus instancias sin necesidad de emplear gcloud auth login.

Este reconocimiento de cuenta de servicio se realiza automáticamente y se aplica solo a gcloud CLI que se incluye con la instancia. Si creas herramientas nuevas o agregas herramientas personalizadas, debes autorizar tu aplicación mediante una biblioteca cliente o mediante tokens de acceso directamente en tu aplicación.

Para aprovechar el reconocimiento automático de la cuenta de servicio, otorga los roles de IAM adecuados a esa cuenta y conecta la cuenta de servicio a la instancia. Por ejemplo, si otorgas el rol roles/storage.objectAdmin a una cuenta de servicio, gcloud CLI puede administrar y acceder automáticamente a los objetos de Cloud Storage.

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

¿Qué sigue?

Pruébalo tú mismo

Si es la primera vez que usas Google Cloud, crea una cuenta para evaluar el rendimiento de Compute Engine en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

Probar Compute Engine gratis