Überprüfung der Objektintegrität

Amazon S3 verwendet Prüfsummenwerte, um die Integrität von Daten zu verifizieren, die Sie auf Amazon S3 hochladen oder von Amazon S3 herunterladen. Darüber hinaus können Sie anfordern, dass ein weiterer Prüfsummenwert für jedes Objekt berechnet wird, das Sie in Amazon S3 speichern. Sie können einen von mehreren Prüfsummenalgorithmen auswählen, der beim Hochladen oder Kopieren Ihrer Daten verwendet werden soll. Amazon S3 berechnet mit diesem Algorithmus einen zusätzlichen Prüfsummenwert und speichert ihn als Teil der Objektmetadaten. Weitere Informationen zur Verwendung zusätzlicher Prüfsummen zur Überprüfung der Datenintegrität finden Sie im Tutorial: Überprüfen der Integrität von Daten in Amazon S3 mit zusätzlichen Prüfsummen.

Wenn Sie ein Objekt hochladen, können Sie optional eine vorberechnete Prüfsumme als Teil Ihrer Anforderung aufnehmen. Amazon S3 vergleicht die bereitgestellte Prüfsumme mit der Prüfsumme, die mit Ihrem angegebenen Algorithmus berechnet wird. Wenn die beiden Werte nicht übereinstimmen, meldet Amazon S3 einen Fehler.

Verwenden unterstützter Prüfsummenalgorithmen

Amazon S3 bietet Ihnen die Möglichkeit, den Prüfsummenalgorithmus auszuwählen, der zur Validierung Ihrer Daten beim Hoch- oder Herunterladen verwendet wird. Sie können einen der folgenden Algorithmen zur Prüfung der Datenintegrität zwischen Secure Hash Algorithms (SHA) oder Cyclic Redundancy Check (CRC) wählen:

• CRC32

• CRC32C

• SHA-1

• SHA-256

Wenn Sie ein Objekt hochladen, können Sie den Algorithmus angeben, den Sie verwenden möchten:

• Wenn Sie den verwenden AWS Management Console, wählen Sie den Prüfsummenalgorithmus aus, den Sie verwenden möchten. In diesem Fall können Sie den Prüfsummenwert des Objekts optional angeben. Wenn Amazon S3 das Objekt erhält, berechnet es die Prüfsumme mithilfe des von Ihnen angegebenen Algorithmus. Wenn die beiden Prüfsummenwerte nicht übereinstimmen, generiert Amazon S3 einen Fehler.

• Wenn Sie einen verwenden SDK, können Sie den Wert des ChecksumAlgorithm Parameters auf den Algorithmus setzen, den Amazon S3 bei der Berechnung der Prüfsumme verwenden soll. Amazon S3 berechnet den Prüfsummenwert automatisch.

• Wenn Sie den verwenden REST API, verwenden Sie den x-amz-sdk-checksum-algorithm Parameter nicht. Stattdessen verwenden Sie einen der algorithmenspezifischen Header (z. B. x-amz-checksum-crc32).

Weitere Informationen zum Hochladen von Objekten finden Sie unter Objekte hochladen.

Um einen dieser Prüfsummenwerte auf Objekte anzuwenden, die bereits auf Amazon S3 hochgeladen wurden, können Sie das Objekt kopieren. Wenn Sie ein Objekt kopieren, können Sie angeben, ob Sie den vorhandenen oder einen neuen Prüfsummenalgorithmus verwenden möchten. Sie können einen Prüfsummenalgorithmus angeben, wenn Sie eine unterstützte Methode zum Kopieren von Objekten verwenden, einschließlich S3-Batch-Operationen. Weitere Informationen über S3-Batch-Vorgänge finden Sie unter Ausführung umfangreicher Batch-Vorgänge für Amazon S3-Objekte durch..

Wichtig

Wenn Sie einen mehrteiligen Upload mit zusätzlichen Prüfsummen verwenden, müssen die mehrteiligen Teilenummern aufeinander folgende Teilenummern sein. Wenn Sie zusätzliche Prüfsummen verwenden und versuchen, eine mehrteilige Upload-Anfrage mit nicht aufeinanderfolgenden Artikelnummern abzuschließen, generiert Amazon S3 einen Fehler. HTTP 500 Internal Server Error

