Crea y administra cachés con Rapid Cache

Puedes crear y administrar instancias de caché con Rapid Cache para reducir la latencia y optimizar el acceso a los datos de los objetos almacenados en Cloud Storage. Esta solución de almacenamiento en caché ayuda a mejorar el rendimiento de tus aplicaciones, ya que acelera la recuperación de datos.

En esta página, se muestra cómo crear y administrar instancias de caché con Rapid Cache. Para obtener información sobre cómo usar y administrar operaciones de larga duración que se inician a partir de las operaciones de caché asíncronas de Rapid Cache, consulta Usa operaciones de larga duración.

Antes de usar Rapid Cache, revisa las limitaciones y restricciones.

Antes de comenzar

Antes de comenzar a crear y administrar cachés, completa las siguientes secciones.

Obtén las funciones necesarias

Para obtener los permisos que necesitas para crear y administrar cachés de Rapid Cache, pídele a tu administrador que te otorgue el rol de IAM de Administrador de almacenamiento (roles/storage.admin) en el bucket para el que quieres crear cachés.

Este rol predefinido contiene los permisos necesarios para crear y administrar cachés de Rapid Cache. Para ver los permisos exactos que son necesarios, expande la sección Permisos requeridos:

Permisos necesarios

Se requieren los siguientes permisos para crear y administrar cachés de Rapid Cache:

  • storage.anywhereCaches.create (obligatorio para crear cachés)
  • storage.anywhereCaches.disable (obligatorio para inhabilitar las memorias caché)
  • storage.anywhereCaches.get (obligatorio para obtener cachés)
  • storage.anywhereCaches.list (obligatorio para enumerar cachés)
  • storage.anywhereCaches.resume (obligatorio para reanudar las memorias caché)
  • storage.anywhereCaches.update (obligatorio para actualizar cachés)
  • storage.managedFolders.create (solo es obligatorio para habilitar el comportamiento de transferencia en la escritura para una caché)
  • storage.managedFolders.update (solo se requiere para actualizar el comportamiento de la caché de la transferencia en escritura)

También puedes obtener estos permisos con roles personalizados.

Para obtener más información sobre cómo otorgar roles en los buckets, consulta Configura y administra políticas de IAM en buckets.

Para administrar las operaciones de larga duración que se inician desde los métodos de Rapid Cache, es posible que necesites roles y permisos adicionales. Consulta los roles necesarios para las operaciones de larga duración para obtener más información.

Información sobre la configuración de transferencia en el momento de la escritura

Cuando creas o actualizas una caché, puedes habilitarla de forma opcional para transferir datos en el momento en que se escriben en el bucket. Esta capacidad se conoce como "transferencia en el momento de la escritura". Si planeas habilitar la transferencia en el momento de la escritura con la API de JSON, te recomendamos que primero comprendas los comportamientos de los parámetros de configuración que se usan para la transferencia en el momento de la escritura.

Crea una caché

Console

Crea una caché para un bucket existente

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

    Ir a Buckets

  2. En la lista de buckets, haz clic en el nombre del bucket para el que deseas almacenar datos en caché.

  3. En la página de detalles del bucket haz clic en la pestaña Configuración.

  4. En la sección Rapid Cache, haz clic en Configurar caché.

    Aparecerá la página Configurar caché de tu bucket.

  5. En la sección Regiones de caché, haz clic en la región que contiene las zonas en las que deseas crear una caché.

  6. En la sección Zonas de caché, selecciona las zonas en las que deseas crear una caché. Para cada caché que crees en una zona, puedes completar los siguientes pasos de forma opcional:

    • Opcional: Puedes establecer un tiempo de actividad (TTL) personalizado que determine cuándo se expulsan los datos de la caché desde su última lectura. De forma predeterminada, el TTL de una caché se establece en un día.

      Para establecer un TTL personalizado, haz lo siguiente:

      1. En la columna Tiempo de actividad, especifica un valor de duración (por ejemplo: 48) y una unidad de tiempo (por ejemplo: hours).

      2. Haga clic en Guardar configuración.

    • Opcional: Puedes habilitar la caché para transferir datos en la escritura, además de transferir datos en la primera lectura. De forma predeterminada, las cachés solo están configuradas para transferir datos en la primera lectura.

      Para habilitar la caché para que transfiera datos en la escritura, haz lo siguiente:

      1. En la columna Criterios de transferencia, haz clic en Editar criterios de transferencia de caché edit.

        Aparecerá la página Establecer criterios de transferencia.

      2. Selecciona la casilla de verificación Transferir datos en la escritura.

        • Para habilitar la transferencia en el momento de la escritura en todos los objetos que se escriben recientemente en el bucket, haz clic en Todo el bucket.

        • Para habilitar la transferencia en el momento de la escritura solo para los objetos recién escritos que tengan un prefijo específico en su nombre, haz clic en Carpetas seleccionadas y, luego, ingresa el prefijo del nombre del objeto. El prefijo del nombre del objeto también se conoce como "ruta de acceso de la carpeta".

        Para ingresar varios prefijos de nombres de objetos, haz clic en Agregar add.

        Para quitar un prefijo, haz clic en Borrar elemento delete.

      3. Haz clic en Listo.

  7. Haga clic en Guardar configuración.

  8. En el diálogo que aparece, haga clic en Confirmar.

    Se abrirá la pestaña Operaciones en la página Detalles del bucket, en la que se muestra el estado del trabajo de la operación de creación de caché.

Crea una caché para un bucket nuevo

Para crear una caché como parte de la creación de un bucket nuevo, sigue las instrucciones en Crea un bucket nuevo.

Para ver el estado de la caché de un bucket desde la página Lista de buckets, haz lo siguiente:

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

    Ir a Buckets

  2. Haz clic en el ícono Ver columna (), selecciona Caché y, luego, haz clic en Aceptar.

Línea de comandos

Usa el comando gcloud storage buckets anywhere-caches create:

gcloud storage buckets anywhere-caches create gs://BUCKET_NAME CACHE_ZONE \
[--ttl=TTL] [--enable-ingest-on-write]

