Créer et gérer les clés de comptes de service

Cette page explique comment créer et gérer des clés de compte de service à l'aide de Google Cloud Console, de l'outil de ligne de commande gcloud, de l'API Identity and Access Management ou de l'une des bibliothèques clientes Google Cloud.

Avant de commencer

Autorisations requises

Pour permettre à un utilisateur de gérer les clés de compte de service, attribuez-lui le rôle Administrateur de clés de compte de service (roles/iam.serviceAccountKeyAdmin). Pour en savoir plus, consultez la section Rôles des comptes de service.

Les rôles de base IAM contiennent également les autorisations nécessaires pour gérer les clés de compte de service. Les rôles de base ne doivent pas être attribués dans un environnement de production, mais ils peuvent être attribués dans un environnement de développement ou de test.

Créer des clés de compte de service

Pour utiliser un compte de service en dehors de Google Cloud, par exemple à partir d'autres plates-formes ou sur site, vous devez d'abord établir l'identité du compte de service. Pour ce faire, un moyen sûr consiste à utiliser les paires de clés publique/privée. Lorsque vous créez une clé de compte de service, la partie publique est stockée sur Google Cloud, tandis que la partie privée n'est disponible que pour vous. Pour en savoir plus sur les paires de clés publiques/privées, consultez la page Clés de compte de service.

Pour créer une clé de compte de service, vous pouvez utiliser Cloud Console, l'outil gcloud, la méthode serviceAccounts.keys.create() ou l'une des bibliothèques clientes. Un compte de service peut compter jusqu'à 10 clés.

Dans les exemples ci-dessous, sa-name est le nom de votre compte de service et project-id est l'ID de votre projet Google Cloud. Vous pouvez récupérer la chaîne sa-name@project-id.iam.gserviceaccount.com à partir de la page Comptes de service de Cloud Console.

Console

  1. Dans Cloud Console, accédez à la page Comptes de service.

    Accéder à la page "Comptes de service"

  2. Sélectionnez un projet.

  3. Cliquez sur l'adresse e-mail du compte de service pour lequel vous souhaitez créer une clé.

  4. Cliquez sur l'onglet Clés.

  5. Cliquez sur le menu déroulant Ajouter une clé, puis sélectionnez Créer une clé.

  6. Sélectionnez JSON comme Type de clé et cliquez sur Create (Créer).

Cliquez sur Créer pour télécharger un fichier de clé de compte de service. Une fois téléchargé, vous ne pouvez plus le télécharger à nouveau.

La clé téléchargée est au format suivant, où private-key correspond à la partie privée de la paire de clés publique/privée :

{
  "type": "service_account",
  "project_id": "project-id",
  "private_key_id": "key-id",
  "private_key": "-----BEGIN PRIVATE KEY-----\nprivate-key\n-----END PRIVATE KEY-----\n",
  "client_email": "service-account-email",
  "client_id": "client-id",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://accounts.google.com/o/oauth2/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/service-account-email"
}

Veillez à stocker le fichier de clé en toute sécurité, car il peut être utilisé pour s'authentifier en tant que compte de service. Vous pouvez déplacer et renommer ce fichier comme vous le souhaitez.

Vous pouvez utiliser des fichiers de clé de compte de service pour authentifier une application en tant que compte de service.

gcloud

Exécutez la commande gcloud iam service-accounts keys create pour créer des clés de compte de service.

Remplacez les valeurs suivantes :

  • key-file : chemin d'accès à un nouveau fichier de sortie destiné à la clé privée, par exemple ~/sa-private-key.json.
  • sa-name : nom du compte de service pour lequel créer une clé.
  • project-id : ID de votre projet Google Cloud.
gcloud iam service-accounts keys create key-file \
    --iam-account=sa-name@project-id.iam.gserviceaccount.com

Sortie :

created key [e44da1202f82f8f4bdd9d92bc412d1d8a837fa83] of type [json] as
[/usr/home/username/key-file] for
[sa-name@project-id.iam.gserviceaccount.com]

Le fichier de clé du compte de service est maintenant téléchargé sur votre ordinateur. Une fois téléchargé, vous ne pouvez plus le télécharger à nouveau.

La clé téléchargée est au format suivant, où private-key correspond à la partie privée de la paire de clés publique/privée :

{
  "type": "service_account",
  "project_id": "project-id",
  "private_key_id": "key-id",
  "private_key": "-----BEGIN PRIVATE KEY-----\nprivate-key\n-----END PRIVATE KEY-----\n",
  "client_email": "service-account-email",
  "client_id": "client-id",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://accounts.google.com/o/oauth2/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/service-account-email"
}

Veillez à stocker le fichier de clé en toute sécurité, car il peut être utilisé pour s'authentifier en tant que compte de service. Vous pouvez déplacer et renommer ce fichier comme vous le souhaitez.

Vous pouvez utiliser des fichiers de clé de compte de service pour authentifier une application en tant que compte de service.

REST

La méthode projects.serviceAccounts.keys.create crée une clé pour un compte de service.

