Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Créer et gérer des caches avec Rapid Cache

Vous pouvez créer et gérer des instances de cache avec Rapid Cache pour réduire la latence et optimiser l'accès aux données des objets stockés dans Cloud Storage. Cette solution de mise en cache permet d'améliorer les performances de vos applications en accélérant la récupération des données.

Cette page vous explique comment créer et gérer des instances de cache avec Rapid Cache. Pour savoir comment utiliser et gérer les opérations de longue durée lancées à partir des opérations de cache asynchrones Rapid Cache, consultez Utiliser des opérations de longue durée.

Avant d'utiliser Rapid Cache, consultez les limites et restrictions.

Avant de commencer

Avant de commencer à créer et à gérer des caches, suivez les étapes décrites dans les sections ci-dessous.

Obtenir les rôles requis

Pour obtenir les autorisations nécessaires pour créer et gérer des caches Rapid Cache, demandez à votre administrateur de vous accorder le rôle IAM Administrateur Storage (roles/storage.admin) sur le bucket pour lequel vous souhaitez créer des caches.

Ce rôle prédéfini contient les autorisations requises pour créer et gérer des caches Rapid Cache. Pour connaître les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Vous devez disposer des autorisations suivantes pour créer et gérer des caches Rapid Cache :

storage.anywhereCaches.create (requise pour créer des caches)
storage.anywhereCaches.disable (requise pour désactiver des caches)
storage.anywhereCaches.get (requise pour récupérer des caches)
storage.anywhereCaches.list (requise pour créer une liste de caches)
storage.anywhereCaches.resume (requise pour réactiver des caches)
storage.anywhereCaches.update (requise pour mettre à jour des caches)
storage.managedFolders.create (uniquement requis pour activer le comportement d'ingestion lors de l'écriture pour un cache)
storage.managedFolders.update (obligatoire uniquement pour mettre à jour le comportement d'ingestion à l'écriture d'un cache)

Vous pouvez également obtenir ces autorisations avec des rôles personnalisés.

Pour en savoir plus sur l'attribution de rôles sur des buckets, consultez Définir et gérer des stratégies IAM sur des buckets.

Pour gérer les opérations de longue durée lancées à partir de méthodes Rapid Cache, vous aurez peut-être besoin de rôles et d'autorisations supplémentaires. Pour en savoir plus, consultez la section Rôles requis pour les opérations de longue durée.

Comprendre les paramètres d'ingestion à l'écriture

Lorsque vous créez ou mettez à jour un cache, vous pouvez éventuellement l'activer pour ingérer les données dès qu'elles sont écrites dans le bucket. Cette fonctionnalité est appelée "ingest-on-write" (ingestion à l'écriture). Si vous prévoyez d'activer l'ingestion à l'écriture à l'aide de l'API JSON, nous vous recommandons de commencer par comprendre les comportements des paramètres configurés pour l'ingestion à l'écriture.

Créer un cache

Console

Créer un cache pour un bucket existant

Dans la console Google Cloud , accédez à la page Buckets de Cloud Storage.
Accéder à la page "Buckets"
Dans la liste des buckets, cliquez sur le nom du bucket pour lequel vous souhaitez mettre en cache les données.
Sur la page Informations sur le bucket, cliquez sur l'onglet Configuration.
Dans la section Rapid Cache, cliquez sur Configurer le cache.

La page Configurer le cache s'affiche pour votre bucket.
Dans la section Régions de cache, cliquez sur la région contenant les zones dans lesquelles vous souhaitez créer un cache.
Dans la section Zones de cache, sélectionnez les zones dans lesquelles vous souhaitez créer un cache. Pour chaque cache que vous créez dans une zone, vous pouvez éventuellement procéder comme suit :
- Facultatif : Vous pouvez définir une valeur TTL (Time to Live) personnalisée qui détermine le moment où les données sont supprimées du cache après leur dernière lecture. Par défaut, la valeur TTL d'un cache est définie sur un jour.
  
  Pour définir un TTL personnalisé :
  1. Dans la colonne Durée de vie, spécifiez une valeur de durée (par exemple, 48) et une unité de temps (par exemple, hours).
  2. Cliquez sur Enregistrer la configuration.
- Facultatif : Vous pouvez activer le cache pour ingérer des données lors de l'écriture, en plus de l'ingestion de données lors de la première lecture. Par défaut, les caches ne sont configurés que pour ingérer les données lors de la première lecture.
  
  Pour permettre au cache d'ingérer des données lors de l'écriture :
  1. Dans la colonne Critères d'ingestion, cliquez sur Modifier les critères d'ingestion du cache edit.
    
    La page Définir les critères d'ingestion s'affiche.
  2. Cochez la case Ingérer les données lors de l'écriture.
    - Pour activer l'ingestion lors de l'écriture pour tous les objets nouvellement écrits dans le bucket, cliquez sur Bucket entier.
    - Pour n'activer l'ingestion lors de l'écriture que pour les objets nouvellement écrits dont le nom comporte un préfixe spécifique, cliquez sur Dossiers sélectionnés, puis saisissez le préfixe du nom de l'objet. Le préfixe du nom de l'objet est également appelé "chemin d'accès au dossier".
    Vous pouvez saisir plusieurs préfixes de nom d'objet en cliquant sur Ajouter Ajouter.
    
    Pour supprimer un préfixe, cliquez sur Supprimer l'élément delete.
  3. Cliquez sur OK.
Cliquez sur Enregistrer la configuration.
Dans la boîte de dialogue qui s'affiche, cliquez sur Confirmer.

L'onglet Opérations de la page Informations sur le bucket s'ouvre. Il affiche l'état du job de création du cache.

Créer un cache pour un nouveau bucket

Pour créer un cache au moment de la création d'un bucket, suivez les instructions de la section Créer un bucket.

Pour afficher l'état du cache d'un bucket sur la page Liste des buckets, procédez comme suit :

Dans la console Google Cloud , accédez à la page Buckets de Cloud Storage.

Accéder à la page Buckets
Cliquez sur l'icône Afficher la colonne (), sélectionnez Cache, puis cliquez sur OK.

Ligne de commande

Exécutez la commande gcloud storage buckets anywhere-caches create :

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

Remplacez :

BUCKET_NAME par le nom du bucket pour lequel vous souhaitez mettre en cache les données. Par exemple, my-bucket.
CACHE_ZONE par la zone dans laquelle le cache s'exécutera. Par exemple, us-east1-b.

Pour créer plusieurs caches à la fois, vous pouvez spécifier plusieurs zones. (par exemple, us-east1-b us-east1-c us-east1-d)
TTL (facultatif) avec la valeur TTL (Time To Live) des données dans le cache. Cette valeur peut être comprise entre 1 jour et 7 jours, inclus. La valeur peut être exprimée en secondes, minutes, heures et jours. Exemple :
- 86400s pour 86 400 secondes
- 1440m pour 1 440 minutes
- 24h pour 24 heures
- 1d pour 1 jour
Si aucune valeur n'est spécifiée, la valeur définie par défaut est 86400s (1 jour).

Pour configurer le cache afin d'ingérer les données dès qu'elles sont écrites dans le bucket, spécifiez l'option facultative --enable-ingest-on-write. Cet indicateur permet au cache d'ingérer tous les objets lorsqu'ils sont écrits dans le bucket.

Si la commande aboutit, elle renvoie l'ID de l'opération de longue durée associée à l'opération AnywhereCaches Create (création de caches Anywhere). Vous pouvez obtenir des informations sur l'opération de longue durée ou bien l'annuler, afin d'interrompre l'opération AnywhereCaches Create avant qu'elle n'arrive à son terme.

Bibliothèques clientes

C++

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C++.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour les bibliothèques clientes.

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Java.

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

Consultez la documentation Terraform google_storage_anywhere_cache pour savoir comment utiliser Rapid Cache avec Terraform.

API REST

API JSON

Vous devez installer et initialiser la gcloud CLI afin de générer un jeton d'accès pour l'en-tête Authorization.
Créez un fichier JSON contenant les informations suivantes :
```
{
   "zone": "ZONE",
   "ttl": "TIME_TO_LIVE",
   "ingestOnWrite": INGEST_SETTING
}
```
Remplacez :
- ZONE par la zone dans laquelle le cache s'exécutera. Par exemple, us-east1-b.
- TIME_TO_LIVE par la valeur TTL (Time To Live) des données dans le cache. Les valeurs peuvent être exprimées en secondes, minutes, heures et jours. Exemple :
  - 86400s pour 86 400 secondes
  - 1440m pour 1 440 minutes
  - 24h pour 24 heures
  - 1d pour 1 jour
  Si aucune valeur n'est spécifiée, la valeur définie par défaut est 86400s (1 jour). La valeur maximale est de sept jours.
- INGEST_SETTING avec true ou false pour indiquer si le cache ingère ou non les données lors de l'écriture.
  
  Si la valeur est définie sur true, l'ingestion à l'écriture est activée pour tous les objets écrits dans le bucket. Si la valeur est définie sur false, l'ingestion à l'écriture peut être activée de manière sélective pour les objets écrits sous un préfixe ou désactivée pour l'ensemble du bucket.
  
  Pour en savoir plus sur les paramètres utilisés pour configurer l'activation de l'ingestion à l'écriture, consultez les conditions requises pour activer l'ingestion à l'écriture.
  
  Pour activer l'ingestion à l'écriture au niveau du bucket ou du préfixe, ou pour la désactiver complètement, suivez l'un des ensembles d'instructions ci-dessous.
  
  Activer l'ingestion à l'écriture pour le bucket
  1. Pour activer l'ingestion à l'écriture pour tous les objets écrits dans le bucket, définissez la valeur de INGEST_SETTINGS sur true.
  2. Complétez votre demande de mise en cache en suivant l'étape 3.
  Activer l'ingestion à l'écriture de manière sélective pour les objets sous un préfixe
  1. Définissez la valeur de INGEST_SETTINGS sur false.
  2. Complétez votre demande de mise en cache en suivant l'étape 3.
  3. Créez un dossier géré qui utilise le préfixe comme nom, s'il n'existe pas déjà.
  4. Envoyez une requête PATCH de dossier géré qui inclut une configuration rapidCacheConfig. Définissez les valeurs des champs dans la configuration en suivant les instructions de la section Comprendre comment utiliser l'ingestion à l'écriture.
  Pour obtenir des instructions détaillées sur l'utilisation d'une configuration rapidCacheConfig, consultez Mettre à jour l'ingestion à l'écriture dans un dossier géré.
  
  Créer un cache sans activer l'ingestion à l'écriture
  1. Définissez la valeur de INGEST_SETTINGS sur false.
  2. Complétez votre demande de mise en cache en suivant l'étape 3.
Exécutez cURL pour appeler l'API JSON avec une requête permettant de créer un cache :
```
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"
```
Remplacez :
- JSON_FILE_NAME par le nom du fichier JSON que vous avez créé à l'étape 2.
- BUCKET_NAME par le nom du bucket pour lequel vous souhaitez mettre en cache les données. Par exemple, my-bucket.

Si l'opération réussit, elle renvoie une google.longrunning.Operation. Vous pouvez obtenir des informations sur l'opération de longue durée ou bien l'annuler, afin d'interrompre l'opération AnywhereCaches Create avant qu'elle n'arrive à son terme.

Afficher un cache

Console

Dans la console Google Cloud , accédez à la page Buckets de Cloud Storage.
Accéder à la page Buckets
Dans la liste des buckets, cliquez sur le nom du bucket associé au cache que vous souhaitez afficher.
Sur la page Informations sur le bucket, cliquez sur l'onglet Configuration.
Dans la section Rapid Cache, cliquez sur Modifier à côté du champ Cache.
Sur la page Modifier la configuration qui s'affiche, sélectionnez une région pour afficher tous les caches situés dans les zones de cette région.

Dans le volet Zones de cache, vous pouvez ensuite afficher des informations sur chaque cache disponible.

Ligne de commande

Exécutez la commande gcloud storage buckets anywhere-caches describe :

gcloud storage buckets anywhere-caches describe CACHE_ID

Remplacez :

CACHE_ID par l'identifiant de l'instance de cache, indiqué sous la forme BUCKET_NAME/CACHE_ZONE. Par exemple, my-bucket/us-east1-b.

Utilisez le flag raw facultatif pour générer une réponse d'API brute au lieu d'une réponse d'API standardisée.

Si l'opération réussit, la commande renvoie une ressource AnywhereCache.

Bibliothèques clientes

C++

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C++.

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Java.


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

Consultez la documentation Terraform google_storage_anywhere_cache pour savoir comment utiliser Rapid Cache avec Terraform.

API REST

API JSON

Vous devez installer et initialiser la gcloud CLI afin de générer un jeton d'accès pour l'en-tête Authorization.
Exécutez cURL pour appeler l'API JSON avec une requête permettant d'obtenir un cache :
```
curl -X GET -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/anywhereCaches/RAPID_CACHE_ID"
```
Remplacez :
- BUCKET_NAME par le nom du bucket associé au cache que vous souhaitez récupérer. Par exemple, my-bucket.
- RAPID_CACHE_ID par la zone dans laquelle se trouve le cache. Par exemple, us-east1-b.

Si l'opération réussit, elle renvoie une ressource AnywhereCache.

Répertorier des caches

Console

Dans la console Google Cloud , accédez à la page Buckets de Cloud Storage.
Accéder à la page Buckets
Dans la liste des buckets, cliquez sur le nom du bucket associé aux caches que vous souhaitez afficher.
Sur la page Informations sur le bucket, cliquez sur l'onglet Configuration.
Dans la section Rapid Cache, cliquez sur Modifier à côté du champ Cache.
Sur la page Modifier la configuration qui s'affiche, sélectionnez une région pour afficher tous les caches situés dans les zones de cette région.

Tous les caches disponibles pour les zones de la région s'affichent dans le volet Zones de cache.

Ligne de commande

Exécutez la commande gcloud storage buckets anywhere-caches list :

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

Remplacez :

BUCKET_NAME par le nom du bucket associé aux caches que vous souhaitez répertorier. Par exemple, my-bucket.

Si la commande réussit, elle renvoie une liste de ressources AnywhereCache.

Vous pouvez également utiliser le flag --raw pour renvoyer une réponse d'API brute au lieu d'une réponse standardisée. Pour en savoir plus sur le contrôle du comportement des listes, comme la pagination des résultats, consultez la documentation de gcloud storage ls.

Bibliothèques clientes

C++

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C++.

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Java.


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

Consultez la documentation Terraform google_storage_anywhere_cache pour savoir comment utiliser Rapid Cache avec Terraform.

API REST

API JSON

Vous devez installer et initialiser la gcloud CLI afin de générer un jeton d'accès pour l'en-tête Authorization.
Utilisez cURL pour appeler l'API JSON avec une requête permettant de répertorier les caches :
```
curl -X GET -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/anywhereCaches"
```
Remplacez :
- BUCKET_NAME par le nom du bucket associé aux caches que vous souhaitez récupérer. Par exemple, my-bucket.
Lorsque vous répertoriez plusieurs caches, vous pouvez paginer les résultats.

Si l'opération réussit, elle renvoie une liste de ressources AnywhereCache. Pour en savoir plus sur la structure de cette réponse, consultez la réponse dans la documentation sur la liste des opérations AnywhereCaches.

Mettre à jour un cache

Console

Dans la console Google Cloud , accédez à la page Buckets de Cloud Storage.
Accéder à la page Buckets
Dans la liste des buckets, cliquez sur le nom du bucket associé au cache que vous souhaitez mettre à jour.
Sur la page Informations sur le bucket, cliquez sur l'onglet Configuration.
Dans la section Rapid Cache, cliquez sur Gérer les caches .
Dans le volet Gérer les caches, cliquez sur Modifier ou créer des caches ().
Sur la page Modifier la configuration qui s'affiche, mettez à jour les propriétés du cache :
- Pour modifier la valeur TTL du cache, recherchez la colonne Time to live (Valeur TTL), puis spécifiez une durée et sélectionnez une unité de temps (par exemple, minutes).
- Pour configurer le comportement d'ingestion lors de l'écriture du cache, y compris pour déterminer si tous les objets écrits sont mis en cache ou si seuls certains objets écrits sous un préfixe le sont :
  1. Recherchez la colonne Critères d'ingestion, puis cliquez sur Modifier les critères d'ingestion du cache.
  2. Dans le volet Définir les critères d'ingestion :
  - Pour activer ou désactiver l'ingestion à l'écriture, cochez ou décochez la case Ingérer les données à l'écriture, puis cliquez sur OK.
  - Pour mettre à jour le cache afin d'ingérer tous les objets du bucket lors de l'écriture, assurez-vous que la case Ingérer les données lors de l'écriture est cochée, puis sélectionnez Bucket entier. Cliquez ensuite sur OK.
  - Pour mettre à jour le cache afin d'ingérer uniquement les objets dont le nom contient un préfixe spécifique, assurez-vous que la case Ingérer les données lors de l'écriture est cochée, puis sélectionnez Dossiers sélectionnés.
    - Pour spécifier un préfixe, saisissez-en un ou plusieurs dans le champ du chemin d'accès au dossier, puis cliquez sur OK.
    - Pour supprimer un préfixe, cliquez sur Supprimer l'élément à côté du préfixe.
Sur la page Modifier la configuration, cliquez sur Enregistrer.
Dans la boîte de dialogue qui s'affiche, cliquez sur Confirmer.

Ligne de commande

Exécutez la commande gcloud storage buckets anywhere-caches update :

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

Remplacez :

CACHE_ID par l'identifiant de l'instance de cache, indiqué sous la forme BUCKET_NAME/CACHE_ZONE. Par exemple, my-bucket/us-east1-b.

Pour mettre à jour plusieurs caches à la fois, vous pouvez spécifier plusieurs identifiants. Par exemple, my-bucket/us-east1-b my-bucket/us-east1-c.
TTL (facultatif) avec la valeur TTL (Time To Live) des données dans le cache. Cette valeur peut être comprise entre 1 jour et 7 jours, inclus. La valeur peut être exprimée en secondes, minutes, heures et jours. Exemple :
- 86400s pour 86 400 secondes
- 1440m pour 1 440 minutes
- 24h pour 24 heures
- 1d pour 1 jour

Pour configurer le cache afin qu'il ingère les données dès qu'elles sont écrites dans le bucket, spécifiez l'indicateur --enable-ingest-on-write. Cet indicateur permet au cache d'ingérer tous les objets lorsqu'ils sont écrits dans le bucket. Pour désactiver l'ingestion de données dans le cache lors de l'écriture, spécifiez l'option --no-enable-ingest-on-write.

Si la commande aboutit, elle renvoie l'ID de l'opération de longue durée brute associée à l'opération AnywhereCache Update (mise à jour des caches Anywhere). Vous pouvez obtenir des informations sur l'opération de longue durée.

Bibliothèques clientes

C++

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C++.

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Java.


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

Consultez la documentation Terraform google_storage_anywhere_cache pour savoir comment utiliser Rapid Cache avec Terraform.

API REST

API JSON

Vous devez installer et initialiser la gcloud CLI afin de générer un jeton d'accès pour l'en-tête Authorization.
Créez un fichier JSON incluant les modifications apportées aux propriétés de cache que vous souhaitez mettre à jour.
```
{
   "ttl": "TIME_TO_LIVE",
   "ingestOnWrite": INGEST_SETTING
}
```
Remplacez :
- TIME_TO_LIVE par la valeur TTL des données dans le cache. Cette valeur peut être comprise entre 1 jour et 7 jours, inclus. La valeur peut être exprimée en secondes, minutes, heures et jours. Exemple :
  - 86400s pour 86 400 secondes
  - 1440m pour 1 440 minutes
  - 24h pour 24 heures
  - 1d pour 1 jour
- INGEST_SETTING avec true ou false pour indiquer si le cache ingère ou non les données lors de l'écriture.
  
  Si la valeur est définie sur true, l'ingestion à l'écriture est activée pour tous les objets écrits dans le bucket. Si la valeur est définie sur false, l'ingestion à l'écriture peut être activée de manière sélective pour les objets écrits sous un préfixe ou désactivée entièrement.
  
  Pour en savoir plus sur les paramètres utilisés pour configurer l'activation de l'ingestion à l'écriture au niveau du bucket ou du préfixe, consultez Comprendre comment activer l'ingestion à l'écriture.
  
  Pour activer l'ingestion à l'écriture au niveau du bucket ou du préfixe, ou pour la désactiver complètement, suivez l'un des ensembles d'instructions ci-dessous.
  
  Activer l'ingestion à l'écriture pour le bucket
  1. Pour activer l'ingestion lors de l'écriture pour tous les objets écrits dans le bucket, définissez la valeur de INGEST_SETTINGS sur true.
  2. Complétez votre demande de mise en cache en suivant l'étape 3.
  3. Si l'ingestion à l'écriture était précédemment activée pour un préfixe, un dossier géré avec une configuration rapidCacheConfig existe. Effectuez une requête PATCH de dossier géré qui définit la carte policies dans la configuration rapidCacheConfig sur null.
  Pour obtenir des instructions détaillées sur l'utilisation d'une configuration rapidCacheConfig, consultez Mettre à jour l'ingestion à l'écriture dans un dossier géré.
  
  Activer l'ingestion à l'écriture de manière sélective pour les objets sous un préfixe
  1. Définissez la valeur de INGEST_SETTINGS sur false.
  2. Complétez votre demande de mise en cache en suivant l'étape 3.
  3. Créez un dossier géré qui utilise le préfixe comme nom, s'il n'existe pas déjà.
  4. Envoyez une requête PATCH de dossier géré qui inclut une configuration rapidCacheConfig. Définissez les valeurs des champs dans la configuration en suivant les instructions de la section Paramètres et comportements d'ingestion à l'écriture.
  La carte policies d'une configuration rapidCacheConfig peut contenir un ou plusieurs ID de cache (par exemple, us-east1-a et us-east1-b). Pour activer l'ingestion à l'écriture pour certains caches, définissez le paramètre ingestOnWrite de chaque cache sur enabled. Pour désactiver l'ingestion lors de l'écriture pour certains caches, définissez le paramètre ingestOnWrite de chaque cache sur unspecified. Lisez attentivement les informations sur l'héritage de l'ingestion à l'écriture pour comprendre comment la règle d'ingestion à l'écriture d'un cache peut être affectée lorsque le paramètre ingestOnWrite du cache est défini sur unspecified.
  
  Pour obtenir des instructions détaillées sur l'utilisation d'une configuration rapidCacheConfig, consultez Mettre à jour l'ingestion à l'écriture dans un dossier géré.
  
  Désactiver l'ingestion lors de l'écriture
  1. Définissez la valeur de INGEST_SETTINGS sur false. Ce paramètre désactive l'ingestion lors de l'écriture au niveau du bucket.
  2. Complétez votre demande de mise en cache en suivant l'étape 3.
  3. Pour désactiver l'ingestion à l'écriture au niveau du préfixe, recherchez le dossier géré dans lequel l'ingestion à l'écriture au niveau du préfixe est configurée. Effectuez une requête PATCH de dossier géré qui définit la carte policies dans la configuration rapidCacheConfig sur null. Vous pouvez également supprimer la configuration rapidCacheConfig de la ressource de dossier géré dans une requête PATCH.
  Pour obtenir des instructions détaillées sur l'utilisation d'une configuration rapidCacheConfig, consultez Mettre à jour l'ingestion à l'écriture dans un dossier géré.
L'exemple suivant met à jour la valeur TTL du cache sur 2 jours et active l'ingestion à l'écriture pour tous les objets écrits dans le bucket :
```
{
   "ttl": "172800s",
   "ingestOnWrite": true
}
```
Pour appliquer les nouvelles propriétés, exécutez cURL pour appeler l'API JSON avec une requête permettant de mettre à jour le cache :
```
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"
```
Remplacez :
- JSON_FILE_NAME par le nom du fichier JSON que vous avez créé à l'étape 2.
- BUCKET_NAME par le nom du bucket associé au cache que vous souhaitez mettre à jour. Par exemple, my-bucket.
- RAPID_CACHE_ID par l'identifiant du cache. Par exemple, us-east1-b.

Si l'opération réussit, elle renvoie une google.longrunning.Operation. Vous pouvez obtenir des informations sur l'opération de longue durée.

Réactiver un cache

Console

Pour réactiver un cache qui a été suspendu ou désactivé, procédez comme suit :

Dans la console Google Cloud , accédez à la page Buckets de Cloud Storage.

Accéder à la page Buckets
Dans la liste des buckets, cliquez sur le nom du bucket associé au cache que vous souhaitez réactiver.
Sur la page Informations sur le bucket, cliquez sur l'onglet Configuration.
Dans la section Rapid Cache, cliquez sur Gérer les caches .
Dans le volet Gérer les caches, cliquez sur l'icône Réactiver le cache ().
Cliquez sur Fermer.

Ligne de commande

Exécutez la commande gcloud storage buckets anywhere-caches resume :

gcloud storage buckets anywhere-caches resume CACHE_ID

Remplacez :

CACHE_ID par l'identifiant de l'instance de cache, indiqué sous la forme BUCKET_NAME/CACHE_ZONE. Par exemple, my-bucket/us-east1-b.

Pour réactiver plusieurs caches à la fois, vous pouvez spécifier plusieurs identifiants. Par exemple, my-bucket/us-east1-b my-bucket/us-east1-c.

Si la commande aboutit, elle renvoie une ressource AnywhereCache formatée.

Bibliothèques clientes

C++

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C++.

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Java.


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

Consultez la documentation Terraform google_storage_anywhere_cache pour savoir comment utiliser Rapid Cache avec Terraform.

API REST

API JSON

Vous devez installer et initialiser la gcloud CLI afin de générer un jeton d'accès pour l'en-tête Authorization.
Exécutez cURL pour appeler l'API JSON avec une requête permettant de réactiver un cache :
```
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"
```
Remplacez :
- BUCKET_NAME par le nom du bucket associé au cache que vous souhaitez réactiver. Par exemple, my-bucket.
- RAPID_CACHE_ID par l'identifiant du cache. Par exemple, us-east1-b.

Si l'opération aboutit, elle renvoie une ressource AnywhereCache formatée.

Désactiver un cache

Console

Dans la console Google Cloud , accédez à la page Buckets de Cloud Storage.
Accéder à la page Buckets
Dans la liste des buckets, cliquez sur le nom du bucket associé au cache que vous souhaitez désactiver.
Sur la page Informations sur le bucket, cliquez sur l'onglet Configuration.
Dans la section Rapid Cache, cliquez sur Gérer les caches .
Dans le volet Gérer les caches, cliquez sur l'icône Désactiver le cache ().
Dans la boîte de dialogue qui s'affiche, cliquez sur Confirmer.
Cliquez sur Fermer.

Ligne de commande

Exécutez la commande gcloud storage buckets anywhere-caches disable :

gcloud storage buckets anywhere-caches disable CACHE_ID

Remplacez :

CACHE_ID par l'identifiant de l'instance de cache, indiqué sous la forme BUCKET_NAME/CACHE_ZONE. Par exemple, my-bucket/us-east1-b.

Pour désactiver plusieurs caches à la fois, vous pouvez spécifier plusieurs identifiants. Par exemple, my-bucket/us-east1-b my-bucket/us-east1-c.

Si la commande aboutit, elle renvoie une ressource AnywhereCache formatée.

Bibliothèques clientes

C++

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C++.

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

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage Java.


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

Consultez la documentation Terraform google_storage_anywhere_cache pour savoir comment utiliser Rapid Cache avec Terraform.

API REST

API JSON

Vous devez installer et initialiser la gcloud CLI afin de générer un jeton d'accès pour l'en-tête Authorization.
Exécutez cURL pour appeler l'API JSON avec une requête permettant de désactiver un cache :
```
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"
```
Remplacez :
- BUCKET_NAME par le nom du bucket associé au cache que vous souhaitez désactiver. Par exemple, my-bucket.
- RAPID_CACHE_ID par l'identifiant du cache. Par exemple, us-east1-b.

Si la commande aboutit, elle renvoie une ressource AnywhereCache formatée.

Surveiller les performances des caches

La section Cloud Storage de la console Google Cloud fournit des graphiques de surveillance qui vous permettent de suivre les performances de vos caches à l'aide de métriques. Vous pouvez également afficher ces graphiques de surveillance dans Cloud Monitoring.

Graphiques disponibles

Graphique	Niveau de la hiérarchie des ressources	Description
Taux d'éviction des octets	Bucket	Taux d'octets évincés du cache, échantillonné toutes les heures. Ces données sont actualisées plusieurs fois par heure pour laisser le temps nécessaire au post-traitement des données.
Taux d'éviction des octets	Projet	Taux d'octets évincés de tous les caches d'un bucket, échantillonné toutes les heures. Ces données sont actualisées plusieurs fois par heure pour laisser le temps nécessaire au post-traitement des données.
Octets dans le cache	Bucket	Nombre d'octets dans le cache, échantillonné toutes les heures. Ces données sont actualisées plusieurs fois par heure pour laisser le temps nécessaire au post-traitement des données.
Octets dans le cache	Projet	Nombre d'octets dans tous les caches d'un bucket, échantillonné toutes les heures. Ces données sont actualisées plusieurs fois par heure pour laisser le temps nécessaire au post-traitement des données.
Avantage du débit de cache	Projet	Débit du quota de bande passante relatif au transfert de données au niveau régional, birégional et multirégional, utilisation du quota et débit supplémentaire fourni par le cache. Le débit supplémentaire fourni par le cache n'est pas comptabilisé dans le quota. L'utilisation du cache permet donc aux projets de dépasser le débit autorisé par le quota.
Taux de réussite des opérations de cache	Bucket	Pourcentage d'opérations de cache qui délivrent toutes les données demandées à partir du cache par rapport au nombre total d'opérations éligibles à la mise en cache, échantillonné toutes les 60 secondes. Si une lecture est entièrement renvoyée à partir du cache, l'opération est considérée comme un succès. Si la lecture n'est pas renvoyée par le cache ou si elle n'est renvoyée que partiellement, l'opération est considérée comme un échec.
Taux de réussite des opérations de cache	Projet	Pourcentage d'opérations de cache qui délivrent les données demandées à partir de tous les caches d'un bucket par rapport au nombre total d'opérations éligibles à la mise en cache, échantillonné toutes les 60 secondes. Si une lecture est entièrement renvoyée à partir du cache, l'opération est considérée comme un succès. Si la lecture n'est pas renvoyée par le cache ou si elle n'est renvoyée que partiellement, l'opération est considérée comme un échec.
Octets de taux de succès	Bucket	Pourcentage d'octets diffusés à partir du cache par rapport au nombre total d'octets éligibles à la mise en cache, échantillonné toutes les 60 secondes.
Octets de taux de succès	Projet	Pourcentage d'octets diffusés à partir de tous les caches d'un bucket par rapport au nombre total d'octets éligibles à la mise en cache, échantillonné toutes les 60 secondes.
Taux d'ingestion d'octets bruts	Bucket	Taux d'octets bruts ingérés dans chaque cache, échantillonné toutes les 60 secondes. Tous les octets ingérés, y compris ceux qui ne sont pas facturables, sont utilisés pour calculer la valeur de cette métrique. Cette métrique est signalée en temps réel.
Taux d'ingestion d'octets bruts	Projet	Taux d'octets bruts ingérés dans tous les caches d'un bucket, échantillonné toutes les 60 secondes. Tous les octets ingérés, y compris ceux qui ne sont pas facturables, sont utilisés pour calculer la valeur de cette métrique. Cette métrique est signalée en temps réel.
Débit - Succès de cache	Bucket	Débit fourni par le cache, échantillonné toutes les 60 secondes.
Débit - Succès de cache	Projet	Débit fourni par tous les caches d'un bucket, échantillonné toutes les 60 secondes.
Débit - Défaut de cache (miss)	Bucket	Débit qui n'est pas fourni par le cache, échantillonné toutes les 60 secondes.
Débit - Défaut de cache (miss)	Projet	Débit qui n'est fourni par aucun des caches d'un bucket, échantillonné toutes les 60 secondes.

Accéder aux graphiques

Les graphiques de surveillance capturent les données de buckets individuels ou de tous les buckets d'un projet. Le niveau de hiérarchie des ressources qu'un graphique capture détermine l'emplacement où vous pouvez accéder à ce graphique.

Accéder aux graphiques au niveau du bucket

Dans la console Google Cloud , accédez à la page Buckets de Cloud Storage.

Accéder à la page Buckets
Dans la liste des buckets, cliquez sur le nom du bucket pour lequel vous souhaitez afficher les graphiques de surveillance.
Sur la page Informations sur le bucket, cliquez sur l'onglet Observabilité.
Dans le menu de navigation, sélectionnez Rapid Cache.

Les graphiques de surveillance s'affichent.

Accéder aux graphiques au niveau du projet

Dans la console Google Cloud , accédez à la page Buckets de Cloud Storage.

Accéder à la page "Buckets"
Dans le volet de navigation Cloud Storage, cliquez sur Surveillance.
Dans la barre de menu, cliquez sur Rapid Cache.

Les graphiques de surveillance s'affichent.

Utiliser des opérations de longue durée

Lorsqu'elles sont exécutées avec succès, les opérations AnywhereCaches Create (création de caches Anywhere) et Update (mise à jour de caches Anywhere) lancent une opération de longue durée. Vous pouvez obtenir et recenser les opérations de longue durée afin d'afficher les détails et l'état de l'opération AnywhereCaches sous-jacente, ou annuler une opération de longue durée pour annuler l'opération AnywhereCaches sous-jacente en cours.

Pour savoir comment utiliser les opérations de longue durée pour Rapid Cache, consultez Utiliser des opérations de longue durée.

L'exemple suivant montre une opération de longue durée lancée par une opération AnywhereCaches Create (création de caches Anywhere) :

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

Tentatives

Les API AnywhereCaches asynchrones sont idempotentes par défaut. Par conséquent, vous pouvez relancer en toute sécurité des appels d'API AnywhereCaches asynchrones, sans risquer de modifier involontairement des ressources.

Par exemple, imaginons que vous lanciez une opération AnywhereCaches Create pour créer un cache dans us-central1-a et que celle-ci réussit. Si vous relancez une opération AnywhereCaches Create dans la même zone et qu'elle réussit, la requête renvoie la même opération de longue durée que la requête précédente. Notez que ce comportement ne se produit que si vous incluez un request_id dans votre requête de création de cache. Si aucun request_id n'est inclus, une erreur ANYWHERE_CACHE_ALREADY_EXISTS s'affiche lorsque vous essayez de créer un cache qui existe déjà. Pour savoir comment inclure un request_id, consultez Identification de la requête.

Étape suivante

Obtenez des recommandations sur les buckets et les zones dans lesquels créer un cache.

Créer et gérer des caches avec Rapid Cache Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Avant de commencer

Obtenir les rôles requis

Autorisations requises

Comprendre les paramètres d'ingestion à l'écriture

Créer un cache

Console

Ligne de commande

Bibliothèques clientes

C++

Java

Rust

Terraform

API REST

API JSON

Activer l'ingestion à l'écriture pour le bucket

Activer l'ingestion à l'écriture de manière sélective pour les objets sous un préfixe

Créer un cache sans activer l'ingestion à l'écriture

Afficher un cache

Console

Ligne de commande

Bibliothèques clientes

C++

Java

Rust

Terraform

API REST

API JSON

Répertorier des caches

Console

Ligne de commande

Bibliothèques clientes

C++

Java

Rust

Terraform

API REST

API JSON

Mettre à jour un cache

Console

Ligne de commande

Bibliothèques clientes

C++

Java

Rust

Terraform

API REST

API JSON

Activer l'ingestion à l'écriture pour le bucket

Activer l'ingestion à l'écriture de manière sélective pour les objets sous un préfixe

Désactiver l'ingestion lors de l'écriture

Réactiver un cache

Console

Ligne de commande

Bibliothèques clientes

C++

Java

Rust

Terraform

API REST

API JSON

Désactiver un cache

Console

Ligne de commande

Bibliothèques clientes

C++

Java

Rust

Terraform

API REST

API JSON

Surveiller les performances des caches

Graphiques disponibles

Accéder aux graphiques

Accéder aux graphiques au niveau du bucket

Accéder aux graphiques au niveau du projet

Utiliser des opérations de longue durée

Tentatives

Étape suivante

Créer et gérer des caches avec Rapid Cache