Reemplaza lo siguiente:

  • BUCKET_NAME por el nombre del bucket para el que deseas almacenar datos en caché. Por ejemplo, my-bucket

  • CACHE_ZONE con la zona en la que se ejecutará la caché. Por ejemplo, us-east1-b

    Para crear varias memorias caché a la vez, puedes especificar varias zonas. Por ejemplo, us-east1-b us-east1-c us-east1-d.

  • TTL (opcional) con el tiempo de actividad (TTL) de los datos en la caché. El valor puede ser de entre 1 y 7 días, inclusive. El valor se puede expresar en segundos, minutos, horas y días. Por ejemplo:

    • 86400s para 86,400 segundos
    • 1440m durante 1,440 minutos
    • 24h durante 24 horas
    • 1d por 1 día

    Si no se especifica, el valor predeterminado es 86400s (1 día).

Para configurar la caché de modo que transfiera datos en el momento en que se escriben en el bucket, especifica la marca opcional --enable-ingest-on-write. Esta marca permite que la caché transfiera todos los objetos cuando se escriben en el bucket.

Si se ejecuta de forma correcta, el comando devuelve el ID de la operación de larga duración asociada con la operación de creación de AnywhereCache. Puedes obtener detalles sobre la operación de larga duración o cancelarla para detener la operación de creación de AnywhereCaches antes de que se complete.

Bibliotecas cliente

C++

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage C++.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente. 

namespace storagecontrol = google::cloud::storagecontrol_v2;
[](storagecontrol::StorageControlClient client,
   std::string const& bucket_name, std::string const& cache_name,
   std::string const& zone_name) {
  google::storage::control::v2::AnywhereCache cache;
  cache.set_name(cache_name);
  cache.set_zone(zone_name);

  google::storage::control::v2::CreateAnywhereCacheRequest request;
  request.set_parent(std::string{"projects/_/buckets/"} + bucket_name);
  *request.mutable_anywhere_cache() = cache;

  // Start a create operation and block until it completes. Real applications
  // may want to setup a callback, wait on a coroutine, or poll until it
  // completes.
  auto anywhere_cache = client.CreateAnywhereCache(request).get();
  if (!anywhere_cache) throw std::move(anywhere_cache).status();
  std::cout << "Created anywhere cache: " << anywhere_cache->name() << "\n";
}

Java

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage Java.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente. 

import com.google.api.gax.longrunning.OperationFuture;
import com.google.storage.control.v2.AnywhereCache;
import com.google.storage.control.v2.BucketName;
import com.google.storage.control.v2.CreateAnywhereCacheMetadata;
import com.google.storage.control.v2.CreateAnywhereCacheRequest;
import com.google.storage.control.v2.StorageControlClient;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public final class AnywhereCacheCreate {

  public static void anywhereCacheCreate(String bucketName, String cacheName, String zoneName)
      throws InterruptedException, ExecutionException, IOException {
    try (StorageControlClient storageControl = StorageControlClient.create()) {

      CreateAnywhereCacheRequest request =
          CreateAnywhereCacheRequest.newBuilder()
              // Set project to "_" to signify globally scoped bucket
              .setParent(BucketName.format("_", bucketName))
              .setAnywhereCache(
                  AnywhereCache.newBuilder().setName(cacheName).setZone(zoneName).build())
              .build();

      // Start a long-running operation (LRO).
      OperationFuture<AnywhereCache, CreateAnywhereCacheMetadata> operation =
          storageControl.createAnywhereCacheAsync(request);

      // Await the LROs completion.
      AnywhereCache anywhereCache = operation.get();
      System.out.printf("Created anywhere cache: %s%n", anywhereCache.getName());
    }
  }
}

Rust

use google_cloud_lro::Poller;
use google_cloud_storage::client::StorageControl;
use google_cloud_storage::model::AnywhereCache;

pub async fn sample(client: &StorageControl, bucket_id: &str, zone: &str) -> anyhow::Result<()> {
    let cache = client
        .create_anywhere_cache()
        .set_parent(format!("projects/_/buckets/{bucket_id}"))
        .set_anywhere_cache(AnywhereCache::new().set_zone(zone).set_name(format!(
            "projects/_/buckets/{bucket_id}/anywhereCaches/{zone}"
        )))
        .poller()
        .until_done()
        .await?;
    println!("Created anywhere cache: {cache:?}");
    Ok(())
}

Terraform

Consulta la documentación de Terraform de google_storage_anywhere_cache para obtener detalles sobre cómo usar Rapid Cache con Terraform.

API de REST

API de JSON

  1. Tener la gcloud CLI instalada e inicializada, lo que te permite generar un token de acceso para el encabezado Authorization.

  2. Crea un archivo JSON que contenga la siguiente información:

    {
   "zone": "ZONE",
   "ttl": "TIME_TO_LIVE",
   "ingestOnWrite": INGEST_SETTING
}

    Reemplaza lo siguiente:

    • ZONE por la zona en la que se ejecutará la caché. Por ejemplo, us-east1-b

    • TIME_TO_LIVE por el tiempo de actividad (TTL) de los datos en la caché. El valor debe expresarse en segundos (por ejemplo, 172800s para 172,800 segundos, lo que equivale a 2 días).

      El valor mínimo es 86400s (1 día) y el valor máximo es 604800s (7 días). Si no se especifica, se establece de forma predeterminada como 86400s.

    • INGEST_SETTING con true o false para especificar si la caché transferirá datos en la escritura.

      Si se establece en true, se habilita la transferencia en la escritura para todos los objetos que se escriben en el bucket. Si se configura como false, la transferencia en escritura se puede habilitar de forma selectiva para los objetos que se escriben con un prefijo, o bien se puede inhabilitar para todo el bucket.

      Para obtener más información sobre la configuración que se usa para habilitar la escritura durante la transferencia, consulta los requisitos para habilitar la escritura durante la transferencia.

      Para habilitar la incorporación en escritura a nivel del bucket o del prefijo, o para inhabilitar por completo la incorporación en escritura, usa uno de los siguientes conjuntos de instrucciones.

      Habilita la transferencia en el momento de la escritura para el bucket

      1. Para habilitar la transferencia en la escritura para todos los objetos escritos en el bucket, establece el valor de INGEST_SETTINGS en true.

      2. Sigue el paso 3 para completar tu solicitud de almacenamiento en caché.

      Habilita la transferencia en el momento de la escritura de forma selectiva para los objetos que se encuentran bajo un prefijo

      1. Establece el valor de INGEST_SETTINGS en false.

      2. Sigue el paso 3 para completar la solicitud de almacenamiento en caché.

      3. Crea una carpeta administrada que use el prefijo como nombre, si la carpeta administrada aún no existe.

      4. Envía una solicitud PATCH de carpeta administrada que incluya una configuración de rapidCacheConfig. Establece los valores de los campos en la configuración con la guía de Información para usar la transferencia en el momento de la escritura.

      Para obtener instrucciones detalladas sobre cómo usar una configuración de rapidCacheConfig, consulta Actualiza la función de incorporación en escritura en una carpeta administrada.

      Crea una caché sin habilitar la transferencia en escritura

      1. Establece el valor de INGEST_SETTINGS en false.

      2. Completa tu solicitud de caché siguiendo el paso 3.

  3. Usa cURL para llamar a la API de JSON con una solicitud para crear una caché:

    curl -X POST --data-binary @JSON_FILE_NAME \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json" \
    "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/anywhereCaches"

    Reemplaza lo siguiente:

    • JSON_FILE_NAME por el nombre del archivo JSON que creaste en el paso 2.

    • BUCKET_NAME por el nombre del bucket para el que deseas almacenar datos en caché. Por ejemplo, my-bucket