Avant d'utiliser les données de requête, effectuez les remplacements suivants :

  • PROJECT_ID : ID de votre projet Google Cloud. Les ID de projet sont des chaînes alphanumériques, telles que my-project.
  • SA_NAME : nom du compte de service pour lequel vous souhaitez créer une clé.
  • KEY_ALGORITHM : facultatif. Algorithme de clé à utiliser pour la clé. La valeur par défaut, susceptible d'être modifiée, est une clé RSA de 2 048 bits. Pour obtenir la liste de toutes les valeurs possibles, consultez la documentation de référence sur ServiceAccountKeyAlgorithm.

Méthode HTTP et URL :

POST https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/SA_NAME@PROJECT_ID.iam.gserviceaccount.com/keys

Corps JSON de la requête :

{
  "keyAlgorithm": "KEY_ALGORITHM"
}

Pour envoyer votre requête, développez l'une des options suivantes :

La réponse contient une clé pour votre compte de service. La clé renvoyée est au format suivant, où ENCODED_PRIVATE_KEY correspond à la partie privée de la paire de clés publique/privée, encodée en base64.

{
  "name": "projects/PROJECT_ID/serviceAccounts/SERVICE_ACCOUNT_EMAIL/keys/KEY_ID",
  "privateKeyType": "TYPE_GOOGLE_CREDENTIALS_FILE",
  "privateKeyData": "ENCODED_PRIVATE_KEY",
  "validAfterTime": "DATE",
  "validBeforeTime": "DATE",
  "keyAlgorithm": "KEY_ALG_RSA_2048"
}

Pour créer un fichier de clé servant à vous authentifier en tant que compte de service, décodez les données de la clé privée et enregistrez-les dans un fichier :

Linux

Exécutez la commande suivante :

echo 'ENCODED_PRIVATE_KEY' | base64 --decode > PATH

Remplacez PATH par le chemin d'accès au fichier dans lequel vous souhaitez enregistrer la clé. Utilisez l'extension de fichier .json.

macOS

Exécutez la commande suivante :

echo 'ENCODED_PRIVATE_KEY' | base64 --decode > PATH

Remplacez PATH par le chemin d'accès au fichier dans lequel vous souhaitez enregistrer la clé. Utilisez l'extension de fichier .json.

PowerShell

  1. Enregistrez les données de clé privée encodées (ENCODED_PRIVATE_KEY) dans un fichier.

  2. Décodez le fichier à l'aide de certutil :

    certutil -decode ENCODED_FILE DECODED_FILE
    

    Remplacez les valeurs suivantes :

    • ENCODED_FILE : chemin d'accès au fichier contenant les données de clé privée encodées.
    • DECODED_FILE : chemin d'accès au fichier dans lequel vous souhaitez enregistrer la clé. Utilisez l'extension de fichier .json.

Veillez à stocker les données de la clé en toute sécurité, car elles peuvent être utilisées pour s'authentifier en tant que compte de service.

Vous pouvez utiliser des fichiers de clé de compte de service pour authentifier une application en tant que compte de service.

C++

Pour savoir comment installer et utiliser la bibliothèque cliente pour IAM, consultez la page Bibliothèques clientes IAM. Pour en savoir plus, consultez la documentation de référence de l'API Cloud IAM en langage C++.

namespace iam = ::google::cloud::iam;
return [](std::string const& name) {
  iam::IAMClient client(iam::MakeIAMConnection());
  auto response = client.CreateServiceAccountKey(
      name,
      google::iam::admin::v1::ServiceAccountPrivateKeyType::
          TYPE_GOOGLE_CREDENTIALS_FILE,
      google::iam::admin::v1::ServiceAccountKeyAlgorithm::KEY_ALG_RSA_2048);
  if (!response) throw std::runtime_error(response.status().message());
  std::cout << "ServiceAccountKey successfully created: "
            << response->DebugString() << "\n";
  return response->name();
}

C#

Pour savoir comment installer et utiliser la bibliothèque cliente pour IAM, consultez la page Bibliothèques clientes IAM. Pour en savoir plus, consultez la documentation de référence de l'API Cloud IAM en langage C#.


using System;
using Google.Apis.Auth.OAuth2;
using Google.Apis.Iam.v1;
using Google.Apis.Iam.v1.Data;

public partial class ServiceAccountKeys
{
    public static ServiceAccountKey CreateKey(string serviceAccountEmail)
    {
        var credential = GoogleCredential.GetApplicationDefault()
            .CreateScoped(IamService.Scope.CloudPlatform);
        var service = new IamService(new IamService.Initializer
        {
            HttpClientInitializer = credential
        });

        var key = service.Projects.ServiceAccounts.Keys.Create(
            new CreateServiceAccountKeyRequest(),
            "projects/-/serviceAccounts/" + serviceAccountEmail)
            .Execute();
        Console.WriteLine("Created key: " + key.Name);
        return key;
    }
}

Go

Pour savoir comment installer et utiliser la bibliothèque cliente pour IAM, consultez la page Bibliothèques clientes IAM. Pour en savoir plus, consultez la documentation de référence de l'API Cloud IAM en langage Go.

import (
	"context"
	"fmt"
	"io"

	iam "google.golang.org/api/iam/v1"
)

