

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Verifica dell’integrità degli oggetti per i dati a riposo in Amazon S3
<a name="checking-object-integrity-at-rest"></a>

Per verificare il contenuto dei set di dati archiviati in Amazon S3, l’operazione [Calcola il checksum](https://docs.aws.amazon.com//AmazonS3/latest/userguide/batch-ops-compute-checksums.html) di Operazioni in batch S3 calcola i checksum dell’oggetto completo o compositi per gli oggetti a riposo. L’operazione **Calcola il checksum** utilizza Operazioni in batch per calcolare in modo asincrono i valori di checksum per un gruppo di oggetti e genera automaticamente un report di integrità consolidato, senza creare nuove copie dei dati oppure ripristinare o scaricare dati.

Con l’operazione **Calcola il checksum**, puoi verificare in modo efficiente miliardi di oggetti con una singola richiesta di processo. Per ogni richiesta di processo **Calcola il checksum**, S3 calcola i valori di checksum e li include in un report di integrità generato automaticamente (noto anche come report di completamento). È quindi possibile utilizzare il report di completamento per convalidare l’integrità del set di dati.

L’operazione **Calcola il checksum** funziona con qualsiasi oggetto archiviato in S3, indipendentemente dalla classe di archiviazione o dalla dimensione dell’oggetto. Che sia necessario verificare gli oggetti come best practice di conservazione dei dati o soddisfare i requisiti di conformità, l’operazione **Calcola il checksum** riduce i costi, i tempi e le attività necessari per la convalida dei dati eseguendo calcoli di checksum a riposo. Per informazioni sui prezzi di **Calcola il checksum**, consulta la scheda **Gestione e approfondimenti** in [Prezzi di Amazon S3](https://aws.amazon.com/s3/pricing/).

Quindi, puoi utilizzare l’output del report di completamento generato per confrontarlo con i valori di checksum archiviati nei database per verificare che i set di dati rimangano intatti nel tempo. Questo approccio consente di mantenere l'integrità end-to-end dei dati per le esigenze aziendali e di conformità. Ad esempio, puoi utilizzare l’operazione **Calcola il checksum** per inviare un elenco di oggetti archiviati nelle classi di archiviazione S3 Glacier per i controlli di sicurezza annuali. Inoltre, la gamma di algoritmi di checksum supportati consente di mantenere la continuità con gli algoritmi utilizzati nelle applicazioni.

## Utilizzo di algoritmi di checksum supportati
<a name="using-additional-checksums-rest"></a>

Per i dati a riposo, è possibile calcolare i checksum utilizzando uno qualsiasi degli algoritmi di checksum supportati:
+ CRC-64/NVME (`CRC64NVME`): supporta solo il tipo di checksum dell’oggetto completo.
+ CRC-32 (`CRC32`): supporta il tipo di checksum dell’oggetto completo e composito.
+ CRC-32C (`CRC32C`): supporta il tipo di checksum dell’oggetto completo e composito.
+ SHA-1 (`SHA1`): supporta il tipo di checksum dell’oggetto completo e composito.
+ SHA-256 (`SHA256`): supporta il tipo di checksum dell’oggetto completo e composito.
+ MD5 (`MD5`): Supporta sia i tipi di checksum completi che quelli compositi.

## Utilizzo di **Calcola il checksum**
<a name="Compute-checksums"></a>

Per gli oggetti archiviati in Amazon S3, puoi utilizzare l’operazione **Calcola il checksum** con Operazioni in batch S3 per controllare il contenuto dei dati a riposo archiviati. Puoi [creare un processo Compute checksum Batch Operations](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-create-job.html) utilizzando la console Amazon S3, AWS Command Line Interface (AWS CLI), l'API REST o AWS l'SDK. Al termine del processo **Calcola il checksum**, si riceve un report di completamento. Per ulteriori informazioni su come utilizzare il report di completamento, consulta [Monitoraggio dei rapporti sullo stato e sul completamento dei processi](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-job-status.html).

Prima di creare il processo di **checksum di Compute**, devi creare un ruolo S3 Batch AWS Identity and Access Management Operations (IAM) per concedere ad Amazon S3 le autorizzazioni per eseguire azioni per tuo conto. È necessario fornire le autorizzazioni per leggere il file manifesto e scrivere un report di completamento nel bucket S3. Per ulteriori informazioni, consulta [Calcolo dei checksum](batch-ops-compute-checksums.md).

### Utilizzo della console S3
<a name="Compute-checksum-console"></a>

**Come utilizzare l’operazione **Calcola il checksum****

1. Accedi a Console di gestione AWS e apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)

1. Nella barra di navigazione nella parte superiore della pagina, scegli il nome del file attualmente visualizzato Regione AWS. Scegli la Regione in cui creare il processo.
**Nota**  
Per le operazioni di copia, è necessario creare il processo nella stessa Regione del bucket di destinazione. Per tutte le altre operazioni, è necessario creare il processo nella stessa Regione degli oggetti del manifesto.

1. Scegli **Operazioni in batch** nel pannello di navigazione sinistro della console Amazon S3.

1. Scegli **Crea processo**.

1. Visualizza Regione AWS dove vuoi creare il tuo lavoro.
**Nota**  
Per le operazioni di copia, è necessario creare il processo nella stessa Regione del bucket di destinazione. Per tutte le altre operazioni, è necessario creare il processo nella stessa Regione degli oggetti del manifesto.

1. In **Formato manifest** scegliere il tipo di oggetto manifest da usare.
   + Se scegli **Report di inventario S3 (manifest.json)**, inserisci il percorso dell’oggetto `manifest.json` e (facoltativamente) l’**ID versione dell’oggetto manifesto** se desideri utilizzare una versione dell’oggetto specifica. In alternativa, puoi scegliere **Sfoglia S3** e scegliere il file JSON manifesto, che popola automaticamente tutte le voci del campo dell’oggetto manifesto.
   + Se scegli **CSV**, scegli il tipo di posizione del manifesto, quindi inserisci il percorso di un oggetto manifesto in formato CSV o scegli **Sfoglia S3** per selezionare un oggetto manifesto. L'oggetto manifest deve avere il formato descritto nella console. Per utilizzare una versione specifica dell’oggetto manifesto, è anche possibile specificare l’ID versione dell’oggetto.
   + Se scegli **Crea manifesto utilizzando la configurazione di replica S3**, verrà generato un elenco di oggetti utilizzando la configurazione di replica e facoltativamente salvato nella destinazione scelta. Quando si utilizza una configurazione di replica per generare il manifesto, l’unica operazione disponibile è **Replica**.

1. Scegli **Next (Successivo)**.

1. In **Operazione**, scegli l’operazione **Calcola il checksum** per calcolare i checksum su tutti gli oggetti elencati nel manifesto. Scegli il **Tipo di checksum** e la **Funzione di checksum** per il processo. Quindi, seleziona **Successivo**.

1. Inserisci le informazioni per **Configura opzioni aggiuntive**, quindi scegli **Successivo**.

1. Nella pagina **Configura opzioni aggiuntive**, inserisci le informazioni relative al processo **Calcola il checksum**.
**Nota**  
Nella sezione **Report di completamento**, assicurati di confermare la dichiarazione di conferma. Questa dichiarazione conferma che hai compreso che il report di completamento contiene valori di checksum, che vengono utilizzati per verificare l’integrità dei dati archiviati in Amazon S3. Pertanto, il report di completamento deve essere condiviso con cautela. Inoltre, tieni presente che se stai creando una richiesta di checksum di Compute e specifichi la posizione del bucket del proprietario dell'account esterno per archiviare il rapporto di completamento, assicurati di specificare l' Account AWS ID del proprietario del bucket esterno.

1. Scegli **Next (Successivo)**.

1. Nella pagina **Esamina**, verifica e conferma le impostazioni.

1. (Facoltativo) Per apportare modifiche, scegli **Precedente** per tornare alla pagina precedente o scegli **Modifica** per aggiornare una fase specifica.

1. Dopo aver confermato le modifiche, scegli **Crea processo**.

**Come elencare e monitorare l’avanzamento di tutte le richieste **Calcola il checksum****

1. Accedi a Console di gestione AWS e apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)