Si se ejecuta de forma correcta, la operación devuelve un google.longrunning.Operation. Puedes obtener detalles sobre la operación de larga duración o cancelarla para detener la operación de creación de AnywhereCaches antes de que se complete.

Cómo ver una caché

Console

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

    Ir a Buckets

  2. En la lista de buckets, haz clic en el nombre del bucket asociado con la caché que deseas ver.

  3. En la página de detalles del bucket haz clic en la pestaña Configuración.

  4. En la sección Rapid Cache, haz clic en Editar junto al campo Caché.

  5. En la página Editar configuración que aparece, selecciona una región para ver todas las cachés dentro de las zonas de la región.

    En el panel Zonas de caché, puedes ver los detalles de cada caché disponible.

Línea de comandos

Usa el comando gcloud storage buckets anywhere-caches describe:

gcloud storage buckets anywhere-caches describe CACHE_ID

Reemplaza lo siguiente:

  • CACHE_ID por el identificador de la instancia de caché, formulado como BUCKET_NAME/CACHE_ZONE. Por ejemplo: my-bucket/us-east1-b.

Usa la marca opcional raw para generar una respuesta sin procesar de la API en lugar de una respuesta estandarizada de la API.

Si se ejecuta correctamente, el comando devuelve un recurso de AnywhereCache.

Bibliotecas cliente

C++

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage C++.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente. 

namespace storagecontrol = google::cloud::storagecontrol_v2;
[](storagecontrol::StorageControlClient client,
   std::string const& cache_name) {
  auto anywhere_cache = client.GetAnywhereCache(cache_name);
  if (!anywhere_cache) throw std::move(anywhere_cache).status();
  std::cout << "Got anywhere cache: " << anywhere_cache->name() << "\n";
}

Java

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage Java.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente. 


import com.google.storage.control.v2.AnywhereCache;
import com.google.storage.control.v2.GetAnywhereCacheRequest;
import com.google.storage.control.v2.StorageControlClient;
import java.io.IOException;

public final class AnywhereCacheGet {

  public static void anywhereCacheGet(String cacheName) throws IOException {
    try (StorageControlClient storageControl = StorageControlClient.create()) {

      GetAnywhereCacheRequest request =
          GetAnywhereCacheRequest.newBuilder().setName(cacheName).build();

      AnywhereCache anywhereCache = storageControl.getAnywhereCache(request);

      System.out.printf("Got anywhere cache: %s%n", anywhereCache.getName());
    }
  }
}

Rust

use google_cloud_storage::client::StorageControl;

pub async fn sample(
    client: &StorageControl,
    bucket_id: &str,
    cache_id: &str,
) -> anyhow::Result<()> {
    let cache = client
        .get_anywhere_cache()
        .set_name(format!(
            "projects/_/buckets/{bucket_id}/anywhereCaches/{cache_id}"
        ))
        .send()
        .await?;
    println!("Got anywhere cache: {:?}", cache);
    Ok(())
}

Terraform

Consulta la documentación de google_storage_anywhere_cache de Terraform para obtener detalles sobre cómo usar Rapid Cache con Terraform.

API de REST

API de JSON

  1. Tener la gcloud CLI instalada e inicializada, lo que te permite generar un token de acceso para el encabezado Authorization

  2. Usa cURL para llamar a la API de JSON con una solicitud para obtener una caché:

    curl -X GET -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/anywhereCaches/RAPID_CACHE_ID"

    Reemplaza lo siguiente:

    • BUCKET_NAME por el nombre del bucket asociado con la caché que deseas recuperar. Por ejemplo, my-bucket.

    • RAPID_CACHE_ID por la zona en la que se encuentra la caché. Por ejemplo, us-east1-b

Si se ejecuta de forma correcta, esta operación devuelve un recurso AnywhereCache.

Enumera las cachés

Console

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

    Ir a Buckets

  2. En la lista de buckets, haz clic en el nombre del bucket asociado con las cachés que deseas ver.

  3. En la página de detalles del bucket haz clic en la pestaña Configuración.

  4. En la sección Rapid Cache, haz clic en Editar junto al campo Caché.

  5. En la página Editar configuración que aparece, selecciona una región para ver todas las memorias caché dentro de las zonas de esa región.

    En el panel Zonas de caché, aparecen todas las cachés disponibles para las zonas dentro de la región.

Línea de comandos

Usa el comando gcloud storage buckets anywhere-caches list:

gcloud storage buckets anywhere-caches list gs://BUCKET_NAME

Reemplaza lo siguiente:

  • BUCKET_NAME con el nombre del bucket asociado con los cachés que deseas enumerar. Por ejemplo, my-bucket