Nach dem Hochladen von Objekten können Sie den Prüfsummenwert abrufen und mit einem vorberechneten oder zuvor gespeicherten Prüfsummenwert vergleichen, der mit demselben Algorithmus berechnet wurde.

Verwenden der S3-Konsole

Weitere Informationen zur Verwendung der Konsole und zum Angeben von Prüfsummenalgorithmen, die beim Hochladen von Objekten verwendet werden, finden Sie unter Objekte hochladen und unter Tutorial: Überprüfen der Integrität von Daten in Amazon S3 mit zusätzlichen Prüfsummen.

Mit dem AWS SDKs

Das folgende Beispiel zeigt, wie Sie mit dem AWS SDKs eine große Datei mit mehrteiligem Upload hochladen, eine große Datei herunterladen und eine mehrteilige Upload-Datei validieren können, wobei Sie jeweils SHA -256 für die Dateiüberprüfung verwenden.

Java

Beispiel: Eine große Datei mit -256 hochladen, herunterladen und verifizieren SHA

Anweisungen zum Erstellen und Testen eines funktionierenden Beispiels finden Sie unter Erste Schritte im AWS SDK for Java Entwicklerhandbuch.

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

Mit dem REST API

Sie können REST Anfragen zum Hochladen eines Objekts mit einem Prüfsummenwert senden, um die Integrität der Daten mit PutObjectzu überprüfen. Sie können den Prüfsummenwert für Objekte auch mit GetObjectoder abrufen. HeadObject

Mit dem AWS CLI

Sie können eine PUT-Anforderung zum Hochladen eines Objekts von bis zu 5 GB in einem einzigen Vorgang senden. Weitere Informationen finden Sie unter PutObject in der AWS CLI -Befehlszeilenreferenz. Sie können auch get-object und head-object verwenden, um die Prüfsumme eines bereits hochgeladenen Objekts abzurufen und die Integrität der Daten zu überprüfen.

Weitere Informationen finden Sie unter Amazon S3 CLI FAQ im AWS Command Line Interface Benutzerhandbuch.

Inhalte verwenden — MD5 beim Hochladen von Objekten

Eine weitere Möglichkeit, die Integrität Ihres Objekts nach dem Hochladen zu überprüfen, besteht darin, MD5 beim Hochladen eine Zusammenfassung des Objekts bereitzustellen. Wenn Sie den MD5 Digest für Ihr Objekt berechnen, können Sie den Digest mit dem PUT Befehl bereitstellen, indem Sie den Header verwenden. Content-MD5

Nach dem Hochladen des Objekts berechnet Amazon S3 den MD5 Digest des Objekts und vergleicht ihn mit dem von Ihnen angegebenen Wert. Die Anforderung ist nur erfolgreich, wenn die beiden Digests übereinstimmen.

Die Angabe eines MD5 Digest ist nicht erforderlich, Sie können ihn jedoch verwenden, um die Integrität des Objekts im Rahmen des Upload-Vorgangs zu überprüfen.

Verwenden Sie Content- MD5 und the, um hochgeladene ETag Objekte zu verifizieren

Das Entity-Tag (ETag) für ein Objekt steht für eine bestimmte Version dieses Objekts. Beachten Sie, dass das nur Änderungen am Inhalt eines Objekts ETag widerspiegelt, nicht an seinen Metadaten. Wenn sich nur die Metadaten eines Objekts ändern, ETag bleiben die gleichen.

Je nach Objekt kann es sich ETag bei dem Objekt um eine MD5 Zusammenfassung der Objektdaten handeln:

• Wenn ein Objekt durch die CopyObject OperationPutObject,PostObject, oder durch die AWS Management Console, erstellt wird und dieses Objekt auch Klartext oder durch serverseitige Verschlüsselung mit verwalteten Amazon S3 S3-Schlüsseln (SSE-S3) verschlüsselt ist, hat ETag dieses Objekt eine MD5 Zusammenfassung seiner Objektdaten.

