Questa pagina è stata tradotta dall'API Cloud Translation.

Gestisci chiavi API

Questa pagina descrive come creare, modificare e limitare le chiavi API. Per informazioni su come utilizzare le chiavi API per accedere alle API di Google, consulta Utilizzare le chiavi API per accedere alle API.

Introduzione alle chiavi API

Esistono due tipi di chiavi API: chiavi API standard e chiavi API associate a un account di servizio.

Chiavi API standard

Le chiavi API standard forniscono un modo per associare una richiesta a un progetto a fini di fatturazione e quota. Quando utilizzi una chiave API standard (una chiave API non associata a un account di servizio) per accedere a un'API, la chiave API non identifica un principal. Senza un principal, la richiesta non può utilizzare Identity and Access Management (IAM) per verificare se il chiamante è autorizzato a eseguire l'operazione richiesta.

Le chiavi API standard possono essere utilizzate con qualsiasi API che le accetta, a meno che non siano state aggiunte limitazioni API alla chiave. Le chiavi API standard non possono essere utilizzate con servizi che non accettano chiavi API, inclusa la modalità express.

Chiavi API associate a un account di servizio

Le chiavi API associate a un account di servizio forniscono l'identità e l'autorizzazione delaccount di serviziot a una richiesta. Quando utilizzi una chiave API associata a un account di servizio per accedere a un'API, la tua richiesta viene elaborata come se avessi utilizzato il account di servizio associato per effettuare la richiesta.

L'unica API che supporta le chiavi API associate è aiplatform.googleapis.com.

L'associazione di chiavi a un account di servizio è impedita da un vincolo dei criteri dell'organizzazione predefinito. Per modificare questa impostazione, consulta la sezione Attivare il binding delle chiavi ai service account.

Componenti della chiave API

Una chiave API è composta dai seguenti componenti, che ti consentono di gestire e utilizzare la chiave:

Stringa: La stringa della chiave API è una stringa criptata, ad esempio, AIzaSyDaGmWKa4JsXZ-HjGw7ISLn_3namBGewQe. Quando utilizzi una chiave API per accedere a un'API, utilizzi sempre la stringa della chiave. Le chiavi API non hanno un file JSON associato.
ID: L'ID chiave API viene utilizzato dagli Google Cloud strumenti amministrativi per identificare in modo univoco la chiave. L'ID chiave non può essere utilizzato per accedere alle API. L'ID chiave si trova nell'URL della pagina di modifica della chiave nella console Google Cloud . Puoi anche ottenere l'ID chiave utilizzando Google Cloud CLI per elencare le chiavi nel tuo progetto.
Nome visualizzato: Il nome visualizzato è un nome descrittivo facoltativo per la chiave, che puoi impostare quando crei o aggiorni la chiave.
Account di servizio associato: Le chiavi API associate a un account di servizio includono l'indirizzo email del account di servizio.

Prima di iniziare

Completa le seguenti attività per utilizzare gli esempi in questa pagina.

Configura l'autenticazione

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

Per utilizzare gli esempi di C++ questa pagina in un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura le Credenziali predefinite dell'applicazione con le tue credenziali utente.

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.
To initialize the gcloud CLI, run the following command:
```
gcloud init
```
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.

Per saperne di più, consulta Configura ADC per un ambiente di sviluppo locale nella documentazione sull'autenticazione Google Cloud .

Java

Per utilizzare gli esempi di Java questa pagina in un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura le Credenziali predefinite dell'applicazione con le tue credenziali utente.

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.
To initialize the gcloud CLI, run the following command:
```
gcloud init
```
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.

Per saperne di più, consulta Configura ADC per un ambiente di sviluppo locale nella documentazione sull'autenticazione Google Cloud .

Python

Per utilizzare gli esempi di Python questa pagina in un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura le Credenziali predefinite dell'applicazione con le tue credenziali utente.

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.
To initialize the gcloud CLI, run the following command:
```
gcloud init
```
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.

Per saperne di più, consulta Configura ADC per un ambiente di sviluppo locale nella documentazione sull'autenticazione Google Cloud .

REST

Per utilizzare gli esempi di API REST in questa pagina in un ambiente di sviluppo locale, utilizzi le credenziali che fornisci a gcloud CLI.

After installing the Google Cloud CLI, initialize it by running the following command:

gcloud init

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

Per saperne di più, consulta la sezione Autenticarsi per l'utilizzo di REST nella documentazione sull'autenticazione di Google Cloud .

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per gestire le chiavi API, chiedi all'amministratore di concederti i seguenti ruoli IAM sul progetto:

Amministratore chiavi API (roles/serviceusage.apiKeysAdmin)
Limita una chiave API a API specifiche utilizzando la console Google Cloud : Visualizzatore utilizzo servizio (roles/serviceusage.serviceUsageViewer)

Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Attiva l'associazione delle chiavi ai service account

