Créer et supprimer des clés de compte de service

Cette page explique comment créer et supprimer des clés de compte de service à l'aide de la console Google Cloud, de Google Cloud CLI, de l'API Identity and Access Management, ou de l'une des bibliothèques clientes Google Cloud.

Avant de commencer

Enable the IAM API.
Enable the API
Configurez l'authentification.

Select the tab for how you plan to use the samples on this page:
Console

When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.
gcloud

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
C++

Pour utiliser les exemples C++ 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 Configurer l'authentification pour un environnement de développement local dans la documentation sur l'authentification Google Cloud.
C#

Pour utiliser les exemples .NET 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 Configurer l'authentification pour un environnement de développement local dans la documentation sur l'authentification Google Cloud.
Go

Pour utiliser les exemples Go 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 Configurer l'authentification pour un environnement de développement local dans la documentation sur l'authentification Google Cloud.
Java

Pour utiliser les exemples Java 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 Configurer l'authentification pour un environnement de développement local dans la documentation sur l'authentification Google Cloud.
Python

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 Configurer l'authentification pour un environnement de développement local dans la documentation sur l'authentification Google Cloud.
REST

Pour utiliser les exemples d'API REST de cette page dans un environnement de développement local, vous devez utiliser les identifiants que vous fournissez à gcloud CLI.
Pour en savoir plus, consultez la section S'authentifier pour utiliser REST dans la documentation sur l'authentification Google Cloud.
Comprendre les identifiants de compte de service

Rôles requis

Pour obtenir les autorisations nécessaires pour créer et supprimer des clés de compte de service, demandez à votre administrateur de vous attribuer le rôle IAM Administrateur de clés de compte de service (roles/iam.serviceAccountKeyAdmin) sur le projet, ou sur le compte de service dont vous souhaitez gérer les clés. Pour en savoir plus sur l'attribution de rôles, consultez la section Gérer les accès.

Vous pouvez également obtenir les autorisations requises via des rôles personnalisés ou d'autres rôles prédéfinis.

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 une clé 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 la console Google Cloud, gcloud CLI, la méthode serviceAccounts.keys.create() ou l'une des bibliothèques clientes. Un compte de service peut compter jusqu'à 10 clés.

Par défaut, les clés de compte de service n'expirent jamais. Vous pouvez utiliser une contrainte liée aux règles d'administration pour spécifier la durée de validité d'une clé de compte de service. Pour en savoir plus, consultez la section Délais d'expiration des clés gérées par l'utilisateur.

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 la console Google Cloud.

Console

Dans Google Cloud Console, accédez à la page Comptes de service.
Accéder à la page "Comptes de service"
Les étapes restantes apparaîtront automatiquement dans la console Google Cloud.
Sélectionnez un projet.
Cliquez sur l'adresse e-mail du compte de service pour lequel vous souhaitez créer une clé.
Cliquez sur l'onglet Clés.
Cliquez sur le menu déroulant Ajouter une clé, puis sélectionnez Créer une clé.
Sélectionnez le type de clé JSON et cliquez sur Créer.

Cliquez sur Créer pour télécharger un fichier de clé de compte de service. Vous ne pourrez le télécharger qu'une seule fois.

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"
}

Vous devez veiller à stocker le fichier de clé de façon sécurisée, car il permet de 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://oauth2.googleapis.com/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"
}

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 C++.

Pour vous authentifier auprès d'IAM, configurez le service Identifiants par défaut de l'application. Pour plus d'informations, consultez la section Avant de commencer.

namespace iam = ::google::cloud::iam_admin_v1;
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::move(response).status();
  std::cout << "ServiceAccountKey successfully created: "
            << response->DebugString() << "\n"
            << "Please save the key in a secure location, as they cannot "
               "be downloaded later\n";
  return response->name();
}

C#

Pour vous authentifier auprès d'IAM, configurez le service Identifiants par défaut de l'application. Pour plus d'informations, consultez la section Avant de commencer.


using System;
using System.Text;
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();

        // The PrivateKeyData field contains the base64-encoded service account key
        // in JSON format.
        // TODO(Developer): Save the below key (jsonKeyFile) to a secure location.
        //  You cannot download it later.
        byte[] valueBytes = System.Convert.FromBase64String(key.PrivateKeyData);
        string jsonKeyContent = Encoding.UTF8.GetString(valueBytes);

        Console.WriteLine("Key created successfully");
        return key;
    }
}

