Comprobación de la integridad de objetos

Amazon S3 utiliza valores de suma de comprobación para verificar la integridad de los datos que carga o descarga de Amazon S3. Además, puede solicitar que se calcule otro valor de suma de comprobación para cualquier objeto que almacene en Amazon S3. Puede seleccionar uno de los varios algoritmos de suma de comprobación que se utilizarán al cargar o copiar los datos. Amazon S3 utiliza este algoritmo para calcular un valor de suma de comprobación adicional y almacenarlo como parte de los metadatos del objeto. Para obtener más información sobre cómo utilizar sumas de comprobación adicionales para verificar la integridad de los datos, consulte el Tutorial: Checking the integrity of data in Amazon S3 with additional checksums (Comprobación de la integridad de los datos en Amazon S3 con sumas de comprobación adicionales).

Al cargar un objeto, puede incluir opcionalmente una suma de comprobación precalculada como parte de la solicitud. Amazon S3 compara la suma de comprobación proporcionada con la suma de comprobación que calcula mediante el algoritmo especificado. Si los valores no coinciden, Amazon S3 genera un error.

Uso de algoritmos de suma de comprobación admitidos

Amazon S3 le ofrece la opción de elegir el algoritmo de suma de comprobación que se utiliza para validar los datos durante la carga o descarga. Puede seleccionar uno de los siguientes algoritmos de comprobación de integridad de datos Secure Hash Algoritms (SHA) o Cyclic Redundancy Check (CRC):

• CRC-32

• CRC-32C

• SHA-1

• SHA-256

Al cargar un objeto, puede especificar el algoritmo que desea utilizar:

• Cuando utilice el campo AWS Management Console, seleccione el algoritmo de suma de comprobación que desee utilizar. Cuando lo haga, puede especificar opcionalmente el valor de la suma de comprobación del objeto. Cuando Amazon S3 recibe el objeto, calcula la suma de comprobación mediante el algoritmo especificado. Si los valores de la suma de comprobación no coinciden, Amazon S3 genera un error.

• Cuando se utiliza un SDK, se puede establecer el valor del parámetro ChecksumAlgorithm en el algoritmo que desea que Amazon S3 utilice al calcular la suma de comprobación. Amazon S3 calcula automáticamente el valor de la suma de comprobación.

• Si utiliza la API de REST, no utilice el parámetro x-amz-sdk-checksum-algorithm. En su lugar, utilice uno de los encabezados específicos del algoritmo (por ejemplo, x-amz-checksum-crc32).

Para obtener más información acerca de la carga de objetos, consulte Carga de objetos.

Para aplicar cualquiera de estos valores de suma de comprobación a objetos que ya se han cargado en Amazon S3, puede copiar el objeto. Al copiar un objeto, puede especificar si desea utilizar el algoritmo de suma de comprobación existente o utilizar uno nuevo. Puede especificar un algoritmo de suma de comprobación cuando utilice cualquier mecanismo admitido para copiar objetos, incluidas las operaciones por lotes de S3. Para obtener más información sobre la herramienta de operaciones por lotes de S3, consulte Realización de operaciones por lotes a gran escala en objetos de Amazon S3.

importante

Si utiliza una carga multiparte con sumas de comprobación adicionales, los números de partes multiparte deben ser consecutivos. Al utilizar sumas de comprobación adicionales, si intenta completar una solicitud de carga multiparte con números de parte no consecutivos, Amazon S3 genera un error 500 Internal Server Error de HTTP.

Después de cargar objetos, puede obtener el valor de la suma de comprobación y compararlo con un valor de suma de comprobación precalculado o almacenado previamente que se ha calculado utilizando el mismo algoritmo.

Uso de la consola de S3

Para obtener más información sobre el uso de la consola y la especificación de los algoritmos de suma de comprobación que se utilizan al cargar objetos, consulte Carga de objetos y el Tutorial: Comprobación de la integridad de los datos en Amazon S3 con sumas de comprobación adicionales.

