Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Crea e gestisci i job di operazioni batch

Questa pagina descrive come creare, visualizzare, elencare, annullare ed eliminare i job di operazioni batch di archiviazione. Descrive inoltre come utilizzare Cloud Audit Logs con i job di operazioni batch di archiviazione.

Prima di iniziare

Per creare e gestire i job di operazioni batch di archiviazione, completa i passaggi nelle sezioni seguenti.

Configura Storage Intelligence

Per creare e gestire i job di operazioni batch di archiviazione, configura Storage Intelligence nel bucket in cui vuoi eseguire il job.

Abilita l'API per le operazioni batch di archiviazione

Abilita l'API per le operazioni batch di archiviazione.

gcloud services enable storagebatchoperations.googleapis.com

Crea un manifest

Se vuoi utilizzare un manifest per la selezione degli oggetti, crea un file manifest. L'utilizzo di un manifest è uno dei modi in cui puoi selezionare gli oggetti da elaborare in un job di operazioni batch di archiviazione.

Crea un job di operazioni batch di archiviazione

Questa sezione descrive come creare un job di operazioni batch di archiviazione.

Per ottenere le autorizzazioni necessarie per creare un job di operazioni batch di archiviazione, chiedi all'amministratore di concederti il ruolo IAM Storage Admin (roles/storage.admin) sul progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Console

Nella console Google Cloud , vai alla pagina Bucket in Cloud Storage.

Vai a Bucket
Nell'elenco dei bucket, fai clic sul nome del bucket che contiene gli oggetti su cui vuoi eseguire operazioni batch.

Si apre la pagina Dettagli bucket con la scheda Oggetti selezionata.
Fai clic su Crea operazioni batch.
Nel riquadro Seleziona operazione, scegli il tipo di operazione:
- Gestisci blocchi sugli oggetti: seleziona Blocco temporaneo o Blocco basato su eventi. Per saperne di più, consulta Blocchi oggetto.
- Aggiorna i metadati degli oggetti: per aggiungere metadati degli oggetti, segui questi passaggi:
  - Per aggiungere metadati personalizzati, completa i seguenti passaggi:
    1. Nel campo Chiave, inserisci un nome per la chiave.
    2. Nel campo Valore, inserisci un valore per la chiave.
    3. (Facoltativo) Fai clic su + Aggiungi elemento per aggiungere altre coppie chiave-valore.
  - Per aggiornare i metadati a chiave fissa, completa i seguenti passaggi:
    1. Per espandere la sezione Aggiorna metadati a chiave fissa, fai clic sulla freccia di espansione .
    2. Nell'elenco Seleziona uno o più metadati da aggiornare, seleziona gli elementi dei metadati da modificare.
- Aggiorna/Ruota chiave di crittografia: per utilizzare o aggiornare la chiave di crittografia per gli oggetti, segui questi passaggi:
  1. Nell'elenco Seleziona una chiave Cloud KMS, seleziona una chiave di crittografia gestita dal cliente (CMEK).
  2. (Facoltativo) Seleziona Cambia progetto per scegliere una chiave da un altro progetto o seleziona Inserisci chiave manualmente per inserire i dettagli.
- Elimina oggetti: per eliminare gli oggetti, segui questi passaggi:
  1. Verifica se il controllo delle versioni degli oggetti è attivato.
  2. Se il controllo delle versioni degli oggetti è attivato, scegli una delle seguenti opzioni di eliminazione:
    - Seleziona Elimina tutte le versioni degli oggetti per rimuovere sia le versioni attive che quelle non correnti.
    - Seleziona Elimina definitivamente le versioni live per rimuovere solo la versione live.
    Se il controllo delle versioni degli oggetti non è abilitato, tutti gli oggetti selezionati per l'eliminazione vengono eliminati definitivamente.
  Avviso: l'eliminazione accidentale di oggetti comporta il rischio di perdita di dati. Abilita l'eliminazione temporanea per recuperare le eliminazioni accidentali di oggetti.
Fai clic su Avanti.
Nel riquadro Assegna un nome all'operazione e specifica gli oggetti, segui questi passaggi:
1. Nel campo Nome, inserisci un nome.
2. (Facoltativo) Nel campo Descrizione, inserisci una descrizione.
3. Nella sezione Specifica oggetti, definisci un criterio per elaborare gli oggetti dal bucket. Scegli una delle seguenti opzioni:
  - Seleziona tutti gli oggetti: include tutti gli oggetti nel bucket.
  - Seleziona gli oggetti utilizzando i filtri dei prefissi: per definire l'elenco di oggetti utilizzando i filtri dei prefissi, procedi nel seguente modo:
    1. Nel campo Inserisci i prefissi degli oggetti da includere, inserisci un prefisso.
    2. (Facoltativo) Fai clic su + Aggiungi prefisso per specificare altri prefissi.
  - Carica elenchi di oggetti utilizzando file manifest CSV: per utilizzare un file manifest per selezionare gli oggetti, procedi nel seguente modo:
    1. Carica il file CSV manifest in un bucket. Questo file deve contenere le intestazioni per Nome bucket, Chiave oggetto e Numero di generazione.
    2. Nell'elenco Seleziona la modalità del file manifest, scegli una delle seguenti opzioni:
      - Se selezioni Seleziona un file manifest da Cloud Storage, fai clic su Sfoglia nel campo Seleziona un file manifest da Cloud Storage. Nella finestra di dialogo Seleziona oggetto che viene visualizzata, vai al file CSV manifest e fai clic su Seleziona.
      - Se selezioni Seleziona più file manifest utilizzando un carattere jolly, inserisci il percorso del file nel campo Inserisci la posizione del file manifest utilizzando un carattere jolly. Ad esempio: bucket-name/folder/manifest_*.
Fai clic su Crea.

Riga di comando

Per definire l'elenco di oggetti per il job di operazione batch, puoi scegliere una delle seguenti configurazioni di origine:

Progetto come origine: ha come target gli oggetti di un progetto utilizzando una configurazione del set di dati Storage Insights. Invece di specificare singoli bucket o prefissi, puoi specificare parametri di filtro avanzati, come --insights-dataset-config, --target-project, --bucket-filters e --object-filters. Per maggiori dettagli, vedi Creare un job utilizzando i filtri avanzati.
Bucket come origine: ha come target gli oggetti all'interno di bucket specifici. Devi specificare uno dei seguenti flag:
- --bucket o --bucket-list per definire i bucket di destinazione.
- Un file CSV manifest (--manifest-location) o prefissi degli oggetti (--included-object-prefixes) per definire gli oggetti di destinazione.

Nella console Google Cloud , attiva Cloud Shell.

Attiva Cloud Shell

Nella parte inferiore della console Google Cloud viene avviata una sessione di Cloud Shell e viene visualizzato un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installata e con valori già impostati per il progetto corrente. L'inizializzazione della sessione può richiedere alcuni secondi.
Utilizza Google Cloud CLI versione 516.0.0 o successive.
Per impostare il progetto predefinito, esegui il comando gcloud config set project:
```
gcloud config set project PROJECT_ID
```
Dove PROJECT_ID è l'ID del tuo progetto.
(Facoltativo) Esegui un job di simulazione. Prima di eseguire qualsiasi job, ti consigliamo di eseguirlo in modalità dry run per verificare i criteri di selezione degli oggetti e controllare la presenza di errori. Il dry run non modifica alcun oggetto.

Nell'ambiente di sviluppo, esegui il comando gcloud storage batch-operations jobs create con il flag --dry-run:
```
gcloud storage batch-operations jobs create DRY_RUN_JOB_NAME \
{--bucket=BUCKET | --bucket-list=BUCKET_LIST} OBJECT_SELECTION_FLAG JOB_TYPE_FLAG \
--dry-run
```
Dove:
- DRY_RUN_JOB_NAME è il nome del job di dry run delle operazioni batch di archiviazione.
Gli altri parametri sono gli stessi del job effettivo. Per saperne di più, consulta le descrizioni dei parametri.

Per visualizzare i risultati del dry run, vedi Visualizzare i dettagli del job delle operazioni batch di archiviazione.
Dopo una prova dry run riuscita, esegui il comando gcloud storage batch-operations jobs create.
```
gcloud storage batch-operations jobs create JOB_NAME \
{--bucket=BUCKET | --bucket-list=BUCKET_LIST} OBJECT_SELECTION_FLAG JOB_TYPE_FLAG
```
Dove i parametri sono i seguenti:
- JOB_NAME è il nome del job di operazioni batch di archiviazione.
  
  Nota :quando crei il job effettivo, specifica un nome univoco o elimina prima il job di dry run. Il riutilizzo del nome del job di dry run causa un errore di creazione already exists.
- --bucket: BUCKET è il nome del bucket contenente gli oggetti che vuoi elaborare.
- --bucket-list: BUCKET_LIST è un elenco separato da virgole di uno o più nomi di bucket contenenti gli oggetti che vuoi elaborare. Puoi specificare fino a 1000 bucket di qualsiasi progetto, a condizione che ogni bucket sia registrato in un piano di storage intelligence.
- OBJECT_SELECTION_FLAG è uno dei seguenti flag che devi specificare:
  - --included-object-prefixes: specifica uno o più prefissi degli oggetti. Ad esempio:
    - Per far corrispondere un singolo prefisso, utilizza: --included-object-prefixes='prefix1'.
    - Per trovare corrispondenze con più prefissi, utilizza un elenco di prefissi separati da virgole: --included-object-prefixes='prefix1,prefix2'.
    - Per includere tutti gli oggetti, utilizza un prefisso vuoto: --included-object-prefixes=''.
  - --manifest-location: specifica la posizione del manifest. Ad esempio: gs://bucket_name/path/object_name.csv.