Si se ejecuta de forma correcta, el comando devuelve una lista de recursos de AnywhereCache.

De manera opcional, puedes usar la marca --raw para devolver una respuesta de la API sin procesar en lugar de una respuesta estandarizada. Para obtener más información sobre cómo controlar los comportamientos de las listas, como la paginación de los resultados, consulta la documentación de gcloud storage ls.

Bibliotecas cliente

C++

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage C++.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente. 

namespace storagecontrol = google::cloud::storagecontrol_v2;
[](storagecontrol::StorageControlClient client,
   std::string const& bucket_name) {
  auto const parent = std::string{"projects/_/buckets/"} + bucket_name;
  for (auto anywhere_cache : client.ListAnywhereCaches(parent)) {
    if (!anywhere_cache) throw std::move(anywhere_cache).status();
    std::cout << anywhere_cache->name() << "\n";
  }
}

Java

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage Java.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente. 


import com.google.storage.control.v2.AnywhereCache;
import com.google.storage.control.v2.BucketName;
import com.google.storage.control.v2.ListAnywhereCachesRequest;
import com.google.storage.control.v2.StorageControlClient;
import com.google.storage.control.v2.StorageControlClient.ListAnywhereCachesPagedResponse;
import java.io.IOException;

public final class AnywhereCacheList {

  public static void anywhereCacheList(String bucketName) throws IOException {
    try (StorageControlClient storageControl = StorageControlClient.create()) {

      ListAnywhereCachesRequest request =
          ListAnywhereCachesRequest.newBuilder()
              .setParent(BucketName.format("_", bucketName))
              .build();

      ListAnywhereCachesPagedResponse page = storageControl.listAnywhereCaches(request);
      for (AnywhereCache anywhereCache : page.iterateAll()) {
        System.out.println(anywhereCache.getName());
      }
    }
  }
}

Rust

use google_cloud_gax::paginator::ItemPaginator;
use google_cloud_storage::client::StorageControl;

pub async fn sample(client: &StorageControl, bucket_id: &str) -> anyhow::Result<()> {
    let mut stream = client
        .list_anywhere_caches()
        .set_parent(format!("projects/_/buckets/{}", bucket_id))
        .by_item();
    while let Some(cache) = stream.next().await {
        println!("Found cache: {:?}", cache?);
    }
    Ok(())
}

Terraform

Consulta la documentación de Terraform de google_storage_anywhere_cache para obtener detalles sobre cómo usar Rapid Cache con Terraform.

API de REST

API de JSON

  1. Tener la gcloud CLI instalada e inicializada, lo que te permite generar un token de acceso para el encabezado Authorization

  2. Usa cURL para llamar a la API de JSON con una solicitud para enumerar cachés:

    curl -X GET -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/anywhereCaches"

    Reemplaza lo siguiente:

    • BUCKET_NAME con el nombre del bucket asociado con los cachés que deseas recuperar. Por ejemplo, my-bucket.

    Cuando enumeres varias memorias caché, puedes paginar los resultados.

Si se ejecuta correctamente, esta operación devuelve una lista de recursos de AnywhereCache. Para obtener detalles sobre la estructura de esta respuesta, consulta la respuesta en la documentación de la lista de AnywhereCaches.

Actualiza una caché

Console

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

    Ir a Buckets

  2. En la lista de buckets, haz clic en el nombre del bucket asociado con la caché que deseas actualizar.

  3. En la página de detalles del bucket haz clic en la pestaña Configuración.

  4. En la sección Rapid Cache, haz clic en Administrar cachés.

  5. En el panel Administrar cachés, haz clic en Editar o crear cachés.

  6. En la página Editar configuración que aparece, actualiza las propiedades de la caché:

    • Para actualizar el TTL de la caché, busca la columna Tiempo de actividad, especifica una duración y selecciona una unidad de tiempo (por ejemplo, minutos).

    • Para configurar el comportamiento de la caché de la transferencia en escritura, lo que incluye si se almacenan en caché todos los objetos escritos o solo los objetos selectivos escritos bajo un prefijo:

      1. Busca la columna Criterios de transferencia y, luego, haz clic en Editar criterios de transferencia de caché.

      2. En el panel Establecer criterios de transferencia, haz lo siguiente:

      • Para habilitar o inhabilitar la transferencia en el momento de la escritura, selecciona o desmarca la casilla de verificación Ingest data on write y, luego, haz clic en Done.

      • Para actualizar la caché de modo que transfiera todos los objetos del bucket en el momento de la escritura, asegúrate de que la casilla de verificación Transferir datos en el momento de la escritura esté seleccionada y, luego, selecciona Todo el bucket. Luego, haz clic en Listo.

      • Para actualizar la caché de modo que solo se transfieran los objetos que contengan un prefijo especificado en su nombre, asegúrate de que esté seleccionada la casilla de verificación Ingest data on write y, luego, selecciona Selected folders.

        • Para especificar un prefijo, ingresa uno o varios prefijos en el campo de ruta de la carpeta y, luego, haz clic en Listo.

        • Para quitar un prefijo, haz clic en Borrar elemento junto al prefijo.

  7. En la página Editar configuración, haz clic en Guardar.

  8. En el diálogo que aparece, haga clic en Confirmar.

Línea de comandos

Usa el comando gcloud storage buckets anywhere-caches update:

gcloud storage buckets anywhere-caches update CACHE_ID \
[--ttl=TTL] [--[no-]enable-ingest-on-write]

Reemplaza lo siguiente:

  • CACHE_ID por el identificador de la instancia de caché, formulado como BUCKET_NAME/CACHE_ZONE. Por ejemplo: my-bucket/us-east1-b.

    Para actualizar varias cachés a la vez, puedes especificar varios identificadores. Por ejemplo, my-bucket/us-east1-b my-bucket/us-east1-c.

  • TTL (opcional) por el tiempo de actividad (TTL) de los datos en la caché. El valor puede ser de entre 1 y 7 días, inclusive. El valor se puede expresar en segundos, minutos, horas y días. Por ejemplo:

    • 86400s para 86,400 segundos
    • 1440m durante 1,440 minutos
    • 24h durante 24 horas
    • 1d por 1 día

