Autentica con claves de API

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

En esta página, se describe cómo usar las claves de API para autenticarte en las APIs de Google Cloud y los servicios que admiten las claves de API.

La mayoría de las APIs de Google Cloud no admiten claves de API. Verifica que la API que quieres usar admita claves de API antes de usar este método de autenticación.

Si deseas obtener información sobre el uso de claves de API para autenticarte en Google Maps Platform, consulta la documentación de Google Maps Platform. Para obtener más información sobre la API de las claves de API, consulta la documentación de la API de claves de API.

Introducción a las claves de API

Cuando usas una clave de API para autenticarte en una API, esta no identifica una principal ni proporciona información de autorización. La clave de API asocia la solicitud con un proyecto de Google Cloud para fines de facturación y cuota. Debido a que las claves de API no identifican al emisor, a menudo se usan para acceder a recursos o datos públicos.

Muchas APIs de Google Cloud no aceptan claves de API para la autenticación. Revisa la documentación de autenticación del servicio o la API que deseas usar para determinar si es compatible con las claves de API.

Una clave de API tiene los siguientes componentes, que se usan para administrar y usar la clave:

String
La string de clave de API es una string encriptada, por ejemplo, AIzaSyDaGmWKa4JsXZ-HjGw7ISLn_3namBGewQe. Cuando uses una clave de API para autenticar, siempre usarás la string de la clave. Las claves de API no tienen un archivo JSON asociado.
ID
Las herramientas administrativas de Google Cloud usan el ID de la clave de API para identificar de forma única la clave. No se puede usar el ID de clave para la autenticación. El ID de clave se puede encontrar en la URL de la página de edición de la clave en la consola de Google Cloud. También puedes obtener el ID de la clave mediante la CLI de Google Cloud para enumerar las claves de tu proyecto.
Nombre visible
El nombre visible es un nombre descriptivo y opcional de la clave, que puedes configurar cuando creas o actualizas la clave.

Para administrar las claves de API, debes tener el rol de administrador de claves de API (roles/serviceusage.apiKeysAdmin) en el proyecto.

Crear una clave de API

Para crear una clave de API, usa una de las siguientes opciones:

Consola

  1. En la consola de Google Cloud, ve a la página Credenciales.

    Ir a Credenciales

  2. Haz clic en Crear credenciales y, luego, selecciona Clave de API en el menú.

    Se mostrará la string a la clave recién creada en el cuadro de diálogo Se creó la clave de API.

gcloud

Usa el comando gcloud alpha services api-keys create para crear una clave de API.

Reemplaza DISPLAY_NAME por un nombre descriptivo para tu clave.

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

REST

Usarás el método keys.create para crear una clave de API. Esta solicitud muestra una operación de larga duración. Debes consultar la operación para obtener la información de la clave nueva.

Reemplaza los siguientes valores:

  • DISPLAY_NAME: Opcional Un nombre descriptivo para tu clave.
  • PROJECT_ID: el nombre o el ID de tu proyecto de 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"

Para obtener más información sobre cómo crear claves de API con la API de REST, consulta Crea una clave de API en la documentación de la API de claves de API.

Java

Para ejecutar esta muestra, debes instalar el google-cloud-apikeys cliente.

auth/src/main/java/CreateApiKey.java 

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

Para ejecutar esta muestra, debes instalar la API del cliente de Python para las APIs de claves.

auth/api-client/create_api_key.py 

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