// createKey creates a service account key.
func createKey(w io.Writer, serviceAccountEmail string) (*iam.ServiceAccountKey, error) {
	ctx := context.Background()
	service, err := iam.NewService(ctx)
	if err != nil {
		return nil, fmt.Errorf("iam.NewService: %v", err)
	}

	resource := "projects/-/serviceAccounts/" + serviceAccountEmail
	request := &iam.CreateServiceAccountKeyRequest{}
	key, err := service.Projects.ServiceAccounts.Keys.Create(resource, request).Do()
	if err != nil {
		return nil, fmt.Errorf("Projects.ServiceAccounts.Keys.Create: %v", err)
	}
	fmt.Fprintf(w, "Created key: %v", key.Name)
	return key, nil
}

Java

Pour savoir comment installer et utiliser la bibliothèque cliente pour IAM, consultez la page Bibliothèques clientes IAM. Pour en savoir plus, consultez la documentation de référence de l'API Cloud IAM en langage Java.

import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.json.jackson2.JacksonFactory;
import com.google.api.services.iam.v1.Iam;
import com.google.api.services.iam.v1.IamScopes;
import com.google.api.services.iam.v1.model.CreateServiceAccountKeyRequest;
import com.google.api.services.iam.v1.model.ServiceAccountKey;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.Collections;

public class CreateServiceAccountKey {

  // Creates a key for a service account.
  public static void createKey(String projectId, String serviceAccountName) {
    // String projectId = "my-project-id";
    // String serviceAccountName = "my-service-account-name";

    Iam service = null;
    try {
      service = initService();
    } catch (IOException | GeneralSecurityException e) {
      System.out.println("Unable to initialize service: \n" + e.toString());
      return;
    }

    String serviceAccountEmail = serviceAccountName + "@" + projectId + ".iam.gserviceaccount.com";
    try {
      ServiceAccountKey key =
          service
              .projects()
              .serviceAccounts()
              .keys()
              .create(
                  "projects/-/serviceAccounts/" + serviceAccountEmail,
                  new CreateServiceAccountKeyRequest())
              .execute();

      System.out.println("Created key: " + key.getName());
    } catch (IOException e) {
      System.out.println("Unable to create service account key: \n" + e.toString());
    }
  }

  private static Iam initService() throws GeneralSecurityException, IOException {
    // Use the Application Default Credentials strategy for authentication. For more info, see:
    // https://cloud.google.com/docs/authentication/production#finding_credentials_automatically
    GoogleCredentials credential =
        GoogleCredentials.getApplicationDefault()
            .createScoped(Collections.singleton(IamScopes.CLOUD_PLATFORM));
    // Initialize the IAM service, which can be used to send requests to the IAM API.
    Iam service =
        new Iam.Builder(
                GoogleNetHttpTransport.newTrustedTransport(),
                JacksonFactory.getDefaultInstance(),
                new HttpCredentialsAdapter(credential))
            .setApplicationName("service-account-keys")
            .build();
    return service;
  }
}

Python

Pour savoir comment installer et utiliser la bibliothèque cliente pour IAM, consultez la page Bibliothèques clientes IAM. Pour en savoir plus, consultez la documentation de référence de l'API Cloud IAM en langage Python.

import os

from google.oauth2 import service_account
import googleapiclient.discovery

def create_key(service_account_email):
    """Creates a key for a service account."""

    credentials = service_account.Credentials.from_service_account_file(
        filename=os.environ['GOOGLE_APPLICATION_CREDENTIALS'],
        scopes=['https://www.googleapis.com/auth/cloud-platform'])

    service = googleapiclient.discovery.build(
        'iam', 'v1', credentials=credentials)

    key = service.projects().serviceAccounts().keys().create(
        name='projects/-/serviceAccounts/' + service_account_email, body={}
        ).execute()

    print('Created key: ' + key['name'])

Google fait en sorte que toutes les clés publiques de tous les comptes de service soient accessibles par tout le monde et disponibles pour vérifier les signatures créées avec la clé privée. La clé publique est accessible aux adresses suivantes :

  • Certificat x.509 : https://www.googleapis.com/service_accounts/v1/metadata/x509/sa-name@project-id.iam.gserviceaccount.com
  • Clé Web JSON (JWK) : https://www.googleapis.com/service_accounts/v1/jwk/sa-name@project-id.iam.gserviceaccount.com
  • Point de terminaison brut : https://www.googleapis.com/service_accounts/v1/metadata/raw/sa-name@project-id.iam.gserviceaccount.com

Liste des clés de compte de service

Pour répertorier les clés d'un compte de service particulier, vous pouvez utiliser Cloud Console, l'outil gcloud, la méthode serviceAccount.keys.list() ou l'une des bibliothèques clientes.

La méthode serviceAccount.keys.list() est couramment utilisée pour auditer les comptes et les clés de service. Elle permet également de créer un outil de gestion personnalisé pour les comptes de service.

Pour savoir à quel projet votre clé est associée, vous pouvez la télécharger sous forme de fichier JSON, puis consulter ce fichier.

Il est possible que des clés soient répertoriées alors que vous ne les avez pas créées. Ces clés sont utilisées par les services Google Cloud tels qu'App Engine et Compute Engine. Pour en savoir plus sur la différence entre les clés utilisateur et les clés gérées par Google Cloud, consultez la section Comprendre les comptes de service.

