Verificar a integridade do objeto

O Amazon S3 usa valores de soma de verificação para verificar a integridade dos dados que você carrega ou baixa do Amazon S3. Além disso, você pode solicitar que outro valor de soma de verificação seja calculado para qualquer objeto armazenado no Amazon S3. Você pode selecionar um dos vários algoritmos de soma de verificação para usar ao carregar ou copiar seus dados. O Amazon S3 usa esse algoritmo para calcular um valor de soma de verificação adicional e armazená-lo como parte dos metadados do objeto. Para saber mais sobre como usar somas de verificação adicionais para verificar a integridade dos dados, consulte Tutorial: Verificar a integridade dos dados no Amazon S3 com somas de verificação adicionais.

Ao carregar um objeto, você pode incluir uma soma de verificação pré-calculada como parte de sua solicitação. O Amazon S3 compara a soma de verificação fornecida com a soma de verificação calculada usando o algoritmo especificado. Se os dois valores não corresponderem, o Amazon S3 gerará um erro.

Usar algoritmos de soma de verificação compatíveis

O Amazon S3 oferece a opção de escolher o algoritmo de soma de verificação usado para validar seus dados durante o upload ou o download. Você pode selecionar um dos seguintes algoritmos de verificação de integridade de dados de hash seguro (SHA) ou de verificação de redundância cíclica (CRC):

• CRC32

• CRC32C

• SHA-1

• SHA-256

Ao carregar um objeto, você pode especificar o algoritmo que deseja usar:

• Quando você estiver usando o AWS Management Console, selecione o algoritmo de soma de verificação que deseja usar. Ao fazer isso, você pode especificar o valor da soma de verificação do objeto. Quando o Amazon S3 recebe o objeto, ele calcula a soma de verificação usando o algoritmo especificado. Se os dois valores de soma de verificação não corresponderem, o Amazon S3 gerará um erro.

• Ao usar um SDK, você pode definir o valor do parâmetro x-amz-sdk-checksum-algorithm para o algoritmo que deseja que o Amazon S3 use ao calcular a soma de verificação. O Amazon S3 calcula automaticamente o valor da soma de verificação.

• Ao utilizar a API REST, não use o parâmetro x-amz-sdk-checksum-algorithm. Em vez disso, use um dos cabeçalhos específicos do algoritmo (por exemplo, x-amz-checksum-crc32).

Para obter mais informações sobre como carregar objetos, consulte Fazer upload de objetos.

Para aplicar qualquer um desses valores de soma de verificação a objetos já carregados para o Amazon S3, você pode copiar o objeto. Ao copiar um objeto, você pode especificar se deseja usar o algoritmo de soma de verificação existente ou usar um novo. É possível especificar um algoritmo de soma de verificação ao usar qualquer mecanismo compatível para copiar objetos, incluindo operações em lote do S3. Para obter mais informações sobre o S3 Batch Operations, consulte Executar operações em lote de grande escala em objetos do Amazon S3.

Importante

Se você estiver usando um carregamento fracionado com somas de verificação adicionais, os números das partes fracionadas deverão ser consecutivos. Ao usar somas de verificação adicionais, se você tentar concluir uma solicitação de carregamento fracionado com números de parte não consecutivos, o Amazon S3 gerará um erro HTTP 500 Internal Server Error.

Depois de carregar objetos, você pode obter o valor da soma de verificação e compará-lo com um valor de soma de verificação pré-calculado ou armazenado anteriormente que tenha sido calculado com o mesmo algoritmo.

Uso do console do S3

Para saber mais sobre como usar o console e especificar algoritmos de soma de verificação a serem usados ao carregar objetos, consulte Fazer upload de objetos e Tutorial: verificar a integridade dos dados no Amazon S3 com somas de verificação adicionais.

Uso dos AWS SDKs

O exemplo a seguir mostra como usar os AWS SDKs para carregar um arquivo grande com carregamento fracionado, baixar um arquivo grande e validar um arquivo de carregamento fracionado por meio do SHA-256 para validação de arquivos.

Java

exemplo Exemplo: carregar, baixar e verificar um arquivo grande com SHA-256

Para obter instruções sobre como criar e testar um exemplo funcional, consulte Testar exemplos de código Java no Amazon S3.

    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 da API REST

