Cette page a été traduite par l'API Cloud Translation.

Gérer des clés API

Cette page explique comment créer, modifier et restreindre des clés API. Pour savoir comment utiliser les clés API pour accéder aux API Google, consultez Utiliser des clés API pour accéder aux API.

Présentation des clés API

Il existe deux types de clés API : les clés API standards et les clés API associées à un compte de service.

Clés API standards

Les clés API standards permettent d'associer une requête à un projet à des fins de facturation et de quota. Lorsque vous utilisez une clé API standard (une clé API qui n'a pas été liée à un compte de service) pour accéder à une API, la clé API n'identifie pas de compte principal. Sans un compte principal, la requête ne peut pas utiliser Identity and Access Management (IAM) pour vérifier si l'appelant est autorisé à effectuer l'opération demandée.

Les clés API standards peuvent être utilisées avec n'importe quelle API qui accepte les clés API, sauf si des restrictions d'API ont été ajoutées à la clé. Les clés API standards ne peuvent pas être utilisées avec les services qui ne les acceptent pas, y compris en mode Express.

Clés API liées à un compte de service

Les clés API liées à un compte de service fournissent l'identité et l'autorisation du compte de service pour une requête. Lorsque vous utilisez une clé API associée à un compte de service pour accéder à une API, votre requête est traitée comme si vous aviez utilisé le compte de service associé pour l'effectuer.

La seule API compatible avec les clés API liées est aiplatform.googleapis.com.

Une contrainte de règle d'administration par défaut empêche l'association de clés à un compte de service. Pour modifier ce paramètre, consultez Activer l'association de clés aux comptes de service.

Composants des clés API

Une clé API comprend les composants suivants, qui vous permettent de gérer et d'utiliser la clé :

Chaîne: La chaîne de clé API est une chaîne chiffrée, par exemple AIzaSyDaGmWKa4JsXZ-HjGw7ISLn_3namBGewQe. Lorsque vous utilisez une clé API pour accéder à une API, vous utilisez toujours la chaîne de la clé. Les clés API ne sont pas associées à un fichier JSON.
ID: L'ID de clé API est utilisé par les outils d'administration Google Cloud pour identifier de manière unique la clé. Vous ne pouvez pas utiliser l'ID de clé pour accéder aux API. Vous pouvez trouver l'ID de la clé dans l'URL de la page de modification de la clé dans la console Google Cloud . Vous pouvez également obtenir l'ID de clé à l'aide de Google Cloud CLI pour répertorier les clés de votre projet.
Nom à afficher: Le nom à afficher est un nom descriptif facultatif pour la clé, que vous pouvez définir lorsque vous créez ou mettez à jour la clé.
Compte de service lié

Avant de commencer

Pour utiliser les exemples de cette page, effectuez les tâches suivantes.

Configurer 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 la gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.

Install the Google Cloud CLI.
If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.
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.

If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

Pour en savoir plus, consultez la page Configurer les ADC 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 la gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.

Install the Google Cloud CLI.
If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.
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.

If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

Pour en savoir plus, consultez la section Configurer les ADC 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 la gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.

Install the Google Cloud CLI.
If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.
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.

If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

Pour en savoir plus, consultez la section Configurer les ADC pour un environnement de développement local dans la documentation sur l'authentification Google Cloud .

REST

Pour utiliser les exemples API REST de cette page dans un environnement de développement local, vous devez utiliser les identifiants que vous fournissez à la gcloud CLI.

Install the Google Cloud CLI.

If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

Pour en savoir plus, consultez la section S'authentifier pour utiliser REST dans la documentation sur l'authentification Google Cloud .

Rôles requis

Pour obtenir les autorisations nécessaires pour gérer les clés API, demandez à votre administrateur de vous accorder les rôles IAM suivants sur votre projet :

Administrateur de clés API (roles/serviceusage.apiKeysAdmin)
Restreignez une clé API à des API spécifiques à l'aide de la console Google Cloud : Lecteur Service Usage (roles/serviceusage.serviceUsageViewer)

Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

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

Activer l'association de clés aux comptes de service

Avant de pouvoir associer une clé API à un compte de service, vous devez d'abord définir la contrainte de règle d'administration constraints/iam.managed.disableServiceAccountApiKeyCreation sur false. Pour modifier la règle d'administration, vous devez disposer d'une ressource d'organisation associée. Les projets sans organisation ne sont pas acceptés.

Pour modifier la contrainte de stratégie, suivez les instructions ci-dessous.

Console

Dans la console Google Cloud , accédez à la page Règles d'administration.

Accéder à la page Règles d'administration
Passez à l'organisation, au dossier ou au projet dont vous souhaitez modifier les règles.
Dans la zone Filtre, saisissez Block service, puis cliquez sur le nom du filtre Bloquer les liaisons de clé API de compte de service.
Cliquez sur Gérer la règle.
Dans la section Source de la règle, sélectionnez Remplacer la règle parente.
Cliquez sur Ajouter une règle, puis définissez Application sur Désactivée.
Cliquez sur OK.
Facultatif : Cliquez sur Tester les modifications pour obtenir des informations sur les problèmes de non-conformité ou les perturbations que la stratégie proposée pourrait engendrer.
Cliquez sur Définir la règle.

gcloud

Créez un fichier nommé spec.yaml avec le contenu suivant :
```
name: SCOPE/SCOPE_ID/policies/iam.managed.disableServiceAccountApiKeyCreation
spec:
  rules:
  - enforce: false
```
Indiquez les valeurs suivantes :
- SCOPE : organizations, folders ou projects.
- SCOPE_ID : selon SCOPE, ID de l'organisation, du dossier ou du projet auquel s'applique la règle d'organisation.
Exécutez la commande gcloud suivante pour autoriser l'association de clés API à des comptes de service :
```
gcloud org-policies set-policy spec.yaml \
    --update-mask spec
```

Créer une clé API

Appliquez l'une des procédures suivantes pour créer une clé API.

Console

Dans la console Google Cloud , accédez à la page Identifiants :

Accéder à "Identifiants"
Cliquez sur Créer des identifiants, puis sélectionnez Clé API dans le menu.
Facultatif : Pour associer la clé API à un compte de service, cochez la case Authentifier les appels d'API via un compte de service, puis cliquez sur Sélectionner un compte de service pour choisir le compte de service que vous souhaitez associer à la clé.

Pour en savoir plus, consultez Clés API liées à un compte de service.
Ajoutez des restrictions de clé API.

Il est recommandé de restreindre les clés API. Pour en savoir plus, consultez Appliquer des restrictions de clé API.
Cliquez sur Créer. La boîte de dialogue Clé API créée affiche la chaîne correspondant à la clé que vous venez de créer.

gcloud

Vous exécutez la commande gcloud services api-keys create pour créer une clé API.

Remplacez DISPLAY_NAME par un nom descriptif pour votre clé.

 gcloud services api-keys create \
     --display-name=DISPLAY_NAME

Facultatif : Pour associer la clé API à un compte de service, utilisez plutôt gcloud beta avec le paramètre --service-account :

 gcloud beta services api-keys create \
     --display-name=DISPLAY_NAME \
     --service-account=SERVICE_ACCOUNT_EMAIL_ADDRESS

Pour en savoir plus, consultez Clés API liées à un compte de service.

C++

Pour exécuter cet exemple, vous devez installer la bibliothèque cliente des clés API.

#include "google/cloud/apikeys/v2/api_keys_client.h"
#include "google/cloud/location.h"

google::api::apikeys::v2::Key CreateApiKey(
    google::cloud::apikeys_v2::ApiKeysClient client,
    google::cloud::Location location, std::string display_name) {
  google::api::apikeys::v2::CreateKeyRequest request;
  request.set_parent(location.FullName());
  request.mutable_key()->set_display_name(std::move(display_name));
  // As an example, restrict the API key's scope to the Natural Language API.
  request.mutable_key()->mutable_restrictions()->add_api_targets()->set_service(
      "language.googleapis.com");

  // Create the key, blocking on the result.
  auto key = client.CreateKey(request).get();
  if (!key) throw std::move(key.status());
  std::cout << "Successfully created an API key: " << key->name() << "\n";

  // For authenticating with the API key, use the value in `key->key_string()`.

  // The API key's resource name is the value in `key->name()`. Use this to
  // refer to the specific key in a `GetKey()` or `DeleteKey()` RPC.
  return *key;
}

Java

Pour exécuter cet exemple, vous devez installer la bibliothèque cliente google-cloud-apikeys.