Go

Pour vous authentifier auprès d'IAM, configurez le service Identifiants par défaut de l'application. Pour plus d'informations, consultez la section Avant de commencer.

import (
	"context"
	// "encoding/base64"
	"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: %w", 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: %w", err)
	}
	// The PrivateKeyData field contains the base64-encoded service account key
	// in JSON format.
	// TODO(Developer): Save the below key (jsonKeyFile) to a secure location.
	// You cannot download it later.
	// jsonKeyFile, _ := base64.StdEncoding.DecodeString(key.PrivateKeyData)
	fmt.Fprintf(w, "Key created successfully")
	return key, nil
}

Java

Pour vous authentifier auprès d'IAM, configurez le service Identifiants par défaut de l'application. Pour plus d'informations, consultez la section Avant de commencer.

import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.json.gson.GsonFactory;
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.Base64;
import java.util.Collections;

public class CreateServiceAccountKey {

  // Creates a key for a service account.
  public static String 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);
      return null;
    }

    // Construct the service account email.
    // You can modify the ".iam.gserviceaccount.com" to match the service account name in which
    // you want to create the key.
    // See, https://cloud.google.com/iam/docs/creating-managing-service-account-keys?hl=en#creating
    String serviceAccountEmail = serviceAccountName + "@" + projectId + ".iam.gserviceaccount.com";
    try {
      ServiceAccountKey key =
          service
              .projects()
              .serviceAccounts()
              .keys()
              .create(
                  "projects/-/serviceAccounts/" + serviceAccountEmail,
                  new CreateServiceAccountKeyRequest())
              .execute();

      // The privateKeyData field contains the base64-encoded service account key
      // in JSON format.
      // TODO(Developer): Save the below key (jsonKeyFile) to a secure location.
      //  You cannot download it later.
      String jsonKeyFile = new String(Base64.getDecoder().decode(key.getPrivateKeyData()));

      System.out.println("Key created successfully");
      String keyName = key.getName();
      return keyName.substring(keyName.lastIndexOf("/") + 1).trim();
    } catch (IOException e) {
      System.out.println("Unable to create service account key: \n" + e);
      return null;
    }
  }

  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(),
            GsonFactory.getDefaultInstance(),
            new HttpCredentialsAdapter(credential))
            .setApplicationName("service-account-keys")
            .build();
    return service;
  }
}

Python

Pour vous authentifier auprès d'IAM, configurez le service Identifiants par défaut de l'application. Pour plus d'informations, consultez la section Avant de commencer.

import os

from google.oauth2 import service_account
import googleapiclient.discovery  # type: ignore

