Creare e gestire cache con Rapid Cache

Console

Crea una cache per un bucket esistente

1. Nella console Cloud de Confiance , vai alla pagina Bucket in Cloud Storage.
   

   Vai a Bucket

2. Nell'elenco dei bucket, fai clic sul nome del bucket per cui vuoi memorizzare i dati nella cache.

3. Nella pagina Dettagli bucket, fai clic sulla scheda Configurazione.

4. Nella sezione Rapid Cache, fai clic su Configura cache.

   Viene visualizzata la pagina Configura cache per il tuo bucket.

5. Nella sezione Regioni cache, fai clic sulla regione che contiene le zone in cui vuoi creare una cache.

6. Nella sezione Zone cache, seleziona le zone in cui vuoi creare una cache. Per ogni cache creata in una zona, facoltativamente completa i seguenti passaggi:

   • (Facoltativo) Puoi impostare una durata (TTL) personalizzata che determina quando i dati vengono rimossi dalla cache dall'ultima lettura. Per impostazione predefinita, il TTL di una cache è impostato su un giorno.

     Per impostare un TTL personalizzato:

     1. Nella colonna Durata, specifica un valore di durata (ad esempio: 48) e un'unità di tempo (ad esempio: hours).

     2. Fai clic su Save configuration (Salva configurazione).

   • (Facoltativo) Puoi abilitare la cache per l'importazione dei dati in scrittura, oltre che per l'importazione dei dati alla prima lettura. Per impostazione predefinita, le cache sono configurate solo per l'importazione dei dati alla prima lettura.

     Per consentire alla cache di importare i dati in scrittura:

     1. Nella colonna Criteri di importazione, fai clic su Modifica criteri di importazione della cache edit.

        Viene visualizzata la pagina Imposta criteri di importazione.

     2. Seleziona la casella di controllo Importa i dati alla scrittura.

        • Per abilitare l'importazione in scrittura per tutti gli oggetti appena scritti nel bucket, fai clic su Intero bucket.

        • Per attivare l'importazione in scrittura solo per gli oggetti appena scritti che hanno un prefisso specifico nel nome, fai clic su Cartelle selezionate, quindi inserisci il prefisso del nome dell'oggetto. Il prefisso del nome dell'oggetto viene anche chiamato "percorso della cartella".

        Puoi inserire più prefissi dei nomi degli oggetti facendo clic su Aggiungi add.

        Per rimuovere un prefisso, fai clic su Elimina elemento delete.

     3. Fai clic su Fine.

7. Fai clic su Save configuration (Salva configurazione).

8. Nella finestra di dialogo visualizzata, fai clic su Conferma.

   Si apre la scheda Operazioni nella pagina Dettagli bucket, che mostra lo stato del job dell'operazione di creazione della cache.

Crea una cache per un nuovo bucket

Per creare una cache nell'ambito della creazione di un nuovo bucket, segui le istruzioni riportate in Crea un nuovo bucket.

Per visualizzare lo stato della cache di un bucket dalla pagina Elenco bucket:

1. Nella console Cloud de Confiance , vai alla pagina Bucket in Cloud Storage.
   

   Vai a Bucket

2. Fai clic sull'icona Visualizza colonna (view_column), seleziona Cache e poi fai clic su Ok.

Riga di comando

Utilizza il comando gcloud storage buckets anywhere-caches create:

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

Sostituisci:

• BUCKET_NAME con il nome del bucket per cui vuoi memorizzare i dati nella cache. Ad esempio, my-bucket.

• CACHE_ZONE con la zona in cui verrà eseguita la cache. Ad esempio, us-east1-b.

  Per creare più cache contemporaneamente, puoi specificare più zone. Ad esempio, us-east1-b us-east1-c us-east1-d.

• TTL (facoltativo) con la durata (TTL) dei dati nella cache. Il valore può essere compreso tra 1 e 7 giorni (inclusi). Il valore può essere espresso in secondi, minuti, ore e giorni. Ad esempio:

  • 86400s per 86.400 secondi
  • 1440m per 1440 minuti
  • 24h per 24 ore
  • 1d per 1 giorno

  Se non specificato, il valore predefinito è 86400s (1 giorno).

Per configurare la cache in modo che acquisisca i dati nel momento in cui vengono scritti nel bucket, specifica il flag facoltativo --enable-ingest-on-write. Questo flag consente alla cache di importare tutti gli oggetti quando vengono scritti nel bucket.

In caso di esito positivo, il comando restituisce l'ID dell'operazione a lunga esecuzione associata all'operazione di creazione di AnywhereCache. Puoi ottenere i dettagli dell'operazione a lunga esecuzione o annullarla per interrompere l'operazione di creazione di AnywhereCaches prima che venga completata.