Prima di poter associare una chiave API a un service account, devi prima impostare il vincolo dei criteri dell'organizzazione constraints/iam.managed.disableServiceAccountApiKeyCreation su false. La modifica del criterio dell'organizzazione richiede una risorsa organizzazione associata. I progetti senza un'organizzazione non sono supportati.

Per modificare il vincolo di policy, completa le seguenti istruzioni.

Console

Nella console Google Cloud , vai alla pagina Policy dell'organizzazione.

Vai a Policy dell'organizzazione
Passa all'organizzazione, alla cartella o al progetto per cui vuoi modificare i criteri.
Nella casella Filtro, inserisci Block service e fai clic sul nome del filtro Blocca i binding delle chiavi API dell'account di servizio.
Fai clic su Gestisci policy.
Nella sezione Origine policy, seleziona Esegui override della policy dell'unità organizzativa principale.
Fai clic su Aggiungi una regola e imposta Applicazione su Off.
Fai clic su Fine.
(Facoltativo) Fai clic su Testa modifiche per avere un'idea di come la policy proposta potrebbe causare violazioni o interruzioni della conformità.
Fai clic su Imposta criterio.

gcloud

Crea un file denominato spec.yaml con il seguente contenuto:
```
name: SCOPE/SCOPE_ID/policies/iam.managed.disableServiceAccountApiKeyCreation
spec:
  rules:
  - enforce: false
```
Fornisci i seguenti valori:
- SCOPE: organizations, folders o projects.
- SCOPE_ID: a seconda di SCOPE, l'ID dell'organizzazione, della cartella o del progetto a cui si applica la policy dell'organizzazione.
Esegui il comando gcloud seguente per consentire il binding delle chiavi API agli account di servizio:
```
gcloud org-policies set-policy spec.yaml \
    --update-mask spec
```

Crea una chiave API

Per creare una chiave API, utilizza una delle seguenti opzioni:

Console

Nella console Google Cloud , vai alla pagina Credenziali:

Vai a credenziali
Fai clic su Crea credenziali e poi seleziona Chiave API dal menu.
(Facoltativo) Per associare la chiave API a un account di servizio, seleziona la casella di controllo Autentica le chiamate API tramite un service account e poi fai clic su Seleziona un service account per selezionare il account di servizio che vuoi associare alla chiave.

Per saperne di più, consulta la sezione Chiavi API associate a un service account.
Aggiungi limitazioni relative alle chiavi API.

La limitazione delle chiavi API è una best practice. Per maggiori informazioni, vedi Applicare le limitazioni relative alle chiavi API.
Fai clic su Crea. La finestra di dialogo Chiave API creata mostra la stringa per la chiave appena creata.

gcloud

Utilizza il comando gcloud services api-keys create per creare una chiave API.

Sostituisci DISPLAY_NAME con un nome descrittivo per la chiave.

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

(Facoltativo) Per associare la chiave API a un account di servizio, utilizza gcloud beta invece, con il flag --service-account:

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

Per ulteriori informazioni, consulta la sezione Chiavi API associate a un service account.

C++

Per eseguire questo esempio, devi installare la libreria client API Keys.

#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

Per eseguire questo esempio, devi installare la libreria client 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

Per eseguire questo esempio, devi installare la libreria client API Keys.


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

Utilizza il metodo keys.create per creare una chiave API. Questa richiesta restituisce un'operazione di lunga durata; devi eseguire il polling dell'operazione per ottenere le informazioni per la nuova chiave.

Sostituisci i seguenti valori:

DISPLAY_NAME: (Facoltativo). Un nome descrittivo per la chiave.
PROJECT_ID: il tuo ID progetto o nome del progetto 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"

(Facoltativo) Per associare la chiave API a un account di servizio, utilizza il seguente comando:

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"

Per saperne di più, consulta la sezione Chiavi API associate a un service account.

Per saperne di più sulla creazione di chiavi API utilizzando l'API REST, consulta la sezione Creazione di una chiave API nella documentazione dell'API API Keys.

Applica le limitazioni relative alle chiavi API

Per impostazione predefinita, le chiavi API non sono soggette a restrizioni. Le chiavi senza limitazioni non sono sicure perché possono essere utilizzate da chiunque e ovunque. Per le applicazioni di produzione, devi impostare sia le limitazioni delle applicazioni sia le limitazioni delle API.

Aggiungere limitazioni delle applicazioni

Le limitazioni delle applicazioni specificano quali siti web, indirizzi IP o app possono utilizzare una chiave API.

Puoi applicare un solo tipo di limitazione delle applicazioni alla volta. Scegli il tipo di limitazione in base al tipo di applicazione:

Opzione	Tipo di applicazione	Note
Referrer HTTP	Applicazioni web	Specifica i siti web che possono utilizzare la chiave.
Indirizzi IP	Applicazioni chiamate da server specifici	Specifica i server o i cron job che possono utilizzare la chiave. Questa è l'unica limitazione disponibile se associ la chiave API a un account di servizio.
App per Android	App Android	Specifica l'applicazione Android che può utilizzare la chiave.
App per iOS	Applicazioni iOS	Specifica i bundle iOS che possono utilizzare la chiave.

Referrer HTTP

Per limitare i siti web che possono utilizzare la tua chiave API, aggiungi una o più limitazioni del referrer HTTP.

Puoi sostituire un carattere jolly (*) con il sottodominio o il percorso, ma non puoi inserire un carattere jolly al centro dell'URL. Ad esempio, *.example.com è valido e accetta tutti i siti che terminano con .example.com. Tuttavia, mysubdomain*.example.com non è una limitazione valida.

I numeri di porta possono essere inclusi nelle limitazioni referrer HTTP. Se includi un numero di porta, vengono abbinate solo le richieste che utilizzano quella porta. Se non specifica un numero di porta, le richieste provenienti da qualsiasi numero di porta vengono abbinate.

La tabella seguente mostra alcuni scenari di esempio e le limitazioni del browser:

Scenario Restrizioni

Consentire un URL specifico

Scenario	Restrizioni
Consentire un URL specifico	Aggiungi un URL con un percorso esatto. Ad esempio: `www.example.com/path` `www.example.com/path/path` Alcuni browser implementano un criterio referrer che invia solo l'URL di origine per le richieste multiorigine. Gli utenti di questi browser non possono utilizzare chiavi con limitazioni degli URL specifiche per la pagina.
Consenti qualsiasi URL nel tuo sito	Devi impostare due URL nell'elenco `allowedReferers`. URL per il dominio, senza un sottodominio e con un carattere jolly per il percorso. Ad esempio: `example.com/` Un secondo URL che include un carattere jolly per il sottodominio e un carattere jolly per il percorso. Ad esempio: `.example.com/*`
Consenti qualsiasi URL in un singolo sottodominio o dominio nudo	Devi impostare due URL nell'elenco `allowedReferers` per consentire un intero dominio: URL del dominio, senza barra finale. Ad esempio: `www.example.com` `sub.example.com` `example.com` Un secondo URL per il dominio che include un carattere jolly per il percorso. Ad esempio: `www.example.com/` `sub.example.com/` `example.com/*`

Aggiungi un URL con un percorso esatto. Ad esempio:
www.example.com/path
www.example.com/path/path

Alcuni browser implementano un criterio referrer che invia solo l'URL di origine per le richieste multiorigine. Gli utenti di questi browser non possono utilizzare chiavi con limitazioni degli URL specifiche per la pagina.

Consenti qualsiasi URL nel tuo sito

Devi impostare due URL nell'elenco allowedReferers.