1. Nel pannello di navigazione a sinistra, scegli **Operazioni in batch**.

1. Nella pagina **Operazioni in batch**, è possibile esaminare i dettagli del processo come la priorità del processo, la percentuale di completamento del processo e gli oggetti totali.

1. Se desideri gestire o clonare uno specifico processo **Calcola il checksum**, fai clic sull’**ID processo** per visualizzare ulteriori informazioni sul processo.

1. Nella pagina dello specifico processo **Calcola il checksum**, esamina i dettagli del processo.

Ogni processo di operazione in batch passa attraverso diversi [stati di processo](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-job-status.html#batch-ops-job-status-table). È anche possibile [abilitare gli eventi AWS CloudTrail](https://docs.aws.amazon.com/AmazonS3/latest/userguide/enable-cloudtrail-logging-for-s3.html) nella console S3 per ricevere avvisi su qualsiasi modifica dello stato del processo. Per i processi attivi, puoi esaminare il processo in esecuzione e la percentuale di completamento nella pagina dei **Dettagli processo**.

### Usando il AWS SDKs
<a name="Compute-checksum-sdk"></a>

------
#### [ Java ]

**Example Esempio: creare un processo **Calcola il checksum****  
L’esempio seguente mostra come creare un processo **Calcola il checksum** (come parte di una richiesta **Crea processo**) e come specificare un manifesto:  

```
// Required parameters
String accountId = "111122223333";
String roleArn = "arn:aws:iam::111122223333:role/BatchOperations";
String manifestArn = "arn:aws:s3:::my_manifests/manifest.csv";
String manifestEtag = "60e460c9d1046e73f7dde5043ac3ae85";
String reportBucketArn = "arn:aws:s3:::amzn-s3-demo-completion-report-bucket";
String reportExpectedBucketOwner = "111122223333";
String reportPrefix = "demo-report";

// Job Operation
S3ComputeObjectChecksumOperation s3ComputeObjectChecksum = S3ComputeObjectChecksumOperation.builder()
    .checksumAlgorithm(ComputeObjectChecksumAlgorithm.CRC64)
    .checksumType(ComputeObjectChecksumType.COMPOSITE)
    .build();

JobOperation operation = JobOperation.builder()
    .s3ComputeObjectChecksum(s3ComputeObjectChecksum)
    .build();

// Job Manifest
JobManifestLocation location = JobManifestLocation.builder()
    .eTag(manifestEtag)
    .objectArn(manifestArn)
    .build();

JobManifestSpec spec = JobManifestSpec.builder()
    .format(JobManifestFormat.S3_BATCH_OPERATIONS_CSV_20180820)
    .fields(Arrays.asList(JobManifestFieldName.BUCKET, JobManifestFieldName.KEY))
    .build();

JobManifest manifest = JobManifest.builder()
    .location(location)
    .spec(spec)
    .build();

// Completion Report
JobReport report = JobReport.builder()
    .bucket(reportBucketArn)
    .enabled(true) // Must be true
    .expectedBucketOwner(reportExpectedBucketOwner)
    .format(JobReportFormat.REPORT_CSV_20180820)
    .prefix(reportPrefix)
    .reportScope(JobReportScope.ALL_TASKS)
    .build();

// Create Job Request
CreateJobRequest request = CreateJobRequest.builder()
    .accountId(accountId)
    .confirmationRequired(false)
    .manifest(manifest)
    .operation(operation)
    .priority(10)
    .report(report)
    .roleArn(roleArn);

// Create the client
S3ControlClient client = S3ControlClient.builder()
    .credentialsProvider(new ProfileCredentialsProvider())
    .region(Region.US_EAST_1)
    .build();

// Send the request
try {
    CreateJobResponse response = client.createJob(request);
    System.out.println(response);    
} catch (AwsServiceException e) {
    System.out.println("AwsServiceException: " + e.getMessage());
    throw new RuntimeException(e);
} catch (SdkClientException e) {
    System.out.println("SdkClientException: " + e.getMessage());
    throw new RuntimeException(e);
}
```

**Example Esempio: visualizzare i dettagli del processo **Calcola il checksum****  
L’esempio seguente mostra come specificare un ID di processo per visualizzare i dettagli del processo (come la percentuale di completamento del processo) per una richiesta di processo **Calcola il checksum**:  

```
DescribeJobRequest request = DescribeJobRequest.builder()
        .accountId("1234567890")
        .jobId("a16217a1-e082-48e5-b04f-31fac3a66b13")
        .build();
```

------

### Utilizzando il AWS CLI
<a name="Compute-checksum-cli"></a>

È possibile utilizzare il comando [https://docs.aws.amazon.com/cli/latest/reference/s3control/create-job.html](https://docs.aws.amazon.com/cli/latest/reference/s3control/create-job.html) per creare un nuovo processo di operazioni in batch e fornire l’elenco di oggetti. Quindi, specifica l’algoritmo di checksum e il tipo di checksum, nonché il bucket di destinazione in cui desideri salvare il report **Calcola il checksum**. L'esempio seguente crea un processo di **checksum di S3 Batch Operations Compute** utilizzando un manifesto generato da S3 per. Account AWS *111122223333*

Per utilizzare questo comando, sostituiscilo *user input placeholders* con le tue informazioni:

```
aws s3control create-job \
    --account-id 111122223333 \
    --manifest '{"Spec":{"Format":"S3BatchOperations_CSV_20180820","Fields":["Bucket","Key"]},"Location":{"ObjectArn":"arn:aws:s3:::my-manifest-bucket/manifest.csv","ETag":"e0e8bfc50e0f0c5d5a1a5f0e0e8bfc50"}}' \
    --manifest-generator '{
        "S3JobManifestGenerator": {
          "ExpectedBucketOwner": "111122223333",
          "SourceBucket": "arn:aws:s3:::amzn-s3-demo-source-bucket",
          "EnableManifestOutput": true,
          "ManifestOutputLocation": {
            "ExpectedManifestBucketOwner": "111122223333",
            "Bucket": "arn:aws:s3:::amzn-s3-demo-manifest-bucket",
            "ManifestPrefix": "prefix",
            "ManifestFormat": "S3InventoryReport_CSV_20211130"
          },
          "Filter": {
            "CreatedAfter": "2023-09-01",
            "CreatedBefore": "2023-10-01",
            "KeyNameConstraint": {
              "MatchAnyPrefix": [
                "prefix"
              ],
              "MatchAnySuffix": [
                "suffix"
              ]
            },
            "ObjectSizeGreaterThanBytes": 100,
            "ObjectSizeLessThanBytes": 200,
            "MatchAnyStorageClass": [
              "STANDARD",
              "STANDARD_IA"
            ]
          }
        }
      }' \
    --operation '{"S3ComputeObjectChecksum":{"ChecksumAlgorithm":"CRC64NVME","ChecksumType":"FULL_OBJECT"}}' \
    --report '{"Bucket":"arn:aws:s3:::my-report-bucket","Format":"Report_CSV_20180820","Enabled":true,"Prefix":"batch-op-reports/","ReportScope":"AllTasks","ExpectedBucketOwner":"111122223333"}' \
    --priority 10 \
    --role-arn arn:aws:iam::123456789012:role/S3BatchJobRole \
    --client-request-token 6e023a7e-4820-4654-8c81-7247361aeb73 \
    --description "Compute object checksums" \
    --region us-west-2
```

Dopo aver inviato il processo **Calcola il checksum**, ricevi l’ID del processo come risposta e viene visualizzato nella pagina elenco Operazioni in batch S3. Amazon S3 elabora l’elenco di oggetti e calcola i checksum per ogni oggetto. Al termine del processo, S3 fornisce un report **Calcola il checksum** consolidato nella destinazione specificata.

Per monitorare l’avanzamento del processo **Calcola il checksum**, utilizza il comando [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3control/describe-job.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3control/describe-job.html). Questo comando controlla lo stato del processo di operazioni in batch specificato. Per utilizzare questo comando, sostituisci *user input placeholders* con le informazioni appropriate.

Esempio:

```
aws s3control describe-job --account-id 111122223333 --job-id 1234567890abcdef0
```

Per [ottenere un elenco](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-list-jobs.html) di tutti i processi di operazioni in batch **attivi** e **completi**, consulta [Elenco di processi](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-list-jobs.html) o [list-jobs](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3control/list-jobs.html) nella *documentazione di riferimento dei comandi della AWS CLI *.

### Utilizzo della REST API
<a name="Compute-checksum-api"></a>

Puoi inviare richieste REST per verificare l'integrità dell'oggetto con **Compute checksum** utilizzando. [CreateJob](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_CreateJob.html) Puoi monitorare l'avanzamento delle richieste di **checksum di Compute** inviando richieste REST all'operazione API. [DescribeJob](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_DescribeJob.html) Ogni processo di operazioni in batch passa attraverso i seguenti stati:
+ **NUOVO**
+ **PREPARAZIONE**
+ **PRONTO**
+ **ACTIVE**
+ **PAUSA IN CORSO**
+ **IN PAUSA**
+ **COMPLETO**
+ **ANNULLAMENTO**
+ **Non riuscito**

La risposta dell’API ti comunica lo stato corrente del processo.