- JOB_TYPE_FLAG è uno dei seguenti flag che devi specificare, a seconda del tipo di prestazione.
  - --delete-object: elimina uno o più oggetti.
    - Se il controllo delle versioni degli oggetti è abilitato per il bucket, gli oggetti correnti passano a uno stato non corrente e gli oggetti non correnti vengono ignorati.
    - Se il controllo delle versioni degli oggetti è disabilitato per il bucket, l'operazione di eliminazione elimina definitivamente gli oggetti e ignora gli oggetti non correnti.
  - --enable-permanent-object-deletion: elimina definitivamente gli oggetti. Utilizza questo flag insieme al flag --delete-object per eliminare definitivamente gli oggetti attivi e non correnti in un bucket, indipendentemente dalla configurazione del controllo delle versioni degli oggetti del bucket.
  - --rewrite-object: aggiorna le chiavi di crittografia gestite dal cliente per uno o più oggetti. Puoi anche utilizzare questo flag per modificare la classe di archiviazione dell'oggetto specificando la chiave storage-class. Le classi di archiviazione supportate includono STANDARD, NEARLINE, COLDLINE e ARCHIVE. Ad esempio, --rewrite-object=storage-class=NEARLINE.
    
    Attenzione :se modifichi la classe di archiviazione di un oggetto in un bucket abilitato per Autoclass, l'operazione non ha effetto. L'operazione viene segnalata come riuscita, ma Cloud Storage reimposta la classe di archiviazione dell'oggetto sulla classe predefinita definita da Autoclass.
    Nota: la modifica della classe di archiviazione di un oggetto comporta la riscrittura dei relativi dati. Una riscrittura è un'operazione di classe A. Queste operazioni potrebbero comportare costi aggiuntivi a seconda dell'età, della località e della classe di archiviazione dei dati. Per saperne di più, consulta la pagina Prezzi di Cloud Storage. Se attivi il controllo delle versioni degli oggetti per il tuo bucket, Cloud Storage conserva l'oggetto originale come versione non corrente. Questa versione rimane nel bucket finché non la elimini in modo esplicito.
  - --set-object-acls-from-file: applica patch agli elenchi di controllo dell'accesso (ACL) degli oggetti. Fornisci un file JSON o YAML con le concessioni da aggiungere o aggiornare per entità come allUsers o allAuthenticatedUsers. Ad esempio: --set-object-acls-from-file=acl-updates.yaml o --set-object-acls-from-file=acl-updates.json.
    
    La struttura del file YAML per gli aggiornamenti è la seguente:
```
grants:
  - entity: allAuthenticatedUsers
    role: READER
  remove_entities:
  - allUsers
```
    La struttura del file JSON per gli aggiornamenti è la seguente:
```
{
"grants": [
  {
    "entity": "allAuthenticatedUsers",
    "role": "READER"
  }
],
"remove_entities": [
  "allUsers"
]
}
```
  - --put-object-event-based-hold: attiva Object holds basato sugli eventi.
  - --no-put-object-event-based-hold: disabilita Blocco di oggetti basato sugli eventi.
  - --put-object-temporary-hold: attiva Blocco di oggetti temporaneo.
  - --no-put-object-temporary-hold: disattiva i blocchi di oggetti temporanei.
    
    L'esempio seguente mostra come creare un job per aggiornare i metadati Content-Language in en per tutti gli oggetti elencati in manifest.csv.
```
gcloud storage batch-operations jobs create my-job \
--bucket=my-bucket \
--manifest-location=gs://my-bucket/manifest.csv \
--put-metadata=Content-Language=en
```
    L'esempio seguente mostra come creare un job che ha come target più bucket per aggiornare Content-Language a en-us:
```
gcloud storage batch-operations jobs create my-job \
--bucket-list=bucket1,bucket2 \
--included-object-prefixes='' \
--put-metadata=Content-Language=en-us
```
  - --put-metadata: aggiorna i metadati dell'oggetto. Specifica la coppia chiave-valore per i metadati dell'oggetto che vuoi modificare. Puoi specificare una o più coppie chiave-valore sotto forma di elenco. Puoi anche impostare le configurazioni di conservazione degli oggetti utilizzando il flag --put-metadata. Per farlo, specifica i parametri di conservazione utilizzando i campi Retain-Until e Retention-Mode. Ad esempio,
```
gcloud storage batch-operations jobs create my-job \
--bucket=my-bucket \
--manifest-location=gs://my-bucket/manifest.csv \
--put-metadata=Retain-Until=RETAIN_UNTIL_TIME,Retention-Mode=RETENTION_MODE
```
    Dove:
    - RETAIN_UNTIL_TIME è la data e l'ora, nel formato RFC 3339, fino alla quale l'oggetto viene conservato. Ad esempio 2025-10-09T10:30:00Z. Per impostare la configurazione di conservazione su un oggetto, devi abilitare la conservazione sul bucket che contiene l'oggetto.
    - RETENTION_MODE è la modalità di conservazione, Unlocked o Locked.
      
      Quando invii una richiesta di aggiornamento dei campi RETENTION_MODE e RETAIN_UNTIL_TIME, tieni presente quanto segue:
      - Per aggiornare la configurazione della conservazione degli oggetti, devi fornire valori non vuoti per i campi RETENTION_MODE e RETAIN_UNTIL_TIME. L'impostazione di un solo campo genera un errore INVALID_ARGUMENT.
      - Puoi estendere il valore RETAIN_UNTIL_TIME per gli oggetti in entrambe le modalità Unlocked o Locked.
      - La conservazione degli oggetti deve essere in modalità Unlocked se vuoi eseguire le seguenti operazioni:
        
        Riduci il valore di RETAIN_UNTIL_TIME.
        
        Rimuovi la configurazione di conservazione. Per rimuovere la configurazione, devi fornire valori vuoti per i campi RETENTION_MODE e RETAIN_UNTIL_TIME.
      - Se ometti entrambi i campi RETENTION_MODE e RETAIN_UNTIL_TIME, la configurazione della conservazione rimane invariata.
  - --clear-all-object-custom-contexts: elimina tutti i contesti degli oggetti esistenti.
    
    L'esempio seguente mostra come creare un job per cancellare tutti i contesti degli oggetti elencati in manifest.csv:
```
gcloud storage batch-operations jobs create my-job \
--bucket=my-bucket \
--manifest-location=gs://my-bucket/manifest.csv \
--clear-all-object-custom-contexts
```
    Attenzione: se cancelli tutti i contesti degli oggetti, vengono eliminati tutti i contesti esistenti dell'oggetto. Per conservare i contesti degli oggetti precedenti, attiva Cloud Logging. I log contengono contesti precedenti all'aggiornamento, che puoi utilizzare per ripristinare i valori precedenti.
  - --clear-object-custom-contexts: rimuovi i contesti con chiavi specifiche. Puoi anche aggiornare contesti specifici e rimuovere le chiavi utilizzando sia il flag --clear-object-custom-contexts sia uno dei seguenti flag:
    - --update-object-custom-contexts: fornisci una mappa di coppie chiave-valore.
      
      L'esempio seguente mostra come creare un job per rimuovere il contesto con la chiave temp-id e aggiornare o inserire il contesto con le chiavi project-id e cost-center per tutti gli oggetti elencati in manifest.csv:
      gcloud storage batch-operations jobs create my-job \ --bucket=my-bucket \ --manifest-location=gs://my-bucket/manifest.csv \ --clear-object-custom-contexts=temp-id \ --update-object-custom-contexts=project-id=project-A,cost-center=engineering
      Nota: non puoi specificare la stessa chiave sia nel flag --clear-object-custom-contexts che nel flag --update-object-custom-contexts. In questo modo si verifica un errore INVALID_ARGUMENT.
    - --update-object-custom-contexts-file: fornisci il percorso di un file JSON o YAML con coppie chiave-valore.
      
      L'esempio seguente mostra come creare un job per elaborare gli oggetti definiti in manifest.csv. Il job esegue le seguenti operazioni:
      - Rimuove tutti i contesti con la chiave temp-id.
      - Aggiorna i contesti esistenti con le chiavi project-id e cost-center definite nel file /tmp/context_updates.json.
      gcloud storage batch-operations jobs create my-job \ --bucket=my-bucket \ --manifest-location=gs://my-bucket/manifest.csv \ --clear-object-custom-contexts=temp-id \ --update-object-custom-contexts-file=/tmp/context_updates.json
      Dove /tmp/context_updates.json contiene i seguenti contesti degli oggetti:
      { "project-id": {"value": "project-A"}, "cost-center": {"value": "engineering"} }

Librerie client

C++

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage C++.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