Uso de los SDK de AWS

En el siguiente ejemplo, se muestra cómo se pueden utilizar los SDK de AWS para cargar un archivo grande con carga multiparte, descargar un archivo grande y validar un archivo de carga multiparte, todo con SHA-256 para la validación de archivos.

Java

ejemplo Ejemplo: carga, descarga y verificación de un archivo grande con SHA-256

Para obtener instrucciones sobre cómo crear y probar una muestra funcional, consulte Introducción en la Guía del desarrollador de AWS SDK for Java.

    import software.amazon.awssdk.auth.credentials.AwsCredentials;
    import software.amazon.awssdk.auth.credentials.AwsCredentialsProvider;
    import software.amazon.awssdk.core.ResponseInputStream;
    import software.amazon.awssdk.core.sync.RequestBody;
    import software.amazon.awssdk.regions.Region;
    import software.amazon.awssdk.services.s3.S3Client;
    import software.amazon.awssdk.services.s3.model.AbortMultipartUploadRequest;
    import software.amazon.awssdk.services.s3.model.ChecksumAlgorithm;
    import software.amazon.awssdk.services.s3.model.ChecksumMode;
    import software.amazon.awssdk.services.s3.model.CompleteMultipartUploadRequest;
    import software.amazon.awssdk.services.s3.model.CompleteMultipartUploadResponse;
    import software.amazon.awssdk.services.s3.model.CompletedMultipartUpload;
    import software.amazon.awssdk.services.s3.model.CompletedPart;
    import software.amazon.awssdk.services.s3.model.CreateMultipartUploadRequest;
    import software.amazon.awssdk.services.s3.model.CreateMultipartUploadResponse;
    import software.amazon.awssdk.services.s3.model.GetObjectAttributesRequest;
    import software.amazon.awssdk.services.s3.model.GetObjectAttributesResponse;
    import software.amazon.awssdk.services.s3.model.GetObjectRequest;
    import software.amazon.awssdk.services.s3.model.GetObjectResponse;
    import software.amazon.awssdk.services.s3.model.GetObjectTaggingRequest;
    import software.amazon.awssdk.services.s3.model.ObjectAttributes;
    import software.amazon.awssdk.services.s3.model.PutObjectTaggingRequest;
    import software.amazon.awssdk.services.s3.model.Tag;
    import software.amazon.awssdk.services.s3.model.Tagging;
    import software.amazon.awssdk.services.s3.model.UploadPartRequest;
    import software.amazon.awssdk.services.s3.model.UploadPartResponse;
     
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.nio.ByteBuffer;
    import java.security.MessageDigest;
    import java.security.NoSuchAlgorithmException;
    import java.util.ArrayList;
    import java.util.Base64;
    import java.util.List;
     
    public class LargeObjectValidation {
        private static String FILE_NAME = "sample.file";
        private static String BUCKET = "sample-bucket";
        //Optional, if you want a method of storing the full multipart object checksum in S3.
        private static String CHECKSUM_TAG_KEYNAME = "fullObjectChecksum";
        //If you have existing full-object checksums that you need to validate against, you can do the full object validation on a sequential upload.
        private static String SHA256_FILE_BYTES = "htCM5g7ZNdoSw8bN/mkgiAhXt5MFoVowVg+LE9aIQmI=";
        //Example Chunk Size - this must be greater than or equal to 5MB.
        private static int CHUNK_SIZE = 5 * 1024 * 1024;
     
        public static void main(String[] args) {
            S3Client s3Client = S3Client.builder()
                    .region(Region.US_EAST_1)
                    .credentialsProvider(new AwsCredentialsProvider() {
                        @Override
                        public AwsCredentials resolveCredentials() {
                            return new AwsCredentials() {
                                @Override
                                public String accessKeyId() {
                                    return Constants.ACCESS_KEY;
                                }
     
                                @Override
                                public String secretAccessKey() {
                                    return Constants.SECRET;
                                }
                            };
                        }
                    })
                    .build();
            uploadLargeFileBracketedByChecksum(s3Client);
            downloadLargeFileBracketedByChecksum(s3Client);
            validateExistingFileAgainstS3Checksum(s3Client);
        }
     
        public static void uploadLargeFileBracketedByChecksum(S3Client s3Client) {
            System.out.println("Starting uploading file validation");
            File file = new File(FILE_NAME);
            try (InputStream in = new FileInputStream(file)) {
                MessageDigest sha256 = MessageDigest.getInstance("SHA-256");
                CreateMultipartUploadRequest createMultipartUploadRequest = CreateMultipartUploadRequest.builder()
                        .bucket(BUCKET)
                        .key(FILE_NAME)
                        .checksumAlgorithm(ChecksumAlgorithm.SHA256)
                        .build();
                CreateMultipartUploadResponse createdUpload = s3Client.createMultipartUpload(createMultipartUploadRequest);
                List<CompletedPart> completedParts = new ArrayList<CompletedPart>();
                int partNumber = 1;
                byte[] buffer = new byte[CHUNK_SIZE];
                int read = in.read(buffer);
                while (read != -1) {
                    UploadPartRequest uploadPartRequest = UploadPartRequest.builder()
                            .partNumber(partNumber).uploadId(createdUpload.uploadId()).key(FILE_NAME).bucket(BUCKET).checksumAlgorithm(ChecksumAlgorithm.SHA256).build();
                    UploadPartResponse uploadedPart = s3Client.uploadPart(uploadPartRequest, RequestBody.fromByteBuffer(ByteBuffer.wrap(buffer, 0, read)));
                    CompletedPart part = CompletedPart.builder().partNumber(partNumber).checksumSHA256(uploadedPart.checksumSHA256()).eTag(uploadedPart.eTag()).build();
                    completedParts.add(part);
                    sha256.update(buffer, 0, read);
                    read = in.read(buffer);
                    partNumber++;
                }
                String fullObjectChecksum = Base64.getEncoder().encodeToString(sha256.digest());
                if (!fullObjectChecksum.equals(SHA256_FILE_BYTES)) {
                    //Because the SHA256 is uploaded after the part is uploaded; the upload is bracketed and the full object can be fully validated.
                    s3Client.abortMultipartUpload(AbortMultipartUploadRequest.builder().bucket(BUCKET).key(FILE_NAME).uploadId(createdUpload.uploadId()).build());
                    throw new IOException("Byte mismatch between stored checksum and upload, do not proceed with upload and cleanup");
                }
                CompletedMultipartUpload completedMultipartUpload = CompletedMultipartUpload.builder().parts(completedParts).build();
                CompleteMultipartUploadResponse completedUploadResponse = s3Client.completeMultipartUpload(
                        CompleteMultipartUploadRequest.builder().bucket(BUCKET).key(FILE_NAME).uploadId(createdUpload.uploadId()).multipartUpload(completedMultipartUpload).build());
                Tag checksumTag = Tag.builder().key(CHECKSUM_TAG_KEYNAME).value(fullObjectChecksum).build();
                //Optionally, if you need the full object checksum stored with the file; you could add it as a tag after completion.
                s3Client.putObjectTagging(PutObjectTaggingRequest.builder().bucket(BUCKET).key(FILE_NAME).tagging(Tagging.builder().tagSet(checksumTag).build()).build());
            } catch (IOException | NoSuchAlgorithmException e) {
                e.printStackTrace();
            }
            GetObjectAttributesResponse
                    objectAttributes = s3Client.getObjectAttributes(GetObjectAttributesRequest.builder().bucket(BUCKET).key(FILE_NAME)
                    .objectAttributes(ObjectAttributes.OBJECT_PARTS, ObjectAttributes.CHECKSUM).build());
            System.out.println(objectAttributes.objectParts().parts());
            System.out.println(objectAttributes.checksum().checksumSHA256());
        }
     
        public static void downloadLargeFileBracketedByChecksum(S3Client s3Client) {
            System.out.println("Starting downloading file validation");
            File file = new File("DOWNLOADED_" + FILE_NAME);
            try (OutputStream out = new FileOutputStream(file)) {
                GetObjectAttributesResponse
                        objectAttributes = s3Client.getObjectAttributes(GetObjectAttributesRequest.builder().bucket(BUCKET).key(FILE_NAME)
                        .objectAttributes(ObjectAttributes.OBJECT_PARTS, ObjectAttributes.CHECKSUM).build());
                //Optionally if you need the full object checksum, you can grab a tag you added on the upload
                List<Tag> objectTags = s3Client.getObjectTagging(GetObjectTaggingRequest.builder().bucket(BUCKET).key(FILE_NAME).build()).tagSet();
                String fullObjectChecksum = null;
                for (Tag objectTag : objectTags) {
                    if (objectTag.key().equals(CHECKSUM_TAG_KEYNAME)) {
                        fullObjectChecksum = objectTag.value();
                        break;
                    }
                }
                MessageDigest sha256FullObject = MessageDigest.getInstance("SHA-256");
                MessageDigest sha256ChecksumOfChecksums = MessageDigest.getInstance("SHA-256");
     
                //If you retrieve the object in parts, and set the ChecksumMode to enabled, the SDK will automatically validate the part checksum
                for (int partNumber = 1; partNumber <= objectAttributes.objectParts().totalPartsCount(); partNumber++) {
                    MessageDigest sha256Part = MessageDigest.getInstance("SHA-256");
                    ResponseInputStream<GetObjectResponse> response = s3Client.getObject(GetObjectRequest.builder().bucket(BUCKET).key(FILE_NAME).partNumber(partNumber).checksumMode(ChecksumMode.ENABLED).build());
                    GetObjectResponse getObjectResponse = response.response();
                    byte[] buffer = new byte[CHUNK_SIZE];
                    int read = response.read(buffer);
                    while (read != -1) {
                        out.write(buffer, 0, read);
                        sha256FullObject.update(buffer, 0, read);
                        sha256Part.update(buffer, 0, read);
                        read = response.read(buffer);
                    }
                    byte[] sha256PartBytes = sha256Part.digest();
                    sha256ChecksumOfChecksums.update(sha256PartBytes);
                    //Optionally, you can do an additional manual validation again the part checksum if needed in addition to the SDK check
                    String base64PartChecksum = Base64.getEncoder().encodeToString(sha256PartBytes);
                    String base64PartChecksumFromObjectAttributes = objectAttributes.objectParts().parts().get(partNumber - 1).checksumSHA256();
                    if (!base64PartChecksum.equals(getObjectResponse.checksumSHA256()) || !base64PartChecksum.equals(base64PartChecksumFromObjectAttributes)) {
                        throw new IOException("Part checksum didn't match for the part");
                    }
                    System.out.println(partNumber + " " + base64PartChecksum);
                }
                //Before finalizing, do the final checksum validation.
                String base64FullObject = Base64.getEncoder().encodeToString(sha256FullObject.digest());
                String base64ChecksumOfChecksums = Base64.getEncoder().encodeToString(sha256ChecksumOfChecksums.digest());
                if (fullObjectChecksum != null && !fullObjectChecksum.equals(base64FullObject)) {
                    throw new IOException("Failed checksum validation for full object");
                }
                System.out.println(fullObjectChecksum);
                String base64ChecksumOfChecksumFromAttributes = objectAttributes.checksum().checksumSHA256();
                if (base64ChecksumOfChecksumFromAttributes != null && !base64ChecksumOfChecksums.equals(base64ChecksumOfChecksumFromAttributes)) {
                    throw new IOException("Failed checksum validation for full object checksum of checksums");
                }
                System.out.println(base64ChecksumOfChecksumFromAttributes);
                out.flush();
            } catch (IOException | NoSuchAlgorithmException e) {
                //Cleanup bad file
                file.delete();
                e.printStackTrace();
            }
        }
     
        public static void validateExistingFileAgainstS3Checksum(S3Client s3Client) {
            System.out.println("Starting existing file validation");
            File file = new File("DOWNLOADED_" + FILE_NAME);
            GetObjectAttributesResponse
                    objectAttributes = s3Client.getObjectAttributes(GetObjectAttributesRequest.builder().bucket(BUCKET).key(FILE_NAME)
                    .objectAttributes(ObjectAttributes.OBJECT_PARTS, ObjectAttributes.CHECKSUM).build());
            try (InputStream in = new FileInputStream(file)) {
                MessageDigest sha256ChecksumOfChecksums = MessageDigest.getInstance("SHA-256");
                MessageDigest sha256Part = MessageDigest.getInstance("SHA-256");
                byte[] buffer = new byte[CHUNK_SIZE];
                int currentPart = 0;
                int partBreak = objectAttributes.objectParts().parts().get(currentPart).size();
                int totalRead = 0;
                int read = in.read(buffer);
                while (read != -1) {
                    totalRead += read;
                    if (totalRead >= partBreak) {
                        int difference = totalRead - partBreak;
                        byte[] partChecksum;
                        if (totalRead != partBreak) {
                            sha256Part.update(buffer, 0, read - difference);
                            partChecksum = sha256Part.digest();
                            sha256ChecksumOfChecksums.update(partChecksum);
                            sha256Part.reset();
                            sha256Part.update(buffer, read - difference, difference);
                        } else {
                            sha256Part.update(buffer, 0, read);
                            partChecksum = sha256Part.digest();
                            sha256ChecksumOfChecksums.update(partChecksum);
                            sha256Part.reset();
                        }
                        String base64PartChecksum = Base64.getEncoder().encodeToString(partChecksum);
                        if (!base64PartChecksum.equals(objectAttributes.objectParts().parts().get(currentPart).checksumSHA256())) {
                            throw new IOException("Part checksum didn't match S3");
                        }
                        currentPart++;
                        System.out.println(currentPart + " " + base64PartChecksum);
                        if (currentPart < objectAttributes.objectParts().totalPartsCount()) {
                            partBreak += objectAttributes.objectParts().parts().get(currentPart - 1).size();
                        }
                    } else {
                        sha256Part.update(buffer, 0, read);
                    }
                    read = in.read(buffer);
                }
                if (currentPart != objectAttributes.objectParts().totalPartsCount()) {
                    currentPart++;
                    byte[] partChecksum = sha256Part.digest();
                    sha256ChecksumOfChecksums.update(partChecksum);
                    String base64PartChecksum = Base64.getEncoder().encodeToString(partChecksum);
                    System.out.println(currentPart + " " + base64PartChecksum);
                }
     
                String base64CalculatedChecksumOfChecksums = Base64.getEncoder().encodeToString(sha256ChecksumOfChecksums.digest());
                System.out.println(base64CalculatedChecksumOfChecksums);
                System.out.println(objectAttributes.checksum().checksumSHA256());
                if (!base64CalculatedChecksumOfChecksums.equals(objectAttributes.checksum().checksumSHA256())) {
                    throw new IOException("Full object checksum of checksums don't match S3");
                }
     
            } catch (IOException | NoSuchAlgorithmException e) {
                e.printStackTrace();
            }
        }
    }

