Authentification en tant que compte de service

Cet article explique comment authentifier une application en tant que compte de service. Pour obtenir des informations générales sur l'authentification auprès des API Google Cloud, y compris les scénarios et les stratégies d'authentification courants, consultez la page Présentation de l'authentification. Pour en savoir plus sur les comptes de service, consultez la section Comptes de service dans la documentation sur la gestion de l'authentification et des accès.

Rechercher automatiquement des identifiants

Si votre application s'exécute dans un environnement Google Cloud et que vous avez associé un compte de service à cet environnement, votre application peut récupérer les identifiants du compte de service. L'application peut ensuite utiliser ces identifiants pour appeler les API Google Cloud.

Vous pouvez associer des comptes de service à des ressources pour de nombreux services Google Cloud, dont Compute Engine, Google Kubernetes Engine, App Engine, Cloud Run et Cloud Functions. Nous vous recommandons d'utiliser cette stratégie car elle est plus pratique et plus sécurisée que la transmission manuelle des identifiants.

En outre, nous vous recommandons d'utiliser les bibliothèques clientes Google Cloud pour votre application. Les bibliothèques clientes Google Cloud utilisent une bibliothèque appelée "Application Default Credentials" (ADC) pour rechercher automatiquement vos identifiants de compte de service. L'ADC recherche les identifiants du compte de service dans l'ordre suivant :

  1. Si la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS est définie, ADC utilise la clé de compte de service ou le fichier de configuration vers lequel renvoie la variable.

  2. Si la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS n'est pas définie, ADC utilise le compte de service associé à la ressource qui exécute votre code.

    Ce compte de service peut être un compte de service par défaut fourni par Compute Engine, Google Kubernetes Engine, App Engine, Cloud Run ou Cloud Functions. Il peut également s'agir d'un compte de service géré par l'utilisateur que vous avez créé.

  3. Si ADC ne peut utiliser aucune des informations d'identification ci-dessus, une erreur se produit.

L'exemple de code suivant montre comment utiliser la bibliothèque ADC dans le code de votre application. Pour exécuter cet exemple, vous devez installer la bibliothèque cliente Cloud Storage.

C#

public object AuthImplicit(string projectId)
{
    // If you don't specify credentials when constructing the client, the
    // client library will look for credentials in the environment.
    var credential = GoogleCredential.GetApplicationDefault();
    var storage = StorageClient.Create(credential);
    // Make an authenticated API request.
    var buckets = storage.ListBuckets(projectId);
    foreach (var bucket in buckets)
    {
        Console.WriteLine(bucket.Name);
    }
    return null;
}

Go


// implicit uses Application Default Credentials to authenticate.
func implicit() {
	ctx := context.Background()

	// For API packages whose import path is starting with "cloud.google.com/go",
	// such as cloud.google.com/go/storage in this case, if there are no credentials
	// provided, the client library will look for credentials in the environment.
	storageClient, err := storage.NewClient(ctx)
	if err != nil {
		log.Fatal(err)
	}
	defer storageClient.Close()

	it := storageClient.Buckets(ctx, "project-id")
	for {
		bucketAttrs, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			log.Fatal(err)
		}
		fmt.Println(bucketAttrs.Name)
	}

	// For packages whose import path is starting with "google.golang.org/api",
	// such as google.golang.org/api/cloudkms/v1, use NewService to create the client.
	kmsService, err := cloudkms.NewService(ctx)
	if err != nil {
		log.Fatal(err)
	}

	_ = kmsService
}

Java

static void authImplicit() {
  // If you don't specify credentials when constructing the client, the client library will
  // look for credentials via the environment variable GOOGLE_APPLICATION_CREDENTIALS.
  Storage storage = StorageOptions.getDefaultInstance().getService();

  System.out.println("Buckets:");
  Page<Bucket> buckets = storage.list();
  for (Bucket bucket : buckets.iterateAll()) {
    System.out.println(bucket.toString());
  }
}

Node.js

// Imports the Google Cloud client library.
const {Storage} = require('@google-cloud/storage');

// Instantiates a client. If you don't specify credentials when constructing
// the client, the client library will look for credentials in the
// environment.
const storage = new Storage();
// Makes an authenticated API request.
async function listBuckets() {
  try {
    const results = await storage.getBuckets();

    const [buckets] = results;

    console.log('Buckets:');
    buckets.forEach(bucket => {
      console.log(bucket.name);
    });
  } catch (err) {
    console.error('ERROR:', err);
  }
}
listBuckets();

PHP

// Imports the Cloud Storage client library.
use Google\Cloud\Storage\StorageClient;

/**
 * Authenticate to a cloud client library using a service account implicitly.
 *
 * @param string $projectId The Google project ID.
 */
function auth_cloud_implicit($projectId)
{
    $config = [
        'projectId' => $projectId,
    ];

    # If you don't specify credentials when constructing the client, the
    # client library will look for credentials in the environment.
    $storage = new StorageClient($config);

    # Make an authenticated API request (listing storage buckets)
    foreach ($storage->buckets() as $bucket) {
        printf('Bucket: %s' . PHP_EOL, $bucket->name());
    }
}