[](google::cloud::storagebatchoperations_v1::StorageBatchOperationsClient
       client,
   std::string const& project_id, std::string const& job_id,
   std::string const& target_bucket_name, std::string const& object_prefix) {
  auto const parent =
      std::string{"projects/"} + project_id + "/locations/global";
  namespace sbo = google::cloud::storagebatchoperations::v1;
  sbo::Job job;
  sbo::BucketList* bucket_list = job.mutable_bucket_list();
  sbo::BucketList::Bucket* bucket_config = bucket_list->add_buckets();
  bucket_config->set_bucket(target_bucket_name);
  sbo::PrefixList* prefix_list_config = bucket_config->mutable_prefix_list();
  prefix_list_config->add_included_object_prefixes(object_prefix);
  sbo::DeleteObject* delete_object_config = job.mutable_delete_object();
  delete_object_config->set_permanent_object_deletion_enabled(false);
  auto result = client.CreateJob(parent, job, job_id).get();
  if (!result) throw result.status();
  std::cout << "Created job: " << result->name() << "\n";
}

PHP

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage PHP.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

use Google\Cloud\StorageBatchOperations\V1\Client\StorageBatchOperationsClient;
use Google\Cloud\StorageBatchOperations\V1\CreateJobRequest;
use Google\Cloud\StorageBatchOperations\V1\Job;
use Google\Cloud\StorageBatchOperations\V1\BucketList;
use Google\Cloud\StorageBatchOperations\V1\BucketList\Bucket;
use Google\Cloud\StorageBatchOperations\V1\PrefixList;
use Google\Cloud\StorageBatchOperations\V1\DeleteObject;

/**
 * Create a new batch job.
 *
 * @param string $projectId Your Google Cloud project ID.
 *        (e.g. 'my-project-id')
 * @param string $jobId A unique identifier for this job.
 *        (e.g. '94d60cc1-2d95-41c5-b6e3-ff66cd3532d5')
 * @param string $bucketName The name of your Cloud Storage bucket to operate on.
 *        (e.g. 'my-bucket')
 * @param string $objectPrefix The prefix of objects to include in the operation.
 *        (e.g. 'prefix1')
 */
function create_job(string $projectId, string $jobId, string $bucketName, string $objectPrefix): void
{
    // Create a client.
    $storageBatchOperationsClient = new StorageBatchOperationsClient();

    $parent = $storageBatchOperationsClient->locationName($projectId, 'global');

    $prefixListConfig = new PrefixList(['included_object_prefixes' => [$objectPrefix]]);
    $bucket = new Bucket(['bucket' => $bucketName, 'prefix_list' => $prefixListConfig]);
    $bucketList = new BucketList(['buckets' => [$bucket]]);

    $deleteObject = new DeleteObject(['permanent_object_deletion_enabled' => false]);

    $job = new Job(['bucket_list' => $bucketList, 'delete_object' => $deleteObject]);

    $request = new CreateJobRequest([
        'parent' => $parent,
        'job_id' => $jobId,
        'job' => $job,
    ]);
    $response = $storageBatchOperationsClient->createJob($request);

    printf('Created job: %s', $response->getName());
}

API JSON

Per definire l'elenco di oggetti per il job di operazioni batch, puoi scegliere una delle seguenti configurazioni di origine:

Progetto come origine: ha come target gli oggetti a livello di progetto utilizzando una configurazione projectSource. Anziché elencare singoli bucket o prefissi, specifichi parametri di filtro avanzati per eseguire query dinamiche sui metadati di Storage Insights. Per ulteriori informazioni, consulta la scheda API JSON in Creare un job utilizzando i filtri avanzati.
Bucket come origine: ha come target gli oggetti all'interno di bucket specifici utilizzando una configurazione bucketList. Devi specificare i bucket di destinazione e un file CSV manifest (manifest_location) o i prefissi degli oggetti (include_object_prefixes).

Avere gcloud CLI installata e inizializzata, il che ti consente di generare un token di accesso per l'intestazione Authorization.
Crea un file JSON contenente le impostazioni per il job di operazioni batch di archiviazione. Di seguito sono riportate le impostazioni comuni da includere:
```
{
        "Description": "JOB_DESCRIPTION",
        "BucketList":
        {
        "Buckets":
        [
         {
           "Bucket": "BUCKET_NAME",
           "Manifest": {
              "manifest_location": "MANIFEST_LOCATION"
               }
           "PrefixList": {
              "include_object_prefixes": "OBJECT_PREFIXES"
               }
         }
        ]
        },
        "DeleteObject":
        {
        "permanent_object_deletion_enabled": OBJECT_DELETION_VALUE
         }
        "RewriteObject": {
          "kms_key":"KMS_KEY_VALUE",
          "storage_class":"STORAGE_CLASS_VALUE"
          }
        "PutMetadata":{
          "METADATA_KEY": "METADATA_VALUE",
          ...,
          "objectRetention": {
              "retainUntilTime": "RETAIN_UNTIL_TIME",
              "mode": "RETENTION_MODE"
             }
           }
        "PutObjectHold": {
          "temporary_hold": TEMPORARY_HOLD_VALUE,
          "event_based_hold": EVENT_BASED_HOLD_VALUE
        },
        "updateObjectCustomContext": {
           "customContextUpdates": {
              "updates": {
                 "CONTEXT_KEY": { "value": "CONTEXT_VALUE" }
              },
              "keysToClear": ["CONTEXT_KEY_TO_CLEAR"]
           },
           "clearAll": CLEAR_ALL_VALUE
        },
        "SetObjectAcls": {
           "accessControlsUpdates": {
              "grants": [
                 { "entity": "allUsers", "role": "READER" }
              ],
              "removeEntities": ["allAuthenticatedUsers"]
           }
        },
        "dryRun": DRY_RUN_VALUE
        }
         
```
```
Where:
```
- JOB_NAME è il nome del job di operazioni batch di archiviazione.
- JOB_DESCRIPTION è la descrizione del job di operazioni batch di archiviazione.
- BUCKET_NAME è il nome del bucket che contiene uno o più oggetti da elaborare.
- Per specificare gli oggetti che vuoi elaborare, utilizza uno dei seguenti attributi nel file JSON:
  - MANIFEST_LOCATION è la posizione del manifest. Ad esempio: gs://bucket_name/path/object_name.csv.
  - OBJECT_PREFIXES è l'elenco separato da virgole contenente uno o più prefissi degli oggetti. Per trovare una corrispondenza con tutti gli oggetti, utilizza un elenco vuoto.
- A seconda del job che vuoi elaborare, specifica una delle seguenti opzioni:
  - Elimina oggetti:
```
"DeleteObject":
  {
  "permanent_object_deletion_enabled": OBJECT_DELETION_VALUE
  }
```
    Dove OBJECT_DELETION_VALUE è TRUE per eliminare gli oggetti.
  - Aggiorna la chiave di crittografia gestita dal cliente per gli oggetti:
```
"RewriteObject":
  {
  "kms_key": KMS_KEY_VALUE
  }
```
    Dove KMS_KEY_VALUE è il valore della chiave KMS dell'oggetto che vuoi aggiornare.
  - Aggiorna la classe di archiviazione per gli oggetti:
```
"RewriteObject":
  {
  "storage_class": STORAGE_CLASS_VALUE
  }
```
    Dove STORAGE_CLASS_VALUE è la nuova classe di archiviazione a cui vuoi trasferire gli oggetti. Le classi di archiviazione supportate includono STANDARD, NEARLINE, COLDLINE e ARCHIVE.
  - Aggiorna i metadati dell'oggetto:
```
"PutMetadata": {
     "METADATA_KEY": "METADATA_VALUE",
     ...,
    "objectRetention": {
       "retainUntilTime": "RETAIN_UNTIL_TIME",
       "mode": "RETENTION_MODE"
     }
   }
```
    Dove:
    - METADATA_KEY/VALUE è la coppia chiave-valore dei metadati dell'oggetto. Puoi specificare una o più coppie.
    - RETAIN_UNTIL_TIME è la data e l'ora, nel formato RFC 3339, fino alla quale l'oggetto viene conservato. Ad esempio 2025-10-09T10:30:00Z. Per impostare la configurazione di conservazione su un oggetto, devi abilitare la conservazione sul bucket che contiene l'oggetto.
    - RETENTION_MODE è la modalità di conservazione, Unlocked o Locked.
      
      Quando invii una richiesta per aggiornare i campi RETENTION_MODE e RETAIN_UNTIL_TIME, tieni presente quanto segue:
      
      Per aggiornare la configurazione della conservazione degli oggetti, devi fornire valori non vuoti per i campi RETENTION_MODE e RETAIN_UNTIL_TIME. L'impostazione di un solo campo genera un errore INVALID_ARGUMENT.
      
      Puoi estendere il valore RETAIN_UNTIL_TIME per gli oggetti in entrambe le modalità Unlocked o Locked.
      
      La conservazione degli oggetti deve essere in modalità Unlocked se vuoi eseguire le seguenti operazioni:
      
      Riduci il valore di RETAIN_UNTIL_TIME.
      
      Rimuovi la configurazione di conservazione. Per rimuovere la configurazione, devi fornire valori vuoti per i campi RETENTION_MODE e RETAIN_UNTIL_TIME.
      
      Se ometti i campi RETENTION_MODE e RETAIN_UNTIL_TIME, la configurazione della conservazione rimane invariata.
    - Aggiorna i blocchi oggetto:
      "PutObjectHold": { "temporary_hold": TEMPORARY_HOLD_VALUE, "event_based_hold": EVENT_BASED_HOLD_VALUE }
      Dove:
      - TEMPORARY_HOLD_VALUE viene utilizzato per attivare o disattivare la sospensione temporanea dell'oggetto. Un valore pari a 1 attiva l'archiviazione a fini legali, mentre un valore pari a 2 la disattiva.
      - EVENT_BASED_HOLD_VALUE viene utilizzato per attivare o disattivare il blocco oggetto basato su eventi. Un valore 1 attiva la sospensione, mentre un valore 2 la disattiva.
    - Aggiorna i contesti degli oggetti:
      "updateObjectCustomContext": { "customContextUpdates": { "updates": { "CONTEXT_KEY": { "value": "CONTEXT_VALUE" } }, "keysToClear": ["CONTEXT_KEY_TO_CLEAR"] }, "clearAll": CLEAR_ALL_VALUE }
      Dove:
      - CONTEXT_KEY è la chiave del contesto dell'oggetto da inserire o aggiornare.
      - CONTEXT_VALUE è il valore del contesto dell'oggetto per la chiave.
      - CONTEXT_KEY_TO_CLEAR è la chiave da rimuovere.
      - CLEAR_ALL_VALUE è impostato su true per eliminare tutti i contesti degli oggetti esistenti.
    - Aggiorna gli elenchi di controllo dell'accesso (ACL) degli oggetti:
      "SetObjectAcls": { "accessControlsUpdates": { "grants": [ { "entity": "ENTITY_NAME", "role": "ROLE_NAME" } ], "removeEntities": ["ENTITY_TO_REMOVE"] } }
      Dove:
      - ENTITY_NAME è l'entità a cui aggiungere o aggiornare l'accesso, ad esempio allUsers, allAuthenticatedUsers o un utente/gruppo specifico.
      - ROLE_NAME è il ruolo da concedere. Ad esempio, READER, OWNER.
      - ENTITY_TO_REMOVE è l'entità di cui vuoi rimuovere le credenziali.
  - DRY_RUN_VALUE è un valore booleano facoltativo. Imposta su true per eseguire il job in modalità dry run. Il valore predefinito è false.
    
    Importante: ti consigliamo di eseguire il job in modalità dry run prima di eseguire il job effettivo. Il dry run verifica i criteri di selezione degli oggetti e rileva gli errori senza modificare alcun oggetto.
  1. Utilizza curl per chiamare l'API JSON con una richiesta di job di operazioni batch di archiviazione POST:
```
curl -X POST --data-binary @JSON_FILE_NAME \
 -H "Authorization: Bearer $(gcloud auth print-access-token)" \
 -H "Content-Type: application/json" \
 "https://storagebatchoperations.googleapis.com/v1/projects/PROJECT_ID/locations/global/jobs?job_id=JOB_NAME"
```
    Dove:
    - JSON_FILE_NAME è il nome del file JSON.
    - PROJECT_ID è l'ID o il numero del progetto. Ad esempio, my-project.
    - JOB_NAME è il nome del job di operazioni batch di archiviazione.
      
      Nota :quando crei il job effettivo dopo un dry run, devi specificare un nome univoco per il job, a meno che tu non elimini esplicitamente il job di dry run. Il riutilizzo del nome del job di prova comporta l'esito negativo della creazione del job con un errore already exists.

Recupera i dettagli del job di operazioni batch di archiviazione

Questa sezione descrive come ottenere i dettagli del job di operazioni batch di archiviazione.

Per ottenere le autorizzazioni necessarie per visualizzare un job di operazioni batch di archiviazione, chiedi all'amministratore di concederti il ruolo IAM Storage Admin (roles/storage.admin) sul progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Console

Nella console Google Cloud , vai alla pagina Bucket in Cloud Storage.

Vai a Bucket
Nell'elenco dei bucket, fai clic sul nome del bucket associato all'operazione.
Nella pagina Dettagli bucket, fai clic sulla scheda Operazioni.
Nell'elenco delle operazioni, fai clic sull'ID operazione del job che vuoi visualizzare.
La pagina dei dettagli mostra le metriche del job nella scheda Panoramica, ad esempio gli oggetti rilevati, elaborati e gli eventuali errori verificatisi.
Nella tabella Riepilogo errori, esamina i dettagli degli errori di esecuzione o fai clic su Visualizza in Cloud Logging per visualizzare i record.
Per visualizzare le impostazioni di configurazione del job, fai clic sulla scheda Configurazione.

Riga di comando

Nella console Google Cloud , attiva Cloud Shell.

Attiva Cloud Shell

Nella parte inferiore della console Google Cloud viene avviata una sessione di Cloud Shell e viene visualizzato un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installata e con valori già impostati per il progetto corrente. L'inizializzazione della sessione può richiedere alcuni secondi.
Nell'ambiente di sviluppo, esegui il comando gcloud storage batch-operations jobs describe.
```
gcloud storage batch-operations jobs describe JOB_NAME
```
Dove:

JOB_NAME è il nome del job di operazioni batch di archiviazione.

Quando esegui il dry run di un job, l'output include i seguenti campi:
- totalObjectCount: mostra il numero di oggetti che corrispondono ai criteri di selezione.
- errorSummaries: elenca gli errori rilevati durante il dry run, ad esempio problemi di autorizzazione o configurazioni non valide.
- totalBytesFound: mostra la dimensione totale degli oggetti interessati. Questo campo viene visualizzato solo quando utilizzi i prefissi degli oggetti per la selezione degli oggetti.
Se l'operazione va a buon fine, la risposta per il job di dry run è simile al seguente esempio:
```
  bucketList:
    buckets:
    - bucket: my-bucket
      manifest:
        manifestLocation: gs://my-bucket/manifest.csv
  completeTime: '2025-10-27T23:56:32Z'
  counters:
    totalObjectCount: '4'
  createTime: '2025-10-27T23:56:22.243528568Z'
  dryRun: true
  name: projects/my-project/locations/global/jobs/my-job
  putMetadata:
    contentLanguage: en
  state: SUCCEEDED
```
Una risposta corretta del job omette il campo dryRun e restituisce le seguenti metriche nel campo counters:
- Totale oggetti trovati.
- Byte totali trovati quando si utilizzano i prefissi degli oggetti.
- Trasformazioni degli oggetti riuscite.
- Trasformazioni degli oggetti non riuscite, se applicabile.
- Contesti degli oggetti creati, se applicabile.
- Contesti degli oggetti eliminati, se applicabile.
- Contesti degli oggetti aggiornati, se applicabile. Questo contatore monitora gli aggiornamenti apportati alle chiavi di contesto esistenti.
La risposta per l'esecuzione di un job effettivo è simile al seguente esempio:
```
  bucketList:
    buckets:
    - bucket: my-bucket
      manifest:
        manifestLocation: gs://my-bucket/manifest.csv
  completeTime: '2025-10-31T20:19:42.357826655Z'
  counters:
    succeededObjectCount: '4'
    totalObjectCount: '4'
  createTime: '2025-10-31T20:19:22.016517077Z'
  name: projects/my-project/locations/global/jobs/my-job
  putMetadata:
    contentLanguage: en
  state: SUCCEEDED
  
```
Nota: se gli oggetti nel bucket vengono modificati dopo un dry run, il valore totalObjectCount del job effettivo potrebbe differire dai risultati del dry run.

Librerie client

C++

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage C++.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

[](google::cloud::storagebatchoperations_v1::StorageBatchOperationsClient
       client,
   std::string const& project_id, std::string const& job_id) {
  auto const parent =
      std::string{"projects/"} + project_id + "/locations/global";
  auto const name = parent + "/jobs/" + job_id;
  auto job = client.GetJob(name);
  if (!job) throw job.status();
  std::cout << "Got job: " << job->name() << "\n";
}

PHP

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage PHP.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

use Google\Cloud\StorageBatchOperations\V1\Client\StorageBatchOperationsClient;
use Google\Cloud\StorageBatchOperations\V1\GetJobRequest;

/**
 * Gets a batch job.
 *
 * @param string $projectId Your Google Cloud project ID.
 *        (e.g. 'my-project-id')
 * @param string $jobId A unique identifier for this job.
 *        (e.g. '94d60cc1-2d95-41c5-b6e3-ff66cd3532d5')
 */
function get_job(string $projectId, string $jobId): void
{
    // Create a client.
    $storageBatchOperationsClient = new StorageBatchOperationsClient();

    $parent = $storageBatchOperationsClient->locationName($projectId, 'global');
    $formattedName = $parent . '/jobs/' . $jobId;

    $request = new GetJobRequest([
        'name' => $formattedName,
    ]);

    $response = $storageBatchOperationsClient->getJob($request);

    printf('Got job: %s', $response->getName());
}

API JSON