Uso de la API de REST

Puede enviar solicitudes REST para cargar un objeto con un valor de suma de comprobación para verificar la integridad de los datos con PutObject. También puede recuperar el valor de suma de comprobación de los objetos con GetObject o HeadObject.

Uso de la AWS CLI

Envíe una solicitud PUT para cargar un objeto de hasta 5 GB en una única operación. Para obtener más información, consulte PutObject en la Referencia de comandos de AWS CLI. También puede utilizar get-object y head-object para recuperar la suma de comprobación de un objeto ya cargado para verificar la integridad de los datos.

Para ver más información, consulte Amazon S3 CLI FAQ en la Guía del usuario de la AWS Command Line Interface.

Uso de Content-MD5 al cargar objetos

Otra forma de verificar la integridad del objeto después de cargarlo es proporcionar un resumen MD5 del objeto al cargarlo. Si calcula el resumen MD5 de su objeto, puede proporcionar el resumen con el comando PUT mediante el encabezado Content-MD5.

Tras cargar el objeto, Amazon S3 calcula el resumen MD5 del objeto y lo compara con el valor que proporcionó. La solicitud se realiza correctamente solo si los dos resúmenes coinciden.

No es necesario suministrar un resumen MD5, pero puede usarlo para verificar la integridad del objeto como parte del proceso de carga.