Console

  1. Dans Cloud Console, accédez à la page Comptes de service.

    Accéder à la page "Comptes de service"

  2. Sélectionnez un projet. Cloud Console répertorie tous les comptes de service du projet, ainsi que les clés correspondantes.

gcloud

Exécutez la commande gcloud iam service-accounts keys list pour répertorier les clés de compte de service.

Remplacez les valeurs suivantes :

  • sa-name : nom du compte de service pour lequel vous souhaitez répertorier les clés.
  • project-id : ID de votre projet Google Cloud.
gcloud iam service-accounts keys list \
    --iam-account=sa-name@project-id.iam.gserviceaccount.com

Sortie :

KEY_ID CREATED_AT EXPIRES_AT DÉSACTIVÉ
8e6e3936d7024646f8ceb39792006c07f4a9760c 2021-01-01T21:01:42Z 9999-12-31T23:59:59Z  
937c98f870f5c8db970af527aa3c12fd88b1c20a 2021-01-01T20:55:40Z 9999-12-31T23:59:59Z Vrai

REST

La méthode projects.serviceAccounts.keys.list répertorie toutes les clés d'un compte de service donné.

Avant d'utiliser les données de requête, effectuez les remplacements suivants :

  • PROJECT_ID : ID de votre projet Google Cloud. Les ID de projet sont des chaînes alphanumériques, telles que my-project.
  • SA_NAME : nom du compte de service dont vous souhaitez répertorier les clés.
  • KEY_TYPES : facultatif. Liste de types de clés séparés par une virgule que vous souhaitez inclure dans la réponse. Le type de clé indique si une clé est gérée par l'utilisateur (USER_MANAGED) ou gérée par le système (SYSTEM_MANAGED). Si aucune valeur n'est spécifiée, toutes les clés sont renvoyées.

Méthode HTTP et URL :

GET https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/SA_NAME@PROJECT_ID.iam.gserviceaccount.com/keys?keyTypes=KEY_TYPES

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
  "keys": [
    {
      "name": "projects/my-project/serviceAccounts/my-service-account@my-project.iam.gserviceaccount.com/keys/90c48f61c65cd56224a12ab18e6ee9ca9c3aee7c",
      "validAfterTime": "2020-03-04T17:39:47Z",
      "validBeforeTime": "9999-12-31T23:59:59Z",
      "keyAlgorithm": "KEY_ALG_RSA_2048",
      "keyOrigin": "GOOGLE_PROVIDED",
      "keyType": "USER_MANAGED"
    },
    {
      "name": "projects/my-project/serviceAccounts/my-service-account@my-project.iam.gserviceaccount.com/keys/e5e3800831ac1adc8a5849da7d827b4724b1fce8",
      "validAfterTime": "2020-03-31T23:50:09Z",
      "validBeforeTime": "9999-12-31T23:59:59Z",
      "keyAlgorithm": "KEY_ALG_RSA_2048",
      "keyOrigin": "GOOGLE_PROVIDED",
      "keyType": "USER_MANAGED"
    },
    {
      "name": "projects/my-project/serviceAccounts/my-service-account@my-project.iam.gserviceaccount.com/keys/b97699f042b8eee6a846f4f96259fbcd13e2682e",
      "validAfterTime": "2020-05-17T18:58:13Z",
      "validBeforeTime": "9999-12-31T23:59:59Z",
      "keyAlgorithm": "KEY_ALG_RSA_2048",
      "keyOrigin": "GOOGLE_PROVIDED",
      "keyType": "USER_MANAGED",
      "disabled": true
    }
  ]
}

C++

Pour savoir comment installer et utiliser la bibliothèque cliente pour IAM, consultez la page Bibliothèques clientes IAM. Pour en savoir plus, consultez la documentation de référence de l'API Cloud IAM en langage C++.

namespace iam = ::google::cloud::iam;
[](std::string const& service_account_name,
   std::vector<std::string> const& key_type_labels) {
  iam::IAMClient client(iam::MakeIAMConnection());
  std::vector<google::iam::admin::v1::ListServiceAccountKeysRequest::KeyType>
      key_types;
  for (auto const& type : key_type_labels) {
    if (type == "USER_MANAGED") {
      key_types.push_back(google::iam::admin::v1::
                              ListServiceAccountKeysRequest::USER_MANAGED);
    } else if (type == "SYSTEM_MANAGED") {
      key_types.push_back(google::iam::admin::v1::
                              ListServiceAccountKeysRequest::SYSTEM_MANAGED);
    }
  }
  auto response =
      client.ListServiceAccountKeys(service_account_name, key_types);
  if (!response) throw std::runtime_error(response.status().message());
  std::cout << "ServiceAccountKeys successfully retrieved: "
            << response->DebugString() << "\n";
}

C#

Pour savoir comment installer et utiliser la bibliothèque cliente pour IAM, consultez la page Bibliothèques clientes IAM. Pour en savoir plus, consultez la documentation de référence de l'API Cloud IAM en langage C#.


using System;
using System.Collections.Generic;
using Google.Apis.Auth.OAuth2;
using Google.Apis.Iam.v1;
using Google.Apis.Iam.v1.Data;

