Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Signaturberechnungen für nachfolgende Header (aufgeteilte Uploads) (AWS Signatur (Version 4)
Wenn Sie Anfragen mithilfe des `Authorization` Headers authentifizieren, können Sie die Nutzlast auch in Blöcken hochladen. Wenn Sie die Daten für das Objekt in Blöcken senden, haben Sie auch die Möglichkeit, nachfolgende Header einzufügen. (Weitere Informationen finden Sie unter [Signaturberechnungen für den Autorisierungs-Header: Übertragung von Nutzdaten in mehreren Blöcken (Chunked Upload) (AWS Signatur (Version 4)](sigv4-streaming.md).) In diesem Abschnitt werden die Schritte beschrieben, die Sie ausführen müssen, wenn Sie am Ende Ihres Uploads mit mehreren Blöcken einen abschließenden Header einfügen möchten.
**Wichtig**
Wenn Sie nachfolgende Header hinzufügen, müssen Sie in Ihrem ersten Header Folgendes angeben:
Sie `x-amz-content-sha256` müssen einen geeigneten Wert angeben, der angibt, dass ein Trailer aufgenommen wird. Die akzeptablen Werte für `x-amz-content-sha256` finden Sie unter[Authentifizieren von Anfragen: Verwenden des Autorisierungs-Headers (AWS Signatur (Version 4)](sigv4-auth-using-authorization-header.md).
Sie `x-amz-trailer` müssen festlegen, dass der Inhalt angegeben wird, den Sie in Ihre nachfolgende Kopfzeile aufnehmen.
Nachstehende Header werden erst gesendet, nachdem die Chunks hochgeladen wurden. Frühere Chunks werden wie gewohnt gesendet und signiert, wie in den vorherigen Abschnitten beschrieben, einschließlich des Sendens des letzten Chunks mit einer Nutzlast von 0 Byte. Die nachfolgenden Header werden als eigener Chunk aufgenommen und nach dem letzten Chunk mit einer Nutzlast von 0 Byte gesendet. Wenn Ihre Daten beispielsweise mit einem 100-KB-Block enden, würden Sie Folgendes senden:
+ Frühere Datenblöcke
+ 100 KB letzter Block des Objekts
+ Ein Block von 0 Byte, der das Ende des Objekts angibt
+ Block mit nachfolgenden Headern
## Beispiele: Überprüfung der Signaturberechnungen
Sie können die Beispiele in diesem Abschnitt als Referenz verwenden, um die Signaturberechnungen in Ihrem Code zu überprüfen. Bevor Sie sich die Beispiele ansehen, beachten Sie Folgendes:
+ Bei den Signaturberechnungen in diesen Beispielen werden die folgenden Beispiel-Sicherheitsanmeldeinformationen verwendet.
Parameter
Wert
AWSAccessKeyId
AKIAIOSFODNN7EXAMPLE
AWSSecretAccessKey
wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
+ Alle Beispiele verwenden den Anforderungszeitstempel 20130524T000000Z (). `Fri, 24 May 2013 00:00:00 GMT`
+ Alle Beispiele werden als Bucket-Namen verwendet. `examplebucket`
+ Es wird davon ausgegangen, dass sich der Bucket in der Region USA Ost (Nord-Virginia) befindet, und die Anmeldeinformationen `Scope` und die `Signing Key` Berechnungen werden `us-east-1` als Regionsspezifizierer verwendet. Weitere Informationen finden Sie unter [Regionen und Endpunkte](https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region) in der *Allgemeinen Amazon Web Services-Referenz*.
+ Sie können Anfragen im Pfadstil oder im virtuell gehosteten Stil verwenden. In den folgenden Beispielen werden beispielsweise Anfragen im virtuell gehosteten Stil verwendet:
```
https://examplebucket.s3.amazonaws.com/photos/photo1.jpg
```
Weitere Informationen finden Sie unter [ Virtuelles Hosting von Buckets ](https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html) im * Amazon Simple Storage Service-Benutzerhandbuch. *
Das folgende Beispiel sendet eine `PUT` Anfrage zum Hochladen eines Objekts. Bei den Signaturberechnungen wird Folgendes vorausgesetzt:
+ Sie laden eine 65-KB-Textdatei hoch, und der Dateiinhalt ist eine einstellige Zeichenfolge, die aus dem Buchstaben 'a' besteht.
+ Die Chunk-Größe beträgt 64 KB. Infolgedessen wird die Nutzlast in drei Blöcken hochgeladen: 64 KB, 1 KB und der letzte Block mit 0 Byte an Chunk-Daten.
+ Das resultierende Objekt hat den Schlüsselnamen. `chunkObject.txt`
+ Sie fordern `REDUCED_REDUNDANCY` als Speicherklasse an, indem Sie den `x-amz-storage-class` Anforderungsheader hinzufügen.
+ Die Übertragung enthält einen CRC32C-Prüfsummenwert als abschließenden Header.
Hinweise zur API-Aktion finden Sie unter. [ PutObject ](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) Die allgemeine Anforderungssyntax lautet wie folgt:
```
PUT /examplebucket/chunkObject.txt HTTP/1.1
Host: s3.amazonaws.com
x-amz-date: 20130524T000000Z
x-amz-storage-class: REDUCED_REDUNDANCY
Authorization: {{SignatureToBeCalculated}}
x-amz-content-sha256: STREAMING-AWS4-HMAC-SHA256-PAYLOAD-TRAILER
Content-Encoding: aws-chunked
x-amz-decoded-content-length: 66560
x-amz-trailer: x-amz-checksum-crc32c
Content-Length: 66946
{{}}
```
Die folgenden Schritte zeigen Signaturberechnungen.
1.
**Seed-Signatur — Erstellen Sie eine zu signierende Zeichenfolge**
1.
**CanonicalRequest**
```
PUT
/examplebucket/chunkObject.txt
content-encoding:aws-chunked
host:s3.amazonaws.com
x-amz-content-sha256:STREAMING-AWS4-HMAC-SHA256-PAYLOAD-TRAILER
x-amz-date:20130524T000000Z
x-amz-decoded-content-length:66560
x-amz-storage-class:REDUCED_REDUNDANCY
x-amz-trailer:x-amz-checksum-crc32c
content-encoding;host;x-amz-content-sha256;x-amz-date;x-amz-decoded-content-length;x-amz-storage-class;x-amz-trailer
STREAMING-AWS4-HMAC-SHA256-PAYLOAD-TRAILER
```
In der kanonischen Anfrage ist die dritte Zeile leer, da die Anfrage keine Abfrageparameter enthält. Die letzte Zeile ist die konstante Zeichenfolge, die als Wert der Hash-Nutzlast bereitgestellt wird. Diese sollte dem Wert von entsprechen. `x-amz-content-sha256 header`
1.
**StringToSign**
```
AWS4-HMAC-SHA256
20130524T000000Z
20130524/us-east-1/s3/aws4_request
44d48b8c2f70eae815a0198cc73d7a546a73a93359c070abbaa5e6c7de112559
```
**Anmerkung**
Informationen zu den einzelnen Zeilen in der zu signierenden Zeichenfolge finden Sie in dem Diagramm, das die Berechnung der Startsignatur erklärt.
1.
**SigningKey**
```
signing key = HMAC-SHA256(HMAC-SHA256(HMAC-SHA256(HMAC-SHA256("AWS4" + "{{}}","20130524"),"us-east-1"),"s3"),"aws4_request")
```
1.
**Seed-Signatur**
```
106e2a8a18243abcf37539882f36619c00e2dfc72633413f02d3b74544bfeb8e
```
1.
**Authorization-Header**
Der resultierende Authorization-Header lautet wie folgt:
```
AWS4-HMAC-SHA256 Credential=AKIAIOSFODNN7EXAMPLE/20130524/us-east-1/s3/aws4_request,SignedHeaders=content-encoding;content-length;host;x-amz-content-sha256;x-amz-date;x-amz-decoded-content-length;x-amz-storage-class,Signature=106e2a8a18243abcf37539882f36619c00e2dfc72633413f02d3b74544bfeb8e
```
1.
**Block 1: (65536 Byte, mit dem Wert 97 für den Buchstaben 'a')**
1. Zu signierende Chunk-Zeichenfolge:
```
AWS4-HMAC-SHA256-PAYLOAD
20130524T000000Z
20130524/us-east-1/s3/aws4_request
106e2a8a18243abcf37539882f36619c00e2dfc72633413f02d3b74544bfeb8e
e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
bf718b6f653bebc184e1479f1935b8da974d701b893afcf49e701f3e2f9f9c5a
```
**Anmerkung**
Informationen zu jeder Zeile in der zu signierenden Zeichenfolge finden Sie im Diagramm im vorherigen Thema ([Berechnung der Seed-Signatur](sigv4-streaming.md#sigv4-chunked-upload-sig-calculation-chunk0)), das verschiedene Komponenten der zu signierenden Zeichenfolge zeigt. Die letzten drei Zeilen bestehen beispielsweise aus den folgenden Elementen:
{{previous-signature}}
`hash("")`
`hash({{current-chunk-data}})`
1. Chunk-Signatur:
```
b474d8862b1487a5145d686f57f013e54db672cee1c953b3010fb58501ef5aa2
```
1. Gesendete Chunk-Daten:
```
10000;chunk-signature=b474d8862b1487a5145d686f57f013e54db672cee1c953b3010fb58501ef5aa2
<65536-bytes>
```
1.
**Block 2: (1024 Byte, mit dem Wert 97 für den Buchstaben 'a')**
1. Zu signierende Chunk-Zeichenfolge:
```
AWS4-HMAC-SHA256-PAYLOAD
20130524T000000Z
20130524/us-east-1/s3/aws4_request
b474d8862b1487a5145d686f57f013e54db672cee1c953b3010fb58501ef5aa2
e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
2edc986847e209b4016e141a6dc8716d3207350f416969382d431539bf292e4a
```
1. Chunk-Signatur:
```
1c1344b170168f8e65b41376b44b20fe354e373826ccbbe2c1d40a8cae51e5c7
```
1. Gesendete Chunk-Daten:
```
400;chunk-signature=1c1344b170168f8e65b41376b44b20fe354e373826ccbbe2c1d40a8cae51e5c7
<1024-bytes>
```
1.
**Block 3: (0-Byte-Daten)**
1. Zu signierende Chunk-Zeichenfolge:
```
AWS4-HMAC-SHA256-PAYLOAD
20130524T000000Z
20130524/us-east-1/s3/aws4_request
1c1344b170168f8e65b41376b44b20fe354e373826ccbbe2c1d40a8cae51e5c7
e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
```
1. Chunk-Signatur:
```
2ca2aba2005185cf7159c6277faf83795951dd77a3a99e6e65d5c9f85863f992
```
1. Gesendete Chunk-Daten:
```
0;chunk-signature=2ca2aba2005185cf7159c6277faf83795951dd77a3a99e6e65d5c9f85863f992
```
1.
**Abschnitt 4: Nachfolgende Header**
1. Zu signierende Trailer-Chunk-Zeichenfolge:
```
AWS4-HMAC-SHA256-TRAILER
20130524T000000Z
20130524/us-east-1/s3/aws4_request
2ca2aba2005185cf7159c6277faf83795951dd77a3a99e6e65d5c9f85863f992
1e376db7e1a34a8ef1c4bcee131a2d60a1cb62503747488624e10995f448d774
```
**Anmerkung**
Die letzten beiden Zeilen sind `previous-signature` (die 0-Byte-Datenblock-Signatur), `hash` ({{trailing-checksum-header-name}}: {{base64-encoded-trailing-checksum-value}}\\n).
Der Hash wird wie folgt ohne Leerzeichen berechnet:
Der Name des Headers der nachfolgenden Prüfsumme
Ein Doppelpunkt () `:`
Der Base64-kodierte abschließende Prüfsummenwert
Ein Zeichen für den Zeilenumbruch (). `\n`
In diesem Beispiel, in dem Sie den `crc32c` Hash-Algorithmus mit dem Base64-kodierten Prüfsummenwert verwenden`sOO8/Q==`, können Sie die Berechnung wie folgt darstellen:. `hash('x-amz-checksum-crc32c:sOO8/Q==\n')`
1. Blocksignatur:
```
d81f82fc3505edab99d459891051a732e8730629a2e4a59689829ca17fe2e435
```
1. Gesendete Chunk-Daten:
```
x-amz-checksum-crc32c:sOO8/Q==
x-amz-trailer-signature:d81f82fc3505edab99d459891051a732e8730629a2e4a59689829ca17fe2e435
```