Python

def implicit():
    from google.cloud import storage

    # If you don't specify credentials when constructing the client, the
    # client library will look for credentials in the environment.
    storage_client = storage.Client()

    # Make an authenticated API request
    buckets = list(storage_client.list_buckets())
    print(buckets)

Ruby

# project_id = "Your Google Cloud project ID"

require "google/cloud/storage"

# If you don't specify credentials when constructing the client, the client
# library will look for credentials in the environment.
storage = Google::Cloud::Storage.new project: project_id

# Make an authenticated API request
storage.buckets.each do |bucket|
  puts bucket.name
end

Transmettre manuellement des identifiants

Si votre application s'exécute dans un environnement sans compte de service associé, tel qu'un environnement sur site ou un autre fournisseur cloud, vous devez utiliser la fédération d'identité de charge de travail.

Si vous ne pouvez pas utiliser la fédération d'identité de charge de travail, vous devez créer un compte de service et une ou plusieurs clés de compte de service, qui sont des identifiants associés au compte de service. Les clés de compte de service peuvent ensuite être transmises manuellement à votre application.

Assurez-vous de consulter les bonnes pratiques pour gérer les clés de compte de service.

Créer un compte de service

Les étapes suivantes décrivent comment créer un compte de service si vous n'en avez pas :

Console

Créez un compte de service :

  1. Dans Cloud Console, accédez à la page Créer un compte de service.

    Accéder à la page "Créer un compte de service"
  2. Sélectionnez votre projet.

  3. Dans le champ Nom du compte de service, saisissez un nom. Cloud Console remplit le champ ID du compte de service en fonction de ce nom.

    Dans le champ Description du compte de service, saisissez une description. Exemple : Service account for quickstart.

  4. Cliquez sur Créer et continuer.

  5. Pour accorder l'accès à votre projet, attribuez le ou les rôles suivants à votre compte de service : Projet > Propriétaire.

    Dans la liste Sélectinoner un rôle, sélectionnez un rôle.

    Pour ajouter des rôles supplémentaires, cliquez sur Ajouter un autre rôle et ajoutez chaque rôle supplémentaire.

  6. Cliquez sur Continuer.

  7. Cliquez sur OK pour terminer la création du compte de service.

    Ne fermez pas la fenêtre de votre navigateur. Vous en aurez besoin lors de la tâche suivante.

Créez une clé de compte de service :

  1. Dans Cloud Console, cliquez sur l'adresse e-mail du compte de service que vous avez créé.
  2. Cliquez sur Keys (Clés).
  3. Cliquez sur Ajouter une clé, puis sur Créer une clé.
  4. Cliquez sur Create (Créer). Un fichier de clé JSON est téléchargé sur votre ordinateur.
  5. Cliquez sur Close (Fermer).

gcloud

Configurez l'authentification :

  1. Créez le compte de service. Remplacez NAME par le nom que vous souhaitez donner au compte de service : 

    gcloud iam service-accounts create NAME

  2. Attribuez des rôles au compte de service. Exécutez la commande suivante une fois pour chacun des rôles IAM suivants : roles/owner : 

    gcloud projects add-iam-policy-binding PROJECT_ID --member="serviceAccount:NAME@PROJECT_ID.iam.gserviceaccount.com" --role=ROLE

    Remplacez les éléments suivants :

    • NAME : nom du compte de service.
    • PROJECT_ID: ID du projet dans lequel vous avez créé le compte de service.
    • ROLE: rôle à accorder

  3. Générez le fichier de clé : 

    gcloud iam service-accounts keys create FILE_NAME.json --iam-account=NAME@PROJECT_ID.iam.gserviceaccount.com

    Remplacez les éléments suivants :

    • FILE_NAME: nom du fichier de clé
    • NAME : nom du compte de service.
    • PROJECT_ID: ID du projet dans lequel vous avez créé le compte de service.

Transmettre des identifiants via une variable d'environnement

Fournissez des identifiants d'authentification au code de votre application en définissant la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS. Cette variable ne s'applique qu'à la session d'interface système actuelle. Si vous souhaitez que la variable s'applique aux sessions d'interface système futures, définissez-la dans votre fichier de démarrage de l'interface système, par exemple dans le fichier ~/.bashrc ou ~/.profile.

Linux ou macOS

export GOOGLE_APPLICATION_CREDENTIALS="KEY_PATH"

Remplacez KEY_PATH par le chemin du fichier JSON contenant la clé de votre compte de service.

Exemple :

export GOOGLE_APPLICATION_CREDENTIALS="/home/user/Downloads/service-account-file.json"

Windows

Pour PowerShell :

$env:GOOGLE_APPLICATION_CREDENTIALS="KEY_PATH"

Remplacez KEY_PATH par le chemin du fichier JSON contenant la clé de votre compte de service.

Exemple :

$env:GOOGLE_APPLICATION_CREDENTIALS="C:\Users\username\Downloads\service-account-file.json"

Pour l'invite de commande :

set GOOGLE_APPLICATION_CREDENTIALS=KEY_PATH

Remplacez KEY_PATH par le chemin du fichier JSON contenant la clé de votre compte de service.