• Wenn ein Objekt durch die CopyObject OperationPutObject,PostObject, oder durch die AWS Management Console, erstellt wird und dieses Objekt durch serverseitige Verschlüsselung mit vom Kunden bereitgestellten Schlüsseln (SSE-C) oder serverseitige Verschlüsselung mit AWS Key Management Service (AWS KMS) Schlüsseln (SSE-KMS) verschlüsselt wird, hat dieses Objekt eine, ETag die keine MD5 Zusammenfassung seiner Objektdaten ist.

• Wenn ein Objekt durch die Part Copy Operation Multipart Upload oder erstellt wird, handelt es sich bei dem Objekt unabhängig von der ETag Verschlüsselungsmethode nicht um einen MD5 Digest. Wenn ein Objekt größer als 16 MB ist, wird dieses Objekt als mehrteiliger AWS Management Console Upload hochgeladen oder kopiert, es handelt sich also ETag nicht um einen Digest. MD5

Bei Objekten, bei denen ETag es sich um den Content-MD5 Digest des Objekts handelt, können Sie den ETag Wert des Objekts mit einem berechneten oder zuvor gespeicherten Digest vergleichen. Content-MD5

Verwenden von nachfolgenden Prüfsummen

Wenn Sie Objekte auf Amazon S3 hochladen, können Sie entweder eine vorberechnete Prüfsumme für das Objekt angeben oder eine verwenden, AWS SDK um automatisch abschließende Prüfsummen in Ihrem Namen zu erstellen. Wenn Sie sich für eine nachfolgende Prüfsumme entscheiden, generiert Amazon S3 die Prüfsumme automatisch mithilfe des von Ihnen angegebenen Algorithmus und überprüft damit die Integrität des Objekts während des Uploads.

Um bei der Verwendung von eine eine abschließende Prüfsumme zu erstellen AWS SDK, füllen Sie den Parameter mit Ihrem bevorzugten Algorithmus. ChecksumAlgorithm Der berechnet SDK anhand dieses Algorithmus die Prüfsumme für Ihr Objekt (oder Objektteile) und hängt sie automatisch an das Ende Ihrer Upload-Anfrage an. Dank dieser Funktionsweise sparen Sie Zeit, da Amazon S3 sowohl die Überprüfung als auch das Hochladen Ihrer Daten in einem einzigen Durchgang durchführt.

Wichtig

Wenn Sie S3 Object Lambda verwenden, werden alle Anfragen an S3 Object Lambda mit s3-object-lambda anstelle von s3 signiert. Dieses Verhalten wirkt sich auf die Signatur der nachfolgenden Prüfsummenwerte aus. Weitere Informationen zu S3 Object Lambda finden Sie unter Transformieren von Objekten mit S3 Object Lambda.

Verwenden von Prüfsummen auf Teilebene für mehrteilige Uploads

Wenn Objekte auf Amazon S3 hochgeladen werden, können sie entweder als einzelnes Objekt oder durch den mehrteiligen Upload-Prozess hochgeladen werden. Objekte, die größer als 16 MB sind und über die Konsole hochgeladen werden, werden automatisch mit mehrteiligen Uploads hochgeladen. Weitere Informationen über mehrteilige Uploads finden Sie unter Hochladen und Kopieren von Objekten mit mehrteiligen Uploads.

Wenn ein Objekt als mehrteiliger Upload hochgeladen wird, handelt es sich ETag bei dem Objekt nicht um eine MD5 Zusammenfassung des gesamten Objekts. Amazon S3 berechnet den MD5 Digest jedes einzelnen Teils beim Hochladen. Die MD5 Digests werden verwendet, um den Wert ETag für das endgültige Objekt zu bestimmen. Amazon S3 verkettet die Bytes für die MD5 Digests miteinander und berechnet dann den Digest dieser verketteten MD5 Werte. Der letzte Schritt bei der Erstellung von ETag besteht darin, dass Amazon S3 am Ende einen Bindestrich mit der Gesamtzahl der Teile hinzufügt.

Stellen Sie sich zum Beispiel ein Objekt vor, das mit einem mehrteiligen Upload hochgeladen wurde und den Wert ETag von C9A5A6878D97B48CC965C1E41859F034-14 hat. In diesem Fall C9A5A6878D97B48CC965C1E41859F034 ist der MD5 Digest aller Digests miteinander verkettet. Der Wert -14 gibt an, dass mit dem mehrteiligen Upload dieses Objekts 14 Teile verknüpft sind.

