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à.

# Protezione dell'integrità dei dati con checksum
<a name="s3-checksums"></a>

Amazon Simple Storage Service (Amazon S3) Simple Storage Service (Amazon S3) offre la possibilità di specificare un checksum quando carichi un oggetto. Quando specifichi un checksum, questo viene memorizzato con l'oggetto e può essere convalidato quando l'oggetto viene scaricato.

I checksum forniscono un ulteriore livello di integrità dei dati durante il trasferimento dei file. Con i checksum, è possibile verificare la coerenza dei dati confermando che il file ricevuto corrisponde al file originale. [Per ulteriori informazioni sui checksum con Amazon S3, consulta la Guida per l'[utente di Amazon Simple Storage Service](https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html), che include gli algoritmi supportati.](https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#using-additional-checksums)

Hai la flessibilità di scegliere l'algoritmo più adatto alle tue esigenze e lasciare che sia l'SDK a calcolare il checksum. In alternativa, puoi fornire un valore di checksum precalcolato utilizzando uno degli algoritmi supportati. 

**Nota**  
A partire dalla versione 2.30.0 di AWS SDK for Java 2.x, l'SDK fornisce protezioni di integrità predefinite calcolando automaticamente un checksum per i caricamenti. `CRC32` L'SDK calcola questo checksum se non fornisci un valore di checksum precalcolato o se non specifichi un algoritmo che l'SDK deve utilizzare per calcolare un checksum.   
[L'SDK fornisce anche impostazioni globali per la protezione dell'integrità dei dati che puoi impostare esternamente, come puoi leggere nella Guida di riferimento agli strumenti.AWS SDKs ](https://docs.aws.amazon.com/sdkref/latest/guide/feature-dataintegrity.html)

Discutiamo i checksum in due fasi di richiesta: caricamento di un oggetto e download di un oggetto. 

## Caricamento di un oggetto
<a name="use-service-S3-checksum-upload"></a>

 Quando caricate un oggetto con il `putObject` metodo e fornite un algoritmo di checksum, l'SDK calcola il checksum per l'algoritmo specificato. 

Il seguente frammento di codice mostra una richiesta di caricamento di un oggetto con un checksum. `SHA256` Quando l'SDK invia la richiesta, calcola il `SHA256` checksum e carica l'oggetto. Amazon S3 convalida l'integrità del contenuto calcolando il checksum e confrontandolo con il checksum fornito dall'SDK. Amazon S3 memorizza quindi il checksum con l'oggetto.

```
public void putObjectWithChecksum() {
        s3Client.putObject(b -> b
                .bucket(bucketName)
                .key(key)
                .checksumAlgorithm(ChecksumAlgorithm.SHA256),
            RequestBody.fromString("This is a test"));
}
```

Se non fornisci un algoritmo di checksum con la richiesta, il comportamento del checksum varia a seconda della versione dell'SDK che usi, come mostrato nella tabella seguente.

**Comportamento del checksum quando non viene fornito alcun algoritmo di checksum**


| Versione Java SDK | Comportamento del checksum | 
| --- | --- | 
| precedente alla 2.30.0 | L'SDK non calcola automaticamente un checksum basato su CRC e lo fornisce nella richiesta. | 
| 2.30.0 o versione successiva | L'SDK utilizza l'`CRC32`algoritmo per calcolare il checksum e lo fornisce nella richiesta. Amazon S3 convalida l'integrità del trasferimento calcolando il proprio `CRC32` checksum e lo confronta con il checksum fornito dall'SDK. Se i checksum corrispondono, il checksum viene salvato con l'oggetto. | 

### Utilizza un valore di checksum precalcolato
<a name="use-service-S3-checksum-upload-pre"></a>

Un valore di checksum precalcolato fornito con la richiesta disabilita il calcolo automatico da parte dell'SDK e utilizza invece il valore fornito.

L'esempio seguente mostra una richiesta con un checksum precalcolato. SHA256

```
    public void putObjectWithPrecalculatedChecksum(String filePath) {
        String checksum = calculateChecksum(filePath, "SHA-256");

        s3Client.putObject((b -> b
                .bucket(bucketName)
                .key(key)
                .checksumSHA256(checksum)),
            RequestBody.fromFile(Paths.get(filePath)));
    }
```

Se Amazon S3 determina che il valore del checksum non è corretto per l'algoritmo specificato, il servizio restituisce una risposta di errore.

### Caricamenti in più parti
<a name="use-service-S3-checksum-upload-multi"></a>

Puoi anche utilizzare i checksum con caricamenti in più parti.

 L'SDK for Java 2.x offre due opzioni per utilizzare i checksum con caricamenti multiparte. La prima opzione utilizza il. `S3TransferManager` 

Il seguente esempio di gestore di trasferimento specifica l' SHA1 algoritmo per il caricamento.

```
    public void multipartUploadWithChecksumTm(String filePath) {
        S3TransferManager transferManager = S3TransferManager.create();
        UploadFileRequest uploadFileRequest = UploadFileRequest.builder()
            .putObjectRequest(b -> b
                .bucket(bucketName)
                .key(key)
                .checksumAlgorithm(ChecksumAlgorithm.SHA1))
            .source(Paths.get(filePath))
            .build();
        FileUpload fileUpload = transferManager.uploadFile(uploadFileRequest);
        fileUpload.completionFuture().join();
        transferManager.close();
    }
```

Se non fornite un algoritmo di checksum quando utilizzate il gestore di trasferimento per i caricamenti, l'SDK calcola automaticamente un checksum in base all'algoritmo. `CRC32` L'SDK esegue questo calcolo per tutte le versioni dell'SDK.

La seconda opzione utilizza l'[`S3Client`API](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html) (o l'[`S3AsyncClient`API](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClient.html)) per eseguire il caricamento in più parti. Se si specifica un checksum con questo approccio, è necessario specificare l'algoritmo da utilizzare all'avvio del caricamento. Inoltre, devi specificare l’algoritmo per ogni richiesta parte e fornire il checksum calcolato per ciascuna parte dopo che è stata caricata.

```
    public void multipartUploadWithChecksumS3Client(String filePath) {
        ChecksumAlgorithm algorithm = ChecksumAlgorithm.CRC32;

        // Initiate the multipart upload.
        CreateMultipartUploadResponse createMultipartUploadResponse = s3Client.createMultipartUpload(b -> b
            .bucket(bucketName)
            .key(key)
            .checksumAlgorithm(algorithm)); // Checksum specified on initiation.
        String uploadId = createMultipartUploadResponse.uploadId();

        // Upload the parts of the file.
        int partNumber = 1;
        List<CompletedPart> completedParts = new ArrayList<>();
        ByteBuffer bb = ByteBuffer.allocate(1024 * 1024 * 5); // 5 MB byte buffer

        try (RandomAccessFile file = new RandomAccessFile(filePath, "r")) {
            long fileSize = file.length();
            long position = 0;
            while (position < fileSize) {
                file.seek(position);
                long read = file.getChannel().read(bb);

                bb.flip(); // Swap position and limit before reading from the buffer.
                UploadPartRequest uploadPartRequest = UploadPartRequest.builder()
                    .bucket(bucketName)
                    .key(key)
                    .uploadId(uploadId)
                    .checksumAlgorithm(algorithm) // Checksum specified on each part.
                    .partNumber(partNumber)
                    .build();

                UploadPartResponse partResponse = s3Client.uploadPart(
                    uploadPartRequest,
                    RequestBody.fromByteBuffer(bb));

                CompletedPart part = CompletedPart.builder()
                    .partNumber(partNumber)
                    .checksumCRC32(partResponse.checksumCRC32()) // Provide the calculated checksum.
                    .eTag(partResponse.eTag())
                    .build();
                completedParts.add(part);

                bb.clear();
                position += read;
                partNumber++;
            }
        } catch (IOException e) {
            System.err.println(e.getMessage());
        }

        // Complete the multipart upload.
        s3Client.completeMultipartUpload(b -> b
            .bucket(bucketName)
            .key(key)
            .uploadId(uploadId)
            .multipartUpload(CompletedMultipartUpload.builder().parts(completedParts).build()));
    }
```

Il [codice per gli esempi e i test completi](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javav2/example_code/s3/src/main/java/com/example/s3/PerformMultiPartUpload.java) [si trova](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javav2/example_code/s3/src/test/java/com/example/s3/PerformMultiPartUploadTests.java) nel repository degli esempi di GitHub codice.

## Donwload di un oggetto
<a name="use-service-S3-checksum-download"></a>

 quando il `checksumMode` metodo del builder for the è impostato su. `GetObjectRequest` `ChecksumMode.ENABLED` 

La richiesta nel seguente frammento indica all'SDK di convalidare il checksum nella risposta calcolando il checksum e confrontando i valori.

```
    public GetObjectResponse getObjectWithChecksum() {
        return s3Client.getObject(b -> b
                        .bucket(bucketName)
                        .key(key)
                        .checksumMode(ChecksumMode.ENABLED))
                .response();
    }
```

**Nota**  
Se l'oggetto non è stato caricato con un checksum, non viene effettuata alcuna convalida. 

## Altre opzioni di calcolo del checksum
<a name="S3-checsum-calculation-options"></a>

**Nota**  
Per verificare l'integrità dei dati trasmessi e identificare eventuali errori di trasmissione, incoraggiamo gli utenti a mantenere le impostazioni predefinite dell'SDK per le opzioni di calcolo del checksum. Per impostazione predefinita, l'SDK aggiunge questo importante controllo per molte operazioni S3, tra cui e. `PutObject` `GetObject`

Se l'uso di Amazon S3 richiede una convalida minima dei checksum, tuttavia, puoi disabilitare molti controlli modificando le impostazioni di configurazione predefinite. 

### Disattiva il calcolo automatico del checksum a meno che non sia necessario
<a name="S3-minimize-checksum-calc-global"></a>

Puoi disabilitare il calcolo automatico del checksum da parte dell'SDK per le operazioni che lo supportano, ad esempio e. `PutObject` `GetObject` Alcune operazioni di S3, tuttavia, richiedono un calcolo del checksum; non è possibile disabilitare il calcolo del checksum per queste operazioni.

L'SDK fornisce impostazioni separate per il calcolo di un checksum per il payload di una richiesta e per il payload di una risposta.

L'elenco seguente descrive le impostazioni che è possibile utilizzare per ridurre al minimo i calcoli di checksum nei diversi ambiti.
+ **Ambito di tutte le applicazioni**: modificando le impostazioni nelle variabili di ambiente o in un profilo negli archivi condivisi AWS `config` e nei `credentials` file, tutte le applicazioni possono utilizzare queste impostazioni. Queste impostazioni influiscono su tutti i client di servizio in tutte le applicazioni AWS SDK, a meno che non vengano sostituite nell'ambito dell'applicazione o del client di servizio.
  + Aggiungi le impostazioni in un profilo:

    ```
    [default]
    request_checksum_calculation = WHEN_REQUIRED
    response_checksum_validation = WHEN_REQUIRED
    ```
  + Aggiungi variabili di ambiente:

    ```
    AWS_REQUEST_CHECKSUM_CALCULATION=WHEN_REQUIRED
    AWS_RESPONSE_CHECKSUM_VALIDATION=WHEN_REQUIRED
    ```
+ **Ambito dell'applicazione corrente**: è possibile impostare la proprietà del sistema Java `aws.requestChecksumCalculation` su per `WHEN_REQUIRED` limitare il calcolo del checksum. La proprietà di sistema corrispondente per le risposte è. `aws.responseChecksumValidation`

  Queste impostazioni influiscono su tutti i client di servizio SDK nell'applicazione, a meno che non vengano sostituite durante la creazione del client di servizio.

  Imposta la proprietà del sistema all'avvio dell'applicazione:

  ```
  import software.amazon.awssdk.core.SdkSystemSetting;
  import software.amazon.awssdk.core.checksums.RequestChecksumCalculation;
  import software.amazon.awssdk.core.checksums.ResponseChecksumValidation;
  import software.amazon.awssdk.services.s3.S3Client;
  
  class DemoClass {
      public static void main(String[] args) {
  
          System.setProperty(SdkSystemSetting.AWS_REQUEST_CHECKSUM_CALCULATION.property(), // Resolves to "aws.requestChecksumCalculation".
                  "WHEN_REQUIRED");
          System.setProperty(SdkSystemSetting.AWS_RESPONSE_CHECKSUM_VALIDATION.property(), // Resolves to "aws.responseChecksumValidation".
                  "WHEN_REQUIRED");
  
          S3Client s3Client = S3Client.builder().build();
  
          // Use s3Client.
      }
  }
  ```
+ **Ambito del client di servizio S3 singolo**: puoi configurare un singolo client di servizio S3 per calcolare la quantità minima di checksum utilizzando i metodi builder:

  ```
  import software.amazon.awssdk.core.checksums.RequestChecksumCalculation;
  import software.amazon.awssdk.services.s3.S3Client;
  
  public class RequiredChecksums {
      public static void main(String[] args) {
          S3Client s3 = S3Client.builder()
                  .requestChecksumCalculation(RequestChecksumCalculation.WHEN_REQUIRED)
                  .responseChecksumValidation(ResponseChecksumValidation.WHEN_REQUIRED)
                  .build();
  
          // Use s3Client. 
      }
  // ...
  }
  ```

### `LegacyMd5Plugin` MD5 Utilizza il per una compatibilità semplificata
<a name="S3-checksum-legacy-md5"></a>

Oltre al rilascio del comportamento dei CRC32 checksum con la versione 2.30.0, l'SDK ha interrotto il calcolo MD5 dei checksum sulle operazioni richieste.

Se hai bisogno di un comportamento di MD5 checksum precedente per le operazioni S3, puoi utilizzare la, che è stata rilasciata con la versione 2.31.32 dell'`LegacyMd5Plugin`SDK.

`LegacyMd5Plugin`È particolarmente utile quando è necessario mantenere la compatibilità con le applicazioni che dipendono dal comportamento dei MD5 checksum precedenti, specialmente quando si lavora con provider di storage di terze parti compatibili con S3, come quelli utilizzati con i connettori di file system S3A (Apache Spark, Iceberg).

Per utilizzarlo, aggiungilo al tuo client builder S3: `LegacyMd5Plugin`

```
// For synchronous S3 client.
S3Client s3Client = S3Client.builder()
                           .addPlugin(LegacyMd5Plugin.create())
                           .build();

// For asynchronous S3 client.
S3AsyncClient asyncClient = S3AsyncClient.builder()
                                       .addPlugin(LegacyMd5Plugin.create())
                                       .build();
```

Se desideri aggiungere MD5 checksum alle operazioni che richiedono checksum e vuoi saltare l'aggiunta di checksum SDK predefiniti per operazioni che supportano i checksum ma non sono obbligatorie, puoi abilitare le opzioni e as. `ClientBuilder` `requestChecksumCalculation` `responseChecksumValidation` `WHEN_REQUIRED` Questo aggiungerà i checksum predefiniti dell'SDK solo alle operazioni che richiedono i checksum:

```
// Use the `LegacyMd5Plugin` with `requestChecksumCalculation` and `responseChecksumValidation` set to WHEN_REQUIRED.
S3AsyncClient asyncClient = S3AsyncClient.builder()
                                       .addPlugin(LegacyMd5Plugin.create())
                                       .requestChecksumCalculation(RequestChecksumCalculation.WHEN_REQUIRED)
                                       .responseChecksumValidation(ResponseChecksumValidation.WHEN_REQUIRED)
                                       .build();
```

Questa configurazione è particolarmente utile quando si lavora con sistemi di storage di terze parti compatibili con S3 che potrebbero non supportare completamente i nuovi algoritmi di checksum ma che richiedono comunque i checksum per determinate operazioni. MD5