public partial class ServiceAccountKeys
{
    public static IList<ServiceAccountKey> ListKeys(string serviceAccountEmail)
    {
        var credential = GoogleCredential.GetApplicationDefault()
            .CreateScoped(IamService.Scope.CloudPlatform);
        var service = new IamService(new IamService.Initializer
        {
            HttpClientInitializer = credential
        });

        var response = service.Projects.ServiceAccounts.Keys
            .List($"projects/-/serviceAccounts/{serviceAccountEmail}")
            .Execute();
        foreach (ServiceAccountKey key in response.Keys)
        {
            Console.WriteLine("Key: " + key.Name);
        }
        return response.Keys;
    }
}

Go

Pour savoir comment installer et utiliser la bibliothèque cliente pour IAM, consultez la page Bibliothèques clientes IAM. Pour en savoir plus, consultez la documentation de référence de l'API Cloud IAM en langage Go.

import (
	"context"
	"fmt"
	"io"

	iam "google.golang.org/api/iam/v1"
)

// listKey lists a service account's keys.
func listKeys(w io.Writer, serviceAccountEmail string) ([]*iam.ServiceAccountKey, error) {
	ctx := context.Background()
	service, err := iam.NewService(ctx)
	if err != nil {
		return nil, fmt.Errorf("iam.NewService: %v", err)
	}

	resource := "projects/-/serviceAccounts/" + serviceAccountEmail
	response, err := service.Projects.ServiceAccounts.Keys.List(resource).Do()
	if err != nil {
		return nil, fmt.Errorf("Projects.ServiceAccounts.Keys.List: %v", err)
	}
	for _, key := range response.Keys {
		fmt.Fprintf(w, "Listing key: %v", key.Name)
	}
	return response.Keys, nil
}

Java

Pour savoir comment installer et utiliser la bibliothèque cliente pour IAM, consultez la page Bibliothèques clientes IAM. Pour en savoir plus, consultez la documentation de référence de l'API Cloud IAM en langage Java.

import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.json.jackson2.JacksonFactory;
import com.google.api.services.iam.v1.Iam;
import com.google.api.services.iam.v1.IamScopes;
import com.google.api.services.iam.v1.model.ServiceAccountKey;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.Collections;
import java.util.List;

public class ListServiceAccountKeys {

  // Lists all keys for a service account.
  public static void listKeys(String projectId, String serviceAccountName) {
    // String projectId = "my-project-id";
    // String serviceAccountName = "my-service-account-name";

    Iam service = null;
    try {
      service = initService();
    } catch (IOException | GeneralSecurityException e) {
      System.out.println("Unable to initialize service: \n" + e.toString());
      return;
    }

    String serviceAccountEmail = serviceAccountName + "@" + projectId + ".iam.gserviceaccount.com";
    try {
      List<ServiceAccountKey> keys =
          service
              .projects()
              .serviceAccounts()
              .keys()
              .list("projects/-/serviceAccounts/" + serviceAccountEmail)
              .execute()
              .getKeys();

      for (ServiceAccountKey key : keys) {
        System.out.println("Key: " + key.getName());
      }
    } catch (IOException e) {
      System.out.println("Unable to list service account keys: \n" + e.toString());
    }
  }

  private static Iam initService() throws GeneralSecurityException, IOException {
    // Use the Application Default Credentials strategy for authentication. For more info, see:
    // https://cloud.google.com/docs/authentication/production#finding_credentials_automatically
    GoogleCredentials credential =
        GoogleCredentials.getApplicationDefault()
            .createScoped(Collections.singleton(IamScopes.CLOUD_PLATFORM));
    // Initialize the IAM service, which can be used to send requests to the IAM API.
    Iam service =
        new Iam.Builder(
                GoogleNetHttpTransport.newTrustedTransport(),
                JacksonFactory.getDefaultInstance(),
                new HttpCredentialsAdapter(credential))
            .setApplicationName("service-account-keys")
            .build();
    return service;
  }
}

Python

Pour savoir comment installer et utiliser la bibliothèque cliente pour IAM, consultez la page Bibliothèques clientes IAM. Pour en savoir plus, consultez la documentation de référence de l'API Cloud IAM en langage Python.

import os

from google.oauth2 import service_account
import googleapiclient.discovery

def list_keys(service_account_email):
    """Lists all keys for a service account."""

    credentials = service_account.Credentials.from_service_account_file(
        filename=os.environ['GOOGLE_APPLICATION_CREDENTIALS'],
        scopes=['https://www.googleapis.com/auth/cloud-platform'])

    service = googleapiclient.discovery.build(
        'iam', 'v1', credentials=credentials)

    keys = service.projects().serviceAccounts().keys().list(
        name='projects/-/serviceAccounts/' + service_account_email).execute()

    for key in keys['keys']:
        print('Key: ' + key['name'])

Obtenir une clé de compte de service

Vous ne pouvez obtenir les données de clé privée d'une clé de compte de service qu'au moment où vous la créez.

Pour accéder aux informations de base d'une clé, telles que l'ID, l'algorithme et les données de clé publique, utilisez la méthode projects.serviceAccounts.keys.get() de l'API REST. Cloud Console et l'outil de ligne de commande gcloud ne permettent pas d'obtenir ces informations.

Importer des clés publiques pour des comptes de service