Wenn Sie zusätzliche Prüfsummenwerte für Ihr mehrteiliges Objekt aktiviert haben, berechnet Amazon S3 die Prüfsumme für jeden einzelnen Teil mithilfe des angegebenen Prüfsummenalgorithmus. Die Prüfsumme für das abgeschlossene Objekt wird auf die gleiche Weise berechnet, wie Amazon S3 den MD5 Digest für den mehrteiligen Upload berechnet. Mithilfe dieser Prüfsumme können Sie die Integrität des Objekts überprüfen.

Um Informationen über das Objekt abzurufen, einschließlich der Anzahl der Teile, aus denen das gesamte Objekt besteht, können Sie die Operation verwenden. GetObjectAttributes Mit zusätzlichen Prüfsummen können Sie auch Informationen für jeden einzelnen Teil wiederherstellen, der den Prüfsummenwert jedes Teils enthält.

Bei abgeschlossenen Uploads können Sie die Prüfsumme eines einzelnen Teils abrufen, indem Sie die HeadObjectOperationen GetObjectoder verwenden und eine Bauteilnummer oder einen Bytebereich angeben, der einem einzelnen Teil entspricht. Wenn Sie die Prüfsummenwerte für einzelne Teile von mehrteiligen Uploads abrufen möchten, die noch in Bearbeitung sind, können Sie Folgendes verwenden. ListParts

Aufgrund der Art und Weise, wie Amazon S3 die Prüfsumme für mehrteilige Objekte berechnet, kann sich der Prüfsummenwert für das Objekt ändern, wenn Sie es kopieren. Wenn Sie ein SDK oder das verwenden REST API und Sie aufrufen CopyObject, kopiert Amazon S3 jedes Objekt bis zu den Größenbeschränkungen des CopyObject API Vorgangs. Amazon S3 führt diese Kopie als einzelne Aktion aus, unabhängig davon, ob das Objekt in einer einzigen Anforderung oder im Rahmen eines mehrteiligen Uploads hochgeladen wurde. Mit einem Kopierbefehl ist die Prüfsumme des Objekts eine direkte Prüfsumme des vollständigen Objekts. Wenn das Objekt ursprünglich mit einem mehrteiligen Upload hochgeladen wurde, ändert sich der Prüfsummenwert, auch wenn die Daten unverändert bleiben.

Anmerkung

Objekte, die die Größenbeschränkungen des CopyObject API Vorgangs überschreiten, müssen mehrteilige Kopierbefehle verwenden.

Wichtig

Wenn Sie einige Operationen mit dem ausführen AWS Management Console, verwendet Amazon S3 einen mehrteiligen Upload, wenn das Objekt größer als 16 MB ist. In diesem Fall ist die Prüfsumme keine direkte Prüfsumme des vollständigen Objekts, sondern eine Berechnung, die auf den Prüfsummenwerten jeden einzelnen Teils basiert.

Stellen Sie sich zum Beispiel ein Objekt mit einer Größe von 100 MB vor, das Sie als einteiligen direkten Upload mit dem hochgeladen haben. REST API Die Prüfsumme ist in diesem Fall eine Prüfsumme des gesamten Objekts. Wenn Sie das Objekt später mit der Konsole umbenennen, es kopieren, die Speicherklasse ändern oder die Metadaten bearbeiten, verwendet Amazon S3 die mehrteilige Upload-Funktion, um das Objekt zu aktualisieren. Infolgedessen erstellt Amazon S3 einen neuen Prüfsummenwert für das Objekt, der basierend auf den Prüfsummenwerten der einzelnen Teile berechnet wird.

Die obige Liste der Konsolenoperationen ist keine vollständige Liste aller möglichen Aktionen, die Sie ergreifen können, wenn sie dazu führen AWS Management Console , dass Amazon S3 das Objekt mithilfe der mehrteiligen Upload-Funktion aktualisiert. Beachten Sie, dass der Prüfsummenwert möglicherweise nicht die Prüfsumme des gesamten Objekts ist, wenn Sie die Konsole für Objekte mit einer Größe über 16 MB verwenden.