Uso de Content-MD5 y ETag para verificar los objetos cargados

La etiqueta de entidad (ETag) de un objeto representa una versión específica de ese objeto. Tenga en cuenta que la ETag solo refleja los cambios en su contenido, no en los metadatos. Si solo cambian los metadatos de un objeto, la ETag sigue siendo la misma.

Según el objeto, la ETag del objeto puede ser un resumen MD5 de los datos del objeto:

• Si un objeto se ha creado con la operación PutObject, PostObject o CopyObject, o a través de AWS Management Console, y también tiene texto sin formato o está cifrado mediante cifrado del lado del servidor con claves administradas de Amazon S3 (SSE-S3), ese objeto tiene una ETag que es un resumen MD5 de sus datos de objeto.

• Si un objeto se ha creado con la operación PutObject, PostObject o CopyObject, o a través de AWS Management Console, y está cifrado mediante cifrado del lado del servidor con claves proporcionadas por el cliente (SSE-C) o mediante cifrado del lado del servidor con AWS Key Management Service (AWS KMS) (SSE-KMS), ese objeto tiene una ETag que no es un resumen MD5 de sus datos de objeto.

• Si un objeto se crea mediante el proceso de carga multiparte o la operación UploadPartCopy, la ETag del objeto no es un resumen MD5, independientemente del método de cifrado. Si un objeto tiene más de 16 MB, la AWS Management Console carga o copia ese objeto como carga multiparte y, por lo tanto, la ETag no es un resumen MD5.