Para configurar la caché de modo que transfiera datos en el momento en que se escriben en el bucket, especifica la marca --enable-ingest-on-write. Esta marca permite que la caché transfiera todos los objetos cuando se escriben en el bucket. Para inhabilitar la transferencia de datos de la caché en la escritura, especifica la marca --no-enable-ingest-on-write.

Si se ejecuta correctamente, el comando devuelve el ID de la operación sin procesar de larga duración asociada con la operación de actualización de Anywhere Cache. Puedes obtener detalles sobre la operación de larga duración.

Bibliotecas cliente

C++

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage C++.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente. 

namespace storagecontrol = google::cloud::storagecontrol_v2;
[](storagecontrol::StorageControlClient client,
   std::string const& cache_name) {
  google::storage::control::v2::AnywhereCache cache;
  google::protobuf::FieldMask field_mask;
  field_mask.add_paths("ttl");
  cache.set_name(cache_name);
  cache.mutable_ttl()->set_seconds(86400);
  // Start an update operation and block until it completes. Real applications
  // may want to setup a callback, wait on a coroutine, or poll until it
  // completes.
  auto anywhere_cache = client.UpdateAnywhereCache(cache, field_mask).get();
  if (!anywhere_cache) throw std::move(anywhere_cache).status();
  std::cout << "Updated anywhere cache: " << anywhere_cache->name() << "\n";
}

Java

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage Java.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente. 


import com.google.api.gax.longrunning.OperationFuture;
import com.google.protobuf.FieldMask;
import com.google.storage.control.v2.AnywhereCache;
import com.google.storage.control.v2.StorageControlClient;
import com.google.storage.control.v2.UpdateAnywhereCacheMetadata;
import com.google.storage.control.v2.UpdateAnywhereCacheRequest;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public final class AnywhereCacheUpdate {

  public static void anywhereCacheUpdate(String cacheName, String admissionPolicy)
      throws InterruptedException, ExecutionException, IOException {
    try (StorageControlClient storageControl = StorageControlClient.create()) {

      AnywhereCache pendingUpdate =
          AnywhereCache.newBuilder().setName(cacheName).setAdmissionPolicy(admissionPolicy).build();

      UpdateAnywhereCacheRequest request =
          UpdateAnywhereCacheRequest.newBuilder()
              .setAnywhereCache(pendingUpdate)
              .setUpdateMask(FieldMask.newBuilder().addPaths("admission_policy").build())
              .build();

      // Start a long-running operation (LRO).
      OperationFuture<AnywhereCache, UpdateAnywhereCacheMetadata> operation =
          storageControl.updateAnywhereCacheAsync(request);

      // Await the LROs completion.
      AnywhereCache updatedAnywhereCache = operation.get();
      System.out.printf("Updated anywhere cache: %s%n", updatedAnywhereCache.getName());
    }
  }
}

Rust

use google_cloud_lro::Poller;
use google_cloud_storage::client::StorageControl;
use google_cloud_storage::model::AnywhereCache;
use google_cloud_wkt::FieldMask;

pub async fn sample(
    client: &StorageControl,
    bucket_id: &str,
    cache_id: &str,
) -> anyhow::Result<()> {
    let anywhere_cache = AnywhereCache::new()
        .set_name(format!(
            "projects/_/buckets/{}/anywhereCaches/{}",
            bucket_id, cache_id
        ))
        .set_admission_policy("ADMIT_ON_SECOND_MISS".to_string());
    let operation = client
        .update_anywhere_cache()
        .set_anywhere_cache(anywhere_cache)
        .set_update_mask(FieldMask::default().set_paths(["admission_policy"]))
        .poller()
        .until_done()
        .await?;
    println!("Updated anywhere cache: {:?}", operation);
    Ok(())
}

Terraform

Consulta la documentación de Terraform de google_storage_anywhere_cache para obtener detalles sobre cómo usar Rapid Cache con Terraform.

API de REST

