Caches mit Rapid Cache erstellen und verwalten

Console

Cache für einen vorhandenen Bucket erstellen

1. Wechseln Sie in der Cloud de Confiance Console unter „Cloud Storage“ zur Seite Buckets.
   

   Buckets aufrufen

2. Klicken Sie in der Liste der Buckets auf den Namen des Buckets, für den Sie Daten im Cache speichern möchten.

3. Klicken Sie auf der Seite Bucket-Details auf den Tab Konfiguration.

4. Klicken Sie im Abschnitt Rapid Cache auf Cache konfigurieren.

   Die Seite Cache konfigurieren wird für Ihren Bucket angezeigt.

5. Klicken Sie im Abschnitt Cache-Regionen auf die Region, die die Zonen enthält, in denen Sie einen Cache erstellen möchten.

6. Wählen Sie im Abschnitt Cache-Zonen die Zonen aus, in denen Sie einen Cache erstellen möchten. Führen Sie für jeden Cache, den Sie in einer Zone erstellen, optional die folgenden Schritte aus:

   • Optional: Sie können eine benutzerdefinierte Gültigkeitsdauer (TTL) festlegen, die bestimmt, wann Daten nach dem letzten Lesevorgang aus dem Cache entfernt werden. Standardmäßig ist die TTL eines Cache auf einen Tag festgelegt.

     So legen Sie eine benutzerdefinierte TTL fest:

     1. Geben Sie in der Spalte Gültigkeitsdauer einen Wert für die Dauer (z. B. 48) und eine Zeiteinheit (z. B. hours) an.

     2. Klicken Sie auf Save configuration (Konfiguration speichern).

   • Optional: Sie können den Cache so aktivieren, dass Daten beim Schreiben zusätzlich zum ersten Lesen aufgenommen werden. Standardmäßig sind Caches so konfiguriert, dass Daten nur beim ersten Lesen aufgenommen werden.

     So aktivieren Sie den Cache, um Daten beim Schreiben aufzunehmen:

     1. Klicken Sie in der Spalte Aufnahmekriterien auf Kriterien für die Cache-Aufnahme bearbeiten Bearbeiten.

        Die Seite Kriterien für Datenaufnahme festlegen wird angezeigt.

     2. Klicken Sie das Kästchen Daten beim Schreiben aufnehmen an.

        • Klicken Sie auf Gesamter Bucket, um die Aufnahme beim Schreiben für alle Objekte zu aktivieren, die neu in den Bucket geschrieben werden.

        • Wenn Sie die Aufnahme beim Schreiben nur für neu geschriebene Objekte aktivieren möchten, die ein bestimmtes Präfix im Namen haben, klicken Sie auf Ausgewählte Ordner und geben Sie das Objektnamenspräfix ein. Das Präfix des Objektnamens wird auch als „Ordnerpfad“ bezeichnet.

        Sie können mehrere Objektnamenpräfixe eingeben, indem Sie auf Hinzufügen add klicken.

        Wenn Sie ein Präfix entfernen möchten, klicken Sie auf Element löschen delete.

     3. Klicken Sie auf Fertig.

7. Klicken Sie auf Save configuration (Konfiguration speichern).

8. Klicken Sie im angezeigten Dialogfeld auf Bestätigen.

   Der Tab Vorgänge auf der Seite Bucket-Details wird geöffnet. Dort sehen Sie den Jobstatus des Vorgangs zum Erstellen des Cache.

Cache für einen neuen Bucket erstellen

Wenn Sie einen Cache im Rahmen der Erstellung eines neuen Buckets erstellen möchten, folgen Sie der Anleitung unter Neuen Bucket erstellen.

So rufen Sie den Status des Caches eines Buckets auf der Seite Bucket-Liste auf:

1. Wechseln Sie in der Cloud de Confiance Console unter „Cloud Storage“ zur Seite Buckets.
   

   Buckets aufrufen

2. Klicken Sie auf das Symbol Spalte ansehen (view_column), wählen Sie Cache aus und klicken Sie dann auf OK.

Befehlszeile

Führen Sie den Befehl gcloud storage buckets anywhere-caches create aus:

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

Ersetzen Sie:

• BUCKET_NAME durch den Namen des Buckets, für den Sie Daten im Cache speichern möchten. Beispiel: my-bucket.