Para objetos en los que la ETag es el resumen Content-MD5 del objeto, puede comparar el valor de ETag del objeto con un resumen Content-MD5 calculado o almacenado previamente.

Uso de sumas de comprobación finales

Al cargar objetos en Amazon S3, puede proporcionar una suma de comprobación calculada previamente para el objeto o utilizar un SDK de AWS para crear automáticamente sumas de comprobación finales en su nombre. Si decide utilizar una suma de comprobación final, Amazon S3 genera automáticamente la suma de comprobación mediante el algoritmo especificado y la utiliza para validar la integridad del objeto durante la carga.

Para crear una suma de comprobación final cuando utilice un SDK de AWS, rellene el parámetro ChecksumAlgorithm con su algoritmo preferido. El SDK utiliza ese algoritmo para calcular la suma de comprobación de su objeto (o partes de objeto) y lo anexa automáticamente al final de la solicitud de carga. Este comportamiento le ahorra tiempo porque Amazon S3 realiza la verificación y la carga de sus datos en un solo pase.

importante

Si utiliza S3 Object Lambda, todas las solicitudes a S3 Object Lambda se firman mediante s3-object-lambda en lugar de s3. Este comportamiento afecta a la firma de los valores de suma de comprobación final. Para obtener más información acerca de S3 Object Lambda, consulte Transformación de objetos con Lambda para objetos S3.