URL per il dominio, senza un sottodominio e con un carattere jolly per il percorso. Ad esempio:
example.com/*
Un secondo URL che include un carattere jolly per il sottodominio e un carattere jolly per il percorso. Ad esempio:
*.example.com/*

Consenti qualsiasi URL in un singolo sottodominio o dominio nudo

Devi impostare due URL nell'elenco allowedReferers per consentire un intero dominio:

URL del dominio, senza barra finale. Ad esempio:
www.example.com
sub.example.com
example.com
Un secondo URL per il dominio che include un carattere jolly per il percorso. Ad esempio:
www.example.com/*
sub.example.com/*
example.com/*

Per limitare la tua chiave API a siti web specifici, utilizza una delle seguenti opzioni:

Console

Nella console Google Cloud , vai alla pagina Credenziali:

Vai a credenziali
Fai clic sul nome della chiave API che vuoi limitare.
Nella sezione Restrizioni delle applicazioni, seleziona Referrer HTTP.
Per ogni limitazione da aggiungere, fai clic su Aggiungi un elemento, inserisci la limitazione e fai clic su Fine.
Fai clic su Salva per salvare le modifiche e tornare all'elenco delle chiavi API.

gcloud

Recupera l'ID della chiave che vuoi limitare.

L'ID non è uguale al nome visualizzato o alla stringa della chiave. Puoi ottenere l'ID utilizzando il comando gcloud services api-keys list per elencare le chiavi nel tuo progetto.
Utilizza il comando gcloud services api-keys update per aggiungere limitazioni dei referrer HTTP a una chiave API.

Sostituisci i seguenti valori:
- KEY_ID: l'ID della chiave che vuoi limitare.
- ALLOWED_REFERRER_1: la tua restrizione del referrer HTTP.
  
  Puoi aggiungere tutte le limitazioni necessarie; utilizza le virgole per separarle. Devi fornire tutte le limitazioni dei referrer con il comando di aggiornamento; le limitazioni dei referrer fornite sostituiscono quelle esistenti sulla chiave.
```
gcloud services api-keys update KEY_ID \
 --allowed-referrers="ALLOWED_REFERRER_1"
```

Java

Per eseguire questo esempio, devi installare la libreria client 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

Per eseguire questo esempio, devi installare la libreria client API Keys.


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

Recupera l'ID della chiave che vuoi limitare.

L'ID non è uguale al nome visualizzato o alla stringa della chiave. Puoi ottenere l'ID utilizzando il metodo keys.list. L'ID è elencato nel campo uid della risposta.

Sostituisci PROJECT_ID con l'ID o il nome del tuo progetto Google Cloud .
```
curl -X GET \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
"https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/"
```
Utilizza il metodo keys.patch per aggiungere limitazioni di referrer HTTP alla chiave API.

Questa richiesta restituisce un'operazione a lunga esecuzione; devi eseguire il polling dell'operazione per sapere quando viene completata e ottenere lo stato dell'operazione.

Sostituisci i seguenti valori:
- ALLOWED_REFERRER_1: la tua restrizione del referrer HTTP.
  
  Puoi aggiungere tutte le limitazioni necessarie; utilizza le virgole per separarle. Devi fornire tutte le limitazioni referrer con la richiesta; le limitazioni referrer fornite sostituiscono quelle esistenti sulla chiave.
- PROJECT_ID: il tuo ID progetto o il tuo nome Google Cloud .
- KEY_ID: l'ID della chiave che vuoi limitare.
```
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"
```

Per ulteriori informazioni sull'aggiunta di limitazioni dei referrer HTTP a una chiave utilizzando l'API REST, consulta Aggiunta di limitazioni del browser nella documentazione dell'API API Keys.

Indirizzi IP

Puoi specificare uno o più indirizzi IP dei chiamanti, ad esempio un server web o un cron job, autorizzati a utilizzare la tua chiave API. Puoi specificare gli indirizzi IP in uno dei seguenti formati:

IPv4 (198.51.100.1)
IPv6 (2001:db8::1)
Una subnet che utilizza la notazione CIDR (198.51.100.0/24, 2001:db8::/64)

L'utilizzo di localhost non è supportato per le limitazioni del server.

Per limitare la chiave API a indirizzi IP specifici, utilizza una delle seguenti opzioni:

Console

Nella console Google Cloud , vai alla pagina Credenziali:

Vai a credenziali
Fai clic sul nome della chiave API che vuoi limitare.
Nella sezione Limitazioni dell'applicazione, seleziona Indirizzi IP.
Per ogni indirizzo IP da aggiungere, fai clic su Aggiungi un elemento, inserisci l'indirizzo e fai clic su Fine.
Fai clic su Salva per salvare le modifiche e tornare all'elenco delle chiavi API.

gcloud

Recupera l'ID della chiave che vuoi limitare.

L'ID non è uguale al nome visualizzato o alla stringa della chiave. Puoi ottenere l'ID utilizzando il comando gcloud services api-keys list per elencare le chiavi nel tuo progetto.
Utilizza il comando gcloud services api-keys update per aggiungere limitazioni del server (indirizzo IP) a una chiave API.

Sostituisci i seguenti valori:
- KEY_ID: l'ID della chiave che vuoi limitare.
- ALLOWED_IP_ADDR_1: L'indirizzo IP consentito.
  
  Puoi aggiungere tutti gli indirizzi IP che ti servono; utilizza le virgole per separarli.
```
gcloud services api-keys update KEY_ID \
--allowed-ips="ALLOWED_IP_ADDR_1"
```

Java

Per eseguire questo esempio, devi installare la libreria client 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

Per eseguire questo esempio, devi installare la libreria client API Keys.


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

Recupera l'ID della chiave che vuoi limitare.

L'ID non è uguale al nome visualizzato o alla stringa della chiave. Puoi ottenere l'ID utilizzando il metodo keys.list. L'ID è elencato nel campo uid della risposta.

Sostituisci PROJECT_ID con l'ID o il nome del tuo progetto Google Cloud .
```
curl -X GET \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
"https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/"
```
Utilizza il metodo keys.patch per aggiungere limitazioni del server (indirizzo IP) a una chiave API.

Questa richiesta restituisce un'operazione a lunga esecuzione; devi eseguire il polling dell'operazione per sapere quando viene completata e ottenere lo stato dell'operazione.

Sostituisci i seguenti valori:
- ALLOWED_IP_ADDR_1: L'indirizzo IP consentito.
  
  Puoi aggiungere tutti gli indirizzi IP che ti servono; utilizza le virgole per separare le limitazioni. Devi fornire tutti gli indirizzi IP con la richiesta; le limitazioni dei referrer fornite sostituiscono eventuali limitazioni degli indirizzi IP esistenti nella chiave.
- PROJECT_ID: il tuo ID progetto o il tuo nome Google Cloud .
- KEY_ID: l'ID della chiave che vuoi limitare.
```
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"
```

Per saperne di più sull'aggiunta di limitazioni degli indirizzi IP a una chiave utilizzando l'API REST, consulta la sezione Aggiunta di limitazioni del server nella documentazione dell'API API Keys.

App Android

Puoi limitare l'utilizzo di una chiave API ad app per Android specifiche. Devi fornire il nome del pacchetto e la fingerprint del certificato SHA-1 a 20 byte per ciascuna app.

Quando utilizzi la chiave API in una richiesta, devi specificare il nome del pacchetto e l'impronta del certificato utilizzando le seguenti intestazioni HTTP:

X-Android-Package
X-Android-Cert

Per limitare la chiave API a una o più app per Android, utilizza una delle seguenti opzioni:

Console

Nella console Google Cloud , vai alla pagina Credenziali:

Vai a credenziali
Fai clic sul nome della chiave API che vuoi limitare.
Nella sezione Restrizioni delle applicazioni, seleziona App per Android.
Per ogni app per Android che vuoi aggiungere, fai clic su Aggiungi un elemento e inserisci il nome del pacchetto e l'impronta del certificato SHA-1, quindi fai clic su Fine.
Fai clic su Salva per salvare le modifiche e tornare all'elenco delle chiavi API.

gcloud

Recupera l'ID della chiave che vuoi limitare.

L'ID non è uguale al nome visualizzato o alla stringa della chiave. Puoi ottenere l'ID utilizzando il comando gcloud services api-keys list per elencare le chiavi nel tuo progetto.
Utilizza il comando gcloud services api-keys update per specificare le app per Android che possono utilizzare una chiave API.

Sostituisci i seguenti valori:
- KEY_ID: l'ID della chiave che vuoi limitare.
- SHA1_FINGERPRINT e PACKAGE_NAME: le informazioni sull'app per un'app Android che può utilizzare la chiave.
  
  Puoi aggiungere tutte le app che vuoi; utilizza flag --allowed-application aggiuntivi.
```
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

Per eseguire questo esempio, devi installare la libreria client 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

Per eseguire questo esempio, devi installare la libreria client API Keys.


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

Recupera l'ID della chiave che vuoi limitare.

L'ID non è uguale al nome visualizzato o alla stringa della chiave. Puoi ottenere l'ID utilizzando il metodo keys.list. L'ID è elencato nel campo uid della risposta.

Sostituisci PROJECT_ID con l'ID o il nome del tuo progetto Google Cloud .
```
curl -X GET \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
"https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/"
```
Utilizza il metodo keys.patch per specificare le app per Android che possono utilizzare una chiave API.

Questa richiesta restituisce un'operazione a lunga esecuzione; devi eseguire il polling dell'operazione per sapere quando viene completata e ottenere lo stato dell'operazione.

Sostituisci i seguenti valori:
- SHA1_FINGERPRINT_1 e PACKAGE_NAME_1: le informazioni sull'app per un'app Android che può utilizzare la chiave.
  
  Puoi aggiungere le informazioni per tutte le app necessarie; utilizza le virgole per separare gli oggetti AndroidApplication. Devi fornire tutte le applicazioni con la richiesta; le applicazioni fornite sostituiscono le applicazioni consentite esistenti nella chiave.
- PROJECT_ID: il tuo ID progetto o il tuo nome Google Cloud .
- KEY_ID: l'ID della chiave che vuoi limitare.
```
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"
```

Per saperne di più sull'aggiunta di limitazioni per le app per Android a una chiave utilizzando l'API REST, consulta Aggiunta di limitazioni per Android nella documentazione dell'API API Keys.

App per iOS

Puoi limitare l'utilizzo di una chiave API a specifiche app per iOS fornendo l'ID pacchetto di ciascuna app.

Quando utilizzi la chiave API in una richiesta, devi specificare l'ID pacchetto utilizzando l'intestazione HTTP X-Ios-Bundle-Identifier.

Per limitare la tua chiave API a una o più app per iOS, utilizza una delle seguenti opzioni:

Console

Nella console Google Cloud , vai alla pagina Credenziali:

Vai a credenziali
Fai clic sul nome della chiave API che vuoi limitare.
Nella sezione Restrizioni delle applicazioni, seleziona App per iOS.
Per ogni app per iOS da aggiungere, fai clic su Aggiungi un elemento e inserisci l'ID pacchetto, quindi fai clic su Fine.
Fai clic su Salva per salvare le modifiche e tornare all'elenco delle chiavi API.

gcloud

Recupera l'ID della chiave che vuoi limitare.

L'ID non è uguale al nome visualizzato o alla stringa della chiave. Puoi ottenere l'ID utilizzando il comando gcloud services api-keys list per elencare le chiavi nel tuo progetto.
Utilizza il metodo gcloud services api-keys update per specificare le app per iOS che possono utilizzare la chiave.

Sostituisci i seguenti valori:
- KEY_ID: l'ID della chiave che vuoi limitare.
- ALLOWED_BUNDLE_ID: l'ID bundle di un'app per iOS che vuoi poter utilizzare questa chiave API.
  
  Puoi aggiungere tutti gli ID bundle necessari; utilizza le virgole per separarli.
```
gcloud services api-keys update KEY_ID \
--allowed-bundle-ids=ALLOWED_BUNDLE_ID_1,ALLOWED_BUNDLE_ID_2
```

Java

Per eseguire questo esempio, devi installare la libreria client 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

Per eseguire questo esempio, devi installare la libreria client API Keys.


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

Recupera l'ID della chiave che vuoi limitare.

L'ID non è uguale al nome visualizzato o alla stringa della chiave. Puoi ottenere l'ID utilizzando il metodo keys.list. L'ID è elencato nel campo uid della risposta.

Sostituisci PROJECT_ID con l'ID o il nome del tuo progetto Google Cloud .
```
curl -X GET \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
"https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/"
```
Utilizza il metodo keys.patch per specificare le app per iOS che possono utilizzare una chiave API.

Questa richiesta restituisce un'operazione a lunga esecuzione; devi eseguire il polling dell'operazione per sapere quando viene completata e ottenere lo stato dell'operazione.

Sostituisci i seguenti valori:
- ALLOWED_BUNDLE_ID: l'ID bundle di un'app per iOS che può utilizzare la chiave.
  
  Puoi aggiungere le informazioni per tutte le app che ti servono; utilizza le virgole per separare gli ID bundle. Devi fornire tutti gli ID bundle con la richiesta; gli ID bundle forniti sostituiscono le applicazioni consentite esistenti nella chiave.
- PROJECT_ID: il tuo ID progetto o il tuo nome Google Cloud .
- KEY_ID: l'ID della chiave che vuoi limitare.
```
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"
```

Per ulteriori informazioni sull'aggiunta di limitazioni alle app per iOS a una chiave utilizzando l'API REST, consulta la sezione Aggiunta di limitazioni per iOS nella documentazione dell'API API Keys.

Aggiungi limitazioni dell'API

Le restrizioni delle API specificano quali API possono essere chiamate utilizzando la chiave API.

Per aggiungere restrizioni API, utilizza una delle seguenti opzioni:

Console

Nella console Google Cloud , vai alla pagina Credenziali:

Vai a credenziali
Fai clic sul nome della chiave API che vuoi limitare.
Nella sezione Restrizioni delle API, fai clic su Limita chiave.
Seleziona tutte le API a cui verrà utilizzata la tua chiave API per accedere.
Fai clic su Salva per salvare le modifiche e tornare all'elenco delle chiavi API.

gcloud

Recupera l'ID della chiave che vuoi limitare.

L'ID non è uguale al nome visualizzato o alla stringa della chiave. Puoi ottenere l'ID utilizzando il comando gcloud services api-keys list per elencare le chiavi nel tuo progetto.
Utilizza il comando gcloud services api-keys update per specificare a quali servizi è possibile accedere con una chiave API.

Sostituisci i seguenti valori:
- KEY_ID: l'ID della chiave che vuoi limitare.
- SERVICE_1, SERVICE_2...: I nomi dei servizi delle API a cui è possibile accedere con la chiave.
  
  Devi fornire tutti i nomi dei servizi con il comando di aggiornamento; i nomi dei servizi forniti sostituiscono tutti i servizi esistenti sulla chiave.
Puoi trovare il nome del servizio cercando l'API nella dashboard delle API. I nomi dei servizi sono stringhe come bigquery.googleapis.com.
```
gcloud services api-keys update KEY_ID \
--api-target=service=SERVICE_1 --api-target=service=SERVICE_2
```

Java

Per eseguire questo esempio, devi installare la libreria client 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

Per eseguire questo esempio, devi installare la libreria client API Keys.


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

Recupera l'ID della chiave che vuoi limitare.

L'ID non è uguale al nome visualizzato o alla stringa della chiave. Puoi ottenere l'ID utilizzando il metodo keys.list. L'ID è elencato nel campo uid della risposta.

Sostituisci PROJECT_ID con l'ID o il nome del tuo progetto Google Cloud .
```
curl -X GET \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
"https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/"
```
Utilizza il metodo keys.patch per specificare a quali servizi può essere utilizzata una chiave API per accedere.

Questa richiesta restituisce un'operazione a lunga esecuzione; devi eseguire il polling dell'operazione per sapere quando viene completata e ottenere lo stato dell'operazione.

Sostituisci i seguenti valori:
- SERVICE_1, SERVICE_2...: I nomi dei servizi delle API a cui è possibile accedere con la chiave.
  
  Devi fornire tutti i nomi dei servizi con la richiesta; i nomi dei servizi forniti sostituiscono tutti i servizi esistenti nella chiave.
  
  Puoi trovare il nome del servizio cercando l'API nella dashboard delle API. I nomi dei servizi sono stringhe come bigquery.googleapis.com.
- PROJECT_ID: il tuo ID progetto o il tuo nome Google Cloud .
- KEY_ID: l'ID della chiave che vuoi limitare.
```
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"
```

Per ulteriori informazioni sull'aggiunta di limitazioni API a una chiave utilizzando l'API REST, consulta Aggiunta di limitazioni API nella documentazione dell'API API Keys.

Recuperare le informazioni del progetto da una stringa chiave

Puoi determinare a quale Google Cloud progetto è associata una chiave API dalla relativa stringa.

Sostituisci KEY_STRING con la stringa della chiave per cui hai bisogno delle informazioni sul progetto.

gcloud

Utilizza il comando gcloud services api-keys lookup per ottenere l'ID progetto da una stringa di chiave.

 gcloud services api-keys lookup KEY_STRING

Java

Per eseguire questo esempio, devi installare la libreria client 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

Per eseguire questo esempio, devi installare la libreria client API Keys.


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

Utilizza il metodo lookupKey per ottenere l'ID progetto da una stringa di chiave.

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"

Creare una copia di una chiave API

Se hai bisogno di una nuova chiave API con le stesse limitazioni di una chiave API esistente, puoi crearne una copia. Questa operazione crea una nuova chiave API con una stringa e un ID chiave unici, con le limitazioni della chiave API esistente.

L'operazione di copia è disponibile solo nella Google Cloud console. Per utilizzare altri metodi, segui i passaggi per creare una chiave API e poi applica le stesse limitazioni della chiave API alla chiave API appena generata.

Nella console Google Cloud , vai alla pagina Credenziali:

Vai a credenziali
Fai clic sul nome della chiave API che vuoi copiare.

Viene visualizzata la pagina dei dettagli della chiave API.
Fai clic su Crea una copia.
Inserisci un nome per la nuova chiave API e conferma che le limitazioni siano corrette.
Fai clic su Crea.

Ruotare una chiave API

Ruotando periodicamente le chiavi API, puoi limitare l'impatto di eventuali chiavi API compromesse.

Quando ruoti una chiave API, crei una nuova chiave con le stesse limitazioni della chiave precedente e aggiorni le tue applicazioni in modo che utilizzino la nuova chiave. Dopo aver aggiornato tutte le applicazioni, elimina la vecchia chiave.

L'operazione di rotazione è disponibile solo nella Google Cloud console. Per utilizzare altri metodi, segui i passaggi per creare una chiave API e poi applica le stesse limitazioni della chiave API alla chiave API appena generata. Dopo aver aggiornato le applicazioni in modo che utilizzino la nuova chiave, puoi eliminare la vecchia chiave.

Nella console Google Cloud , vai alla pagina Credenziali:

Vai a credenziali
Fai clic sul nome della chiave API che vuoi ruotare per aprire la relativa pagina dei dettagli.
Fai clic su Ruota la chiave.
Inserisci un nome per la nuova chiave API e conferma che le limitazioni siano corrette.
Fai clic su Crea.
Copia la stringa della chiave e aggiorna le tue applicazioni in modo che utilizzino la nuova stringa.
Dopo aver aggiornato tutte le applicazioni in modo che utilizzino la nuova chiave, torna alla pagina dei dettagli della nuova chiave. Nella sezione Chiave precedente, fai clic su Elimina la chiave precedente per eliminare la vecchia chiave.

Se ti accorgi di aver eliminato la vecchia chiave prima del tempo, puoi annullare l'eliminazione.

Annullamento eliminazione di una chiave API

Se elimini una chiave API per errore, puoi annullare l'eliminazione (ripristinarla) entro 30 giorni dall'eliminazione. Dopo 30 giorni, non puoi annullare l'eliminazione della chiave API.

Console

Nella console Google Cloud , vai alla pagina Credenziali:

Vai a credenziali
Fai clic su Ripristina credenziali eliminate.
Individua la chiave API eliminata che vuoi ripristinare e fai clic su Ripristina.

La ripristino di una chiave API potrebbe richiedere alcuni minuti. Dopo la propagazione, la chiave API ripristinata viene visualizzata nell'elenco delle chiavi API.

gcloud

Recupera l'ID della chiave che vuoi ripristinare.

L'ID non è uguale al nome visualizzato o alla stringa della chiave. Puoi ottenere l'ID utilizzando il comando gcloud services api-keys list --show-deleted per elencare le chiavi eliminate nel progetto.
Utilizza il comando gcloud services api-keys undelete per ripristinare una chiave API.
```
gcloud services api-keys undelete KEY_ID
```
Sostituisci i seguenti valori:
- KEY_ID: l'ID della chiave che vuoi recuperare.

Java

Per eseguire questo esempio, devi installare la libreria client 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

Recupera l'ID della chiave che vuoi ripristinare.

L'ID non è uguale al nome visualizzato o alla stringa della chiave. Puoi ottenere l'ID utilizzando il metodo keys.list, con il parametro di query showDeleted impostato su true. L'ID chiave è elencato nel campo uid della risposta.

Sostituisci PROJECT_ID con l'ID o il nome del tuo progetto 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"
```
Utilizza il metodo undelete per annullare l'eliminazione della chiave 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"
```
Questa richiesta restituisce un'operazione a lunga esecuzione; devi eseguire il polling dell'operazione per sapere quando viene completata e ottenere lo stato dell'operazione.

Sostituisci i seguenti valori:
- PROJECT_ID: il tuo ID progetto o il tuo nome Google Cloud .
- KEY_ID: l'ID della chiave che vuoi limitare.

Determinare il tipo di chiave API

Puoi determinare se la chiave API è associata a un account di servizio ispezionando la chiave.

Console

Nella console Google Cloud , vai alla pagina Credenziali:

Vai a credenziali

Se la chiave API è associata a un account di servizio, viene visualizzato l'identificatore del account di servizio.

gcloud

Recupera l'ID della chiave.

L'ID non è uguale al nome visualizzato o alla stringa della chiave. Puoi ottenere l'ID utilizzando il comando gcloud services api-keys list per elencare le chiavi nel tuo progetto.
Utilizza il comando gcloud services api-keys describe per descrivere la chiave API.
```
gcloud services api-keys describe KEY_ID
```
Se la chiave API è associata a un account di servizio, viene visualizzato il campo serviceAccountEmail.

Eseguire il polling delle operazioni a lunga esecuzione

I metodi dell'API API Keys utilizzano operazioni a lunga esecuzione. Se utilizzi l'API REST per creare e gestire le chiavi API, viene restituito un oggetto operazione dalla richiesta di metodo iniziale. Utilizzi il nome dell'operazione per eseguire il polling dell'operazione a lunga esecuzione. Al termine della richiesta a lunga esecuzione, il polling dell'operazione restituisce i dati della richiesta a lunga esecuzione.

Per eseguire il polling di un'operazione a lunga esecuzione dell'API API Keys, utilizza il metodo operations.get.

Sostituisci OPERATION_NAME con il nome dell'operazione restituito dall&#39operazione a lunga esecuzionea. Ad esempio, 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"

Limiti per le chiavi API

Puoi creare fino a 300 chiavi API per progetto. Questo limite è un limite di sistema e non può essere modificato utilizzando una richiesta di aumento della quota. Se sono necessarie più chiavi API, devi utilizzare più di un progetto.

Puoi aggiungere fino a 1200 limitazioni delle applicazioni a una chiave API.

Passaggi successivi

Scopri di più sulle best practice per proteggere le chiavi API.
Scopri di più sull'API API Keys.

Gestisci chiavi API Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Introduzione alle chiavi API

Chiavi API standard

Chiavi API associate a un account di servizio

Componenti della chiave API

Prima di iniziare

Configura l'autenticazione

Console

gcloud

C++

Java

Python

REST

Ruoli obbligatori

Attiva l'associazione delle chiavi ai service account

Console

gcloud

Crea una chiave API

Console

gcloud

C++

Java

Python

REST

Applica le limitazioni relative alle chiavi API

Aggiungere limitazioni delle applicazioni

Referrer HTTP

Console

gcloud

Java

Python

REST

Indirizzi IP

Console

gcloud

Java

Python

REST

App Android

Console

gcloud

Java

Python

REST

App per iOS

Console

gcloud

Java

Python

REST

Aggiungi limitazioni dell'API

Console

gcloud

Java

Python

REST

Recuperare le informazioni del progetto da una stringa chiave

gcloud

Java

Python

REST

Creare una copia di una chiave API

Ruotare una chiave API

Annullamento eliminazione di una chiave API

Console

gcloud

Java

REST

Determinare il tipo di chiave API

Console

gcloud

Eseguire il polling delle operazioni a lunga esecuzione

Limiti per le chiavi API

Passaggi successivi

Gestisci chiavi API