Une fois que vous avez terminé les étapes ci-dessus, l'ADC peut trouver automatiquement vos identifiants, comme décrit dans la section ci-dessus. Nous vous recommandons d'utiliser la stratégie ADC, car elle nécessite moins de code et rend votre code portable dans environnements différents.

Transmettre des identifiants grâce à du code

Vous pouvez également choisir de renvoyer explicitement vers votre fichier de compte de service, directement dans le code comme indiqué dans l'exemple suivant. Vous devez installer la bibliothèque cliente Cloud Storage pour exécuter l'exemple suivant.

C#

        // Some APIs, like Storage, accept a credential in their Create()
        // method.
        public object AuthExplicit(string projectId, string jsonPath)
        {
            // Explicitly use service account credentials by specifying
            // the private key file.
            var credential = GoogleCredential.FromFile(jsonPath);
            var storage = StorageClient.Create(credential);
            // Make an authenticated API request.
            var buckets = storage.ListBuckets(projectId);
            foreach (var bucket in buckets)
            {
                Console.WriteLine(bucket.Name);
            }
            return null;
        }
        // Other APIs, like Language, accept a channel in their Create()
        // method.
        public object AuthExplicit(string projectId, string jsonPath)
        {
            LanguageServiceClientBuilder builder = new LanguageServiceClientBuilder
            {
                CredentialsPath = jsonPath
            };

            LanguageServiceClient client = builder.Build();
            AnalyzeSentiment(client);
            return 0;
        }

Go


// explicit reads credentials from the specified path.
func explicit(jsonPath, projectID string) {
	ctx := context.Background()
	client, err := storage.NewClient(ctx, option.WithCredentialsFile(jsonPath))
	if err != nil {
		log.Fatal(err)
	}
	defer client.Close()
	fmt.Println("Buckets:")
	it := client.Buckets(ctx, projectID)
	for {
		battrs, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			log.Fatal(err)
		}
		fmt.Println(battrs.Name)
	}
}

Java

static void authExplicit(String jsonPath) throws IOException {
  // You can specify a credential file by providing a path to GoogleCredentials.
  // Otherwise credentials are read from the GOOGLE_APPLICATION_CREDENTIALS environment variable.
  GoogleCredentials credentials = GoogleCredentials.fromStream(new FileInputStream(jsonPath))
        .createScoped(Lists.newArrayList("https://www.googleapis.com/auth/cloud-platform"));
  Storage storage = StorageOptions.newBuilder().setCredentials(credentials).build().getService();

  System.out.println("Buckets:");
  Page<Bucket> buckets = storage.list();
  for (Bucket bucket : buckets.iterateAll()) {
    System.out.println(bucket.toString());
  }
}

Node.js

// Imports the Google Cloud client library.
const {Storage} = require('@google-cloud/storage');

// Instantiates a client. Explicitly use service account credentials by
// specifying the private key file. All clients in google-cloud-node have this
// helper, see https://github.com/GoogleCloudPlatform/google-cloud-node/blob/master/docs/authentication.md
// const projectId = 'project-id'
// const keyFilename = '/path/to/keyfile.json'
const storage = new Storage({projectId, keyFilename});

// Makes an authenticated API request.
async function listBuckets() {
  try {
    const [buckets] = await storage.getBuckets();

    console.log('Buckets:');
    buckets.forEach(bucket => {
      console.log(bucket.name);
    });
  } catch (err) {
    console.error('ERROR:', err);
  }
}
listBuckets();

PHP

namespace Google\Cloud\Samples\Auth;

// Imports the Cloud Storage client library.
use Google\Cloud\Storage\StorageClient;

/**
 * Authenticate to a cloud client library using a service account explicitly.
 *
 * @param string $projectId           The Google project ID.
 * @param string $serviceAccountPath  Path to service account credentials JSON.
 */
function auth_cloud_explicit($projectId, $serviceAccountPath)
{
    # Explicitly use service account credentials by specifying the private key
    # file.
    $config = [
        'keyFilePath' => $serviceAccountPath,
        'projectId' => $projectId,
    ];
    $storage = new StorageClient($config);

    # Make an authenticated API request (listing storage buckets)
    foreach ($storage->buckets() as $bucket) {
        printf('Bucket: %s' . PHP_EOL, $bucket->name());
    }
}

Python

def explicit():
    from google.cloud import storage

    # Explicitly use service account credentials by specifying the private key
    # file.
    storage_client = storage.Client.from_service_account_json(
        'service_account.json')

    # Make an authenticated API request
    buckets = list(storage_client.list_buckets())
    print(buckets)

Ruby

# project_id = "Your Google Cloud project ID"
# key_file   = "path/to/service-account.json"
require "google/cloud/storage"

# Explicitly use service account credentials by specifying the private key
# file.
storage = Google::Cloud::Storage.new project: project_id, keyfile: key_file

# Make an authenticated API request
storage.buckets.each do |bucket|
  puts bucket.name
end

Dépanner les erreurs d'API

Pour en savoir plus sur le dépannage des requêtes d'API ayant échoué, consultez la section Erreurs.

Étape suivante

Faites l'essai

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

Essai gratuit