Uso de sumas de comprobación a nivel de parte para cargas multiparte

Cuando los objetos se cargan en Amazon S3, se pueden cargar como un solo objeto o mediante el proceso de carga multiparte. Los objetos de más de 16 MB que se cargan a través de la consola se cargan automáticamente mediante cargas multiparte. Para obtener más información acerca de las cargas multipartes, consulte Carga y copia de objetos con la carga multiparte.

Cuando un objeto se carga como carga multiparte, la ETag del objeto no es un resumen MD5 de todo el objeto. Amazon S3 calcula el resumen MD5 de cada parte individual a medida que se carga. Los resúmenes MD5 se utilizan para determinar la ETag del objeto final. Amazon S3 concatena los bytes de los resúmenes MD5 y, a continuación, calcula el resumen MD5 de estos valores concatenados. El último paso para crear la ETag es cuando Amazon S3 añade un guion con el número total de partes al final.

Por ejemplo, supongamos que tenemos un objeto cargado con una carga multiparte que tiene una ETag de C9A5A6878D97B48CC965C1E41859F034-14. En este caso, C9A5A6878D97B48CC965C1E41859F034 es el resumen MD5 de todos los resúmenes concatenados. El -14 indica que hay 14 artículos asociados a la carga multiparte de este objeto.

