# Verificar a integridade do objeto no Amazon S3 O Amazon S3 oferece diversos recursos de proteção de dados em todo o ciclo de vida de armazenamento de um objeto. Com o Amazon S3, você pode usar valores de soma de verificação para verificar a integridade dos dados que você carrega ou baixa. Além disso, você pode solicitar que outro valor de soma de verificação seja calculado para qualquer objeto armazenado no S3. Ao carregar, copiar ou gerenciar seus dados, é possível escolher entre vários algoritmos de soma de verificação compatíveis: + CRC-64/NVME (`CRC64NVME`) **nota** O algoritmo `CRC64NVME` é o algoritmo de soma de verificação padrão usado para cálculos de soma de verificação. + CRC-32 (`CRC32`) + CRC-32C (`CRC32C`) + SHA-1 (`SHA1`) + SHA-256 (`SHA256`) + MD5 (`MD5`) **nota** Para multipart uploads, a operação de cálculo de soma de verificação fornece valores de soma de verificação de objetos completos usando o `MD5`, o que não é possível durante os uploads. Para uploads únicos, o `content-MD5 header` está disponível somente ao usar a ETag do S3 para objetos e deve usar a criptografia SSE-S3. Ao fazer upload de um objeto no S3, é possível especificar o uso de qualquer um desses algoritmos de soma de verificação. Para uploads, todos os clientes pertencentes à AWS calculam uma soma de verificação do objeto e a enviam com a solicitação de upload. Em seguida, o S3 calcula de forma independente um valor de soma de verificação do objeto do lado do servidor e o valida com o valor fornecido antes de armazenar o objeto e o valor da soma de verificação. Você também pode fornecer valores pré-calculados para esses algoritmos de soma de verificação ao realizar um upload único ou um multipart upload (usando o tipo de soma de verificação de objeto completo para multipart uploads). Para usar valores pré-calculados com vários objetos, use a AWS CLI ou os AWS SDKs. Outra opção é, caso queira verificar conjuntos de dados no S3 sem precisar restaurar ou baixar dados, usar a operação **Calcular soma de verificação** com o recurso Operações em Lote do S3. A operação **Calcular soma de verificação** permite que você verifique com eficiência bilhões de objetos em uma solicitação de trabalho. Quando a operação **Calcular soma de verificação** é executada, o S3 calcula os valores de soma de verificação para uma lista de objetos em repouso. Ao final da solicitação de trabalho, você receberá um relatório de integridade gerado automaticamente (também conhecido como relatório de conclusão), que pode ser usado para confirmar que seu conjunto de dados permanece intacto. **Topics** + [Verificar a integridade do objeto para uploads de dados no Amazon S3](checking-object-integrity-upload.md) + [Verificar a integridade do objeto para dados em repouso no Amazon S3](checking-object-integrity-at-rest.md) # Verificar a integridade do objeto para uploads de dados no Amazon S3 O Amazon S3 usa valores de soma de verificação para verificar a integridade dos dados durante operações de upload e download. Quando você carrega dados, o SDK da AWS e o Console de gerenciamento da AWS usam o algoritmo de soma de verificação escolhido para calcular um valor de soma de verificação antes da transmissão de dados. Em seguida, o S3 calcula de forma independente uma soma de verificação dos seus dados e a valida com base no valor da soma de verificação fornecido. Os objetos são aceitos somente após a confirmação de que a integridade dos dados foi mantida durante o trânsito. O S3 armazena o valor da soma de verificação como metadados do objeto e o próprio objeto. Para verificar a integridade do objeto, você pode solicitar o valor da soma de verificação durante os downloads. Essa validação funciona de maneira consistente em todos os modos de criptografia, tamanhos de objeto e classes de armazenamento e para uploads únicos e multipart uploads. Para alterar o algoritmo de soma de verificação de um upload, é possível copiar um objeto individual ou usar a cópia em lote para vários objetos. Para uploads únicos, você pode fornecer valores de soma de verificação como cabeçalhos. É possível fornecer um valor pré-calculado ou deixar que o SDK da AWS calcule um durante o upload. Se o valor da soma de verificação calculado pelo S3 corresponder ao valor fornecido, a solicitação será aceita. Se os valores não coincidirem, a solicitação será rejeitada. Para multipart uploads, os SDKs da AWS podem criar automaticamente somas de verificação finais para uploads fragmentados. Quando você usa uma soma de verificação final, o Amazon S3 gera valores de soma de verificação para cada parte usando o algoritmo especificado e acrescenta o valor da soma de verificação ao final da solicitação de upload fragmentado. O S3 realiza a verificação e o upload em uma única etapa, melhorando a eficiência. Para obter mais informações, consulte [Usar somas de verificação à direita](#trailing-checksums). ## Usar algoritmos de soma de verificação compatíveis Com o Amazon S3, você pode escolher um algoritmo de soma de verificação para calcular os valores de soma de verificação durante os uploads. O algoritmo de soma de verificação especificado é armazenado com o objeto e pode ser usado para validar a integridade dos dados durante os downloads. Você pode selecionar um dos seguintes algoritmos de soma de verificação Secure Hash Algorithms (SHA) ou Cyclic Redundancy Check (CRC) para calcular o valor da soma de verificação: + CRC-64/NVME (`CRC64NVME`) + CRC-32 (`CRC32`) + CRC-32C (`CRC32C`) + SHA-1 (`SHA1`) + SHA-256 (`SHA256`) + MD5 (`MD5`) **nota** O cabeçalho `content-MD5` está disponível somente quando se usa a ETag do S3 para objetos carregados em um upload único (operação `PUT`) que use a criptografia SSE-S3. Além disso, você pode fornecer uma soma de verificação com cada solicitação usando o cabeçalho Content-MD5. Ao [fazer upload de um objeto](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html), especifique o algoritmo que deseja usar: + **Ao usar o Console de gerenciamento da AWS**, escolha o algoritmo de soma de verificação que deseja usar. Você também 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**, esteja ciente do seguinte: + Defina o parâmetro `ChecksumAlgorithm` como o algoritmo que você deseja que o Amazon S3 use. Se você já tem uma soma de verificação pré-calculada, envie o valor da soma de verificação para o AWS SDK, que incluirá o valor na solicitação. Se você não enviar um valor de soma de verificação ou não especificar um algoritmo de soma de verificação, o SDK calculará automaticamente um valor de soma de verificação para você e o incluirá na solicitação a fim de fornecer proteções de integridade. Se o valor da soma de verificação individual não corresponder ao valor definido do algoritmo de soma de verificação, o Amazon S3 rejeitará a solicitação com um erro `BadDigest`. + Se você estiver usando um AWS SDK atualizado, o SDK escolherá um algoritmo de soma de verificação para você. No entanto, você pode substituir esse algoritmo de soma de verificação. + Se você não especificar um algoritmo de soma de verificação e o SDK também não calcular uma soma de verificação para você, o S3 escolherá automaticamente o algoritmo de soma de verificação CRC-64/NVME (`CRC64NVME`). + **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 aplicar qualquer um desses valores de soma de verificação a objetos que já foram carregados no Amazon S3, você pode copiar o objeto e especificar se deseja usar o algoritmo de soma de verificação existente ou um novo. Se você não especificar um algoritmo, o S3 usará o algoritmo existente. Se o objeto de origem não tiver um algoritmo de soma de verificação ou valor de soma de verificação especificado, o Amazon S3 usará o algoritmo CRC-64/NVME para calcular o valor da soma de verificação do objeto de destino. Também é possível especificar um algoritmo de soma de verificação ao copiar objetos usando a funcionalidade [Operações em Lote do S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops.html). **Importante** Se você usar um upload fracionado com **somas de verificação** para somas de verificação compostas (ou no nível da parte), os números de partes do upload fracionado deverão ser consecutivos e começar com 1. Se você tentar concluir uma solicitação de upload fracionado com números de parte não consecutivos, o Amazon S3 gerará um erro `HTTP 500 Internal Server`. ## Tipos de soma de verificação de objeto inteiro e composta No Amazon S3, há dois tipos de somas de verificação compatíveis: + **Somas de verificação de objeto inteiro:** uma soma de verificação de objeto inteiro é calculada com base em todo o conteúdo de um upload fracionado, abrangendo todos os dados desde o primeiro byte da primeira parte até o último byte da última parte. Lembre-se de que, se você estiver usando o Console de gerenciamento da AWS para fazer upload de objetos com menos de 16 MB, só será possível usar o tipo de soma de verificação de objeto completo. **nota** Todas as solicitações PUT exigem um tipo de soma de verificação de objeto inteiro. É necessário especificar um tipo de soma de verificação de objeto completo se você estiver fazendo upload do objeto por meio de uma solicitação PUT. + **Somas de verificação compostas:** uma soma de verificação composta é calculada com base nas somas de verificação individuais de cada parte em um upload fracionado. Em vez de calcular uma soma de verificação com base em todo o conteúdo dos dados, essa abordagem agrega as somas de verificação ao nível da parte (da primeira à última parte) para produzir uma única soma de verificação combinada para o objeto inteiro. Se você estiver usando um multipart upload para fazer upload do objeto, especifique a soma de verificação composta. **nota** Quando um objeto é carregado como um upload fracionado, a tag de entidade (ETag) do objeto não é um resumo MD5 do objeto inteiro. Em vez disso, o Amazon S3 calcula o resumo MD5 de cada parte à medida que são carregadas. 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. Durante a etapa final de criação da ETag, o Amazon S3 adiciona um traço com o número total de partes ao final. O Amazon S3 oferece suporte aos seguintes tipos de algoritmo de soma de verificação de objeto inteiro e composta: + CRC-64/NVME (`CRC64NVME`): compatível somente com o tipo de soma de verificação de objeto completo. + CRC-32 (`CRC32`): compatível com os tipos de soma de verificação de objeto completo e composta. + CRC-32C (`CRC32C`): compatível com os tipos de soma de verificação de objeto completo e composta. + SHA-1 (`SHA1`): compatível com os tipos de soma de verificação de objeto completo e composta. + SHA-256 (`SHA256`): compatível com os tipos de soma de verificação de objeto completo e composta. + MD5 (`MD5`): compatível com os tipos de soma de verificação de objeto completo e composta. ### Uploads de parte única As somas de verificação de objetos que são carregados em uma única parte (usando [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html#API_PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html#API_PutObject)) são tratadas como somas de verificação de objeto inteiro. Ao fazer upload de um objeto no console do Amazon S3, você pode escolher o algoritmo de soma de verificação que deseja que o S3 use e também (opcionalmente) fornecer um valor pré-calculado. O Amazon S3 valida esse valor de soma de verificação pré-calculado antes de armazenar o objeto e o respectivo valor de soma de verificação. Você pode verificar a integridade dos dados de um objeto ao solicitar o valor da soma de verificação durante os downloads de objetos. ### Carregamentos fracionados Ao fazer upload do objeto em várias partes usando a API [https://docs.aws.amazon.com/AmazonS3/latest/API/API_MultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_MultipartUpload.html), você pode especificar o algoritmo de soma de verificação que deseja que o Amazon S3 use e o tipo de soma de verificação (objeto inteiro ou composta). A tabela a seguir indica qual tipo de algoritmo de soma de verificação é compatível com cada algoritmo de soma de verificação em um upload fracionado: | Algoritmo da soma de verificação | Objeto inteiro | Composto | | --- | --- | --- | | CRC-64/NVME (CRC64NVME) | Sim | Não | | CRC-32 (CRC32) | Sim | Sim | | CRC-32C (CRC32C) | Sim | Sim | | SHA-1 (SHA1) | Não | Sim | | SHA-256 (SHA256) | Não | Sim | ## Usar somas de verificação de objetos inteiros para upload fracionado Ao criar ou realizar um upload fracionado, você pode usar somas de verificação de objeto inteiro para validação no upload. Isso significa que é possível fornecer o algoritmo de soma de verificação para a API [https://docs.aws.amazon.com/AmazonS3/latest/API/API_MultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_MultipartUpload.html), simplificando as ferramentas de validação de integridade, pois você não precisa mais rastrear os limites das partes dos objetos carregados. Você pode fornecer a soma de verificação do objeto inteiro na solicitação [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html) com o tamanho do objeto. Ao fornecer uma soma de verificação de objeto inteiro durante um upload fracionado, o AWS SDK envia a soma de verificação para o Amazon S3, e o S3 valida a integridade do objeto do lado do servidor, comparando-a com o valor recebido. Depois, o Amazon S3 armazena o objeto se os valores corresponderem. Se os dois valores não corresponderem, o S3 reprovará a solicitação com um erro `BadDigest`. A soma de verificação do objeto também é armazenada nos metadados do objeto que você usará posteriormente para validar a integridade dos dados do objeto. Para somas de verificação de objeto inteiro, você pode usar os algoritmos de soma de verificação CRC-64/NVME (`CRC64NVME`), CRC-32 (`CRC32`) ou CRC-32C (`CRC32C`) no S3. As somas de verificação de objeto inteiro em uploads fracionados só estão disponíveis para somas de verificação baseadas em CRC porque podem ser linearizadas em uma soma de verificação de objeto inteiro. Essa linearização permite que o Amazon S3 paralelize as solicitações para melhorar a performance. Em particular, o S3 pode calcular a soma de verificação do objeto inteiro com base nas somas de verificação ao nível da parte. Esse tipo de validação não está disponível para outros algoritmos, como SHA e MD5. Como o S3 tem proteções de integridade padrão, se os objetos forem carregados sem uma soma de verificação, o S3 anexará automaticamente o algoritmo de soma de verificação CRC-64/NVME (`CRC64NVME`) de objeto inteiro recomendado ao objeto. **nota** Para inicializar o upload fracionado, você pode especificar o algoritmo de soma de verificação e o tipo de soma de verificação de objeto inteiro. Depois de especificar o algoritmo de soma de verificação e o tipo de soma de verificação de objeto inteiro, você pode fornecer o valor da soma de verificação de objeto inteiro para o upload fracionado. ## Usar somas de verificação ao nível da parte para upload fracionado Quando os objetos são carregados no Amazon S3, eles podem ser carregados como um único objeto ou em partes por meio do processo de upload fracionado. Você pode escolher um tipo de **Checksum** para o upload fracionado. Para somas de verificação ao nível da parte (ou somas de verificação compostas) em uploads fracionados, o Amazon S3 calcula a soma de verificação de cada parte usando o algoritmo de soma de verificação especificado. Você pode usar [https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html) para fornecer os valores de soma de verificação de cada parte. Se o objeto que você tentar carregar no console do Amazon S3 estiver configurado para usar o algoritmo de soma de verificação CRC-64/NVME (`CRC64NVME`) e exceder 16 MB, ele será automaticamente designado como uma soma de verificação de objeto inteiro. Depois, o Amazon S3 usa os valores de soma de verificação ao nível da parte armazenados para confirmar se cada parte foi carregada corretamente. Quando a soma de verificação de cada parte (para o objeto inteiro) é fornecida, o S3 usa os valores de soma de verificação armazenados de cada parte para calcular a soma de verificação do objeto inteiro internamente, comparando esse valor com o valor de soma de verificação fornecido. Isso minimiza os custos de computação, pois o S3 pode calcular uma soma de verificação de objeto inteiro usando a soma de verificação das partes. Para ter mais informações sobre os uploads fracionados, consulte [Carregar e copiar objetos usando upload fracionado no Amazon S3](mpuoverview.md) e [Usar somas de verificação de objetos inteiros para upload fracionado](#Full-object-checksums). Quando o objeto tiver sido completamente carregado, você poderá usar a soma de verificação final calculada para verificar a integridade dos dados do objeto. Ao fazer upload de uma parte do upload fracionado, esteja ciente do seguinte: + 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 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObjectAttributes.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObjectAttributes.html). Com somas de verificação adicionais, também é possível recuperar informações de cada parte, incluindo o valor da soma de verificação da parte. + Para uploads concluídos, é possível obter a soma de verificação de uma parte individual usando as operações [https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html) ou [https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html) e especificando um número de partes ou intervalo de bytes que se alinha a uma única parte. Se você quiser recuperar os valores da soma de verificação para partes individuais de carregamentos fracionados ainda em andamento, poderá usar [https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html). + 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 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html), o Amazon S3 copiará qualquer objeto até as limitações de tamanho da operação de API `CopyObject`. 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 upload fracionado, o valor da soma de verificação será alterado mesmo que os dados não mudem. + Os objetos que ultrapassam as limitações de tamanho da operação de API `CopyObject` devem usar [comandos de cópia de upload fracionado](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CopyingObjectsMPUapi.html). + Quando você executar algumas operações usando o Console de gerenciamento da AWS, o Amazon S3 usará o carregamento fracionado se o objeto tiver mais de 16 MB. ## Métodos de soma de verificação Depois de fazer upload de 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 do mesmo tipo de algoritmo de soma de verificação. Os exemplos a seguir mostram quais métodos de cálculo de soma de verificação você pode usar para verificar a integridade dos dados. ### Usar o 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](upload-objects.md) e [Tutorial: verificar a integridade dos dados no Amazon S3 com somas de verificação adicionais](https://aws.amazon.com/getting-started/hands-on/amazon-s3-with-additional-checksums/?ref=docs_gateway/amazons3/checking-object-integrity.html). ### Usar SDKs da AWS O exemplo a seguir mostra como usar os AWS SDKs para fazer upload de um arquivo grande com upload fracionado, baixar um arquivo grande e validar um arquivo de upload fracionado usando SHA-256 para validação de arquivos. ------ #### [ Java ] **Example Exemplo: carregar, baixar e verificar um arquivo grande com SHA-256** Consulte instruções sobre como criar e testar uma amostra funcional em [Getting Started](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/getting-started.html) no Guia do desenvolvedor do AWS SDK para 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 completedParts = new ArrayList(); 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 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 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](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html). Você também pode recuperar o valor da soma de verificação para objetos usando [GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html) ou [HeadObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html). ### Como usar o 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 [https://docs.aws.amazon.com/cli/latest/reference/s3api/put-object.html#examples](https://docs.aws.amazon.com/cli/latest/reference/s3api/put-object.html#examples) na *Referência de comando da AWS CLI*. Você também pode usar [https://docs.aws.amazon.com/cli/latest/reference/s3api/get-object.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/get-object.html) e [https://docs.aws.amazon.com/cli/latest/reference/s3api/head-object.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/head-object.html) 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](https://docs.aws.amazon.com/cli/latest/topic/s3-faq.html) 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 apenas as alterações no conteúdo de um objeto, não as alterações nos metadados dele. 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 Console de gerenciamento da AWS, 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 Console de gerenciamento da AWS, 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 pelo processo de carregamento fracionado ou pela operação `UploadPartCopy`, a respectiva ETag não será um resumo MD5, independentemente do método de criptografia. Se um objeto for maior que 16 MB, o Console de gerenciamento da AWS 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 fazer upload de grandes objetos no Amazon S3, você pode fornecer uma soma de verificação pré-calculada para o objeto ou usar um SDK da AWS para criar automaticamente somas de verificação finais para uploads fragmentados em seu nome. Se você usar uma soma de verificação final, o Amazon S3 gerará automaticamente o valor da soma de verificação usando o algoritmo especificado para validar a integridade do objeto nos uploads fragmentados, quando você fizer upload de um objeto. 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 o valor da soma de verificação do objeto (ou das partes do objeto) e o anexa automaticamente ao final da solicitação de upload fragmentado. 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](transforming-objects.md). ### Cabeçalhos de soma de verificação final Para fazer uma solicitação de codificação de conteúdo fragmentado, o Amazon S3 exige que os servidores clientes incluam vários cabeçalhos para analisar corretamente a solicitação. Os servidores clientes devem incluir os seguintes cabeçalhos: + **`x-amz-decoded-content-length`:**esse cabeçalho indica o tamanho em texto simples dos dados reais que estão sendo carregados no Amazon S3 com a solicitação. + **`x-amz-content-sha256`:** esse cabeçalho indica o tipo de upload fragmentado incluído na solicitação. Para uploads fragmentados com somas de verificação finais, o valor do cabeçalho é `STREAMING-UNSIGNED-PAYLOAD-TRAILER` para solicitações que não usam assinatura de carga útil e `STREAMING-AWS4-HMAC-SHA256-PAYLOAD-TRAILER` para solicitações que usam assinatura de carga útil SigV4. (Para ter mais informações sobre a implementação de cargas úteis assinadas, consulte [Signature calculations for the authorization header: Transferring a payload in multiple chunks](https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-streaming.html).) + **`x-amz-trailer`:** esse cabeçalho indica o nome do cabeçalho final na solicitação. Se existirem somas de verificação finais (em que os AWS SDKs anexam somas de verificação aos corpos de solicitações codificadas), o valor do cabeçalho `x-amz-trailer` inclui o prefixo `x-amz-checksum-` e termina com o nome do algoritmo. No momento, os seguintes valores de `x-amz-trailer` são compatíveis: + `x-amz-checksum-crc32` + `x-amz-checksum-crc32c` + `x-amz-checksum-crc64nvme` + `x-amz-checksum-sha1` + `x-amz-checksum-sha256` **nota** Você também pode incluir o cabeçalho `Content-Encoding`, com o valor fragmentado, na solicitação. Embora esse cabeçalho não seja obrigatório, incluí-lo pode minimizar os problemas de proxy HTTP ao transmitir dados codificados. Se outro cabeçalho `Content-Encoding` (como gzip) existir na solicitação, o cabeçalho `Content-Encoding` incluirá o valor fragmentado em uma lista de codificações separadas por vírgulas. Por exemplo, `Content-Encoding: aws-chunked, gzip`. ### Partes fragmentadas Quando você faz upload de um objeto para o Amazon S3 usando codificação fragmentada, a solicitação de upload inclui os seguintes tipos de fragmentos (formatados na ordem listada): + **Fragmentos de corpo de objeto:** pode haver um, vários ou nenhum fragmento de corpo associado a uma solicitação de upload fragmentado. + **Fragmentos de conclusão:** pode haver um, vários ou nenhum fragmento de corpo associado a uma solicitação de upload fragmentado. + **Fragmentos finais:** a soma de verificação final é listada após o fragmento de conclusão. Só é permitido um fragmento final. **nota** Cada upload fragmentado deve terminar com um CRLF final (como `\r\n`) para indicar o fim da solicitação. Para conferir exemplos de formatação fragmentada, consulte [Exemplos: uploads fragmentados com somas de verificação finais](#example-chunked-uploads-trailing). #### Fragmentos de corpo de objeto Os fragmentos de corpo de objeto são os fragmentos que contêm os dados reais do objeto que estão sendo carregados no S3. Esses fragmentos têm restrições consistentes de tamanho e formato. ##### Tamanho do fragmento de corpo de objeto Esses fragmentos devem conter pelo menos 8.192 bytes (ou 8 KiB) de dados do objeto, exceto o fragmento final do corpo, que pode ser menor. Não há um tamanho máximo explícito para os fragmentos, mas todos serão menores do que o tamanho máximo de upload de 5 GB. Os tamanhos dos fragmentos podem variar de um para o outro com base na implementação do servidor cliente. ##### Formato do fragmento de corpo de objeto Os fragmentos de corpo de objeto começam com a codificação hexadecimal do número de bytes no fragmento de corpo de objeto, seguidos por um CRLF (Carriage Return Line Feed), os bytes do objeto desse fragmento e outro CRLF. Por exemplo: ``` hex-encoding-of-object-bytes-in-chunk\r\n chunk-object-bytes\r\n ``` No entanto, quando o fragmento é assinado, o fragmento de corpo de objeto segue um formato diferente, em que a assinatura é anexada ao tamanho do fragmento com um delimitador de ponto e vírgula. Por exemplo: ``` hex-encoding-of-object-bytes-in-chunk;chunk-signature\r\n chunk-object-bytes\r\n ``` Para ter mais informações sobre a assinatura de fragmentos, consulte [Signature calculations for the Authorization Header: Transferring a payload in multiple chunks (AWS Signature Version 4)](https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-streaming.html). Para ter mais informações sobre a formatação de fragmentos, consulte [Chunked transfer encoding](https://www.rfc-editor.org/rfc/rfc9112#name-chunked-transfer-coding) no site do *RFC Editor*. #### Fragmentos de conclusão É necessário que os fragmentos de conclusão sejam o último fragmento de corpo de objeto de cada upload fragmentado. O formato de um fragmento de conclusão é semelhante ao de um fragmento de corpo, mas sempre contém zero byte de dados do objeto. (O valor de zero byte de dados do objeto indica que todos os dados foram carregados.) Os uploads fragmentados devem incluir um fragmento de conclusão como último fragmento de corpo de objeto, seguindo um formato como este: ``` 0\r\n ``` No entanto, se a solicitação de codificação de conteúdo usar assinatura de carga útil, o formato será o seguinte: ``` 0;chunk-signature\r\n ``` #### Fragmentos finalizadores Os fragmentos finalizadores contêm a soma de verificação calculada para todas as solicitações de upload do S3. Os fragmentos finalizadores incluem dois campos: um campo de nome de cabeçalho e um campo de valor de cabeçalho. O campo de nome de cabeçalho de uma solicitação de upload deve corresponder ao valor enviado no cabeçalho da solicitação `x-amz-trailer`. Por exemplo, se uma solicitação contiver `x-amz-trailer: x-amz-checksum-crc32` e o fragmento finalizador tiver o nome de cabeçalho `x-amz-checksum-sha1`, a solicitação falhará. O campo de valor no fragmento finalizador inclui uma codificação base64 do valor de soma de verificação big-endian desse objeto. (A ordenação big-endian armazena o byte de dados mais significativo no endereço de memória mais baixo e o byte menos significativo no maior endereço de memória.) O algoritmo usado para calcular essa soma de verificação é o mesmo que o sufixo do nome de cabeçalho (por exemplo, `crc32`). ##### Formato do fragmento finalizador Os fragmentos finalizadores usam o seguinte formato para solicitações de carga útil não assinadas: ``` x-amz-checksum-lowercase-checksum-algorithm-name:base64-checksum-value\n\r\n\r\n ``` Para solicitações com [cargas úteis assinadas com SigV4](https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-streaming-trailers.html), o fragmento finalizador inclui uma assinatura finalizadora após o fragmento. ``` trailer-checksum\n\r\n trailer-signature\r\n ``` Você também pode adicionar o CRLF diretamente ao final do valor de soma de verificação base64. Por exemplo: ``` x-amz-checksum-lowercase-checksum-algorithm-name:base64-checksum-value\r\n\r\n ``` #### Exemplos: uploads fragmentados com somas de verificação finais O Amazon S3 oferece suporte a uploads fragmentados que usam codificação de conteúdo `aws-chunked` para solicitações `PutObject` e `UploadPart` com somas de verificação finais. **Example 1: solicitação `PutObject` fragmentada não assinada com uma soma de verificação final CRC-32** Veja a seguir um exemplo de uma solicitação `PutObject` fragmentada com uma soma de verificação final CRC-32. Nesse exemplo, o cliente faz upload de um objeto de 17 KB em três fragmentos não assinados e acrescenta um fragmento de soma de verificação final CRC-32 usando o cabeçalho `x-amz-checksum-crc32`. ``` PUT /Key+ HTTP/1.1 Host: amzn-s3-demo-bucket Content-Encoding: aws-chunked x-amz-decoded-content-length: 17408 x-amz-content-sha256: STREAMING-UNSIGNED-PAYLOAD-TRAILER x-amz-trailer: x-amz-checksum-crc32 2000\r\n // Object body chunk 1 (8192 bytes) object-bytes\r\n 2000\r\n // Object body chunk 2 (8192 bytes) object-bytes\r\n 400\r\n // Object body chunk 3 (1024 bytes) object-bytes\r\n 0\r\n // Completion chunk x-amz-checksum-crc32:YABb/g==\n\r\n\r\n // Trailer chunk (note optional \n character) \r\n // CRLF ``` Veja aqui um exemplo de resposta: ``` HTTP/1.1 200 ETag: ETag x-amz-checksum-crc32: YABb/g== ``` **nota** O uso da quebra de linha `\n` no final do valor da soma de verificação pode variar entre os clientes. **Example 2: solicitação `PutObject` fragmentada assinada com SigV4 com uma soma de verificação final CRC-32 (`CRC32`)** Veja a seguir um exemplo de uma solicitação `PutObject` fragmentada com uma soma de verificação final CRC-32. Essa solicitação usa a assinatura de carga útil SigV4. Nesse exemplo, o cliente faz upload de um objeto de 17 KB em três fragmentos assinados. Além dos fragmentos `object body`, o `completion chunk` e o `trailer chunk` também são assinados. ``` PUT /Key+ HTTP/1.1 Host: amzn-s3-demo-bucket.s3.amazonaws.com Content-Encoding: aws-chunked x-amz-decoded-content-length: 17408 x-amz-content-sha256: STREAMING-AWS4-HMAC-SHA256-PAYLOAD-TRAILER x-amz-trailer: x-amz-checksum-crc32 authorization-code // SigV4 headers authorization 2000;chunk-signature=signature-value...\r\n // Object body chunk 1 (8192 bytes) object-bytes\r\n 2000;chunk-signature\r\n // Object body chunk 2 (8192 bytes) object-bytes\r\n 400;chunk-signature\r\n // Object body chunk 3 (1024 bytes) object-bytes\r\n 0;chunk-signature\r\n // Completion chunk x-amz-checksum-crc32:YABb/g==\n\r\n // Trailer chunk (note optional \n character) trailer-signature\r\n \r\n // CRLF ``` Veja aqui um exemplo de resposta: ``` HTTP/1.1 200 ETag: ETag x-amz-checksum-crc32: YABb/g== ``` # Verificar a integridade do objeto para dados em repouso no Amazon S3 Se você precisar verificar o conteúdo dos conjuntos de dados armazenados no Amazon S3, a operação [Calcular soma de verificação](https://docs.aws.amazon.com//AmazonS3/latest/userguide/batch-ops-compute-checksums.html) do recurso Operações em Lote do S3 calcula somas de verificação de objeto completo ou compostas para objetos em repouso. A operação **Calcular soma de verificação** usa o recurso Operações em Lote para calcular de forma assíncrona os valores de soma de verificação para um grupo de objetos e gera automaticamente um relatório de integridade consolidado, sem criar cópias de seus dados nem restaurar ou baixar nenhum dado. Com a operação **Calcular soma de verificação**, você pode verificar com eficiência bilhões de objetos em uma única solicitação de trabalho. Para cada solicitação de trabalho de **Cálculo de soma de verificação**, o S3 calcula os valores da soma de verificação e os inclui em um relatório de integridade gerado automaticamente (também conhecido como relatório de conclusão). Em seguida, você pode usar o relatório de conclusão para validar a integridade do conjunto de dados. A operação **Calcular soma de verificação** funciona com qualquer objeto armazenado no S3, independentemente da classe de armazenamento ou do tamanho do objeto. Se for preciso verificar seus objetos como uma prática recomendada de preservação de dados ou atender aos requisitos de conformidade, a operação **Calcular soma de verificação** pode reduzir o custo, o tempo e o esforço necessários para validação de dados realizando cálculos de soma de verificação em repouso. Para ter informações sobre os preços da operação **Calcular soma de verificação**, consulte a guia **Gerenciamento e insights** em [Definição de preço do Amazon S3](https://aws.amazon.com/s3/pricing/). Em seguida, será possível usar a saída do relatório de conclusão gerado para comparar com os valores da soma de verificação que você armazenou em seus bancos de dados e verificar se os conjuntos de dados permanecem intactos ao longo do tempo. Essa abordagem ajuda você a manter a integridade completa dos dados para atender a necessidades comerciais e de conformidade. Por exemplo, você pode usar a operação **Calcular soma de verificação** para enviar uma lista de objetos armazenados nas classes de armazenamento S3 Glacier para auditorias anuais de segurança. Além disso, a variedade de algoritmos de soma de verificação compatíveis permite que você mantenha a continuidade com os algoritmos usados em suas aplicações. ## Usar algoritmos de soma de verificação compatíveis Para dados em repouso, é possível calcular somas de verificação usando qualquer um dos algoritmos de soma de verificação compatíveis: + CRC-64/NVME (`CRC64NVME`): compatível somente com o tipo de soma de verificação de objeto completo. + CRC-32 (`CRC32`): compatível com os tipos de soma de verificação de objeto completo e composta. + CRC-32C (`CRC32C`): compatível com os tipos de soma de verificação de objeto completo e composta. + SHA-1 (`SHA1`): compatível com os tipos de soma de verificação de objeto completo e composta. + SHA-256 (`SHA256`): compatível com os tipos de soma de verificação de objeto completo e composta. + MD5 (`MD5`): compatível com os tipos de soma de verificação de objeto completo e composta. ## Usar a operação **Calcular soma de verificação** Para objetos armazenados no Amazon S3, é possível usar a operação **Calcular soma de verificação** com o recurso Operações em Lote do S3 para verificar o conteúdo dos dados armazenados em repouso. Você pode [criar um trabalho Compute checksum no recurso Operações em Lote](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-create-job.html) usando o console do Amazon S3, a AWS Command Line Interface (AWS CLI), a API REST ou o SDK da AWS. Quando o trabalho de **cálculo de soma de verificação** termina, você recebe um relatório de conclusão. Para ter mais informações sobre como usar o relatório de conclusão, consulte [Monitoramento de relatórios de status e conclusão](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-job-status.html). Antes de criar seu trabalho de **cálculo de soma de verificação**, você deve criar um perfil do AWS Identity and Access Management (IAM) para o recurso Operações em Lote do S3 a fim de conceder permissões ao Amazon S3 para realizar ações em seu nome. Você precisará conceder permissões para ler o arquivo de manifesto e gravar um relatório de conclusão no bucket do S3. Para obter mais informações, consulte [Calcular somas de verificação](batch-ops-compute-checksums.md). ### Usar o console do S3 **Como usar a operação **Calcular soma de verificação**** 1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/). 1. Na barra de navegação na parte superior da página, escolha o nome da Região da AWS exibida no momento. Em seguida, escolha a região onde você deseja criar o trabalho. **nota** Para operações de cópia, você deve criar o trabalho na mesma região que o bucket de destino. Para todas as outras operações, você deve criar o trabalho na mesma região que os objetos arquivados no manifesto. 1. Selecione **Operações em lotes** no painel de navegação do console do Amazon S3. 1. Escolha **Criar trabalho**. 1. Visualize a Região da AWS onde você deseja criar o trabalho. **nota** Para operações de cópia, você deve criar o trabalho na mesma região que o bucket de destino. Para todas as outras operações, você deve criar o trabalho na mesma região que os objetos arquivados no manifesto. 1. Em **Formato do manifesto**, escolha o tipo de objeto do manifesto a ser usado. + Se você escolher **Relatório de inventário do S3 (manifest.json)**, insira o caminho para o objeto `manifest.json` e (opcionalmente) o **ID da versão do objeto de manifesto** se quiser usar uma versão específica do objeto. Outra opção é escolher **Procurar no S3** e escolher o arquivo JSON do manifesto, que preenche automaticamente todas as entradas do campo de objeto do manifesto. + Se você escolher **CSV**, selecione o tipo de localização do manifesto e, em seguida, insira o caminho para um objeto do manifesto formatado em CSV ou escolha **Procurar no S3** para selecionar um objeto de manifesto. O objeto do manifesto deve seguir o formato descrito no console. Se você quiser usar uma versão específica de objeto de manifesto, também poderá especificar o ID da versão do objeto. + Se você escolher **Criar manifesto usando a configuração da Replicação do S3**, uma lista de objetos será gerada usando a configuração de replicação e, opcionalmente, salva no destino escolhido. Ao usar uma configuração de replicação para gerar o manifesto, a única operação disponível é **Replicar**. 1. Escolha **Próximo**. 1. Em **Operação**, escolha a operação **Calcular soma de verificação** para calcular as somas de verificação em todos os objetos listados no manifesto. Escolha o **Tipo de soma de verificação** e a **Função de soma de verificação** para seu trabalho. Em seguida, escolha **Próximo**. 1. Preencha as informações em **Configurar opções adicionais** e selecione **Próximo**. 1. Na página **Configurar opções adicionais**, preencha as informações do seu trabalho de **cálculo de soma de verificação**. **nota** Em **Relatório de conclusão**, confirme a declaração de reconhecimento. Essa declaração de reconhecimento confirma que você entende que o relatório de conclusão contém valores de soma de verificação, os quais são usados para verificar a integridade dos dados armazenados no Amazon S3. Portanto, o relatório de conclusão deve ser compartilhado com cautela. Além disso, lembre-se de que, se você estiver criando uma solicitação de cálculo de soma de verificação e especificar uma localização de bucket de um proprietário de conta externa para armazenar seu relatório de conclusão, será necessário especificar o ID da Conta da AWS do proprietário do bucket externo. 1. Escolha **Próximo**. 1. Na página **Revisar**, analise e confirme suas configurações. 1. (Opcional) Se você precisar fazer alterações, escolha **Anterior** para voltar à página anterior ou selecione **Editar** para atualizar uma etapa específica. 1. Depois de confirmar suas alterações, escolha **Criar trabalho**. **Como listar e monitorar o andamento de todas as solicitações de **cálculo de soma de verificação**** 1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/). 1. No painel de navegação esquerdo, escolha **Batch Operations** (Operações em lote). 1. Na página **Operações em lotes**, é possível analisar os detalhes do trabalho, como prioridade, taxa de conclusão e total de objetos. 1. Se você quiser gerenciar ou clonar um trabalho específico de **cálculo de soma de verificação**, clique em **ID do trabalho** para analisar informações adicionais do trabalho. 1. Na página específica do trabalho de **cálculo de soma de verificação**, analise os respectivos detalhes. Cada trabalho de operações em lote passa por diferentes [status de trabalho](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-job-status.html#batch-ops-job-status-table). Você também pode [habilitar eventos do AWS CloudTrail](https://docs.aws.amazon.com/AmazonS3/latest/userguide/enable-cloudtrail-logging-for-s3.html) no console do S3 para receber alertas sobre qualquer alteração no estado do trabalho. Para trabalhos ativos, é possível analisar o trabalho em execução e a taxa de conclusão na página **Detalhes do trabalho**. ### Usar SDKs da AWS ------ #### [ Java ] **Example Exemplo: criar um trabalho de **cálculo de soma de verificação**** O seguinte exemplo mostra como criar um trabalho de **cálculo de soma de verificação** (como parte de uma solicitação **Create job**) e como especificar um 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 Exemplo: visualizar detalhes do trabalho de **cálculo de soma de verificação**** O seguinte exemplo mostra como você pode especificar um ID de trabalho para visualizar os detalhes do trabalho (como a taxa de conclusão) de uma solicitação de trabalho de **cálculo de soma de verificação**: ``` DescribeJobRequest request = DescribeJobRequest.builder() .accountId("1234567890") .jobId("a16217a1-e082-48e5-b04f-31fac3a66b13") .build(); ``` ------ ### Como usar a AWS CLI Você pode usar o 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) para criar um trabalho de operações em lote e fornecer a lista de objetos. Em seguida, especifique o algoritmo e o tipo de soma de verificação, bem como o bucket de destino em que você deseja salvar o relatório de **cálculo de soma de verificação**. O exemplo a seguir cria um trabalho de **cálculo de soma de verificação** do recurso Operações em Lote do S3 usando um manifesto gerado pelo S3 para a Conta da AWS *111122223333*. Para usar esse comando, substitua os *espaços reservados para entrada do usuário* por suas próprias informações: ``` 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 ``` Depois de enviar o trabalho de **cálculo de soma de verificação**, você recebe o ID do trabalho como resposta e ele aparece na página de listagem do recurso Operações em Lote do S3. O Amazon S3 processa a lista de objetos e calcula somas de verificação para cada objeto. Após a conclusão do trabalho, o S3 fornece um relatório consolidado de **cálculo de soma de verificação** no destino especificado. Para monitorar o andamento do seu trabalho de **cálculo de soma de verificação**, use o 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). Esse comando verifica o status do trabalho de operações em lote especificado. Para usar esse comando, substitua os *espaços reservados para entrada do usuário* por suas próprias informações. Por exemplo: ``` aws s3control describe-job --account-id 111122223333 --job-id 1234567890abcdef0 ``` Para [obter uma lista](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-list-jobs.html) de todos os trabalhos de operações em lote **Ativos** e **Concluídos**, consulte [Listing jobs](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-list-jobs.html) ou [list-jobs](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3control/list-jobs.html) na *Referência de comandos da AWS CLI*. ### Uso da API REST Você pode enviar solicitações REST para verificar a integridade do objeto com o **cálculo de soma de verificação** usando [CreateJob](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_CreateJob.html). Você pode monitorar o andamento das solicitações de **cálculo de soma de verificação** enviando solicitações REST à operação de API [DescribeJob](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_DescribeJob.html). Cada trabalho de operações em lote passa pelos seguintes status: + **NOVO** + **PREPARANDO** + **PRONTO** + **ATIVO** + **PAUSANDO** + **PAUSADO** + **CONCLUÍDO** + **CANCELANDO** + **COM FALHA** A resposta da API notifica você sobre o estado atual do trabalho.