Avere gcloud CLI installata e inizializzata, il che ti consente di generare un token di accesso per l'intestazione Authorization.
Utilizza cURL per chiamare l'API JSON con una richiesta di GETjob di operazioni batch di archiviazione:
```
curl -X GET \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://storagebatchoperations.googleapis.com/v1/projects/PROJECT_ID/locations/global/jobs/JOB_NAME"
```
Dove:
- PROJECT_ID è l'ID o il numero del progetto. Ad esempio, my-project.
- JOB_NAME è il nome del job di operazioni batch di archiviazione.
Quando esegui un dry run di un job, l'output include i seguenti campi:
- totalObjectCount: mostra il numero di oggetti che corrispondono ai criteri di selezione.
- errorSummaries: elenca gli errori rilevati durante il dry run, ad esempio problemi di autorizzazione o configurazioni non valide.
- totalBytesFound: mostra la dimensione totale degli oggetti interessati. Questo campo viene visualizzato solo quando utilizzi i prefissi degli oggetti per la selezione degli oggetti.
Se l'operazione ha esito positivo, la risposta per il dry run è simile al seguente esempio:
```
{
  "name": "projects/my-project/locations/global/jobs/my-job",
  "description": "dry-run-job",
  "deleteObject": {
    "permanent_object_deletion_enabled": true
     },
  "createTime": "2025-10-28T00:26:53.900882459Z",
  "completeTime": "2025-10-28T00:27:04.101663275Z",
  "counters": {
      "totalObjectCount": "5",
      "totalBytesFound": "203"
    },
  "state": "SUCCEEDED",
  "bucketList": {
    "buckets": [
      {
        "bucket": "my-bucket",
        "prefixList": {
          "includedObjectPrefixes": [
            ""
          ]
        }
      }
    ]
  },
  "dryRun": true
}
```
Una risposta corretta al job omette il campo dryRun e restituisce le seguenti metriche nel campo counters:
- Totale oggetti trovati.
- Byte totali trovati quando si utilizzano i prefissi degli oggetti.
- Trasformazioni degli oggetti riuscite.
- Trasformazioni degli oggetti non riuscite, se applicabile.
- Contesti degli oggetti creati, se applicabile.
- Contesti degli oggetti eliminati, se applicabile.
- Contesti degli oggetti aggiornati, se applicabile. Questo contatore monitora gli aggiornamenti apportati alle chiavi di contesto esistenti.
  
  La risposta per l'esecuzione di un job effettivo è simile al seguente esempio:
```
{
"name": "my-job",
"description": "my-delete-objects-job",
"deleteObject": {
  "permanent_object_deletion_enabled": true
},
"createTime": "2025-10-28T00:26:53.900882459Z",
"completeTime": "2025-10-28T00:27:04.101663275Z",
"counters": {
  "succeededObjectCount: "5"
  "totalObjectCount": "5",
  "totalBytesFound": "203"
},
"state": "SUCCEEDED",
"bucketList": {
  "buckets": [
    {
      "bucket": "my-bucket",
      "prefixList": {
        "includedObjectPrefixes": [
          ""
        ]
      }
    }
  ]
}
}
```
Nota: Se gli oggetti nel bucket vengono modificati dopo un dry run, il valore totalObjectCount del job effettivo potrebbe differire dai risultati del dry run.

Elenca operazioni sui bucket

Per i job che includono più bucket, puoi visualizzare l'avanzamento e lo stato delle operazioni sui singoli bucket. Per elencare le operazioni eseguite sui bucket per un job specifico, esegui il comando gcloud storage batch-operations bucket-operations list:

gcloud storage batch-operations bucket-operations list --job=JOB_NAME

Puoi anche filtrare l'elenco in base a bucket specifici utilizzando il flag --buckets:

gcloud storage batch-operations bucket-operations list --job=JOB_NAME --buckets=BUCKET_NAME_LIST

Il seguente esempio mostra come elencare le operazioni per bucket1 e bucket2 per il job my-job:

gcloud storage batch-operations bucket-operations list --job=my-job --buckets=bucket1,bucket2

Dove:

JOB_NAME è il nome univoco del job di operazioni batch di archiviazione che hai creato. Ad esempio, my-job.
BUCKET_NAME_LIST è un elenco separato da virgole di nomi di bucket, senza spazi tra i nomi. Ad esempio, bucket1,bucket2.

Descrivi un'operazione bucket

Per visualizzare i dettagli di un'operazione specifica sul bucket, puoi utilizzare uno dei seguenti metodi:

Utilizza il comando gcloud storage batch-operations bucket-operations describe con il flag del nome della risorsa dell'operazione:
```
gcloud alpha storage batch-operations bucket-operations describe BUCKET_OPERATION_RESOURCE_NAME
```
Dove:
- BUCKET_OPERATION_RESOURCE_NAME è il percorso completo della risorsa dell'operazione del bucket. Ad esempio, projects/my-project/locations/global/jobs/my-job/bucketOperations/bo-1.
Utilizza il comando gcloud storage batch-operations bucket-operations describe con i flag ID operazione bucket e ID job:
```
gcloud alpha storage batch-operations bucket-operations describe BUCKET_OPERATION_ID --job=JOB_NAME
```
Dove:
- BUCKET_OPERATION_ID è l'ID dell'operazione sul bucket.
- JOB_NAME è il nome univoco del job di operazioni batch di archiviazione che hai creato. Ad esempio, my-job.

Elenca job di operazioni batch di archiviazione

Questa sezione descrive come elencare i job di operazioni batch di archiviazione all'interno di un progetto.

Per ottenere le autorizzazioni necessarie per elencare i job delle operazioni batch di archiviazione, chiedi all'amministratore di concederti il ruolo IAM Storage Admin (roles/storage.admin) nel progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Console

Nella console Google Cloud , vai alla pagina Bucket in Cloud Storage.

Vai a Bucket
Nell'elenco dei bucket, fai clic sul nome del bucket associato all'operazione.
Nella pagina Dettagli bucket, fai clic sulla scheda Operazioni. La pagina Operazioni mostra un elenco delle operazioni attive in esecuzione.

Riga di comando

Nella console Google Cloud , attiva Cloud Shell.

Attiva Cloud Shell

Nella parte inferiore della console Google Cloud viene avviata una sessione di Cloud Shell e viene visualizzato un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installata e con valori già impostati per il progetto corrente. L'inizializzazione della sessione può richiedere alcuni secondi.
Nell'ambiente di sviluppo, esegui il comando gcloud storage batch-operations jobs list.
```
gcloud storage batch-operations jobs list
```

Librerie client

C++

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage C++.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

[](google::cloud::storagebatchoperations_v1::StorageBatchOperationsClient
       client,
   std::string const& project_id) {
  auto const parent =
      std::string{"projects/"} + project_id + "/locations/global";
  for (auto const& job : client.ListJobs(parent)) {
    if (!job) throw job.status();
    std::cout << job->name() << "\n";
  }
}

PHP

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage PHP.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

use Google\Cloud\StorageBatchOperations\V1\Client\StorageBatchOperationsClient;
use Google\Cloud\StorageBatchOperations\V1\ListJobsRequest;

/**
 * List Jobs in a given project.
 *
 * @param string $projectId Your Google Cloud project ID.
 *        (e.g. 'my-project-id')
 */
function list_jobs(string $projectId): void
{
    // Create a client.
    $storageBatchOperationsClient = new StorageBatchOperationsClient();

    $parent = $storageBatchOperationsClient->locationName($projectId, 'global');

    $request = new ListJobsRequest([
        'parent' => $parent,
    ]);

    $jobs = $storageBatchOperationsClient->listJobs($request);

    foreach ($jobs as $job) {
        printf('Job name: %s' . PHP_EOL, $job->getName());
    }
}

API JSON

Avere gcloud CLI installata e inizializzata, il che ti consente di generare un token di accesso per l'intestazione Authorization.
Utilizza cURL per chiamare l'API JSON con una richiesta LIST per i job di operazioni batch di archiviazione:
```
curl -X GET \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://storagebatchoperations.googleapis.com/v1/projects/PROJECT_ID/locations/global/jobs"
```
Dove:

PROJECT_ID è l'ID o il numero del progetto. Ad esempio, my-project.

Annulla un job di operazioni batch di archiviazione

Questa sezione descrive come annullare un job di operazioni batch di archiviazione all'interno di un progetto.

Per ottenere le autorizzazioni necessarie per annullare un job di operazioni batch di archiviazione, chiedi all'amministratore di concederti il ruolo IAM Storage Admin (roles/storage.admin) nel progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Console

Nella console Google Cloud , vai alla pagina Bucket in Cloud Storage.

Vai a Bucket
Nell'elenco dei bucket, fai clic sul nome del bucket associato all'operazione batch di archiviazione da annullare.
Fai clic sulla scheda Operazioni. Questa scheda mostra un elenco di job di operazioni batch. Puoi annullare solo i job in corso.
Nell'elenco delle operazioni, seleziona uno o più job da annullare, quindi fai clic su Annulla.

Riga di comando

Nella console Google Cloud , attiva Cloud Shell.

Attiva Cloud Shell

Nella parte inferiore della console Google Cloud , viene avviata una sessione di Cloud Shell e viene visualizzato un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installata e con valori già impostati per il progetto corrente. L'inizializzazione della sessione può richiedere alcuni secondi.
Nell'ambiente di sviluppo, esegui il comando gcloud storage batch-operations jobs cancel.
```
gcloud storage batch-operations jobs cancel JOB_NAME
```
Dove:

JOB_NAME è il nome del job di operazioni batch di archiviazione.

Librerie client

C++

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage C++.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

[](google::cloud::storagebatchoperations_v1::StorageBatchOperationsClient
       client,
   std::string const& project_id, std::string const& job_id) {
  auto const parent =
      std::string{"projects/"} + project_id + "/locations/global";
  auto const name = parent + "/jobs/" + job_id;
  auto response = client.CancelJob(name);
  if (!response) throw response.status();
  std::cout << "Cancelled job: " << name << "\n";
}