Você pode enviar solicitações REST para carregar um objeto com um valor de soma de verificação para verificar a integridade dos dados com PutObject. Você também pode recuperar o valor da soma de verificação para objetos usando GetObject ou HeadObject.

Usando a AWS CLI

Você pode enviar uma solicitação PUT para carregar um objeto de até 5 GB em uma única operação. Para obter mais informações, consulte PutObject na Referência de comando da AWS CLI. Você também pode usar get-object e head-object para recuperar a soma de verificação de um objeto já carregado a fim de verificar a integridade dos dados.

Para obter informações, consulte Amazon S3 CLI FAQ no Guia do usuário da AWS Command Line Interface.

Usar Content-MD5 ao carregar objetos

Outra maneira de verificar a integridade do objeto após o carregamento é fornecer um resumo MD5 do objeto quando você o carrega. Se você calcular o resumo MD5 para seu objeto, poderá fornecê-lo com o comando PUT usando o cabeçalho Content-MD5.

Após o carregamento do objeto, o Amazon S3 calcula o resumo MD5 do objeto e o compara com o valor que você forneceu. A solicitação só será bem-sucedida se os dois resumos corresponderem.

Não é necessário fornecer um resumo MD5, mas você pode usá-lo para verificar a integridade do objeto como parte do processo de carregamento.

Usar Content-MD5 e a ETag para verificar objetos carregados

A etiqueta de entidade (ETag) de um objeto representa uma versão específica dele. Lembre-se de que a ETag reflete as alterações apenas no conteúdo de um objeto, não nos respectivos metadados. Se apenas os metadados de um objeto forem alterados, a ETag permanecerá a mesma.

Dependendo do objeto, a ETag do objeto pode ser um resumo MD5 dos dados do objeto:

• Se um objeto for criado pela operação PutObject, PostObject ou CopyObject, ou por meio do AWS Management Console, e ele também for em texto simples ou criptografado no lado do servidor com chaves gerenciadas pelo Amazon S3 (SSE-S3), ele terá uma ETag que é um resumo MD5 dos respectivos dados.

• Se um objeto for criado pela operação PutObject, PostObject ou CopyObject, ou por meio do AWS Management Console, e for criptografado no lado do servidor com chaves fornecidas pelo cliente (SSE-C) ou com criptografia no lado do servidor com chaves AWS Key Management Service(AWS KMS) (SSE-KMS), ele terá uma ETag que não é um resumo MD5 dos respectivos dados.

• Se um objeto for criado pela operação Multipart Upload ou Part Copy, a respectiva ETag não será um resumo MD5, independentemente do método de criptografia. Se um objeto for maior que 16 MB, o AWS Management Console o carregará ou copiará como carregamento fracionado e, por isso, a ETag não será um resumo MD5.

Para objetos em que a ETag é o resumo Content-MD5 do objeto, você pode comparar o valor da ETag do objeto com um resumo Content-MD5 calculado ou armazenado anteriormente.

Usar somas de verificação à direita

Ao carregar objetos para o Amazon S3, você pode fornecer uma soma de verificação pré-calculada para o objeto ou usar um AWS SDK para criar automaticamente somas de verificação à direita em seu nome. Se você decidir usar uma soma de verificação à direita, o Amazon S3 a gerará automaticamente usando o algoritmo especificado e a usará para validar a integridade do objeto durante o carregamento.

Para criar uma soma de verificação à direita ao usar um AWS SDK, preencha o parâmetro ChecksumAlgorithm com seu algoritmo preferido. O SDK usa esse algoritmo para calcular a soma de verificação do objeto (ou partes do objeto) e o anexa automaticamente ao final da solicitação de carregamento. Esse comportamento economiza tempo porque o Amazon S3 executa a verificação e o carregamento de seus dados em uma única passagem.

Importante

Se estiver usando o S3 Object Lambda, todas as solicitações ao S3 Object Lambda serão assinadas usando s3-object-lambda em vez de s3. Esse comportamento afeta a assinatura dos valores de soma de verificação à direita. Para obter mais informações sobre o S3 Object Lambda, consulte Transformar objetos com o S3 Object Lambda.

Usar somas de verificação de nível parcial para carregamentos fracionados