Vous pouvez importer la partie publique d'une paire de clés gérée par l'utilisateur vers un compte de service. Une fois que vous avez importé la clé publique, celle-ci est associée définitivement au compte de service et est utilisée de la même manière que les autres clés de compte de service gérées par les utilisateurs. Pour désactiver l'importation de clés pour votre projet, consultez la section Limiter l'importation des clés de compte de service.

Si vous choisissez d'utiliser une paire de clés gérée par l'utilisateur au lieu d'une paire de clés gérée par Google, veillez à la gérer et à l'alterner régulièrement.

La clé que vous importez doit être une clé publique RSA encapsulée dans un certificat X.509 v3 et encodée en base64. Vous pouvez utiliser des outils tels que OpenSSL pour générer une clé et un certificat dans ce format.

Par exemple, la commande suivante génère une paire de clés RSA de 2 048 bits et encapsule la clé publique dans un certificat autosigné qui est valide pendant 365 jours :

openssl req -x509 -nodes -newkey rsa:2048 -days 365 \
    -keyout /path/to/private_key.pem \
    -out /path/to/public_key.pem \
    -subj "/CN=unused"

Vous pouvez ensuite importer le fichier public_key.pem en tant que clé publique d'un compte de service.

Console

  1. Dans Cloud Console, accédez à la page Comptes de service.

    Accéder à la page "Comptes de service"

  2. Sélectionnez un projet.

  3. Cliquez sur l'adresse e-mail du compte de service pour lequel vous souhaitez importer une clé.

  4. Cliquez sur l'onglet Clés.

  5. Cliquez sur le menu déroulant Ajouter une clé, puis sélectionnez Importer une clé existante.

  6. Cliquez sur Parcourir, puis recherchez et sélectionnez votre fichier de clé publique. Vous pouvez également copier et coller le contenu de votre fichier de clé publique dans la zone Coller une clé existante.

  7. Cliquez sur Importer.

gcloud

Exécutez la commande gcloud iam service-accounts keys upload pour importer une clé publique permettant de signer des clés de compte de service.

Remplacez les valeurs suivantes :

  • key-file : chemin d'accès au fichier contenant les données de clé à importer (par exemple, ./public_key.pem).
  • sa-name : nom du compte de service pour lequel importer une clé.
  • project-id : ID de votre projet Google Cloud.
gcloud iam service-accounts keys upload key-file \
    --iam-account=sa-name@project-id.iam.gserviceaccount.com

Le résultat contient un identifiant unique pour la clé importée :

Name: projects/project-id/serviceAccounts/sa-name@project-id.iam.gserviceaccount.com/keys/c7b74879da78e4cdcbe7e1bf5e129375c0bfa8d0

Pour savoir si la commande a réussi, exécutez la commande gcloud iam service-accounts keys list :

gcloud iam service-accounts keys list \
    --iam-account=sa-name@project-id.iam.gserviceaccount.com

Le résultat contiendra l'identifiant unique qui a été renvoyé après la création de la clé :

KEY_ID CREATED_AT EXPIRES_AT DÉSACTIVÉ
c7b74879da78e4cdcbe7e1bf5e129375c0bfa8d0 2019-06-26T21:01:42Z 9999-12-31T23:59:59Z  

REST

La méthode projects.serviceAccounts.keys.upload importe la clé publique à partir d'une paire de clés gérée par l'utilisateur et ajoute cette clé au compte de service.

Avant d'utiliser les données de requête, effectuez les remplacements suivants :

  • PROJECT_ID : ID de votre projet Google Cloud. Les ID de projet sont des chaînes alphanumériques, telles que my-project.
  • SA_NAME : nom du compte de service auquel associer la clé.
  • PUBLIC_KEY_DATA : données de la clé publique pour la paire de clés. Il doit s'agir d'une clé publique RSA encapsulée dans un certificat X.509 v3. Encodez les données de clé publique en base64, y compris la première ligne, -----BEGIN CERTIFICATE-----, et la dernière ligne, -----END CERTIFICATE-----.

Méthode HTTP et URL :

POST https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/SA_NAME@PROJECT_ID.iam.gserviceaccount.com/keys:upload

Corps JSON de la requête :

{
  "publicKeyData": "PUBLIC_KEY_DATA"
}

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
  "name": "projects/my-project/serviceAccounts/my-service-account@my-project.iam.gserviceaccount.com/keys/c7b74879da78e4cdcbe7e1bf5e129375c0bfa8d0",
  "validAfterTime": "2020-05-17T19:31:19Z",
  "validBeforeTime": "2021-05-17T19:31:19Z",
  "keyAlgorithm": "KEY_ALG_RSA_2048",
  "keyOrigin": "USER_PROVIDED",
  "keyType": "USER_MANAGED"
}

Désactiver des clés de compte de service

La désactivation d'une clé de compte de service vous empêche d'utiliser la clé pour vous authentifier auprès des API Google. Vous pouvez réactiver une clé désactivée à tout moment.

Avant de supprimer une clé de compte de service, nous vous recommandons de la désactiver, puis de vous assurer qu'elle n'est plus nécessaire. Vous pouvez ensuite la supprimer.

Vous pouvez afficher les clés désactivées dans Cloud Console, mais vous ne pouvez pas utiliser Cloud Console pour les désactiver. Utilisez plutôt l'outil gcloud ou l'API REST.

