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

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, che include gli algoritmi supportati.

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.

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

Caricamento di un oggetto

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

Utilizza un valore di checksum precalcolato

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

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'S3ClientAPI (o l'S3AsyncClientAPI) 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 si trova nel repository degli esempi di GitHub codice.

Donwload di un oggetto

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();
    }

Altre opzioni di calcolo del checksum

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

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.

LegacyMd5Plugin MD5 Utilizza il per una compatibilità semplificata

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'LegacyMd5PluginSDK.

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