API de JSON

  1. Tener la gcloud CLI instalada e inicializada, lo que te permite generar un token de acceso para el encabezado Authorization.

  2. Crea un archivo JSON que incluya cambios en las propiedades de la caché que deseas actualizar.

    {
   "ttl": "TIME_TO_LIVE",
   "ingestOnWrite": INGEST_SETTING
}

    Reemplaza lo siguiente:

    • TIME_TO_LIVE con el TTL de los datos en la caché. El valor puede ser de entre 1 y 7 días, inclusive. El valor se puede expresar en segundos, minutos, horas y días. Por ejemplo:

      • 86400s para 86,400 segundos
      • 1440m durante 1,440 minutos
      • 24h durante 24 horas
      • 1d por 1 día

    • INGEST_SETTING con true o false para especificar si la caché transfiere datos en la escritura.

      Si se establece en true, se habilita la transferencia en la escritura para todos los objetos que se escriben en el bucket. Si se configura como false, la transferencia en escritura se puede habilitar de forma selectiva para los objetos que se escriben con un prefijo, o bien se puede inhabilitar por completo.

      Para obtener información sobre la configuración que se usa para habilitar la escritura durante la transferencia a nivel del bucket o del prefijo, consulta Cómo habilitar la escritura durante la transferencia.

      Para habilitar la transferencia en el momento de la escritura a nivel del bucket o del prefijo, o para inhabilitarla por completo, usa uno de los siguientes conjuntos de instrucciones.

      Habilita la transferencia en el momento de la escritura para el bucket

      1. Para habilitar la transferencia en la escritura para todos los objetos escritos en el bucket, establece el valor de INGEST_SETTINGS en true.

      2. Completa tu solicitud de caché siguiendo el paso 3.

      3. Si la opción de incorporación en escritura se habilitó anteriormente para un prefijo, existe una carpeta administrada con una configuración de rapidCacheConfig. Realiza una solicitud PATCH de carpeta administrada que establezca el mapa policies en la configuración rapidCacheConfig como null.

      Para obtener instrucciones detalladas sobre cómo usar una configuración de rapidCacheConfig, consulta Actualiza la transferencia en el momento de la escritura en una carpeta administrada.

      Habilita la transferencia en el momento de la escritura de forma selectiva para los objetos con un prefijo

      1. Establece el valor de INGEST_SETTINGS en false.

      2. Sigue el paso 3 para completar la solicitud de almacenamiento en caché.

      3. Crea una carpeta administrada que use el prefijo como nombre, si la carpeta administrada aún no existe.

      4. Envía una solicitud PATCH de carpeta administrada que incluya una configuración de rapidCacheConfig. Establece los valores de los campos en la configuración siguiendo las instrucciones de la sección Configuración y comportamientos de la incorporación en escritura.

      El mapa policies de una configuración de rapidCacheConfig puede contener uno o varios IDs de caché (por ejemplo, us-east1-a y us-east1-b). Para habilitar la transferencia en la escritura para ciertas cachés, establece el parámetro de configuración ingestOnWrite de la caché individual en enabled. Para inhabilitar la transferencia en escritura para ciertos cachés, establece el parámetro de configuración ingestOnWrite del caché individual en unspecified. Lee atentamente sobre la herencia de la transferencia en escritura para comprender cómo se puede ver afectada la política de transferencia en escritura de una caché cuando el parámetro de configuración ingestOnWrite de la caché se establece en unspecified.

      Para obtener instrucciones detalladas sobre cómo usar una configuración de rapidCacheConfig, consulta Actualiza la función de incorporación en escritura en una carpeta administrada.

      Inhabilita la transferencia en escritura

      1. Establece el valor de INGEST_SETTINGS en false. Este parámetro de configuración inhabilita la transferencia en el momento de la escritura a nivel del bucket.

      2. Sigue el paso 3 para completar la solicitud de almacenamiento en caché.

      3. Para inhabilitar la transferencia en el momento de la escritura a nivel del prefijo, busca la carpeta administrada en la que se configuró la transferencia en el momento de la escritura a nivel del prefijo. Realiza una solicitud PATCH de carpeta administrada que establezca el mapa policies en la configuración rapidCacheConfig como null. Como alternativa, borra la configuración de rapidCacheConfig del recurso de carpeta administrada en una solicitud PATCH.

      Para obtener instrucciones detalladas sobre cómo usar una configuración de rapidCacheConfig, consulta Actualiza la función de incorporación en escritura en una carpeta administrada.

    En el siguiente ejemplo, se actualiza el TTL de la caché a 2 días y se habilita la transferencia en el momento de la escritura para todos los objetos escritos en el bucket:

    {
   "ttl": "172800s",
   "ingestOnWrite": true
}

  3. Para aplicar las propiedades nuevas, usa cURL para llamar a la API de JSON con una solicitud para actualizar la caché:

    curl -X PATCH --data-binary @JSON_FILE_NAME \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json" \
    "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/anywhereCaches/RAPID_CACHE_ID"

    Reemplaza lo siguiente:

    • JSON_FILE_NAME con el nombre del archivo JSON que creaste en el paso 2.

    • BUCKET_NAME por el nombre del bucket asociado con la caché que deseas actualizar. Por ejemplo, my-bucket.

    • RAPID_CACHE_ID con el identificador de la caché. Por ejemplo, us-east1-b

Si la operación se realiza correctamente, devuelve un objeto google.longrunning.Operation. Puedes obtener detalles sobre la operación de larga duración.

Cómo reanudar una caché

Console

Para reanudar una caché que se detuvo o inhabilitó, sigue estas instrucciones:

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

    Ir a Buckets

  2. En la lista de buckets, haz clic en el nombre del bucket asociado con la caché que deseas reanudar.

  3. En la página de detalles del bucket haz clic en la pestaña Configuración.

  4. En la sección Rapid Cache, haz clic en Administrar cachés.

  5. En el panel Administrar cachés, haz clic en el ícono Reanudar caché ().

  6. Haz clic en Cerrar.

Línea de comandos

Usa el comando gcloud storage buckets anywhere-caches resume:

gcloud storage buckets anywhere-caches resume CACHE_ID

Reemplaza lo siguiente:

  • CACHE_ID por el identificador de la instancia de caché, formulado como BUCKET_NAME/CACHE_ZONE. Por ejemplo: my-bucket/us-east1-b.

    Para reanudar varias cachés a la vez, puedes especificar varios identificadores. Por ejemplo, my-bucket/us-east1-b my-bucket/us-east1-c.

Si se ejecuta de forma correcta, el comando devuelve un recurso de AnywhereCache con formato.

Bibliotecas cliente

C++

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage C++.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente. 

namespace storagecontrol = google::cloud::storagecontrol_v2;
[](storagecontrol::StorageControlClient client,
   std::string const& cache_name) {
  auto anywhere_cache = client.ResumeAnywhereCache(cache_name);
  if (!anywhere_cache) throw std::move(anywhere_cache).status();
  std::cout << "Resumed anywhere cache: " << anywhere_cache->name() << "\n";
}

Java

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage Java.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente. 


import com.google.storage.control.v2.AnywhereCache;
import com.google.storage.control.v2.ResumeAnywhereCacheRequest;
import com.google.storage.control.v2.StorageControlClient;
import java.io.IOException;

public final class AnywhereCacheResume {

  public static void anywhereCacheResume(String cacheName) throws IOException {
    try (StorageControlClient storageControl = StorageControlClient.create()) {

      ResumeAnywhereCacheRequest request =
          ResumeAnywhereCacheRequest.newBuilder().setName(cacheName).build();

      AnywhereCache anywhereCache = storageControl.resumeAnywhereCache(request);

      System.out.printf("Resumed anywhere cache: %s%n", anywhereCache.getName());
    }
  }
}

Rust

use google_cloud_storage::client::StorageControl;

pub async fn sample(
    client: &StorageControl,
    bucket_id: &str,
    cache_id: &str,
) -> anyhow::Result<()> {
    let cache = client
        .resume_anywhere_cache()
        .set_name(format!(
            "projects/_/buckets/{}/anywhereCaches/{}",
            bucket_id, cache_id
        ))
        .send()
        .await?;
    println!("Resumed anywhere cache: {:?}", cache);
    Ok(())
}