Librerie client

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

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());
    }
  }
}

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 documentazione di Terraform per google_storage_anywhere_cache per informazioni dettagliate su come utilizzare Rapid Cache con Terraform.

API REST

Console

1. Nella console Cloud de Confiance , vai alla pagina Bucket in Cloud Storage.
   

   Vai a Bucket

2. Nell'elenco dei bucket, fai clic sul nome del bucket associato alla cache che vuoi visualizzare.

3. Nella pagina Dettagli bucket, fai clic sulla scheda Configurazione.

4. Nella sezione Rapid Cache, fai clic su edit Modifica accanto al campo Cache.

5. Nella pagina Modifica configurazione visualizzata, seleziona una regione per visualizzare tutte le cache all'interno delle zone della regione.

   Nel riquadro Zone cache, puoi visualizzare i dettagli di ogni cache disponibile.

Riga di comando

Utilizza il comando gcloud storage buckets anywhere-caches describe:

gcloud storage buckets anywhere-caches describe CACHE_ID

Sostituisci:

• CACHE_ID con l'identificatore dell'istanza della cache, formulato come BUCKET_NAME/CACHE_ZONE. Ad esempio, my-bucket/us-east1-b.

Utilizza il flag facoltativo raw per generare una risposta dell'API non elaborata anziché una risposta dell'API standardizzata.

In caso di esito positivo, il comando restituisce una risorsa AnywhereCache.

Librerie client

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

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());
    }
  }
}

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 documentazione di Terraform per google_storage_anywhere_cache per informazioni dettagliate su come utilizzare Rapid Cache con Terraform.

API REST

Console

1. Nella console Cloud de Confiance , vai alla pagina Bucket in Cloud Storage.
   

   Vai a Bucket

2. Nell'elenco dei bucket, fai clic sul nome del bucket associato alle cache che vuoi visualizzare.

3. Nella pagina Dettagli bucket, fai clic sulla scheda Configurazione.

4. Nella sezione Rapid Cache, fai clic su edit Modifica accanto al campo Cache.

5. Nella pagina Modifica configurazione visualizzata, seleziona una regione per visualizzare tutte le cache all'interno delle zone della regione.

   Tutte le cache disponibili per le zone all'interno della regione vengono visualizzate nel riquadro Zone cache.

Riga di comando

Utilizza il comando gcloud storage buckets anywhere-caches list:

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

Sostituisci:

• BUCKET_NAME con il nome del bucket associato alle cache che vuoi elencare. Ad esempio, my-bucket.

In caso di esito positivo, il comando restituisce un elenco di risorse AnywhereCache.

Facoltativamente, puoi utilizzare il flag --raw per restituire una risposta dell'API non elaborata anziché una risposta standardizzata. Per saperne di più sul controllo dei comportamenti di elenco, ad esempio l'impaginazione dei risultati, consulta la documentazione di gcloud storage ls.

Librerie client

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

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());
      }
    }
  }
}

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 documentazione di Terraform per google_storage_anywhere_cache per informazioni dettagliate su come utilizzare Rapid Cache con Terraform.

API REST

Console

1. Nella console Cloud de Confiance , vai alla pagina Bucket in Cloud Storage.
   

   Vai a Bucket

2. Nell'elenco dei bucket, fai clic sul nome del bucket associato alla cache che vuoi aggiornare.

3. Nella pagina Dettagli bucket, fai clic sulla scheda Configurazione.

4. Nella sezione Rapid Cache, fai clic su edit Gestisci cache.

5. Nel riquadro Gestisci cache, fai clic su edit Modifica o crea cache.

6. Nella pagina Modifica configurazione visualizzata, aggiorna le proprietà della cache:

   • Per aggiornare il TTL della cache, individua la colonna Durata (TTL), quindi specifica una durata e seleziona un'unità di tempo (ad esempio, minuti).

   • Per configurare il comportamento di importazione in scrittura della cache, incluso se tutti gli oggetti scritti vengono memorizzati nella cache o se vengono memorizzati nella cache solo oggetti selettivi scritti con un prefisso:

     1. Individua la colonna Criteri di importazione, quindi fai clic su edit Modifica i criteri di importazione della cache.

     2. Nel riquadro Imposta criteri di importazione:

     • Per attivare o disattivare l'importazione in scrittura, seleziona o deseleziona la casella di controllo Importa i dati in scrittura, quindi fai clic su Fine.

     • Per aggiornare la cache in modo da importare tutti gli oggetti nel bucket in fase di scrittura, assicurati che la casella di controllo Importa i dati in fase di scrittura sia selezionata, quindi seleziona Intero bucket. Poi fai clic su Fine.

     • Per aggiornare la cache in modo che importi solo gli oggetti che contengono un prefisso specificato nel nome, assicurati che la casella di controllo Importa i dati in scrittura sia selezionata, quindi seleziona Cartelle selezionate.

       • Per specificare un prefisso, inserisci uno o più prefissi nel campo del percorso della cartella, quindi fai clic su Fine.

       • Per rimuovere un prefisso, fai clic su Elimina elemento delete accanto al prefisso.