• CACHE_ZONE durch die Zone, in der der Cache ausgeführt wird. Beispiel: us-east1-b.

  Wenn Sie mehrere Caches gleichzeitig erstellen möchten, können Sie mehrere Zonen angeben. Beispiel: us-east1-b us-east1-c us-east1-d

• TTL (optional) mit der Gültigkeitsdauer (TTL) der Daten im Cache. Der Wert kann zwischen 1 Tag und 7 Tagen liegen. Der Wert kann in Sekunden, Minuten, Stunden und Tagen angegeben werden. Beispiel:

  • 86400s für 86.400 Sekunden
  • 1440m für 1.440 Minuten
  • 24h für 24 Stunden
  • 1d für 1 Tag

  Wenn nicht angegeben, wird standardmäßig 86400s (1 Tag) verwendet.

Wenn Sie den Cache so konfigurieren möchten, dass Daten aufgenommen werden, sobald sie in den Bucket geschrieben werden, geben Sie das optionale Flag --enable-ingest-on-write an. Mit diesem Flag kann der Cache alle Objekte aufnehmen, wenn sie in den Bucket geschrieben werden.

Bei Erfolg gibt der Befehl die ID des Vorgangs mit langer Ausführungszeit zurück, der dem AnywhereCache-Erstellungsvorgang zugeordnet ist. Sie können Details zum Vorgang mit langer Ausführungszeit abrufen oder den Vorgang mit langer Ausführungszeit abbrechen, um den AnywhereCaches-Erstellungsvorgang zu beenden, bevor er abgeschlossen ist.

Clientbibliotheken

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

Weitere Informationen zur Verwendung von Rapid Cache mit Terraform finden Sie in der google_storage_anywhere_cache-Terraform-Dokumentation.

REST APIs

Console

1. Wechseln Sie in der Cloud de Confiance Console unter „Cloud Storage“ zur Seite Buckets.
   

   Buckets aufrufen

2. Klicken Sie in der Liste der Buckets auf den Namen des Buckets, der mit dem Cache verknüpft ist, den Sie aufrufen möchten.

3. Klicken Sie auf der Seite Bucket-Details auf den Tab Konfiguration.

4. Klicken Sie im Bereich Rapid Cache neben dem Feld Cache auf edit Bearbeiten.

5. Wählen Sie auf der Seite Konfiguration bearbeiten eine Region aus, um alle Caches in den Zonen der Region aufzurufen.

   Im Bereich Cache-Zonen können Sie dann Details zu jedem verfügbaren Cache aufrufen.

Befehlszeile

Führen Sie den Befehl gcloud storage buckets anywhere-caches describe aus:

gcloud storage buckets anywhere-caches describe CACHE_ID

Ersetzen Sie:

• CACHE_ID durch die Kennung der Cache-Instanz, formuliert als BUCKET_NAME/CACHE_ZONE. Beispiel: my-bucket/us-east1-b.

Verwenden Sie das optionale Flag raw, um eine API-Rohantwort anstelle einer standardisierten API-Antwort auszugeben.

Wenn der Vorgang erfolgreich war, gibt der Befehl eine AnywhereCache-Ressource zurück.

Clientbibliotheken

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

Weitere Informationen zur Verwendung von Rapid Cache mit Terraform finden Sie in der google_storage_anywhere_cache-Terraform-Dokumentation.

REST APIs

Console

1. Wechseln Sie in der Cloud de Confiance Console unter „Cloud Storage“ zur Seite Buckets.
   

   Buckets aufrufen

2. Klicken Sie in der Liste der Buckets auf den Namen des Buckets, der mit den Caches verknüpft ist, die Sie aufrufen möchten.

3. Klicken Sie auf der Seite Bucket-Details auf den Tab Konfiguration.

4. Klicken Sie im Bereich Rapid Cache neben dem Feld Cache auf edit Bearbeiten.

5. Wählen Sie auf der Seite Konfiguration bearbeiten eine Region aus, um alle Caches in den Zonen dieser Region aufzurufen.

   Alle verfügbaren Caches für Zonen innerhalb der Region werden im Bereich Cache-Zonen angezeigt.

Befehlszeile

Führen Sie den Befehl gcloud storage buckets anywhere-caches list aus:

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

Ersetzen Sie:

• BUCKET_NAME durch den Namen des Buckets, der mit den Caches verknüpft ist, die Sie auflisten möchten. Beispiel: my-bucket.

Wenn der Vorgang erfolgreich ist, gibt der Befehl eine Liste von AnywhereCache-Ressourcen zurück.

Sie können optional das Flag --raw verwenden, um eine API-Rohantwort anstelle einer standardisierten Antwort zurückzugeben. Weitere Informationen zum Steuern des Auflistungsverhaltens, z. B. zum Paginieren von Ergebnissen, finden Sie in der Dokumentation zu gcloud storage ls.

Clientbibliotheken

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

Weitere Informationen zur Verwendung von Rapid Cache mit Terraform finden Sie in der google_storage_anywhere_cache-Terraform-Dokumentation.

REST APIs

Console

1. Wechseln Sie in der Cloud de Confiance Console unter „Cloud Storage“ zur Seite Buckets.
   

   Buckets aufrufen

2. Klicken Sie in der Liste der Buckets auf den Namen des Buckets, der mit dem Cache verknüpft ist, den Sie aktualisieren möchten.

3. Klicken Sie auf der Seite Bucket-Details auf den Tab Konfiguration.

4. Klicken Sie im Abschnitt Rapid Cache auf edit Caches verwalten.

5. Klicken Sie im Bereich Caches verwalten auf edit Caches bearbeiten oder erstellen.

6. Aktualisieren Sie auf der Seite Konfiguration bearbeiten die Attribute des Cache:

   • Wenn Sie die TTL des Cache aktualisieren möchten, suchen Sie die Spalte Gültigkeitsdauer, geben Sie eine Zeitdauer an und wählen Sie eine Zeiteinheit aus (z. B. Minuten).

   • So konfigurieren Sie das Verhalten des Caches beim Schreiben, einschließlich der Frage, ob alle geschriebenen Objekte oder nur ausgewählte Objekte, die unter einem Präfix geschrieben wurden, im Cache gespeichert werden:

     1. Suchen Sie die Spalte Aufnahmekriterien und klicken Sie dann auf edit Cache-Aufnahmekriterien bearbeiten.

     2. Im Bereich Kriterien für Datenaufnahme festlegen:

     • Wenn Sie die Aufnahme beim Schreiben aktivieren oder deaktivieren möchten, aktivieren oder deaktivieren Sie das Kästchen Daten beim Schreiben aufnehmen und klicken Sie dann auf Fertig.

     • Wenn Sie den Cache so aktualisieren möchten, dass alle Objekte im Bucket beim Schreiben aufgenommen werden, muss das Kästchen Daten beim Schreiben aufnehmen angeklickt sein. Wählen Sie dann Gesamter Bucket aus. Klicken Sie dann auf Fertig.

     • Wenn Sie den Cache so aktualisieren möchten, dass nur Objekte aufgenommen werden, die ein bestimmtes Präfix im Namen enthalten, muss das Kästchen Daten beim Schreiben aufnehmen aktiviert sein. Wählen Sie dann Ausgewählte Ordner aus.

       • Wenn Sie ein Präfix angeben möchten, geben Sie ein oder mehrere Präfixe in das Feld für den Ordnerpfad ein und klicken Sie dann auf Fertig.

       • Wenn Sie ein Präfix entfernen möchten, klicken Sie neben dem Präfix auf Element löschen delete.

7. Klicken Sie auf der Seite Konfiguration bearbeiten auf Speichern.

8. Klicken Sie im angezeigten Dialogfeld auf Bestätigen.

Befehlszeile

Führen Sie den Befehl gcloud storage buckets anywhere-caches update aus:

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

Ersetzen Sie:

• CACHE_ID durch die Kennung der Cache-Instanz, formuliert als BUCKET_NAME/CACHE_ZONE. Beispiel: my-bucket/us-east1-b.

  Wenn Sie mehrere Caches gleichzeitig aktualisieren möchten, können Sie mehrere Kennungen angeben. Beispiel: my-bucket/us-east1-b my-bucket/us-east1-c

• TTL (optional) mit der Gültigkeitsdauer (TTL) der Daten im Cache. Der Wert kann zwischen 1 Tag und 7 Tagen liegen. Der Wert kann in Sekunden, Minuten, Stunden und Tagen angegeben werden. Beispiel:

  • 86400s für 86.400 Sekunden
  • 1440m für 1.440 Minuten
  • 24h für 24 Stunden
  • 1d für 1 Tag