Terraform

Consulta la documentación de google_storage_anywhere_cache de Terraform para obtener detalles sobre cómo usar Rapid Cache con Terraform.

API de REST

API de JSON

  1. Tener la gcloud CLI instalada e inicializada, lo que te permite generar un token de acceso para el encabezado Authorization.

  2. Usa cURL para llamar a la API de JSON con una solicitud para reanudar una caché:

    curl -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/anywhereCaches/RAPID_CACHE_ID/resume"

    Reemplaza lo siguiente:

    • BUCKET_NAME por el nombre del bucket asociado con la caché que deseas reanudar. Por ejemplo, my-bucket.

    • RAPID_CACHE_ID con el identificador de la caché. Por ejemplo, us-east1-b

Si la operación se realiza correctamente, se muestra un recurso de AnywhereCache con formato.

Inhabilita una caché

Console

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

    Ir a Buckets

  2. En la lista de buckets, haz clic en el nombre del bucket asociado con la caché que deseas inhabilitar.

  3. En la página de detalles del bucket haz clic en la pestaña Configuración.

  4. En la sección Rapid Cache, haz clic en Administrar cachés.

  5. En el panel Administrar cachés, haz clic en el ícono Inhabilitar la caché ().

  6. En el diálogo que aparece, haga clic en Confirmar.

  7. Haz clic en Cerrar.

Línea de comandos

Usa el comando gcloud storage buckets anywhere-caches disable:

gcloud storage buckets anywhere-caches disable CACHE_ID

Reemplaza lo siguiente:

  • CACHE_ID con el identificador de la instancia de caché, formulado como BUCKET_NAME/CACHE_ZONE. Por ejemplo: my-bucket/us-east1-b.

    Para inhabilitar varias cachés a la vez, puedes especificar varios identificadores. Por ejemplo, my-bucket/us-east1-b my-bucket/us-east1-c.

Si se ejecuta de forma correcta, el comando devuelve un recurso de AnywhereCache con formato.

Bibliotecas cliente

C++

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage C++.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente. 

namespace storagecontrol = google::cloud::storagecontrol_v2;
[](storagecontrol::StorageControlClient client,
   std::string const& cache_name) {
  auto anywhere_cache = client.DisableAnywhereCache(cache_name);
  if (!anywhere_cache) throw std::move(anywhere_cache).status();
  std::cout << "Disabled anywhere cache: " << anywhere_cache->name() << "\n";
}

Java

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage Java.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente. 


import com.google.storage.control.v2.AnywhereCache;
import com.google.storage.control.v2.DisableAnywhereCacheRequest;
import com.google.storage.control.v2.StorageControlClient;
import java.io.IOException;

public final class AnywhereCacheDisable {

  public static void anywhereCacheDisable(String cacheName) throws IOException {
    try (StorageControlClient storageControl = StorageControlClient.create()) {

      DisableAnywhereCacheRequest request =
          DisableAnywhereCacheRequest.newBuilder().setName(cacheName).build();

      AnywhereCache anywhereCache = storageControl.disableAnywhereCache(request);

      System.out.printf("Disabled anywhere cache: %s%n", anywhereCache.getName());
    }
  }
}

Rust

use google_cloud_storage::client::StorageControl;

pub async fn sample(
    client: &StorageControl,
    bucket_id: &str,
    cache_id: &str,
) -> anyhow::Result<()> {
    let cache = client
        .disable_anywhere_cache()
        .set_name(format!(
            "projects/_/buckets/{}/anywhereCaches/{}",
            bucket_id, cache_id
        ))
        .send()
        .await?;
    println!("Disabled anywhere cache: {:?}", cache);
    Ok(())
}

Terraform

Consulta la documentación de google_storage_anywhere_cache de Terraform para obtener detalles sobre cómo usar Rapid Cache con Terraform.

API de REST

API de JSON

  1. Tener la gcloud CLI instalada e inicializada, lo que te permite generar un token de acceso para el encabezado Authorization.

  2. Usa cURL para llamar a la API de JSON con una solicitud para inhabilitar una caché:

    curl -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/anywhereCaches/RAPID_CACHE_ID/disable"

    Reemplaza lo siguiente:

    • BUCKET_NAME con el nombre del bucket asociado con la caché que deseas inhabilitar. Por ejemplo, my-bucket.

    • RAPID_CACHE_ID con el identificador de la caché. Por ejemplo, us-east1-b

Si se ejecuta de forma correcta, el comando devuelve un recurso AnywhereCache con formato.

Supervisa el rendimiento de la caché

La parte de Cloud Storage de la consola de Google Cloud proporciona gráficos de supervisión que te permiten hacer un seguimiento del rendimiento de tus memorias caché con métricas. Estos gráficos de supervisión también se pueden ver con Cloud Monitoring.

Gráficos disponibles