7. Nella pagina Modifica configurazione, fai clic su Salva.

8. Nella finestra di dialogo visualizzata, fai clic su Conferma.

Riga di comando

Utilizza il comando gcloud storage buckets anywhere-caches update:

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

Sostituisci:

• CACHE_ID con l'identificatore dell'istanza della cache, formulato come BUCKET_NAME/CACHE_ZONE. Ad esempio, my-bucket/us-east1-b.

  Per aggiornare più cache contemporaneamente, puoi specificare più identificatori. Ad esempio, my-bucket/us-east1-b my-bucket/us-east1-c.

• TTL (facoltativo) con la durata (TTL) dei dati nella cache. Il valore può essere compreso tra 1 e 7 giorni (inclusi). Il valore può essere espresso in secondi, minuti, ore e giorni. Ad esempio:

  • 86400s per 86.400 secondi
  • 1440m per 1440 minuti
  • 24h per 24 ore
  • 1d per 1 giorno

Per configurare la cache in modo che acquisisca i dati nel momento in cui vengono scritti nel bucket, specifica il flag --enable-ingest-on-write. Questo flag consente alla cache di importare tutti gli oggetti quando vengono scritti nel bucket. Per impedire alla cache di importare dati in scrittura, specifica il flag --no-enable-ingest-on-write.

In caso di esito positivo, il comando restituisce l'ID dell'operazione non elaborata a lunga esecuzione associata all'operazione di aggiornamento di AnywhereCache. Puoi visualizzare i dettagli dell'operazione a lunga esecuzione.

Librerie client

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

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());
    }
  }
}

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 documentazione di Terraform per google_storage_anywhere_cache per informazioni dettagliate su come utilizzare Rapid Cache con Terraform.

API REST

Console

Per riprendere una cache che è stata messa in pausa o disattivata, completa le seguenti istruzioni:

1. Nella console Cloud de Confiance , vai alla pagina Bucket in Cloud Storage.
   

   Vai a Bucket

2. Nell'elenco dei bucket, fai clic sul nome del bucket associato alla cache che vuoi riprendere.

3. Nella pagina Dettagli bucket, fai clic sulla scheda Configurazione.

4. Nella sezione Rapid Cache, fai clic su edit Gestisci cache.

5. Nel riquadro Gestisci cache, fai clic sull'icona Riprendi cache (play_arrow).

6. Fai clic su Chiudi.

Riga di comando

Utilizza il comando gcloud storage buckets anywhere-caches resume:

gcloud storage buckets anywhere-caches resume CACHE_ID

Sostituisci:

• CACHE_ID con l'identificatore dell'istanza della cache, formulato come BUCKET_NAME/CACHE_ZONE. Ad esempio, my-bucket/us-east1-b.

  Per riprendere più cache contemporaneamente, puoi specificare più identificatori. Ad esempio, my-bucket/us-east1-b my-bucket/us-east1-c.

In caso di esito positivo, il comando restituisce una risorsa AnywhereCache formattata.

Librerie client

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

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());
    }
  }
}

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 documentazione di Terraform per google_storage_anywhere_cache per informazioni dettagliate su come utilizzare Rapid Cache con Terraform.

API REST

Console

1. Nella console Cloud de Confiance , vai alla pagina Bucket in Cloud Storage.
   

   Vai a Bucket

2. Nell'elenco dei bucket, fai clic sul nome del bucket associato alla cache che vuoi disattivare.

3. Nella pagina Dettagli bucket, fai clic sulla scheda Configurazione.

4. Nella sezione Rapid Cache, fai clic su edit Gestisci cache.

5. Nel riquadro Gestisci cache, fai clic sull'icona Disattiva cache (delete).

6. Nella finestra di dialogo visualizzata, fai clic su Conferma.

7. Fai clic su Chiudi.

Riga di comando

Utilizza il comando gcloud storage buckets anywhere-caches disable:

gcloud storage buckets anywhere-caches disable CACHE_ID

Sostituisci:

• CACHE_ID con l'identificatore dell'istanza della cache, formulato come BUCKET_NAME/CACHE_ZONE. Ad esempio, my-bucket/us-east1-b.

  Per disattivare più cache contemporaneamente, puoi specificare più identificatori. Ad esempio, my-bucket/us-east1-b my-bucket/us-east1-c.

In caso di esito positivo, il comando restituisce una risorsa AnywhereCache formattata.

Librerie client

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

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());
    }
  }
}

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 documentazione di Terraform per google_storage_anywhere_cache per informazioni dettagliate su come utilizzare Rapid Cache con Terraform.

API REST