gcloud

Exécutez la commande gcloud iam service-accounts keys disable pour désactiver un compte de service.

Remplacez les valeurs suivantes :

  • key-id : ID de la clé à désactiver.
  • sa-name : nom du compte de service auquel appartient la clé.
  • project-id : ID de votre projet Google Cloud.
gcloud iam service-accounts keys disable key-id \
    --iam-account=sa-name@project-id.iam.gserviceaccount.com

Sortie :

Disabled key [key-id] for service account
[sa-name@project-id.iam.gserviceaccount.com]

REST

La méthode projects.serviceAccounts.keys.disable désactive une clé de compte de service.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_ID : ID de votre projet Google Cloud. Les ID de projet sont des chaînes alphanumériques, telles que my-project.
  • SA_NAME : nom du compte de service dont vous souhaitez désactiver la clé.
  • KEY_ID : ID de la clé que vous souhaitez désactiver.

Méthode HTTP et URL :

POST https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/SA_NAME@PROJECT_ID.iam.gserviceaccount.com/keys/KEY_ID:disable

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
}

Activer des clés de compte de service

Après avoir désactivé une clé de compte de service, vous pouvez l'activer à tout moment, puis vous en servir pour vous authentifier auprès des API Google.

Vous ne pouvez pas activer de clés de compte de service à l'aide de Cloud Console. Utilisez plutôt l'outil gcloud ou l'API REST.

gcloud

Exécutez la commande gcloud iam service-accounts keys enable pour activer une clé de compte de service.

Remplacez les valeurs suivantes :

  • key-id : ID de la clé à activer.
  • sa-name : nom du compte de service auquel appartient la clé.
  • project-id : ID de votre projet Google Cloud.
gcloud iam service-accounts keys enable key-id \
    --iam-account=sa-name@project-id.iam.gserviceaccount.com

Sortie :

Enabled key [key-id] for service account
[sa-name@project-id.iam.gserviceaccount.com]

REST

La méthode projects.serviceAccounts.keys.enable active une clé de compte de service.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_ID : ID de votre projet Google Cloud. Les ID de projet sont des chaînes alphanumériques, telles que my-project.
  • SA_NAME : nom du compte de service dont vous souhaitez activer la clé.
  • KEY_ID : ID de la clé que vous souhaitez activer.

Méthode HTTP et URL :

POST https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/SA_NAME@PROJECT_ID.iam.gserviceaccount.com/keys/KEY_ID:enable

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
}

Supprimer des clés de compte de service

La suppression d'une clé de compte de service vous empêche de manière permanente d'utiliser cette clé pour vous authentifier auprès des API Google.

Vous ne pouvez pas annuler la suppression d'une clé. Avant de supprimer une clé, nous vous recommandons de la désactiver, puis de vous assurer qu'elle n'est plus nécessaire. Vous pouvez ensuite la supprimer.

Il est recommandé d'alterner régulièrement les vos clés de compte de service. Vous pouvez alterner une clé en procédant comme suit :

  1. Créez une clé.
  2. Mettez à jour vos applications afin qu'elles utilisent la nouvelle clé.
  3. Désactivez l'ancienne clé.
  4. Patientez le temps qu'il faut pour vous assurer que l'ancienne clé n'est plus utilisée.
  5. Supprimez l'ancienne clé.

Console

  1. Dans Cloud Console, accédez à la page Comptes de service.

    Accéder à la page "Comptes de service"

  2. Sélectionnez un projet.

  3. Cliquez sur l'adresse e-mail du compte de service dont vous souhaitez supprimer la clé.

  4. Cliquez sur l'onglet Clés.

  5. Dans la liste de clés, cliquez sur Supprimer  pour chaque clé que vous souhaitez supprimer.

gcloud

Exécutez la commande gcloud iam service-accounts keys delete pour supprimer des clés de compte de service.

Remplacez les valeurs suivantes :

  • key-id : ID de la clé à supprimer.
  • sa-name : nom du compte de service auquel appartient la clé.
  • project-id : ID de votre projet Google Cloud.
gcloud iam service-accounts keys delete key-id \
    --iam-account=sa-name@project-id.iam.gserviceaccount.com

Sortie :

Deleted key [key-id] for service account
[sa-name@project-id.iam.gserviceaccount.com]

REST

La méthode projects.serviceAccounts.keys.delete supprime une clé de compte de service.

Avant d'utiliser les données de requête, effectuez les remplacements suivants :

  • PROJECT_ID : ID de votre projet Google Cloud. Les ID de projet sont des chaînes alphanumériques, telles que my-project.
  • SA_NAME : nom du compte de service dont vous souhaitez supprimer la clé.
  • KEY_ID : ID de la clé que vous souhaitez supprimer.

Méthode HTTP et URL :

DELETE https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/SA_NAME@PROJECT_ID.iam.gserviceaccount.com/keys/KEY_ID

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
}

C++

Pour savoir comment installer et utiliser la bibliothèque cliente pour IAM, consultez la page Bibliothèques clientes IAM. Pour en savoir plus, consultez la documentation de référence de l'API Cloud IAM en langage C++.