Quando os objetos são carregados para o Amazon S3, eles podem ser carregados como um único objeto ou por meio do processo de carregamento fracionado. Objetos maiores que 16 MB e carregados pelo console são carregados automaticamente por meio de carregamentos fracionados. Para obter mais informações sobre multipart uploads, consulte Carregar e copiar objetos usando multipart upload.

Quando um objeto é carregado como um carregamento fracionado, a ETag do objeto não é um resumo MD5 do objeto completo. O Amazon S3 calcula o resumo MD5 de cada parte à medida que ela é carregada. Os resumos MD5 são usados para determinar a ETag do objeto final. O Amazon S3 concatena os bytes para os resumos MD5 e, depois, calcula o resumo MD5 desses valores concatenados. A etapa final para criar a ETag ocorre quando o Amazon S3 adiciona um traço com o número total de partes ao final.

Por exemplo, considere um objeto com carregamento fracionado que tenha uma ETag de C9A5A6878D97B48CC965C1E41859F034-14. Nesse caso, o C9A5A6878D97B48CC965C1E41859F034 é o resumo MD5 de todos os resumos concatenados. O -14 indica que há 14 partes associadas ao carregamento fracionado desse objeto.

Se você tiver habilitado valores de soma de verificação adicionais para o objeto fracionado, o Amazon S3 calculará a soma de verificação de cada parte usando o algoritmo de soma de verificação especificado. A soma de verificação do objeto concluído é calculada da mesma forma que o Amazon S3 calcula o resumo MD5 do carregamento fracionado. Você pode usar essa soma de verificação para verificar a integridade do objeto.

Para recuperar informações sobre o objeto, incluindo o número de partes que compõem o objeto inteiro, você pode usar a operação GetObjectAttributes. Com somas de verificação adicionais, também é possível recuperar informações de cada parte que inclui o valor da soma de verificação de cada uma.

Você também pode obter a soma de verificação de uma parte usando a operação GetObject ou HeadObject e especificando um número de parte ou um intervalo de bytes que se alinhe a uma única parte. Com esse método, você pode usar essa soma de verificação para validar a parte sem precisar esperar a conclusão do carregamento de todas as partes para verificar a integridade dos dados. Ao usar esse método, você também pode solicitar somente as partes que falharam no teste de integridade.

Devido à forma como o Amazon S3 calcula a soma de verificação para objetos fracionados, o valor da soma de verificação do objeto poderá ser alterado se você copiá-lo. Se estiver usando um SDK ou a API REST e chamar CopyObject, o Amazon S3 copiará qualquer objeto até as limitações de tamanho da operação CopyObject da API. O Amazon S3 faz essa cópia como uma única ação, independentemente de o objeto ter sido carregado em uma única solicitação ou como parte de um carregamento fracionado. Com um comando copy, a soma de verificação do objeto é uma soma de verificação direta do objeto completo. Se o objeto tiver sido originalmente carregado usando um carregamento fracionado, o valor da soma de verificação será alterado mesmo que os dados não mudem.

nota

Os objetos que ultrapassam as limitações de tamanho da operação CopyObject da API devem usar comandos de cópia fracionada.

Importante

Quando você executar algumas operações usando o AWS Management Console, o Amazon S3 usará o carregamento fracionado se o objeto tiver mais de 16 MB. Nesse caso, a soma de verificação não é uma soma de verificação direta do objeto completo, mas um cálculo baseado nos valores da soma de verificação de cada parte.

Por exemplo, considere um objeto de 100 MB que você carregou como um carregamento direto de uma única parte usando a API REST. Nesse caso, a soma de verificação é do objeto completo. Se você usar o console posteriormente para renomear esse objeto, copiá-lo, alterar a classe de armazenamento ou editar os metadados, o Amazon S3 usará a funcionalidade de carregamento fracionado para atualizá-lo. Por isso, o Amazon S3 cria um valor de soma de verificação para o objeto que é calculado com base nos valores de soma de verificação das partes.

A lista anterior de operações do console não é uma lista completa de todas as ações possíveis que você pode executar no AWS Management Console que resultam na atualização do objeto do Amazon S3 usando a funcionalidade de carregamento fracionado. Lembre-se de que sempre que usar o console para lidar com objetos com mais de 16 MB, o valor da soma de verificação pode não ser a soma de verificação do objeto completo.