Authentifier des charges de travail auprès des API Google Cloud à l'aide de comptes de service

Cette page explique comment utiliser des comptes de service pour permettre aux applications s'exécutant sur vos instances de machine virtuelle (VM) de s'authentifier auprès des API Google Cloud et pour autoriser l'accès aux ressources.

Pour vous authentifier à l'aide de comptes de service, vous devez d'abord vous assurer que votre VM est configurée. Pour ce faire, effectuez l'une des procédures suivantes :

Avant de commencer

  • Consultez la Présentation des comptes de service.
  • Si ce n'est pas déjà fait, configurez l'authentification. L'authentification est le processus permettant de valider votre identité pour accéder aux services et aux API Google Cloud. Pour exécuter du code ou des exemples depuis un environnement de développement local, vous pouvez vous authentifier auprès de Compute Engine comme suit :

    Pour utiliser les exemples Python de cette page dans un environnement de développement local, installez et initialisez gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.

    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.

    Pour en savoir plus, consultez Set up authentication for a local development environment.

Présentation

Une fois que vous avez configuré une instance de VM pour qu'elle s'exécute à l'aide d'un compte de service, une application exécutée sur cette instance peut utiliser l'une des méthodes d'authentification suivantes :

Authentifier des applications à l'aide des identifiants du compte de service

Après avoir configuré une instance à exécuter en tant que compte de service, vous pouvez utiliser les identifiants du compte de service pour authentifier les applications en cours d'exécution sur l'instance.

Authentifier des applications avec une bibliothèque cliente

Les bibliothèques clientes peuvent utiliser les identifiants par défaut de l'application pour s'authentifier auprès des API Google et envoyer des requêtes à ces API. Les identifiants par défaut d'application permettent aux applications d'obtenir des identifiants de plusieurs sources. Vous pouvez ainsi tester votre application localement, puis la déployer sur une instance Compute Engine sans modifier le code de l'application.

Pour en savoir plus sur la configuration des identifiants par défaut d'une application, consultez Configurer les identifiants par défaut de l'application.

Cet exemple utilise la bibliothèque cliente Python pour s'authentifier et envoyer une requête à l'API Cloud Storage afin de lister les buckets d'un projet. L'exemple utilise la procédure suivante :

  1. Obtenez les identifiants nécessaires pour l'API Cloud Storage, et initialisez le service Cloud Storage à l'aide de la méthode build() et des identifiants.
  2. Répertoriez les buckets dans Cloud Storage.

Vous pouvez exécuter cet exemple sur une instance ayant accès à la gestion des buckets dans Cloud Storage.

compute/auth/application_default.py 
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)

Authentifier des applications directement avec les jetons d'accès

Pour la plupart des applications, vous pouvez effectuer l'authentification via Identifiants par défaut de l'application, qui recherche les identifiants et gère les jetons à votre place. Toutefois, si votre application nécessite que vous lui fournissiez un jeton d'accès OAuth2, vous pouvez en obtenir un auprès du serveur de métadonnées de Compute Engine et l'utiliser dans votre application.

Il existe plusieurs manières d'obtenir et d'utiliser ces jetons d'accès pour authentifier vos applications. Par exemple, vous pouvez exploiter curl pour créer une requête simple ou utiliser un langage de programmation tel que Python pour plus de flexibilité.

cURL

Pour demander un jeton d'accès et envoyer une requête à une API à l'aide de curl, procédez comme suit :

  1. Sur l'instance sur laquelle votre application s'exécute, exécutez la commande suivante pour interroger le serveur de métadonnées et obtenir un jeton d'accès :

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

    La requête renvoie une réponse semblable à celle-ci :

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

    Pour les requêtes API, vous devez inclure la valeur access_token, et non l'intégralité de la réponse. Si le processeur JSON de ligne de commande jq est installé, vous pouvez utiliser la commande suivante pour extraire la valeur du jeton d'accès de la réponse :

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

  2. Copiez la valeur de la propriété access_token de la réponse et utilisez-la pour envoyer des requêtes à l'API. Par exemple, la requête suivante affiche la liste des instances de votre projet dans une zone donnée :

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

    Remplacez les éléments suivants :

    • PROJECT_ID : ID du projet pour cette requête.
    • ZONE : zone à partir de laquelle répertorier les VM
    • ACCESS_TOKEN : valeur du jeton d'accès obtenue à l'étape précédente.

    Pour plus d'informations sur les paramètres que vous pouvez définir dans votre requête, consultez la documentation relative aux paramètres système.

Python

Cet exemple montre comment demander un jeton permettant d'accéder à l'API Cloud Storage dans une application Python. L'exemple utilise la procédure suivante :

  1. Demande d'un jeton d'accès au serveur de métadonnées
  2. Récupération du jeton d'accès à partir de la réponse du serveur
  3. Utilisation du jeton d'accès pour envoyer une requête à Google Cloud Storage
  4. Si la requête aboutit, le script affiche la réponse
compute/auth/access_token.py 

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)

Les jetons d'accès expirent après une courte période. Le serveur de métadonnées met en cache les jetons d'accès jusqu'à ce qu'il ne reste plus que cinq minutes avant leur expiration. Si les jetons ne peuvent pas être mis en cache, le débit des requêtes dépassant 50 requêtes par seconde peut être limité. Vos applications doivent disposer d'un jeton d'accès valide pour que leurs appels d'API aboutissent.

Outils d'authentification sur une instance utilisant un compte de service

Certaines applications peuvent utiliser des commandes des outils gcloud et gsutil, qui sont incluses par défaut dans la plupart des images Compute Engine. Ces outils reconnaissent automatiquement le compte de service d'une instance et les autorisations correspondantes accordées au compte de service. Plus précisément, si vous attribuez les rôles appropriés au compte de service, vous pouvez utiliser les outils gcloud et gsutil à partir de vos instances sans avoir à employer gcloud auth login.

Cette reconnaissance de compte de service est effectuée automatiquement et ne s'applique qu'aux outils gcloud et gsutil inclus dans l'instance. Si vous créez des outils ou ajoutez des outils personnalisés, vous devez autoriser votre application à l'aide d'une bibliothèque cliente ou en utilisant des jetons d'accès directement dans votre application.

Pour tirer parti de la reconnaissance automatique des comptes de service, accordez les rôles IAM appropriés au compte de service et associez le compte de service à l'instance. Par exemple, si vous attribuez le rôle roles/storage.objectAdmin à un compte de service, l'outil gsutil peut gérer et accéder automatiquement aux objets Cloud Storage.

De même, si vous activez roles/compute.instanceAdmin.v1 pour le compte de service, l'outil gcloud compute peut gérer automatiquement les instances.

Étapes suivantes

Faites l'essai

Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de Compute Engine en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits offerts pour exécuter, tester et déployer des charges de travail.

Profiter d'un essai gratuit de Compute Engine