namespace iam = ::google::cloud::iam;
[](std::string const& name) {
  iam::IAMClient client(iam::MakeIAMConnection());
  auto response = client.DeleteServiceAccountKey(name);
  if (!response.ok()) throw std::runtime_error(response.message());
  std::cout << "ServiceAccountKey successfully deleted.\n";
}

C#

Pour savoir comment installer et utiliser la bibliothèque cliente pour IAM, consultez la page Bibliothèques clientes IAM. Pour en savoir plus, consultez la documentation de référence de l'API Cloud IAM en langage C#.


using System;
using Google.Apis.Auth.OAuth2;
using Google.Apis.Iam.v1;
using Google.Apis.Iam.v1.Data;

public partial class ServiceAccountKeys
{
    public static void DeleteKey(string fullKeyName)
    {
        var credential = GoogleCredential.GetApplicationDefault()
            .CreateScoped(IamService.Scope.CloudPlatform);
        var service = new IamService(new IamService.Initializer
        {
            HttpClientInitializer = credential
        });

        service.Projects.ServiceAccounts.Keys.Delete(fullKeyName).Execute();
        Console.WriteLine("Deleted key: " + fullKeyName);
    }
}

Go

Pour savoir comment installer et utiliser la bibliothèque cliente pour IAM, consultez la page Bibliothèques clientes IAM. Pour en savoir plus, consultez la documentation de référence de l'API Cloud IAM en langage Go.

import (
	"context"
	"fmt"
	"io"

	iam "google.golang.org/api/iam/v1"
)

// deleteKey deletes a service account key.
func deleteKey(w io.Writer, fullKeyName string) error {
	ctx := context.Background()
	service, err := iam.NewService(ctx)
	if err != nil {
		return fmt.Errorf("iam.NewService: %v", err)
	}

	_, err = service.Projects.ServiceAccounts.Keys.Delete(fullKeyName).Do()
	if err != nil {
		return fmt.Errorf("Projects.ServiceAccounts.Keys.Delete: %v", err)
	}
	fmt.Fprintf(w, "Deleted key: %v", fullKeyName)
	return nil
}

Java

Pour savoir comment installer et utiliser la bibliothèque cliente pour IAM, consultez la page Bibliothèques clientes IAM. Pour en savoir plus, consultez la documentation de référence de l'API Cloud IAM en langage Java.

import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.json.jackson2.JacksonFactory;
import com.google.api.services.iam.v1.Iam;
import com.google.api.services.iam.v1.IamScopes;
import com.google.api.services.iam.v1.model.ServiceAccountKey;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.Collections;
import java.util.List;

public class DeleteServiceAccountKey {

  // Deletes a service account key.
  public static void deleteKey(String projectId, String serviceAccountName) {
    // String projectId = "my-project-id";
    // String serviceAccountName = "my-service-account-name";

    Iam service = null;
    try {
      service = initService();
    } catch (IOException | GeneralSecurityException e) {
      System.out.println("Unable to initialize service: \n" + e.toString());
      return;
    }

    String serviceAccountEmail = serviceAccountName + "@" + projectId + ".iam.gserviceaccount.com";
    try {
      // First, get the name of the key using List() or Get()
      List<ServiceAccountKey> keys =
          service
              .projects()
              .serviceAccounts()
              .keys()
              .list("projects/-/serviceAccounts/" + serviceAccountEmail)
              .execute()
              .getKeys();
      String keyToDelete = keys.get(0).getName();

      // Then you can delete the key
      service.projects().serviceAccounts().keys().delete(keyToDelete).execute();

      System.out.println("Deleted key: " + keyToDelete);
    } catch (IOException e) {
      System.out.println("Unable to delete service account key: \n" + e.toString());
    }
  }

  private static Iam initService() throws GeneralSecurityException, IOException {
    // Use the Application Default Credentials strategy for authentication. For more info, see:
    // https://cloud.google.com/docs/authentication/production#finding_credentials_automatically
    GoogleCredentials credential =
        GoogleCredentials.getApplicationDefault()
            .createScoped(Collections.singleton(IamScopes.CLOUD_PLATFORM));
    // Initialize the IAM service, which can be used to send requests to the IAM API.
    Iam service =
        new Iam.Builder(
                GoogleNetHttpTransport.newTrustedTransport(),
                JacksonFactory.getDefaultInstance(),
                new HttpCredentialsAdapter(credential))
            .setApplicationName("service-account-keys")
            .build();
    return service;
  }
}

Python

Pour savoir comment installer et utiliser la bibliothèque cliente pour IAM, consultez la page Bibliothèques clientes IAM. Pour en savoir plus, consultez la documentation de référence de l'API Cloud IAM en langage Python.

import os

from google.oauth2 import service_account
import googleapiclient.discovery

def delete_key(full_key_name):
    """Deletes a service account key."""

    credentials = service_account.Credentials.from_service_account_file(
        filename=os.environ['GOOGLE_APPLICATION_CREDENTIALS'],
        scopes=['https://www.googleapis.com/auth/cloud-platform'])

    service = googleapiclient.discovery.build(
        'iam', 'v1', credentials=credentials)

    service.projects().serviceAccounts().keys().delete(
        name=full_key_name).execute()

    print('Deleted key: ' + full_key_name)

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