Si ha habilitado valores de suma de comprobación adicionales para el objeto multiparte, Amazon S3 calcula la suma de comprobación de cada parte individual mediante el algoritmo de suma de comprobación especificado. La suma de comprobación del objeto completado se calcula de la misma manera que Amazon S3 calcula el resumen MD5 para la carga multiparte. Puede utilizar esta suma de comprobación para verificar la integridad del objeto.

Para recuperar información sobre el objeto, incluida la cantidad de partes que componen todo el objeto, puede utilizar la operación GetObjectAttributes. Con sumas de comprobación adicionales, también puede recuperar información de cada parte individual que incluye el valor de suma de comprobación de cada parte.

En el caso de cargas completadas, puede obtener la suma de comprobación de una parte individual mediante la operación GetObject o HeadObject y especificar un número de parte o rango de bytes que se ajuste a una sola parte. Si quiere recuperar los valores de la suma de comprobación de partes individuales de las cargas de varias partes que aún están en curso, puede utilizar ListParts.

Debido a la forma en que Amazon S3 calcula la suma de comprobación de objetos multiparte, es posible que el valor de la suma de comprobación del objeto cambie si lo copia. Si utiliza un SDK o la API de REST y llama a CopyObject, Amazon S3 copia cualquier objeto hasta el tamaño límite de la operación API CopyObject. Amazon S3 realiza esta copia como una sola acción, independientemente de si el objeto se ha cargado en una sola solicitud o como parte de una carga multiparte. Con un comando de copia, la suma de comprobación del objeto es una suma de comprobación directa de todo el objeto. Si el objeto se subió originalmente mediante una carga multiparte, el valor de la suma de comprobación cambia aunque los datos no lo hayan hecho.

nota

Los objetos que superen los límites de tamaño de la operación de API CopyObject deben utilizar comandos de copia multiparte.

importante

Cuando realiza algunas operaciones con la AWS Management Console, Amazon S3 utiliza una carga multiparte si el objeto tiene un tamaño superior a 16 MB. En este caso, la suma de comprobación no es una suma de comprobación directa del objeto completo, sino un cálculo basado en los valores de suma de comprobación de cada parte individual.

Por ejemplo, supongamos que tenemos un objeto de 100 MB que ha subido como carga directa de una sola parte mediante la API de REST. La suma de comprobación en este caso es una suma de comprobación de todo el objeto. Si posteriormente utiliza la consola para cambiar el nombre de ese objeto, copiarlo, cambiar la clase de almacenamiento o editar los metadatos, Amazon S3 utiliza la funcionalidad de carga multiparte para actualizar el objeto. Como resultado, Amazon S3 crea un nuevo valor de suma de comprobación para el objeto que se calcula en función de los valores de suma de comprobación de las partes individuales.

La lista anterior de operaciones de la consola no es una lista completa de todas las acciones que se pueden realizar en la AWS Management Console que hacen que Amazon S3 actualice el objeto mediante la funcionalidad de carga multiparte. Tenga en cuenta que siempre que utilice la consola para actuar sobre objetos de más de 16 MB, es posible que el valor de la suma de comprobación no sea la suma de comprobación de todo el objeto.