PHP

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage PHP.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

use Google\Cloud\StorageBatchOperations\V1\Client\StorageBatchOperationsClient;
use Google\Cloud\StorageBatchOperations\V1\CancelJobRequest;

/**
 * Cancel a batch job.
 *
 * @param string $projectId Your Google Cloud project ID.
 *        (e.g. 'my-project-id')
 * @param string $jobId A unique identifier for this job.
 *        (e.g. '94d60cc1-2d95-41c5-b6e3-ff66cd3532d5')
 */
function cancel_job(string $projectId, string $jobId): void
{
    // Create a client.
    $storageBatchOperationsClient = new StorageBatchOperationsClient();

    $parent = $storageBatchOperationsClient->locationName($projectId, 'global');
    $formattedName = $parent . '/jobs/' . $jobId;

    $request = new CancelJobRequest([
        'name' => $formattedName,
    ]);

    $storageBatchOperationsClient->cancelJob($request);

    printf('Cancelled job: %s', $formattedName);
}

API JSON

Avere gcloud CLI installato e inizializzato, che ti consente di generare un token di accesso per l'intestazione Authorization.
Utilizza cURL per chiamare l'API JSON con una richiesta CANCEL di un job di operazioni batch di archiviazione:
```
curl -X CANCEL \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://storagebatchoperations.googleapis.com/v1/projects/PROJECT_ID/locations/global/jobs/JOB_NAME"
```
Dove:
- PROJECT_ID è l'ID o il numero del progetto. Ad esempio, my-project.
- JOB_NAME è il nome del job di operazioni batch di archiviazione.

Elimina un job di operazioni batch di archiviazione

Questa sezione descrive come eliminare un job di operazioni batch di archiviazione.

Per ottenere le autorizzazioni necessarie per eliminare un job di operazioni batch di archiviazione, chiedi all'amministratore di concederti il ruolo IAM Storage Admin (roles/storage.admin) nel progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Console

Nella console Google Cloud , vai alla pagina Bucket in Cloud Storage.

Vai a Bucket
Nell'elenco dei bucket, fai clic sul nome del bucket associato all'operazione batch di archiviazione che vuoi eliminare.
Fai clic sulla scheda Operazioni. Questa scheda mostra un elenco di job di operazioni batch. Puoi eliminare solo i job non in esecuzione, ad esempio quelli completati, non riusciti o annullati.
Nell'elenco delle operazioni, seleziona uno o più job da eliminare, quindi fai clic su Elimina.

Riga di comando

Nella console Google Cloud , attiva Cloud Shell.

Attiva Cloud Shell

Nella parte inferiore della console Google Cloud viene avviata una sessione di Cloud Shell e viene visualizzato un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installata e con valori già impostati per il progetto corrente. L'inizializzazione della sessione può richiedere alcuni secondi.
Nell'ambiente di sviluppo, esegui il comando gcloud storage batch-operations jobs delete.
```
gcloud storage batch-operations jobs delete JOB_NAME
```
Dove:

JOB_NAME è il nome del job di operazioni batch di archiviazione.

Librerie client

C++

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage C++.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

[](google::cloud::storagebatchoperations_v1::StorageBatchOperationsClient
       client,
   std::string const& project_id, std::string const& job_id) {
  auto const parent =
      std::string{"projects/"} + project_id + "/locations/global";
  auto const name = parent + "/jobs/" + job_id;
  auto status = client.DeleteJob(name);
  if (!status.ok()) throw status;
  std::cout << "Deleted job: " << name << "\n";
}

PHP

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage PHP.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

use Google\Cloud\StorageBatchOperations\V1\Client\StorageBatchOperationsClient;
use Google\Cloud\StorageBatchOperations\V1\DeleteJobRequest;

/**
 * Delete a batch job.
 *
 * @param string $projectId Your Google Cloud project ID.
 *        (e.g. 'my-project-id')
 * @param string $jobId A unique identifier for this job.
 *        (e.g. '94d60cc1-2d95-41c5-b6e3-ff66cd3532d5')
 */
function delete_job(string $projectId, string $jobId): void
{
    // Create a client.
    $storageBatchOperationsClient = new StorageBatchOperationsClient();

    $parent = $storageBatchOperationsClient->locationName($projectId, 'global');
    $formattedName = $parent . '/jobs/' . $jobId;

    $request = new DeleteJobRequest([
        'name' => $formattedName,
    ]);

    $storageBatchOperationsClient->deleteJob($request);

    printf('Deleted job: %s', $formattedName);
}

API JSON

Avere gcloud CLI installata e inizializzata, il che ti consente di generare un token di accesso per l'intestazione Authorization.
Utilizza cURL per chiamare l'API JSON con una richiesta DELETE di un job di operazioni batch di archiviazione:
```
curl -X DELETE \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://storagebatchoperations.googleapis.com/v1/projects/PROJECT_ID/locations/global/jobs/JOB_NAME"
```
Dove:
- PROJECT_ID è l'ID o il numero del progetto. Ad esempio, my-project.
- JOB_NAME è il nome del job di operazioni batch di archiviazione.

Crea un job di operazioni batch di archiviazione utilizzando i set di dati Storage Insights

Per eseguire un job di operazioni batch sugli oggetti elencati in un set di dati, seleziona una delle seguenti opzioni:

Utilizza filtri avanzati: filtra gli oggetti in modo dinamico a livello di progetto direttamente nel comando Google Cloud CLI.

I set di dati di Storage Insights vengono creati da snapshot periodici point-in-time dei metadati di archiviazione. Ogni snapshot ha un'ora di acquisizione che indica quando sono stati acquisiti i metadati. Quando esegui un job batch utilizzando filtri avanzati, questo orario dello snapshot determina quali oggetti e versioni vengono elaborati. Per impostazione predefinita, le operazioni batch di archiviazione selezionano automaticamente l'ora dell'ultimo snapshot. Per evitare operazioni su dati obsoleti, la creazione del job non va a buon fine se lo snapshot selezionato risale a più di due giorni fa. Per informazioni su come risolvere questo errore, consulta Risoluzione dei problemi relativi alle operazioni batch di archiviazione.
Utilizza un file manifest: genera un file manifest CSV eseguendo una query BigQuery e poi forniscilo al job.

I metodi sono descritti nelle sezioni seguenti.

Utilizza i filtri avanzati

Anziché creare un file manifest, puoi utilizzare i filtri Common Expression Language (CEL) per selezionare gli oggetti direttamente in base ai campi del set di dati Storage Insights. Puoi eseguire job in più bucket di un progetto. Quando utilizzi i filtri dei set di dati per la selezione degli oggetti, le operazioni batch di archiviazione hanno come target gli oggetti attivi e aggiornati allo snapshot del set di dati selezionato. Di conseguenza, il job include solo gli oggetti che hanno un valore NULL sia per softDeleteTime che per timeDeleted al momento dello snapshot.

Riga di comando

Nella console Google Cloud , attiva Cloud Shell.

Attiva Cloud Shell

Nella parte inferiore della console Google Cloud , viene avviata una sessione di Cloud Shell e viene visualizzato un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installata e con valori già impostati per il progetto corrente. L'inizializzazione della sessione può richiedere alcuni secondi.
Esegui il comando gcloud storage batch-operations jobs create:
```
gcloud storage batch-operations jobs create JOB_NAME \
{--insights-dataset-config=INSIGHTS_DATASET_CONFIG_RESOURCE_NAME --target-project=TARGET_PROJECT [--bucket-filters=BUCKET_FILTER_CEL] [--object-filters=OBJECT_FILTER_CEL] [--target-locations=TARGET_LOCATIONS] [--target-snapshot-time=TARGET_SNAPSHOT_TIME] | --dry-run-job-id=DRY_RUN_JOB_ID} \
--JOB_TYPE_FLAG
```
Dove:
- JOB_NAME è il nome del job di operazioni batch di archiviazione.
- INSIGHTS_DATASET_CONFIG_RESOURCE_NAME: il nome della risorsa della configurazione del set di dati. Ad esempio: projects/{project-id}/locations/{location-id}/datasetConfigs/{dataset_config_id}. Devi specificare questo parametro prima di utilizzare i flag --bucket-filters e --object-filters.
- TARGET_PROJECT: l'ID progetto o il numero di progetto associato alle risorse di destinazione.
- BUCKET_FILTER_CEL e OBJECT_FILTER_CEL (facoltativo): le espressioni di filtro CEL utilizzate per selezionare gli oggetti. Ecco alcuni esempi:
  - --bucket-filters="name in ['bucket-1', 'bucket-2']"
  - --object-filters="size >= 5000 && name.endsWith('.pdf')" Per informazioni su campi, operatori e funzioni supportati, consulta il riferimento ai filtri CEL.