def create_key(service_account_email: str) -> None:
    """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()
    )

    # The privateKeyData field contains the base64-encoded service account key
    # in JSON format.
    # TODO(Developer): Save the below key {json_key_file} to a secure location.
    #  You cannot download it again later.
    # import base64
    # json_key_file = base64.b64decode(key['privateKeyData']).decode('utf-8')

    if not key["disabled"]:
        print("Created json key")

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 :

curl (Linux, macOS ou Cloud Shell)

Remarque : La commande suivante suppose que vous êtes connecté à la gcloud CLI avec votre compte utilisateur, via la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la gcloud CLI. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/SA_NAME@PROJECT_ID.iam.gserviceaccount.com/keys"

PowerShell (Windows)

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/SA_NAME@PROJECT_ID.iam.gserviceaccount.com/keys" | Select-Object -Expand Content

APIs Explorer (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau APIs Explorer s'ouvre dans la partie droite de la page. Vous pouvez interagir avec cet outil pour envoyer des requêtes. Collez le corps de la requête dans cet outil, renseignez tous les champs obligatoires, puis cliquez sur Execute (Exécuter).

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

Enregistrez les données de clé privée encodées (ENCODED_PRIVATE_KEY) dans un fichier.
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.

Supprimer une clé 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. Pour en savoir plus sur la rotation des clés de compte de service, consultez la page Rotation des clés de compte de service.

Console

Dans Google Cloud Console, accédez à la page Comptes de service.
Accéder à la page "Comptes de service"
Les étapes restantes apparaîtront automatiquement dans la console Google Cloud.
Sélectionnez un projet.
Sur la page Comptes de service, cliquez sur l'adresse e-mail du compte de service dont vous souhaitez supprimer une ou des clés.
Cliquez sur l'onglet Clés.
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. Pour trouver l'ID de la clé, répertoriez toutes les clés du compte de service, identifiez la clé que vous souhaitez supprimer, puis copiez son ID.
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

Résultat :

Deleted key [KEY_ID] for service account
[SA_NAME@PROJECT_ID.iam.gserviceaccount.com]

C++

Pour vous authentifier auprès d'IAM, configurez le service Identifiants par défaut de l'application. Pour plus d'informations, consultez la section Avant de commencer.

namespace iam = ::google::cloud::iam_admin_v1;
[](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 vous authentifier auprès d'IAM, configurez le service Identifiants par défaut de l'application. Pour plus d'informations, consultez la section Avant de commencer.


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 vous authentifier auprès d'IAM, configurez le service Identifiants par défaut de l'application. Pour plus d'informations, consultez la section Avant de commencer.

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: %w", err)
	}

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

Java

Pour vous authentifier auprès d'IAM, configurez le service Identifiants par défaut de l'application. Pour plus d'informations, consultez la section Avant de commencer.


import com.google.cloud.iam.admin.v1.IAMClient;
import com.google.iam.admin.v1.DeleteServiceAccountKeyRequest;
import com.google.iam.admin.v1.KeyName;
import java.io.IOException;

public class DeleteServiceAccountKey {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace the variables before running the sample.
    String projectId = "your-project-id";
    String serviceAccountName = "my-service-account-name";
    String serviceAccountKeyId = "service-account-key-id";

    deleteKey(projectId, serviceAccountName, serviceAccountKeyId);
  }

  // Deletes a service account key.
  public static void deleteKey(String projectId, String accountName,
                               String serviceAccountKeyId) throws IOException {
    //Initialize client that will be used to send requests.
    //This client only needs to be created once, and can be reused for multiple requests.
    try (IAMClient iamClient = IAMClient.create()) {

      //Construct the service account email.
      //You can modify the ".iam.gserviceaccount.com" to match the service account name in which
      //you want to delete the key.
      //See, https://cloud.google.com/iam/docs/creating-managing-service-account-keys?hl=en#deleting

      String accountEmail = String.format("%s@%s.iam.gserviceaccount.com", accountName, projectId);

      String name = KeyName.of(projectId, accountEmail, serviceAccountKeyId).toString();

      DeleteServiceAccountKeyRequest request = DeleteServiceAccountKeyRequest.newBuilder()
              .setName(name)
              .build();

      // Then you can delete the key
      iamClient.deleteServiceAccountKey(request);

      System.out.println("Deleted key: " + serviceAccountKeyId);
    }
  }
}

Python

Pour vous authentifier auprès d'IAM, configurez le service Identifiants par défaut de l'application. Pour plus d'informations, consultez la section Avant de commencer.

import os

from google.oauth2 import service_account
import googleapiclient.discovery  # type: ignore

def delete_key(full_key_name: str) -> None:
    """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)

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. Pour trouver l'ID de la clé, répertoriez toutes les clés du compte de service, identifiez la clé que vous souhaitez supprimer, puis copiez son ID à la fin du champ name. L'ID de la clé correspond à tout ce qui suit keys/.

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 :

curl (Linux, macOS ou Cloud Shell)

Exécutez la commande suivante :

curl -X DELETE \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/SA_NAME@PROJECT_ID.iam.gserviceaccount.com/keys/KEY_ID"

PowerShell (Windows)

Exécutez la commande suivante :

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method DELETE `
    -Headers $headers `
    -Uri "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/SA_NAME@PROJECT_ID.iam.gserviceaccount.com/keys/KEY_ID" | Select-Object -Expand Content

APIs Explorer (navigateur)

Ouvrez la page de référence de la méthode. Le panneau APIs Explorer s'ouvre dans la partie droite de la page. Vous pouvez interagir avec cet outil pour envoyer des requêtes. Renseignez tous les champs obligatoires, puis cliquez sur Exécuter.

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

{
}

Étapes suivantes

Découvrez comment répertorier et obtenir des clés de compte de service.
Découvrez comment importer vos propres clés de compte de service publiques.
Identifiez les bonnes pratiques pour gérer les clés de compte de service.
Découvrez des alternatives aux clés de compte de service pour l'authentification.

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