Wenn Sie den Cache so konfigurieren möchten, dass Daten aufgenommen werden, sobald sie in den Bucket geschrieben werden, geben Sie das Flag --enable-ingest-on-write an. Mit diesem Flag kann der Cache alle Objekte aufnehmen, wenn sie in den Bucket geschrieben werden. Wenn Sie verhindern möchten, dass der Cache beim Schreiben Daten aufnimmt, geben Sie das Flag --no-enable-ingest-on-write an.

Bei Erfolg gibt der Befehl die ID des Rohvorgangs mit langer Ausführungszeit zurück, der dem AnywhereCache-Aktualisierungsvorgang zugeordnet ist. Sie können Details zum Vorgang mit langer Ausführungszeit abrufen.

Clientbibliotheken

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

Weitere Informationen zur Verwendung von Rapid Cache mit Terraform finden Sie in der google_storage_anywhere_cache-Terraform-Dokumentation.

REST APIs

Console

So setzen Sie einen Cache fort, der pausiert oder deaktiviert wurde:

1. Wechseln Sie in der Cloud de Confiance Console unter „Cloud Storage“ zur Seite Buckets.
   

   Buckets aufrufen

2. Klicken Sie in der Liste der Buckets auf den Namen des Buckets, der mit dem Cache verknüpft ist, den Sie fortsetzen möchten.

3. Klicken Sie auf der Seite Bucket-Details auf den Tab Konfiguration.

4. Klicken Sie im Bereich Rapid Cache auf edit Caches verwalten.

5. Klicken Sie im Bereich Caches verwalten auf das Symbol Cache fortsetzen (play_arrow).

6. Klicken Sie auf Schließen.

Befehlszeile

Führen Sie den Befehl gcloud storage buckets anywhere-caches resume aus:

gcloud storage buckets anywhere-caches resume CACHE_ID

Ersetzen Sie:

• CACHE_ID durch die Kennung der Cache-Instanz, formuliert als BUCKET_NAME/CACHE_ZONE. Beispiel: my-bucket/us-east1-b.

  Wenn Sie mehrere Caches gleichzeitig fortsetzen möchten, können Sie mehrere Kennungen angeben. Beispiel: my-bucket/us-east1-b my-bucket/us-east1-c

Wenn der Vorgang erfolgreich ist, gibt der Befehl eine formatierte AnywhereCache-Ressource zurück.

Clientbibliotheken

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

Weitere Informationen zur Verwendung von Rapid Cache mit Terraform finden Sie in der google_storage_anywhere_cache-Terraform-Dokumentation.

REST APIs

Console

1. Wechseln Sie in der Cloud de Confiance Console unter „Cloud Storage“ zur Seite Buckets.
   

   Buckets aufrufen

2. Klicken Sie in der Liste der Buckets auf den Namen des Buckets, der mit dem Cache verknüpft ist, den Sie deaktivieren möchten.

3. Klicken Sie auf der Seite Bucket-Details auf den Tab Konfiguration.

4. Klicken Sie im Abschnitt Rapid Cache auf edit Caches verwalten.

5. Klicken Sie im Bereich Caches verwalten auf das Symbol Cache deaktivieren (delete).

6. Klicken Sie im angezeigten Dialogfeld auf Bestätigen.

7. Klicken Sie auf Schließen.

Befehlszeile

Führen Sie den Befehl gcloud storage buckets anywhere-caches disable aus:

gcloud storage buckets anywhere-caches disable CACHE_ID

Ersetzen Sie:

• CACHE_ID durch die Kennung der Cache-Instanz, formuliert als BUCKET_NAME/CACHE_ZONE. Beispiel: my-bucket/us-east1-b.

  Wenn Sie mehrere Caches gleichzeitig deaktivieren möchten, können Sie mehrere Kennungen angeben. Beispiel: my-bucket/us-east1-b my-bucket/us-east1-c

Wenn der Vorgang erfolgreich ist, gibt der Befehl eine formatierte AnywhereCache-Ressource zurück.

Clientbibliotheken

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

Weitere Informationen zur Verwendung von Rapid Cache mit Terraform finden Sie in der google_storage_anywhere_cache-Terraform-Dokumentation.

REST APIs