- TARGET_LOCATIONS (Facoltativo) Un elenco di località di Cloud Storage utilizzate per restringere l'ambito del job. Ad esempio: us,us-central1,us-east4. Utilizza questo parametro per escludere le località che stanno riscontrando un'interruzione del servizio. Se viene specificato solo TARGET_LOCATIONS e TARGET_SNAPSHOT_TIME viene omesso, il job sceglie automaticamente il timestamp dello snapshot più recente compilato correttamente nelle visualizzazioni degli attributi di oggetti e bucket in tutte le località specificate.
- TARGET_SNAPSHOT_TIME (facoltativo): il timestamp UTC dello snapshot del set di dati da utilizzare, in formato RFC 3339. Ad esempio, 2026-05-03T16:00:00Z. Questo snapshot deve esistere in tutte le visualizzazioni degli attributi di bucket e oggetti. Se specifichi questo parametro, devi specificare anche il parametro TARGET_LOCATIONS.
- DRY_RUN_JOB_ID: l'identificatore di un job di prova eseguito in precedenza. Se specifichi questo parametro, non puoi specificare altri parametri di selezione degli oggetti, inclusi --insights-dataset-config, --target-project, --bucket-filters, --object-filters, --target-locations e --target-snapshot-time. Il job attivo esegue il polling di tutti i criteri di selezione direttamente dal job dry run.
- JOB_TYPE_FLAG: il flag corrispondente all'operazione collettiva che vuoi eseguire, ad esempio --put-metadata o --delete-object.

API JSON

Avere gcloud CLI installata e inizializzata, il che ti consente di generare un token di accesso per l'intestazione Authorization.
Crea un file di configurazione JSON che specifichi i filtri del set di dati e le impostazioni delle operazioni collettive. Ad esempio:
```
{
    "description": "JOB_DESCRIPTION",
    "projectSource": {
        "project": "projects/TARGET_PROJECT",
        "insightsDatasetConfig": "INSIGHTS_DATASET_CONFIG_RESOURCE_NAME",
        "bucketFilters": {
            "expression": "BUCKET_FILTER_CEL"
        },
        "objectFilters": {
            "expression": "OBJECT_FILTER_CEL"
        },
        "snapshotTime": "SNAPSHOT_TIME",
        "targetLocations": {
            "locations": ["LOCATION_1", "LOCATION_2"]
        }
    },
    "deleteObject": {
        "permanentObjectDeletionEnabled": OBJECT_DELETION_VALUE
    }
 }
```
Dove:
- JOB_DESCRIPTION è la descrizione del lavoro.
  - TARGET_PROJECT è l'ID progetto o il numero di progetto associato agli oggetti di destinazione.
- INSIGHTS_DATASET_CONFIG_RESOURCE_NAME è il nome completo della risorsa della configurazione del set di dati (ad esempio, projects/{project-id}/locations/{location-id}/datasetConfigs/{dataset_config_id}).
- BUCKET_FILTER_CEL è l'espressione di filtro CEL per i bucket. Ad esempio, name in ['bucket-1', 'bucket-2']. Per informazioni dettagliate su parole chiave, campi e operatori supportati, consulta il riferimento ai filtri CEL.
- OBJECT_FILTER_CEL è l'espressione di filtro CEL per gli oggetti. Ad esempio, size >= 5000 && name.endsWith('.pdf').
- snapshotTime (facoltativo): un timestamp UTC specifico in formato RFC 3339 (ad esempio, "2026-05-03T16:00:00Z") che specifica lo snapshot del set di dati da utilizzare. Questo snapshot deve esistere sia nelle visualizzazioni dei set di dati dei bucket che in quelle degli oggetti in tutte le località target. Se specifichi questo campo, devi specificare anche il campo targetLocations.
- targetLocations (facoltativo): un oggetto JSON che specifica un elenco di posizioni Cloud Storage (ad esempio ["us", "us-central1", "us-east4"]) per filtrare l'ambito del job. Se le dipendenze subiscono un'interruzione in località specifiche, puoi limitare il job a località specifiche. Se viene specificato solo targetLocations e snapshotTime viene omesso, il job sceglie automaticamente il timestamp dello snapshot più recente che viene compilato correttamente nelle visualizzazioni degli attributi degli oggetti e dei bucket in tutte le località specificate.
- OBJECT_DELETION_VALUE è il valore booleano che attiva/disattiva l'eliminazione definitiva. Ad esempio: true o false.

Invia una richiesta POST utilizzando cURL per eseguire il job:

curl -X POST \
     -H "Authorization: Bearer OAUTH2_TOKEN" \
     -H "Content-Type: application/json" \
     -d @JSON_FILE_NAME \
     "https://storagebatchoperations.googleapis.com/v1/projects/PROJECT_ID/locations/global/jobs?job_id=JOB_NAME"

Dove:

JSON_FILE_NAME è il nome del file JSON.
PROJECT_ID è l'ID o il numero del progetto. Ad esempio, my-project.
JOB_NAME è il nome del job di operazioni batch di archiviazione.

Utilizzare un file manifest

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Creare un manifest utilizzando i set di dati Storage Insights

Puoi creare il manifest per il job di operazioni batch di archiviazione estraendo i dati da BigQuery. Per farlo, devi eseguire una query sul set di dati collegato, esportare i dati risultanti come file CSV e salvarli in un bucket Cloud Storage. Il job di operazioni batch di archiviazione può quindi utilizzare questo file CSV come manifest.

L'esecuzione della seguente query SQL in BigQuery su una visualizzazione del set di dati Storage Insights recupera gli oggetti di dimensioni superiori a 1 KiB denominati Temp_Training:

  EXPORT DATA OPTIONS(
   uri=`URI`,
   format=`CSV`,
   overwrite=OVERWRITE_VALUE,
   field_delimiter=',') AS
  SELECT bucket, name, generation
  FROM DATASET_VIEW_NAME
  WHERE bucket = BUCKET_NAME
  AND name LIKE (`Temp_Training%`)
  AND size > 1024 * 1024
  AND snapshotTime = SNAPSHOT_TIME

Dove:

URI è l'URI del bucket che contiene il manifest. Ad esempio, gs://bucket_name/path_to_csv_file/*.csv. Quando utilizzi il carattere jolly *.csv, BigQuery esporta il risultato in più file CSV.
OVERWRITE_VALUE è un valore booleano. Se impostato su true, l'operazione di esportazione sovrascrive i file esistenti nella posizione specificata.
DATASET_VIEW_NAME è il nome completo della visualizzazione del set di dati Storage Insights nel formato PROJECT_ID.DATASET_ID.VIEW_NAME. Per trovare il nome del set di dati, visualizza il set di dati collegato.

Dove:
- PROJECT_ID è l'ID o il numero del progetto. Ad esempio, my-project.
- DATASET_ID è il nome del set di dati. Ad esempio, objects-deletion-dataset.
- VIEW_NAME è il nome della vista del set di dati. Ad esempio, bucket_attributes_view.
BUCKET_NAME è il nome del bucket. Ad esempio, my-bucket.
SNAPSHOT_TIME è l'ora dello snapshot della visualizzazione del set di dati di Storage Insights. Ad esempio, 2024-09-10T00:00:00Z.

Crea un job di operazioni batch di archiviazione utilizzando un file manifest

Per creare un job di operazioni batch di archiviazione per elaborare gli oggetti contenuti nel manifest, completa i seguenti passaggi:

Console

Nella console Google Cloud , vai alla pagina Bucket in Cloud Storage.

Vai a Bucket
Nell'elenco dei bucket, fai clic sul nome del bucket che contiene gli oggetti su cui vuoi eseguire operazioni batch.

Si apre la pagina Dettagli bucket con la scheda Oggetti selezionata.
Fai clic su Crea operazioni batch.
Nel riquadro Seleziona operazione, scegli il tipo di operazione:
- Gestisci i blocchi oggetto: seleziona Blocco temporaneo o Blocco basato su eventi. Per saperne di più, consulta Archiviazione a fini legali degli oggetti.
- Aggiorna metadati oggetto: per aggiungere metadati dell'oggetto, procedi nel seguente modo:
  - Per aggiungere metadati personalizzati, completa i seguenti passaggi:
    1. Nel campo Chiave, inserisci un nome per la chiave.
    2. Nel campo Valore, inserisci un valore per la chiave.
    3. (Facoltativo) Fai clic su + Aggiungi elemento per aggiungere altre coppie chiave-valore.
  - Per aggiornare i metadati a chiave fissa, completa i seguenti passaggi:
    1. Per espandere la sezione Aggiorna metadati a chiave fissa, fai clic sulla freccia di espansione .
    2. Nell'elenco Seleziona uno o più metadati da aggiornare, seleziona gli elementi dei metadati da modificare.
- Aggiorna/Ruota chiave di crittografia: per utilizzare o aggiornare la chiave di crittografia per gli oggetti, segui questi passaggi:
  1. Nell'elenco Seleziona una chiave Cloud KMS, seleziona una chiave di crittografia gestita dal cliente (CMEK).
  2. (Facoltativo) Seleziona Cambia progetto per scegliere una chiave da un altro progetto o seleziona Inserisci chiave manualmente per compilare i dettagli.
- Elimina oggetti: per eliminare gli oggetti, segui questi passaggi:
  1. Verifica se il controllo delle versioni degli oggetti è attivato.
  2. Se il controllo delle versioni degli oggetti è attivato, scegli una delle seguenti opzioni di eliminazione:
    - Seleziona Elimina tutte le versioni degli oggetti per rimuovere sia le versioni attive che quelle non correnti.
    - Seleziona Elimina definitivamente le versioni live per rimuovere solo la versione live.
    Se il controllo delle versioni degli oggetti non è abilitato, tutti gli oggetti selezionati per l'eliminazione vengono eliminati definitivamente.
  Avviso: l'eliminazione accidentale di oggetti comporta il rischio di perdita di dati. Abilita l'eliminazione temporanea per recuperare le eliminazioni accidentali di oggetti.