def create_api_key(project_id: str) -> Key:
    """
    Creates and restrict an API key.

    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 = "My first API key"

    # 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

Copia tu string de clave y mantenla segura. A menos que uses una clave de prueba que pretendas borrar más adelante, agrega restricciones de aplicación y de clave de API.

Usa una clave de API

Si una API admite el uso de claves de API, puedes usar claves de API para autenticarla. Puedes usar claves de API con solicitudes de REST y bibliotecas cliente que las admitan.

Usa una clave de API con REST

Puedes pasar la clave de API a una llamada a la API de REST como un parámetro de consulta con el siguiente formato. Reemplaza API_KEY por la string de clave de tu clave de API.

Por ejemplo, si deseas pasar una clave de API para solicitar documents.analyzeEntities a la API de Cloud Natural Language, usa lo siguiente:

POST https://language.googleapis.com/v1/documents:analyzeEntities?key=API_KEY

Como alternativa, puedes usar el encabezado x-goog-api-key para pasar la clave. Este encabezado se debe usar con solicitudes de gRPC.

curl -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "X-goog-api-key: API_KEY" \
    -H "Content-Type: application/json; charset=utf-8" \
    -d @request.json \
    "https://translation.googleapis.com/language/translate/v2"

Usa una clave de API con bibliotecas cliente

La compatibilidad de la biblioteca cliente con las claves de API es específica del lenguaje.

Python

En este ejemplo, se usa la API de Cloud Natural Language, que admite claves de API para la autenticación, a fin de demostrar cómo se proporciona una clave de API a la biblioteca.

A fin de ejecutar esta muestra, debes instalar el cliente de Python para la API de Natural Language y la API del cliente de Python para la API de claves.

auth/api-client/authenticate_with_api_key.py 

from google.cloud import language_v1

def authenticate_with_api_key(quota_project_id: str, api_key_string: str) -> None:
    """
    Authenticates with an API key for Google Language service.

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

    Args:
        quota_project_id: Google Cloud project id that should be used for quota and billing purposes.
        api_key_string: The API key to authenticate to the service.
    """

    # Initialize the Language Service client and set the API key and the quota project id.
    client = language_v1.LanguageServiceClient(client_options={"api_key": api_key_string,
                                                               "quota_project_id": quota_project_id})

    text = "Hello, world!"
    document = language_v1.Document(
        content=text, type_=language_v1.Document.Type.PLAIN_TEXT
    )

    # Make a request to analyze the sentiment of the text.
    sentiment = client.analyze_sentiment(
        request={"document": document}
    ).document_sentiment

    print(f"Text: {text}")
    print(f"Sentiment: {sentiment.score}, {sentiment.magnitude}")
    print("Successfully authenticated using the API key")

Protege una clave de API

Cuando uses claves de API en tus aplicaciones, asegúrate de que se mantengan seguras durante el almacenamiento y la transmisión. Si expones tus claves de API de forma pública, puedes generar cargos inesperados en tu cuenta. Para ayudarte a mantener tus claves de API seguras, sigue estas prácticas recomendadas:

  • Agrega restricciones de clave de API a tu clave.

    Si agregas restricciones, puedes limitar las formas en que se puede usar una clave de API, lo que reduce el impacto de una clave de API vulnerada.

  • Borra las claves de API innecesarias para minimizar la exposición a los ataques.

  • Recrea tus claves de API de forma periódica.

    Crea periodicamente claves de API nuevas de forma periódica, borrar las claves antiguas y actualizar tus aplicaciones para que usen las claves de API nuevas.

Aplica restricciones de claves de API

Las claves de API no están restringidas de forma predeterminada. Las claves no restringidas son inseguras porque cualquier persona puede usarlas desde cualquier lugar. Para las aplicaciones de producción, debes establecer restricciones de aplicaciones y restricciones de API.

Agrega restricciones de aplicaciones

Las restricciones de aplicaciones especifican qué sitios web, direcciones IP o apps pueden usar una clave de API.

Solo puedes aplicar un tipo de restricción de aplicación a la vez. Elige el tipo de restricción según el tipo de tu aplicación:

Opción Application type Notas
URL de referencia HTTP Aplicaciones web Especifica los sitios web que pueden usar la clave.
Direcciones IP Aplicaciones llamadas por servidores específicos Especifica los servidores o los trabajos cron que pueden usar la clave.
Apps para Android Aplicaciones para Android Especifica la aplicación para Android que puede usar la clave.
Apps para iOS Aplicaciones para iOS Especifica los paquetes de iOS que pueden usar la clave.

URL de referencia HTTP

Para restringir los sitios web que pueden usar tu clave de API, agrega una o más restricciones de referente HTTP.

Puedes reemplazar un carácter comodín (*) por el subdominio o la ruta, pero no puedes insertar un carácter comodín en el medio de la URL. Por ejemplo, *.google.com es válido y acepta todos los sitios que terminan en .google.com. Sin embargo, mysubdomain*.google.com no es una restricción válida.

Los números de puerto se pueden incluir en las restricciones de referente HTTP. Si incluyes un número de puerto, solo se detectarán coincidencias con las solicitudes que usen ese puerto. Si no especificas un número de puerto, las solicitudes de cualquier número de puerto coincidirán.

Puedes agregar hasta 1,200 referentes HTTP a una clave de API.

En la siguiente tabla, se muestran algunos ejemplos de situaciones y restricciones de navegador:

Situación Restricciones
Permite una URL específica Agrega una URL con una ruta de acceso exacta. Por ejemplo:
www.example.com/path
www.example.com/path/path
Permitir cualquier URL en tu sitio Debes establecer dos URLs en la lista allowedReferers.
  1. Es la URL para el dominio, sin un subdominio, y con un comodín en la ruta de acceso. Por ejemplo:
    example.com/*
  2. Una segunda URL que incluye un comodín para el subdominio y un comodín para la ruta. Por ejemplo:
    *.example.com/*
Permitir cualquier URL en un solo subdominio o dominio simple

Debes establecer dos URLs en la lista allowedReferers para permitir un dominio completo:

  1. Es la URL del dominio sin una barra diagonal final. Por ejemplo:
    www.example.com
    sub.example.com
    example.com
  2. Una segunda URL para el dominio que incluye un comodín en la ruta de acceso. Por ejemplo:
    www.example.com/*
    sub.example.com/*
    example.com/*

Para restringir tu clave de API a sitios web específicos, usa una de las siguientes opciones:

Consola

  1. En la consola de Google Cloud, ve a la página Credenciales.

    Ir a Credenciales

  2. Haz clic en el nombre de la clave de API que deseas restringir.

  3. En la sección Restricciones de aplicaciones, selecciona URL de referencia HTTP.

  4. Para cada restricción que desees agregar, haz clic en Agregar un elemento, ingresa la restricción y haz clic en Listo.

  5. Haz clic en Guardar para guardar los cambios y volver a la lista de claves de API.

gcloud

  1. Obtén el ID de la clave que deseas restringir.

    El ID no es el mismo que el nombre visible o la string de clave. Puedes obtener el ID mediante el comando gcloud services api-keys list para enumerar las claves de tu proyecto.

  2. Usa el comando gcloud alpha services api-keys update para agregar restricciones de referentes HTTP a una clave de API.

    Reemplaza los siguientes valores:

    • KEY_ID: Es el ID de la clave que deseas restringir.

    • ALLOWED_REFERRER_1: Es la restricción de referente HTTP.

      Puedes agregar tantas restricciones como sea necesario. Usa comas para separar las restricciones. Debes proporcionar todas las restricciones de referencia con el comando update. Las restricciones de referencia que se proporcionan reemplazan cualquier restricción de referencia existente en la clave.

    gcloud alpha services api-keys update KEY_ID \
 --allowed-referrers="ALLOWED_REFERRER_1"

REST

  1. Obtén el ID de la clave que deseas restringir.

    El ID no es el mismo que el nombre visible o la string de clave. Puedes obtener el ID mediante el método keys.list. El ID se enumera en el campo uid de la respuesta.

    Reemplaza PROJECT_ID por el ID o el nombre de tu proyecto de Google Cloud.

    curl -X GET \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
"https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/"

  2. Usa el método keys.patch para agregar restricciones de referentes HTTP a la clave de API.

    Esta solicitud muestra una operación de larga duración. Debes sondear la operación para saber cuándo se completa y obtener su estado.

    Reemplaza los siguientes valores:

    • ALLOWED_REFERRER_1: Es la restricción de referente HTTP.

      Puedes agregar tantas restricciones como sea necesario. Usa comas para separar las restricciones. Debes proporcionar todas las restricciones de referencia con la solicitud. Las restricciones de referencia que se proporcionan reemplazan cualquier restricción de referencia existente en la clave.

    • PROJECT_ID: el nombre o el ID de tu proyecto de Google Cloud.

    • KEY_ID: Es el ID de la clave que deseas restringir.

    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"

Para obtener más información sobre cómo agregar restricciones de referentes HTTP a una clave mediante la API de REST, consulta Agrega restricciones de navegador en la documentación de la API de claves de API.

Java

Para ejecutar esta muestra, debes instalar el google-cloud-apikeys cliente.

auth/src/main/java/RestrictApiKeyHttp.java 

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

Para ejecutar esta muestra, debes instalar la API del cliente de Python para las APIs de claves.

auth/api-client/restrict_api_key_http.py 

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

Direcciones IP

Puedes especificar una o más direcciones IP de los emisores, como un servidor web o un trabajo cron, que pueden usar tu clave de API. Puedes especificar las direcciones IP en cualquiera de los siguientes formatos:

  • IPv4 (198.51.100.1)
  • IPv6 (2001:db8::1)
  • Una subred con notación CIDR (198.51.100.0/24, 2001:db8::/64)

El uso de localhost no es compatible con las restricciones del servidor.

Para restringir tu clave de API a direcciones IP específicas, usa una de las siguientes opciones:

Consola

  1. En la consola de Google Cloud, ve a la página Credenciales.

    Ir a Credenciales

  2. Haz clic en el nombre de la clave de API que deseas restringir.

  3. En la sección Restricciones de aplicaciones, selecciona Direcciones IP.

  4. Por cada dirección IP que desees agregar, haz clic en Agregar un elemento, ingresa la dirección y haz clic en Listo.

  5. Haz clic en Guardar para guardar los cambios y volver a la lista de claves de API.

gcloud

  1. Obtén el ID de la clave que deseas restringir.

    El ID no es el mismo que el nombre visible o la string de clave. Puedes obtener el ID mediante el comando gcloud services api-keys list para enumerar las claves de tu proyecto.

  2. Usa el comando gcloud alpha services api-keys update para agregar restricciones de servidor (dirección IP) a una clave de API.

    Reemplaza los siguientes valores:

    • KEY_ID: Es el ID de la clave que deseas restringir.

    • ALLOWED_IP_ADDR_1: La dirección IP permitida.

      Puedes agregar tantas direcciones IP como sea necesario. Usa comas para separar las direcciones.

    gcloud alpha services api-keys update KEY_ID \
--allowed-ips="ALLOWED_IP_ADDR_1"

REST

  1. Obtén el ID de la clave que deseas restringir.

    El ID no es el mismo que el nombre visible o la string de clave. Puedes obtener el ID mediante el método keys.list. El ID se enumera en el campo uid de la respuesta.

    Reemplaza PROJECT_ID por el ID o el nombre de tu proyecto de Google Cloud.

    curl -X GET \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
"https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/"

  2. Usa el método keys.patch para agregar restricciones de servidor (dirección IP) a una clave de API.

    Esta solicitud muestra una operación de larga duración. Debes sondear la operación para saber cuándo se completa y obtener su estado.

    Reemplaza los siguientes valores:

    • ALLOWED_IP_ADDR_1: La dirección IP permitida.

      Puedes agregar tantas direcciones IP como sea necesario. Usa comas para separar las restricciones. Debes proporcionar todas las direcciones IP con la solicitud. Las restricciones de referente proporcionadas reemplazan cualquier restricción de dirección IP existente en la clave.

    • PROJECT_ID: el nombre o el ID de tu proyecto de Google Cloud.

    • KEY_ID: Es el ID de la clave que deseas restringir.

    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"

Para obtener más información sobre cómo agregar restricciones de direcciones IP a una clave mediante la API de REST, consulta Agrega restricciones de servidores en la documentación de la API de claves de API.

Java

Para ejecutar esta muestra, debes instalar el google-cloud-apikeys cliente.

auth/src/main/java/RestrictApiKeyServer.java 

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

Para ejecutar esta muestra, debes instalar la API del cliente de Python para las APIs de claves.

auth/api-client/restrict_api_key_server.py 

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

Apps para Android

Puedes restringir el uso de una clave de API a apps para Android específicas. Debes proporcionar el nombre del paquete y la huella digital del certificado SHA-1 de 20 bytes para cada app.

Para restringir tu clave de API a una o más apps para Android, usa una de las siguientes opciones:

Consola

  1. En la consola de Google Cloud, ve a la página Credenciales.

    Ir a Credenciales

  2. Haz clic en el nombre de la clave de API que deseas restringir.

  3. En la sección Restricciones de aplicaciones, selecciona Apps de Android.

  4. Por cada app para Android que desees agregar, haz clic en Agregar un elemento y, luego, ingresa el nombre del paquete y la huella digital del certificado SHA-1. Luego, haz clic en Listo.

  5. Haz clic en Guardar para guardar los cambios y volver a la lista de claves de API.

gcloud

  1. Obtén el ID de la clave que deseas restringir.

    El ID no es el mismo que el nombre visible o la string de clave. Puedes obtener el ID mediante el comando gcloud services api-keys list para enumerar las claves de tu proyecto.

  2. Usa el comando gcloud alpha services api-keys update para especificar las apps para Android que pueden usar una clave de API.

    Reemplaza los siguientes valores:

    • KEY_ID: Es el ID de la clave que deseas restringir.

    • SHA1_FINGERPRINT y PACKAGE_NAME: Es la información de una app de Android que puede usar la clave.

      Puedes agregar tantas apps como sea necesario. Usa marcas --allowed-application adicionales.

    gcloud alpha 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

REST

  1. Obtén el ID de la clave que deseas restringir.

    El ID no es el mismo que el nombre visible o la string de clave. Puedes obtener el ID mediante el método keys.list. El ID se enumera en el campo uid de la respuesta.

    Reemplaza PROJECT_ID por el ID o el nombre de tu proyecto de Google Cloud.

    curl -X GET \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
"https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/"

  2. Usa el método keys.patch para especificar las apps para Android que pueden usar una clave de API.

    Esta solicitud muestra una operación de larga duración. Debes sondear la operación para saber cuándo se completa y obtener su estado.

    Reemplaza los siguientes valores:

    • SHA1_FINGERPRINT_1 y PACKAGE_NAME_1: Es la información de una app de Android que puede usar la clave.

      Puedes agregar la información para tantas aplicaciones como sea necesario. Usa comas para separar los objetos AndroidApplication. Debes proporcionar todas las aplicaciones con la solicitud. Las aplicaciones proporcionadas reemplazan cualquier aplicación permitida existente en la clave.

    • PROJECT_ID: el nombre o el ID de tu proyecto de Google Cloud.

    • KEY_ID: Es el ID de la clave que deseas restringir.

    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"

Para obtener más información sobre cómo agregar restricciones de apps para Android a una clave mediante la API de REST, consulta Agrega restricciones de Android en la documentación de la API de claves de API.

Java

Para ejecutar esta muestra, debes instalar el google-cloud-apikeys cliente.

auth/src/main/java/RestrictApiKeyAndroid.java 

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

Para ejecutar esta muestra, debes instalar la API del cliente de Python para las APIs de claves.

auth/api-client/restrict_api_key_android.py 

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

Apps para iOS

Puedes restringir el uso de una clave de API a apps para iOS específicas si proporcionas el ID del paquete de cada app.

Para restringir tu clave de API a una o más apps para iOS, usa una de las siguientes opciones:

Consola

  1. En la consola de Google Cloud, ve a la página Credenciales.

    Ir a Credenciales

  2. Haz clic en el nombre de la clave de API que deseas restringir.

  3. En la sección Restricciones de aplicaciones, selecciona Apps para iOS.

  4. Por cada app para iOS que desees agregar, haz clic en Agregar un elemento, ingresa el ID del paquete y, luego, haz clic en Listo.

  5. Haz clic en Guardar para guardar los cambios y volver a la lista de claves de API.

gcloud

  1. Obtén el ID de la clave que deseas restringir.

    El ID no es el mismo que el nombre visible o la string de clave. Puedes obtener el ID mediante el comando gcloud services api-keys list para enumerar las claves de tu proyecto.

  2. Usa el método gcloud alpha services api-keys update para especificar las apps para iOS que pueden usar la clave.

    Reemplaza los siguientes valores:

    • KEY_ID: Es el ID de la clave que deseas restringir.

    • ALLOWED_BUNDLE_ID: El ID del paquete de una app para iOS que deseas que pueda usar esta clave de API.

      Puedes agregar tantos ID del paquete como sea necesario. Usa comas para separar los IDs.

    gcloud alpha services api-keys update KEY_ID \
--allowed-bundle-ids=ALLOWED_BUNDLE_ID_1,ALLOWED_BUNDLE_ID_2

REST

  1. Obtén el ID de la clave que deseas restringir.

    El ID no es el mismo que el nombre visible o la string de clave. Puedes obtener el ID mediante el método keys.list. El ID se enumera en el campo uid de la respuesta.

    Reemplaza PROJECT_ID por el ID o el nombre de tu proyecto de Google Cloud.

    curl -X GET \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
"https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/"

  2. Usa el método keys.patch para especificar las apps para iOS que pueden usar una clave de API.

    Esta solicitud muestra una operación de larga duración. Debes sondear la operación para saber cuándo se completa y obtener su estado.

    Reemplaza los siguientes valores:

    • ALLOWED_BUNDLE_ID: El ID del paquete de una app para iOS que puede usar la clave.

      Puedes agregar la información para tantas aplicaciones como sea necesario. Usa comas para separar los ID del paquete. Debes proporcionar todos los ID del paquete con la solicitud. Los ID del paquete proporcionados reemplazan cualquier aplicación permitida existente en la clave.

    • PROJECT_ID: el nombre o el ID de tu proyecto de Google Cloud.

    • KEY_ID: Es el ID de la clave que deseas restringir.

    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"

Para obtener más información sobre cómo agregar restricciones de apps para iOS a una clave mediante la API de REST, consulta Agrega restricciones de iOS en la documentación de la API de claves de API.

Java

Para ejecutar esta muestra, debes instalar el google-cloud-apikeys cliente.

auth/src/main/java/RestrictApiKeyIos.java 

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

Para ejecutar esta muestra, debes instalar la API del cliente de Python para las APIs de claves.

auth/api-client/restrict_api_key_ios.py 

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

Agrega restricciones de API

Las restricciones de API especifican a qué API se puede llamar mediante la clave de API.

Para agregar restricciones de API, usa una de las siguientes opciones:

Consola

  1. En la consola de Google Cloud, ve a la página Credenciales.

    Ir a Credenciales

  2. Haz clic en el nombre de la clave de API que deseas restringir.

  3. En la sección Restricciones de API, haz clic en Restringir clave .

  4. Selecciona todas las APIs a las que se usará tu clave de API para acceder.

  5. Haz clic en Guardar para guardar los cambios y volver a la lista de claves de API.

gcloud

  1. Obtén el ID de la clave que deseas restringir.

    El ID no es el mismo que el nombre visible o la string de clave. Puedes obtener el ID mediante el comando gcloud services api-keys list para enumerar las claves de tu proyecto.

  2. Usa el comando gcloud alpha services api-keys update para especificar en qué servicios se puede usar una clave de API a fin de autenticarse.

    Reemplaza los siguientes valores:

    • KEY_ID: Es el ID de la clave que deseas restringir.

    • SERVICE_1, SERVICE_2…: Los nombres de los servicios de las APIs a las que se puede acceder la clave.

      Debes proporcionar todos los nombres de los servicios con el comando update. Los nombres de los servicios proporcionados reemplazan cualquier servicio existente en la clave.

    Para encontrar el nombre del servicio, busca la API en el panel de la API. Los nombres de servicios son strings como bigquery.googleapis.com.

    gcloud alpha services api-keys update KEY_ID \
--api-target=service=SERVICE_1 --api-target=service=SERVICE_2

REST

  1. Obtén el ID de la clave que deseas restringir.

    El ID no es el mismo que el nombre visible o la string de clave. Puedes obtener el ID mediante el método keys.list. El ID se enumera en el campo uid de la respuesta.

    Reemplaza PROJECT_ID por el ID o el nombre de tu proyecto de Google Cloud.

    curl -X GET \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
"https://apikeys.googleapis.com/v2/projects/PROJECT_ID/locations/global/keys/"

  2. Usa el método keys.patch para especificar en qué servicios se puede usar una clave de API a fin de autenticarse.

    Esta solicitud muestra una operación de larga duración. Debes sondear la operación para saber cuándo se completa y obtener su estado.

    Reemplaza los siguientes valores:

    • SERVICE_1, SERVICE_2…: Los nombres de los servicios de las APIs a las que se puede acceder la clave.

      Debes proporcionar todos los nombres de servicios con la solicitud. Los nombres de los servicios proporcionados reemplazan cualquier servicio existente en la clave.

      Para encontrar el nombre del servicio, busca la API en el panel de la API. Los nombres de servicios son strings como bigquery.googleapis.com.

    • PROJECT_ID: el nombre o el ID de tu proyecto de Google Cloud.

    • KEY_ID: Es el ID de la clave que deseas restringir.

    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"

Para obtener más información sobre cómo agregar restricciones de API a una clave mediante la API de REST, consulta Agrega restricciones de API en la documentación de la API de claves de API.

Java

Para ejecutar esta muestra, debes instalar el google-cloud-apikeys cliente.

auth/src/main/java/RestrictApiKeyApi.java 

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

Para ejecutar esta muestra, debes instalar la API del cliente de Python para las APIs de claves.

auth/api-client/restrict_api_key_api.py 

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

Obtén información del proyecto a partir de una string de clave

Puedes determinar con qué proyecto de Google Cloud se asocia una clave de API desde su string.

Reemplaza KEY_STRING por la string de clave para la que necesitas información del proyecto.

gcloud

Usa el comando gcloud beta services api-keys lookup para obtener el ID del proyecto de una string de clave.

gcloud beta services api-keys lookup KEY_STRING

REST

Usa el método lookupKey para obtener el ID del proyecto de una string de clave.

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"

Java

Para ejecutar esta muestra, debes instalar el google-cloud-apikeys cliente.

auth/src/main/java/LookupApiKey.java 

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

Para ejecutar esta muestra, debes instalar la API del cliente de Python para las APIs de claves.

auth/api-client/lookup_api_key.py 

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

Recuperar una clave de API

Si borras una clave de API por error, puedes recuperarla (en un plazo de 30 días después de borrarla). Después de 30 días, no puedes recuperar la clave de API.

Consola

  1. En la consola de Google Cloud, ve a la página Credenciales.

    Ir a Credenciales

  2. Haz clic en Restablecer credenciales borradas.

  3. Busca la clave de API borrada que deseas recuperar y haz clic en Restablecer.

    Recuperar una clave de API puede tardar unos minutos en propagarse. Después de la propagación, la clave de API no borrada se muestra en la lista de claves de API.

gcloud

  1. Obtén el ID de la clave que deseas reperar.

    El ID no es el mismo que el nombre visible o la string de clave. Puedes obtener el ID mediante el comando gcloud services api-keys list --show-deleted para enumerar las claves de tu proyecto.

  2. Usa el comando gcloud beta services api-keys undelete para recuperar una clave de API.

    gcloud beta services api-keys undelete KEY_ID

    Reemplaza los siguientes valores:

    • KEY_ID: El ID de la clave que deseas restringir.

REST

  1. Obtén el ID de la clave que deseas reperar.

    El ID no es el mismo que el nombre visible o la string de clave. Puedes obtener el ID mediante el método keys.list, con el parámetro de búsqueda showDeleted configurado como true. El ID de clave se enumera en el campo uid de la respuesta.

    Reemplaza PROJECT_ID por el ID o el nombre de tu proyecto de 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"

  2. Usa el método undelete para recuperar la clave de 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"

    Esta solicitud muestra una operación de larga duración. Debes sondear la operación para saber cuándo se completa y obtener su estado.

    Reemplaza los siguientes valores:

    • PROJECT_ID: el nombre o el ID de tu proyecto de Google Cloud.
    • KEY_ID: Es el ID de la clave que deseas restringir.

Sondea operaciones de larga duración

Los métodos de API de la clave de API usan operaciones de larga duración. Si usas la API de REST para crear y administrar claves de API, se muestra un objeto de operación a partir de la solicitud del método inicial. Usa el nombre de la operación para sondear la operación de larga duración. Cuando se completa la solicitud de larga duración, el sondeo de la operación muestra los datos de la solicitud de larga duración.

Para sondear una operación de API de claves de API de larga duración, usa el método operations.get.

Reemplaza OPERATION_NAME por el nombre de la operación que muestra la operación de larga duración. Por ejemplo, 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"

Límites de las claves de API

Puedes crear hasta 300 claves de API por proyecto. Este es un límite del sistema y no se puede cambiar mediante una solicitud de aumento de cuota.

Si se necesitan más claves de API, debes usar más de un proyecto.

¿Qué sigue?