Gráfico Nivel de la jerarquía de recursos Descripción
Tasa de expulsión de bytes Bucket Es la tasa de bytes expulsados de la caché, muestreada cada hora. Estos datos se actualizan más de una vez por hora para permitir el procesamiento posterior de los datos.
Tasa de expulsión de bytes Proyecto Es la tasa de bytes expulsados de todas las cachés de un bucket, muestreada cada hora. Estos datos se actualizan más de una vez por hora para permitir el procesamiento posterior de los datos.
Bytes en la caché Bucket Es la cantidad de bytes en la caché, muestreada cada hora. Estos datos se actualizan más de una vez por hora para permitir el procesamiento posterior de los datos.
Bytes en la caché Proyecto La cantidad de bytes en todas las cachés de un bucket, muestreada cada hora. Estos datos se actualizan más de una vez por hora para permitir el procesamiento posterior de los datos.
Beneficio de capacidad de procesamiento de caché Proyecto La tasa de la cuota de ancho de banda de transferencia de datos para la región, birregión o multirregión, el uso de la cuota y la capacidad de procesamiento adicional que entrega la caché. La capacidad de procesamiento adicional que entrega la caché no se tiene en cuenta para la cuota. Por lo tanto, el uso de la caché permite que los proyectos excedan la capacidad de procesamiento permitida por la cuota.
Operaciones de tasa de aciertos Bucket Es el porcentaje de operaciones de caché que entrega los datos solicitados desde la caché en relación con el total de operaciones aptas para caché, muestreadas cada 60 segundos. Si una lectura se devuelve por completo desde la caché, la operación se considera un acierto. Si la lectura no se devuelve desde la caché o solo se devuelve parcialmente desde la caché, la operación se considera como un error.
Operaciones de tasa de aciertos Proyecto Es el porcentaje de operaciones de caché que entregan los datos solicitados desde todas las cachés de un bucket en relación con el total de operaciones aptas para caché, muestreadas durante 60 segundos. Si una lectura se devuelve por completo desde la caché, la operación se considera un acierto. Si la lectura no se devuelve desde la caché o solo se devuelve parcialmente desde la caché, la operación se considera como un error.
Bytes de tasa de aciertos Bucket Es el porcentaje de bytes que se entregan desde la caché en relación con el total de bytes aptos para caché, con muestreo cada 60 segundos.
Bytes de tasa de aciertos Proyecto Es el porcentaje de bytes que se entregan desde todas las cachés de un bucket en relación con el total de bytes aptos para caché, con muestreo cada 60 segundos.
Tasa de transferencia de bytes sin procesar Bucket Es la tasa de bytes sin procesar transferidos a cada caché, con muestreo cada 60 segundos. Todos los bytes transferidos, incluidos los no facturables, se usan para calcular el valor de esta métrica. Esta métrica se informa en tiempo real.
Tasa de transferencia de bytes sin procesar Proyecto Es la tasa de bytes sin procesar transferidos a todas las cachés de un bucket, con muestreo cada 60 segundos. Todos los bytes transferidos, incluidos los no facturables, se usan para calcular el valor de esta métrica. Esta métrica se informa en tiempo real.
Capacidad de procesamiento: Acierto de caché Bucket Es la capacidad de procesamiento que se entrega desde la caché, con muestreo cada 60 segundos.
Capacidad de procesamiento: Acierto de caché Proyecto Es la capacidad de procesamiento que se entrega desde todas las cachés de un bucket, con muestreo cada 60 segundos.
Capacidad de procesamiento: Error de caché Bucket Es la capacidad de procesamiento que no se entrega desde la caché, con muestreo cada 60 segundos.
Capacidad de procesamiento: Error de caché Proyecto Es la capacidad de procesamiento que no se entrega desde ninguna de las cachés de un bucket, con muestreo cada 60 segundos.

Accede a los gráficos

Los gráficos de supervisión capturan datos de buckets individuales o de todos los buckets de un proyecto. El nivel de jerarquía de recursos que captura un gráfico determina dónde puedes acceder a él.

Accede a gráficos a nivel de bucket

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

    Ir a Buckets

  2. En la lista de buckets, haz clic en el nombre del bucket para el que deseas ver los gráficos de supervisión.

  3. En la página Detalles del bucket, haz clic en la pestaña Observabilidad.

  4. En el menú de navegación, selecciona Rapid Cache.

    Se muestran los gráficos de Monitoring.

Accede a los gráficos a nivel del proyecto

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

    Ir a Buckets

  2. En el panel de navegación de Cloud Storage, haz clic en Monitoring.

  3. En la barra de menú, haz clic en Rapid Cache.

    Se muestran los gráficos de Monitoring.

Usa operaciones de larga duración

Cuando se ejecutan correctamente, las operaciones AnywhereCaches Create y Update inician una operación de larga duración. Puedes obtener y enumerar operaciones de larga duración para ver los detalles y el estado de la operación de AnywhereCaches subyacente, o cancelar una operación de larga duración para cancelar la operación de AnywhereCaches subyacente mientras está en curso.

Para obtener instrucciones sobre el uso de operaciones de larga duración para Rapid Cache, consulta Usa operaciones de larga duración.

En el siguiente ejemplo, se muestra una operación de larga duración que se inicia desde una operación de creación de AnywhereCaches:

done: false
kind: storage#operation
metadata:
  '@type': type.googleapis.com/google.storage.control.v2.CreateAnywhereCacheMetadata
  anywhereCacheId: us-central1-c
  zone: us-central1-c
  ttl: 172800s
  commonMetadata:
    createTime: '2023-12-14T20:52:00.032Z'
    progressPercent: -1
    requestedCancellation: false
    type: create-anywhere-cache
    updateTime: '2023-12-14T20:52:00.032Z'
name: projects/_/buckets/my-bucket/operations/AULf_KhQxxsWRSn56wv4jfmn3pOu_dKTz9FoYx6S0EzMw5ssR0cXIiorCvHRwqxZnQmWj9jnGpKb3Y6iCD3XM9KLc8EHBm7uig
selfLink: https://www.googleapis.com/storage/v1/b/my-bucket/operations/AULf_KhQxxsWRSn56wv4jfmn3pOu_dKTz9FoYx6S0EzMw5ssR0cXIiorCvHRwqxZnQmWj9jnGpKb3Y6iCD3XM9KLc8EHBm7uig

Reintentos

Las APIs de AnywhereCaches asíncronas son idempotentes de forma predeterminada. Esto significa que puedes reintentar de forma segura las llamadas asíncronas a la API de AnywhereCaches sin preocuparte por modificar los recursos de forma involuntaria.

Por ejemplo, supongamos que realizas una operación de creación de AnywhereCaches para crear una caché en us-central1-a, que se realiza correctamente. Si realizas una operación de creación de AnywhereCaches posterior con la misma zona que se ejecuta correctamente, la solicitud devuelve la misma operación de larga duración que la solicitud anterior. Ten en cuenta que este comportamiento solo se produce si incluyes un request_id como parte de tu solicitud de creación de caché. Si no se incluye un request_id, recibirás un error ANYWHERE_CACHE_ALREADY_EXISTS cuando intentes crear una caché que ya existe. Para obtener información sobre cómo incluir un request_id, consulta Cómo solicitar la identificación.

¿Qué sigue?

Obtén recomendaciones sobre qué buckets y zonas crear una caché.