Fai clic su Avanti.
Nel riquadro Assegna un nome all'operazione e specifica gli oggetti, segui questi passaggi:
1. Nel campo Nome, inserisci un nome.
2. (Facoltativo) Nel campo Descrizione, inserisci una descrizione.
3. Nella sezione Specifica oggetti, seleziona Carica elenchi di oggetti utilizzando file manifest CSV, quindi procedi come segue:
  1. Carica il file CSV manifest in un bucket. Questo file deve contenere le intestazioni per Nome bucket, Chiave oggetto e Numero di generazione.
  2. Nell'elenco Seleziona la modalità del file manifest, scegli una delle seguenti opzioni:
    - Se selezioni Seleziona un file manifest da Cloud Storage, fai clic su Sfoglia nel campo Seleziona un file manifest da Cloud Storage. Nella finestra di dialogo Seleziona oggetto che viene visualizzata, vai al file CSV manifest e fai clic su Seleziona.
    - Se selezioni Seleziona più file manifest utilizzando un carattere jolly, inserisci il percorso del file nel campo Inserisci la posizione del file manifest utilizzando un carattere jolly. Ad esempio: bucket-name/folder/manifest_*.
Fai clic su Crea.

Riga di comando

Nella console Google Cloud , attiva Cloud Shell.

Attiva Cloud Shell

Nella parte inferiore della console Google Cloud , viene avviata una sessione di Cloud Shell e viene visualizzato un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installata e con valori già impostati per il progetto corrente. L'inizializzazione della sessione può richiedere alcuni secondi.
Nell'ambiente di sviluppo, esegui il comando gcloud storage batch-operations jobs create:
```
gcloud storage batch-operations jobs create \
JOB_NAME \
{--bucket=SOURCE_BUCKET | --bucket-list=SOURCE_BUCKET_LIST} \
--manifest-location=URI \
JOB_TYPE_FLAG
```
Dove:
- JOB_NAME è il nome del job di operazioni batch di archiviazione.
- SOURCE_BUCKET è il nome del bucket che contiene gli oggetti da elaborare. Ad esempio, my-bucket.
- SOURCE_BUCKET_LIST è un elenco separato da virgole di uno o più nomi di bucket che contengono gli oggetti che vuoi elaborare. Ad esempio, bucket1,bucket2.
- URI è l'URI del bucket che contiene il manifest. Ad esempio, gs://bucket_name/path_to_csv_file/*.csv. Quando utilizzi il carattere jolly *.csv, BigQuery esporta il risultato in più file CSV.
- JOB_TYPE_FLAG è uno dei seguenti flag, a seconda del tipo di prestazione.
  - --delete-object: elimina uno o più oggetti.
  - --put-metadata: aggiorna i metadati dell'oggetto. I metadati dell'oggetto vengono archiviati come coppie chiave-valore. Specifica la coppia chiave-valore per i metadati che vuoi modificare. Puoi specificare una o più coppie chiave-valore come elenco. Puoi anche fornire configurazioni di conservazione degli oggetti utilizzando il flag --put-metadata.
  - --rewrite-object: aggiorna le chiavi di crittografia gestite dal cliente per uno o più oggetti. Puoi anche utilizzare questo flag per modificare la classe di archiviazione dell'oggetto specificando la chiave storage-class. Le classi di archiviazione supportate includono STANDARD, NEARLINE, COLDLINE e ARCHIVE. Ad esempio: --rewrite-object=storage-class=NEARLINE.
  - --set-object-acls-from-file: Applica patch agli elenchi di controllo dell'accesso (ACL) degli oggetti. Fornisci il percorso di un file JSON o YAML con le concessioni da aggiungere o aggiornare per entità come allUsers o allAuthenticatedUsers. Ad esempio: --set-object-acls-from-file=acl-updates.yaml.
  - --put-object-event-based-hold: abilita i blocchi oggetto basati su eventi.
  - --no-put-object-event-based-hold: disabilita Blocco di oggetti basato sugli eventi.
  - --put-object-temporary-hold: attiva i blocchi oggetto temporanei.
  - --no-put-object-temporary-hold: disattiva i blocchi di oggetti temporanei.
  - --clear-all-object-custom-contexts: elimina tutti i contesti degli oggetti esistenti.
    
    L'esempio seguente mostra come creare un job per cancellare tutti i contesti degli oggetti per gli oggetti elencati in manifest.csv:
```
gcloud storage batch-operations jobs create my-job \
--bucket=my-bucket \
--manifest-location=gs://my-bucket/manifest.csv \
--clear-all-object-custom-contexts
```
    Attenzione: se cancelli tutti i contesti degli oggetti, vengono eliminati tutti i contesti esistenti dell'oggetto. Per conservare i contesti degli oggetti precedenti, abilita Cloud Logging. I log contengono i contesti precedenti all'aggiornamento, che puoi utilizzare per ripristinare i valori precedenti.
  - --clear-object-custom-contexts: rimuovi i contesti con chiavi specifiche. Puoi anche aggiornare contesti specifici e rimuovere le chiavi utilizzando sia il flag --clear-object-custom-contexts sia uno dei seguenti flag:
    - --update-object-custom-contexts: fornisci una mappa di coppie chiave-valore.
      
      L'esempio seguente mostra come creare un job per rimuovere il contesto con la chiave temp-id e aggiornare o inserire il contesto con le chiavi project-id e cost-center per tutti gli oggetti elencati in manifest.csv:
      gcloud storage batch-operations jobs create my-job \ --bucket=my-bucket \ --manifest-location=gs://my-bucket/manifest.csv \ --clear-object-custom-contexts=temp-id \ --update-object-custom-contexts=project-id=project-A,cost-center=engineering
      Nota: non puoi specificare la stessa chiave sia nel flag --clear-object-custom-contexts che nel flag --update-object-custom-contexts. In questo modo viene generato un errore INVALID_ARGUMENT.
    - --update-object-custom-contexts-file: fornisci il percorso di un file JSON o YAML con coppie chiave-valore.
      
      L'esempio seguente mostra come creare un job per elaborare gli oggetti definiti in manifest.csv. Il job esegue le seguenti operazioni:
      - Rimuove tutti i contesti con la chiave temp-id.
      - Aggiorna i contesti esistenti con le chiavi project-id e cost-center definite nel file /tmp/context_updates.json.
      gcloud storage batch-operations jobs create my-job \ --bucket=my-bucket \ --manifest-location=gs://my-bucket/manifest.csv \ --clear-object-custom-contexts=temp-id \ --update-object-custom-contexts-file=/tmp/context_updates.json
      Dove /tmp/context_updates.json contiene i seguenti contesti dell'oggetto:
      { "project-id": {"value": "project-A"}, "cost-center": {"value": "engineering"} }

Integrazione con i Controlli di servizio VPC

I Controlli di servizio VPC forniscono un livello aggiuntivo di sicurezza per le risorse delle operazioni batch di archiviazione. Se inserisci i progetti all'interno di un perimetro di servizio, contribuisci a proteggere risorse e servizi da richieste provenienti dall'esterno del perimetro. Per saperne di più sui dettagli del perimetro di servizio dei Controlli di servizio VPC per le operazioni batch di archiviazione, consulta Prodotti supportati e limitazioni.

Utilizza Cloud Audit Logs per i job di operazioni batch di archiviazione

I job di operazioni batch di archiviazione registrano le trasformazioni sugli oggetti Cloud Storage in Cloud Audit Logs per Cloud Storage. Utilizza Cloud Audit Logs con Cloud Storage per monitorare queste trasformazioni. Per informazioni dettagliate su come attivare gli audit log, consulta Attivazione degli audit log. Nella voce di log di controllo, un campo dei metadati callUserAgent con il valore StorageBatchOperations indica che la trasformazione è stata eseguita dalle operazioni batch di archiviazione.

Passaggi successivi

Scopri di più sui set di dati Storage Insights

Crea e gestisci i job di operazioni batch Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Prima di iniziare

Configura Storage Intelligence

Abilita l'API per le operazioni batch di archiviazione

Crea un manifest

Crea un job di operazioni batch di archiviazione

Console

Riga di comando

Librerie client

C++

PHP

API JSON

Recupera i dettagli del job di operazioni batch di archiviazione

Console

Riga di comando

Librerie client

C++

PHP

API JSON

Elenca operazioni sui bucket

Descrivi un'operazione bucket

Elenca job di operazioni batch di archiviazione

Console

Riga di comando

Librerie client

C++

PHP

API JSON

Annulla un job di operazioni batch di archiviazione

Console

Riga di comando

Librerie client

C++

PHP

API JSON

Elimina un job di operazioni batch di archiviazione

Console

Riga di comando

Librerie client

C++

PHP

API JSON

Crea un job di operazioni batch di archiviazione utilizzando i set di dati Storage Insights

Utilizza i filtri avanzati

Riga di comando

API JSON

Utilizzare un file manifest

Creare un manifest utilizzando i set di dati Storage Insights

Crea un job di operazioni batch di archiviazione utilizzando un file manifest

Console

Riga di comando

Integrazione con i Controlli di servizio VPC

Utilizza Cloud Audit Logs per i job di operazioni batch di archiviazione

Passaggi successivi

Crea e gestisci i job di operazioni batch