import com.google.api.apikeys.v2.ApiKeysClient;
import com.google.api.apikeys.v2.ApiTarget;
import com.google.api.apikeys.v2.CreateKeyRequest;
import com.google.api.apikeys.v2.Key;
import com.google.api.apikeys.v2.LocationName;
import com.google.api.apikeys.v2.Restrictions;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateApiKey {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(Developer): Before running this sample,
    //  1. Replace the variable(s) below.
    //  2. Set up ADC as described in https://cloud.google.com/docs/authentication/external/set-up-adc
    //  3. Make sure you have the necessary permission to create API keys.
    String projectId = "GOOGLE_CLOUD_PROJECT_ID";

    createApiKey(projectId);
  }

  // Creates an API key.
  public static void createApiKey(String projectId)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `apiKeysClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (ApiKeysClient apiKeysClient = ApiKeysClient.create()) {

      Key key = Key.newBuilder()
          .setDisplayName("My first API key")
          // Set the API key restriction.
          // You can also set browser/ server/ android/ ios based restrictions.
          // For more information on API key restriction, see:
          // https://cloud.google.com/docs/authentication/api-keys#api_key_restrictions
          .setRestrictions(Restrictions.newBuilder()
              // Restrict the API key usage by specifying the target service and methods.
              // The API key can only be used to authenticate the specified methods in the service.
              .addApiTargets(ApiTarget.newBuilder()
                  .setService("translate.googleapis.com")
                  .addMethods("translate.googleapis.com.TranslateText")
                  .build())
              .build())
          .build();

      // Initialize request and set arguments.
      CreateKeyRequest createKeyRequest = CreateKeyRequest.newBuilder()
          // API keys can only be global.
          .setParent(LocationName.of(projectId, "global").toString())
          .setKey(key)
          .build();

      // Make the request and wait for the operation to complete.
      Key result = apiKeysClient.createKeyAsync(createKeyRequest).get(3, TimeUnit.MINUTES);

      // For authenticating with the API key, use the value in "result.getKeyString()".
      // To restrict the usage of this API key, use the value in "result.getName()".
      System.out.printf("Successfully created an API key: %s", result.getName());
    }
  }
}

Python

Pour exécuter cet exemple, vous devez installer la bibliothèque cliente des clés API.


from google.cloud import api_keys_v2
from google.cloud.api_keys_v2 import Key


def create_api_key(project_id: str, suffix: str) -> Key:
    """
    Creates and restrict an API key. Add the suffix for uniqueness.

    TODO(Developer):
    1. Before running this sample,
      set up ADC as described in https://cloud.google.com/docs/authentication/external/set-up-adc
    2. Make sure you have the necessary permission to create API keys.

    Args:
        project_id: Google Cloud project id.

    Returns:
        response: Returns the created API Key.
    """
    # Create the API Keys client.
    client = api_keys_v2.ApiKeysClient()

    key = api_keys_v2.Key()
    key.display_name = f"My first API key - {suffix}"

    # Initialize request and set arguments.
    request = api_keys_v2.CreateKeyRequest()
    request.parent = f"projects/{project_id}/locations/global"
    request.key = key

    # Make the request and wait for the operation to complete.
    response = client.create_key(request=request).result()

    print(f"Successfully created an API key: {response.name}")
    # For authenticating with the API key, use the value in "response.key_string".
    # To restrict the usage of this API key, use the value in "response.name".
    return response

REST

Vous utilisez la méthode keys.create pour créer une clé API. Cette requête renvoie une opération de longue durée, que vous devez interroger pour obtenir les informations de la nouvelle clé.

Remplacez les valeurs suivantes :

DISPLAY_NAME : facultatif. Un nom descriptif pour votre clé.
PROJECT_ID : ID ou nom de votre projet Google Cloud .

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
-d {'"displayName" : "DISPLAY_NAME"'} \
"https://apikeys.googleapis.com/v2/projects/PROJECT/locations/global/keys"

Facultatif : Pour associer la clé API à un compte de service, utilisez la commande suivante :

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
-d {'"displayName" : "DISPLAY_NAME",
     "serviceAccountEmail" : "SERVICE_ACCOUNT_EMAIL"'} \
"https://apikeys.googleapis.com/v2/projects/PROJECT/locations/global/keys"

Pour en savoir plus, consultez Clés API liées à un compte de service.

Pour plus d'informations sur la création de clés API à l'aide de l'API REST, consultez la page Créer une clé API dans la documentation de l'API "API Keys".

Appliquer des restrictions liées aux clés API

Les clés API ne sont pas restreintes par défaut. Les clés sans restriction ne sont pas sécurisées, car elles peuvent être utilisées par n'importe qui et depuis n'importe quel emplacement. Pour les applications de production, vous devez définir des restrictions d'application et des restrictions d'API.

Ajouter des restrictions liées aux applications

Les restrictions relatives aux applications spécifient les sites Web, adresses IP ou applications qui peuvent utiliser une clé API.

Vous ne pouvez appliquer qu'un seul type de restriction d'application à la fois. Choisissez le type de restriction en fonction du type de votre application :

Option	Type d'application	Remarques
Référents HTTP	Applications Web	Spécifie les sites Web pouvant utiliser la clé.
Adresses IP	Applications appelées par des serveurs spécifiques	Spécifie les serveurs ou les jobs Cron pouvant utiliser la clé. Il s'agit de la seule restriction disponible si vous associez votre clé API à un compte de service.
Applications Android	Applications Android	Spécifie l'application Android pouvant utiliser la clé.
Applications iOS	Applications iOS	Spécifie les groupes iOS pouvant utiliser la clé.

Référents HTTP

Pour limiter les sites Web autorisés à utiliser votre clé API, vous pouvez ajouter une ou plusieurs restrictions de référents HTTP.

Vous pouvez remplacer un sous-domaine ou un chemin d'accès par un caractère générique (*), mais vous ne pouvez pas insérer de caractère générique au milieu de l'URL. Par exemple, la valeur *.example.com est valide et accepte tous les sites se terminant par .example.com. En revanche, mysubdomain*.example.com n'est pas une restriction valide.

Les numéros de ports peuvent être inclus dans les restrictions de référents HTTP. Si vous incluez un numéro de port, seules les requêtes utilisant ce port sont prises en compte. Si vous ne spécifiez pas de numéro de port, les requêtes exploitant n'importe quel numéro de port sont prises en compte.

Le tableau suivant présente quelques exemples de scénarios, et décrit les restrictions correspondantes appliquées dans le navigateur :

Scénario Restrictions

Autoriser une URL spécifique

Scénario	Restrictions
Autoriser une URL spécifique	Vous devez ajoutez une URL avec un chemin d'accès exact. Exemple : `www.example.com/path` `www.example.com/path/path` Certains navigateurs mettent en œuvre une règle d'URL de provenance qui envoie uniquement l'URL d'origine pour les requêtes d'origines multiples. Les utilisateurs de ces navigateurs ne peuvent pas utiliser de clés avec des restrictions d'URL spécifiques à une page.
Autoriser n'importe quelle URL de votre site	Vous devez définir deux URL dans la liste `allowedReferers`. URL du domaine, sans sous-domaine et avec un caractère générique représentant le chemin d'accès. Par exemple : `example.com/` Une deuxième URL comprenant un caractère générique pour le sous-domaine et un caractère générique pour le chemin d'accès. Par exemple : `.example.com/*`
Autoriser n'importe quelle URL dans un seul sous-domaine ou domaine nu	Vous devez définir deux URL dans la liste `allowedReferers` pour autoriser l'ensemble d'un domaine : URL du domaine, sans barre oblique finale. Exemple : `www.example.com` `sub.example.com` `example.com` Une deuxième URL pour le domaine, qui inclut un caractère générique pour le chemin d'accès. Exemple : `www.example.com/` `sub.example.com/` `example.com/*`

Vous devez ajoutez une URL avec un chemin d'accès exact. Exemple :
www.example.com/path
www.example.com/path/path

Certains navigateurs mettent en œuvre une règle d'URL de provenance qui envoie uniquement l'URL d'origine pour les requêtes d'origines multiples. Les utilisateurs de ces navigateurs ne peuvent pas utiliser de clés avec des restrictions d'URL spécifiques à une page.

Autoriser n'importe quelle URL de votre site

Vous devez définir deux URL dans la liste allowedReferers.

URL du domaine, sans sous-domaine et avec un caractère générique représentant le chemin d'accès. Par exemple :
example.com/*
Une deuxième URL comprenant un caractère générique pour le sous-domaine et un caractère générique pour le chemin d'accès. Par exemple :
*.example.com/*

Autoriser n'importe quelle URL dans un seul sous-domaine ou domaine nu

Vous devez définir deux URL dans la liste allowedReferers pour autoriser l'ensemble d'un domaine :

URL du domaine, sans barre oblique finale. Exemple :
www.example.com
sub.example.com
example.com
Une deuxième URL pour le domaine, qui inclut un caractère générique pour le chemin d'accès. Exemple :
www.example.com/*
sub.example.com/*
example.com/*

Pour limiter votre clé API à des sites Web spécifiques, utilisez l'une des options suivantes :

Console

Dans la console Google Cloud , accédez à la page Identifiants :

Accéder à "Identifiants"
Cliquez sur le nom de la clé API que vous souhaitez restreindre.
Dans la section Restrictions liées aux applications, sélectionnez Référents HTTP.
Pour chaque restriction que vous souhaitez ajouter, cliquez sur Ajouter un élément, saisissez la restriction, puis cliquez sur OK.
Cliquez sur Enregistrer pour enregistrer vos modifications et revenir à la liste des clés API.

gcloud

Obtenez l'ID de la clé que vous souhaitez restreindre.

L'ID est différent du nom à afficher ou de la chaîne de clé. Vous pouvez obtenir l'ID à l'aide de la commande gcloud services api-keys list pour lister les clés de votre projet.
Exécutez la commande gcloud services api-keys update pour ajouter des restrictions d'URL de provenance HTTP à une clé API.

Remplacez les valeurs suivantes :
- KEY_ID : ID de la clé que vous souhaitez restreindre.
- ALLOWED_REFERRER_1 : votre restriction de référent HTTP.
  
  Vous pouvez ajouter autant de restrictions que nécessaire, en utilisant des virgules pour les séparer. Vous devez fournir toutes les restrictions de référents avec la commande update ; les restrictions de référents ainsi fournies remplacent toutes les restrictions de référents existantes sur la clé.
```
gcloud services api-keys update KEY_ID \
 --allowed-referrers="ALLOWED_REFERRER_1"
```

Java

Pour exécuter cet exemple, vous devez installer la bibliothèque cliente google-cloud-apikeys.


import com.google.api.apikeys.v2.ApiKeysClient;
import com.google.api.apikeys.v2.BrowserKeyRestrictions;
import com.google.api.apikeys.v2.Key;
import com.google.api.apikeys.v2.Restrictions;
import com.google.api.apikeys.v2.UpdateKeyRequest;
import com.google.protobuf.FieldMask;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class RestrictApiKeyHttp {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(Developer): Before running this sample,
    //  1. Replace the variable(s) below.
    String projectId = "GOOGLE_CLOUD_PROJECT_ID";

    // ID of the key to restrict. This ID is auto-created during key creation.
    // This is different from the key string. To obtain the key_id,
    // you can also use the lookup api: client.lookupKey()
    String keyId = "key_id";

    restrictApiKeyHttp(projectId, keyId);
  }

  // Restricts an API key. To restrict the websites that can use your API key,
  // you add one or more HTTP referrer restrictions.
  public static void restrictApiKeyHttp(String projectId, String keyId)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `apiKeysClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (ApiKeysClient apiKeysClient = ApiKeysClient.create()) {

      // Restrict the API key usage to specific websites by adding them
      // to the list of allowed_referrers.
      Restrictions restrictions = Restrictions.newBuilder()
          .setBrowserKeyRestrictions(BrowserKeyRestrictions.newBuilder()
              .addAllowedReferrers("www.example.com/*")
              .build())
          .build();

      Key key = Key.newBuilder()
          .setName(String.format("projects/%s/locations/global/keys/%s", projectId, keyId))
          // Set the restriction(s).
          // For more information on API key restriction, see:
          // https://cloud.google.com/docs/authentication/api-keys
          .setRestrictions(restrictions)
          .build();

      // Initialize request and set arguments.
      UpdateKeyRequest updateKeyRequest = UpdateKeyRequest.newBuilder()
          .setKey(key)
          .setUpdateMask(FieldMask.newBuilder().addPaths("restrictions").build())
          .build();

      // Make the request and wait for the operation to complete.
      Key result = apiKeysClient.updateKeyAsync(updateKeyRequest).get(3, TimeUnit.MINUTES);

      // For authenticating with the API key, use the value in "result.getKeyString()".
      System.out.printf("Successfully updated the API key: %s", result.getName());
    }
  }
}

Python

Pour exécuter cet exemple, vous devez installer la bibliothèque cliente des clés API.


from google.cloud import api_keys_v2
from google.cloud.api_keys_v2 import Key


def restrict_api_key_http(project_id: str, key_id: str) -> Key:
    """
    Restricts an API key. To restrict the websites that can use your API key,
    you add one or more HTTP referrer restrictions.

    TODO(Developer): Replace the variables before running this sample.

    Args:
        project_id: Google Cloud project id.
        key_id: ID of the key to restrict. This ID is auto-created during key creation.
            This is different from the key string. To obtain the key_id,
            you can also use the lookup api: client.lookup_key()

    Returns:
        response: Returns the updated API Key.
    """

    # Create the API Keys client.
    client = api_keys_v2.ApiKeysClient()

    # Restrict the API key usage to specific websites by adding them to the list of allowed_referrers.
    browser_key_restrictions = api_keys_v2.BrowserKeyRestrictions()
    browser_key_restrictions.allowed_referrers = ["www.example.com/*"]

    # Set the API restriction.
    # For more information on API key restriction, see:
    # https://cloud.google.com/docs/authentication/api-keys
    restrictions = api_keys_v2.Restrictions()
    restrictions.browser_key_restrictions = browser_key_restrictions

    key = api_keys_v2.Key()
    key.name = f"projects/{project_id}/locations/global/keys/{key_id}"
    key.restrictions = restrictions

    # Initialize request and set arguments.
    request = api_keys_v2.UpdateKeyRequest()
    request.key = key
    request.update_mask = "restrictions"

    # Make the request and wait for the operation to complete.
    response = client.update_key(request=request).result()

    print(f"Successfully updated the API key: {response.name}")
    # Use response.key_string to authenticate.
    return response

REST

Obtenez l'ID de la clé que vous souhaitez restreindre.

L'ID est différent du nom à afficher ou de la chaîne de clé. Vous pouvez obtenir l'ID à l'aide de la méthode keys.list. L'ID est listé dans le champ uid de la réponse.

Remplacez PROJECT_ID par l'ID ou le nom de votre projet Google Cloud .
```
curl -X GET \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
"https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/"
```
Utilisez la méthode keys.patch pour ajouter des restrictions de référents HTTP à la clé API.

Cette requête renvoie une opération de longue durée ; vous devez interroger l'opération pour savoir quand elle est terminée et obtenir l'état de l'opération.

Remplacez les valeurs suivantes :
- ALLOWED_REFERRER_1 : votre restriction de référent HTTP.
  
  Vous pouvez ajouter autant de restrictions que nécessaire, en utilisant des virgules pour les séparer. Vous devez fournir toutes les restrictions de référents avec la requête. les restrictions de référent ainsi fournies remplacent toutes les restrictions de référents existantes sur la clé.
- PROJECT_ID : ID ou nom de votre projet Google Cloud .
- KEY_ID : ID de la clé que vous souhaitez restreindre.
```
curl -X PATCH \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
--data '{
"restrictions" : {
"browserKeyRestrictions": {
  "allowedReferrers": ["ALLOWED_REFERRER_1"]
}
}
}' \
"https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/KEY_ID?updateMask=restrictions"
```

Pour en savoir plus sur l'ajout à une clé de restrictions sur les URL de provenance HTTP, à l'aide de l'API REST, consultez la section Ajouter des restrictions de navigateur dans la documentation de l'API "API Keys".

Adresses IP

Vous pouvez spécifier une ou plusieurs adresses IP pour les appelants, tels qu'un serveur Web ou un job Cron, qui sont autorisés à utiliser votre clé API. Vous pouvez spécifier les adresses IP dans l'un des formats suivants :

IPv4 (198.51.100.1)
IPv6 (2001:db8::1)
Un sous-réseau utilisant la notation CIDR (198.51.100.0/24, 2001:db8::/64)

L'utilisation de localhost n'est pas compatible avec les restrictions de serveur.

Pour limiter votre clé API à des adresses IP spécifiques, utilisez l'une des options suivantes :

Console

Dans la console Google Cloud , accédez à la page Identifiants :

Accéder à "Identifiants"
Cliquez sur le nom de la clé API que vous souhaitez restreindre.
Dans la section Restrictions liées aux applications, sélectionnez Adresses IP.
Pour chaque adresse IP que vous souhaitez ajouter, cliquez sur Ajouter un élément, saisissez l'adresse, puis cliquez sur OK.
Cliquez sur Enregistrer pour enregistrer vos modifications et revenir à la liste des clés API.

gcloud

Obtenez l'ID de la clé que vous souhaitez restreindre.

L'ID est différent du nom à afficher ou de la chaîne de clé. Vous pouvez obtenir l'ID à l'aide de la commande gcloud services api-keys list pour lister les clés de votre projet.
Exécutez la commande gcloud services api-keys update pour ajouter des restrictions de serveur (adresse IP) à une clé API.

Remplacez les valeurs suivantes :
- KEY_ID : ID de la clé que vous souhaitez restreindre.
- ALLOWED_IP_ADDR_1 : votre adresse IP autorisée.
  
  Vous pouvez ajouter autant d'adresses IP que nécessaire, en les séparant par des virgules.
```
gcloud services api-keys update KEY_ID \
--allowed-ips="ALLOWED_IP_ADDR_1"
```

Java

Pour exécuter cet exemple, vous devez installer la bibliothèque cliente google-cloud-apikeys.


import com.google.api.apikeys.v2.ApiKeysClient;
import com.google.api.apikeys.v2.Key;
import com.google.api.apikeys.v2.Restrictions;
import com.google.api.apikeys.v2.ServerKeyRestrictions;
import com.google.api.apikeys.v2.UpdateKeyRequest;
import com.google.protobuf.FieldMask;
import java.io.IOException;
import java.util.Arrays;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class RestrictApiKeyServer {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(Developer): Before running this sample,
    //  1. Replace the variable(s) below.
    String projectId = "GOOGLE_CLOUD_PROJECT_ID";

    // ID of the key to restrict. This ID is auto-created during key creation.
    // This is different from the key string. To obtain the key_id,
    // you can also use the lookup api: client.lookupKey()
    String keyId = "key_id";

    restrictApiKeyServer(projectId, keyId);
  }

  // Restricts the API key based on IP addresses. You can specify one or more IP addresses
  // of the callers, for example web servers or cron jobs, that are allowed to use your API key.
  public static void restrictApiKeyServer(String projectId, String keyId)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `apiKeysClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (ApiKeysClient apiKeysClient = ApiKeysClient.create()) {

      // Restrict the API key usage by specifying the IP addresses.
      // You can specify the IP addresses in IPv4 or IPv6 or a subnet using CIDR notation.
      Restrictions restrictions = Restrictions.newBuilder()
          .setServerKeyRestrictions(ServerKeyRestrictions.newBuilder()
              .addAllAllowedIps(Arrays.asList("198.51.100.0/24", "2000:db8::/64"))
              .build())
          .build();

      Key key = Key.newBuilder()
          .setName(String.format("projects/%s/locations/global/keys/%s", projectId, keyId))
          // Set the restriction(s).
          // For more information on API key restriction, see:
          // https://cloud.google.com/docs/authentication/api-keys
          .setRestrictions(restrictions)
          .build();

      // Initialize request and set arguments.
      UpdateKeyRequest updateKeyRequest = UpdateKeyRequest.newBuilder()
          .setKey(key)
          .setUpdateMask(FieldMask.newBuilder().addPaths("restrictions").build())
          .build();

      // Make the request and wait for the operation to complete.
      Key result = apiKeysClient.updateKeyAsync(updateKeyRequest).get(3, TimeUnit.MINUTES);

      // For authenticating with the API key, use the value in "result.getKeyString()".
      System.out.printf("Successfully updated the API key: %s", result.getName());
    }
  }
}

Python

Pour exécuter cet exemple, vous devez installer la bibliothèque cliente des clés API.


from google.cloud import api_keys_v2
from google.cloud.api_keys_v2 import Key


def restrict_api_key_server(project_id: str, key_id: str) -> Key:
    """
    Restricts the API key based on IP addresses. You can specify one or more IP addresses of the callers,
    for example web servers or cron jobs, that are allowed to use your API key.

    TODO(Developer): Replace the variables before running this sample.

    Args:
        project_id: Google Cloud project id.
        key_id: ID of the key to restrict. This ID is auto-created during key creation.
            This is different from the key string. To obtain the key_id,
            you can also use the lookup api: client.lookup_key()

    Returns:
        response: Returns the updated API Key.
    """

    # Create the API Keys client.
    client = api_keys_v2.ApiKeysClient()

    # Restrict the API key usage by specifying the IP addresses.
    # You can specify the IP addresses in IPv4 or IPv6 or a subnet using CIDR notation.
    server_key_restrictions = api_keys_v2.ServerKeyRestrictions()
    server_key_restrictions.allowed_ips = ["198.51.100.0/24", "2000:db8::/64"]

    # Set the API restriction.
    # For more information on API key restriction, see:
    # https://cloud.google.com/docs/authentication/api-keys
    restrictions = api_keys_v2.Restrictions()
    restrictions.server_key_restrictions = server_key_restrictions

    key = api_keys_v2.Key()
    key.name = f"projects/{project_id}/locations/global/keys/{key_id}"
    key.restrictions = restrictions

    # Initialize request and set arguments.
    request = api_keys_v2.UpdateKeyRequest()
    request.key = key
    request.update_mask = "restrictions"

    # Make the request and wait for the operation to complete.
    response = client.update_key(request=request).result()

    print(f"Successfully updated the API key: {response.name}")
    # Use response.key_string to authenticate.
    return response

REST

Obtenez l'ID de la clé que vous souhaitez restreindre.

L'ID est différent du nom à afficher ou de la chaîne de clé. Vous pouvez obtenir l'ID à l'aide de la méthode keys.list. L'ID est listé dans le champ uid de la réponse.

Remplacez PROJECT_ID par l'ID ou le nom de votre projet Google Cloud .
```
curl -X GET \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
"https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/"
```
Utilisez la méthode keys.patch pour ajouter des restrictions de serveur (adresse IP) à une clé API.

Cette requête renvoie une opération de longue durée ; vous devez interroger l'opération pour savoir quand elle est terminée et obtenir l'état de l'opération.

Remplacez les valeurs suivantes :
- ALLOWED_IP_ADDR_1 : votre adresse IP autorisée.
  
  Vous pouvez ajouter autant d'adresses IP que nécessaire, en séparant les restrictions ainsi définies par des virgules. Vous devez fournir toutes les adresses IP avec la requête. Les restrictions fournies remplacent toutes les restrictions d'adresse IP existantes sur la clé.
- PROJECT_ID : ID ou nom de votre projet Google Cloud .
- KEY_ID : ID de la clé que vous souhaitez restreindre.
```
curl -X PATCH \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
--data '{
"restrictions" : {
  "serverKeyRestrictions": {
    "allowedIps": ["ALLOWED_IP_ADDR_1"]
  }
}
}' \
"https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/KEY_ID?updateMask=restrictions"
```

Pour en savoir plus sur l'ajout à une clé de restrictions d'adresse IP à l'aide de l'API REST, consultez la section Ajouter des restrictions de serveur dans la documentation de l'API "API Keys".

Applications Android

Vous pouvez limiter l'utilisation d'une clé API à des applications Android spécifiques. Vous devez indiquer le nom du package et l'empreinte de 20 octets du certificat SHA-1 pour chaque application.

Lorsque vous utilisez la clé API dans une requête, vous devez spécifier le nom du package et l'empreinte du certificat à l'aide des en-têtes HTTP suivants :

X-Android-Package
X-Android-Cert

Pour limiter votre clé API à une ou plusieurs applications Android, appliquez l'une des procédures suivantes.

Console

Dans la console Google Cloud , accédez à la page Identifiants :

Accéder à "Identifiants"
Cliquez sur le nom de la clé API que vous souhaitez restreindre.
Dans la section Restrictions liées aux applications, sélectionnez Applications Android.
Pour chaque application Android que vous souhaitez ajouter, cliquez sur Ajouter un élément, saisissez le nom du package et l'empreinte du certificat SHA-1, puis cliquez sur OK.
Cliquez sur Enregistrer pour enregistrer vos modifications et revenir à la liste des clés API.

gcloud

Obtenez l'ID de la clé que vous souhaitez restreindre.

L'ID est différent du nom à afficher ou de la chaîne de clé. Vous pouvez obtenir l'ID à l'aide de la commande gcloud services api-keys list pour lister les clés de votre projet.
Exécutez la commande gcloud services api-keys update pour spécifier les applications Android pouvant utiliser une clé API.

Remplacez les valeurs suivantes :
- KEY_ID : ID de la clé que vous souhaitez restreindre.
- SHA1_FINGERPRINT et PACKAGE_NAME : informations relatives à une application Android pouvant utiliser la clé.
  
  Vous pouvez ajouter autant d'applications que nécessaire, en utilisant des options --allowed-application supplémentaires.
```
gcloud services api-keys update KEY_ID \
--allowed-application=sha1_fingerprint=SHA1_FINGERPRINT_1,package_name=PACKAGE_NAME_1 \
--allowed-application=sha1_fingerprint=SHA1_FINGERPRINT_2,package_name=PACKAGE_NAME_2
```

Java

Pour exécuter cet exemple, vous devez installer la bibliothèque cliente google-cloud-apikeys.


import com.google.api.apikeys.v2.AndroidApplication;
import com.google.api.apikeys.v2.AndroidKeyRestrictions;
import com.google.api.apikeys.v2.ApiKeysClient;
import com.google.api.apikeys.v2.Key;
import com.google.api.apikeys.v2.Restrictions;
import com.google.api.apikeys.v2.UpdateKeyRequest;
import com.google.protobuf.FieldMask;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class RestrictApiKeyAndroid {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(Developer): Before running this sample,
    //  1. Replace the variable(s) below.
    String projectId = "GOOGLE_CLOUD_PROJECT_ID";

    // ID of the key to restrict. This ID is auto-created during key creation.
    // This is different from the key string. To obtain the key_id,
    // you can also use the lookup api: client.lookupKey()
    String keyId = "key_id";

    restrictApiKeyAndroid(projectId, keyId);
  }

  // Restricts an API key based on android applications.
  // Specifies the Android application that can use the key.
  public static void restrictApiKeyAndroid(String projectId, String keyId)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `apiKeysClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (ApiKeysClient apiKeysClient = ApiKeysClient.create()) {

      // Restrict the API key usage by specifying the allowed android applications.
      Restrictions restrictions = Restrictions.newBuilder()
          .setAndroidKeyRestrictions(AndroidKeyRestrictions.newBuilder()
              .addAllowedApplications(AndroidApplication.newBuilder()
                  // Specify the android application's package name and SHA1 fingerprint.
                  .setPackageName("com.google.appname")
                  .setSha1Fingerprint("0873D391E987982FBBD30873D391E987982FBBD3")
                  .build())
              .build())
          .build();

      Key key = Key.newBuilder()
          .setName(String.format("projects/%s/locations/global/keys/%s", projectId, keyId))
          // Set the restriction(s).
          // For more information on API key restriction, see:
          // https://cloud.google.com/docs/authentication/api-keys
          .setRestrictions(restrictions)
          .build();

      // Initialize request and set arguments.
      UpdateKeyRequest updateKeyRequest = UpdateKeyRequest.newBuilder()
          .setKey(key)
          .setUpdateMask(FieldMask.newBuilder().addPaths("restrictions").build())
          .build();

      // Make the request and wait for the operation to complete.
      Key result = apiKeysClient.updateKeyAsync(updateKeyRequest).get(3, TimeUnit.MINUTES);

      // For authenticating with the API key, use the value in "result.getKeyString()".
      System.out.printf("Successfully updated the API key: %s", result.getName());
    }
  }
}

Python

Pour exécuter cet exemple, vous devez installer la bibliothèque cliente des clés API.


from google.cloud import api_keys_v2
from google.cloud.api_keys_v2 import Key


def restrict_api_key_android(project_id: str, key_id: str) -> Key:
    """
    Restricts an API key based on android applications.

    Specifies the Android application that can use the key.

    TODO(Developer): Replace the variables before running this sample.

    Args:
        project_id: Google Cloud project id.
        key_id: ID of the key to restrict. This ID is auto-created during key creation.
            This is different from the key string. To obtain the key_id,
            you can also use the lookup api: client.lookup_key()

    Returns:
        response: Returns the updated API Key.
    """

    # Create the API Keys client.
    client = api_keys_v2.ApiKeysClient()

    # Specify the android application's package name and SHA1 fingerprint.
    allowed_application = api_keys_v2.AndroidApplication()
    allowed_application.package_name = "com.google.appname"
    allowed_application.sha1_fingerprint = "0873D391E987982FBBD30873D391E987982FBBD3"

    # Restrict the API key usage by specifying the allowed applications.
    android_key_restriction = api_keys_v2.AndroidKeyRestrictions()
    android_key_restriction.allowed_applications = [allowed_application]

    # Set the restriction(s).
    # For more information on API key restriction, see:
    # https://cloud.google.com/docs/authentication/api-keys
    restrictions = api_keys_v2.Restrictions()
    restrictions.android_key_restrictions = android_key_restriction

    key = api_keys_v2.Key()
    key.name = f"projects/{project_id}/locations/global/keys/{key_id}"
    key.restrictions = restrictions

    # Initialize request and set arguments.
    request = api_keys_v2.UpdateKeyRequest()
    request.key = key
    request.update_mask = "restrictions"

    # Make the request and wait for the operation to complete.
    response = client.update_key(request=request).result()

    print(f"Successfully updated the API key: {response.name}")
    # Use response.key_string to authenticate.
    return response

REST

Obtenez l'ID de la clé que vous souhaitez restreindre.

L'ID est différent du nom à afficher ou de la chaîne de clé. Vous pouvez obtenir l'ID à l'aide de la méthode keys.list. L'ID est listé dans le champ uid de la réponse.

Remplacez PROJECT_ID par l'ID ou le nom de votre projet Google Cloud .
```
curl -X GET \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
"https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/"
```
Utilisez la méthode keys.patch pour spécifier les applications Android pouvant utiliser une clé API.

Cette requête renvoie une opération de longue durée ; vous devez interroger l'opération pour savoir quand elle est terminée et obtenir l'état de l'opération.

Remplacez les valeurs suivantes :
- SHA1_FINGERPRINT_1 et PACKAGE_NAME_1 : informations relatives à une application Android pouvant utiliser la clé.
  
  Vous pouvez ajouter des informations pour autant d'applications que nécessaire, en utilisant des virgules pour séparer les objets AndroidApplication. Vous devez fournir toutes les applications avec la requête. Les applications fournies remplacent toutes les applications autorisées existantes sur la clé.
- PROJECT_ID : ID ou nom de votre projet Google Cloud .
- KEY_ID : ID de la clé que vous souhaitez restreindre.
```
curl -X PATCH \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
--data '{
"restrictions" : {
"androidKeyRestrictions": {
  "allowedApplications": [
    {
      "sha1Fingerprint": "SHA1_FINGERPRINT_1",
      "packageName": "PACKAGE_NAME_1"
    },
 ]
}
}
}' \
"https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/KEY_ID?updateMask=restrictions"
```

Pour en savoir plus sur l'ajout à une clé de restrictions sur les applications Android, à l'aide de l'API REST, consultez la section Ajouter des restrictions Android dans la documentation de l'API "API Keys".

Applications iOS

Vous pouvez restreindre l'utilisation d'une clé API à des applications iOS spécifiques en fournissant l'ID du bundle de chaque application.

Lorsque vous utilisez la clé API dans une requête, vous devez spécifier l'ID de groupe à l'aide de l'en-tête HTTP X-Ios-Bundle-Identifier.

Pour limiter votre clé API à une ou plusieurs applications iOS, appliquez l'une des procédures suivantes.

Console

Dans la console Google Cloud , accédez à la page Identifiants :

Accéder à "Identifiants"
Cliquez sur le nom de la clé API que vous souhaitez restreindre.
Dans la section Restrictions liées aux applications, sélectionnez Applications iOS.
Pour chaque application iOS que vous souhaitez ajouter, cliquez sur Ajouter un élément, saisissez l'ID du bundle, puis cliquez sur OK.
Cliquez sur Enregistrer pour enregistrer vos modifications et revenir à la liste des clés API.

gcloud

Obtenez l'ID de la clé que vous souhaitez restreindre.

L'ID est différent du nom à afficher ou de la chaîne de clé. Vous pouvez obtenir l'ID à l'aide de la commande gcloud services api-keys list pour lister les clés de votre projet.
Utilisez la méthode gcloud services api-keys update pour spécifier les applications iOS pouvant utiliser la clé.

Remplacez les valeurs suivantes :
- KEY_ID : ID de la clé que vous souhaitez restreindre.
- ALLOWED_BUNDLE_ID : ID de bundle d'une application iOS qui doit pouvoir utiliser cette clé API.
  
  Vous pouvez ajouter autant d'ID de bundle que nécessaire, en les séparant par des virgules.
```
gcloud services api-keys update KEY_ID \
--allowed-bundle-ids=ALLOWED_BUNDLE_ID_1,ALLOWED_BUNDLE_ID_2
```

Java

Pour exécuter cet exemple, vous devez installer la bibliothèque cliente google-cloud-apikeys.


import com.google.api.apikeys.v2.ApiKeysClient;
import com.google.api.apikeys.v2.IosKeyRestrictions;
import com.google.api.apikeys.v2.Key;
import com.google.api.apikeys.v2.Restrictions;
import com.google.api.apikeys.v2.UpdateKeyRequest;
import com.google.protobuf.FieldMask;
import java.io.IOException;
import java.util.Arrays;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class RestrictApiKeyIos {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(Developer): Before running this sample,
    //  1. Replace the variable(s) below.
    String projectId = "GOOGLE_CLOUD_PROJECT_ID";

    // ID of the key to restrict. This ID is auto-created during key creation.
    // This is different from the key string. To obtain the key_id,
    // you can also use the lookup api: client.lookupKey()
    String keyId = "key_id";

    restrictApiKeyIos(projectId, keyId);
  }

  // Restricts an API key. You can restrict usage of an API key to specific iOS apps
  // by providing the bundle ID of each app.
  public static void restrictApiKeyIos(String projectId, String keyId)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `apiKeysClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (ApiKeysClient apiKeysClient = ApiKeysClient.create()) {

      // Restrict the API key usage by specifying the bundle ID(s)
      // of iOS app(s) that can use the key.
      Restrictions restrictions = Restrictions.newBuilder()
          .setIosKeyRestrictions(IosKeyRestrictions.newBuilder()
              .addAllAllowedBundleIds(Arrays.asList("com.google.gmail", "com.google.drive"))
              .build())
          .build();

      Key key = Key.newBuilder()
          .setName(String.format("projects/%s/locations/global/keys/%s", projectId, keyId))
          // Set the restriction(s).
          // For more information on API key restriction, see:
          // https://cloud.google.com/docs/authentication/api-keys
          .setRestrictions(restrictions)
          .build();

      // Initialize request and set arguments.
      UpdateKeyRequest updateKeyRequest = UpdateKeyRequest.newBuilder()
          .setKey(key)
          .setUpdateMask(FieldMask.newBuilder().addPaths("restrictions").build())
          .build();

      // Make the request and wait for the operation to complete.
      Key result = apiKeysClient.updateKeyAsync(updateKeyRequest).get(3, TimeUnit.MINUTES);

      // For authenticating with the API key, use the value in "result.getKeyString()".
      System.out.printf("Successfully updated the API key: %s", result.getName());
    }
  }
}

Python

Pour exécuter cet exemple, vous devez installer la bibliothèque cliente des clés API.


from google.cloud import api_keys_v2
from google.cloud.api_keys_v2 import Key


def restrict_api_key_ios(project_id: str, key_id: str) -> Key:
    """
    Restricts an API key. You can restrict usage of an API key to specific iOS apps
    by providing the bundle ID of each app.

    TODO(Developer): Replace the variables before running this sample.

    Args:
        project_id: Google Cloud project id.
        key_id: ID of the key to restrict. This ID is auto-created during key creation.
            This is different from the key string. To obtain the key_id,
            you can also use the lookup api: client.lookup_key()

    Returns:
        response: Returns the updated API Key.
    """

    # Create the API Keys client.
    client = api_keys_v2.ApiKeysClient()

    # Restrict the API key usage by specifying the bundle ID(s) of iOS app(s) that can use the key.
    ios_key_restrictions = api_keys_v2.IosKeyRestrictions()
    ios_key_restrictions.allowed_bundle_ids = ["com.google.gmail", "com.google.drive"]

    # Set the API restriction.
    # For more information on API key restriction, see:
    # https://cloud.google.com/docs/authentication/api-keys
    restrictions = api_keys_v2.Restrictions()
    restrictions.ios_key_restrictions = ios_key_restrictions

    key = api_keys_v2.Key()
    key.name = f"projects/{project_id}/locations/global/keys/{key_id}"
    key.restrictions = restrictions

    # Initialize request and set arguments.
    request = api_keys_v2.UpdateKeyRequest()
    request.key = key
    request.update_mask = "restrictions"

    # Make the request and wait for the operation to complete.
    response = client.update_key(request=request).result()

    print(f"Successfully updated the API key: {response.name}")
    # Use response.key_string to authenticate.
    return response

REST

Obtenez l'ID de la clé que vous souhaitez restreindre.

L'ID est différent du nom à afficher ou de la chaîne de clé. Vous pouvez obtenir l'ID à l'aide de la méthode keys.list. L'ID est listé dans le champ uid de la réponse.

Remplacez PROJECT_ID par l'ID ou le nom de votre projet Google Cloud .
```
curl -X GET \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
"https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/"
```
Utilisez la méthode keys.patch pour spécifier les applications iOS pouvant utiliser une clé API.

Cette requête renvoie une opération de longue durée ; vous devez interroger l'opération pour savoir quand elle est terminée et obtenir l'état de l'opération.

Remplacez les valeurs suivantes :
- ALLOWED_BUNDLE_ID : ID de bundle d'une application iOS pouvant utiliser la clé.
  
  Vous pouvez ajouter les informations pour autant d'applications que nécessaire ; utilisez des virgules pour séparer les ID de groupe. Vous devez fournir tous les ID de groupe avec la requête ; les ID de groupe fournis remplacent les applications autorisées existantes sur la clé.
- PROJECT_ID : ID ou nom de votre projet Google Cloud .
- KEY_ID : ID de la clé que vous souhaitez restreindre.
```
curl -X PATCH \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
--data '{
"restrictions" : {
"iosKeyRestrictions": {
  "allowedBundleIds": ["ALLOWED_BUNDLE_ID_1","ALLOWED_BUNDLE_ID_2"]
}
}
}' \
"https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/KEY_ID?updateMask=restrictions"
```

Pour en savoir plus sur l'ajout à une clé de restrictions sur les applications iOS, à l'aide de l'API REST, consultez la section Ajouter des restrictions iOS dans la documentation de l'API "API Keys".

Ajouter des restrictions liées aux API

Les restrictions relatives aux API définissent les API qui peuvent être appelées à l'aide de la clé API.

Appliquez l'une des procédures suivantes pour ajouter des restrictions liées aux API.

Console

Dans la console Google Cloud , accédez à la page Identifiants :

Accéder à "Identifiants"
Cliquez sur le nom de la clé API que vous souhaitez restreindre.
Dans la section Restrictions relatives aux API, cliquez sur Restreindre la clé.
Sélectionnez toutes les API dont l'accès nécessitera votre clé API.
Cliquez sur Enregistrer pour enregistrer vos modifications et revenir à la liste des clés API.

gcloud

Obtenez l'ID de la clé que vous souhaitez restreindre.

L'ID est différent du nom à afficher ou de la chaîne de clé. Vous pouvez obtenir l'ID à l'aide de la commande gcloud services api-keys list pour lister les clés de votre projet.
Spécifiez les services auxquels une clé API peut être utilisée pour accéder à l'aide de la commande gcloud services api-keys update.

Remplacez les valeurs suivantes :
- KEY_ID : ID de la clé que vous souhaitez restreindre.
- SERVICE_1, SERVICE_2 : noms des services des API auxquels la clé peut accéder.
  
  Vous devez fournir tous les noms de services via la commande update ; Les noms de services fournis remplacent tous les services existants sur la clé.
Vous pouvez trouver le nom du service en recherchant l'API sur le tableau de bord des API. Les noms de service sont des chaînes telles que bigquery.googleapis.com.
```
gcloud services api-keys update KEY_ID \
--api-target=service=SERVICE_1 --api-target=service=SERVICE_2
```

Java

Pour exécuter cet exemple, vous devez installer la bibliothèque cliente google-cloud-apikeys.


import com.google.api.apikeys.v2.ApiKeysClient;
import com.google.api.apikeys.v2.ApiTarget;
import com.google.api.apikeys.v2.Key;
import com.google.api.apikeys.v2.Restrictions;
import com.google.api.apikeys.v2.UpdateKeyRequest;
import com.google.protobuf.FieldMask;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class RestrictApiKeyApi {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(Developer): Before running this sample,
    //  1. Replace the variable(s) below.
    String projectId = "GOOGLE_CLOUD_PROJECT_ID";

    // ID of the key to restrict. This ID is auto-created during key creation.
    // This is different from the key string. To obtain the key_id,
    // you can also use the lookup api: client.lookupKey()
    String keyId = "key_id";

    restrictApiKeyApi(projectId, keyId);
  }

  // Restricts an API key. Restrictions specify which APIs can be called using the API key.
  public static void restrictApiKeyApi(String projectId, String keyId)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `apiKeysClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (ApiKeysClient apiKeysClient = ApiKeysClient.create()) {

      // Restrict the API key usage by specifying the target service and methods.
      // The API key can only be used to authenticate the specified methods in the service.
      Restrictions restrictions = Restrictions.newBuilder()
          .addApiTargets(ApiTarget.newBuilder()
              .setService("translate.googleapis.com")
              .addMethods("translate.googleapis.com.TranslateText")
              .build())
          .build();

      Key key = Key.newBuilder()
          .setName(String.format("projects/%s/locations/global/keys/%s", projectId, keyId))
          // Set the restriction(s).
          // For more information on API key restriction, see:
          // https://cloud.google.com/docs/authentication/api-keys
          .setRestrictions(restrictions)
          .build();

      // Initialize request and set arguments.
      UpdateKeyRequest updateKeyRequest = UpdateKeyRequest.newBuilder()
          .setKey(key)
          .setUpdateMask(FieldMask.newBuilder().addPaths("restrictions").build())
          .build();

      // Make the request and wait for the operation to complete.
      Key result = apiKeysClient.updateKeyAsync(updateKeyRequest).get(3, TimeUnit.MINUTES);

      // For authenticating with the API key, use the value in "result.getKeyString()".
      System.out.printf("Successfully updated the API key: %s", result.getName());
    }
  }
}

Python

Pour exécuter cet exemple, vous devez installer la bibliothèque cliente des clés API.


from google.cloud import api_keys_v2
from google.cloud.api_keys_v2 import Key


def restrict_api_key_api(project_id: str, key_id: str) -> Key:
    """
    Restricts an API key. Restrictions specify which APIs can be called using the API key.

    TODO(Developer): Replace the variables before running the sample.

    Args:
        project_id: Google Cloud project id.
        key_id: ID of the key to restrict. This ID is auto-created during key creation.
            This is different from the key string. To obtain the key_id,
            you can also use the lookup api: client.lookup_key()

    Returns:
        response: Returns the updated API Key.
    """

    # Create the API Keys client.
    client = api_keys_v2.ApiKeysClient()

    # Restrict the API key usage by specifying the target service and methods.
    # The API key can only be used to authenticate the specified methods in the service.
    api_target = api_keys_v2.ApiTarget()
    api_target.service = "translate.googleapis.com"
    api_target.methods = ["transate.googleapis.com.TranslateText"]

    # Set the API restriction(s).
    # For more information on API key restriction, see:
    # https://cloud.google.com/docs/authentication/api-keys
    restrictions = api_keys_v2.Restrictions()
    restrictions.api_targets = [api_target]

    key = api_keys_v2.Key()
    key.name = f"projects/{project_id}/locations/global/keys/{key_id}"
    key.restrictions = restrictions

    # Initialize request and set arguments.
    request = api_keys_v2.UpdateKeyRequest()
    request.key = key
    request.update_mask = "restrictions"

    # Make the request and wait for the operation to complete.
    response = client.update_key(request=request).result()

    print(f"Successfully updated the API key: {response.name}")
    # Use response.key_string to authenticate.
    return response

REST

Obtenez l'ID de la clé que vous souhaitez restreindre.

L'ID est différent du nom à afficher ou de la chaîne de clé. Vous pouvez obtenir l'ID à l'aide de la méthode keys.list. L'ID est listé dans le champ uid de la réponse.

Remplacez PROJECT_ID par l'ID ou le nom de votre projet Google Cloud .
```
curl -X GET \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
"https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/"
```
Utilisez la méthode keys.patch pour spécifier les services auxquels une clé API peut accéder.

Cette requête renvoie une opération de longue durée ; vous devez interroger l'opération pour savoir quand elle est terminée et obtenir l'état de l'opération.

Remplacez les valeurs suivantes :
- SERVICE_1, SERVICE_2 : noms des services des API auxquels la clé peut accéder.
  
  Vous devez fournir tous les noms de services dans la requête ; ceux-ci remplacent tous les services existants sur la clé.
  
  Vous pouvez trouver le nom du service en recherchant l'API sur le tableau de bord des API. Les noms de service sont des chaînes telles que bigquery.googleapis.com.
- PROJECT_ID : ID ou nom de votre projet Google Cloud .
- KEY_ID : ID de la clé que vous souhaitez restreindre.
```
curl -X PATCH \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
--data '{
"restrictions" : {
"apiTargets": [
  {
    "service": "SERVICE_1"
  },
  {
    "service" : "SERVICE_2"
  },
]
}
}' \
"https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/KEY_ID?updateMask=restrictions"
```

Pour en savoir plus sur l'ajout à une clé de restrictions sur les API, à l'aide de l'API REST, consultez la section Ajouter des restrictions d'API dans la documentation de l'API "API Keys".

Obtenir des informations sur le projet à partir d'une chaîne de clé

Vous pouvez déterminer le projet Google Cloud auquel une clé API est associée à partir de sa chaîne.

Remplacez KEY_STRING par la chaîne de clé pour laquelle vous souhaitez identifier le projet associé.

gcloud

Exécutez la commande gcloud services api-keys lookup pour obtenir l'ID du projet à partir d'une chaîne de clé.

 gcloud services api-keys lookup KEY_STRING

Java

Pour exécuter cet exemple, vous devez installer la bibliothèque cliente google-cloud-apikeys.


import com.google.api.apikeys.v2.ApiKeysClient;
import com.google.api.apikeys.v2.LookupKeyRequest;
import com.google.api.apikeys.v2.LookupKeyResponse;
import java.io.IOException;

public class LookupApiKey {

  public static void main(String[] args) throws IOException {
    // TODO(Developer): Before running this sample,
    //  1. Replace the variable(s) below.
    //  2. Set up ADC as described in https://cloud.google.com/docs/authentication/external/set-up-adc
    //  3. Make sure you have the necessary permission to view API keys.
    // API key string to retrieve the API key name.
    String apiKeyString = "API_KEY_STRING";

    lookupApiKey(apiKeyString);
  }

  // Retrieves name (full path) of an API key using the API key string.
  public static void lookupApiKey(String apiKeyString) 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. After completing all of your requests, call
    // the `apiKeysClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (ApiKeysClient apiKeysClient = ApiKeysClient.create()) {

      // Initialize the lookup request and set the API key string.
      LookupKeyRequest lookupKeyRequest = LookupKeyRequest.newBuilder()
          .setKeyString(apiKeyString)
          .build();

      // Make the request and obtain the response.
      LookupKeyResponse response = apiKeysClient.lookupKey(lookupKeyRequest);

      System.out.printf("Successfully retrieved the API key name: %s", response.getName());
    }
  }
}

Python

Pour exécuter cet exemple, vous devez installer la bibliothèque cliente des clés API.


from google.cloud import api_keys_v2


def lookup_api_key(api_key_string: str) -> None:
    """
    Retrieves name (full path) of an API key using the API key string.

    TODO(Developer):
    1. Before running this sample,
      set up ADC as described in https://cloud.google.com/docs/authentication/external/set-up-adc
    2. Make sure you have the necessary permission to view API keys.

    Args:
        api_key_string: API key string to retrieve the API key name.
    """

    # Create the API Keys client.
    client = api_keys_v2.ApiKeysClient()

    # Initialize the lookup request and set the API key string.
    lookup_key_request = api_keys_v2.LookupKeyRequest(
        key_string=api_key_string,
        # Optionally, you can also set the etag (version).
        # etag=etag,
    )

    # Make the request and obtain the response.
    lookup_key_response = client.lookup_key(lookup_key_request)

    print(f"Successfully retrieved the API key name: {lookup_key_response.name}")

REST

Utilisez la méthode lookupKey pour obtenir l'ID du projet à partir d'une chaîne de clé.

curl -X GET \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
"https://apikeys.googleapis.com/v2/keys:lookupKey?keyString=KEY_STRING"

Créer une copie d'une clé API

Si vous avez besoin d'une nouvelle clé API avec les mêmes restrictions qu'une clé API existante, vous pouvez créer une copie de la clé API existante. Cette opération crée une clé API avec une chaîne et un ID uniques, ainsi que les restrictions de la clé API existante.

L'opération de copie n'est disponible que dans la console Google Cloud . Pour utiliser d'autres méthodes, suivez les étapes pour créer une clé API, puis appliquez les mêmes restrictions de clé API à la clé API nouvellement générée.

Dans la console Google Cloud , accédez à la page Identifiants :

Accéder à "Identifiants"
Cliquez sur le nom de la clé API que vous souhaitez copier.

La page d'informations de la clé API s'ouvre.
Cliquez sur Créer une copie.
Saisissez un nom pour la nouvelle clé API et vérifiez que les restrictions sont correctes.
Cliquez sur Créer.

Faire pivoter une clé API

En alternant régulièrement vos clés API, vous pouvez limiter l'impact de toute clé API compromise.

Lorsque vous faites pivoter une clé API, vous créez une clé avec les mêmes restrictions que l'ancienne et vous mettez à jour vos applications pour qu'elles utilisent la nouvelle clé. Une fois toutes vos applications mises à jour, supprimez l'ancienne clé.

L'opération de rotation n'est disponible que dans la console Google Cloud . Pour utiliser d'autres méthodes, suivez les étapes pour créer une clé API, puis appliquez les mêmes restrictions de clé API à la clé API nouvellement générée. Une fois que vous avez mis à jour vos applications pour qu'elles utilisent la nouvelle clé, supprimez l'ancienne clé.

Dans la console Google Cloud , accédez à la page Identifiants :

Accéder à "Identifiants"
Cliquez sur le nom de la clé API que vous souhaitez faire pivoter pour ouvrir sa page d'informations.
Cliquez sur Effectuer une rotation de la clé.
Saisissez un nom pour la nouvelle clé API et vérifiez que les restrictions sont correctes.
Cliquez sur Créer.
Copiez la chaîne de clé et mettez à jour vos applications pour qu'elles utilisent la nouvelle chaîne.
Une fois que vous avez mis à jour toutes les applications pour qu'elles utilisent la nouvelle clé, revenez à la page d'informations de la nouvelle clé. Dans la section Clé précédente, cliquez sur Supprimer la clé précédente pour supprimer l'ancienne clé.

Si vous vous rendez compte que vous avez supprimé l'ancienne clé trop tôt, vous pouvez annuler la suppression.

Annuler la suppression d'une clé API

Si vous supprimez une clé API par erreur, vous pouvez annuler sa suppression (la restaurer) dans les 30 jours suivant l'opération. Passé ce délai, vous ne pouvez plus annuler la suppression de la clé API.

Console

Dans la console Google Cloud , accédez à la page Identifiants :

Accéder à "Identifiants"
Cliquez sur Restaurer des identifiants supprimés.
Recherchez la clé API supprimée dont vous souhaitez annuler la suppression, puis cliquez sur Restaurer.

L'annulation de la suppression d'une clé API peut prendre quelques minutes pour se propager. Après la propagation, la clé API dont la suppression a été annulée s'affiche dans la liste des clés API.

gcloud

Obtenez l'ID de la clé dont vous souhaitez annuler la suppression.

L'ID est différent du nom à afficher ou de la chaîne de clé. Vous pouvez obtenir l'ID à l'aide de la commande gcloud services api-keys list --show-deleted pour lister les clés supprimées de votre projet.
Exécutez la commande gcloud services api-keys undelete pour annuler la suppression d'une clé API.
```
gcloud services api-keys undelete KEY_ID
```
Remplacez les valeurs suivantes :
- KEY_ID : ID de la clé dont vous souhaitez annuler la suppression.

Java

Pour exécuter cet exemple, vous devez installer la bibliothèque cliente google-cloud-apikeys.

import com.google.api.apikeys.v2.ApiKeysClient;
import com.google.api.apikeys.v2.Key;
import com.google.api.apikeys.v2.UndeleteKeyRequest;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class UndeleteApiKey {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Google Cloud project.
    String projectId = "YOUR_PROJECT_ID";
    // The API key id to undelete.
    String keyId = "YOUR_KEY_ID";

    undeleteApiKey(projectId, keyId);
  }

  // Undeletes an API key.
  public static void undeleteApiKey(String projectId, String keyId)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // 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 (ApiKeysClient apiKeysClient = ApiKeysClient.create()) {

      // Initialize the undelete request and set the argument.
      UndeleteKeyRequest undeleteKeyRequest = UndeleteKeyRequest.newBuilder()
          .setName(String.format("projects/%s/locations/global/keys/%s", projectId, keyId))
          .build();

      // Make the request and wait for the operation to complete.
      Key undeletedKey = apiKeysClient.undeleteKeyAsync(undeleteKeyRequest)
          .get(3, TimeUnit.MINUTES);

      System.out.printf("Successfully undeleted the API key: %s", undeletedKey.getName());
    }
  }
}

REST

Obtenez l'ID de la clé dont vous souhaitez annuler la suppression.

L'ID est différent du nom à afficher ou de la chaîne de clé. Vous pouvez obtenir l'ID à l'aide de la méthode keys.list, avec le paramètre de requête showDeleted défini sur true. L'ID est listé dans le champ uid de la réponse.

Remplacez PROJECT_ID par l'ID ou le nom de votre projet Google Cloud .
```
curl -X GET \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
"https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys?showDeleted=true"
```
Utilisez la méthode undelete pour annuler la suppression de la clé API.
```
curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
"https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/KEY_ID:undelete"
```
Cette requête renvoie une opération de longue durée ; vous devez interroger l'opération pour savoir quand elle est terminée et obtenir l'état de l'opération.

Remplacez les valeurs suivantes :
- PROJECT_ID : ID ou nom de votre projet Google Cloud .
- KEY_ID : ID de la clé que vous souhaitez restreindre.

Déterminer le type de clé API

Vous pouvez déterminer si la clé API est liée à un compte de service en l'inspectant.

Console

Dans la console Google Cloud , accédez à la page Identifiants :

Accéder à "Identifiants"

Si la clé API est liée à un compte de service, l'identifiant du compte de service s'affiche.

gcloud

Obtenez l'ID de la clé.

L'ID est différent du nom à afficher ou de la chaîne de clé. Vous pouvez obtenir l'ID à l'aide de la commande gcloud services api-keys list pour lister les clés de votre projet.
Exécutez la commande gcloud services api-keys describe pour décrire la clé API.
```
gcloud services api-keys describe KEY_ID
```
Si la clé API est liée à un compte de service, le champ serviceAccountEmail s'affiche.

Interroger des opérations de longue durée

Les méthodes de l'API "API Keys" utilisent des opérations de longue durée. Si vous utilisez l'API REST pour créer et gérer des clés API, un objet d'opération est renvoyé par la requête de méthode initiale. Vous devez utiliser le nom de l'opération pour interroger l'opération de longue durée. Lorsque la requête de longue durée est terminée, l'interrogation de l'opération va renvoyer les données de la requête de longue durée.

Pour interroger une opération de longue durée de l'API "API Keys", vous devez utiliser la méthode operations.get.

Remplacez OPERATION_NAME par le nom d'opération renvoyé par l'opération de longue durée. Exemple : operations/akmf.p7-358517206116-cd10a88a-7740-4403-a8fd-979f3bd7fe1c.

curl -X GET \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json; charset=utf-8" \
    "https://apikeys.googleapis.com/v2/OPERATION_NAME"

Limites concernant les clés API

Vous pouvez créer jusqu'à 300 clés API par projet. Il s'agit d'une limite du système qui ne peut pas être modifiée par une demande d'augmentation de quota. Si vous avez besoin de plus de clés d'API, vous devez utiliser plusieurs projets.

Vous pouvez ajouter jusqu'à 1 200 restrictions d'application à une clé API.

Étapes suivantes

Découvrez les bonnes pratiques pour sécuriser vos clés API.
Apprenez-en plus sur l'API "API Keys".